@antst/dashi 0.1.0-alpha.6 → 0.1.0-alpha.8

package/lib/application.js

@@ -1,4 +1,5 @@
 import { createRenderer } from './renderer.js';
+import { runEditor } from './external-editor.js';
 import { initialViewState, reduce, } from './state.js';
 import { createTerminalGuard } from './terminal-guard.js';
 function suspendProcess() {
@@ -44,7 +45,14 @@ export function createTerminalShell(options) {
     async function run(effect) {
         switch (effect.type) {
             case 'activate-overlay':
-                await options.activateOverlay?.(effect.value);
+                if (effect.value.kind === 'open-file') {
+                    const path = effect.value.path;
+                    await guard.withCookedTerminal(() => runEditor(process.env.EDITOR?.trim() || 'vi', path, options.cwd)).catch(error => {
+                        dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                    });
+                }
+                else
+                    await options.activateOverlay?.(effect.value);
                 return;
             case 'attach': {
                 try {

package/lib/diff-view.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Overlay } from './state.js';
+import { type ToolPresenter } from './tool-presentation.js';
+export declare function diffOverlay(ctx: Context, agent: Agent, presenter: ToolPresenter, mode: '' | 'turn', signal: AbortSignal): Promise<Overlay>;

package/lib/diff-view.js

@@ -0,0 +1,23 @@
+import { boundedBody } from './tool-presentation.js';
+import { foldCells } from './transcript.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 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,
+    }));
+    const output = [result.stdout.text, result.stderr.text].filter(Boolean).join('\n');
+    const cell = {
+        key: 'diff:working', kind: result.exitCode === 0 ? 'tool' : 'error', text: 'git diff',
+        tool: { card: 'terminal', title: 'git diff', status: result.exitCode === 0 ? output === '' ? 'clean' : 'changed'
+                : result.exitCode === null ? result.signal ?? 'failed' : `exit ${String(result.exitCode)}`,
+            ...(output === '' ? {} : { body: boundedBody(output) }) },
+    };
+    return { cells: [cell], kind: 'info', lines: [], title: 'Working tree diff' };
+}

package/lib/external-editor.d.ts

@@ -1,2 +1,3 @@
+export declare function runEditor(command: string, file: string, cwd: string): Promise<void>;
 /** Edit one draft through the user's terminal editor and always remove its file. */
 export declare function editDraftExternally(text: string, cwd: string): Promise<string>;

package/lib/external-editor.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { mkdtemp, readFile, rm, rmdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-function runEditor(command, file, cwd) {
+export function runEditor(command, file, cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn('/bin/sh', ['-c', `exec ${command} "$1"`, 'dashi-editor', file], {
             cwd, stdio: 'inherit',

package/lib/help.d.ts

@@ -0,0 +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"];

package/lib/help.js

@@ -0,0 +1,6 @@
+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'
+];

package/lib/index.js

@@ -6,19 +6,24 @@ import { createTerminalShell } from './application.js';
 import { sessionOverlay } from './catalogs.js';
 import { readClipboardImage } from './clipboard-image.js';
 import { editDraftExternally } from './external-editor.js';
+import { FLAG_HELP, VERSION_LINE } from './help.js';
 import { formatSessionList, isSessionId, parseSessionListArgs, sessionMatches, sessionNotFound, } from './session-list.js';
 import { createSessionRuntime } from './session-runtime.js';
 import { TuiRoot } from './tui-root.js';
 export const name = 'dashi';
 export const inject = [
-    'agentPresets', 'agents', 'attachments', 'cmdlineArgs', 'commands', 'fs', 'permissionPresets', 'sessionController',
-    'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'shell', 'skills', 'tools',
+    'agentPresets', 'agents', 'attachments', 'cmdlineArgs', 'commands', 'fs', 'loader', 'permissionPresets',
+    'pluginInventory', 'sessionController', 'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'settings', 'shell', 'skills', 'tools',
 ];
 const validatedVersions = JSON.parse(readFileSync(new URL('../validated-dsh-versions.json', import.meta.url), 'utf8'));
 function parseArgs(args) {
     let accessible = false;
     let inline = true;
     let name;
+    let effort;
+    let model;
+    let permission;
+    let provider;
     let resume;
     let resumeAll = false;
     let resumePicker = false;
@@ -33,14 +38,23 @@ function parseArgs(args) {
             inline = true;
         else if (argument === '--fullscreen')
             inline = false;
-        else if (argument === '--name' || argument === '--image') {
+        else if (argument === '--name' || argument === '--image' || argument === '--effort'
+            || argument === '--model' || argument === '--permission' || argument === '--provider') {
             const value = args[++index];
             if (value === undefined || value === '')
                 return undefined;
             if (argument === '--name')
                 name = value;
-            else
+            else if (argument === '--image')
                 images.push(value);
+            else if (argument === '--effort')
+                effort = value;
+            else if (argument === '--model')
+                model = value;
+            else if (argument === '--permission')
+                permission = value;
+            else
+                provider = value;
         }
         else if (argument === '--resume' || argument === '-r') {
             const value = args[index + 1];
@@ -55,6 +69,9 @@ function parseArgs(args) {
             resumeAll = true;
         else if (argument === '--continue' || argument === '-c')
             useContinue = true;
+        else if (argument === '--yolo' || argument === '--dangerously-skip-permissions') {
+            permission = 'danger-full-access';
+        }
         else if (argument?.startsWith('-') === true)
             return undefined;
         else if (argument !== undefined)
@@ -62,7 +79,8 @@ function parseArgs(args) {
     }
     if (resume !== undefined && (resumePicker || useContinue) || resumePicker && useContinue
         || name !== undefined && (resume !== undefined || resumePicker || useContinue)
-        || resumeAll && resume === undefined && !resumePicker || resumeAll && useContinue)
+        || resumeAll && resume === undefined && !resumePicker || resumeAll && useContinue
+        || provider !== undefined && model === undefined)
         return undefined;
     return {
         accessible,
@@ -71,8 +89,12 @@ function parseArgs(args) {
         resumeAll,
         resumePicker,
         ...(images.length === 0 ? {} : { images }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(model === undefined ? {} : { model }),
         ...(name === undefined ? {} : { name }),
+        ...(permission === undefined ? {} : { permission }),
         ...(prompt.length === 0 ? {} : { prompt: prompt.join(' ') }),
+        ...(provider === undefined ? {} : { provider }),
         ...(resume === undefined ? {} : { resume }),
     };
 }
@@ -133,6 +155,11 @@ export function apply(ctx) {
         throw new Error('dashi: the launcher must provide ctx.appExit, ctx.appReady, and ctx.cmdlineArgs');
     }
     const args = cmdline.get();
+    if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) {
+        process.stdout.write(`${VERSION_LINE}\n\nUsage: dashi [options] [prompt]\n\n${FLAG_HELP.join('\n')}\n`);
+        exit(0);
+        return;
+    }
     if (args[0] === 'sessions') {
         const options = parseSessionListArgs(args);
         if (options === undefined) {

package/lib/input.js

@@ -102,6 +102,8 @@ export function installInput(tui, bindings) {
                 bindings.dispatch({ type: 'overlay-move', offset: -1 });
             else if (matchesKey(data, 'down'))
                 bindings.dispatch({ type: 'overlay-move', offset: 1 });
+            else if (matchesKey(data, 'ctrl+o'))
+                bindings.dispatch({ type: 'toggle-tool-mode' });
             else if (matchesKey(data, 'enter'))
                 bindings.dispatch({ type: 'overlay-submit', execute: true });
             else if (matchesKey(data, 'tab'))

package/lib/memory.d.ts

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

package/lib/memory.js

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

package/lib/renderer.js

@@ -65,7 +65,12 @@ function cellText(cell, toolMode, accessible, now = Date.now()) {
                 : accessible ? '[done]' : '◆';
             return `${cell.pending === true ? YELLOW : DIM}${marker} ${safe}${elapsed === undefined ? '' : ` · ${duration(elapsed)}`}${RESET}`;
         }
-        case 'context': return `${DIM}Context · ${safe}${RESET}`;
+        case 'context': {
+            if (cell.collapsed !== true || cell.detail === undefined)
+                return `${DIM}Context · ${safe}${RESET}`;
+            const head = `${DIM}Context · ${plain(cell.detail, true)}${RESET}`;
+            return toolMode === 'expanded' ? `${head}\n${safe}` : head;
+        }
         case 'shell': return `${DIM}Shell${RESET}\n${safe}`;
         case 'compaction': return `${DIM}${accessible ? '[compacted]' : '↻'} ${safe}${RESET}`;
         case 'reasoning': return cell.collapsed
@@ -263,9 +268,11 @@ export function createRenderer(options) {
         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)) ?? [];
             return [
-                `${BOLD_CYAN}${announcement(plain(overlay.title), overlay.lines.length)}${RESET}`,
+                `${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));
         }

package/lib/session-runtime.d.ts

@@ -4,9 +4,13 @@ import type { TuiRoot } from './tui-root.js';
 export interface RootLaunchOptions {
     readonly continue: boolean;
     readonly cwd: string;
+    readonly effort?: string;
     readonly name?: string;
     readonly images?: readonly string[];
+    readonly model?: string;
+    readonly permission?: string;
     readonly prompt?: string;
+    readonly provider?: string;
     readonly resume?: string;
 }
 export interface SessionRuntime {

package/lib/session-runtime.js

@@ -1,14 +1,16 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionId, SessionSeq } from '@deepseek-ai/dsh-session';
 import { agentPresetOverlay, completionOptions, contextOverlay, currentModel, modelOverlay, permissionOverlay, searchOverlay, sessionOverlay, statusOverlay, } from './catalogs.js';
+import { diffOverlay } from './diff-view.js';
 import { eventsFromRecords } from './history-records.js';
 import { admitDraftImages, encodeDraftImages, readDraftImages } from './image-input.js';
 import { contextPercent, jobViews, subagentViews } from './presentation.js';
 import { humanPrompt, humanPrompts, inheritedTurn, rewindActionOverlay, rewindOverlay, } from './rewind.js';
 import { createToolPresenter } from './tool-presentation.js';
-import { runHumanShell } from './shell-command.js';
+import { quoteShellWord, runHumanShell } from './shell-command.js';
 import { markdownTranscript } from './session-export.js';
 import { isSessionId, sessionMatches, sessionNotFound } from './session-list.js';
+import { memoryOverlay } from './memory.js';
 import { foldCells, pendingShellCells } from './transcript.js';
 function detail(error) {
     return error instanceof Error ? error.message : String(error);
@@ -71,6 +73,17 @@ async function firstControl(iterator) {
 function usage(raw, expected) {
     return raw.trim() === '' ? undefined : { kind: 'error', text: `usage: ${expected}` };
 }
+function configValue(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function configLayer(value) {
+    return value === undefined ? '—' : JSON.stringify(value);
+}
 /** Create or resume the exact current root and own its replaceable terminal binding. */
 export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, decisions) {
     const lifetime = new AbortController();
@@ -491,6 +504,82 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     return { kind: 'success' };
                 },
             },
+            {
+                name: 'memory', description: 'Open an instruction file loaded by DSH',
+                handler: (invocation) => {
+                    const invalid = ensureCurrent(invocation) ?? usage(invocation.rawInput, '/memory');
+                    if (invalid !== undefined)
+                        return invalid;
+                    dispatch({ type: 'open-overlay', overlay: memoryOverlay(bound.agent) });
+                    return { kind: 'success' };
+                },
+            },
+            {
+                name: 'config', description: 'Show or update native DSH settings', input: { hint: '[NAMESPACE KEY=VALUE]' },
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    const raw = invocation.rawInput.trim();
+                    if (raw === '')
+                        return { kind: 'success', text: ctx.settings.describe({ redactSecrets: true }).map(item => `${String(item.ns)}\n  value: ${configLayer(item.value)}\n  base: ${configLayer(item.base)}\n  user: ${configLayer(item.user)}`).join('\n') };
+                    const match = /^(\S+)\s+([^\s=]+)=(.*)$/su.exec(raw);
+                    if (match?.[1] === undefined || match[2] === undefined || match[3] === undefined) {
+                        return { kind: 'error', text: 'usage: /config [NAMESPACE KEY=VALUE]' };
+                    }
+                    const value = configValue(match[3]);
+                    if (match[2].includes('.'))
+                        await ctx.settings.mutate(match[1], [{ op: 'set', path: match[2].split('.'), value }]);
+                    else
+                        await ctx.settings.update(match[1], { [match[2]]: value });
+                    return { kind: 'success', text: `updated ${match[1]}.${match[2]}` };
+                },
+            },
+            {
+                name: 'diff', description: 'Show working tree or last-turn file changes', input: { hint: '[turn]' }, handler: async (invocation) => {
+                    const invalid = ensureCurrent(invocation);
+                    if (invalid !== undefined)
+                        return invalid;
+                    const mode = invocation.rawInput.trim();
+                    if (mode !== '' && mode !== 'turn')
+                        return { kind: 'error', text: 'usage: /diff [turn]' };
+                    dispatch({ type: 'open-overlay', overlay: await diffOverlay(ctx, bound.agent, bound.presenter, mode, lifetime.signal) });
+                    return { kind: 'success' };
+                },
+            },
+            {
+                name: 'plugins', description: 'List the running profile plugins',
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    if (invocation.rawInput.trim() !== '')
+                        return { kind: 'error', text: 'usage: /plugins' };
+                    const servers = new Map();
+                    for (const entry of ctx.loader.entries())
+                        if (entry.options.name === '@deepseek-ai/dsh-mcp-client'
+                            && typeof entry.options.config?.serverName === 'string')
+                            servers.set(entry.id, entry.options.config.serverName);
+                    const snapshot = await ctx.get('pluginInventory').list();
+                    return { kind: 'success', text: snapshot.entries.map(entry => `${String(entry.entryId)} · ${entry.moduleName}${servers.has(String(entry.entryId)) ? ` · ${servers.get(String(entry.entryId))}` : ''} · ${entry.enabled ? 'enabled' : 'disabled'} · ${entry.fiberPhase ?? 'inactive'}`).join('\n') };
+                },
+            },
+            {
+                name: 'plugin', description: 'Run DSH profile plugin management', input: { hint: 'ARGS' },
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    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'));
+                    bound.agent.inject(message);
+                    await ctx.sessions.flush(bound.agent.session);
+                    publish(bound);
+                    return result.exitCode === 0 ? { kind: 'success' } : { kind: 'error', text: `dsh plugin exited ${String(result.exitCode ?? result.signal ?? 'without status')}` };
+                },
+            },
             {
                 name: 'new', description: 'Start a new session', input: { hint: '[--name TITLE]' },
                 handler: async (invocation) => {
@@ -775,6 +864,34 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
         await bound.controlPump;
     }
     await install(binding);
+    if (options.model !== undefined || options.effort !== undefined) {
+        const catalog = await ctx.sessionController.modelCatalog();
+        const currentSelection = currentModel(ctx, binding.agent) ?? catalog.default;
+        const model = options.model ?? currentSelection.model;
+        const candidates = catalog.groups.filter(group => group.models.some(item => item.id === model));
+        if (options.provider === undefined && candidates.length > 1) {
+            throw new Error(`model "${model}" is available from multiple providers: ${candidates.map(group => group.id).join(', ')}; pass --provider`);
+        }
+        const result = await ctx.sessionController.selectModel({
+            sessionId: binding.agent.id,
+            model,
+            provider: options.provider ?? candidates[0]?.id ?? currentSelection.provider,
+            ...(options.effort === undefined ? {} : { reasoningEffort: options.effort }),
+        });
+        const { effort: _previousEffort, ...root } = binding.root;
+        binding.root = {
+            ...root, model: result.selected.model, provider: result.selected.provider,
+            ...(result.selected.reasoningEffort === undefined ? {} : { effort: result.selected.reasoningEffort }),
+        };
+    }
+    if (options.permission !== undefined) {
+        const execution = await ctx.commands.execute(binding.agent, `/permission ${options.permission}`, [], lifetime.signal);
+        if (execution === undefined)
+            throw new Error('DSH supplied no /permission command');
+        if (execution.result.kind === 'error')
+            throw new Error(execution.result.text ?? 'permission change failed');
+        binding.root = { ...binding.root, permission: options.permission };
+    }
     tuiRoot.bind(binding.agent);
     const activate = async (value) => {
         try {
@@ -999,7 +1116,8 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     if (attachments.length > 0)
                         throw new Error('!command does not accept image attachments');
                     await bound.agent.runMaintenance(async (signal) => {
-                        bound.agent.inject(await runHumanShell(ctx, bound.agent, command, signal));
+                        const [message] = await runHumanShell(ctx, bound.agent, command, signal);
+                        bound.agent.inject(message);
                         await ctx.sessions.flush(bound.agent.session);
                     });
                     publish(bound);

package/lib/shell-command.d.ts

@@ -5,5 +5,6 @@ import type { ShellRunResult } from '@deepseek-ai/dsh-shell';
 export declare const HUMAN_SHELL_TIMEOUT_MS = 30000;
 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): Promise<UserMessage>;
+export declare function runHumanShell(ctx: Context, agent: Agent, command: string, signal: AbortSignal, success?: string): Promise<readonly [UserMessage, ShellRunResult]>;

package/lib/shell-command.js

@@ -1,4 +1,5 @@
 import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
 export const HUMAN_SHELL_TIMEOUT_MS = 30_000;
 export const HUMAN_SHELL_STREAM_BYTES = 32 * 1024;
 function tail(output) {
@@ -42,21 +43,23 @@ export function shellResultText(command, result) {
     }
     return parts.join('\n');
 }
+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) {
+export async function runHumanShell(ctx, agent, command, signal, success) {
     const result = await ctx.shell.run(ctx.shell.resolve({
         command,
+        env: { DSH_HOME: resolveDshHome() },
         sandboxPolicy: ctx.sandboxPolicy.resolve({ session: agent.session }),
         signal,
         stdoutMaxBytes: HUMAN_SHELL_STREAM_BYTES,
         timeoutMs: HUMAN_SHELL_TIMEOUT_MS,
         workdir: agent.session.header.cwd,
     }));
-    return createUserMessage({
-        content: [{ type: 'text', text: shellResultText(command, result) }],
-        source: {
-            form: 'notice', kind: 'plugin', plugin: 'dashi',
-            summary: boundContextSummary(`Shell: ${command.replace(/\s+/gu, ' ').trim()}`),
-        },
-    });
+    return [createUserMessage({
+            content: [{ type: 'text', text: shellResultText(command, result) + (result.exitCode === 0 && success ? `\n${success}` : '') }],
+            source: {
+                form: 'notice', kind: 'plugin', plugin: 'dashi',
+                summary: boundContextSummary(`Shell: ${command.replace(/\s+/gu, ' ').trim()}`),
+            },
+        }), result];
 }

package/lib/state.d.ts

@@ -137,6 +137,9 @@ export type OverlayValue = {
     readonly effort?: string;
     readonly model: string;
     readonly provider: string;
+} | {
+    readonly kind: 'open-file';
+    readonly path: string;
 } | {
     readonly interrupt?: true;
     readonly kind: 'fork';
@@ -197,9 +200,10 @@ export type Overlay = {
     readonly kind: 'list';
     readonly notice?: string;
     readonly options: readonly OverlayOption[];
-    readonly purpose: 'agents' | 'completion' | 'model' | 'permission' | 'resume' | 'rewind' | 'rewind-action' | 'search';
+    readonly purpose: 'agents' | 'completion' | 'memory' | 'model' | 'permission' | 'resume' | 'rewind' | 'rewind-action' | 'search';
     readonly title: string;
 } | {
+    readonly cells?: readonly TerminalCell[];
     readonly kind: 'info';
     readonly lines: readonly string[];
     readonly title: string;

package/lib/state.js

@@ -1,3 +1,4 @@
+import { FLAG_HELP, VERSION_LINE } from './help.js';
 export function initialViewState(cwd, inline, root, cells = [], prompts = [], historyHasMore = false, attachments = []) {
     return {
         attachments, cells, composer: '', cwd, decisions: [], exitArmed: false, historyHasMore, inline,
@@ -31,6 +32,7 @@ function help() {
         kind: 'info',
         title: 'Help',
         lines: [
+            VERSION_LINE,
             'Enter send · Ctrl+J newline · Ctrl+T steer/next turn',
             'Esc interrupt · Ctrl+C clear/interrupt · Ctrl+C/D again within 2s to exit',
             '/ and @ complete live · Tab insert · Shift+Tab permission · Ctrl+O cards',
@@ -39,8 +41,9 @@ 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 /resume [--all] [NAME|UUID] /fork /rewind /rename /model /permission /agents /queue · launch -r/-c',
-            '/status /context /tasks /history /export /copy /exit',
+            '/new /clear /resume [--all] [NAME|UUID] /fork /rewind /rename /model /permission /agents /queue',
+            '/status /context /memory /config /diff /plugins /plugin /tasks /history /export /copy /exit',
+            ...FLAG_HELP,
         ],
     };
 }

package/lib/transcript.js

@@ -26,6 +26,24 @@ function shellCell(message, pending) {
         key: `shell:${String(message.id)}`, kind: 'shell', pending, text: messageText(message.content),
     };
 }
+function collapsedContextCell(message, key) {
+    const source = message.source;
+    const form = source.form;
+    if (source.kind !== 'agent-instructions'
+        && (source.kind !== 'plugin' || !['instructions', 'catalog', 'snapshot', 'notice', 'recall'].includes(String(form)))) {
+        return undefined;
+    }
+    const text = messageText(message.content);
+    const lines = text.split(/\r?\n/u);
+    const first = form === 'notice' && typeof source.summary === 'string' ? source.summary : lines[0] ?? '';
+    return {
+        collapsed: true,
+        detail: `${String(form)} · ${first.trim()} · ${String(lines.length)} lines`,
+        key,
+        kind: 'context',
+        text,
+    };
+}
 /** Project DSH-owned pending injections beside the durable transcript. */
 export function pendingShellCells(messages) {
     return messages.filter(isDashiShell).map(message => shellCell(message, true));
@@ -132,9 +150,10 @@ export function foldCells(events, presenter = createToolPresenter(() => undefine
                     break;
                 }
                 const text = messageText(event.data.content);
+                const context = collapsedContextCell(event.data, `${event.seq}:context`);
                 cells.push(isDashiShell(event.data)
                     ? shellCell(event.data, false)
-                    : {
+                    : context ?? {
                         key: `${event.seq}:user`,
                         kind: event.data.source.kind === 'user' ? 'user' : 'context',
                         text,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antst/dashi",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.8",
   "description": "A terminal UI for DeepSeek Harness",
   "publishConfig": {
     "access": "public"
@@ -37,7 +37,9 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/cordis-plugin-loader": "1.0.3",
     "@deepseek-ai/dsh-agent": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.2-rc.1",
     "@deepseek-ai/dsh-agent-presets": "0.1.2-rc.1",
     "@deepseek-ai/dsh-api-session-controller": "0.1.2-rc.1",
     "@deepseek-ai/dsh-attachment": "0.1.2-rc.1",
@@ -46,6 +48,8 @@
     "@deepseek-ai/dsh-compaction": "0.1.2-rc.1",
     "@deepseek-ai/dsh-file-reference": "0.1.2-rc.1",
     "@deepseek-ai/dsh-fs": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-home-paths": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-host-plugin-inventory": "0.1.2-rc.1",
     "@deepseek-ai/dsh-llm": "0.1.2-rc.1",
     "@deepseek-ai/dsh-permission-presets": "0.1.2-rc.1",
     "@deepseek-ai/dsh-plan-mode": "0.1.2-rc.1",
@@ -53,6 +57,7 @@
     "@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-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",