@antst/dashi 0.1.0-alpha.7 → 0.1.0-alpha.9

package/lib/application.js

@@ -1,4 +1,5 @@
 import { createRenderer } from './renderer.js';
+import { runEditor } from './external-editor.js';
 import { initialViewState, reduce, } from './state.js';
 import { createTerminalGuard } from './terminal-guard.js';
 function suspendProcess() {
@@ -44,7 +45,14 @@ export function createTerminalShell(options) {
     async function run(effect) {
         switch (effect.type) {
             case 'activate-overlay':
-                await options.activateOverlay?.(effect.value);
+                if (effect.value.kind === 'open-file') {
+                    const path = effect.value.path;
+                    await guard.withCookedTerminal(() => runEditor(process.env.EDITOR?.trim() || 'vi', path, options.cwd)).catch(error => {
+                        dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                    });
+                }
+                else
+                    await options.activateOverlay?.(effect.value);
                 return;
             case 'attach': {
                 try {
@@ -168,6 +176,7 @@ export function createTerminalShell(options) {
             return;
         failed = true;
         accepting = false;
+        renderer.discardSecretComposer();
         const detail = error instanceof Error ? error.stack ?? error.message : String(error);
         writeError(`dashi: terminal failure\n${detail}\n`);
         try {
@@ -193,6 +202,9 @@ export function createTerminalShell(options) {
     function dispatch(action) {
         if (!accepting)
             return;
+        const question = state.decisions[0]?.kind === 'question' ? state.decisions[0].questions[state.decisions[0].index] : undefined;
+        if (question?.secret === true && ['decision-submit', 'decision-cancel', 'decision-withdrawn', 'escape', 'terminal-lost'].includes(action.type))
+            renderer.discardSecretComposer();
         const [next, effects] = reduce(state, action);
         state = next;
         if (effects.length === 0)
@@ -216,6 +228,7 @@ export function createTerminalShell(options) {
         },
         dispatch,
         async dispose() {
+            renderer.discardSecretComposer();
             const [next, effects] = reduce(state, { type: 'terminal-lost' });
             state = next;
             for (const effect of effects)

package/lib/catalogs.d.ts

@@ -6,6 +6,8 @@ import type { SessionSearchHit } from '@deepseek-ai/dsh-session-query';
 import type { Overlay, OverlayOption, RootView } from './state.js';
 /** Build command and skill completion rows for one exact root. */
 export declare function completionOptions(ctx: Context, agent: Agent, input: string, caret?: number, signal?: AbortSignal): Promise<readonly OverlayOption[]>;
+/** Build a filtered view of the skills resolved for one live session. */
+export declare function skillOverlay(ctx: Context, agent: Agent, filter: string, signal?: AbortSignal): Promise<Overlay>;
 /** Build the cold session picker without adopting any candidate. */
 export declare function sessionOverlay(items: readonly SessionSummary[], currentId: string, cwd?: string): Overlay;
 /** Flatten DSH's provider/model/effort catalog into one terminal picker. */

package/lib/catalogs.js

@@ -69,6 +69,23 @@ export async function completionOptions(ctx, agent, input, caret = input.length,
     }));
     return [...commands, ...skills];
 }
+/** Build a filtered view of the skills resolved for one live session. */
+export async function skillOverlay(ctx, agent, filter, signal) {
+    const lookup = { cwd: agent.session.header.cwd, scope: agent, signal };
+    const needle = filter.trim().toLocaleLowerCase();
+    const skills = (await ctx.skills.list(lookup)).filter(skill => needle === ''
+        || skill.name.toLocaleLowerCase().includes(needle)
+        || skill.description.toLocaleLowerCase().includes(needle));
+    const definitions = await Promise.all(skills.map(skill => ctx.skills.get(skill.name, lookup)));
+    return {
+        cursor: 0, kind: 'list', purpose: 'skills', title: needle === '' ? 'Skills' : `Skills · ${filter.trim()}`,
+        options: skills.map((skill, index) => ({
+            detail: `${skill.description} · user ${skill.invocation.userInvocable ? 'yes' : 'no'} · model ${skill.invocation.modelInvocable ? 'yes' : 'no'} · source ${skill.source} · provider ${skill.provider} · path ${definitions[index]?.path ?? 'unavailable'}`,
+            label: `/${skill.name}`,
+            value: { kind: 'insert', text: `/${skill.name} ` },
+        })),
+    };
+}
 /** Build the cold session picker without adopting any candidate. */
 export function sessionOverlay(items, currentId, cwd) {
     return {

package/lib/diff-view.d.ts

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

package/lib/diff-view.js

@@ -0,0 +1,24 @@
+import { HUMAN_SHELL_STREAM_BYTES } from './shell-command.js';
+import { boundedBody } from './tool-presentation.js';
+import { foldCells } from './transcript.js';
+export async function diffOverlay(ctx, agent, presenter, mode, signal) {
+    if (mode === 'turn') {
+        const events = agent.session.snapshotEvents();
+        const start = events.map(event => event.type).lastIndexOf('turn/start');
+        const cells = (start < 0 ? [] : foldCells(events.slice(start), presenter)).filter(cell => cell.pending !== true && cell.tool?.card === 'diff' && (cell.tool.diffs?.length ?? 0) > 0);
+        return { cells, kind: 'info', lines: cells.length === 0 ? ['No write/edit changes in the last turn.'] : [], title: 'Last turn diff' };
+    }
+    const command = 'git diff --no-ext-diff --no-color HEAD --';
+    const result = await ctx.shell.run(ctx.shell.resolve({
+        command, sandboxPolicy: ctx.sandboxPolicy.resolve({ session: agent.session }), signal,
+        stdoutMaxBytes: HUMAN_SHELL_STREAM_BYTES, timeoutMs: 30_000, workdir: agent.session.header.cwd,
+    }));
+    const output = [result.stdout.text, result.stderr.text].filter(Boolean).join('\n');
+    const cell = {
+        key: 'diff:working', kind: result.exitCode === 0 ? 'tool' : 'error', text: 'git diff',
+        tool: { card: 'terminal', title: 'git diff', status: result.exitCode === 0 ? output === '' ? 'clean' : 'changed'
+                : result.exitCode === null ? result.signal ?? 'failed' : `exit ${String(result.exitCode)}`,
+            ...(output === '' ? {} : { body: boundedBody(output) }) },
+    };
+    return { cells: [cell], kind: 'info', lines: [], title: 'Working tree diff' };
+}

package/lib/external-editor.d.ts

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

package/lib/external-editor.js

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

package/lib/help.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION_LINE: string;
+export declare const FLAG_HELP: readonly ["Launch flags: --inline | --fullscreen · --accessible · -r, --resume [NAME|UUID] · -c, --continue · --fork-session · --all", "  -n, --name TITLE · --agent PRESET · --session-id UUID · --model ID [--provider ID] · --effort LEVEL", "  --permission PRESET · --yolo | --dangerously-skip-permissions · --image PATH · -h, --help"];

package/lib/help.js

@@ -0,0 +1,6 @@
+import dashi from '../package.json' with { type: 'json' };
+import dsh from '@deepseek-ai/dsh-cmdline/package.json' with { type: 'json' };
+export const VERSION_LINE = `dashi ${dashi.version} on DSH ${dsh.version}`;
+export const FLAG_HELP = [
+    'Launch flags: --inline | --fullscreen · --accessible · -r, --resume [NAME|UUID] · -c, --continue · --fork-session · --all', '  -n, --name TITLE · --agent PRESET · --session-id UUID · --model ID [--provider ID] · --effort LEVEL', '  --permission PRESET · --yolo | --dangerously-skip-permissions · --image PATH · -h, --help'
+];

package/lib/index.js

@@ -6,17 +6,20 @@ import { createTerminalShell } from './application.js';
 import { sessionOverlay } from './catalogs.js';
 import { readClipboardImage } from './clipboard-image.js';
 import { editDraftExternally } from './external-editor.js';
+import { FLAG_HELP, VERSION_LINE } from './help.js';
 import { formatSessionList, isSessionId, parseSessionListArgs, sessionMatches, sessionNotFound, } from './session-list.js';
 import { createSessionRuntime } from './session-runtime.js';
 import { TuiRoot } from './tui-root.js';
 export const name = 'dashi';
 export const inject = [
-    'agentPresets', 'agents', 'attachments', 'cmdlineArgs', 'commands', 'fs', 'permissionPresets', 'sessionController',
-    'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'shell', 'skills', 'tools',
+    'agentPresets', 'agents', 'attachments', 'authorization', 'cmdlineArgs', 'commands', 'credentials', 'fs', 'loader', 'permissionPresets',
+    'pluginInventory', 'sessionController', 'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'settings', 'shell', 'skills', 'tools',
 ];
 const validatedVersions = JSON.parse(readFileSync(new URL('../validated-dsh-versions.json', import.meta.url), 'utf8'));
 function parseArgs(args) {
     let accessible = false;
+    let agentPreset, sessionId;
+    let forkSession = false;
     let inline = true;
     let name;
     let effort;
@@ -37,13 +40,15 @@ function parseArgs(args) {
             inline = true;
         else if (argument === '--fullscreen')
             inline = false;
-        else if (argument === '--name' || argument === '--image' || argument === '--effort'
-            || argument === '--model' || argument === '--permission' || argument === '--provider') {
+        else if (['--name', '-n', '--agent', '--image', '--effort', '--model', '--permission', '--provider',
+            '--session-id'].includes(argument ?? '')) {
             const value = args[++index];
             if (value === undefined || value === '')
                 return undefined;
-            if (argument === '--name')
+            if (argument === '--name' || argument === '-n')
                 name = value;
+            else if (argument === '--agent')
+                agentPreset = value;
             else if (argument === '--image')
                 images.push(value);
             else if (argument === '--effort')
@@ -52,6 +57,8 @@ function parseArgs(args) {
                 model = value;
             else if (argument === '--permission')
                 permission = value;
+            else if (argument === '--session-id')
+                sessionId = value;
             else
                 provider = value;
         }
@@ -68,6 +75,8 @@ function parseArgs(args) {
             resumeAll = true;
         else if (argument === '--continue' || argument === '-c')
             useContinue = true;
+        else if (argument === '--fork-session')
+            forkSession = true;
         else if (argument === '--yolo' || argument === '--dangerously-skip-permissions') {
             permission = 'danger-full-access';
         }
@@ -79,12 +88,15 @@ function parseArgs(args) {
     if (resume !== undefined && (resumePicker || useContinue) || resumePicker && useContinue
         || name !== undefined && (resume !== undefined || resumePicker || useContinue)
         || resumeAll && resume === undefined && !resumePicker || resumeAll && useContinue
-        || provider !== undefined && model === undefined)
+        || provider !== undefined && model === undefined
+        || sessionId !== undefined && (!isSessionId(sessionId) || resume !== undefined || resumePicker || useContinue)
+        || agentPreset !== undefined && (resume !== undefined || resumePicker || useContinue)
+        || forkSession && resume === undefined && !resumePicker && !useContinue)
         return undefined;
     return {
         accessible,
         continue: useContinue,
-        inline,
+        ...(agentPreset === undefined ? {} : { agentPreset }), forkSession, inline,
         resumeAll,
         resumePicker,
         ...(images.length === 0 ? {} : { images }),
@@ -94,7 +106,7 @@ function parseArgs(args) {
         ...(permission === undefined ? {} : { permission }),
         ...(prompt.length === 0 ? {} : { prompt: prompt.join(' ') }),
         ...(provider === undefined ? {} : { provider }),
-        ...(resume === undefined ? {} : { resume }),
+        ...(resume === undefined ? {} : { resume }), ...(sessionId === undefined ? {} : { sessionId }),
     };
 }
 function packageVersion(path) {
@@ -154,6 +166,11 @@ export function apply(ctx) {
         throw new Error('dashi: the launcher must provide ctx.appExit, ctx.appReady, and ctx.cmdlineArgs');
     }
     const args = cmdline.get();
+    if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) {
+        process.stdout.write(`${VERSION_LINE}\n\nUsage: dashi [options] [prompt]\n\n${FLAG_HELP.join('\n')}\n`);
+        exit(0);
+        return;
+    }
     if (args[0] === 'sessions') {
         const options = parseSessionListArgs(args);
         if (options === undefined) {

package/lib/input.js

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

package/lib/memory.d.ts

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

package/lib/memory.js

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

package/lib/renderer.d.ts

@@ -6,6 +6,7 @@ export type CopyResult = 'ok' | 'too-large' | 'unsupported';
 export interface Renderer extends TerminalSession {
     bell(): void;
     copy(text: string): CopyResult;
+    discardSecretComposer(): void;
     materializedCells(): number;
     setComposer(text: string, cursor?: ComposerCursor): void;
 }

package/lib/renderer.js

@@ -14,6 +14,7 @@ const OVERSCAN_CELLS = 8;
 const THEME_GENERATION = 1;
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const SPINNER_INTERVAL_MS = 80;
+const MASK_TOKEN = new RegExp(String.raw `\u001B(?:\[[0-?]*[ -/]*[@-~]|[_P^X][^\u0007]*(?:\u0007|\u001B\\))|[^\s]`, 'gu');
 export function supportsOsc52(terminalType) {
     return terminalType?.toLocaleLowerCase() !== 'dumb';
 }
@@ -160,14 +161,22 @@ export function createRenderer(options) {
     const tui = options.inline
         ? new TuiMainScreen(terminal, true)
         : new TuiAltScreen(terminal, true, undefined, { mouse: true });
-    const editor = new Editor(tui, theme(), { paddingX: 1 });
+    let editor = new Editor(tui, theme(), { paddingX: 1 });
     editor.disableSubmit = true;
     editor.onChange = text => {
+        const decision = options.readState().decisions[0];
         const caret = caretOffset(text, editor.getCursor());
         options.dispatch({
-            type: 'composer-changed', text, caret, completion: hasCompletionTrigger(text, caret),
+            type: 'composer-changed', text: decision?.kind === 'question' && decision.questions[decision.index]?.secret === true ? editor.getExpandedText() : text, caret, completion: hasCompletionTrigger(text, caret),
         });
     };
+    const replaceEditor = () => {
+        const discarded = editor;
+        editor = new Editor(tui, theme(), { paddingX: 1 });
+        editor.disableSubmit = true;
+        editor.onChange = discarded.onChange;
+        tui.setFocus(editor);
+    };
     const lineCache = new Map();
     let animationTimer;
     const cellLines = (cell, width, toolMode, now) => {
@@ -203,14 +212,18 @@ export function createRenderer(options) {
             return [`${RED}Invalid empty question batch${RESET}`];
         const planReview = question.intent?.kind === 'plan-review';
         const heading = planReview ? 'Plan review' : question.header ?? `Question ${String(decision.index + 1)}/${String(decision.questions.length)}`;
+        const customAllowed = question.allowCustom !== false;
         const selected = question.options[decision.cursor]?.label ?? 'Other (type an answer)';
-        const announced = announcement(plain(heading), question.options.length + 1, selected, decision.cursor);
+        const announced = announcement(plain(heading), question.options.length + Number(customAllowed), selected, decision.cursor);
         const prompt = wrapTextWithAnsi(`${BOLD_CYAN}${announced}${RESET}\n${plain(question.question, true)}`, width);
         const choiceRows = question.options.map((option, index) => optionLine(option.description === undefined ? option.label : `${option.label} — ${option.description}`, index + 1, decision.cursor === index, decision.selected.includes(option.label)));
-        choiceRows.push(optionLine('Other (type an answer)', question.options.length + 1, decision.cursor === question.options.length, false));
+        if (customAllowed)
+            choiceRows.push(optionLine('Other (type an answer)', question.options.length + 1, decision.cursor === question.options.length, false));
         const detailLimit = planReview ? Math.max(3, rows - prompt.length - choiceRows.length - 5) : 3;
         const detail = question.detail === undefined ? [] : wrapTextWithAnsi(`${DIM}${plain(question.detail, true)}${RESET}`, width).slice(0, detailLimit);
-        const custom = decision.cursor === question.options.length ? editor.render(width) : [];
+        const editorLines = decision.cursor === question.options.length ? editor.render(width) : [];
+        const custom = question.secret === true
+            ? editorLines.map((value, index) => index === 0 || index === editorLines.length - 1 ? value : value.replace(MASK_TOKEN, token => token.startsWith('\u001B') ? token : '•')) : editorLines;
         const rendered = [...prompt, ...detail, ...choiceRows, ...custom];
         return rows < 12 ? rendered.slice(0, Math.max(2, rows - 4)) : rendered;
     };
@@ -268,9 +281,11 @@ export function createRenderer(options) {
         if (overlay.kind === 'details')
             return detailsPanel(overlay, state, width, rows);
         if (overlay.kind === 'info') {
+            const cards = overlay.cells?.flatMap(cell => wrapTextWithAnsi(cellText(cell, state.toolMode, accessible), width)) ?? [];
             return [
-                `${BOLD_CYAN}${announcement(plain(overlay.title), overlay.lines.length)}${RESET}`,
+                `${BOLD_CYAN}${announcement(plain(overlay.title), overlay.lines.length + (overlay.cells?.length ?? 0))}${RESET}`,
                 ...overlay.lines.flatMap(value => wrapTextWithAnsi(plain(value, true), width)),
+                ...cards,
                 `${DIM}Enter or Esc to close${RESET}`,
             ].slice(0, Math.max(2, rows - 3));
         }
@@ -404,6 +419,7 @@ export function createRenderer(options) {
             terminal.write(`\u001B]52;c;${Buffer.from(safe).toString('base64')}\u0007`);
             return 'ok';
         },
+        discardSecretComposer: replaceEditor,
         drainInput: () => terminal.drainInput(),
         materializedCells: () => materializedCount,
         render: force => { tui.renderNow(force); },

package/lib/session-runtime.d.ts

@@ -2,9 +2,11 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { ActivatableOverlayValue, DecisionAnswer, DraftAttachment, OverlayOption, PendingDecision, RootView, SendMode, TerminalCell, UiAction } from './state.js';
 import type { TuiRoot } from './tui-root.js';
 export interface RootLaunchOptions {
+    readonly agentPreset?: string;
     readonly continue: boolean;
     readonly cwd: string;
     readonly effort?: string;
+    readonly forkSession: boolean;
     readonly name?: string;
     readonly images?: readonly string[];
     readonly model?: string;
@@ -12,6 +14,7 @@ export interface RootLaunchOptions {
     readonly prompt?: string;
     readonly provider?: string;
     readonly resume?: string;
+    readonly sessionId?: string;
 }
 export interface SessionRuntime {
     readonly initialAttachments: readonly DraftAttachment[];

package/lib/session-runtime.js

@@ -1,15 +1,23 @@
+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 { 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, sessionOverlay, skillOverlay, statusOverlay, } from './catalogs.js';
+import { diffOverlay } from './diff-view.js';
 import { eventsFromRecords } from './history-records.js';
 import { admitDraftImages, encodeDraftImages, readDraftImages } from './image-input.js';
 import { contextPercent, jobViews, subagentViews } from './presentation.js';
 import { humanPrompt, humanPrompts, inheritedTurn, rewindActionOverlay, rewindOverlay, } from './rewind.js';
 import { createToolPresenter } from './tool-presentation.js';
-import { runHumanShell } from './shell-command.js';
+import { quoteShellWord, runHumanShell } from './shell-command.js';
 import { markdownTranscript } from './session-export.js';
 import { isSessionId, sessionMatches, sessionNotFound } from './session-list.js';
+import { memoryOverlay } from './memory.js';
 import { foldCells, pendingShellCells } from './transcript.js';
+function 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`;
+}
 function detail(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -71,6 +79,17 @@ async function firstControl(iterator) {
 function usage(raw, expected) {
     return raw.trim() === '' ? undefined : { kind: 'error', text: `usage: ${expected}` };
 }
+function configValue(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function configLayer(value) {
+    return value === undefined ? '—' : JSON.stringify(value);
+}
 /** Create or resume the exact current root and own its replaceable terminal binding. */
 export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, decisions) {
     const lifetime = new AbortController();
@@ -78,11 +97,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 {
@@ -178,6 +199,15 @@ 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 }),
         ...pendingShellCells(bound.agent.inbox.nextStep),
@@ -451,7 +481,7 @@ 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 definitions = [
             {
                 name: 'help', description: 'Show keyboard and command help',
                 handler: (invocation) => {
@@ -491,6 +521,133 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     return { kind: 'success' };
                 },
             },
+            {
+                name: 'memory', description: 'Open an instruction file loaded by DSH',
+                handler: (invocation) => {
+                    const invalid = ensureCurrent(invocation) ?? usage(invocation.rawInput, '/memory');
+                    if (invalid !== undefined)
+                        return invalid;
+                    dispatch({ type: 'open-overlay', overlay: memoryOverlay(bound.agent) });
+                    return { kind: 'success' };
+                },
+            },
+            {
+                name: '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) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    const raw = invocation.rawInput.trim();
+                    if (raw === '')
+                        return { kind: 'success', text: ctx.settings.describe({ redactSecrets: true }).map(item => `${String(item.ns)}\n  value: ${configLayer(item.value)}\n  base: ${configLayer(item.base)}\n  user: ${configLayer(item.user)}`).join('\n') };
+                    const match = /^(\S+)\s+([^\s=]+)=(.*)$/su.exec(raw);
+                    if (match?.[1] === undefined || match[2] === undefined || match[3] === undefined) {
+                        return { kind: 'error', text: 'usage: /config [NAMESPACE KEY=VALUE]' };
+                    }
+                    const value = configValue(match[3]);
+                    if (match[2].includes('.'))
+                        await ctx.settings.mutate(match[1], [{ op: 'set', path: match[2].split('.'), value }]);
+                    else
+                        await ctx.settings.update(match[1], { [match[2]]: value });
+                    return { kind: 'success', text: `updated ${match[1]}.${match[2]}` };
+                },
+            },
+            { name: '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);
+                    if (invalid !== undefined)
+                        return invalid;
+                    const mode = invocation.rawInput.trim();
+                    if (mode !== '' && mode !== 'turn')
+                        return { kind: 'error', text: 'usage: /diff [turn]' };
+                    dispatch({ type: 'open-overlay', overlay: await diffOverlay(ctx, bound.agent, bound.presenter, mode, lifetime.signal) });
+                    return { kind: 'success' };
+                },
+            },
+            {
+                name: 'plugins', description: 'List the running profile plugins',
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    if (invocation.rawInput.trim() !== '')
+                        return { kind: 'error', text: 'usage: /plugins' };
+                    const servers = new Map();
+                    for (const entry of ctx.loader.entries())
+                        if (entry.options.name === '@deepseek-ai/dsh-mcp-client'
+                            && typeof entry.options.config?.serverName === 'string')
+                            servers.set(entry.id, entry.options.config.serverName);
+                    const snapshot = await ctx.get('pluginInventory').list();
+                    return { kind: 'success', text: snapshot.entries.map(entry => `${String(entry.entryId)} · ${entry.moduleName}${servers.has(String(entry.entryId)) ? ` · ${servers.get(String(entry.entryId))}` : ''} · ${entry.enabled ? 'enabled' : 'disabled'} · ${entry.fiberPhase ?? 'inactive'}`).join('\n') };
+                },
+            },
+            {
+                name: 'plugin', description: 'Run DSH profile plugin management', input: { hint: 'ARGS' },
+                handler: async (invocation) => {
+                    const stale = ensureCurrent(invocation);
+                    if (stale !== undefined)
+                        return stale;
+                    if (invocation.rawInput.trim() === '')
+                        return { kind: 'error', text: 'usage: /plugin ARGS' };
+                    const command = `dsh plugin --profile ${quoteShellWord(decodeURIComponent(new URL(ctx.baseUrl).pathname).split('/').at(-2))}${invocation.rawInput}`;
+                    const [message, result] = await bound.agent.runMaintenance(signal => runHumanShell(ctx, bound.agent, command, signal, 'changes load on the next launch; exit and run dashi again'));
+                    bound.agent.inject(message);
+                    await ctx.sessions.flush(bound.agent.session);
+                    publish(bound);
+                    return result.exitCode === 0 ? { kind: 'success' } : { kind: 'error', text: `dsh plugin exited ${String(result.exitCode ?? result.signal ?? 'without status')}` };
+                },
+            },
             {
                 name: 'new', description: 'Start a new session', input: { hint: '[--name TITLE]' },
                 handler: async (invocation) => {
@@ -628,15 +785,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' };
                 },
             },
@@ -669,6 +828,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) => {
@@ -709,6 +894,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;
@@ -1027,7 +1214,8 @@ export async function createSessionRuntime(ctx, options, tuiRoot, dispatch, deci
                     if (attachments.length > 0)
                         throw new Error('!command does not accept image attachments');
                     await bound.agent.runMaintenance(async (signal) => {
-                        bound.agent.inject(await runHumanShell(ctx, bound.agent, command, signal));
+                        const [message] = await runHumanShell(ctx, bound.agent, command, signal);
+                        bound.agent.inject(message);
                         await ctx.sessions.flush(bound.agent.session);
                     });
                     publish(bound);

package/lib/shell-command.d.ts

@@ -5,5 +5,6 @@ import type { ShellRunResult } from '@deepseek-ai/dsh-shell';
 export declare const HUMAN_SHELL_TIMEOUT_MS = 30000;
 export declare const HUMAN_SHELL_STREAM_BYTES: number;
 export declare function shellResultText(command: string, result: ShellRunResult): string;
+export declare function quoteShellWord(value: string): string;
 /** Run an explicit human command through DSH and identify its next-step context. */
-export declare function runHumanShell(ctx: Context, agent: Agent, command: string, signal: AbortSignal): Promise<UserMessage>;
+export declare function runHumanShell(ctx: Context, agent: Agent, command: string, signal: AbortSignal, success?: string): Promise<readonly [UserMessage, ShellRunResult]>;

package/lib/shell-command.js

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

package/lib/state.d.ts

@@ -87,6 +87,7 @@ export interface QuestionOption {
     readonly label: string;
 }
 export interface QuestionItem {
+    readonly allowCustom?: boolean;
     readonly detail?: string;
     readonly header?: string;
     readonly id: string;
@@ -97,6 +98,7 @@ export interface QuestionItem {
     readonly multiSelect: boolean;
     readonly options: readonly QuestionOption[];
     readonly question: string;
+    readonly secret?: boolean;
 }
 export interface QuestionAnswer {
     readonly custom?: string;
@@ -129,6 +131,9 @@ export type OverlayValue = {
     readonly path: string;
     readonly source: string;
     readonly text: string;
+} | {
+    readonly kind: 'copy';
+    readonly text: string;
 } | {
     readonly kind: 'insert';
     readonly text: string;
@@ -137,6 +142,9 @@ export type OverlayValue = {
     readonly effort?: string;
     readonly model: string;
     readonly provider: string;
+} | {
+    readonly kind: 'open-file';
+    readonly path: string;
 } | {
     readonly interrupt?: true;
     readonly kind: 'fork';
@@ -179,6 +187,8 @@ export type OverlayValue = {
 };
 export type ActivatableOverlayValue = Exclude<OverlayValue, {
     kind: 'attach';
+} | {
+    kind: 'copy';
 } | {
     kind: 'insert';
 }>;
@@ -197,9 +207,10 @@ export type Overlay = {
     readonly kind: 'list';
     readonly notice?: string;
     readonly options: readonly OverlayOption[];
-    readonly purpose: 'agents' | 'completion' | 'model' | 'permission' | 'resume' | 'rewind' | 'rewind-action' | 'search';
+    readonly purpose: 'agents' | 'completion' | 'copy' | 'memory' | 'model' | 'permission' | 'resume' | 'rewind' | 'rewind-action' | 'search' | 'skills';
     readonly title: string;
 } | {
+    readonly cells?: readonly TerminalCell[];
     readonly kind: 'info';
     readonly lines: readonly string[];
     readonly title: string;
@@ -424,7 +435,8 @@ export type UiAction = {
     readonly hasMore?: boolean;
     readonly rootId?: string;
 } | {
-    readonly type: 'copy-latest';
+    readonly selection: number | 'code';
+    readonly type: 'copy-assistant';
 };
 export type UiEffect = {
     readonly type: 'activate-overlay';

package/lib/state.js

@@ -1,3 +1,4 @@
+import { FLAG_HELP, VERSION_LINE } from './help.js';
 export function initialViewState(cwd, inline, root, cells = [], prompts = [], historyHasMore = false, attachments = []) {
     return {
         attachments, cells, composer: '', cwd, decisions: [], exitArmed: false, historyHasMore, inline,
@@ -24,13 +25,14 @@ function moveCursor(decision, cursor) {
     const question = decision.questions[decision.index];
     if (question === undefined)
         return decision;
-    return { ...decision, cursor: Math.max(0, Math.min(question.options.length, cursor)) };
+    return { ...decision, cursor: Math.max(0, Math.min(question.options.length - (question.allowCustom === false ? 1 : 0), cursor)) };
 }
 function help() {
     return {
         kind: 'info',
         title: 'Help',
         lines: [
+            VERSION_LINE,
             'Enter send · Ctrl+J newline · Ctrl+T steer/next turn',
             'Esc interrupt · Ctrl+C clear/interrupt · Ctrl+C/D again within 2s to exit',
             '/ and @ complete live · Tab insert · Shift+Tab permission · Ctrl+O cards',
@@ -39,8 +41,9 @@ function help() {
             'Ctrl+B activity details for jobs and subagents',
             '@ paths require DSH file-reference · Ctrl+V pastes an image · Backspace removes it',
             'Ctrl+S stash · Ctrl+G editor · F1 help · Ctrl+L redraw · Ctrl+Z suspend',
-            '/new /clear /resume [--all] [NAME|UUID] /fork /rewind /rename /model /permission /agents /queue · launch -r/-c --model/--effort/--permission/--yolo',
-            '/status /context /tasks /history /export /copy /exit',
+            '/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 /history /export /copy /exit /quit',
+            ...FLAG_HELP,
         ],
     };
 }
@@ -83,13 +86,24 @@ function refreshSearch(search, cells) {
     const found = matches(cells, search.query);
     return { ...search, cursor: Math.min(search.cursor, Math.max(0, found.length - 1)), matches: found };
 }
-function latestCompletedAssistant(cells) {
+function completedAssistant(cells, nth) {
+    let seen = 0;
     for (let index = cells.length - 1; index >= 0; index--) {
         const cell = cells[index];
-        if (cell?.kind === 'assistant' && cell.pending !== true)
+        if (cell?.kind === 'assistant' && cell.pending !== true && ++seen === nth)
             return cell;
     }
 }
+function codeBlockOptions(text) {
+    const fence = /(?:^|\r?\n)(`{3,}|~{3,})([^\r\n]*)\r?\n([\s\S]*?)\r?\n\1[ \t]*(?=\r?\n|$)/gu;
+    return [...text.matchAll(fence)].map(match => {
+        const code = match[3] ?? '';
+        return {
+            label: `${match[2]?.trim() || 'text'} · ${code.split(/\r?\n/u)[0] ?? ''}`,
+            value: { kind: 'copy', text: code },
+        };
+    });
+}
 export function reduce(state, action) {
     const head = state.decisions[0];
     switch (action.type) {
@@ -215,7 +229,7 @@ export function reduce(state, action) {
             const question = head.questions[head.index];
             if (question === undefined)
                 return [state, []];
-            const custom = head.cursor === question.options.length ? head.custom.trim() : undefined;
+            const custom = question.allowCustom !== false && head.cursor === question.options.length ? question.secret === true ? head.custom : head.custom.trim() : undefined;
             if (custom !== undefined && custom === '')
                 return [state, []];
             const option = question.options[head.cursor];
@@ -407,6 +421,10 @@ export function reduce(state, action) {
                             type: 'attach', path: option.value.path, source: option.value.source, text: option.value.text,
                         }, ...redraw()]];
             }
+            if (option.value.kind === 'copy') {
+                const { overlay: _overlay, ...withoutOverlay } = state;
+                return [withoutOverlay, [{ type: 'copy', text: option.value.text }, ...redraw()]];
+            }
             if (option.value.kind === 'permission' && option.danger === true) {
                 return [{ ...state, overlay: {
                             acceptLabel: 'Enable',
@@ -633,9 +651,15 @@ export function reduce(state, action) {
                     }),
                 }, redraw()];
         }
-        case 'copy-latest': {
-            const cell = latestCompletedAssistant(state.cells);
-            return cell === undefined ? [state, []] : [state, [{ type: 'copy', text: cell.text }]];
+        case 'copy-assistant': {
+            const cell = completedAssistant(state.cells, action.selection === 'code' ? 1 : action.selection);
+            if (cell === undefined)
+                return [state, []];
+            if (action.selection !== 'code')
+                return [state, [{ type: 'copy', text: cell.text }]];
+            return [{ ...state, overlay: {
+                        cursor: 0, kind: 'list', options: codeBlockOptions(cell.text), purpose: 'copy', title: 'Copy code block',
+                    } }, redraw()];
         }
     }
 }

package/lib/transcript.js

@@ -29,7 +29,8 @@ function shellCell(message, pending) {
 function collapsedContextCell(message, key) {
     const source = message.source;
     const form = source.form;
-    if (source.kind !== 'plugin' || !['instructions', 'catalog', 'snapshot', 'notice', 'recall'].includes(String(form))) {
+    if (source.kind !== 'agent-instructions'
+        && (source.kind !== 'plugin' || !['instructions', 'catalog', 'snapshot', 'notice', 'recall'].includes(String(form)))) {
         return undefined;
     }
     const text = messageText(message.content);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antst/dashi",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.9",
   "description": "A terminal UI for DeepSeek Harness",
   "publishConfig": {
     "access": "public"
@@ -37,15 +37,21 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/cordis-plugin-loader": "1.0.3",
     "@deepseek-ai/dsh-agent": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-agent-instructions": "0.1.2-rc.1",
     "@deepseek-ai/dsh-agent-presets": "0.1.2-rc.1",
     "@deepseek-ai/dsh-api-session-controller": "0.1.2-rc.1",
     "@deepseek-ai/dsh-attachment": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-authorization": "0.1.2-rc.1",
     "@deepseek-ai/dsh-cmdline": "0.1.2-rc.1",
     "@deepseek-ai/dsh-commands": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-credentials": "0.1.2-rc.1",
     "@deepseek-ai/dsh-compaction": "0.1.2-rc.1",
     "@deepseek-ai/dsh-file-reference": "0.1.2-rc.1",
     "@deepseek-ai/dsh-fs": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-home-paths": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-host-plugin-inventory": "0.1.2-rc.1",
     "@deepseek-ai/dsh-llm": "0.1.2-rc.1",
     "@deepseek-ai/dsh-permission-presets": "0.1.2-rc.1",
     "@deepseek-ai/dsh-plan-mode": "0.1.2-rc.1",
@@ -53,6 +59,7 @@
     "@deepseek-ai/dsh-session": "0.1.2-rc.1",
     "@deepseek-ai/dsh-session-projection": "0.1.2-rc.1",
     "@deepseek-ai/dsh-session-query": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-settings": "0.1.2-rc.1",
     "@deepseek-ai/dsh-shell": "0.1.2-rc.1",
     "@deepseek-ai/dsh-skill": "0.1.2-rc.1",
     "@deepseek-ai/dsh-subagent": "0.1.2-rc.1",