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

package/lib/application.d.ts

@@ -20,6 +20,7 @@ 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>;

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

package/lib/catalogs.d.ts

@@ -18,6 +18,8 @@ export declare function permissionOverlay(ctx: Context, agent: Agent): Overlay;
 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,9 @@ 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';
+}
 /** 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 +199,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,6 +292,7 @@ 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(),

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 {
 }

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, 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);
 }
@@ -82,6 +83,16 @@ async function firstControl(iterator) {
 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 +125,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;
@@ -149,7 +168,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 agent,
                 controlIterator,
                 cursor: opening.cursor,
-                disposers: disposeRestriction === undefined ? [] : [disposeRestriction],
+                disposers,
                 events: eventsFromRecords(opening.records),
                 hasMore: opening.hasMore,
                 iterator,
@@ -511,6 +530,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 +643,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 +773,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 +781,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 +895,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),

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

@@ -333,6 +333,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[];
@@ -503,6 +506,6 @@ 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 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,
         ],
     };
@@ -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, []];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antst/dashi",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.11",
   "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",