@antst/dashi 0.1.0-alpha.8 → 0.1.0

package/lib/session-runtime.js

@@ -1,17 +1,28 @@
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+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, 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, 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);
 }
@@ -50,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;
@@ -70,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);
@@ -91,11 +140,13 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
     let started = false;
     let shutdown;
     let decisionSequence = 0;
-    const initialId = options.resume === undefined
+    let initialId = options.resume === undefined
         ? options.continue
             ? continuation((await ctx.sessionController.list({}, lifetime.signal)).items, options.cwd)
-            : (await ctx.sessionController.create({ cwd: options.cwd })).sessionId
+            : (await ctx.sessionController.create({ cwd: options.cwd, ...(options.agentPreset === undefined ? {} : { agentPreset: options.agentPreset }), ...(options.sessionId === undefined ? {} : { sessionId: SessionId(options.sessionId) }) })).sessionId
         : SessionId(options.resume);
+    if (options.forkSession)
+        initialId = (await ctx.sessionController.fork({ sessionId: initialId })).sessionId;
     const prepare = async (sessionId, name) => {
         const abort = new AbortController();
         try {
@@ -103,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);
@@ -124,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,
@@ -164,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;
@@ -191,8 +265,18 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
             signal?.removeEventListener('abort', abortDecision);
         });
     };
+    const authorizationPrompt = (bound, prompt, detail) => decide({
+        answers: [], cursor: 0, custom: '', id: `authorization:${String(++decisionSequence)}`, index: 0, kind: 'question', owner: { id: bound.root.id, ...(bound.root.title === undefined ? {} : { label: bound.root.title }) }, selected: [],
+        questions: [{ allowCustom: prompt.kind !== 'select', ...(detail === undefined ? {} : { detail }), header: 'Login', id: 'authorization', multiSelect: false, options: prompt.kind === 'select' ? prompt.options : [], question: prompt.message, secret: prompt.kind === 'secret' }],
+    }, prompt.signal).then(result => prompt.kind === 'select' ? prompt.options[prompt.options.findIndex(option => option.label === result.answers[0]?.selected[0])]?.id ?? ''
+        : result.answers[0]?.custom ?? '').catch(error => {
+        if (prompt.signal?.aborted !== true && error.code === 'ASK_ABORTED')
+            throw new AuthorizationDeclinedError();
+        throw error;
+    });
     const transcriptCells = (bound) => [
         ...foldCells(bound.events, bound.presenter, { truncatedStart: bound.hasMore }),
+        ...bound.streamCells,
         ...pendingShellCells(bound.agent.inbox.nextStep),
     ];
     const publish = (bound) => {
@@ -224,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({
@@ -254,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);
@@ -333,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);
@@ -374,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;
@@ -432,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;
@@ -464,7 +570,100 @@ 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' };
-        return [
+        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',
                 handler: (invocation) => {
@@ -504,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) => {
@@ -514,6 +723,20 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     return { kind: 'success' };
                 },
             },
+            {
+                name: 'skills', description: 'List skills resolved for this session', input: { hint: '[TEXT]' },
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    const overlay = await skillOverlay(ctx, bound.agent, invocation.rawInput, invocation.signal);
+                    const replaced = ensureCurrent(invocation);
+                    if (replaced !== undefined)
+                        return replaced;
+                    dispatch({ type: 'open-overlay', overlay });
+                    return { kind: 'success' };
+                },
+            },
             {
                 name: 'config', description: 'Show or update native DSH settings', input: { hint: '[NAMESPACE KEY=VALUE]' },
                 handler: async (invocation) => {
@@ -535,6 +758,43 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     return { kind: 'success', text: `updated ${match[1]}.${match[2]}` };
                 },
             },
