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

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

@@ -0,0 +1,77 @@
+/**
+ * Reports every session gets: `/doctor` (the backend-neutral facts plus the
+ * backend's own diagnostics lines) and `/export` (the projected transcript as
+ * Markdown in the working directory). A composition with a richer source
+ * overrides them; the DSH extension exports the durable session log.
+ */
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { t } from '../../../i18n.js';
+/** One transcript row as an export section; undefined = not exported. */
+function exportSection(row) {
+    switch (row.kind) {
+        case 'user':
+            return row.text === '' ? undefined : `${t('export-user-section')}\n\n${row.text}\n`;
+        case 'reasoning':
+            return row.text === '' ? undefined : `${t('export-thinking-section')}\n\n${row.text}\n`;
+        case 'assistant':
+            return row.text === '' ? undefined : `${t('export-assistant-section')}\n\n${row.text}\n`;
+        case 'tool': {
+            const tool = row.tool;
+            if (tool === undefined)
+                return undefined;
+            const parts = [`${t('export-tool-section', { name: tool.name })}\n\n\`\`\`json\n${tool.argsFull ?? tool.argsText}\n\`\`\`\n`];
+            const result = tool.resultFull ?? tool.resultText ?? tool.errorText;
+            if (result !== undefined && result !== '')
+                parts.push(`${t('export-result-section')}\n\n\`\`\`\n${result}\n\`\`\`\n`);
+            return parts.join('\n');
+        }
+        default:
+            return undefined;
+    }
+}
+export function createCoreReports(deps) {
+    /** `/doctor`: the backend-neutral facts plus the backend's own lines. */
+    const doctorInfo = () => {
+        const session = deps.binding.session;
+        const state = deps.state();
+        const label = state.backendCapabilities.backendLabel;
+        return [
+            `Node ${process.version} · ${process.platform} ${process.arch}`,
+            t('doctor-backend', { label, id: session.ref.backendId }),
+            t('doctor-model', { model: state.model || t('doctor-unknown'), provider: label }),
+            t('doctor-cwd', { cwd: state.cwd }),
+            t('doctor-context-window', { window: state.contextWindow ?? t('doctor-unknown') }),
+            t('doctor-session', { id: session.ref.sessionId }),
+            ...session.capabilities.diagnostics?.lines() ?? [],
+        ];
+    };
+    /**
+     * `/export`: the transcript as this channel projected it (user, thinking,
+     * assistant and tool rows), written next to the session's work. Returns
+     * the file path, or null when the binding moved on or the write failed.
+     */
+    const exportSession = () => {
+        const capture = deps.binding.capture();
+        const current = () => deps.owner.current() && deps.binding.isCurrent(capture);
+        const state = deps.state();
+        const parts = [t('export-title'), '', t('export-time', { time: new Date().toLocaleString() }),
+            t('export-model', { model: state.model }), t('export-session', { id: state.agentId }), t('export-dir', { cwd: state.cwd }), ''];
+        for (const row of state.rows) {
+            const section = exportSection(row);
+            if (section !== undefined)
+                parts.push(section);
+        }
+        if (!current())
+            return null;
+        try {
+            const target = join(state.cwd, `dsh-tui-export-${Date.now()}.md`);
+            writeFileSync(target, parts.join('\n'), 'utf8');
+            return current() ? target : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    return { doctorInfo, exportSession };
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Session-level facts a backend reports through its typed capabilities: its
+ * native permission mode, reasoning effort, own slash commands, subscription
+ * usage, and the context / MCP reports the synchronous `/context` and `/mcp`
+ * read. The shared projector owns the transcript; these are the facts it
+ * leaves to the channel. A composition whose extension maintains these facts
+ * itself (DSH) never installs the observer (`ownsSessionFacts`).
+ */
+import type { LocalCommand } from '../../../adapter/ports/channel-catalog.js';
+import type { AgentEvent } from '../../../agent/events.js';
+import type { AgentSession } from '../../../agent/session.js';
+import type { ChannelState } from '../types.js';
+/** The built-in commands a capability snapshot serves, in catalog order. A
+ *  snapshot serving every built-in keeps the catalog itself (identity).
+ *  `permission` is not a LOCAL_COMMANDS name: it appears only when the
+ *  snapshot appended it for the session's typed `modes` capability (see
+ *  channel/capabilities.ts), and then rides as BACKEND_PERMISSION_COMMAND.
+ *  `channel` follows the same ride-along for the typed `channels`
+ *  capability (BACKEND_CHANNEL_COMMAND), `goal` for `goals`
+ *  (BACKEND_GOAL_COMMAND). */
+export declare function localCommandsFor(names: readonly string[]): readonly LocalCommand[];
+export declare function createSessionControls(deps: {
+    state: () => ChannelState;
+    /** The user-facing backend name the backend's own commands are tagged with. */
+    backendLabel(): string;
+}): {
+    seed: (session: AgentSession, current: () => boolean) => void;
+    observe: (batch: readonly AgentEvent[], session: AgentSession, current: () => boolean) => void;
+    reset: () => void;
+    refreshCommandList: () => void;
+    /** Re-resolve the channel model display now (the /channel switch path). */
+    refreshModelDisplay: (session: AgentSession) => void;
+    /** The last MCP report, refreshing it for next time (`/mcp` is synchronous). */
+    mcpReport(session: AgentSession, current: () => boolean): string[] | undefined;
+    /** The server names of the last report (undefined before one). */
+    mcpServers: () => readonly string[] | undefined;
+};
+export type SessionControls = ReturnType<typeof createSessionControls>;
+//# sourceMappingURL=session-controls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-controls.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/session-controls.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAA;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAI7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;;;;8BAO8B;AAC9B,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,YAAY,EAAE,CASlF;AAMD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,KAAK,EAAE,MAAM,YAAY,CAAA;IACzB,+EAA+E;IAC/E,YAAY,IAAI,MAAM,CAAA;CACvB;oBAoGwB,YAAY,WAAW,MAAM,OAAO,KAAG,IAAI;qBA+B1C,SAAS,UAAU,EAAE,WAAW,YAAY,WAAW,MAAM,OAAO,KAAG,IAAI;iBAyCjF,IAAI;8BApKS,IAAI;IAgLjC,2EAA2E;mCA5DvC,YAAY,KAAG,IAAI;IA8DvD,gFAAgF;uBAC7D,YAAY,WAAW,MAAM,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS;IAI9E,kEAAkE;sBAClD,SAAS,MAAM,EAAE,GAAG,SAAS;EAEhD;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/lib/types/dsh-adapter/channel/core/session-controls.js

@@ -0,0 +1,219 @@
+import { BACKEND_CHANNEL_COMMAND, BACKEND_GOAL_COMMAND, BACKEND_PERMISSION_COMMAND, LOCAL_COMMANDS } from '../../../commands.js';
+import { t } from '../../../i18n.js';
+import { logForDebugging } from '../../../utils/debug.js';
+/** The built-in commands a capability snapshot serves, in catalog order. A
+ *  snapshot serving every built-in keeps the catalog itself (identity).
+ *  `permission` is not a LOCAL_COMMANDS name: it appears only when the
+ *  snapshot appended it for the session's typed `modes` capability (see
+ *  channel/capabilities.ts), and then rides as BACKEND_PERMISSION_COMMAND.
+ *  `channel` follows the same ride-along for the typed `channels`
+ *  capability (BACKEND_CHANNEL_COMMAND), `goal` for `goals`
+ *  (BACKEND_GOAL_COMMAND). */
+export function localCommandsFor(names) {
+    if (names.length === LOCAL_COMMANDS.length && LOCAL_COMMANDS.every((command, index) => command.name === names[index]))
+        return LOCAL_COMMANDS;
+    const served = LOCAL_COMMANDS.filter(command => names.includes(command.name));
+    const appended = [
+        ...(names.includes('permission') ? [BACKEND_PERMISSION_COMMAND] : []),
+        ...(names.includes('channel') ? [BACKEND_CHANNEL_COMMAND] : []),
+        ...(names.includes('goal') ? [BACKEND_GOAL_COMMAND] : []),
+    ];
+    return appended.length === 0 ? served : [...served, ...appended];
+}
+const debugFailure = (what) => (error) => {
+    logForDebugging(`channel: ${what} failed (${error instanceof Error ? error.message : String(error)})`);
+};
+export function createSessionControls(deps) {
+    /** The backend's own commands, merged after the local ones. */
+    let backendCommands = [];
+    /** `/mcp` is synchronous: it reads the last report (refreshed per turn). */
+    let mcpLines;
+    /** The servers of that report (`/mcp reconnect|toggle` completion). */
+    let mcpNames;
+    const refreshCommandList = () => {
+        const state = deps.state();
+        // Local names win, served here or not: a typed `/init` is the local
+        // command (or its explicit unavailability), never the backend's. A
+        // served `/goal` (the typed capability) wins over a same-named backend
+        // command the same way.
+        const served = localCommandsFor(state.backendCapabilities.commands);
+        const local = new Set([...LOCAL_COMMANDS.map(command => command.name), ...(served.includes(BACKEND_GOAL_COMMAND) ? [BACKEND_GOAL_COMMAND.name] : [])]);
+        state.commandList = backendCommands.length === 0
+            ? served
+            : [...served, ...backendCommands.filter(command => !local.has(command.name))];
+    };
+    const loadBackendCommands = (session, current) => {
+        const commands = session.capabilities.commands;
+        if (commands === undefined)
+            return;
+        void commands.list().then(list => {
+            if (!current())
+                return;
+            backendCommands = list.map(command => ({
+                name: command.name,
+                description: command.description ?? '',
+                tag: deps.backendLabel(),
+                skill: true,
+                origin: 'backend',
+            }));
+            refreshCommandList();
+            deps.state().emit();
+        }).catch(debugFailure('backend commands'));
+    };
+    /** The native mode as the status line shows it: the base mode unmarked,
+     *  any other one labelled by the backend (plan mode in its own colour). */
+    const applyMode = (session, modeId) => {
+        const state = deps.state();
+        const list = session.capabilities.modes?.list() ?? [];
+        const index = list.findIndex(mode => mode.id === modeId);
+        state.mode = { id: `${session.ref.backendId}:${modeId}`, label: list[index]?.label ?? modeId, ...(modeId === 'plan' ? { plan: true } : {}) };
+        state.modeIndex = index === 0 ? 0 : Math.max(1, index);
+    };
+    const applyEffort = (session, effort) => {
+        const state = deps.state();
+        const levels = session.capabilities.effort?.levels() ?? [];
+        state.effortLevels = levels.length === 0 ? undefined : levels.map(level => level.id);
+        state.reasoningEffort = effort ?? undefined;
+    };
+    const refreshMcp = (session, current) => {
+        const mcp = session.capabilities.mcp;
+        if (mcp === undefined)
+            return;
+        void mcp.status().then(servers => {
+            if (!current())
+                return;
+            mcpNames = servers.map(server => server.name);
+            mcpLines = servers.length === 0
+                ? [t('backend-mcp-none')]
+                : [
+                    t('backend-mcp-heading', { n: servers.length }),
+                    ...servers.map(server => t('backend-mcp-row', {
+                        name: server.name,
+                        status: server.status,
+                        tools: server.toolCount === undefined ? '' : t('backend-mcp-tools', { n: server.toolCount }),
+                    })),
+                    ...(servers.some(server => server.status === 'needs-auth') ? [t('backend-mcp-needs-auth')] : []),
+                ];
+        }).catch(debugFailure('mcp status'));
+    };
+    /** `/context` reads `loadedContext`: the backend's own measurement. */
+    const refreshContext = (session, current) => {
+        const context = session.capabilities.context;
+        if (context === undefined)
+            return;
+        void context.usage('summary').then(usage => {
+            if (!current())
+                return;
+            const state = deps.state();
+            const tokens = (n) => t('context-tokens', { n: n.toLocaleString() });
+            // The summary report may carry no per-section split (the CLI answers
+            // it from the last response's usage): the used categories stand in.
+            const sections = usage.sections ?? [];
+            const used = usage.categories.filter(category => category.kind === 'used');
+            state.loadedContext = {
+                sections: (sections.length > 0 ? sections : used).map(item => ({ name: item.name, text: tokens(item.tokens) })),
+                contexts: sections.length > 0 ? used.map(category => ({ name: category.name, text: tokens(category.tokens) })) : [],
+                files: (usage.files ?? []).map(file => ({ displayPath: file.path.startsWith(`${state.cwd}/`) ? `./${file.path.slice(state.cwd.length + 1)}` : file.path })),
+                skills: (usage.skills ?? []).map(skill => ({ name: skill.name, description: tokens(skill.tokens) })),
+                tools: (usage.tools ?? []).map(tool => ({ name: tool.server === undefined ? tool.name : `${tool.server} › ${tool.name}`, description: tokens(tool.tokens) })),
+            };
+            if (state.contextWindow === undefined && usage.max !== undefined && usage.max > 0)
+                state.contextWindow = usage.max;
+            state.emit();
+        }).catch(debugFailure('context usage'));
+    };
+    /** A freshly bound session: read what it already knows. */
+    const seed = (session, current) => {
+        backendCommands = [];
+        mcpLines = undefined;
+        mcpNames = undefined;
+        const modes = session.capabilities.modes;
+        if (modes !== undefined)
+            applyMode(session, modes.current());
+        if (session.capabilities.effort !== undefined)
+            applyEffort(session, session.capabilities.effort.current());
+        // Rebuild even when the backend exposes no commands capability of its
+        // own: the capability snapshot may still append /permission for the
+        // modes capability, and the first paint must offer it.
+        refreshCommandList();
+        loadBackendCommands(session, current);
+        refreshMcp(session, current);
+        refreshContext(session, current);
+    };
+    /**
+     * Footer model name: when the backend maps the live model id to the model
+     * that actually serves the request (relay channels echo the requested id
+     * back, see backends/claude/modelEnv.ts), the footer shows the mapped
+     * name; data surfaces keep the raw id. A /channel switch also calls this:
+     * the backend reads the mapping lazily, so re-running it after the store
+     * changed repaints the footer immediately.
+     */
+    const refreshModelDisplay = (session) => {
+        const state = deps.state();
+        const display = session.capabilities.models?.display?.();
+        state.modelDisplay = display !== undefined && display !== state.model ? display : undefined;
+    };
+    /** The session-level events of one admitted batch. */
+    const observe = (batch, session, current) => {
+        let changed = false;
+        for (const event of batch) {
+            switch (event.type) {
+                case 'mode.changed':
+                    applyMode(session, event.modeId);
+                    changed = true;
+                    break;
+                case 'effort.changed':
+                    applyEffort(session, event.effort);
+                    changed = true;
+                    break;
+                case 'model.changed':
+                case 'session.ready': {
+                    // Effort levels follow the model.
+                    if (event.type === 'model.changed' && session.capabilities.effort !== undefined) {
+                        applyEffort(session, session.capabilities.effort.current());
+                    }
+                    refreshModelDisplay(session);
+                    changed = true;
+                    break;
+                }
+                case 'commands.changed':
+                    loadBackendCommands(session, current);
+                    break;
+                case 'rate-limit':
+                    deps.state().rateLimit = { windows: event.info.windows };
+                    changed = true;
+                    break;
+                case 'turn.end':
+                    refreshContext(session, current);
+                    refreshMcp(session, current);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (changed)
+            deps.state().emit();
+    };
+    /** A session switch: forget the replaced session's commands and reports. */
+    const reset = () => {
+        backendCommands = [];
+        mcpLines = undefined;
+        mcpNames = undefined;
+        refreshCommandList();
+    };
+    return {
+        seed,
+        observe,
+        reset,
+        refreshCommandList,
+        /** Re-resolve the channel model display now (the /channel switch path). */
+        refreshModelDisplay,
+        /** The last MCP report, refreshing it for next time (`/mcp` is synchronous). */
+        mcpReport(session, current) {
+            refreshMcp(session, current);
+            return mcpLines;
+        },
+        /** The server names of the last report (undefined before one). */
+        mcpServers: () => mcpNames,
+    };
+}

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

@@ -0,0 +1,174 @@
+/**
+ * Session switching every composition shares: the `tui/session-switch` veto,
+ * the fire-and-forget `tui/session-switched` notice, `/new` and the generic
+ * `/resume`. Each is one prepare-then-adopt transaction over the binding,
+ * with the backend's way of opening the session injected. The DSH extension
+ * injects its create path (preset, route, mount reservation, workspace
+ * attach) and keeps its own `/resume`, which parks sessions in this process;
+ * any other backend opens through `ChannelLaunchOptions.openSession`.
+ *
+ * `/new` and `/resume` refuse while a turn runs, and re-check after the open.
+ * A backend handshake can take long (the Claude CLI: up to a minute), and a
+ * prompt the user sent to the current session meanwhile must not be torn
+ * down by the adoption that disposes it, so the candidate is abandoned
+ * instead.
+ *
+ * `/resume` reads the target's durable history before the synchronous
+ * adoption and paints it inside the adoption, ahead of the subscription, so
+ * nothing the live session emits can land before its history. The
+ * cross-process mount ledger is claimed under the backend-qualified key
+ * (`claude:<id>`) for the whole attempt, like a DSH disk resume: a session
+ * another TUI process drives is refused.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentEvent } from '../../../agent/events.js';
+import type { AgentSession } from '../../../agent/session.js';
+import { reserveMount } from '../../../sessionMounts.js';
+import type { ChannelCapabilities } from '../../../adapter/ports/channel-view.js';
+import type { ChannelBinding } from '../binding.js';
+import type { ChannelOwner } from '../owner.js';
+import type { ChannelLaunchOptions } from '../state.js';
+import type { ChannelState, ResumeResult } from '../types.js';
+export type SessionSwitchKind = 'new' | 'resume' | 'agent-view';
+export type SessionSwitchedKind = 'new' | 'resume' | 'rewind' | 'fork' | 'agent-view' | 'background';
+/** A guarded workspace handoff (`/workspace`); never on `ChannelUi.newSession()`. */
+export interface NewSessionTarget {
+    readonly cwd: string;
+    readonly displayCwd?: string;
+}
+/** One `/new` attempt as the backend opens it. */
+export interface NewSessionPlan {
+    /** Claim whatever the attempt must hold before the session exists (DSH:
+     *  the cross-process mount ledger). Runs once, after planning. */
+    reserve?(): Promise<void>;
+    /** Open the fresh session; runs inside the binding's `prepare`. */
+    open(cwd: string): Promise<AgentSession>;
+    /** Ownership work between preparation and adoption (DSH: workspace
+     *  attachment); may notify, must not throw. */
+    attach?(candidate: AgentSession, current: () => boolean): Promise<void>;
+    /** The backend's half of the synchronous adoption tail: reset and bind
+     *  the candidate. Returns the id the session-switched notice names. */
+    adopt(candidate: AgentSession): string;
+    /** Exactly once on every exit after `reserve`: keep (commit) or release
+     *  what the plan holds. */
+    finish?(committed: boolean): void;
+}
+/** How a backend opens a fresh session for `/new`. */
+export interface NewSessionOpener {
+    /**
+     * What happens to an input still in the channel's FIFO when `/new` adopts
+     * (a parked `tui/input` decision, an `@` or IDE read). `true`: it is
+     * stale-dropped with a notice and never delivered (DSH, pinned by
+     * verify-session-reset-hygiene scenario 8). Absent: the input belongs to
+     * the session it was typed in, so `/new` is abandoned instead (a backend
+     * handshake can take a minute).
+     */
+    readonly dropsParkedInputs?: boolean;
+    /** Synchronous gate before anything else (throws to refuse). */
+    assertAllowed?(): void;
+    /** Whether a session can be opened at all; notifies when not. */
+    available(): boolean;
+    /** Everything between the veto and the open. `undefined` stops quietly
+     *  (the binding moved on); a throw becomes the `new-session-failed` notice. */
+    plan(target: {
+        readonly cwd: string;
+    }, current: () => boolean): Promise<NewSessionPlan | undefined>;
+}
+/** One `/resume` attempt (or a rewind's adoption of its fork) as the
+ *  backend opens it. */
+export interface ResumeSessionPlan {
+    /** Claim the session before it opens (the cross-process mount ledger);
+     *  a returned result refuses the resume. Runs once, after the veto. */
+    reserve?(): Promise<ResumeResult | undefined>;
+    /** Open the session and read its durable history; runs inside the
+     *  binding's `prepare`. */
+    open(): Promise<AgentSession>;
+    /** The backend's half of the synchronous adoption tail (paints the history
+     *  read by `open`, then binds). Returns the id the switched notice names. */
+    adopt(candidate: AgentSession): string;
+    /** Exactly once on every exit after `reserve`: keep or release. */
+    finish?(committed: boolean): void;
+}
+/** How a backend reopens a persisted session (`/resume`, a rewind's fork). */
+export interface ResumeSessionOpener {
+    plan(target: {
+        readonly sessionId: string;
+    }): ResumeSessionPlan;
+}
+export declare function createSessionSwitch(ctx: Context, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<ChannelBinding, 'session' | 'capture' | 'isCurrent' | 'prepare' | 'abandon' | 'adopt'>;
+    state: () => Pick<ChannelState, 'agentId' | 'cwd' | 'displayCwd' | 'working' | 'pending'>;
+    notify: ChannelState['notify'];
+    withDecisionPending<T>(name: string, pending: Promise<T>): Promise<T>;
+    /** What a parked decision's staleness is judged by: the same conversation
+     *  across rebinds (default: the session object itself). */
+    conversationKey(session: AgentSession): object;
+    describeWorkspace(cwd: string): {
+        description?: string;
+    };
+    resetIdeSelection(): void;
+    clearStagedImages(): void;
+    opener(): NewSessionOpener | undefined;
+    /**
+     * Monotonic activity of the bound session, compared across the open:
+     * inputs dispatched (the input FIFO and `!!`), whether one is still on its
+     * way, and live turns started.
+     */
+    activity(): {
+        readonly inputs: number;
+        readonly unsettled: boolean;
+        readonly turnStarts: number;
+        readonly parked?: string;
+    };
+    /** How `/resume` reopens a persisted session (undefined = unavailable). */
+    resumeOpener?(): ResumeSessionOpener | undefined;
+    unavailable(name: string): void;
+}): {
+    sessionSwitchVetoed: (kind: SessionSwitchKind, targetSessionId?: string) => Promise<boolean>;
+    notifySessionSwitched: (kind: SessionSwitchedKind, sessionId: string, previousSessionId: string) => void;
+    newSession: (target?: NewSessionTarget) => Promise<boolean>;
+    resumeSession: (sessionId: string, kind?: "resume" | "rewind") => Promise<ResumeResult>;
+};
+export type SessionSwitch = ReturnType<typeof createSessionSwitch>;
+/** The mount ledger as the core uses it (injectable for regressions). */
+export interface SessionMountLedger {
+    reserve(key: string): ReturnType<typeof reserveMount>;
+    /** Announce a freshly created session (a refusal costs announcement only). */
+    announce(key: string): void;
+    release(key: string): void;
+}
+/** The process-wide ledger (`~/.dsh-tui/session-mounts.json`). */
+export declare const SESSION_MOUNT_LEDGER: SessionMountLedger;
+/**
+ * `/new` and `/resume` for a session served by the core alone: the backend's
+ * own `open`, the session's history read ahead of the adoption, then the
+ * common projection reset, the new session's identity, capability snapshot
+ * and command list, the history painted and the bind. The mount ledger holds
+ * the backend-qualified key of the bound session (`claude:<id>`): a resume
+ * claims it for the whole attempt and refuses one another TUI process holds;
+ * a create announces its fresh id; the replaced session's claim is released.
+ */
+export declare function createBackendOpener(deps: {
+    open: NonNullable<ChannelLaunchOptions['openSession']>;
+    state: ChannelState;
+    rowIds: {
+        value: number;
+    };
+    resetProjection(): void;
+    /** Forget the replaced session's subagents and background jobs. */
+    resetActivity?(): void;
+    snapshotOf(session: AgentSession): ChannelCapabilities;
+    /** Forget the replaced session's backend commands and reports. */
+    resetControls(): void;
+    bind(seed: readonly AgentEvent[]): void;
+    /** The bound session (its backend-qualified reference is the ledger key). */
+    bound(): AgentSession;
+    mounts: SessionMountLedger;
+    touch?(sessionId: string): void;
+    notify: ChannelState['notify'];
+}): {
+    create: NewSessionOpener;
+    resume: ResumeSessionOpener;
+};
+//# sourceMappingURL=session-switch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-switch.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/session-switch.ts"],"names":[],"mappings":"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"}