@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/dsh-adapter/channel/core/files.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Workspace files and slash completion for every session: the `fs` surface
+ * `@` mentions and file completion read (the host fs service, else the local
+ * disk where the backend runs on it), the fenced file queries, and the slash
+ * completion tree with whatever catalog the composition offers for
+ * `/model`, `/preset`, `/effort` and `/workspace` arguments. The backend's
+ * own commands join the command list itself (core/session-controls.ts), so
+ * completion lists them like any other entry.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CommandCompletionNode } from '../../../commands.js';
+import type { ChannelBinding } from '../binding.js';
+import type { ChannelOwner } from '../owner.js';
+import type { ChannelState, MentionFs } from '../types.js';
+import type { CoreHost } from './host.js';
+/** Argument catalogs the slash completion tree warms and reads. */
+export interface CompletionCatalog {
+    workspaceCommands(): readonly {
+        name: string;
+        aliases?: readonly string[];
+        description?: string;
+    }[];
+    model: {
+        warmModelNodes(): void;
+        modelNodes(): readonly CommandCompletionNode[];
+        warmPresetOptions(): void;
+        presetOptions(): readonly {
+            id: string;
+            description?: string;
+            name?: string;
+            isDefault?: boolean;
+        }[];
+        warmEffortLevels(): void;
+    };
+}
+/** No argument catalogs: the tree offers its static nodes only. */
+export declare const NO_COMPLETION_CATALOG: CompletionCatalog;
+export declare function createCoreFiles(ctx: Context, deps: {
+    owner: Pick<ChannelOwner, 'current' | 'signal'>;
+    binding: Pick<ChannelBinding, 'capture' | 'isCurrent'>;
+    state: () => ChannelState;
+    host: Pick<CoreHost, 'themeHost' | 'commandTrees'>;
+    /** Whether the local disk stands in for a missing host fs service. */
+    localFallback(): boolean;
+    /** The bound backend's MCP server names (`/mcp` completion). */
+    mcpServers?(): readonly string[] | undefined;
+}): {
+    fallbackFs: () => MentionFs | undefined;
+    listFileCandidates: (query: string, options?: {
+        signal?: AbortSignal;
+        topK?: number;
+    }) => Promise<readonly import("../../../utils/fileSuggestions.js").FileCandidate[]>;
+    listFiles: () => Promise<readonly string[]>;
+    /** The slash completion over the composition's argument catalogs. */
+    commandCompletions(catalog: CompletionCatalog): ChannelState["commandCompletions"];
+};
+//# sourceMappingURL=files.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/files.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAKnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,mEAAmE;AACnE,MAAM,WAAW,iBAAiB;IAChC,iBAAiB,IAAI,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACnG,KAAK,EAAE;QACL,cAAc,IAAI,IAAI,CAAA;QACtB,UAAU,IAAI,SAAS,qBAAqB,EAAE,CAAA;QAC9C,iBAAiB,IAAI,IAAI,CAAA;QACzB,aAAa,IAAI,SAAS;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,OAAO,CAAA;SAAE,EAAE,CAAA;QACpG,gBAAgB,IAAI,IAAI,CAAA;KACzB,CAAA;CACF;AAED,mEAAmE;AACnE,eAAO,MAAM,qBAAqB,EAAE,iBASnC,CAAA;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;IAClD,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,QAAQ,CAAC,CAAA;IAC/C,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,WAAW,CAAC,CAAA;IACtD,KAAK,EAAE,MAAM,YAAY,CAAA;IACzB,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,cAAc,CAAC,CAAA;IAClD,sEAAsE;IACtE,aAAa,IAAI,OAAO,CAAA;IACxB,gEAAgE;IAChE,UAAU,CAAC,IAAI,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;CAC7C;sBAIwB,SAAS,GAAG,SAAS;;cAvC1C,CAAC;YAAoB,CAAA;;;IAoDrB,qEAAqE;gCACzC,iBAAiB,GAAG,YAAY,CAAC,oBAAoB,CAAC;EAWrF"}

