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

package/lib/types/dsh-adapter/backend/translate.js

@@ -0,0 +1,467 @@
+import { NO_EVENTS } from '../../agent/events.js';
+import { isPeakHour } from '../../deepseekPricing.js';
+import { BACKGROUND_START_ACK, isSubagentToolName, parseJobOutputId, todoPanelItems, toolCommandOf } from '../channel/projection-helpers.js';
+import { harnessToolResultView, prepareReplayEvents, toolErrorText } from '../channel/transcript.js';
+import { isCompactionCheckpointSource, toolResultPayload } from '../compat/messages.js';
+import { transcriptImagesOf } from '../transcript-images.js';
+/**
+ * DeepSeek's rate windows, injected into the shared projector as its
+ * `pricingWindow`: each usage buckets by the time its request ran.
+ */
+export function dshPricingWindow(time) {
+    return isPeakHour(new Date(time)) ? 'peak' : 'idle';
+}
+/**
+ * The DSH backend's decision for every Agent Domain event type: whether this
+ * translator (or its session, for the bus-derived `session.status`,
+ * `pending.changed` and `compaction.progress`) ever emits it. The exhaustive
+ * switch is the point: a new `AgentEvent` variant fails `tsc` here until the
+ * DSH side decides, and `verify:agent-domain` checks every translated fixture
+ * event against it.
+ */
+export function dshEmits(type) {
+    switch (type) {
+        case 'session.title':
+        case 'session.color':
+        case 'session.status':
+        case 'turn.start':
+        case 'turn.end':
+        case 'step.start':
+        case 'step.end':
+        case 'user.message':
+        case 'pending.changed':
+        case 'assistant.attempt.start':
+        case 'assistant.delta':
+        case 'assistant.attempt.end':
+        case 'assistant.message':
+        case 'tool.call':
+        case 'tool.result':
+        case 'task.start':
+        case 'task.output':
+        case 'compaction.start':
+        case 'compaction.progress':
+        case 'compaction.end':
+        case 'context.capacity':
+        case 'goal.change':
+        case 'todo.write':
+        case 'preset.selected':
+        case 'system.prompt':
+        case 'request.header':
+        case 'custom':
+            return true;
+        // Owned elsewhere on DSH (subagent/job extensions, approval and question
+        // stores, model/mode actions) or not a DSH concept. Agent-to-agent relay
+        // messages are folded by the adapter's subagent projection straight from
+        // the durable session events, so the translator emits none.
+        case 'agent.message':
+        case 'session.ready':
+        case 'session.reset':
+        case 'tool.progress':
+        // Optional, unused: DSH tool output reaches the card through the
+        // settled result (and background jobs through task.output).
+        case 'tool.output':
+        case 'permission.request':
+        case 'permission.settled':
+        case 'question.request':
+        case 'question.settled':
+        case 'subagent.start':
+        case 'subagent.progress':
+        case 'subagent.end':
+        case 'task.update':
+        case 'task.end':
+        case 'tasks.snapshot':
+        case 'usage':
+        case 'context.usage':
+        case 'model.changed':
+        case 'effort.changed':
+        case 'mode.changed':
+        case 'commands.changed':
+        case 'notice':
+        case 'rate-limit':
+            return false;
+        default: {
+            // Exhaustiveness: a new AgentEvent variant must be classified above.
+            const unhandled = type;
+            return unhandled;
+        }
+    }
+}
+/** Official presets recorded under a former name (blank-session preset
+ *  markers show the user's current spelling, issue #8). A Map, not an object
+ *  literal: the key is untrusted log data, and a plain-object lookup would
+ *  resolve `constructor`/`toString`/… through `Object.prototype`. */
+const PRESET_ALIASES = new Map([
+    ['code', ['ptc']],
+    ['ptc', ['code']],
+]);
+const QUESTION = { card: 'question' };
+const SUBAGENT = { card: 'subagent' };
+const OTHER_DELTA = { kind: 'other' };
+// ContentBlockMap is merge-extensible: plugin-added block types are silently
+// skipped (v1 renders text blocks only) — never crashes.
+const textOf = (content) => (content ?? []).map(block => (block.type === 'text' ? block.text : '')).join('').trim();
+/**
+ * Transcript-facing text of a user message: the first text block only.
+ * `@`-mention attachments (issue #15) travel as later, model-facing blocks,
+ * so joining every block would dump file contents into the bubble, the
+ * sticky header and session titles.
+ */
+const firstTextOf = (content) => (content ?? []).find(block => block.type === 'text')?.text.trim() ?? '';
+const goalChange = (change) => ({
+    type: 'goal.change',
+    operation: change.operation,
+    goal: change.goal,
+    roundsStarted: change.roundsStarted,
+});
+const usageDelta = (usage) => usage === undefined
+    ? undefined
+    : { input: usage.inputTokens, output: usage.outputTokens, cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens };
+/** DSH turn-close reasons; the ones without a shared name keep their label. */
+const turnEndReason = (reason) => {
+    switch (reason.kind) {
+        case 'completed':
+        case 'aborted':
+        case 'interrupted':
+        case 'blocked':
+            return { kind: reason.kind };
+        case 'error':
+            return { kind: 'error', message: reason.error.message };
+        default:
+            return { kind: 'other', label: reason.kind };
+    }
+};
+/** One stream chunk as a domain delta; non-content records stay `other`. */
+const deltaOf = (chunk) => {
+    switch (chunk.type) {
+        case 'text-delta':
+            return { kind: 'text', text: chunk.text };
+        case 'reasoning-delta':
+            return { kind: 'reasoning', text: chunk.text };
+        case 'tool-call-delta':
+            return { kind: 'tool-args', callId: chunk.id, partialJson: chunk.argumentsDelta, name: chunk.name };
+        default:
+            return OTHER_DELTA;
+    }
+};
+/** Create one translator; it serves exactly one session's event stream. */
+export function createDshTranslator(deps) {
+    /** Frame revisions are monotone within one attached Agent lifecycle; a
+     *  re-delivered or out-of-order frame is dropped here. */
+    let lastStreamRevision = -1;
+    /**
+     * Open calls by callId until their result: what the result's presenter,
+     * images and task feeds need. `card: false` = question-presented (the
+     * projector projects the record from the result text). Subagent calls are
+     * not tracked: nothing about their result is projected. Bounded like the
+     * projector's own card index: deleted on result, cleared on reset.
+     */
+    const openCalls = new Map();
+    /** Ask the producing tool how its call should render (diff/terminal/…).
+     *  Unknown tool, unparseable args, or a throwing presenter all degrade to
+     *  the plain text card. */
+    const presentCallView = (name, rawArgs) => {
+        try {
+            const tool = deps.tools()?.get(name, deps.scope());
+            if (tool?.presentCall === undefined)
+                return undefined;
+            return tool.presentCall(JSON.parse(rawArgs));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Same for the settled result; `meta` is the tool-private presentation
+     *  payload the tool attached to its tool/result event (dsh-tool-fs reads
+     *  its result-time contextual diff back from here). */
+    const presentResultView = (name, rawArgs, data) => {
+        try {
+            // Harness goal/todo tools first: their raw JSON is noise in the
+            // transcript, so known shapes fold into a summary card before the
+            // registry is asked (it may not know these tools).
+            const local = harnessToolResultView(name, data);
+            if (local !== undefined)
+                return local;
+            const tool = deps.tools()?.get(name, deps.scope());
+            if (tool?.presentResult === undefined)
+                return undefined;
+            return tool.presentResult(JSON.parse(rawArgs), {
+                ...toolResultPayload(data.message),
+                ...(data.meta !== undefined ? { meta: data.meta } : {}),
+            });
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const translateUserMessage = (event) => {
+        const data = event.data;
+        const base = { id: data.id, anchor: String(event.seq), seq: event.seq, time: event.time, blocks: data.content };
+        // Both legacy and V4 checkpoints render as a folded summary rather than
+        // disappearing with the other injected context.
+        if (isCompactionCheckpointSource(data.source)) {
+            return [{ type: 'user.message', ...base, source: 'compaction', text: textOf(data.content) }];
+        }
+        // Same-session goal domain: goal-sourced messages are the round driver's
+        // continuation prompts (positive rounds advance the counter); some hosts
+        // also inline the durable snapshot in a round-zero source. They are not
+        // transcript bubbles — they drive the goal panel's projection (replayed on
+        // resume/rewind like every other event; the snapshot itself arrives as
+        // the top-level `goal/change` event).
+        if (data.source.kind === 'goal') {
+            const source = data.source;
+            if (source.round > 0)
+                return [{ type: 'goal.change', operation: 'round', round: source.round }];
+            const change = source.change;
+            // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may not match the static type
+            if (change === undefined || change.kind !== 'goal/change')
+                return NO_EVENTS;
+            return [goalChange(change)];
+        }
+        // Injected context (plugin/skill source) is model-facing only; it has no
+        // transcript-facing text.
+        if (data.source.kind !== 'user')
+            return [{ type: 'user.message', ...base, source: 'injected', text: '' }];
+        return [{
+                type: 'user.message',
+                ...base,
+                source: 'user',
+                text: firstTextOf(data.content),
+                images: transcriptImagesOf(data.content, deps.attachments),
+            }];
+    };
+    const translateToolResult = (event) => {
+        const data = event.data;
+        const callId = data.message.source.callId;
+        const call = openCalls.get(callId);
+        openCalls.delete(callId);
+        const payload = toolResultPayload(data.message);
+        const isError = data.error !== undefined || payload.isError;
+        // Text/presentation/images are derived only for results something
+        // projects (a card or a question record).
+        const text = call === undefined || isError ? '' : textOf(payload.content);
+        const card = call?.card === true ? call : undefined;
+        const result = {
+            type: 'tool.result',
+            seq: event.seq,
+            turn: data.turn,
+            step: data.step,
+            callId,
+            isError,
+            time: event.time,
+            content: payload.content,
+            text,
+            ...(isError && call !== undefined ? { errorText: toolErrorText(event) } : {}),
+            ...(card === undefined ? {} : { images: transcriptImagesOf(data.message.content, deps.attachments) }),
+            ...(data.meta === undefined ? {} : { meta: data.meta }),
+            ...(card === undefined || isError ? {} : { presentation: presentResultView(card.name, card.args, data) }),
+        };
+        if (card === undefined || isError)
+            return [result];
+        const events = [result];
+        // A job_output read doubles as the job card's output feed (the
+        // registry's read is consuming and reserved for the owning agent).
+        if (card.name === 'job_output' && text !== '') {
+            const id = parseJobOutputId(card.args);
+            if (id !== undefined)
+                events.push({ type: 'task.output', taskId: id, text, time: event.time, callId });
+        }
+        // A `started background job <id>` ack pairs the job with its tool call.
+        // Take the full command from the args; the registry label is only the
+        // friendly description.
+        const startAck = BACKGROUND_START_ACK.exec(text);
+        if (startAck !== null) {
+            const command = toolCommandOf(card.args);
+            if (command !== undefined) {
+                events.push({ type: 'task.start', taskId: startAck[1], kind: 'shell', description: '', command, callId, background: true, time: event.time });
+            }
+        }
+        return events;
+    };
+    /** Translate one durable session event (live or as part of a replay). */
+    const translateEvent = (event) => {
+        const type = event.type;
+        // Top-level `goal/change` events are how the goal service records durable
+        // goal mutations (create/edit/pause/resume/complete/block/clear) —
+        // confirmed in production logs. The pinned peer's SessionEvent union
+        // predates the type, so admit it structurally.
+        if (type === 'goal/change')
+            return [goalChange(event.data)];
+        switch (event.type) {
+            case 'user/message':
+                return translateUserMessage(event);
+            case 'step/start':
+                return [{ type: 'step.start', turn: event.data.turn, step: event.data.step }];
+            case 'assistant/attempt':
+                // A durable failed attempt, located by position (it has no stream id).
+                return [{ type: 'assistant.attempt.end', attemptId: `seq:${event.seq}`, outcome: 'abandoned', turn: event.data.turn, step: event.data.step }];
+            case 'assistant/message': {
+                const data = event.data;
+                const content = data.message.content;
+                return [{
+                        type: 'assistant.message',
+                        seq: event.seq,
+                        anchor: String(event.seq),
+                        turn: data.turn,
+                        step: data.step,
+                        attemptId: `seq:${event.seq}`,
+                        time: event.time,
+                        blocks: content,
+                        images: transcriptImagesOf(content, deps.attachments),
+                        usage: usageDelta(data.usage),
+                        ...(data.interrupted === true ? { interrupted: true } : {}),
+                        // V3 embeds its complete attempt stream; older settlements may omit
+                        // reasoning that is still durably recorded in assistant/chunk events.
+                        canonical: Array.isArray(data.stream),
+                    }];
+            }
+            case 'tool/call': {
+                const data = event.data;
+                const callId = data.callId;
+                const base = { type: 'tool.call', seq: event.seq, anchor: String(event.seq), turn: data.turn, step: data.step, callId, name: data.name, argsJson: data.arguments, time: event.time };
+                // ask_user_question renders as the interactive questionnaire panel
+                // (DSH user-interaction seam), not as a tool card.
+                if (data.name === 'ask_user_question') {
+                    openCalls.set(callId, { name: data.name, args: data.arguments, card: false });
+                    return [{ ...base, presentation: QUESTION }];
+                }
+                // The delegation tools render as the live subagent card.
+                if (isSubagentToolName(data.name))
+                    return [{ ...base, presentation: SUBAGENT }];
+                openCalls.set(callId, { name: data.name, args: data.arguments, card: true });
+                return [{ ...base, presentation: presentCallView(data.name, data.arguments) }];
+            }
+            case 'tool/result':
+                return translateToolResult(event);
+            case 'step/end':
+                return [{ type: 'step.end', turn: event.data.turn, step: event.data.step }];
+            case 'turn/start':
+                return [{ type: 'turn.start', turn: event.data.turn, origin: 'user', time: event.time }];
+            case 'turn/end':
+                return [{ type: 'turn.end', turn: event.data.turn, reason: turnEndReason(event.data.reason), time: event.time }];
+            case 'request/context':
+                // Adapter-advertised context capacity, when the route reports one.
+                return event.data.contextWindow === undefined ? NO_EVENTS : [{ type: 'context.capacity', contextWindow: event.data.contextWindow }];
+            case 'system/message':
+                // V3 system prompts are surface nodes, not header fields: the latest
+                // node holds the active instructions (an empty render clears them).
+                return [{ type: 'system.prompt', text: textOf(event.data.message.content) }];
+            case 'request/header': {
+                // The header carries the conversation's call config
+                // (provider/model/effort/sampling). The system prompt moved out of
+                // the header at V3 (see system/message); pre-V3 logs still carry it,
+                // admitted structurally below.
+                // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable session data may lack header config
+                const effort = event.data.header.config?.reasoningEffort;
+                const headerModel = event.data.header.config?.model;
+                const header = {
+                    type: 'request.header',
+                    // A missing/empty model must clear the previous header's value, or
+                    // later usage would keep billing the old model.
+                    model: typeof headerModel === 'string' && headerModel !== '' ? headerModel : undefined,
+                    effort: typeof effort === 'string' ? effort : undefined,
+                };
+                const legacySystem = event.data.header.system;
+                return typeof legacySystem === 'string' ? [header, { type: 'system.prompt', text: legacySystem }] : [header];
+            }
+            case 'session/title': {
+                const source = event.data.source;
+                return [{ type: 'session.title', title: event.data.title, source: source?.kind === 'user' ? 'user' : 'auto' }];
+            }
+            default:
+                break;
+        }
+        const data = event.data;
+        switch (type) {
+            case 'assistant/chunk': {
+                // Pre-0.1.5 live streams and raw pre-V3 logs carry per-token chunks
+                // as durable session events (0.1.5 moved live chunks to transient
+                // frames and compacts the durable record into
+                // `assistant/message.stream`). Matched by name so the current union
+                // (which no longer lists the type) stays compile-clean.
+                const chunk = data;
+                return [{
+                        type: 'assistant.delta',
+                        attemptId: `seq:${event.seq}`,
+                        index: chunk.chunk.index ?? 0,
+                        time: event.time,
+                        turn: chunk.turn,
+                        step: chunk.step,
+                        seq: event.seq,
+                        delta: deltaOf(chunk.chunk),
+                    }];
+            }
+            case 'todo/write': {
+                // dsh-tool-todo owns this optional module augmentation; matched by
+                // name so the TUI remains loadable without that plugin.
+                const todos = todoPanelItems(data);
+                return todos === undefined ? NO_EVENTS : [{ type: 'todo.write', items: todos }];
+            }
+            case 'agent-preset/selected': {
+                // Logged preset switch (blank sessions only, issue #8). Not in
+                // dsh-session's typed union — matched by name.
+                const recorded = data.agentPreset;
+                const preset = typeof recorded === 'string' ? recorded : 'unknown';
+                const aliases = PRESET_ALIASES.get(preset);
+                return [{ type: 'preset.selected', preset, ...(aliases === undefined ? {} : { aliases }) }];
+            }
+            case 'session/color': {
+                // `/color` accent (dsh-tui plugin event): '' clears to the default.
+                const color = data.color;
+                return [{ type: 'session.color', color: typeof color === 'string' ? color : '' }];
+            }
+            // The compaction bracket is a plugin-appended event pair (not part of
+            // dsh-session's typed map): the host writes `compaction/start` before
+            // the summarizer runs and `compaction/end` once the checkpoint is
+            // committed or abandoned. The checkpoint `user/message` tells which,
+            // so the close itself carries no outcome.
+            case 'compaction/start':
+                return [{ type: 'compaction.start', trigger: 'auto', cancellable: false, time: event.time }];
+            case 'compaction/end':
+                return [{ type: 'compaction.end', ok: true, time: event.time }];
+            default:
+                // Custom plugin events: the tuiRenderers seam decides whether they
+                // render at all.
+                return [{ type: 'custom', nativeType: type, data }];
+        }
+    };
+    /**
+     * Translate one live assistant stream frame (0.1.5+): the transient
+     * per-token counterpart of the durable `assistant/message` /
+     * `assistant/attempt` settlement.
+     */
+    const translateFrame = (frame) => {
+        if (frame.revision <= lastStreamRevision)
+            return NO_EVENTS;
+        lastStreamRevision = frame.revision;
+        const attemptId = frame.attemptId;
+        if (frame.type === 'start')
+            return [{ type: 'assistant.attempt.start', attemptId, turn: frame.turn, step: frame.step }];
+        if (frame.type === 'end') {
+            // A settlement recorded as `assistant/attempt` is a failed attempt: its
+            // provisional rows go, exactly like a live abandonment.
+            const discarded = frame.outcome.kind === 'abandoned' || frame.outcome.eventType === 'assistant/attempt';
+            return [{ type: 'assistant.attempt.end', attemptId, outcome: discarded ? 'abandoned' : 'committed' }];
+        }
+        return [{ type: 'assistant.delta', attemptId, index: frame.index, time: frame.time, delta: deltaOf(frame.chunk) }];
+    };
+    /**
+     * Translate a durable replay seed (resume / rewind / model-switch fork).
+     * Settled `assistant/chunk` runs are dropped first (`prepareReplayEvents`);
+     * the frame fence restarts with the replacement session.
+     */
+    const translateReplay = (events) => {
+        lastStreamRevision = -1;
+        const out = [];
+        for (const event of prepareReplayEvents(events)) {
+            for (const translated of translateEvent(event))
+                out.push(translated);
+        }
+        return out;
+    };
+    /** Forget the frame fence and every open call (paired with a projector reset). */
+    const reset = () => {
+        lastStreamRevision = -1;
+        openCalls.clear();
+    };
+    return { translateEvent, translateFrame, translateReplay, reset, presentCallView, presentResultView };
+}

package/lib/types/dsh-adapter/backends.d.ts

@@ -0,0 +1,49 @@
+/** Non-DSH backend loading, detection and startup session ownership. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentBackend, BackendHost, OpenTarget, SdkInstallTarget, SdkInstaller } from '../agent/backend.js';
+import type { AgentEvent } from '../agent/events.js';
+import type { AgentSession } from '../agent/session.js';
+import type { KernelStatus } from '../components/kernelCatalog.js';
+/** Close an already-loaded backend's pooled processes without loading it on DSH. */
+export declare function closeBackendResources(): Promise<void>;
+export declare const BACKEND_LOADERS: {
+    claude: () => Promise<AgentBackend>;
+    codex: () => Promise<AgentBackend>;
+};
+/** The kernel picker's one-click SDK install surface (Chat consumes it as
+ *  props; the types are the neutral ones from agent/backend.js). */
+export declare const sdkInstall: {
+    resolveTarget: () => SdkInstallTarget;
+    start: (dir: string) => SdkInstaller;
+    checkPnpm: () => Promise<boolean>;
+    pinned: {
+        readonly specifier: "@anthropic-ai/claude-agent-sdk@0.3.287";
+        readonly version: "0.3.287";
+    };
+};
+/** All probes and sessions share one credential source per provider. */
+export declare function createBackendHost(ctx: Context, cwd: string, stderr: (line: string) => void): Promise<BackendHost>;
+/** Resume failures abort boot; history is read before the channel's first paint. */
+export declare function openBackendStartup(ctx: Context, backend: AgentBackend, input: {
+    readonly cwd: string;
+    readonly stderr: (line: string) => void;
+    readonly configuredSessionId?: string;
+    readonly argv: readonly string[];
+}): Promise<{
+    session: AgentSession;
+    label: string;
+    backendId: string;
+    initialHistory: readonly AgentEvent[];
+    catalog: import("../agent/backend.js").SessionCatalog | undefined;
+    sessionPrefs: import("../agent/backend.js").BackendSessionPrefs;
+    persisted: (_sessionId: string, rows: readonly {
+        readonly kind: string;
+    }[]) => boolean;
+    resumeCommand: (sessionId: string) => string;
+    open: (target: Extract<OpenTarget, {
+        readonly kind: "create" | "resume";
+    }>) => Promise<AgentSession>;
+}>;
+/** Probe optional backends lazily; failed loading leaves their row unavailable. */
+export declare function probeKernels(ctx: Context, cwd: string): Promise<Record<string, KernelStatus>>;
+//# sourceMappingURL=backends.d.ts.map

package/lib/types/dsh-adapter/backends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backends.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/backends.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAyB,UAAU,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AACvI,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAGvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAclE,oFAAoF;AACpF,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3D;AAED,eAAO,MAAM,eAAe;;;CAMoD,CAAA;AAEhF;oEACoE;AACpE,eAAO,MAAM,UAAU;yBACF,gBAAgB;iBACtB,MAAM,KAAG,YAAY;qBACnB,OAAO,CAAC,OAAO,CAAC;;;;;CAEhC,CAAA;AAID,wEAAwE;AACxE,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAiBvH;AAED,oFAAoF;AACpF,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE;IACnF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACjC;;;;;;;4BAgD2B,MAAM,QAAQ,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE;+BAC/C,MAAM;mBAClB,OAAO,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;KAAE,CAAC;GAG7E;AAED,mFAAmF;AACnF,wBAAsB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAYnG"}

package/lib/types/dsh-adapter/backends.js

@@ -0,0 +1,124 @@
+import { formatSessionRef } from '../agent/refs.js';
+import { reserveMount, reserveNewSession } from '../sessionMounts.js';
+import { resumeTargetFromArgv } from '../sessionHistory.js';
+import { mountFailureText } from '../sessions/resumeFailure.js';
+import { logForDebugging } from '../utils/debug.js';
+// Static on purpose: the install module imports no vendor package (node
+// built-ins + update.ts, which this adapter loads anyway), so a DSH-only
+// boot pays nothing for having the wizard's surface at hand.
+import { checkPnpmAvailable, CLAUDE_SDK_SPECIFIER, resolveSdkInstallTarget, startClaudeSdkInstall } from '../backends/claude/install.js';
+import { VALIDATED_SDK_VERSION } from '../backends/claude/contract.js';
+import { fileChannelTokens } from '../backends/shared/channel-tokens.js';
+let closeCodexHubs;
+/** Close an already-loaded backend's pooled processes without loading it on DSH. */
+export async function closeBackendResources() {
+    await closeCodexHubs?.();
+}
+export const BACKEND_LOADERS = {
+    claude: () => import('../backends/claude/index.js').then(m => m.claudeBackend),
+    codex: () => import('../backends/codex/index.js').then(m => {
+        closeCodexHubs = m.closeAllCodexHubs;
+        return m.codexBackend;
+    }),
+};
+/** The kernel picker's one-click SDK install surface (Chat consumes it as
+ *  props; the types are the neutral ones from agent/backend.js). */
+export const sdkInstall = {
+    resolveTarget: () => resolveSdkInstallTarget(),
+    start: (dir) => startClaudeSdkInstall(dir),
+    checkPnpm: () => checkPnpmAvailable(),
+    pinned: { specifier: CLAUDE_SDK_SPECIFIER, version: VALIDATED_SDK_VERSION },
+};
+const credentialSources = new Map();
+/** All probes and sessions share one credential source per provider. */
+export async function createBackendHost(ctx, cwd, stderr) {
+    const { createOAuthCredentialSource } = await import('./oauth-credential-source.js');
+    return {
+        cwd,
+        debug: message => logForDebugging(message),
+        warn: message => ctx.logger.warn(message),
+        stderr,
+        tokenStore: fileChannelTokens(undefined, message => logForDebugging(message)),
+        oauthCredential: provider => {
+            let source = credentialSources.get(provider);
+            if (source === undefined) {
+                source = createOAuthCredentialSource(provider);
+                credentialSources.set(provider, source);
+            }
+            return source;
+        },
+    };
+}
+/** Resume failures abort boot; history is read before the channel's first paint. */
+export async function openBackendStartup(ctx, backend, input) {
+    const launch = backend.launch;
+    if (launch === undefined)
+        throw new Error(`dsh-tui: backend "${backend.id}" does not support startup`);
+    const host = await createBackendHost(ctx, input.cwd, input.stderr);
+    const prefs = launch.sessionPrefs(host.debug);
+    const requested = (input.configuredSessionId ?? resumeTargetFromArgv(input.argv, () => prefs.lastSession()))?.trim();
+    const resumeId = requested === undefined || requested === ''
+        ? undefined
+        : requested.startsWith(`${backend.id}:`) ? requested.slice(backend.id.length + 1) : requested;
+    let session;
+    let initialHistory = [];
+    if (resumeId !== undefined) {
+        const key = formatSessionRef({ backendId: backend.id, sessionId: resumeId });
+        const reserved = await reserveMount(key);
+        if (!reserved.ok) {
+            throw new Error(`dsh-tui: cannot resume ${backend.descriptor.label} session "${resumeId}": ${mountFailureText(reserved)} — ` +
+                'two processes driving one session would interleave its transcript. Close that terminal, or drop --resume to start a fresh session.');
+        }
+        try {
+            session = await backend.open({ kind: 'resume', sessionId: resumeId }, host);
+            try {
+                initialHistory = await session.history();
+            }
+            catch (error) {
+                await session.dispose().catch(() => undefined);
+                throw error;
+            }
+        }
+        catch (error) {
+            reserved.reservation.abandon();
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`dsh-tui: cannot resume ${backend.descriptor.label} session "${resumeId}": ${reason} — no fresh session was started instead. ` +
+                'Drop --resume to start a fresh session.', { cause: error });
+        }
+        reserved.reservation.settle();
+        prefs.setLastSession(resumeId);
+        prefs.touch(resumeId);
+    }
+    else {
+        session = await backend.open({ kind: 'create', cwd: input.cwd }, host);
+        const { reservation } = await reserveNewSession(formatSessionRef(session.ref));
+        reservation.settle();
+    }
+    return {
+        session,
+        label: backend.descriptor.label,
+        backendId: backend.id,
+        initialHistory,
+        catalog: backend.catalog,
+        sessionPrefs: prefs,
+        // A submitted user row means the backend has persisted a resumable transcript.
+        persisted: (_sessionId, rows) => rows.some(row => row.kind === 'user'),
+        resumeCommand: (sessionId) => launch.resumeCommand(sessionId),
+        open: (target) => backend.open(target, target.kind === 'create' ? { ...host, cwd: target.cwd } : host),
+    };
+}
+/** Probe optional backends lazily; failed loading leaves their row unavailable. */
+export async function probeKernels(ctx, cwd) {
+    const host = await createBackendHost(ctx, cwd, () => undefined);
+    const statuses = {};
+    for (const [id, load] of Object.entries(BACKEND_LOADERS)) {
+        try {
+            statuses[id] = await (await load()).detect(host);
+        }
+        catch (error) {
+            host.debug('dsh-tui: kernel probe failed (' + (error instanceof Error ? error.message : String(error)) + ')');
+            statuses[id] = { installed: false };
+        }
+    }
+    return statuses;
+}

package/lib/types/dsh-adapter/channel/action-readiness.d.ts

@@ -16,5 +16,21 @@ export declare function createChannelActionReadiness(): {
     install(next: ChannelActionDelegates): void;
     getReadyActions(): ChannelActionDelegates;
 };
+/**
+ * The explicit-unavailable half of a non-DSH composition: one delegate per
+ * public action, each failing per its own contract (`false`, `null`,
+ * `undefined`, an empty list or an `{ ok: false }` result) and, for an
+ * action the user invoked, saying so through `unavailable(name)` (which
+ * notifies `capability-unavailable-backend`). Nothing here pretends to succeed.
+ *
+ * Passive reads the renderer performs on its own (agent-view rows and their
+ * subscription, the cached session list, workspace sub-commands, cache
+ * invalidation, approval-store wiring) answer with their empty value
+ * silently: they are not user actions, and a toast per render would be
+ * noise. The composition overrides the generic actions (submit path, clear,
+ * local rows, file queries, completions, `/new`, `/doctor`) and every action
+ * whose capability the session does have.
+ */
+export declare function createUnavailableActionDelegates(unavailable: (name: string) => void, unavailableLines: (name: string) => string[]): ChannelActionDelegates;
 export {};
 //# sourceMappingURL=action-readiness.d.ts.map