@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

package/lib/types/dsh-adapter/channel/lifetime-resources.d.ts

@@ -0,0 +1,9 @@
+import type { AgentHandle } from '@deepseek-ai/dsh-agent';
+import type { ChannelOwner } from './owner.js';
+/** Owns temporary Agent handles until a caller explicitly transfers them. */
+export declare function createDetachedHandleFactory(owner: Pick<ChannelOwner, 'assertActive' | 'current' | 'own'>): (create: () => Promise<AgentHandle>) => Promise<{
+    handle: AgentHandle;
+    transfer(): void;
+    release(): Promise<void>;
+}>;
+//# sourceMappingURL=lifetime-resources.d.ts.map

package/lib/types/dsh-adapter/channel/lifetime-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifetime-resources.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/lifetime-resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,6EAA6E;AAC7E,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,cAAc,GAAG,SAAS,GAAG,KAAK,CAAC,IACzF,QAAQ,MAAM,OAAO,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC;IACzD,MAAM,EAAE,WAAW,CAAA;IACnB,QAAQ,IAAI,IAAI,CAAA;IAChB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CA4BH"}

package/lib/types/dsh-adapter/channel/lifetime-resources.js

@@ -0,0 +1,33 @@
+/** Owns temporary Agent handles until a caller explicitly transfers them. */
+export function createDetachedHandleFactory(owner) {
+    return async (create) => {
+        owner.assertActive();
+        let handle;
+        let transferred = false;
+        let disposePromise;
+        const release = () => {
+            if (transferred || handle === undefined)
+                return Promise.resolve();
+            disposePromise ??= handle.dispose().catch(() => undefined);
+            return disposePromise;
+        };
+        const unregister = owner.own(() => { void release(); });
+        try {
+            handle = await create();
+            if (!owner.current()) {
+                await release();
+                throw new Error('dsh-tui: Channel lifetime has ended');
+            }
+            return {
+                handle,
+                transfer() { transferred = true; unregister(); },
+                async release() { unregister(); await release(); },
+            };
+        }
+        catch (error) {
+            unregister();
+            await release();
+            throw error;
+        }
+    };
+}

package/lib/types/dsh-adapter/channel/loaded-context.d.ts

