@antst/dashi 0.1.0-alpha.8 → 0.1.0

package/README.md

@@ -3,10 +3,10 @@
 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:
+Install DSH 0.1.5-rc.2 or newer and start dashi:
 
 ```sh
-pnpm install @deepseek-ai/dsh@0.1.2-rc.1
+pnpm install @deepseek-ai/dsh@0.1.5-rc.2
 dsh plugin --profile dashi add @antst/dashi-app
 dsh --profile dashi
 ```
@@ -15,11 +15,11 @@ 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.
+A DSH profile must use one uniform DSH version. The minimum supported version
+is `0.1.5-rc.2`; CI tests `0.1.5-rc.2`, `0.1.6-alpha.1`, and
+`0.1.6-alpha.2` with exact, reproducible graphs.
 
-Status: pre-release alpha. Interfaces and behavior may change between
-alpha versions; the validated DSH version is `0.1.2-rc.1`.
+Status: pre-release alpha. Interfaces and behavior may change between alpha versions.
 
 Full documentation, source, and issue tracker:
 https://forgejo.antst.net/ai/dashi

package/lib/application.d.ts

@@ -20,12 +20,14 @@ export interface TerminalShellOptions {
     readonly initialHasMore?: boolean;
     readonly initialPrompts?: ViewState['prompts'];
     readonly initialRoot?: ViewState['root'];
+    readonly initialToolMode?: ViewState['toolMode'];
     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 statusLine?: () => string | undefined;
     readonly submit?: (text: string, mode: 'next-turn' | 'steer', attachments: readonly DraftAttachment[]) => Promise<void> | void;
     readonly suspend?: () => Promise<void>;
     readonly writeError?: (message: string) => void;

package/lib/application.js

@@ -16,7 +16,7 @@ function suspendProcess() {
     });
 }
 export function createTerminalShell(options) {
-    let state = initialViewState(options.cwd, options.inline, options.initialRoot, options.initialCells, options.initialPrompts, options.initialHasMore, options.initialAttachments);
+    let state = initialViewState(options.cwd, options.inline, options.initialRoot, options.initialCells, options.initialPrompts, options.initialHasMore, options.initialAttachments, options.initialToolMode);
     let accepting = true;
     let failed = false;
     let queue = Promise.resolve();
@@ -26,7 +26,7 @@ export function createTerminalShell(options) {
         readState: () => state,
     };
     const renderer = options.createView?.(bindings) ?? createRenderer({
-        ...bindings, ...(options.accessible === undefined ? {} : { accessible: options.accessible }), inline: options.inline,
+        ...bindings, ...(options.accessible === undefined ? {} : { accessible: options.accessible }), ...(options.statusLine === undefined ? {} : { statusLine: options.statusLine }), inline: options.inline,
     });
     const guard = createTerminalGuard(renderer);
     const writeError = options.writeError ?? (message => { process.stderr.write(message); });
@@ -107,7 +107,7 @@ export function createTerminalShell(options) {
             case 'exit-timer':
                 if (exitTimer !== undefined)
                     clearTimeout(exitTimer);
-                exitTimer = effect.armed ? setTimeout(() => { dispatch({ type: 'disarm-exit' }); }, 2_000) : undefined;
+                exitTimer = effect.armed ? setTimeout(() => { dispatch({ type: 'disarm-exit' }); }, 1_500) : undefined;
                 return;
             case 'external-edit': {
                 try {
@@ -176,6 +176,7 @@ export function createTerminalShell(options) {
             return;
         failed = true;
         accepting = false;
+        renderer.discardSecretComposer();
         const detail = error instanceof Error ? error.stack ?? error.message : String(error);
         writeError(`dashi: terminal failure\n${detail}\n`);
         try {
@@ -201,6 +202,9 @@ export function createTerminalShell(options) {
     function dispatch(action) {
         if (!accepting)
             return;
+        const question = state.decisions[0]?.kind === 'question' ? state.decisions[0].questions[state.decisions[0].index] : undefined;
+        if (question?.secret === true && ['decision-submit', 'decision-cancel', 'decision-withdrawn', 'escape', 'terminal-lost'].includes(action.type))
+            renderer.discardSecretComposer();
         const [next, effects] = reduce(state, action);
         state = next;
         if (effects.length === 0)
@@ -224,6 +228,7 @@ export function createTerminalShell(options) {
         },
         dispatch,
         async dispose() {
+            renderer.discardSecretComposer();
             const [next, effects] = reduce(state, { type: 'terminal-lost' });
             state = next;
             for (const effect of effects)

package/lib/catalogs.d.ts

@@ -6,16 +6,21 @@ 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 a filtered view of the skills resolved for one live session. */
+export declare function skillOverlay(ctx: Context, agent: Agent, filter: string, signal?: AbortSignal): Promise<Overlay>;
 /** 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;
+export declare function sessionStatusLine(ctx: Context, agent: Agent, root: RootView, repo?: string): string;
 /** 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;
+/** Read DSH's whole-log token and timing projections without folding session history. */
+export declare function usageOverlay(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. */

package/lib/catalogs.js

@@ -1,7 +1,10 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 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 { pluginCompletionQuery, slashCompletionQuery } from './completion-trigger.js';
 import { isImagePath } from './image-input.js';
 import { sessionTitle } from './session-list.js';
 function matchRank(name, query) {
@@ -15,6 +18,24 @@ function selectedModel(ctx, agent) {
 }
 /** Build command and skill completion rows for one exact root. */
 export async function completionOptions(ctx, agent, input, caret = input.length, signal) {
+    const plugin = pluginCompletionQuery(input, caret);
+    if (plugin !== undefined) {
+        let candidates = ['add', 'remove', 'update', 'outdated', 'list', 'why', 'exec', 'licenses'];
+        if (plugin.command !== undefined) {
+            const profile = fileURLToPath(new URL('.', ctx.baseUrl));
+            if (plugin.command === 'exec') {
+                candidates = (await readdir(join(profile, 'node_modules', '.bin')).catch((error) => error.code === 'ENOENT' ? [] : Promise.reject(error))).sort();
+            }
+            else {
+                const manifest = JSON.parse(await readFile(join(profile, 'package.json'), 'utf8'));
+                candidates = Object.keys(manifest.dependencies ?? {}).sort();
+            }
+        }
+        return candidates.filter(name => matchRank(name, plugin.query) < 2).map(name => ({
+            group: 'Commands', label: name,
+            value: { kind: 'insert', text: `/plugin ${plugin.command === undefined ? '' : `${plugin.command} `}${name} ` },
+        }));
+    }
     const at = detectAtTrigger(input, caret);
     if (at !== undefined) {
         const service = ctx.get('fileReferences');
@@ -69,6 +90,23 @@ export async function completionOptions(ctx, agent, input, caret = input.length,
     }));
     return [...commands, ...skills];
 }
+/** Build a filtered view of the skills resolved for one live session. */
+export async function skillOverlay(ctx, agent, filter, signal) {
+    const lookup = { cwd: agent.session.header.cwd, scope: agent, signal };
+    const needle = filter.trim().toLocaleLowerCase();
+    const skills = (await ctx.skills.list(lookup)).filter(skill => needle === ''
+        || skill.name.toLocaleLowerCase().includes(needle)
+        || skill.description.toLocaleLowerCase().includes(needle));
+    const definitions = await Promise.all(skills.map(skill => ctx.skills.get(skill.name, lookup)));
+    return {
+        cursor: 0, kind: 'list', purpose: 'skills', title: needle === '' ? 'Skills' : `Skills · ${filter.trim()}`,
+        options: skills.map((skill, index) => ({
+            detail: `${skill.description} · user ${skill.invocation.userInvocable ? 'yes' : 'no'} · model ${skill.invocation.modelInvocable ? 'yes' : 'no'} · source ${skill.source} · provider ${skill.provider} · path ${definitions[index]?.path ?? 'unavailable'}`,
+            label: `/${skill.name}`,
+            value: { kind: 'insert', text: `/${skill.name} ` },
+        })),
+    };
+}
 /** Build the cold session picker without adopting any candidate. */
 export function sessionOverlay(items, currentId, cwd) {
     return {
@@ -136,6 +174,37 @@ export function permissionOverlay(ctx, agent) {
 function number(value) {
     return typeof value === 'number' ? value.toLocaleString('en-US') : 'unavailable';
 }
+function milliseconds(value) {
+    return typeof value === 'number' ? `${number(value)} ms` : 'unavailable';
+}
+function compactTokens(value) {
+    return Intl.NumberFormat('en-US', { maximumFractionDigits: 1, notation: 'compact' }).format(value).replace('K', 'k');
+}
+export function sessionStatusLine(ctx, agent, root, repo) {
+    const { modelSelection, permissions, tokenUsage, contextPressure } = ctx.sessionProjections
+        .snapshot(agent.session, ['modelSelection', 'permissions', 'tokenUsage', 'contextPressure']).values;
+    const model = modelSelection?.next ?? modelSelection?.lastUsed;
+    const input = tokenUsage === undefined ? 0 : tokenUsage.uncachedInputTokens + tokenUsage.cacheReadTokens + tokenUsage.cacheWriteTokens;
+    const total = input + (tokenUsage?.outputTokens ?? 0);
+    const used = contextPressure?.projectedTokens ?? contextPressure?.pressureTokens;
+    const context = used === undefined ? undefined
+        : contextPressure?.contextWindow === undefined ? `ctx ${compactTokens(used)}`
+            : `ctx ${compactTokens(used)}/${compactTokens(contextPressure.contextWindow)} ${String(Math.min(100, Math.round(used / contextPressure.contextWindow * 100)))}%`;
+    const agents = root.subagents?.filter(item => item.state === 'running').length ?? 0;
+    const jobs = root.jobs?.filter(item => item.status === 'running' || item.status === 'stopping').length ?? 0;
+    return [
+        model?.model ?? root.model,
+        ...(model?.reasoningEffort === undefined ? [] : [model.reasoningEffort]),
+        permissions?.currentValue ?? root.permission ?? 'unknown',
+        ...(context === undefined ? [] : [context]),
+        ...(input === 0 ? [] : [`cache ${String(Math.min(tokenUsage?.cacheReadTokens === input ? 100 : 99, Math.round((tokenUsage?.cacheReadTokens ?? 0) / input * 100)))}%`]),
+        ...(tokenUsage === undefined ? [] : [`${compactTokens(total)} tok`]),
+        ...(agents === 0 ? [] : [`${String(agents)} agents`]),
+        ...(jobs === 0 ? [] : [`${String(jobs)} jobs`]),
+        ...(root.title === undefined ? [] : [root.title]),
+        ...(repo === undefined ? [] : [repo]),
+    ].join(' · ');
+}
 /** Read DSH-owned root facts for /status in one projection cut. */
 export function statusOverlay(ctx, agent, root) {
     const values = ctx.sessionProjections.snapshot(agent.session, [
@@ -179,6 +248,27 @@ export function contextOverlay(ctx, agent) {
         title: 'Context',
     };
 }
+/** Read DSH's whole-log token and timing projections without folding session history. */
+export function usageOverlay(ctx, agent) {
+    const values = ctx.sessionProjections.snapshot(agent.session, ['tokenUsage', 'sessionStats']).values;
+    const tokens = values.tokenUsage;
+    const stats = values.sessionStats;
+    const measured = stats === undefined ? undefined : stats.llmMs + stats.toolMs;
+    return {
+        kind: 'info',
+        lines: [
+            `Input tokens: ${number(tokens?.uncachedInputTokens)}`,
+            `Output tokens: ${number(tokens?.outputTokens)}`,
+            `Cache read: ${number(tokens?.cacheReadTokens)}`,
+            `Cache write: ${number(tokens?.cacheWriteTokens)}`,
+            `Turns: ${number(stats?.turns)} · Steps: ${number(stats?.steps)}`,
+            `Model time: ${milliseconds(stats?.llmMs)}`,
+            `Tool time: ${milliseconds(stats?.toolMs)}`,
+            `Measured wall time: ${milliseconds(measured)}`,
+        ],
+        title: 'Usage',
+    };
+}
 /** 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 => ({

package/lib/completion-trigger.d.ts

@@ -1,2 +1,6 @@
 export declare function slashCompletionQuery(input: string): string | undefined;
+export declare function pluginCompletionQuery(input: string, caret: number): {
+    readonly command?: string;
+    readonly query: string;
+} | undefined;
 export declare function hasCompletionTrigger(input: string, caret: number): boolean;

package/lib/completion-trigger.js

@@ -2,6 +2,18 @@ import { detectAtTrigger } from './at-trigger.js';
 export function slashCompletionQuery(input) {
     return /^\/([a-z0-9_-]*)$/u.exec(input)?.[1];
 }
+export function pluginCompletionQuery(input, caret) {
+    if (caret !== input.length)
+        return undefined;
+    const match = /^\/plugin +([^\s]*)(?: +([^\s]*))?$/u.exec(input);
+    if (match === null)
+        return undefined;
+    const command = match[1] ?? '';
+    if (match[2] === undefined)
+        return { query: command };
+    return /^(?:exec|remove|update|why)$/u.test(command) ? { command, query: match[2] } : undefined;
+}
 export function hasCompletionTrigger(input, caret) {
-    return slashCompletionQuery(input) !== undefined || detectAtTrigger(input, caret) !== undefined;
+    return slashCompletionQuery(input) !== undefined || pluginCompletionQuery(input, caret) !== undefined
+        || detectAtTrigger(input, caret) !== undefined;
 }

package/lib/diff-view.js

@@ -1,16 +1,23 @@
+import { HUMAN_SHELL_STREAM_BYTES } from './shell-command.js';
 import { boundedBody } from './tool-presentation.js';
 import { foldCells } from './transcript.js';
+import { latestCompletedTurn } from './rewind.js';
 export async function diffOverlay(ctx, agent, presenter, mode, signal) {
     if (mode === 'turn') {
         const events = agent.session.snapshotEvents();
-        const start = events.map(event => event.type).lastIndexOf('turn/start');
-        const cells = (start < 0 ? [] : foldCells(events.slice(start), presenter)).filter(cell => cell.pending !== true && cell.tool?.card === 'diff' && (cell.tool.diffs?.length ?? 0) > 0);
-        return { cells, kind: 'info', lines: cells.length === 0 ? ['No write/edit changes in the last turn.'] : [], title: 'Last turn diff' };
+        const boundary = latestCompletedTurn(events);
+        const end = boundary.atSeq === undefined ? -1 : events.findIndex(event => event.seq === boundary.atSeq);
+        let start = end;
+        while (start >= 0 && events[start]?.type !== 'turn/start')
+            start--;
+        const cells = (start < 0 ? [] : foldCells(events.slice(start, end + 1), presenter)).filter(cell => cell.pending !== true && cell.tool?.card === 'diff' && (cell.tool.diffs?.length ?? 0) > 0);
+        return { cells, kind: 'info', lines: cells.length === 0 ? ['No write/edit changes in the last completed turn.'] : [],
+            title: `Last completed turn diff${boundary.open ? ' · trailing turn open' : ''}` };
     }
     const command = 'git diff --no-ext-diff --no-color HEAD --';
     const result = await ctx.shell.run(ctx.shell.resolve({
         command, sandboxPolicy: ctx.sandboxPolicy.resolve({ session: agent.session }), signal,
-        stdoutMaxBytes: 64 * 1024, timeoutMs: 30_000, workdir: agent.session.header.cwd,
+        stdoutMaxBytes: HUMAN_SHELL_STREAM_BYTES, timeoutMs: 30_000, workdir: agent.session.header.cwd,
     }));
     const output = [result.stdout.text, result.stderr.text].filter(Boolean).join('\n');
     const cell = {

package/lib/help.d.ts

@@ -1,2 +1,2 @@
 export declare const VERSION_LINE: string;
-export declare const FLAG_HELP: readonly ["Launch flags: --inline | --fullscreen · --accessible · -r, --resume [NAME|UUID] · -c, --continue · --all · --name TITLE", "  --model ID [--provider ID] · --effort LEVEL · --permission PRESET", "  --yolo | --dangerously-skip-permissions · --image PATH · -h, --help"];
+export declare const FLAG_HELP: readonly ["Launch flags: --inline | --fullscreen · --accessible · --verbose · -r, --resume [NAME|UUID] · -c, --continue · --fork-session · --all", "  -n, --name TITLE · --agent PRESET · --session-id UUID · --model ID [--provider ID] · --effort LEVEL", "  --permission PRESET · --tools NAMES · --disallowedTools NAMES · --yolo | --dangerously-skip-permissions · --image PATH", "  --system-prompt TEXT | --system-prompt-file PATH · --append-system-prompt TEXT | --append-system-prompt-file PATH · -h, --help"];

package/lib/help.js

@@ -2,5 +2,5 @@ import dashi from '../package.json' with { type: 'json' };
 import dsh from '@deepseek-ai/dsh-cmdline/package.json' with { type: 'json' };
 export const VERSION_LINE = `dashi ${dashi.version} on DSH ${dsh.version}`;
 export const FLAG_HELP = [
-    'Launch flags: --inline | --fullscreen · --accessible · -r, --resume [NAME|UUID] · -c, --continue · --all · --name TITLE', '  --model ID [--provider ID] · --effort LEVEL · --permission PRESET', '  --yolo | --dangerously-skip-permissions · --image PATH · -h, --help'
+    'Launch flags: --inline | --fullscreen · --accessible · --verbose · -r, --resume [NAME|UUID] · -c, --continue · --fork-session · --all', '  -n, --name TITLE · --agent PRESET · --session-id UUID · --model ID [--provider ID] · --effort LEVEL', '  --permission PRESET · --tools NAMES · --disallowedTools NAMES · --yolo | --dangerously-skip-permissions · --image PATH', '  --system-prompt TEXT | --system-prompt-file PATH · --append-system-prompt TEXT | --append-system-prompt-file PATH · -h, --help'
 ];

package/lib/history-records.d.ts

@@ -1,4 +1,4 @@
 import type { SessionHistoryRecord } from '@deepseek-ai/dsh-api-session-controller';
-import { type SessionEvent } from '@deepseek-ai/dsh-session';
-/** Expand the Controller's compact history wire records to canonical Session events. */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/** Read the Controller's canonical Session event history. */
 export declare function eventsFromRecords(records: readonly SessionHistoryRecord[]): SessionEvent[];

package/lib/history-records.js

@@ -1,14 +1,4 @@
-import { decodeStorageRecord } from '@deepseek-ai/dsh-session';
-/** Expand the Controller's compact history wire records to canonical Session events. */
+/** Read the Controller's canonical Session event history. */
 export function eventsFromRecords(records) {
-    return records.flatMap((record) => {
-        if (record.type === 'event')
-            return [record.event];
-        const encoded = record.event.type === 'chunkrow/text-chunks'
-            ? { type: 'text-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data }
-            : record.event.type === 'chunkrow/reasoning-chunks'
-                ? { type: 'reasoning-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data }
-                : { type: 'tool-call-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data };
-        return decodeStorageRecord(encoded);
-    });
+    return records.map(record => record.event);
 }

package/lib/index.js

@@ -8,26 +8,32 @@ 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 } from './session-runtime.js';
+import { createSessionRuntime, LaunchArgumentError, } from './session-runtime.js';
 import { TuiRoot } from './tui-root.js';
 export const name = 'dashi';
 export const inject = [
-    'agentPresets', 'agents', 'attachments', 'cmdlineArgs', 'commands', 'fs', 'loader', 'permissionPresets',
-    'pluginInventory', 'sessionController', 'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'settings', 'shell', 'skills', 'tools',
+    'agentPresets', 'agents', 'attachments', 'authorization', 'cmdlineArgs', 'commands', 'credentials', 'fs', 'jobs', 'loader', 'permissionPresets', 'subagents',
+    'pluginInventory', 'sessionController', 'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'settings', 'shell', 'skills', 'systemPrompt', 'tools',
 ];
-const validatedVersions = JSON.parse(readFileSync(new URL('../validated-dsh-versions.json', import.meta.url), 'utf8'));
 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++) {
@@ -38,13 +44,16 @@ function parseArgs(args) {
             inline = true;
         else if (argument === '--fullscreen')
             inline = false;
-        else if (argument === '--name' || argument === '--image' || argument === '--effort'
-            || argument === '--model' || argument === '--permission' || argument === '--provider') {
+        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')
+            if (argument === '--name' || argument === '-n')
                 name = value;
+            else if (argument === '--agent')
+                agentPreset = value;
             else if (argument === '--image')
                 images.push(value);
             else if (argument === '--effort')
@@ -53,6 +62,32 @@ function parseArgs(args) {
                 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;
         }
@@ -69,6 +104,10 @@ function parseArgs(args) {
             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';
         }
@@ -80,12 +119,17 @@ function parseArgs(args) {
     if (resume !== undefined && (resumePicker || useContinue) || resumePicker && useContinue
         || name !== undefined && (resume !== undefined || resumePicker || useContinue)
         || resumeAll && resume === undefined && !resumePicker || resumeAll && useContinue
-        || provider !== undefined && model === undefined)
+        || 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,
-        inline,
+        ...(agentPreset === undefined ? {} : { agentPreset }), forkSession, inline,
         resumeAll,
         resumePicker,
         ...(images.length === 0 ? {} : { images }),
@@ -95,7 +139,10 @@ function parseArgs(args) {
         ...(permission === undefined ? {} : { permission }),
         ...(prompt.length === 0 ? {} : { prompt: prompt.join(' ') }),
         ...(provider === undefined ? {} : { provider }),
-        ...(resume === undefined ? {} : { resume }),
+        ...(tools === undefined ? {} : { tools }),
+        ...(disallowedTools === undefined ? {} : { disallowedTools }),
+        ...(resume === undefined ? {} : { resume }), ...(sessionId === undefined ? {} : { sessionId }),
+        ...(systemPrompt === undefined ? {} : { systemPrompt }), verbose,
     };
 }
 function packageVersion(path) {
@@ -123,9 +170,6 @@ function warnDshVersion() {
     if (baseVersion !== version) {
         process.stderr.write(`dashi: warning: DSH ${version} loads @deepseek-ai/dsh-base ${baseVersion}; versions must match\n`);
     }
-    if (!validatedVersions.includes(version)) {
-        process.stderr.write(`dashi: warning: DSH ${version} is not validated; validated: ${validatedVersions.join(', ')}\n`);
-    }
 }
 function installSessionList(ctx, options, ready, exit) {
     const abort = new AbortController();
@@ -189,6 +233,8 @@ export function apply(ctx) {
     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); },
@@ -242,12 +288,14 @@ export function apply(ctx) {
                     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();
@@ -262,7 +310,7 @@ export function apply(ctx) {
             process.stderr.write(`dashi: startup failed: ${error instanceof Error ? error.message : String(error)}\n`);
             await runtime?.shutdown();
             await shell?.dispose();
-            exit(1);
+            exit(error instanceof LaunchArgumentError ? 2 : 1);
         });
     });
     ctx.effect(() => async () => {

package/lib/input.d.ts

@@ -1,10 +1,17 @@
 import { type TUI } from '@earendil-works/pi-tui';
-import type { ComposerCursor, UiAction, ViewState } from './state.js';
+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

@@ -1,4 +1,38 @@
+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;
@@ -15,6 +49,13 @@ export function installInput(tui, bindings) {
             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 };
         }
@@ -98,6 +139,10 @@ export function installInput(tui, bindings) {
                 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'))

package/lib/renderer.d.ts

@@ -6,12 +6,14 @@ export type CopyResult = 'ok' | 'too-large' | 'unsupported';
 export interface Renderer extends TerminalSession {
     bell(): void;
     copy(text: string): CopyResult;
+    discardSecretComposer(): void;
     materializedCells(): number;
     setComposer(text: string, cursor?: ComposerCursor): void;
 }
 export interface RendererOptions extends InputBindings {
     readonly accessible?: boolean;
     readonly inline: boolean;
+    readonly statusLine?: () => string | undefined;
     readonly terminal?: Terminal;
     readonly terminalType?: string;
 }