+            { name: 'login', description: 'List or start provider sign-in', input: { hint: '[KEY [METHOD]]' },
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    const values = invocation.rawInput.trim().split(/\s+/u).filter(Boolean);
+                    if (values.length === 0)
+                        return { kind: 'success', text: ctx.authorization.list().map(entry => `${String(entry.key)} · ${entry.label} · ${entry.methods.map(method => `${method.id}: ${method.label}`).join(', ')}${entry.inFlight ? ' · in progress' : ''}`).join('\n') || 'no authorization flows' };
+                    if (values.length > 2)
+                        return { kind: 'error', text: 'usage: /login [KEY [METHOD]]' };
+                    const entry = ctx.authorization.describe(parseCredentialKey(values[0]));
+                    if (entry === undefined)
+                        return { kind: 'error', text: `no authorization flow for ${values[0]}` };
+                    const notices = [];
+                    const outcome = await ctx.authorization.begin({ key: entry.key, ...(values[1] === undefined ? {} : { method: values[1] }), signal: invocation.signal,
+                        interaction: { notify: notice => {
+                                notices.push(notice.message, ...(notice.url === undefined ? [] : [notice.url]), ...(notice.code === undefined ? [] : [`Code: ${notice.code}`]));
+                                dispatch({ type: 'open-overlay', overlay: { kind: 'info', title: 'Login', lines: notices } });
+                            }, prompt: prompt => authorizationPrompt(bound, prompt, notices.join('\n')) },
+                    }).finally(() => { dispatch({ type: 'overlay-close' }); });
+                    return { kind: 'success', text: outcome.status === 'authorized' ? `signed in to ${entry.label}` : 'login cancelled' };
+                },
+            },
+            { name: 'logout', description: 'List or forget provider credentials', input: { hint: '[KEY]' },
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    const raw = invocation.rawInput.trim();
+                    if (raw === '')
+                        return { kind: 'success', text: (await ctx.credentials.listRecords()).map(record => `${String(record.key)} · ${record.kind}`).join('\n') || 'no stored credentials' };
+                    if (/\s/u.test(raw))
+                        return { kind: 'error', text: 'usage: /logout [KEY]' };
+                    await ctx.credentials.deleteRecord(parseCredentialKey(raw));
+                    return { kind: 'success', text: `signed out ${raw}` };
+                },
+            },
             {
                 name: 'diff', description: 'Show working tree or last-turn file changes', input: { hint: '[turn]' }, handler: async (invocation) => {
                     const invalid = ensureCurrent(invocation);
@@ -573,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);
@@ -581,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' };
                 },
@@ -664,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),
@@ -717,15 +1024,17 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 },
             },
             {
-                name: 'copy', description: 'Copy the latest completed assistant response',
+                name: 'copy', description: 'Copy an assistant response or code block', input: { hint: '[N|code]' },
                 handler: (invocation) => {
                     const stale = ensureCurrent(invocation);
                     if (stale !== undefined)
                         return stale;
-                    const invalid = usage(invocation.rawInput, '/copy');
-                    if (invalid !== undefined)
-                        return invalid;
-                    dispatch({ type: 'copy-latest' });
+                    const raw = invocation.rawInput.trim();
+                    const selection = raw === '' ? 1 : raw === 'code' ? 'code' : Number(raw);
+                    if (raw !== '' && selection !== 'code' && (!/^[1-9]\d*$/u.test(raw) || !Number.isSafeInteger(selection))) {
+                        return { kind: 'error', text: 'usage: /copy [N|code]' };
+                    }
+                    dispatch({ selection, type: 'copy-assistant' });
                     return { kind: 'success' };
                 },
             },
@@ -758,6 +1067,32 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     return { kind: 'success' };
                 },
             },
+            {
+                name: 'init', description: 'Create a starter AGENTS.md',
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    const invalid = usage(invocation.rawInput, '/init');
+                    if (invalid !== undefined)
+                        return invalid;
+                    const target = await ctx.fs.resolve('AGENTS.md', { cwd: bound.root.cwd, signal: lifetime.signal });
+                    await ctx.fs.writeText(target, starterAgents(bound.root.cwd), { kind: 'createIfAbsent' }, lifetime.signal, ctx.sandboxPolicy.resolve({ session: bound.agent.session }));
+                    return { kind: 'success', text: `created ${ctx.fs.processPath(target)}` };
+                },
+            },
+            {
+                name: 'effort', description: 'Select the reasoning effort', input: { hint: 'LEVEL' },
+                handler: async (invocation) => {
+                    const invalid = ensureCurrent(invocation);
+                    const effort = invocation.rawInput.trim();
+                    if (invalid !== undefined || effort === '')
+                        return invalid ?? { kind: 'error', text: 'usage: /effort LEVEL' };
+                    const selected = currentModel(ctx, bound.agent) ?? (await ctx.sessionController.modelCatalog()).default;
+                    await activate({ kind: 'model', effort, model: selected.model, provider: selected.provider });
+                    return { kind: 'success' };
+                },
+            },
             {
                 ...nativePermission,
                 handler: async (invocation) => {
@@ -798,6 +1133,8 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                 },
             },
         ];
+        return [...definitions, ...[['quit', 'exit'], ['reset', 'clear'], ['continue', 'resume'], ['branch', 'fork']]
+                .map(([name, target]) => ({ ...definitions.find(definition => definition.name === target), name }))];
     };
     async function install(bound) {
         const id = bound.root.id;
@@ -933,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,
@@ -970,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) {
@@ -1120,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;
                 }