@antst/dashi 0.1.0-alpha.9 → 0.1.1

package/lib/session-runtime.js

@@ -1,23 +1,28 @@
 import { basename } from 'node:path';
 import { AuthorizationDeclinedError } from '@deepseek-ai/dsh-authorization';
 import { parseCredentialKey } from '@deepseek-ai/dsh-credentials';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { JobId } from '@deepseek-ai/dsh-jobs';
+import { createUserMessage, ToolCallId } from '@deepseek-ai/dsh-llm';
+import { expandAssistantStream } from '@deepseek-ai/dsh-llm/assistant-stream';
 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';
 import { contextPercent, jobViews, subagentViews } from './presentation.js';
-import { humanPrompt, humanPrompts, inheritedTurn, rewindActionOverlay, rewindOverlay, } from './rewind.js';
+import { historyInput, historyInputs, humanPrompt, inheritedTurn, latestCompletedTurn, rewindActionOverlay, rewindOverlay, rewindModelSelection, } from './rewind.js';
 import { createToolPresenter } from './tool-presentation.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';
+import { foldAssistantStream, foldCells, pendingShellCells } from './transcript.js';
+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);
 }
@@ -56,6 +61,20 @@ function turnStartTime(events, turn) {
             return event.time;
     }
 }
+function latestStep(events) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        if (event?.type === 'step/start')
+            return event;
+    }
+}
+function openingStream(baseline) {
+    const attempt = baseline?.activeAttempt;
+    if (attempt === undefined)
+        return [];
+    return expandAssistantStream(attempt.stream).slice(0, attempt.nextIndex)
+        .reduce((cells, member) => foldAssistantStream(cells, attempt.turn, attempt.step, member.chunk), []);
+}
 function titleFromEvent(event) {
     if (String(event.type) !== 'session/title')
         return undefined;
@@ -76,9 +95,33 @@ async function firstControl(iterator) {
     }
     return first.value;
 }