@@ -0,0 +1,40 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type SkillSummary } from '@deepseek-ai/dsh-skill';
+import type { LoadedContextEntry, LoadedContextFile, LoadedContextSkill, LoadedContextTool } from './types.js';
+import type { ChannelOwner } from './owner.js';
+export type SkillRegistry = {
+    snapshot(options?: {
+        scope?: unknown;
+        cwd?: string;
+    }): Promise<{
+        skills: readonly SkillSummary[];
+        complete: boolean;
+    }>;
+    get(name: string, options?: {
+        scope?: unknown;
+        cwd?: string;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+};
+/** Assembles the loaded-context panel. A result belongs only to its origin Agent. */
+export declare function createLoadedContextRefresher(ctx: Context, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    agent(): Agent;
+    cwd(): string;
+    publish(context: {
+        sections: LoadedContextEntry[];
+        contexts: LoadedContextEntry[];
+        files: LoadedContextFile[];
+        skills: LoadedContextSkill[];
+        tools: LoadedContextTool[];
+    }): void;
+    skillRegistryFor(agent: Agent): SkillRegistry | undefined;
+    skillViewOptions(agent: Agent): {
+        scope: Agent;
+        cwd: string;
+    };
+}): {
+    refresh: () => Promise<void>;
+};
+//# sourceMappingURL=loaded-context.d.ts.map

package/lib/types/dsh-adapter/channel/loaded-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaded-context.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/loaded-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAGnD,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC9G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAC7D,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;QAC/B,QAAQ,EAAE,OAAO,CAAA;KAClB,CAAC,CAAA;IACF,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACvG,CAAA;AAED,qFAAqF;AACrF,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE;IACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,KAAK,IAAI,KAAK,CAAA;IACd,GAAG,IAAI,MAAM,CAAA;IACb,OAAO,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC;QAAC,QAAQ,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,iBAAiB,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;IAChL,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,GAAG,SAAS,CAAA;IACzD,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9D;mBAEyB,OAAO,CAAC,IAAI,CAAC;EA+CxC"}

package/lib/types/dsh-adapter/channel/loaded-context.js

@@ -0,0 +1,62 @@
+import { assembleContextFor } from '@deepseek-ai/dsh-agent';
+import { loadBaselineInstructions } from '@deepseek-ai/dsh-agent-instructions';
+import { isModelInvocable } from '@deepseek-ai/dsh-skill';
+import { renderContextSections, renderPrompt } from '@deepseek-ai/dsh-system-prompt';
+/** Assembles the loaded-context panel. A result belongs only to its origin Agent. */
+export function createLoadedContextRefresher(ctx, deps) {
+    const refresh = async () => {
+        if (!deps.owner.current())
+            return;
+        const target = deps.agent();
+        const sections = [];
+        const contexts = [];
+        const files = [];
+        const skills = [];
+        const tools = [];
+        try {
+            const systemPrompt = ctx.get('systemPrompt');
+            if (systemPrompt !== undefined) {
+                const assembly = await systemPrompt.assemble(assembleContextFor(target));
+                if (!deps.owner.current() || target !== deps.agent())
+                    return;
+                for (const section of assembly.sections) {
+                    const text = renderPrompt({ sections: [section], contexts: [], tools: [], variables: assembly.variables });
+                    if (text.length > 0)
+                        sections.push({ name: section.name, text });
+                }
+                contexts.push(...renderContextSections(assembly));
+                for (const tool of assembly.tools)
+                    tools.push({ name: tool.name, description: tool.description ?? '' });
+            }
+            const renderedInstructions = await loadBaselineInstructions({
+                cwd: deps.cwd(), maxBytes: 1024 * 1024, maxSourceBytes: 1024 * 1024,
+            }, ctx.get('fs'));
+            if (!deps.owner.current() || target !== deps.agent())
+                return;
+            const sources = renderedInstructions;
+            const paths = new Set([
+                ...(sources?.represented ?? []).map(file => file.displayPath),
+                ...(renderedInstructions?.omitted ?? []).map(file => file.displayPath),
+                ...(renderedInstructions?.truncated ?? []).map(file => file.displayPath),
+            ]);
+            files.push(...[...paths].map(displayPath => ({ displayPath })));
+            const registry = tools.some(tool => tool.name === 'skill') ? deps.skillRegistryFor(target) : undefined;
+            if (registry !== undefined) {
+                const observation = await registry.snapshot(deps.skillViewOptions(target));
+                if (!deps.owner.current() || target !== deps.agent())
+                    return;
+                if (observation.complete) {
+                    skills.push(...observation.skills.filter(isModelInvocable).map(skill => ({ name: skill.name, description: skill.description })));
+                }
+            }
+        }
+        catch (error) {
+            ctx.logger.warn('loaded-context snapshot failed: %o', error);
+            return;
+        }
+        if (!deps.owner.current() || target !== deps.agent())
+            return;
+        deps.publish({ sections, contexts, files, skills, tools });
+    };
+    return { refresh };
+}

package/lib/types/dsh-adapter/channel/local-actions.d.ts

@@ -0,0 +1,70 @@
+import { type foldBack as FoldBack } from './transcript.js';
+import type { ChannelState, ToolViewPresenter } from './types.js';
+type Shell = {
+    resolve(request: {
+        command: string;
+        workdir?: string;
+        timeoutMs: number;
+    }): unknown;
+    run(spec: unknown): Promise<{
+        stdout: {
+            text: string;
+        };
+        stderr: {
+            text: string;
+        };
+        timedOut: boolean;
+    }>;
+};
+/** Owns local-only transcript mutations, shell output, and live subagent queries. */
+export declare function createLocalActions(deps: {
+    ctx: {
+        get(name: string): unknown;
+    };
+    owner: {
+        current(): boolean;
+    };
+    binding: {
+        capture(): unknown;
+        isCurrent(capture: unknown): boolean;
+        readonly agent: {
+            session: unknown;
+            followup(message: unknown): void;
+        };
+    };
+    state: ChannelState;
+    rowIds: {
+        value: number;
+    };
+    projector: {
+        reset(): void;
+        presentCallView: NonNullable<ToolViewPresenter>['call'];
+        presentResultView: NonNullable<ToolViewPresenter>['result'];
+    };
+    subagents: {
+        dropRows(): void;
+    };
+    jobs: {
+        dropRows(): void;
+    };
+    foldBack: typeof FoldBack;
+    workspace: {
+        describe(cwd: string): {
+            kind: string;
+            badge: string;
+            label: string;
+        };
+        commandShell(cwd: string): Promise<Shell | undefined>;
+    };
+    shell?: Shell;
+    notify: ChannelState['notify'];
+}): {
+    loadOlder(): number;
+    clear(): void;
+    pushLocal(title: string, lines: readonly string[]): void;
+    setActivityFrames(name: string): boolean;
+    listSubagents(): Promise<string[]>;
+    runLocalCommand(command: string, includeInContext: boolean): Promise<void>;
+};
+export {};
+//# sourceMappingURL=local-actions.d.ts.map

package/lib/types/dsh-adapter/channel/local-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/local-actions.ts"],"names":[],"mappings":"AAOA,OAAO,EAA+B,KAAK,QAAQ,IAAI,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEjE,KAAK,KAAK,GAAG;IACX,OAAO,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAA;IACnF,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CACvG,CAAA;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,GAAG,EAAE;QAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;IACnC,KAAK,EAAE;QAAE,OAAO,IAAI,OAAO,CAAA;KAAE,CAAA;IAC7B,OAAO,EAAE;QACP,OAAO,IAAI,OAAO,CAAA;QAClB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAA;QACpC,QAAQ,CAAC,KAAK,EAAE;YAAE,OAAO,EAAE,OAAO,CAAC;YAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;SAAE,CAAA;KACvE,CAAA;IACD,KAAK,EAAE,YAAY,CAAA;IACnB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACzB,SAAS,EAAE;QAAE,KAAK,IAAI,IAAI,CAAC;QAAC,eAAe,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAA;IAClJ,SAAS,EAAE;QAAE,QAAQ,IAAI,IAAI,CAAA;KAAE,CAAA;IAC/B,IAAI,EAAE;QAAE,QAAQ,IAAI,IAAI,CAAA;KAAE,CAAA;IAC1B,QAAQ,EAAE,OAAO,QAAQ,CAAA;IACzB,SAAS,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAA;KAAE,CAAA;IAC3I,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;CAC/B;iBAIgB,MAAM;aAKV,IAAI;qBAYI,MAAM,SAAS,SAAS,MAAM,EAAE,GAAG,IAAI;4BAKhC,MAAM,GAAG,OAAO;qBAajB,OAAO,CAAC,MAAM,EAAE,CAAC;6BAmBT,MAAM,oBAAoB,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;EAqBnF"}

package/lib/types/dsh-adapter/channel/local-actions.js

@@ -0,0 +1,108 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { markChannelReadDirty } from '../../adapter/channel/read-view.js';
+import { writeActivityFrames } from '../../activityPrefs.js';
+import { isPresetName, normalizeActivityPreset } from '../../components/activityFrames.js';
+import { t } from '../../i18n.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+import { LOCAL_OUTPUT_LIMIT, preview } from './transcript.js';
+/** Owns local-only transcript mutations, shell output, and live subagent queries. */
+export function createLocalActions(deps) {
+    const { ctx, owner, binding, state, rowIds, projector, subagents, jobs, foldBack, workspace, shell, notify } = deps;
+    const current = (capture) => owner.current() && binding.isCurrent(capture);
+    return {
+        loadOlder() {
+            const restored = foldBack(state.rows, snapshotLiveSessionEvents(binding.agent.session), { call: projector.presentCallView, result: projector.presentResultView });
+            if (restored > 0)
+                state.emit();
+            return restored;
+        },
+        clear() {
+            state.rows.length = 0;
+            markChannelReadDirty(state.rows);
+            rowIds.value = 0;
+            projector.reset();
+            subagents.dropRows();
+            jobs.dropRows();
+            state.activeToolCount = 0;
+            state.responseChars = 0;
+            state.rows.push({ id: rowIds.value++, kind: 'notice', text: 'Session cleared' });
+            state.emit();
+        },
+        pushLocal(title, lines) {
+            state.rows.push({ id: rowIds.value++, kind: 'local', text: title });
+            for (const line of lines)
+                state.rows.push({ id: rowIds.value++, kind: 'local-output', text: preview(line, LOCAL_OUTPUT_LIMIT) });
+            state.emit();
+        },
+        setActivityFrames(name) {
+            // A retired preset id normalizes to the current default, so the
+            // in-memory state, the persisted preference and the toast agree instead
+            // of diverging until restart.
+            const preset = normalizeActivityPreset(name) ?? name;
+            if (!isPresetName(preset)) {
+                notify(t('unknown-activity-preset', { name }), { color: 'error' });
+                return false;
+            }
+            if (preset === state.activityFrames) {
+                notify(t('activity-indicator-already', { name: preset }), { color: 'success' });
+                return true;
+            }
+            if (!writeActivityFrames(preset)) {
+                notify(t('activity-pref-write-failed'), { color: 'error' });
+                return false;
+            }
+            state.activityFrames = preset;
+            state.emit();
+            notify(t('activity-indicator-switched', { name: preset }));
+            return true;
+        },
+        async listSubagents() {
+            const service = ctx.get('subagents');
+            if (!service)
+                return [t('subagent-not-mounted')];
+            const capture = binding.capture();
+            try {
+                const children = await service.listChildren(binding.agent.session.id);
+                if (!current(capture))
+                    throw new Error('dsh-tui: Channel lifetime has ended');
+                if (children.length === 0)
+                    return [t('subagent-none')];
+                return children.map(child => {
+                    const id = typeof child.id === 'string' ? child.id : (child.id.value ?? '');
+                    return t('subagent-row', { mode: child.mode === 'continuable' ? t('subagent-resumable') : t('subagent-oneshot'), label: child.label ? `「${child.label}」` : '', activity: child.activity === 'running' ? t('subagent-running') : t('subagent-archived'), id: id.slice(0, 8) });
+                });
+            }
+            catch (error) {
+                if (!current(capture))
+                    throw error;
+                return [t('subagent-query-failed', { err: error instanceof Error ? error.message : String(error) })];
+            }
+        },
+        async runLocalCommand(command, includeInContext) {
+            const capture = binding.capture();
+            const cwd = state.cwd;
+            const target = workspace.describe(cwd);
+            state.rows.push({ id: rowIds.value++, kind: 'local', text: command, executionTarget: target.kind === 'local' ? target.badge : `${target.badge} · ${target.label}` });
+            state.emit();
+            let output = '(no output)';
+            const executor = await workspace.commandShell(cwd) ?? shell;
+            if (!current(capture))
+                return;
+            if (executor) {
+                try {
+                    const result = await executor.run(executor.resolve({ command, workdir: cwd, timeoutMs: 30000 }));
+                    output = result.stdout.text.trim() || result.stderr.text.trim() || (result.timedOut ? '(timed out)' : '(no output)');
+                }
+                catch (error) {
+                    output = error instanceof Error ? error.message : String(error);
+                }
+            }
+            if (!current(capture))
+                return;
+            state.rows.push({ id: rowIds.value++, kind: 'local-output', text: preview(output, LOCAL_OUTPUT_LIMIT) });
+            state.emit();
+            if (includeInContext)
+                binding.agent.followup(createUserMessage({ content: [{ type: 'text', text: `<bash-stdout>\n${output}\n</bash-stdout>` }], source: { kind: 'user' } }));
+        },
+    };
+}

package/lib/types/dsh-adapter/channel/mentions.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { MentionAttachments, MentionExpansion, MentionFs, MentionImageBlock, MentionImageMediaType, ResolvedMention } from './types.js';
+/** One attached file's contribution is capped so an absent-minded `@` of a
+ *  huge file cannot blow the context window. */
+export declare const MENTION_MAX_FILE_CHARS = 50000;
+/** Total budget across all attachments in one message. */
+export declare const MENTION_MAX_TOTAL_CHARS = 200000;
+/** A directory mention contributes a shallow listing, capped at this many
+ *  entries. */
+export declare const MENTION_MAX_DIR_ENTRIES = 200;
+/** The leaf's fs service in the shape mention expansion needs; undefined
+ *  when the plugin is not mounted (mentions then stay literal text). */
+export declare function mentionFs(ctx: Context): MentionFs | undefined;
+export declare function mentionAttachments(ctx: Context): MentionAttachments | undefined;
+export declare const MENTION_IMAGE_MEDIA_TYPES: Readonly<Record<string, MentionImageMediaType>>;
+export declare function mentionImageMediaType(path: string): MentionImageMediaType | undefined;
+/** Resolve+stat one candidate path; undefined when it throws OR stats
+ * absent — both are a miss for strip-first mention resolution (issue #359). */
+export declare function tryResolveMention(fs: MentionFs, absolute: string): Promise<ResolvedMention | undefined>;
+/**
+ * Expand a submitted text's `@` mentions (issue #15) into model-facing
+ * attachment blocks: supported image files become durable image blocks,
+ * other files contribute capped text, and directories contribute a shallow
+ * listing. Reads always go through the active fs service, so provider-owned
+ * workspaces keep their routing semantics. The typed text stays first and
+ * verbatim. Best-effort failures degrade to `missing`, never a failed send.
+ */
+export declare function expandMentions(fs: MentionFs | undefined, cwd: string, text: string, attachments?: MentionAttachments, stagedImages?: ReadonlyMap<string, MentionImageBlock['attachment']>): Promise<MentionExpansion>;
+//# sourceMappingURL=mentions.d.ts.map

package/lib/types/dsh-adapter/channel/mentions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/mentions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAKlD,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,SAAS,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE5I;gDACgD;AAChD,eAAO,MAAM,sBAAsB,QAAS,CAAA;AAE5C,0DAA0D;AAC1D,eAAO,MAAM,uBAAuB,SAAU,CAAA;AAE9C;eACe;AACf,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C;wEACwE;AACxE,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAE7D;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,GAAG,SAAS,CAE/E;AAED,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAMrF,CAAA;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAErF;AAED;+EAC+E;AAC/E,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAS7G;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,SAAS,GAAG,SAAS,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,kBAAkB,EAChC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,GAClE,OAAO,CAAC,gBAAgB,CAAC,CAqL3B"}

package/lib/types/dsh-adapter/channel/mentions.js

@@ -0,0 +1,235 @@
+import { extname, isAbsolute, join } from 'node:path';
+import { extractMentions } from '../../utils/mentions.js';
+import { basename } from './paths.js';
+import { COMPOSER_IMAGE_TOKEN } from './composer-images.js';
+/** One attached file's contribution is capped so an absent-minded `@` of a
+ *  huge file cannot blow the context window. */
+export const MENTION_MAX_FILE_CHARS = 50_000;
+/** Total budget across all attachments in one message. */
+export const MENTION_MAX_TOTAL_CHARS = 200_000;
+/** A directory mention contributes a shallow listing, capped at this many
+ *  entries. */
+export const MENTION_MAX_DIR_ENTRIES = 200;
+/** The leaf's fs service in the shape mention expansion needs; undefined
+ *  when the plugin is not mounted (mentions then stay literal text). */
+export function mentionFs(ctx) {
+    return ctx.get('fs');
+}
+export function mentionAttachments(ctx) {
+    return ctx.get('attachments');
+}
+export const MENTION_IMAGE_MEDIA_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+};
+export function mentionImageMediaType(path) {
+    return MENTION_IMAGE_MEDIA_TYPES[extname(path).toLowerCase()];
+}
+/** Resolve+stat one candidate path; undefined when it throws OR stats
+ * absent — both are a miss for strip-first mention resolution (issue #359). */
+export async function tryResolveMention(fs, absolute) {
+    try {
+        const target = await fs.resolve(absolute);
+        const info = await fs.stat(target);
+        if (info === undefined)
+            return undefined;
+        return { target, info };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Expand a submitted text's `@` mentions (issue #15) into model-facing
+ * attachment blocks: supported image files become durable image blocks,
+ * other files contribute capped text, and directories contribute a shallow
+ * listing. Reads always go through the active fs service, so provider-owned
+ * workspaces keep their routing semantics. The typed text stays first and
+ * verbatim. Best-effort failures degrade to `missing`, never a failed send.
+ */
+export async function expandMentions(fs, cwd, text, attachments, stagedImages) {
+    const blocks = [{ type: 'text', text }];
+    const attached = [];
+    const missing = [];
+    const mentions = extractMentions(text);
+    let budget = MENTION_MAX_TOTAL_CHARS;
+    let imageCount = 0;
+    let imageBytes = 0;
+    const references = fs === undefined
+        ? []
+        : mentions.map(mention => ({ kind: 'mention', start: mention.start, mention }));
+    if (stagedImages !== undefined) {
+        const seen = new Set();
+        for (const match of text.matchAll(COMPOSER_IMAGE_TOKEN)) {
+            const token = match[0];
+            if (seen.has(token))
+                continue;
+            seen.add(token);
+            const attachment = stagedImages.get(token);
+            if (attachment === undefined)
+                continue;
+            references.push({
+                kind: 'staged-image',
+                start: match.index,
+                token,
+                attachment,
+            });
+        }
+    }
+    references.sort((a, b) => a.start - b.start);
+    // `@image` files and staged `[Image #N]` capabilities share one admission
+    // queue. The earliest reference in the user's text wins both the per-
+    // message count and byte budgets, and image blocks preserve that order.
+    for (const reference of references) {
+        if (reference.kind === 'staged-image') {
+            const { attachment, token } = reference;
+            // A referenced-but-dropped staged image must be loud: silently sending
+            // the bare token would leave the user believing the image reached the
+            // model. Reuse the missing-mention warning channel.
+            if (attachments === undefined) {
+                missing.push(token);
+                continue;
+            }
+            const limits = attachments.imageLimits;
+            if (imageCount >= limits.maxImagesPerMessage
+                || imageBytes + attachment.bytes > limits.maxMessageImageBytes
+                || !limits.mediaTypes.includes(attachment.mediaType)) {
+                missing.push(token);
+                continue;
+            }
+            blocks.push({ type: 'image', attachment });
+            imageCount += 1;
+            imageBytes += attachment.bytes;
+            continue;
+        }
+        if (fs === undefined)
+            continue;
+        const { mention } = reference;
+        const display = mention.literal ?? mention.path;
+        const imageMediaType = mentionImageMediaType(mention.path);
+        // A depleted text budget must not hide a later image reference: image
+        // admission has independent limits and still follows source order.
+        if (budget <= 0 && imageMediaType === undefined)
+            continue;
+        // Mentions resolve against the session cwd, same as the model-facing fs
+        // tools; absolute paths pass through untouched. A `#L12-14` line suffix
+        // (issue #359) is stripped before resolution; when the stripped path
+        // misses, the typed literal (suffix intact) gets ONE fallback try so
+        // filenames genuinely containing `#L…` still resolve as whole files.
+        const absolute = isAbsolute(mention.path) ? mention.path : join(cwd, mention.path);
+        let resolved = await tryResolveMention(fs, absolute);
+        let literalFallback = false;
+        if (resolved === undefined && mention.literal !== undefined) {
+            const literalPath = isAbsolute(mention.literal) ? mention.literal : join(cwd, mention.literal);
+            resolved = await tryResolveMention(fs, literalPath);
+            literalFallback = resolved !== undefined;
+        }
+        if (resolved === undefined) {
+            missing.push(display);
+            continue;
+        }
+        const { target, info } = resolved;
+        // On a literal-fallback hit the attached file IS the typed name — the
+        // model must see that path, not the suffix-stripped one.
+        const shownPath = literalFallback ? display : mention.path;
+        // …and judge image-ness by the typed extension in that case too.
+        const imageType = literalFallback && mention.literal !== undefined
+            ? mentionImageMediaType(mention.literal)
+            : imageMediaType;
+        if (info?.type === 'file') {
+            if (imageType !== undefined && attachments !== undefined && fs.readBytes !== undefined) {
+                const limits = attachments.imageLimits;
+                if (!limits.mediaTypes.includes(imageType) || imageCount >= limits.maxImagesPerMessage) {
+                    missing.push(display);
+                    continue;
+                }
+                try {
+                    const data = await fs.readBytes(target, undefined, limits.maxImageBytes);
+                    if (imageBytes + data.byteLength > limits.maxMessageImageBytes) {
+                        missing.push(display);
+                        continue;
+                    }
+                    const attachment = await attachments.saveImage({
+                        data,
+                        mediaType: imageType,
+                        name: basename(target.displayPath),
+                    });
+                    blocks.push({ type: 'image', attachment });
+                    imageCount += 1;
+                    imageBytes += data.byteLength;
+                    attached.push(display);
+                }
+                catch {
+                    missing.push(display);
+                }
+                continue;
+            }
+            try {
+                const cap = Math.min(MENTION_MAX_FILE_CHARS, budget);
+                const content = await fs.readText(target);
+                let body = content;
+                let truncated = false;
+                let header = `<attached-file path="${shownPath}">`;
+                if (mention.startLine !== undefined && !literalFallback) {
+                    // Line-range slice (issue #359): 1-based inclusive. An endLine
+                    // past EOF clamps to the file; a startLine past EOF falls back
+                    // to the whole file with an in-band note — never a silent
+                    // empty attach. Line ranges never apply to literal-fallback
+                    // hits (those files really are named `…#L…`, no suffix typed).
+                    const lines = content.split('\n');
+                    if (mention.startLine > lines.length) {
+                        header = `<attached-file path="${shownPath}" lines="${mention.startLine}-${mention.endLine}" note="requested lines beyond EOF (file has ${lines.length} line${lines.length === 1 ? '' : 's'}); whole file attached">`;
+                    }
+                    else {
+                        const endLine = Math.min(mention.endLine ?? mention.startLine, lines.length);
+                        header = `<attached-file path="${shownPath}" lines="${mention.startLine}${endLine === mention.startLine ? '' : `-${endLine}`}">`;
+                        body = lines.slice(mention.startLine - 1, endLine).join('\n');
+                    }
+                }
+                if (body.length > cap) {
+                    body = body.slice(0, cap);
+                    truncated = true;
+                }
+                budget -= body.length;
+                blocks.push({
+                    type: 'text',
+                    text: `${header}\n${body}${truncated ? '\n[… truncated]' : ''}\n</attached-file>`,
+                });
+                attached.push(display);
+            }
+            catch {
+                // Binary/undecodable or unreadable — report it like a miss.
+                missing.push(display);
+            }
+            continue;
+        }
+        if (info?.type === 'directory') {
+            try {
+                const entries = await fs.listDir(target);
+                const listing = entries
+                    .slice(0, MENTION_MAX_DIR_ENTRIES)
+                    .map(entry => (entry.type === 'directory' ? `${entry.name}/` : entry.name));
+                if (entries.length > MENTION_MAX_DIR_ENTRIES) {
+                    listing.push(`… (${entries.length - MENTION_MAX_DIR_ENTRIES} more)`);
+                }
+                const body = listing.join('\n');
+                budget -= body.length;
+                blocks.push({
+                    type: 'text',
+                    text: `<attached-directory path="${shownPath}">\n${body}\n</attached-directory>`,
+                });
+                attached.push(display);
+            }
+            catch {
+                missing.push(display);
+            }
+            continue;
+        }
+        // Absent (stat → undefined) or a special file.
+        missing.push(display);
+    }
+    return { blocks, attached, missing };
+}

package/lib/types/dsh-adapter/channel/mode-actions.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import { type SessionModeSpec } from '../../sessionModes.js';
+import { type AdapterRuntimeOptions } from '../../adapter/kernel/runtime.js';
+import type { ChannelState } from './types.js';
+import type { createChannelBinding } from './binding.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+type ModeState = Pick<ChannelState, 'mode' | 'modeIndex' | 'emit'>;
+/** Durable session-mode folds and transitions. Construction is inert; root wires it after state construction. */
+export declare function createModeActions(ctx: Context, state: ModeState, deps: {
+    owner: {
+        current(): boolean;
+    };
+    runtime: AdapterRuntimeOptions;
+    binding: Pick<Binding, 'agent' | 'capture' | 'isCurrent'>;
+    sessionModes: readonly SessionModeSpec[];
+    commandService?: {
+        find(agent: Agent, name: string): unknown;
+    };
+    executeRegistryCommand(name: string, input: string): Promise<string | undefined>;
+    notify: ChannelState['notify'];
+}): {
+    refreshMode: () => void;
+    cycleMode: () => Promise<void>;
+    applyMode: (spec: SessionModeSpec, capture?: import("./binding.js").BindingCapture) => Promise<void>;
+    onSessionEvent: (session: Agent["session"], event: SessionEvent) => void;
+};
+export {};
+//# sourceMappingURL=mode-actions.d.ts.map

package/lib/types/dsh-adapter/channel/mode-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/mode-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAExD,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtD,KAAK,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC,CAAA;AAElE,iHAAiH;AACjH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE;IACJ,KAAK,EAAE;QAAE,OAAO,IAAI,OAAO,CAAA;KAAE,CAAA;IAC7B,OAAO,EAAE,qBAAqB,CAAA;IAC9B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC,CAAA;IACzD,YAAY,EAAE,SAAS,eAAe,EAAE,CAAA;IACxC,cAAc,CAAC,EAAE;QAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;IAC9D,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAChF,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;CAC/B;uBAyDqB,IAAI;qBAkJE,OAAO,CAAC,IAAI,CAAC;sBAlEV,eAAe,sDAAgC,OAAO,CAAC,IAAI,CAAC;8BAyE1D,KAAK,CAAC,SAAS,CAAC,SAAS,YAAY,KAAG,IAAI;EA4B9E"}