package/lib/types/dsh-adapter/channel/core/files.js

@@ -0,0 +1,45 @@
+import { createCommandCompletions } from '../command-completions.js';
+import { createFileActions } from '../file-actions.js';
+import { createLocalFs } from '../local-fs.js';
+import { mentionFs } from '../mentions.js';
+/** No argument catalogs: the tree offers its static nodes only. */
+export const NO_COMPLETION_CATALOG = {
+    workspaceCommands: () => [],
+    model: {
+        warmModelNodes: () => undefined,
+        modelNodes: () => [],
+        warmPresetOptions: () => undefined,
+        presetOptions: () => [],
+        warmEffortLevels: () => undefined,
+    },
+};
+export function createCoreFiles(ctx, deps) {
+    // The session's working directory is the local disk when the host mounts
+    // no fs service and the backend runs here (mentions and `@` completion).
+    const localFs = createLocalFs();
+    const fallbackFs = () => deps.localFallback() ? localFs : undefined;
+    const fs = () => mentionFs(ctx) ?? fallbackFs();
+    const fileActions = createFileActions({
+        owner: deps.owner,
+        capture: () => deps.binding.capture(),
+        current: capture => deps.binding.isCurrent(capture),
+        cwd: () => deps.state().cwd,
+        fs,
+    });
+    return {
+        fallbackFs,
+        listFileCandidates: fileActions.listFileCandidates,
+        listFiles: fileActions.listFiles,
+        /** The slash completion over the composition's argument catalogs. */
+        commandCompletions(catalog) {
+            return createCommandCompletions({
+                state: deps.state,
+                themeHost: deps.host.themeHost,
+                commandTrees: deps.host.commandTrees,
+                workspaceCommands: catalog.workspaceCommands,
+                ...(deps.mcpServers === undefined ? {} : { mcpServers: deps.mcpServers }),
+                model: catalog.model,
+            });
+        },
+    };
+}