+async function gitRepo(ctx, agent, signal) {
+    const fallback = basename(agent.session.header.cwd ?? '');
+    try {
+        const result = await ctx.shell.run(ctx.shell.resolve({
+            command: 'git rev-parse --show-toplevel && git branch --show-current', sandboxPolicy: ctx.sandboxPolicy.resolve({ mode: 'read-only' }),
+            signal, stdoutMaxBytes: 1_024, timeoutMs: 2_000, workdir: agent.session.header.cwd,
+        }));
+        const [root, branch] = result.stdout.text.trim().split(/\r?\n/u);
+        return result.exitCode === 0 && root !== undefined && branch !== undefined ? `${basename(root)}/${branch}` : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
 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);
@@ -111,16 +154,37 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             if ('error' in resolved)
                 throw resolved.error;
             const agent = resolved.agent;
+            const disposers = [];
+            if (options.tools !== undefined || options.disallowedTools !== undefined) {
+                try {
+                    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;
             await ctx.sessions.flush(agent.session);
             const iterator = ctx.sessionController.follow({
-                address: { kind: 'session', sessionId }, maxMessages: 50,
+                address: { kind: 'session', sessionId }, assistantStream: true, 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, repo] = await Promise.all([
                 firstSnapshot(iterator), firstControl(controlIterator), subagentViews(ctx, sessionId, abort.signal),
+                gitRepo(ctx, agent, abort.signal),
             ]);
             title ??= projectionString(opening.projections, 'title');
             const selected = projectionModel(opening.projections);
@@ -132,14 +196,16 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             return {
                 abort,
                 agent,
+                repo,
                 controlIterator,
                 cursor: opening.cursor,
-                disposers: [],
+                disposers,
                 events: eventsFromRecords(opening.records),
                 hasMore: opening.hasMore,
                 iterator,
                 presenter: createToolPresenter(tool => ctx.tools.get(tool, agent)),
                 presentationTimer: undefined,
+                streamCells: openingStream(opening.assistantStream),
                 root: {
                     ...(initialContextPercent === undefined ? {} : { contextPercent: initialContextPercent }),
                     cwd: opening.header.cwd ?? options.cwd,
@@ -172,7 +238,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
     };
     const executeAccepted = async (bound, line, images, onSettled) => {
         const from = bound.agent.session.seq;
-        const execution = ctx.commands.execute(bound.agent, line, images, lifetime.signal);
+        const execution = ctx.commands.execute(bound.agent, line, images.map(image => ({ type: 'image', ...image })), lifetime.signal);
         const accepted = bound.agent.session.snapshotEvents(from).some(event => event.type === 'command/run');
         if (!accepted) {
             const result = await execution;
@@ -210,6 +276,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
     });
     const transcriptCells = (bound) => [
         ...foldCells(bound.events, bound.presenter, { truncatedStart: bound.hasMore }),
+        ...bound.streamCells,
         ...pendingShellCells(bound.agent.inbox.nextStep),
     ];
     const publish = (bound) => {
@@ -241,12 +308,35 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             });
         }, 34);
     };
+    const refreshRepo = async (bound) => {
+        const repo = await gitRepo(ctx, bound.agent, bound.abort.signal);
+        if (bound.abort.signal.aborted || current() !== bound || bound.repo === repo)
+            return;
+        bound.repo = repo;
+        dispatch({ type: 'redraw' });
+    };
     const consume = (bound, frame) => {
+        if (frame.type === 'assistant-stream') {
+            if (frame.frame.type !== 'chunk') {
+                bound.streamCells = [];
+                schedule(bound);
+                return;
+            }
+            const step = latestStep(bound.events);
+            if (step === undefined)
+                return;
+            bound.streamCells = foldAssistantStream(bound.streamCells, step.data.turn, step.data.step, frame.frame.chunk);
+            schedule(bound);
+            return;
+        }
         const [event] = eventsFromRecords([frame]);
         if (event === undefined)
             return;
         bound.events.push(event);
+        if (event.type === 'assistant/message' || event.type === 'assistant/attempt')
+            bound.streamCells = [];
         if (event.type === 'turn/end') {
+            void refreshRepo(bound);
             const startedAt = turnStartTime(bound.events, event.data.turn);
             if (startedAt !== undefined) {
                 dispatch({
@@ -271,7 +361,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 ...(model.reasoningEffort === undefined ? {} : { effort: model.reasoningEffort }),
             });
         }
-        const prompt = humanPrompt(event);
+        const prompt = event.type === 'agent/inbox/spliced' ? undefined : historyInput(event);
         if (prompt !== undefined)
             dispatch({ type: 'prompt-recorded', rootId: bound.root.id, text: prompt });
         schedule(bound);
@@ -350,7 +440,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
         tuiRoot.bind(candidate.agent);
         dispatch({
             type: 'root-bound', cells: transcriptCells(candidate),
-            hasMore: candidate.hasMore, prompts: humanPrompts(candidate.events), root: candidate.root,
+            hasMore: candidate.hasMore, prompts: historyInputs(candidate.events), root: candidate.root,
         });
         if (started) {
             candidate.pump = follow(candidate);
@@ -391,13 +481,12 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             ?? ctx.agentPresets.defaultId;
         const modelProjection = ctx.sessionProjections.snapshot(bound.agent.session, ['modelSelection'])
             .values.modelSelection;
-        const selection = modelProjection?.next ?? modelProjection?.lastUsed ?? undefined;
+        const selection = rewindModelSelection(modelProjection);
         const created = await ctx.sessionController.create({ cwd: bound.root.cwd, agentPreset });
         let selectionFailure;
         try {
-            if (selection === undefined)
-                throw new Error('the current session has no durable model selection');
-            await ctx.sessionController.selectModel({ sessionId: created.sessionId, ...selection });
+            if (selection !== undefined)
+                await ctx.sessionController.selectModel({ sessionId: created.sessionId, ...selection });
         }
         catch (error) {
             selectionFailure = error;
@@ -449,7 +538,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 const roller = ctx.commands.list(bound.agent).some(command => command.name === 'roller-restore');
                 const overlay = rewindOverlay(bound.agent.session.snapshotEvents(), roller);
                 if (overlay.kind !== 'list' || overlay.options.length === 0) {
-                    throw new Error('the current session has no human prompt to rewind');
+                    throw new Error('the current session has no input to rewind');
                 }
                 dispatch({ type: 'open-overlay', overlay });
                 return;
@@ -481,6 +570,99 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
         if (nativePermission === undefined)
             throw new Error('dashi: DSH supplied no /permission command');
         const ensureCurrent = (invocation) => current().agent === invocation.agent ? undefined : { kind: 'error', text: 'this root is no longer current' };
+        const tasks = (invocation) => {
+            const stale = ensureCurrent(invocation);
+            if (stale !== undefined)
+                return stale;
+            const raw = invocation.rawInput.trim();
+            if (raw === '') {
+                dispatch({ type: 'open-details' });
+                return { kind: 'success' };
+            }
+            const match = /^kill\s+(\S+)$/u.exec(raw);
+            if (match?.[1] === undefined)
+                return { kind: 'error', text: 'usage: /tasks [kill ID]' };
+            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' };
+            if (bound.agent.status !== 'idle')
+                return { kind: 'error', text: 'finish or interrupt the turn first' };
+            const boundary = latestCompletedTurn(bound.agent.session.snapshotEvents());
+            if (boundary.atSeq === undefined)
+                throw new Error('the current session has no completed turn to fork');
+            const forked = await ctx.sessionController.fork({ atSeq: boundary.atSeq, 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 === 'event' && 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)}${boundary.open ? ' · trailing turn open' : ''}`,
+                } });
+            return { kind: 'success' };
+        };
         const definitions = [
             {
                 name: 'help', description: 'Show keyboard and command help',
@@ -521,6 +703,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) => {
@@ -641,7 +833,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, 'bundles load on the next launch; plain plugins need a patch row', false));
                     bound.agent.inject(message);
                     await ctx.sessions.flush(bound.agent.session);
                     publish(bound);
@@ -649,29 +841,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' };
                 },
@@ -732,30 +930,71 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 },
             },
             {
-                name: 'tasks', description: 'Show jobs and subagents',
-                handler: (invocation) => {
+                name: 'tasks', description: 'Show jobs and subagents, or kill a job', input: { hint: '[kill ID]' },
+                handler: tasks,
+            },
+            {
+                name: 'bashes', description: 'Alias of /tasks', input: { hint: '[kill ID]' },
+                handler: tasks,
+            },
+            {
+                name: 'subtask', description: 'Start a continuable child', input: { hint: 'TEXT' },
+                handler: async (invocation) => {
                     const stale = ensureCurrent(invocation);
                     if (stale !== undefined)
                         return stale;
-                    const invalid = usage(invocation.rawInput, '/tasks');
-                    if (invalid !== undefined)
-                        return invalid;
-                    dispatch({ type: 'open-details' });
-                    return { kind: 'success' };
+                    const text = invocation.rawInput.trim();
+                    if (text === '')
+                        return { kind: 'error', text: 'usage: /subtask TEXT' };
+                    const started = await ctx.subagents.startContinuable({
+                        label: text, provider: 'spawn',
+                        request: { parent: bound.agent, prompt: [{ type: 'text', text }] },
+                        signal: invocation.signal,
+                    });
+                    return { kind: 'success', text: `subtask ${String(started.childId)} started` };
                 },
             },
             {
-                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),
@@ -1031,6 +1270,14 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     }
                     break;
                 }
+                case 'job-output': {
+                    const result = ctx.jobs.read(JobId(value.jobId), bound.agent);
+                    dispatch({ type: 'open-overlay', overlay: {
+                            cells: [{ key: `job:${value.jobId}`, kind: 'outcome', text: result.text }],
+                            kind: 'info', lines: [], title: `Job ${value.jobId} · ${result.snapshot.status}`,
+                        } });
+                    break;
+                }
                 case 'model': {
                     const result = await ctx.sessionController.selectModel({
                         sessionId: bound.agent.id, model: value.model, provider: value.provider,
@@ -1068,8 +1315,9 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
         initialAttachments,
         get initialCells() { return transcriptCells(current()); },
         get initialHasMore() { return current().hasMore; },
-        get initialPrompts() { return humanPrompts(current().events); },
+        get initialPrompts() { return historyInputs(current().events); },
         get root() { return current().root; },
+        get statusLine() { const bound = current(); return sessionStatusLine(ctx, bound.agent, bound.root, bound.repo); },
         get summary() { return `Resume with: dsh --profile dashi --resume ${current().root.id}`; },
         activate,
         async attach(path) {
@@ -1218,6 +1466,7 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                         bound.agent.inject(message);
                         await ctx.sessions.flush(bound.agent.session);
                     });
+                    dispatch({ type: 'prompt-recorded', rootId: bound.root.id, text: `!${command}` });
                     publish(bound);
                     return;
                 }

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

@@ -137,6 +137,9 @@ export type OverlayValue = {
 } | {
     readonly kind: 'insert';
     readonly text: string;
+} | {
+    readonly jobId: string;
+    readonly kind: 'job-output';
 } | {
     readonly kind: 'model';
     readonly effort?: string;
@@ -213,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;
@@ -268,6 +272,9 @@ export type UiAction = {
     readonly source?: string;
     readonly text?: string;
     readonly type: 'attachment-added';
+} | {
+    readonly path: string;
+    readonly type: 'attachment-path';
 } | {
     readonly index: number;
     readonly type: 'attachment-remove';
@@ -330,6 +337,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[];
@@ -340,6 +350,7 @@ export type UiAction = {
 } | {
     readonly type: 'overlay-close';
 } | {
+    readonly limit?: number;
     readonly type: 'overlay-move';
     readonly offset: number;
 } | {
@@ -500,6 +511,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[]];