@antst/dashi 0.1.0-alpha.10 → 0.1.0-alpha.12

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); });

package/lib/catalogs.d.ts

@@ -14,10 +14,13 @@ export declare function sessionOverlay(items: readonly SessionSummary[], current
 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, branch?: 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

@@ -153,6 +153,23 @@ 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';
+}
+export function sessionStatusLine(ctx, agent, root, branch) {
+    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 used = contextPressure?.projectedTokens ?? contextPressure?.pressureTokens;
+    return [
+        `model ${model == null ? `${root.provider === undefined ? '' : `${root.provider}/`}${root.model}` : `${model.provider}/${model.model}`}`,
+        `permission ${permissions?.currentValue ?? root.permission ?? 'unknown'}`,
+        ...(used === undefined || contextPressure?.contextWindow === undefined ? [] : [`context ${number(used)}/${number(contextPressure.contextWindow)}`]),
+        ...(input === 0 ? [] : [`cache ${String(Math.min(tokenUsage?.cacheReadTokens === input ? 100 : 99, Math.round((tokenUsage?.cacheReadTokens ?? 0) / input * 100)))}%`]),
+        ...(branch === undefined ? [] : [`branch ${branch}`]),
+    ].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, [
@@ -196,6 +213,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/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 · --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 · -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 · --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 · -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/index.js

@@ -13,11 +13,12 @@ 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', 'tools',
+    '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;
@@ -31,7 +32,9 @@ function parseArgs(args) {
     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++) {
@@ -43,6 +46,7 @@ function parseArgs(args) {
         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 === '')
@@ -70,6 +74,21 @@ function parseArgs(args) {
                 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;
         }
@@ -88,6 +107,8 @@ function parseArgs(args) {
             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';
         }
@@ -106,6 +127,8 @@ function parseArgs(args) {
         return undefined;
     return {
         accessible,
+        ...(argumentError === undefined ? {} : { argumentError }),
+        ...(appendSystemPrompt === undefined ? {} : { appendSystemPrompt }),
         continue: useContinue,
         ...(agentPreset === undefined ? {} : { agentPreset }), forkSession, inline,
         resumeAll,
@@ -120,6 +143,7 @@ function parseArgs(args) {
         ...(tools === undefined ? {} : { tools }),
         ...(disallowedTools === undefined ? {} : { disallowedTools }),
         ...(resume === undefined ? {} : { resume }), ...(sessionId === undefined ? {} : { sessionId }),
+        ...(systemPrompt === undefined ? {} : { systemPrompt }), verbose,
     };
 }
 function packageVersion(path) {
@@ -213,6 +237,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); },
@@ -266,12 +292,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();

package/lib/input.d.ts

@@ -1,5 +1,5 @@
 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;

package/lib/input.js

@@ -1,4 +1,5 @@
 import { isKeyRelease, matchesKey } from '@earendil-works/pi-tui';
+import { PAGE_CELLS } from './state.js';
 export function caretOffset(text, cursor) {
     const lines = text.split('\n');
     let offset = 0;
@@ -98,6 +99,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

@@ -13,6 +13,7 @@ export interface Renderer extends TerminalSession {
 export interface RendererOptions extends InputBindings {
     readonly accessible?: boolean;
     readonly inline: boolean;
+    readonly statusLine?: () => string | undefined;
     readonly terminal?: Terminal;
     readonly terminalType?: string;
 }

package/lib/renderer.js

@@ -1,4 +1,4 @@
-import { Editor, TuiAltScreen, TuiMainScreen, stripTerminalSequences, truncateToWidth, wrapTextWithAnsi, } from '@earendil-works/pi-tui';
+import { Editor, Markdown, TuiAltScreen, TuiMainScreen, stripTerminalSequences, truncateToWidth, wrapTextWithAnsi, } from '@earendil-works/pi-tui';
 import { caretOffset, installInput } from './input.js';
 import { hasCompletionTrigger } from './completion-trigger.js';
 import { createProcessTerminal } from './terminal-guard.js';
@@ -15,6 +15,22 @@ const THEME_GENERATION = 1;
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const SPINNER_INTERVAL_MS = 80;
 const MASK_TOKEN = new RegExp(String.raw `\u001B(?:\[[0-?]*[ -/]*[@-~]|[_P^X][^\u0007]*(?:\u0007|\u001B\\))|[^\s]`, 'gu');
+const markdownTheme = {
+    heading: text => `\u001B[36m${text}${RESET}`,
+    link: text => `\u001B[36m${text}${RESET}`,
+    linkUrl: text => `${DIM}${text}${RESET}`,
+    code: text => `${YELLOW}${text}${RESET}`,
+    codeBlock: text => `${GREEN}${text}${RESET}`,
+    codeBlockBorder: text => `${DIM}${text}${RESET}`,
+    quote: text => `${DIM}${text}${RESET}`,
+    quoteBorder: text => `${DIM}${text}${RESET}`,
+    hr: text => `${DIM}${text}${RESET}`,
+    listBullet: text => `\u001B[36m${text}${RESET}`,
+    bold: text => `\u001B[1m${text}\u001B[22m`,
+    italic: text => `\u001B[3m${text}\u001B[23m`,
+    strikethrough: text => `\u001B[9m${text}\u001B[29m`,
+    underline: text => `\u001B[4m${text}\u001B[24m`,
+};
 export function supportsOsc52(terminalType) {
     return terminalType?.toLocaleLowerCase() !== 'dumb';
 }
@@ -138,6 +154,22 @@ function plain(text, preserveNewlines = false) {
 function line(text, width) {
     return truncateToWidth(text, Math.max(1, width), '…');
 }
+function windowRows(values, size, position, follow) {
+    if (values.length <= size)
+        return [...values];
+    if (size < 3)
+        return [values[Math.max(0, Math.min(values.length - 1, position))] ?? ''];
+    const start = Math.max(0, Math.min(values.length - Math.max(1, size - 1), follow ? position - Math.floor((size - 2) / 2) : position));
+    const above = start > 0;
+    let end = Math.min(values.length, start + size - Number(above));
+    if (end < values.length)
+        end--;
+    return [
+        ...(above ? [`${DIM}↑ ${String(start)} more${RESET}`] : []),
+        ...values.slice(start, end),
+        ...(end < values.length ? [`${DIM}↓ ${String(values.length - end)} more${RESET}`] : []),
+    ];
+}
 function theme() {
     const identity = (text) => text;
     return {
@@ -160,7 +192,9 @@ export function createRenderer(options) {
     const osc52 = supportsOsc52(terminalType);
     const tui = options.inline
         ? new TuiMainScreen(terminal, true)
-        : new TuiAltScreen(terminal, true, undefined, { mouse: true });
+        : new class extends TuiAltScreen {
+            isOverlayFocused() { return options.readState().overlay !== undefined || super.isOverlayFocused(); }
+        }(terminal, true, undefined, { mouse: true });
     let editor = new Editor(tui, theme(), { paddingX: 1 });
     editor.disableSubmit = true;
     editor.onChange = text => {
@@ -184,7 +218,11 @@ export function createRenderer(options) {
         const cached = cell.pending === true ? undefined : lineCache.get(key);
         if (cached !== undefined)
             return cached;
-        const rendered = wrapTextWithAnsi(cellText(cell, toolMode, accessible, now), Math.max(1, width - 2)).map(value => `  ${value}`);
+        const cellWidth = Math.max(1, width - 2);
+        const lines = !accessible && cell.kind === 'assistant' && cell.pending !== true
+            ? [`${BOLD_CYAN}Assistant${RESET}`, ...new Markdown(plain(cell.text, true), 0, 0, markdownTheme).render(cellWidth).map(value => value.trimEnd())]
+            : wrapTextWithAnsi(cellText(cell, toolMode, accessible, now), cellWidth);
+        const rendered = lines.map(value => `  ${value}`);
         if (cell.pending !== true) {
             lineCache.set(key, rendered);
             if (lineCache.size > 512)
@@ -275,19 +313,19 @@ export function createRenderer(options) {
         result.push(`${DIM}↑↓ select · Enter details · Esc close${RESET}`);
         return result.slice(0, Math.max(2, rows - 3));
     };
+    const infoRows = (overlay, state, width) => overlay.lines.flatMap(value => wrapTextWithAnsi(plain(value, true), width)).concat(overlay.cells?.flatMap(cell => wrapTextWithAnsi(cellText(cell, state.toolMode, accessible), width)) ?? []);
     const overlayPanel = (overlay, state, width, rows) => {
         if (overlay.kind === 'history')
             return historyPanel(overlay, state, width, rows);
         if (overlay.kind === 'details')
             return detailsPanel(overlay, state, width, rows);
         if (overlay.kind === 'info') {
-            const cards = overlay.cells?.flatMap(cell => wrapTextWithAnsi(cellText(cell, state.toolMode, accessible), width)) ?? [];
+            const body = infoRows(overlay, state, width);
             return [
                 `${BOLD_CYAN}${announcement(plain(overlay.title), overlay.lines.length + (overlay.cells?.length ?? 0))}${RESET}`,
-                ...overlay.lines.flatMap(value => wrapTextWithAnsi(plain(value, true), width)),
-                ...cards,
-                `${DIM}Enter or Esc to close${RESET}`,
-            ].slice(0, Math.max(2, rows - 3));
+                ...windowRows(body, Math.max(1, rows - 5), overlay.scrollOffset ?? 0, false),
+                `${DIM}↑↓ scroll · PageUp/PageDown · Enter or Esc close${RESET}`,
+            ];
         }
         if (overlay.kind === 'confirm') {
             const choices = [overlay.acceptLabel, 'Cancel'];
@@ -303,18 +341,23 @@ export function createRenderer(options) {
             line(`${BOLD_CYAN}${announcement(plain(overlay.title), overlay.options.length, selected === undefined ? undefined : plain(selected.label), overlay.cursor)}${RESET}`, width),
             ...(overlay.notice === undefined ? [] : [`${DIM}${plain(overlay.notice)}${RESET}`]),
         ];
+        const body = [];
+        let selectedRow = 0;
         let group;
         for (const [index, option] of overlay.options.entries()) {
             if (option.group !== undefined && option.group !== group) {
                 group = option.group;
-                result.push(`${DIM}${plain(group)}${RESET}`);
+                body.push(`${DIM}${plain(group)}${RESET}`);
             }
             const detail = option.detail === undefined ? '' : ` — ${plain(option.detail)}`;
             const active = option.active === true ? accessible ? ' [active]' : ' ●' : '';
             const danger = option.danger === true ? ` ${YELLOW}${accessible ? '[danger]' : '!'}${RESET}` : '';
-            result.push(line(`${index === overlay.cursor ? BOLD_CYAN : DIM}${index === overlay.cursor ? accessible ? '>' : '›' : ' '} ${String(index + 1)} ${plain(option.label)}${active}${detail}${RESET}${danger}`, width));
+            if (index === overlay.cursor)
+                selectedRow = body.length;
+            body.push(line(`${index === overlay.cursor ? BOLD_CYAN : DIM}${index === overlay.cursor ? accessible ? '>' : '›' : ' '} ${String(index + 1)} ${plain(option.label)}${active}${detail}${RESET}${danger}`, width));
         }
-        return result.slice(0, Math.max(2, rows - (overlay.purpose === 'completion' ? 6 : 3)));
+        const limit = Math.max(2, rows - (overlay.purpose === 'completion' ? 6 : 3));
+        return [...result, ...windowRows(body, Math.max(1, limit - result.length), selectedRow, true)];
     };
     const document = {
         invalidate() { editor.invalidate(); },
@@ -368,6 +411,11 @@ export function createRenderer(options) {
             const attachmentRows = state.attachments.map((attachment, index) => line(`${YELLOW}[image ${String(index + 1)}]${RESET} ${plain(attachment.name)} · ${attachment.mediaType} · ${String(attachment.bytes)} B · ${plain(attachment.path)}`, width));
             const activityRows = decision !== undefined || state.search !== undefined || state.overlay !== undefined
                 ? [] : activities(state).map(item => line(`${DIM}${activityText(item, now)}${RESET}`, width));
+            const persistentStatus = accessible || state.exitArmed ? undefined : options.statusLine?.();
+            const composer = () => [
+                ...(persistentStatus === undefined ? [] : [line(`${DIM}${plain(persistentStatus)}${RESET}`, width)]),
+                ...editor.render(width),
+            ];
             const control = decision !== undefined
                 ? decisionPanel(decision, width, rows)
                 : state.search !== undefined
@@ -379,11 +427,11 @@ export function createRenderer(options) {
                         `${DIM}${state.search.matches.length === 0 ? 'no matches' : `${String(state.search.cursor + 1)}/${String(state.search.matches.length)}`} · Enter next · Shift+Enter previous${RESET}`,
                     ]
                     : state.overlay === undefined
-                        ? [...activityRows, ...attachmentRows, ...editor.render(width)]
+                        ? [...activityRows, ...attachmentRows, ...composer()]
                         : [
                             ...overlayPanel(state.overlay, state, width, rows),
                             ...(state.overlay.kind === 'list' && state.overlay.purpose === 'completion'
-                                ? [...attachmentRows, ...editor.render(width)]
+                                ? [...attachmentRows, ...composer()]
                                 : []),
                         ];
             const fixedRows = header.length + control.length + 2;
@@ -405,6 +453,13 @@ export function createRenderer(options) {
     tui.setFocus(editor);
     installInput(tui, {
         ...options,
+        dispatch: action => {
+            const overlay = options.readState().overlay;
+            const size = Math.max(1, terminal.rows - 5);
+            options.dispatch(action.type === 'overlay-move' && overlay?.kind === 'info'
+                ? { ...action, limit: Math.max(0, infoRows(overlay, options.readState(), terminal.columns).length - Math.max(1, size - 1)) }
+                : action);
+        },
         insertNewline: () => { editor.insertTextAtCursor('\n'); },
         readComposerCursor: () => editor.getCursor(),
     });

package/lib/session-runtime.d.ts

@@ -4,6 +4,7 @@ import type { TuiRoot } from './tui-root.js';
 export interface RootLaunchOptions {
     readonly agentPreset?: string;
     readonly continue: boolean;
+    readonly appendSystemPrompt?: string;
     readonly cwd: string;
     readonly effort?: string;
     readonly forkSession: boolean;
@@ -17,6 +18,7 @@ export interface RootLaunchOptions {
     readonly disallowedTools?: readonly string[];
     readonly resume?: string;
     readonly sessionId?: string;
+    readonly systemPrompt?: string;
 }
 export declare class LaunchArgumentError extends Error {
 }
@@ -26,6 +28,7 @@ export interface SessionRuntime {
     readonly initialHasMore: boolean;
     readonly initialPrompts: readonly string[];
     readonly root: RootView;
+    readonly statusLine: string;
     readonly summary: string;
     activate(value: ActivatableOverlayValue): Promise<void>;
     attach(path: string): Promise<DraftAttachment | undefined>;

package/lib/session-runtime.js

@@ -2,9 +2,9 @@ import { basename } from 'node:path';
 import { AuthorizationDeclinedError } from '@deepseek-ai/dsh-authorization';
 import { parseCredentialKey } from '@deepseek-ai/dsh-credentials';
 import { JobId } from '@deepseek-ai/dsh-jobs';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createUserMessage, ToolCallId } from '@deepseek-ai/dsh-llm';
 import { SessionId, SessionSeq } from '@deepseek-ai/dsh-session';
-import { agentPresetOverlay, completionOptions, contextOverlay, currentModel, modelOverlay, permissionOverlay, searchOverlay, sessionOverlay, skillOverlay, statusOverlay, } from './catalogs.js';
+import { agentPresetOverlay, completionOptions, contextOverlay, currentModel, modelOverlay, permissionOverlay, searchOverlay, sessionStatusLine, sessionOverlay, skillOverlay, statusOverlay, usageOverlay, } from './catalogs.js';
 import { diffOverlay } from './diff-view.js';
 import { eventsFromRecords } from './history-records.js';
 import { admitDraftImages, encodeDraftImages, readDraftImages } from './image-input.js';
@@ -21,6 +21,7 @@ export class LaunchArgumentError extends Error {
 function starterAgents(cwd) {
     return `# ${basename(cwd)}\n\n## Working agreement\n\n- Add project-specific architecture guidance.\n- Add required build, test, and lint commands.\n- Add repository conventions and constraints.\n`;
 }
+const RECAP_PROMPT = 'Summarize this conversation so far in ten lines: goal, decisions, open items.';
 function detail(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -79,9 +80,31 @@ async function firstControl(iterator) {
     }
     return first.value;
 }
+async function gitBranch(ctx, agent, signal) {
+    try {
+        const result = await ctx.shell.run(ctx.shell.resolve({
+            command: 'git branch --show-current', sandboxPolicy: ctx.sandboxPolicy.resolve({ mode: 'read-only' }),
+            signal, stdoutMaxBytes: 512, timeoutMs: 2_000, workdir: agent.session.header.cwd,
+        }));
+        return result.exitCode === 0 && result.stdout.text.trim() !== '' ? result.stdout.text.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function usage(raw, expected) {
     return raw.trim() === '' ? undefined : { kind: 'error', text: `usage: ${expected}` };
 }
+function loopInterval(seconds) {
+    if (seconds % 3_600 === 0)
+        return `${String(seconds / 3_600)}h`;
+    return seconds % 60 === 0 ? `${String(seconds / 60)}m` : `${String(seconds)}s`;
+}
+function loopLine(schedule) {
+    const rule = schedule.kind === 'every' ? `every ${loopInterval(schedule.everySeconds)}`
+        : schedule.kind === 'after' ? `after ${String(schedule.afterSeconds)}s` : `at ${schedule.scheduledAt}`;
+    return `${String(schedule.id)} · ${rule} · ${schedule.prompt}`;
+}
 function configValue(raw) {
     try {
         return JSON.parse(raw);
@@ -114,18 +137,26 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             if ('error' in resolved)
                 throw resolved.error;
             const agent = resolved.agent;
-            let disposeRestriction;
+            const disposers = [];
             if (options.tools !== undefined || options.disallowedTools !== undefined) {
                 try {
-                    disposeRestriction = agent.ctx.tools.restrict({
+                    disposers.push(agent.ctx.tools.restrict({
                         ...(options.tools === undefined ? {} : { allow: options.tools }),
                         ...(options.disallowedTools === undefined ? {} : { deny: options.disallowedTools }),
-                    });
+                    }));
                 }
                 catch (error) {
                     throw new LaunchArgumentError(detail(error));
                 }
             }
+            if (options.systemPrompt !== undefined)
+                disposers.push(agent.ctx.systemPrompt.section({
+                    complete: true, name: 'dashi:system-prompt', order: Number.MAX_SAFE_INTEGER, text: options.systemPrompt,
+                }));
+            if (options.appendSystemPrompt !== undefined)
+                disposers.push(agent.ctx.systemPrompt.section({
+                    name: 'dashi:append-system-prompt', order: Number.MAX_SAFE_INTEGER, text: options.appendSystemPrompt,
+                }));
             let title;
             if (name !== undefined)
                 title = (await ctx.sessionController.rename({ sessionId, title: name })).title;
@@ -134,8 +165,9 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 address: { kind: 'session', sessionId }, maxMessages: 50,
             }, abort.signal)[Symbol.asyncIterator]();
             const controlIterator = ctx.sessionController.control(abort.signal)[Symbol.asyncIterator]();
-            const [opening, controlOpening, subagents] = await Promise.all([
+            const [opening, controlOpening, subagents, branch] = await Promise.all([
                 firstSnapshot(iterator), firstControl(controlIterator), subagentViews(ctx, sessionId, abort.signal),
+                gitBranch(ctx, agent, abort.signal),
             ]);
             title ??= projectionString(opening.projections, 'title');
             const selected = projectionModel(opening.projections);
@@ -147,9 +179,10 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             return {
                 abort,
                 agent,
+                branch,
                 controlIterator,
                 cursor: opening.cursor,
-                disposers: disposeRestriction === undefined ? [] : [disposeRestriction],
+                disposers,
                 events: eventsFromRecords(opening.records),
                 hasMore: opening.hasMore,
                 iterator,
@@ -256,12 +289,20 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             });
         }, 34);
     };
+    const refreshBranch = async (bound) => {
+        const branch = await gitBranch(ctx, bound.agent, bound.abort.signal);
+        if (bound.abort.signal.aborted || current() !== bound || bound.branch === branch)
+            return;
+        bound.branch = branch;
+        dispatch({ type: 'redraw' });
+    };
     const consume = (bound, frame) => {
         const [event] = eventsFromRecords([frame]);
         if (event === undefined)
             return;
         bound.events.push(event);
         if (event.type === 'turn/end') {
+            void refreshBranch(bound);
             const startedAt = turnStartTime(bound.events, event.data.turn);
             if (startedAt !== undefined) {
                 dispatch({
@@ -511,6 +552,79 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             const result = ctx.jobs.kill(JobId(match[1]), bound.agent, 'stopped by /tasks');
             return { kind: 'success', text: result === 'requested' ? `stopping ${match[1]}` : `${match[1]} already finished` };
         };
+        const loop = async (invocation) => {
+            const stale = ensureCurrent(invocation);
+            if (stale !== undefined)
+                return stale;
+            const raw = invocation.rawInput.trim();
+            const stop = /^stop\s+(\S+)$/u.exec(raw);
+            const create = /^(\d+)([mh])\s+(.+)$/su.exec(raw);
+            if (raw !== '' && stop === null && create === null) {
+                return { kind: 'error', text: 'usage: /loop [INTERVAL TEXT | stop ID]' };
+            }
+            const name = raw === '' ? 'schedule_list' : stop === null ? 'schedule_create' : 'schedule_delete';
+            const args = raw === '' ? {} : stop === null ? {
+                every_seconds: Number(create[1]) * (create[2] === 'h' ? 3_600 : 60), prompt: create[3],
+            } : { id: stop[1] };
+            const result = await ctx.agents.withInitiator(bound.agent, () => ctx.tools.execute({
+                agent: bound.agent, arguments: args, callId: ToolCallId(`${String(invocation.commandId)}:loop`),
+                name, signal: invocation.signal,
+            }));
+            if (result.isError)
+                return { kind: 'error', text: result.error.message };
+            const value = result.value;
+            if (!Array.isArray(value) && 'message' in value)
+                return { kind: 'error', text: value.message };
+            if (Array.isArray(value))
+                return { kind: 'success', text: value.length === 0 ? 'no active schedules' : value.map(loopLine).join('\n') };
+            if ('deleted' in value)
+                return value.deleted ? { kind: 'success', text: `stopped ${String(value.id)}` }
+                    : { kind: 'error', text: `schedule ${String(value.id)} not found` };
+            return { kind: 'success', text: `scheduled ${loopLine(value)}` };
+        };
+        const askAside = async (invocation, prompt = invocation.rawInput.trim()) => {
+            const stale = ensureCurrent(invocation);
+            if (stale !== undefined)
+                return stale;
+            if (prompt === '')
+                return { kind: 'error', text: 'usage: /btw TEXT' };
+            const forked = await ctx.sessionController.fork({ sessionId: bound.agent.id });
+            const resolved = await ctx.sessionController.resolveAgent(forked.sessionId);
+            if ('error' in resolved)
+                throw resolved.error;
+            const child = resolved.agent;
+            const turn = inheritedTurn(child.session.snapshotEvents(), child.session.inheritedEventCount);
+            if (turn === undefined)
+                throw new Error('the fork contains no completed turn');
+            const iterator = ctx.sessionController.follow({
+                address: { kind: 'session', sessionId: child.id }, maxMessages: 50,
+            }, invocation.signal)[Symbol.asyncIterator]();
+            await firstSnapshot(iterator);
+            await ctx.sessionController.rename({
+                sessionId: child.id, title: `btw · ${prompt.split(/\s+/u).slice(0, 6).join(' ')}`,
+            });
+            const from = child.session.seq;
+            child.steer(createUserMessage({ content: [{ type: 'text', text: prompt }], source: { kind: 'user' } }));
+            try {
+                for (;;) {
+                    const next = await iterator.next();
+                    if (next.done === true)
+                        throw new Error('DSH session follow ended before the side turn completed');
+                    if (next.value.type !== 'snapshot' && eventsFromRecords([next.value])[0]?.type === 'turn/end')
+                        break;
+                }
+            }
+            finally {
+                await iterator.return?.();
+            }
+            await ctx.sessions.flush(child.session);
+            const cells = foldCells(child.session.snapshotEvents(from), createToolPresenter(tool => ctx.tools.get(tool, child)))
+                .filter(cell => cell.kind !== 'user');
+            dispatch({ type: 'open-overlay', overlay: {
+                    cells, kind: 'info', lines: [], title: `Btw · turn ${String(turn)}`,
+                } });
+            return { kind: 'success' };
+        };
         const definitions = [
             {
                 name: 'help', description: 'Show keyboard and command help',
@@ -551,6 +665,16 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     return { kind: 'success' };
                 },
             },
+            {
+                name: 'usage', description: 'Show session token and timing totals',
+                handler: (invocation) => {
+                    const invalid = ensureCurrent(invocation) ?? usage(invocation.rawInput, '/usage');
+                    if (invalid !== undefined)
+                        return invalid;
+                    dispatch({ type: 'open-overlay', overlay: usageOverlay(ctx, bound.agent) });
+                    return { kind: 'success' };
+                },
+            },
             {
                 name: 'memory', description: 'Open an instruction file loaded by DSH',
                 handler: (invocation) => {
@@ -671,7 +795,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     if (invocation.rawInput.trim() === '')
                         return { kind: 'error', text: 'usage: /plugin ARGS' };
                     const command = `dsh plugin --profile ${quoteShellWord(decodeURIComponent(new URL(ctx.baseUrl).pathname).split('/').at(-2))}${invocation.rawInput}`;
-                    const [message, result] = await bound.agent.runMaintenance(signal => runHumanShell(ctx, bound.agent, command, signal, 'changes load on the next launch; exit and run dashi again'));
+                    const [message, result] = await bound.agent.runMaintenance(signal => runHumanShell(ctx, bound.agent, command, signal, 'changes load on the next launch; exit and run dashi again', false));
                     bound.agent.inject(message);
                     await ctx.sessions.flush(bound.agent.session);
                     publish(bound);
@@ -679,29 +803,35 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 },
             },
             {
-                name: 'new', description: 'Start a new session', input: { hint: '[--name TITLE]' },
+                name: 'new', description: 'Start a new session', input: { hint: '[NAME | --name TITLE]' },
                 handler: async (invocation) => {
                     const stale = ensureCurrent(invocation);
                     if (stale !== undefined)
                         return stale;
                     const raw = invocation.rawInput.trim();
                     const match = /^--name\s+(.+)$/su.exec(raw);
-                    if (raw !== '' && match === null)
-                        return { kind: 'error', text: 'usage: /new [--name TITLE]' };
+                    if (raw.startsWith('--') && match === null)
+                        return { kind: 'error', text: 'usage: /new [NAME | --name TITLE]' };
                     const title = match?.[1]?.trim();
+                    if (raw !== '' && match === null) {
+                        await ctx.sessionController.rename({ sessionId: bound.agent.id, title: raw });
+                        await ctx.sessions.flush(bound.agent.session);
+                    }
                     await runRootOperation({ kind: 'new', ...(title === undefined ? {} : { title }) });
                     return { kind: 'success' };
                 },
             },
             {
-                name: 'clear', description: 'Start a new session',
+                name: 'clear', description: 'Start a new session', input: { hint: '[NAME]' },
                 handler: async (invocation) => {
                     const stale = ensureCurrent(invocation);
                     if (stale !== undefined)
                         return stale;
-                    const invalid = usage(invocation.rawInput, '/clear');
-                    if (invalid !== undefined)
-                        return invalid;
+                    const title = invocation.rawInput.trim();
+                    if (title !== '') {
+                        await ctx.sessionController.rename({ sessionId: bound.agent.id, title });
+                        await ctx.sessions.flush(bound.agent.session);
+                    }
                     await runRootOperation({ kind: 'new' });
                     return { kind: 'success' };
                 },
@@ -787,17 +917,46 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 },
             },
             {
-                name: 'agents', description: 'Choose the native DSH agent preset',
+                name: 'loop', description: 'List, schedule, or stop a fixed-rate reminder',
+                input: { hint: '[INTERVAL TEXT | stop ID]' }, handler: loop,
+            },
+            {
+                name: 'btw', description: 'Ask a side question in a fork', input: { hint: 'TEXT' }, recordInput: false,
+                handler: invocation => askAside(invocation),
+            },
+            {
+                name: 'recap', description: 'Summarize the conversation in a fork', recordInput: false,
+                handler: invocation => usage(invocation.rawInput, '/recap') ?? askAside(invocation, RECAP_PROMPT),
+            },
+            {
+                name: 'agents', description: 'Choose or author a native DSH agent preset',
+                input: { hint: '[new NAME | copy SRC DEST | delete NAME]' },
                 handler: async (invocation) => {
                     const stale = ensureCurrent(invocation);
                     if (stale !== undefined)
                         return stale;
-                    const invalid = usage(invocation.rawInput, '/agents');
-                    if (invalid !== undefined)
-                        return invalid;
+                    const raw = invocation.rawInput.trim();
                     const blank = !bound.agent.session.snapshotEvents().some(event => event.type === 'turn/start');
                     const selected = ctx.sessionProjections.stateOf(bound.agent.session, 'agentPreset')
                         ?? ctx.agentPresets.defaultId;
+                    const create = /^new\s+(\S+)$/u.exec(raw);
+                    const copy = /^copy\s+(\S+)\s+(\S+)$/u.exec(raw);
+                    const remove = /^delete\s+(\S+)$/u.exec(raw);
+                    if (create?.[1] !== undefined) {
+                        await ctx.agentPresets.copy(selected, create[1]);
+                        dispatch({ type: 'open-file', path: (await ctx.agentPresets.resolve(create[1])).path });
+                        return { kind: 'success', text: `created ${create[1]} from ${selected}` };
+                    }
+                    if (copy?.[1] !== undefined && copy[2] !== undefined) {
+                        await ctx.agentPresets.copy(copy[1], copy[2]);
+                        return { kind: 'success', text: `copied ${copy[1]} to ${copy[2]}` };
+                    }
+                    if (remove?.[1] !== undefined) {
+                        await ctx.agentPresets.remove(remove[1]);
+                        return { kind: 'success', text: `deleted ${remove[1]}` };
+                    }
+                    if (raw !== '')
+                        return { kind: 'error', text: 'usage: /agents [new NAME | copy SRC DEST | delete NAME]' };
                     dispatch({
                         type: 'open-overlay',
                         overlay: agentPresetOverlay(await ctx.agentPresets.list(), selected, blank),
@@ -1120,6 +1279,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
         get initialHasMore() { return current().hasMore; },
         get initialPrompts() { return humanPrompts(current().events); },
         get root() { return current().root; },
+        get statusLine() { const bound = current(); return sessionStatusLine(ctx, bound.agent, bound.root, bound.branch); },
         get summary() { return `Resume with: dsh --profile dashi --resume ${current().root.id}`; },
         activate,
         async attach(path) {

package/lib/shell-command.d.ts

@@ -7,4 +7,4 @@ export declare const HUMAN_SHELL_STREAM_BYTES: number;
 export declare function shellResultText(command: string, result: ShellRunResult): string;
 export declare function quoteShellWord(value: string): string;
 /** Run an explicit human command through DSH and identify its next-step context. */
-export declare function runHumanShell(ctx: Context, agent: Agent, command: string, signal: AbortSignal, success?: string): Promise<readonly [UserMessage, ShellRunResult]>;
+export declare function runHumanShell(ctx: Context, agent: Agent, command: string, signal: AbortSignal, success?: string, useSessionSandbox?: boolean): Promise<readonly [UserMessage, ShellRunResult]>;

package/lib/shell-command.js

@@ -45,11 +45,12 @@ export function shellResultText(command, result) {
 }
 export function quoteShellWord(value) { return `'${value.replaceAll("'", "'\\''")}'`; }
 /** Run an explicit human command through DSH and identify its next-step context. */
-export async function runHumanShell(ctx, agent, command, signal, success) {
+export async function runHumanShell(ctx, agent, command, signal, success, useSessionSandbox = true) {
     const result = await ctx.shell.run(ctx.shell.resolve({
         command,
         env: { DSH_HOME: resolveDshHome() },
-        sandboxPolicy: ctx.sandboxPolicy.resolve({ session: agent.session }),
+        sandboxPolicy: ctx.sandboxPolicy.resolve(useSessionSandbox
+            ? { session: agent.session } : { mode: 'danger-full-access' }),
         signal,
         stdoutMaxBytes: HUMAN_SHELL_STREAM_BYTES,
         timeoutMs: HUMAN_SHELL_TIMEOUT_MS,

package/lib/state.d.ts

@@ -216,6 +216,7 @@ export type Overlay = {
     readonly cells?: readonly TerminalCell[];
     readonly kind: 'info';
     readonly lines: readonly string[];
+    readonly scrollOffset?: number;
     readonly title: string;
 } | {
     readonly cursor: number;
@@ -333,6 +334,9 @@ export type UiAction = {
     readonly type: 'open-history';
 } | {
     readonly type: 'open-details';
+} | {
+    readonly path: string;
+    readonly type: 'open-file';
 } | {
     readonly type: 'completion-ready';
     readonly options: readonly OverlayOption[];
@@ -343,6 +347,7 @@ export type UiAction = {
 } | {
     readonly type: 'overlay-close';
 } | {
+    readonly limit?: number;
     readonly type: 'overlay-move';
     readonly offset: number;
 } | {
@@ -503,6 +508,7 @@ export type UiEffect = {
 } | {
     readonly type: 'suspend';
 };
-export declare function initialViewState(cwd: string, inline: boolean, root?: RootView, cells?: readonly TerminalCell[], prompts?: readonly string[], historyHasMore?: boolean, attachments?: readonly DraftAttachment[]): ViewState;
+export declare function initialViewState(cwd: string, inline: boolean, root?: RootView, cells?: readonly TerminalCell[], prompts?: readonly string[], historyHasMore?: boolean, attachments?: readonly DraftAttachment[], toolMode?: ToolMode): ViewState;
 export declare const TURN_BELL_THRESHOLD_MS = 10000;
+export declare const PAGE_CELLS = 8;
 export declare function reduce(state: ViewState, action: UiAction): readonly [ViewState, readonly UiEffect[]];

package/lib/state.js

@@ -1,9 +1,9 @@
 import { FLAG_HELP, VERSION_LINE } from './help.js';
-export function initialViewState(cwd, inline, root, cells = [], prompts = [], historyHasMore = false, attachments = []) {
+export function initialViewState(cwd, inline, root, cells = [], prompts = [], historyHasMore = false, attachments = [], toolMode = 'collapsed') {
     return {
         attachments, cells, composer: '', cwd, decisions: [], exitArmed: false, historyHasMore, inline,
         newOutput: 0, prompts, rewindArmed: false, scrollOffset: 0,
-        sendMode: 'steer', toolMode: 'collapsed',
+        sendMode: 'steer', toolMode,
         ...(root === undefined ? {} : { root }),
     };
 }
@@ -41,8 +41,8 @@ function help() {
             'Ctrl+B activity details for jobs and subagents',
             '@ paths require DSH file-reference · Ctrl+V pastes an image · Backspace removes it',
             'Ctrl+S stash · Ctrl+G editor · F1 help · Ctrl+L redraw · Ctrl+Z suspend',
-            '/new /clear /reset /resume /continue [--all] [NAME|UUID] /fork /branch /rewind /rename /model /effort /permission /agents /queue /status /context',
-            '/init /memory /skills /config /login /logout /diff /plugins /plugin /tasks /bashes /subtask /history /export /copy /exit /quit',
+            '/new /clear /reset /resume /continue [--all] [NAME|UUID] /fork /branch /rewind /rename /model /effort /permission /agents /queue /status /usage /context',
+            '/init /memory /skills /config /login /logout /diff /plugins /plugin /tasks /bashes /subtask /loop /btw /recap /history /export /copy /exit /quit',
             ...FLAG_HELP,
         ],
     };
@@ -55,7 +55,7 @@ function moveOverlay(overlay, cursor, detailsCount = 0) {
             : Math.max(0, overlay.options.length - 1);
     return { ...overlay, cursor: Math.max(0, Math.min(limit, cursor)) };
 }
-const PAGE_CELLS = 8;
+export const PAGE_CELLS = 8;
 function matches(cells, query) {
     const needle = query.trim().toLocaleLowerCase();
     if (needle === '')
@@ -366,6 +366,7 @@ export function reduce(state, action) {
             return head === undefined
                 ? [{ ...state, overlay: action.overlay, exitArmed: false, rewindArmed: false }, redraw()]
                 : [state, []];
+        case 'open-file': return [state, [{ type: 'activate-overlay', value: { kind: 'open-file', path: action.path } }]];
         case 'overlay-close': {
             if (state.overlay === undefined)
                 return [state, []];
@@ -375,8 +376,14 @@ export function reduce(state, action) {
         case 'overlay-move': {
             if (state.overlay === undefined)
                 return [state, []];
+            if (state.overlay.kind === 'info') {
+                const current = state.overlay.scrollOffset ?? 0;
+                const scrollOffset = Math.max(0, Math.min(action.limit ?? current, current + action.offset));
+                return scrollOffset === current ? [state, []]
+                    : [{ ...state, overlay: { ...state.overlay, scrollOffset } }, redraw()];
+            }
             const count = (state.root?.jobs?.length ?? 0) + (state.root?.subagents?.length ?? 0);
-            const overlay = moveOverlay(state.overlay, state.overlay.kind === 'info' ? 0 : state.overlay.cursor + action.offset, count);
+            const overlay = moveOverlay(state.overlay, state.overlay.cursor + action.offset, count);
             return overlay === state.overlay ? [state, []] : [{ ...state, overlay }, redraw()];
         }
         case 'overlay-number': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antst/dashi",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.12",
   "description": "A terminal UI for DeepSeek Harness",
   "publishConfig": {
     "access": "public"
@@ -57,13 +57,16 @@
     "@deepseek-ai/dsh-permission-presets": "0.1.2-rc.1",
     "@deepseek-ai/dsh-plan-mode": "0.1.2-rc.1",
     "@deepseek-ai/dsh-sandbox-policy": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-schedule": "0.1.2-rc.1",
     "@deepseek-ai/dsh-session": "0.1.2-rc.1",
     "@deepseek-ai/dsh-session-projection": "0.1.2-rc.1",
     "@deepseek-ai/dsh-session-query": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-session-stats": "0.1.2-rc.1",
     "@deepseek-ai/dsh-settings": "0.1.2-rc.1",
     "@deepseek-ai/dsh-shell": "0.1.2-rc.1",
     "@deepseek-ai/dsh-skill": "0.1.2-rc.1",
     "@deepseek-ai/dsh-subagent": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.1.2-rc.1",
     "@deepseek-ai/dsh-token-meter": "0.1.2-rc.1",
     "@deepseek-ai/dsh-tool-todo": "0.1.2-rc.1",
     "@deepseek-ai/dsh-tools": "0.1.2-rc.1",