package/lib/types/dsh-adapter/channel/core/host.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Host seams every channel composition reads: the optional Cordis service
+ * rows (themes, workspaces, command trees, scenes, settings sections,
+ * custom-entry renderers), the default-deny decision gate with its
+ * dispatch-topology marker, the runtime subscriptions that re-render on host
+ * changes, and the git-branch breadcrumb. Each lookup degrades when its row
+ * is not mounted, whatever backend serves the session.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AdapterRuntimeOptions } from '../../../adapter/kernel/runtime.js';
+import { readGrantStore } from '../../../adapter/standard/grants.js';
+import { getHostCommandTrees } from '../../command-trees.js';
+import { getHostRenderers } from '../../renderers.js';
+import { getHostSceneRuntime } from '../../scenes.js';
+import { getHostSettingsSections } from '../../settings-sections.js';
+import { getHostThemes } from '../../themes.js';
+import { createLocalWorkspaceRuntime, getHostWorkspaceRuntime } from '../../workspaces.js';
+import type { ChannelOwner } from '../owner.js';
+import type { ChannelState } from '../types.js';
+/** The host services a channel composition resolved at construction. */
+export interface CoreHost {
+    readonly adapterRuntime: AdapterRuntimeOptions;
+    readonly themeHost: ReturnType<typeof getHostThemes>;
+    /** Workspace registry runtime; the local-only runtime without the row. */
+    readonly workspaceService: NonNullable<ReturnType<typeof getHostWorkspaceRuntime>> | ReturnType<typeof createLocalWorkspaceRuntime>;
+    readonly commandTrees: ReturnType<typeof getHostCommandTrees>;
+    readonly sceneRuntime: ReturnType<typeof getHostSceneRuntime>;
+    readonly settingsSectionsRuntime: ReturnType<typeof getHostSettingsSections>;
+    readonly rendererRuntime: ReturnType<typeof getHostRenderers>;
+    /** The live grant store: the host-owned one when the plugin-host row is
+     *  mounted, else this channel's private fallback (re-read per operation). */
+    currentGrantStore(): ReturnType<typeof readGrantStore>;
+}
+/**
+ * Resolve the host seams and install the decision gate. The topology marker
+ * is effectful state, so it is owned at acquisition: a later construction
+ * failure rolls it back.
+ */
+export declare function resolveCoreHost(ctx: Context, owner: Pick<ChannelOwner, 'own'>): CoreHost;
+/** Re-render on settings-section and plugin-scene changes (owner-scoped). */
+export declare function startHostSubscriptions(host: Pick<CoreHost, 'settingsSectionsRuntime' | 'sceneRuntime'>, owner: Pick<ChannelOwner, 'own' | 'current'>, state: Pick<ChannelState, 'pluginScene' | 'emit'>): void;
+/**
+ * Statusline breadcrumb: the current git branch of the session cwd
+ * (best-effort, through the host `shell` service). Re-run when an adoption
+ * lands on a different cwd (/resume, /workspace, issue #96) so the
+ * breadcrumb never shows the previous workspace's branch.
+ */
+export declare function createGitBranchRefresher(ctx: Context, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    state: Pick<ChannelState, 'cwd' | 'gitBranch' | 'emit'>;
+    /** Record the resolved branch against the bound session (the session
+     *  browser's branch column); absent = nothing records it. */
+    noteBranch?(branch: string): void;
+}): () => void;
+//# sourceMappingURL=host.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/host.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAA;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAI5D,OAAO,EAAE,gBAAgB,EAA2B,MAAM,oBAAoB,CAAA;AAC9E,OAAO,EAAE,mBAAmB,EAAwB,MAAM,iBAAiB,CAAA;AAC3E,OAAO,EAAE,uBAAuB,EAAiE,MAAM,4BAA4B,CAAA;AACnI,OAAO,EAAE,aAAa,EAAwB,MAAM,iBAAiB,CAAA;AACrE,OAAO,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,wEAAwE;AACxE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAA;IAC9C,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAA;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,gBAAgB,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC,GAAG,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAA;IACnI,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;IAC7D,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;IAC7D,QAAQ,CAAC,uBAAuB,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAA;IAC5E,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;IAC7D;iFAC6E;IAC7E,iBAAiB,IAAI,UAAU,CAAC,OAAO,cAAc,CAAC,CAAA;CACvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,GAAG,QAAQ,CAyCxF;AAED,6EAA6E;AAC7E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,yBAAyB,GAAG,cAAc,CAAC,EAChE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,GAAG,SAAS,CAAC,EAC5C,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,GAAG,MAAM,CAAC,GAChD,IAAI,CAiBN;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;IAC3D,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,GAAG,WAAW,GAAG,MAAM,CAAC,CAAA;IACvD;iEAC6D;IAC7D,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC,GAAG,MAAM,IAAI,CA8Bb"}

package/lib/types/dsh-adapter/channel/core/host.js

@@ -0,0 +1,116 @@
+import { adapterRuntimeFor } from '../../../adapter/kernel/runtime-context.js';
+import { readGrantStore } from '../../../adapter/standard/grants.js';
+import { getHostCommandTrees } from '../../command-trees.js';
+import { runForegroundShell } from '../../compat/shell.js';
+import { installDecisionGuard, markDecisionDispatchTopology } from '../../decision-guard.js';
+import { getHostGrantStore } from '../../host-grants.js';
+import { getHostRenderers } from '../../renderers.js';
+import { getHostSceneRuntime } from '../../scenes.js';
+import { getHostSettingsSections, getLocalSettingsSectionsHost } from '../../settings-sections.js';
+import { getHostThemes } from '../../themes.js';
+import { createLocalWorkspaceRuntime, getHostWorkspaceRuntime } from '../../workspaces.js';
+/**
+ * Resolve the host seams and install the decision gate. The topology marker
+ * is effectful state, so it is owned at acquisition: a later construction
+ * failure rolls it back.
+ */
+export function resolveCoreHost(ctx, owner) {
+    const adapterRuntime = adapterRuntimeFor(ctx);
+    const themeHost = getHostThemes(ctx.get('tuiThemes'));
+    // Backstop: the extensions row installs the decision-subscription gate,
+    // but the channel is the dispatch path. A stale patch without that row (or
+    // a bare embed mounting neither) would otherwise leave tui/input and
+    // friends subscribable by default, silently voiding default-deny.
+    // Idempotent per cordis root, so the full-patch path installs exactly
+    // once whichever side runs first. Keep a private fallback for
+    // bare embedders, but resolve the host-owned store on every operation so
+    // a plugin-host row mounted later (or a custom live GrantStore) is not
+    // shadowed by an early snapshot.
+    const fallbackGrantStore = readGrantStore(undefined, undefined, adapterRuntime);
+    const currentGrantStore = () => getHostGrantStore(ctx.get('tuiPluginHost')) ?? fallbackGrantStore;
+    installDecisionGuard(ctx, currentGrantStore());
+    // The channel is the real DecisionEvents dispatch path. Record that
+    // topology so the live driver can distinguish "guard installed" (not a
+    // live feature) from "events can actually be dispatched here".
+    owner.own(markDecisionDispatchTopology(ctx));
+    return {
+        adapterRuntime,
+        themeHost,
+        // Workspace registry runtime (optional service, issue #183): mounted by
+        // the bundle patch's dsh-tui-workspaces row; absent the row (stale patch
+        // or a bare embedder), degrade to the local-only runtime.
+        workspaceService: getHostWorkspaceRuntime(ctx.get('tuiWorkspaces')) ?? createLocalWorkspaceRuntime(),
+        commandTrees: getHostCommandTrees(ctx.get('tuiCommandTrees')),
+        // Plugin scene runtime (optional, dsh-tui-scenes row): absent the row,
+        // `pluginScene` simply stays undefined.
+        sceneRuntime: getHostSceneRuntime(ctx.get('tuiScenes')),
+        // Falls back to the in-package local host when the composition's
+        // service row is unavailable (issue #557).
+        settingsSectionsRuntime: getHostSettingsSections(ctx.get('tuiSettingsSections')) ?? getLocalSettingsSectionsHost(ctx),
+        // Custom-entry text renderers (optional, dsh-tui-extensions row): absent
+        // the row, unknown plugin event types stay invisible in the transcript.
+        rendererRuntime: getHostRenderers(ctx.get('tuiRenderers')),
+        currentGrantStore,
+    };
+}
+/** Re-render on settings-section and plugin-scene changes (owner-scoped). */
+export function startHostSubscriptions(host, owner, state) {
+    owner.own(host.settingsSectionsRuntime?.subscribe(() => { if (owner.current())
+        state.emit(); }) ?? (() => undefined));
+    const sceneRuntime = host.sceneRuntime;
+    let unsubscribeScenes;
+    const disposeScenes = sceneRuntime?.subscribe(() => {
+        if (state.pluginScene === sceneRuntime.active)
+            return;
+        state.pluginScene = sceneRuntime.active;
+        state.emit();
+    });
+    if (disposeScenes !== undefined) {
+        unsubscribeScenes = disposeScenes;
+        owner.own(() => {
+            if (unsubscribeScenes !== disposeScenes)
+                return;
+            unsubscribeScenes = undefined;
+            disposeScenes();
+        });
+    }
+}
+/**
+ * Statusline breadcrumb: the current git branch of the session cwd
+ * (best-effort, through the host `shell` service). Re-run when an adoption
+ * lands on a different cwd (/resume, /workspace, issue #96) so the
+ * breadcrumb never shows the previous workspace's branch.
+ */
+export function createGitBranchRefresher(ctx, deps) {
+    return () => {
+        const { state } = deps;
+        state.gitBranch = undefined;
+        const shell = ctx.get('shell');
+        if (!shell)
+            return;
+        // Capture the requested cwd: a /resume landing while this query is in
+        // flight refreshes the branch for the new cwd, so a late reply from the
+        // old workspace must be dropped (stale statusline, issue #96).
+        const requestedCwd = state.cwd;
+        void runForegroundShell(shell, {
+            command: 'git branch --show-current',
+            workdir: requestedCwd,
+            timeoutMs: 3000,
+        })
+            .then((result) => {
+            if (!deps.owner.current() || state.cwd !== requestedCwd)
+                return;
+            const branch = result.stdout.text.trim();
+            if (branch !== '') {
+                state.gitBranch = branch;
+                deps.noteBranch?.(branch);
+                state.emit();
+            }
+        })
+            .catch(() => {
+            // Git branch detection is best-effort; on Windows the sandbox
+            // backend may be unavailable (no confinement yet) or the cwd may
+            // not be a git repo. Either way the statusline simply stays blank.
+        });
+    };
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Local-only transcript actions every session gets: `/clear`, local report
+ * rows, `!cmd` / `!!cmd` through the session's workspace shell,
+ * `/activity frames`, and the "load earlier" restore of folded rows. The
+ * restore only works when the backend can slice its own durable history;
+ * otherwise nothing is ever folded and the action restores 0 rows.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ChannelBinding } from '../binding.js';
+import type { ChannelOwner } from '../owner.js';
+import type { ChannelState } from '../types.js';
+import type { CoreHost } from './host.js';
+/** `/activity frames <name>`: validate, persist, re-render. */
+export declare function setActivityFrames(state: Pick<ChannelState, 'activityFrames' | 'emit'>, notify: ChannelState['notify'], name: string): boolean;
+export declare function createCoreLocalActions(ctx: Context, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<ChannelBinding, 'capture' | 'isCurrent'>;
+    state: ChannelState;
+    rowIds: {
+        value: number;
+    };
+    workspace: CoreHost['workspaceService'];
+    resetProjection(): void;
+    notify: ChannelState['notify'];
+    unavailable(name: string): void;
+    /** Extension projections whose rows `/clear` drops with the transcript. */
+    dropRows(): void;
+    /** Restore folded rows from the backend's durable history; absent = the
+     *  backend cannot slice it (and nothing is folded). */
+    loadOlder(): (() => number) | undefined;
+    /** An input on its way to the session (`!!`): returns its end. */
+    beginInput?(): () => void;
+}): {
+    loadOlder(): number;
+    clear(): void;
+    pushLocal(title: string, lines: readonly string[]): void;
+    setActivityFrames: (name: string) => boolean;
+    /**
+     * `!cmd` / `!!cmd`: the workspace's own command shell when it has one
+     * (a remote workspace runs the command there), else the host shell;
+     * `!!` sends the output on as a followup of the session it ran for.
+     */
+    runLocalCommand(command: string, includeInContext: boolean): Promise<void>;
+};
+export type CoreLocalActions = ReturnType<typeof createCoreLocalActions>;
+//# sourceMappingURL=local-actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-actions.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/local-actions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAOlD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,gBAAgB,GAAG,MAAM,CAAC,EACpD,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC9B,IAAI,EAAE,MAAM,GACX,OAAO,CAYT;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;IACzD,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,WAAW,CAAC,CAAA;IACtD,KAAK,EAAE,YAAY,CAAA;IACnB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACzB,SAAS,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAA;IACvC,eAAe,IAAI,IAAI,CAAA;IACvB,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;IAC9B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,2EAA2E;IAC3E,QAAQ,IAAI,IAAI,CAAA;IAChB;2DACuD;IACvD,SAAS,IAAI,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAA;IACvC,kEAAkE;IAClE,UAAU,CAAC,IAAI,MAAM,IAAI,CAAA;CAC1B;iBAIgB,MAAM;aAQV,IAAI;qBAYI,MAAM,SAAS,SAAS,MAAM,EAAE,GAAG,IAAI;8BAM9B,MAAM,KAAG,OAAO;IAE1C;;;;OAIG;6BAC4B,MAAM,oBAAoB,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;EA8CnF;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -0,0 +1,117 @@
+import { randomUUID } from 'node:crypto';
+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 { runForegroundShell } from '../../compat/shell.js';
+import { LOCAL_OUTPUT_LIMIT, preview } from '../transcript.js';
+/** `/activity frames <name>`: validate, persist, re-render. */
+export function setActivityFrames(state, notify, 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;
+}
+export function createCoreLocalActions(ctx, deps) {
+    const { owner, binding, state, rowIds, notify } = deps;
+    return {
+        loadOlder() {
+            const restore = deps.loadOlder();
+            if (restore === undefined)
+                return 0;
+            const restored = restore();
+            if (restored > 0)
+                state.emit();
+            return restored;
+        },
+        clear() {
+            state.rows.length = 0;
+            markChannelReadDirty(state.rows);
+            rowIds.value = 0;
+            deps.resetProjection();
+            deps.dropRows();
+            state.activeToolCount = 0;
+            state.responseChars = 0;
+            state.rows.push({ id: rowIds.value++, kind: 'notice', text: t('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) => setActivityFrames(state, notify, name),
+        /**
+         * `!cmd` / `!!cmd`: the workspace's own command shell when it has one
+         * (a remote workspace runs the command there), else the host shell;
+         * `!!` sends the output on as a followup of the session it ran for.
+         */
+        async runLocalCommand(command, includeInContext) {
+            // `!!` is an input from its first keystroke: `/new` must not adopt
+            // over a command whose output is about to reach this session.
+            const end = includeInContext ? deps.beginInput?.() : undefined;
+            try {
+                await runLocal(command, includeInContext);
+            }
+            finally {
+                end?.();
+            }
+        },
+    };
+    async function runLocal(command, includeInContext) {
+        const capture = binding.capture();
+        const current = () => owner.current() && binding.isCurrent(capture);
+        const cwd = state.cwd;
+        const target = deps.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();
+        const executor = await deps.workspace.commandShell(cwd) ?? ctx.get('shell');
+        if (!current())
+            return;
+        if (executor === undefined) {
+            deps.unavailable('shell');
+            return;
+        }
+        let output;
+        try {
+            const result = await runForegroundShell(executor, { 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())
+            return;
+        state.rows.push({ id: rowIds.value++, kind: 'local-output', text: preview(output, LOCAL_OUTPUT_LIMIT) });
+        state.emit();
+        if (includeInContext) {
+            // This runs detached (`void runLocalCommand`): a session that closed
+            // meanwhile (a backend process that exited) must not surface as an
+            // unhandled rejection.
+            try {
+                await capture.session.submit({ text: `<bash-stdout>\n${output}\n</bash-stdout>`, clientMessageId: randomUUID() }, 'followup');
+            }
+            catch (error) {
+                if (current())
+                    notify(t('send-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { TranscriptImage } from '../../../adapter/ports/channel-view.js';
+import type { ImageLimitsView } from '../../../agent/capabilities.js';
+import type { MentionAttachments, MentionImageBlock } from '../types.js';
+type ImageRef = MentionImageBlock['attachment'];
+/** Images kept in memory at most (oldest dropped first). */
+export declare const LOCAL_IMAGE_LIMIT = 64;
+/** Bytes kept in memory at most (oldest dropped first). */
+export declare const LOCAL_IMAGE_BYTES: number;
+/** The local store: the attachments subset the composer and `@` expansion
+ *  use, plus the facades rows show. */
+export interface LocalImageStore extends MentionAttachments {
+    /** The lazily-read facade of a staged image (one object per id). */
+    facade(attachment: ImageRef): TranscriptImage | undefined;
+    /** The staged bytes, while kept. */
+    bytes(attachmentId: string): Uint8Array | undefined;
+}
+/** Create the store over the limits of the bound session (read per call). */
+export declare function createLocalImageStore(limits: () => ImageLimitsView): LocalImageStore;
+export {};
+//# sourceMappingURL=local-images.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-images.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/local-images.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAErE,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAyB,MAAM,aAAa,CAAA;AAE/F,KAAK,QAAQ,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAA;AAE/C,4DAA4D;AAC5D,eAAO,MAAM,iBAAiB,KAAK,CAAA;AACnC,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB,QAAmB,CAAA;AAOjD;uCACuC;AACvC,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD,oEAAoE;IACpE,MAAM,CAAC,UAAU,EAAE,QAAQ,GAAG,eAAe,GAAG,SAAS,CAAA;IACzD,oCAAoC;IACpC,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAA;CACpD;AAID,6EAA6E;AAC7E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,eAAe,GAAG,eAAe,CA8GpF"}

package/lib/types/dsh-adapter/channel/core/local-images.js

@@ -0,0 +1,147 @@
+/**
+ * Image staging for a session that takes images without the DSH attachments
+ * service. A backend that declares the `images` capability (the Claude
+ * backend sends images as base64 blocks of the message itself) gets the
+ * composer's pasted images and `@`-mentioned image files staged here, with
+ * the bytes held in memory and never written anywhere. The backend's declared
+ * limits apply through the same limit model the DSH store uses
+ * (`imageLimits`: media types, per-image and per-message bytes, image count,
+ * per-side and total pixel caps) and the same ingress adaptation
+ * (`adaptImageForAdmission`: an unaccepted format is converted, an oversize
+ * image resampled, when sharp is available).
+ *
+ * The staged reference has the DSH shape (`ImageAttachmentRef`), so the
+ * composer, the `@` expansion and the input pipeline treat it exactly as a
+ * stored attachment; its id is local (`local-<sha256 prefix>`, content-
+ * addressed). The facade a transcript row shows reads the same bytes back.
+ *
+ * Bounded: at most {@link LOCAL_IMAGE_LIMIT} images and
+ * {@link LOCAL_IMAGE_BYTES} bytes, the oldest dropped first. A facade whose
+ * bytes were dropped reports itself unavailable (the row shows the
+ * placeholder); it never holds bytes of its own.
+ */
+import { createHash } from 'node:crypto';
+import { adaptImageForAdmission, probeImageSize, sniffImageMediaType, withinDimensionLimits } from '../../../utils/imageResize.js';
+/** Images kept in memory at most (oldest dropped first). */
+export const LOCAL_IMAGE_LIMIT = 64;
+/** Bytes kept in memory at most (oldest dropped first). */
+export const LOCAL_IMAGE_BYTES = 96 * 1024 * 1024;
+const IMAGE_TYPES = ['image/png', 'image/jpeg', 'image/webp', 'image/gif'];
+/** Create the store over the limits of the bound session (read per call). */
+export function createLocalImageStore(limits) {
+    const images = new Map();
+    const facades = new Map();
+    let total = 0;
+    const imageLimits = () => {
+        const view = limits();
+        return {
+            maxImageBytes: view.maxImageBytes,
+            maxImagesPerMessage: view.maxImagesPerMessage,
+            maxMessageImageBytes: view.maxMessageImageBytes,
+            maxImageDimension: view.maxImageDimension,
+            maxImagePixels: view.maxImagePixels,
+            mediaTypes: IMAGE_TYPES.filter(type => view.mediaTypes.includes(type)),
+        };
+    };
+    const evict = () => {
+        for (const [id, entry] of images) {
+            if (images.size <= LOCAL_IMAGE_LIMIT && total <= LOCAL_IMAGE_BYTES)
+                break;
+            images.delete(id);
+            facades.delete(id);
+            total -= entry.data.byteLength;
+        }
+    };
+    const facade = (ref) => {
+        const id = String(ref.attachmentId);
+        const known = facades.get(id);
+        if (known !== undefined)
+            return known;
+        const view = {
+            id,
+            width: ref.width,
+            height: ref.height,
+            ...(ref.name === undefined ? {} : { name: ref.name }),
+            mediaType: ref.mediaType,
+            bytes: ref.bytes,
+            read: () => {
+                const stored = images.get(id);
+                return stored === undefined
+                    ? Promise.reject(new Error('the image is no longer held in memory'))
+                    : Promise.resolve(stored.data);
+            },
+        };
+        facades.set(id, view);
+        return view;
+    };
+    return {
+        get imageLimits() { return imageLimits(); },
+        async saveImage(input) {
+            const caps = imageLimits();
+            let data = input.data;
+            let mediaType = input.mediaType;
+            // The content wins over the label: a paste or @-mention declares a
+            // media type from the filename, and a renamed file would otherwise be
+            // sent to the backend under a type its bytes contradict. The sniff
+            // reads magic bytes only (no decode, no re-encode), so a mislabeled
+            // image keeps its bytes, animation included. Content it cannot identify
+            // takes the decode-or-refuse path below with the declared label.
+            const sniffed = sniffImageMediaType(data);
+            if (sniffed !== undefined && sniffed !== mediaType)
+                mediaType = sniffed;
+            const dimensions = { maxImageDimension: caps.maxImageDimension, maxImagePixels: caps.maxImagePixels };
+            let size = probeImageSize(data);
+            let originalDimensions;
+            const accepted = caps.mediaTypes.includes(mediaType);
+            if (!accepted || size === null || !withinDimensionLimits(size, dimensions)) {
+                const outcome = await adaptImageForAdmission(data, mediaType, dimensions, caps.mediaTypes);
+                if (outcome.kind === 'adapted') {
+                    if (size !== null && outcome.resized)
+                        originalDimensions = { width: size.width, height: size.height };
+                    data = outcome.data;
+                    mediaType = outcome.mediaType;
+                    size = { width: outcome.width, height: outcome.height };
+                }
+                else if (outcome.kind === 'unavailable') {
+                    if (!accepted)
+                        throw new Error(`${mediaType} images are not accepted by this backend and could not be converted (${outcome.detail})`);
+                    if (size === null)
+                        throw new Error(`the image could not be measured (${outcome.detail})`);
+                    // An accepted format the gate could not resample: the backend's
+                    // own downscaling is the backstop (its hard caps are larger).
+                }
+            }
+            if (size === null)
+                throw new Error('the image could not be measured');
+            if (!caps.mediaTypes.includes(mediaType))
+                throw new Error(`${mediaType} images are not accepted by this backend`);
+            if (data.byteLength > caps.maxImageBytes)
+                throw new Error('the image exceeds the backend\'s per-image size limit');
+            const attachmentId = `local-${createHash('sha256').update(data).digest('hex').slice(0, 32)}`;
+            const ref = {
+                attachmentId,
+                mediaType,
+                bytes: data.byteLength,
+                width: size.width,
+                height: size.height,
+                ...(input.name === undefined ? {} : { name: input.name }),
+                ...(originalDimensions === undefined ? {} : { originalDimensions }),
+            };
+            const known = images.get(attachmentId);
+            if (known !== undefined) {
+                // Content-addressed: the same bytes again move to the newest slot.
+                images.delete(attachmentId);
+                images.set(attachmentId, known);
+                return known.ref;
+            }
+            images.set(attachmentId, { data, ref });
+            total += data.byteLength;
+            evict();
+            return ref;
+        },
+        facade(attachment) {
+            return images.has(String(attachment.attachmentId)) ? facade(attachment) : undefined;
+        },
+        bytes: attachmentId => images.get(attachmentId)?.data,
+    };
+}

package/lib/types/dsh-adapter/channel/core/reports.d.ts

@@ -0,0 +1,12 @@
+import type { ChannelBinding } from '../binding.js';
+import type { ChannelOwner } from '../owner.js';
+import type { ChannelState } from '../types.js';
+export declare function createCoreReports(deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<ChannelBinding, 'session' | 'capture' | 'isCurrent'>;
+    state: () => Pick<ChannelState, 'rows' | 'model' | 'cwd' | 'contextWindow' | 'agentId' | 'backendCapabilities'>;
+}): {
+    doctorInfo: () => string[];
+    exportSession: () => string | null;
+};
+//# sourceMappingURL=reports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reports.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/reports.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAW,MAAM,aAAa,CAAA;AAwBxD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC,CAAA;IAClE,KAAK,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,eAAe,GAAG,SAAS,GAAG,qBAAqB,CAAC,CAAA;CAChH;sBAEwB,MAAM,EAAE;yBAoBL,MAAM,GAAG,IAAI;EAqBxC"}