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

package/lib/types/backends/claude/send-message.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The Claude SendMessage tool as a backend-neutral observation: the
+ * model-authored relay to another agent is the only child-directed send
+ * Claude exposes, and its tool call/result on the parent
+ * lane is the observable fact. Pure parsing/projection only — the hooks in
+ * translate.ts decide where an observation belongs (main lane = the parent
+ * itself sent it; a subagent lane = that subagent sent it, keyed by the
+ * delegating call).
+ *
+ * Delivery rules:
+ *  - a call alone proves nothing beyond `issued` (a successful tool call is
+ *    not a delivery);
+ *  - only a structured result field naming a state (`delivery`/`status` in
+ *    {delivered, held, refused, expired}) or an explicit error marks more;
+ *  - any other shape — including a bare success — is `unknown`, the legal
+ *    terminal. Nothing is ever inferred from the tool having succeeded.
+ */
+import type { AgentMessageState, AgentMessageView } from '../../adapter/ports/channel-view.js';
+/** The SendMessage tool input as this module recognizes it: the addressed
+ *  agent (`to`) and the body (`message`, falling back to `text`). An input
+ *  without both is not an observable fact — no view is fabricated for it. */
+export interface SendMessageInput {
+    readonly to: string;
+    readonly text: string;
+}
+/** Parse one SendMessage tool call's input; undefined when unrecognizable. */
+export declare function parseSendMessageInput(input: unknown): SendMessageInput | undefined;
+/** The observation of one call: state `issued`. `lane`
+ *  names the sending subagent's delegating call id; on the main lane the
+ *  sender is the parent itself (rendered from the absent `from`). */
+export declare function sendMessageCallView(input: {
+    readonly callId: string;
+    readonly lane?: string;
+    readonly observedAt: number;
+    readonly input: SendMessageInput;
+}): AgentMessageView;
+/**
+ * The settled state of one SendMessage result: an explicit error is a
+ * refusal fact; a structured `delivery`/`status` field naming a state
+ * marks exactly that; any other shape — including a bare success — is
+ * `unknown` (never a guessed delivery).
+ */
+export declare function sendMessageResultState(result: {
+    readonly isError: boolean;
+    readonly structured: unknown;
+}): AgentMessageState;
+/** The settlement observation of one call: the same durable identity (the
+ *  parent tool call id); the fold advances the state and nothing else. */
+export declare function sendMessageResultView(input: {
+    readonly callId: string;
+    readonly observedAt: number;
+    readonly state: AgentMessageState;
+}): AgentMessageView;
+//# sourceMappingURL=send-message.d.ts.map

package/lib/types/backends/claude/send-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-message.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/send-message.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAA;AAG9F;;6EAE6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAOlF;AAED;;qEAEqE;AACrE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,GAAG,gBAAgB,CAW/K;AAUD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAAG,iBAAiB,CAU7H;AAED;0EAC0E;AAC1E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GAAG,gBAAgB,CAS1J"}

package/lib/types/backends/claude/send-message.js

@@ -0,0 +1,65 @@
+import { rec, str } from './narrow.js';
+/** Parse one SendMessage tool call's input; undefined when unrecognizable. */
+export function parseSendMessageInput(input) {
+    const args = rec(input);
+    if (args === undefined)
+        return undefined;
+    const to = str(args.to);
+    const body = str(args.message) ?? str(args.text);
+    if (to === undefined || to === '' || body === undefined || body === '')
+        return undefined;
+    return { to, text: body };
+}
+/** The observation of one call: state `issued`. `lane`
+ *  names the sending subagent's delegating call id; on the main lane the
+ *  sender is the parent itself (rendered from the absent `from`). */
+export function sendMessageCallView(input) {
+    return {
+        messageId: input.callId,
+        ...(input.lane === undefined ? {} : { from: input.lane }),
+        to: input.input.to,
+        via: 'parent-mediated',
+        text: input.input.text,
+        state: 'issued',
+        sourceRef: input.callId,
+        observedAt: input.observedAt,
+    };
+}
+/** The states a structured result may explicitly name. */
+const EXPLICIT_STATES = Object.freeze({
+    delivered: 'delivered',
+    held: 'held',
+    refused: 'refused',
+    expired: 'expired',
+});
+/**
+ * The settled state of one SendMessage result: an explicit error is a
+ * refusal fact; a structured `delivery`/`status` field naming a state
+ * marks exactly that; any other shape — including a bare success — is
+ * `unknown` (never a guessed delivery).
+ */
+export function sendMessageResultState(result) {
+    if (result.isError)
+        return 'refused';
+    const structured = rec(result.structured);
+    if (structured !== undefined) {
+        for (const key of ['delivery', 'status']) {
+            const named = EXPLICIT_STATES[str(structured[key]) ?? ''];
+            if (named !== undefined)
+                return named;
+        }
+    }
+    return 'unknown';
+}
+/** The settlement observation of one call: the same durable identity (the
+ *  parent tool call id); the fold advances the state and nothing else. */
+export function sendMessageResultView(input) {
+    return {
+        messageId: input.callId,
+        via: 'parent-mediated',
+        text: '',
+        state: input.state,
+        sourceRef: input.callId,
+        observedAt: input.observedAt,
+    };
+}

package/lib/types/backends/claude/session/auth.d.ts

@@ -0,0 +1,47 @@
+/** Credential reconnect flow and account status text for a Claude session. */
+import type { AccountInfo, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { AccountView, SessionAuthView } from '../../../agent/capabilities.js';
+import type { AgentEvent, AgentEventMeta } from '../../../agent/events.js';
+import { type ClaudeAuthPlan } from '../auth.js';
+import type { ClaudeTranslator } from '../translate.js';
+import type { ClaudeClock, ClaudeSessionDeps, Run } from './types.js';
+export declare function createSessionAuth(context: {
+    readonly deps: ClaudeSessionDeps;
+    readonly clock: ClaudeClock;
+    readonly translator: ClaudeTranslator;
+    readonly pushed: Map<string, SDKUserMessage>;
+    readonly idleWaiters: {
+        resolve(): void;
+        reject(error: Error): void;
+    }[];
+    readonly run: Run;
+    readonly disposing: boolean;
+    authPlan: ClaudeAuthPlan;
+    readonly account: AccountInfo | undefined;
+    readonly apiKeySource: string | undefined;
+    idle(): boolean;
+    stopForReconnect(): {
+        readonly unstarted: readonly string[];
+    };
+    openRun(): Promise<void>;
+    emit(events: readonly AgentEvent[], wake?: AgentEventMeta['wake']): void;
+    consume(target: Run): Promise<void>;
+    onExit(error: unknown): void;
+    stopRun(target: Run): void;
+}): {
+    reconnect: (renewal: {
+        readonly rejected?: string;
+    }, options?: {
+        readonly waitIdle?: boolean;
+    }) => Promise<void>;
+    onAuthFailure: () => void;
+    authStatus: () => Promise<SessionAuthView>;
+    readonly reconnecting: Promise<void> | undefined;
+    readonly reconnectDeferred: boolean;
+    attempts: number;
+};
+/** The `/login` and `/doctor` name of a credential source. */
+export declare function authSourceLabel(plan: ClaudeAuthPlan): string;
+/** Account lines (never the email). */
+export declare function accountLines(view: AccountView): string[];
+//# sourceMappingURL=auth.d.ts.map

package/lib/types/backends/claude/session/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/auth.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE1E,OAAO,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAA;AAE7F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAKrE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;IACrC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE;QAAE,OAAO,IAAI,IAAI,CAAC;QAAC,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;KAAE,EAAE,CAAA;IACvE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,IAAI,IAAI,OAAO,CAAA;IACf,gBAAgB,IAAI;QAAE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAA;IAC7D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,EAAE,IAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,CAAA;IACxE,OAAO,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAAA;CAC3B;yBAmC6B;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,YAAW;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAQ,OAAO,CAAC,IAAI,CAAC;yBAmF/F,IAAI;sBAeD,OAAO,CAAC,eAAe,CAAC;;;cAkB/B,MAAM;EAE7B;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAmB5D;AA8BD,uCAAuC;AACvC,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAGxD"}

package/lib/types/backends/claude/session/auth.js

@@ -0,0 +1,226 @@
+import { t } from '../../../i18n.js';
+import { detectClaudeAuth, refreshFailureDebugDetail } from '../auth.js';
+import { accountView } from '../controls.js';
+/** A failed credential renewal, carrying only its user-facing sentence. */
+class RenewalFailed extends Error {
+}
+export function createSessionAuth(context) {
+    const { deps, clock, translator, pushed, idleWaiters, idle, stopForReconnect, openRun, emit, consume, onExit, stopRun } = context;
+    /** Automatic reconnects after an authentication failure since the last
+     *  successful turn (one; after that the user is sent to /login). */
+    let authAttempts = 0;
+    /**
+     * Restart the CLI on the same session with a renewed credential: the old
+     * CLI's prompts are withdrawn and an open turn closed, the
+     * new query continues the session id, the translator keeps its state, and
+     * the inputs the old CLI never started are pushed again, in order.
+     *
+     * After an authentication failure the old CLI is stopped first — before
+     * the renewal awaits — so its queue cannot start (and fail on the refused
+     * credential) meanwhile: every input it had not started is re-pushed. A
+     * `/login` reconnect instead waits for the running turn and the inputs
+     * queued behind it (submits keep going to the old CLI meanwhile), for at
+     * most {@link RECONNECT_DEFER_MS}; then it reconnects anyway, saying that
+     * it interrupts the turn.
+     */
+    let reconnecting;
+    /** A `/login` reconnect is waiting for the session to go idle. */
+    let reconnectDeferred = false;
+    const RECONNECT_DEFER_MS = deps.reconnectDeferMs ?? 120_000;
+    /** Wait (bounded) until no turn runs and nothing queued would start. */
+    const waitIdleBounded = async () => {
+        if (idle())
+            return;
+        let timer;
+        const timedOut = await Promise.race([
+            new Promise((resolve, reject) => { idleWaiters.push({ resolve: () => resolve(false), reject }); }),
+            new Promise(resolve => { timer = clock.setTimeout(() => resolve(true), RECONNECT_DEFER_MS); }),
+        ]).finally(() => clock.clearTimeout(timer));
+        if (timedOut && !context.disposing)
+            emit([{ type: 'notice', level: 'warning', text: t('claude-auth-reconnect-forced') }]);
+    };
+    const reconnect = (renewal, options = {}) => {
+        if (context.disposing)
+            return Promise.reject(new Error(t('claude-session-closed')));
+        reconnecting ??= (async () => {
+            const deferred = options.waitIdle === true;
+            let stopped = deferred ? undefined : stopForReconnect();
+            let renewError;
+            // A deferred reconnect leaves the old CLI serving submits until it
+            // actually swaps (renewal and the idle wait included).
+            reconnectDeferred = deferred;
+            try {
+                if (deps.auth !== undefined) {
+                    try {
+                        context.authPlan = await deps.auth.renew(renewal);
+                    }
+                    catch (error) {
+                        // Only the sanitized sentence leaves: the refresh error itself
+                        // can carry the OAuth endpoint's response body.
+                        const failure = new RenewalFailed(renewalFailed(error));
+                        // The old CLI is already gone: reconnect on the current
+                        // credential (its inputs still run), report the renewal after.
+                        if (stopped === undefined)
+                            throw failure;
+                        renewError = failure;
+                    }
+                }
+                if (deferred)
+                    await waitIdleBounded();
+            }
+            finally {
+                reconnectDeferred = false;
+            }
+            if (context.disposing)
+                return;
+            stopped ??= stopForReconnect();
+            const { unstarted } = stopped;
+            try {
+                await openRun();
+            }
+            catch (error) {
+                // Nothing can deliver them now: retire their previews, say so.
+                const dropped = translator.dropInputs(unstarted);
+                pushed.clear();
+                if (dropped.length > 0)
+                    emit([...dropped, { type: 'notice', level: 'warning', text: t('claude-auth-inputs-dropped', { n: unstarted.length }) }]);
+                onExit(error);
+                throw error;
+            }
+            // A dispose during the handshake: the replacement must not outlive it.
+            if (context.disposing) {
+                stopRun(context.run);
+                return;
+            }
+            // Background work belonged to the old CLI process; the new one starts
+            // with none (the level signal is per process).
+            emit([{ type: 'tasks.snapshot', taskIds: [] }]);
+            const next = context.run;
+            const lost = [];
+            for (const uuid of unstarted) {
+                const message = pushed.get(uuid);
+                if (message === undefined) {
+                    lost.push(uuid);
+                    continue;
+                }
+                // A fresh CLI is idle: each input is a plain push, in order.
+                const { priority: _priority, ...plain } = message;
+                try {
+                    next.inbox.push(plain);
+                }
+                catch {
+                    lost.push(uuid);
+                }
+            }
+            if (lost.length > 0)
+                emit([...translator.dropInputs(lost), { type: 'notice', level: 'warning', text: t('claude-auth-inputs-dropped', { n: lost.length }) }]);
+            next.consumer = consume(next);
+            if (renewError !== undefined)
+                throw renewError;
+        })().finally(() => { reconnecting = undefined; });
+        return reconnecting;
+    };
+    /** The token the live run spawned with, when it is the dsh-auth login. */
+    const injectedToken = () => context.authPlan.source === 'dsh-auth' ? context.authPlan.env.CLAUDE_CODE_OAUTH_TOKEN : undefined;
+    /** A failed renewal as the user sees it. The debug log gets a fixed
+     *  failure category and at most the HTTP status: a real refresh rejection
+     *  carries the OAuth endpoint's response body, which may echo request
+     *  material (auth.ts contract) — the error's own text is never logged. */
+    const renewalFailed = (error) => {
+        deps.host.debug(`claude: reconnect failed (${refreshFailureDebugDetail(error)})`);
+        return deps.auth?.failureNotice?.(error) ?? t('claude-auth-reconnect-failed');
+    };
+    /** The CLI refused the credential: renew and resume once, then send the
+     *  user to `/login` (never a loop of failing turns). */
+    const onAuthFailure = () => {
+        if (context.disposing)
+            return;
+        if (authAttempts >= 1) {
+            emit([{ type: 'notice', level: 'error', text: t('claude-auth-failed-login') }]);
+            return;
+        }
+        authAttempts += 1;
+        reconnect({ rejected: injectedToken() }).then(() => {
+            emit([{ type: 'notice', level: 'warning', text: t('claude-auth-reconnected') }]);
+        }, (error) => {
+            emit([{ type: 'notice', level: 'error', text: error instanceof RenewalFailed ? error.message : renewalFailed(error) }]);
+        });
+    };
+    /** `/login` lines: where the credential comes from, never the token. */
+    const authStatus = async () => {
+        const lines = [t('claude-auth-source', { source: authSourceLabel(context.authPlan) })];
+        const route = routeLabel(context.authPlan);
+        if (route !== undefined)
+            lines.push(t('claude-auth-route', { route }));
+        if (context.authPlan.source === 'claude-login' && await detectClaudeAuth(process.env, undefined) === 'missing' && context.account?.subscriptionType === undefined) {
+            lines.push(t('claude-auth-missing-hint'));
+        }
+        lines.push(t('claude-auth-cli', { source: context.apiKeySource ?? t('doctor-unknown'), token: context.account?.tokenSource ?? t('doctor-unknown') }));
+        if (context.account !== undefined)
+            lines.push(...accountLines(accountView(context.account, context.apiKeySource)));
+        return { lines };
+    };
+    return {
+        reconnect,
+        onAuthFailure,
+        authStatus,
+        get reconnecting() { return reconnecting; },
+        get reconnectDeferred() { return reconnectDeferred; },
+        get attempts() { return authAttempts; },
+        set attempts(value) { authAttempts = value; },
+    };
+}
+/** The `/login` and `/doctor` name of a credential source. */
+export function authSourceLabel(plan) {
+    switch (plan.source) {
+        case 'dsh-auth':
+            return plan.expiresAt === undefined ? t('claude-auth-source-dsh-auth') : t('claude-auth-source-dsh-auth-expires', { time: new Date(plan.expiresAt).toISOString() });
+        case 'api-key':
+            return 'ANTHROPIC_API_KEY';
+        case 'auth-token':
+            return 'ANTHROPIC_AUTH_TOKEN';
+        case 'oauth-env':
+            return 'CLAUDE_CODE_OAUTH_TOKEN';
+        case 'cloud':
+            return t('claude-auth-source-cloud', { provider: plan.cloud ?? '' });
+        case 'claude-login':
+            return t('claude-auth-source-claude-login');
+        default: {
+            const unknown = plan.source;
+            return unknown;
+        }
+    }
+}
+/** Why the subscription sign-in is not in use, when the route is not
+ *  first-party (the origin host at most — never a full URL). */
+function routeLabel(plan) {
+    const route = plan.route;
+    if (route === undefined)
+        return undefined;
+    switch (route.kind) {
+        case 'first-party':
+        case 'cloud':
+            return undefined;
+        case 'custom-endpoint':
+            return t('claude-route-custom-endpoint', { host: route.host });
+        case 'custom-oauth':
+            return t('claude-route-custom-oauth');
+        case 'unix-socket':
+            return t('claude-route-unix-socket');
+        case 'gateway':
+            return t('claude-route-gateway');
+        case 'api-key-helper':
+            return t('claude-route-api-key-helper');
+        case 'settings-unreadable':
+            return t('claude-route-settings-unreadable');
+        default: {
+            const unknown = route;
+            return unknown;
+        }
+    }
+}
+/** Account lines (never the email). */
+export function accountLines(view) {
+    const parts = [view.organization, view.subscription, view.provider].filter((part) => part !== undefined && part !== '');
+    return parts.length === 0 ? [] : [t('claude-auth-account', { account: parts.join(' · ') })];
+}

package/lib/types/backends/claude/session/channels.d.ts

@@ -0,0 +1,82 @@
+import type { AgentEvent } from '../../../agent/events.js';
+import type { AgentSession } from '../../../agent/session.js';
+import type { ClaudeAuthPlan } from '../auth.js';
+import { type ClaudeChannels } from '../channels.js';
+import type { ClaudeChannelTokens } from '../../shared/channel-tokens.js';
+import type { ClaudePrefs } from '../prefs.js';
+import type { ClaudeTranslator } from '../translate.js';
+import type { ClaudeSessionDeps, Run } from './types.js';
+export declare function createSessionControls(context: {
+    readonly deps: ClaudeSessionDeps;
+    readonly prefs: ClaudePrefs;
+    readonly channels: ClaudeChannels;
+    readonly channelTokens: ClaudeChannelTokens;
+    readonly translator: ClaudeTranslator;
+    readonly run: Run;
+    readonly authPlan: ClaudeAuthPlan;
+    readonly session: AgentSession;
+    configDir(): string;
+    emit(events: readonly AgentEvent[]): void;
+}): {
+    capabilities: {
+        models: {
+            list(): Promise<readonly import("../../../agent/capabilities.js").ModelOption[]>;
+            current: () => import("../../../agent/capabilities.js").ModelRef;
+            display: () => string | undefined;
+            set(ref: import("../../../agent/capabilities.js").ModelRef): Promise<import("../../../agent/capabilities.js").ModelSwitchOutcome>;
+        };
+        effort: {
+            readonly levelsFallback: true | undefined;
+            levels(): readonly import("../../../agent/capabilities.js").EffortOption[];
+            current: () => string | undefined;
+            set(id: string | null): Promise<void>;
+        };
+        modes: {
+            list: () => readonly import("../../../agent/capabilities.js").ModeOption[];
+            cycle: () => readonly import("../../../agent/capabilities.js").ModeOption[];
+            current: () => string;
+            set(id: string): Promise<void>;
+        };
+        channels: {
+            list: () => readonly import("../../../agent/capabilities.js").ChannelProfileView[];
+            activeId: () => string | undefined;
+            setActive: (id: string) => void;
+            importFromSettings: () => import("../../../agent/capabilities.js").ChannelProfileView | undefined;
+            save: (input: {
+                readonly id: string;
+                readonly name: string;
+                readonly baseUrl?: string;
+                readonly token?: string;
+                readonly env?: Readonly<Record<string, string>>;
+                readonly models?: Readonly<Record<string, string>>;
+                readonly tiers?: Readonly<Record<string, string>>;
+            }) => import("../../../agent/capabilities.js").ChannelProfileView;
+            remove: (id: string) => boolean;
+            peekSettingsImport: () => {
+                tiers: Readonly<Record<string, string>>;
+                baseUrl?: string | undefined;
+            } | undefined;
+        };
+        init: {
+            run: () => Promise<void>;
+        };
+        compact: {
+            run: () => Promise<void>;
+        };
+        commands: {
+            list(): Promise<readonly import("../../../agent/events.js").CommandInfo[]>;
+        };
+        mcp: {
+            status(): Promise<readonly import("../../../agent/capabilities.js").McpServerView[]>;
+            reconnect: (name: string) => Promise<void>;
+            toggle: (name: string, enabled: boolean) => Promise<void>;
+        };
+        context: {
+            usage(detail: "summary" | "full"): Promise<import("../../../agent/capabilities.js").ContextUsageView>;
+        };
+    };
+    seed(init: Readonly<Record<string, unknown>> | undefined): void;
+    noteConfirmedModel(model: string): void;
+    setTerminalOnly(names: readonly string[]): void;
+};
+//# sourceMappingURL=channels.d.ts.map

package/lib/types/backends/claude/session/channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/channels.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAGzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAExD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,aAAa,EAAE,mBAAmB,CAAA;IAC3C,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;IACrC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,SAAS,IAAI,MAAM,CAAA;IACnB,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAAA;CAC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDA"}

package/lib/types/backends/claude/session/channels.js

@@ -0,0 +1,45 @@
+/** Assemble the session's model, mode and relay-channel controls. */
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { DATA_DIR } from '../../../utils/paths.js';
+import { activeProfileOf } from '../channels.js';
+import { createClaudeControls } from '../controls.js';
+import { importedModelEnv, modelTruthFrom, readLocalModelNames } from '../modelEnv.js';
+export function createSessionControls(context) {
+    const { deps, prefs, channels, channelTokens, translator, configDir, emit } = context;
+    /** The env keys the TUI itself put into the spawn env: the auth plan's
+     *  flag layer (the channel connection, or the first-party pin). The
+     *  settings import leaves them out (it would re-import the channel the TUI
+     *  activated); the model truth ranks them above the settings file, the
+     *  flag > settings > inherited order the CLI applies. */
+    const injectedEnvKeys = () => new Set(Object.keys(context.authPlan.settings?.env ?? {}));
+    const controls = createClaudeControls({
+        query: () => context.run.query,
+        emit: events => emit(events),
+        submitText: async (text) => {
+            await context.session.submit({ text, clientMessageId: randomUUID() }, 'turn');
+        },
+        currentModel: () => translator.model,
+        currentMode: () => translator.mode ?? deps.start.mode,
+        noteModel: model => translator.noteModel(model),
+        noteMode: mode => translator.noteMode(mode),
+        prefs,
+        channels,
+        tokens: channelTokens,
+        debug: deps.host.debug,
+        // "Import from settings" reads the user's settings file plus the
+        // inherited env (settings first, as the CLI does), without the TUI's own
+        // injections: a cc-switch-written settings.json is what it sees.
+        settingsEnv: () => importedModelEnv(configDir(), context.authPlan.env, injectedEnvKeys()),
+        // Channel model truth, lazily (the list reads it on demand): the active
+        // channel profile first (channels.json — the user's own data), then the
+        // settings env of the same config dir the transcripts use, plus the
+        // live auth env on top. A cosmetic tier name a relay channel wrote
+        // must not hide the model that actually serves the request.
+        modelTruth: () => {
+            const active = activeProfileOf(channels.read());
+            return modelTruthFrom(configDir(), context.authPlan.env, readLocalModelNames(join(DATA_DIR, 'backends', 'claude')), active === undefined ? undefined : { models: active.models, tiers: active.tiers }, injectedEnvKeys());
+        },
+    });
+    return controls;
+}

package/lib/types/backends/claude/session/input.d.ts

@@ -0,0 +1,16 @@
+/** Streaming inbox, input placement and renderer wake policy. */
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { AgentEvent, AgentEventMeta } from '../../../agent/events.js';
+import type { SubmitPlacement } from '../../../agent/session.js';
+/** A minimal push-based async iterable: the session's stdin. */
+export declare function createInbox<T>(): {
+    push(value: T): void;
+    close(): void;
+    readonly closed: boolean;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+};
+/** Renderer urgency of one translated message. */
+export declare function wakeOf(message: unknown, events: readonly AgentEvent[]): AgentEventMeta['wake'];
+/** `SDKUserMessage.priority` for a channel placement. */
+export declare function priorityOf(placement: SubmitPlacement, turnOpen: boolean): SDKUserMessage['priority'];
+//# sourceMappingURL=input.d.ts.map

package/lib/types/backends/claude/session/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/input.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAGhE,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,CAAC;gBAKb,CAAC,GAAG,IAAI;aAMX,IAAI;qBAKC,OAAO;8BACK,aAAa,CAAC,CAAC,CAAC;EAe7C;AAED,kDAAkD;AAClD,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,cAAc,CAAC,MAAM,CAAC,CAK9F;AAED,yDAAyD;AACzD,wBAAgB,UAAU,CAAC,SAAS,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,GAAG,cAAc,CAAC,UAAU,CAAC,CAWpG"}

package/lib/types/backends/claude/session/input.js

@@ -0,0 +1,64 @@
+import { rec } from '../narrow.js';
+/** A minimal push-based async iterable: the session's stdin. */
+export function createInbox() {
+    const queue = [];
+    const waiters = [];
+    let closed = false;
+    return {
+        push(value) {
+            if (closed)
+                throw new Error('dsh-tui: Claude session input is closed');
+            const waiter = waiters.shift();
+            if (waiter !== undefined)
+                waiter({ value, done: false });
+            else
+                queue.push(value);
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            for (const waiter of waiters.splice(0))
+                waiter({ value: undefined, done: true });
+        },
+        get closed() { return closed; },
+        [Symbol.asyncIterator]() {
+            return {
+                next: () => {
+                    const value = queue.shift();
+                    if (value !== undefined)
+                        return Promise.resolve({ value, done: false });
+                    if (closed)
+                        return Promise.resolve({ value: undefined, done: true });
+                    return new Promise(resolve => { waiters.push(resolve); });
+                },
+                return: () => {
+                    closed = true;
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+            };
+        },
+    };
+}
+/** Renderer urgency of one translated message. */
+export function wakeOf(message, events) {
+    const value = rec(message);
+    if (value?.type === 'stream_event' && rec(value.event)?.type === 'content_block_delta')
+        return 'frame';
+    if (value?.type === 'system' && value.subtype === 'thinking_tokens')
+        return 'frame';
+    return events.every(event => event.type === 'session.status' || event.type === 'pending.changed') ? 'none' : 'sync';
+}
+/** `SDKUserMessage.priority` for a channel placement. */
+export function priorityOf(placement, turnOpen) {
+    switch (placement) {
+        case 'steer':
+            return 'next';
+        case 'now':
+            return 'now';
+        case 'followup':
+            return turnOpen ? 'later' : undefined;
+        default:
+            return undefined;
+    }
+}

package/lib/types/backends/claude/session/lifecycle.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSession } from '../../../agent/session.js';
+import type { ClaudeSessionDeps } from './types.js';
+/** Open one session: start the query, wait for its handshake, start the
+ *  consumer loop. Throws (after cleaning up) when the CLI cannot start. */
+export declare function openClaudeSession(input: ClaudeSessionDeps): Promise<AgentSession>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/types/backends/claude/session/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/lifecycle.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAAc,YAAY,EAAoD,MAAM,2BAA2B,CAAA;AA4B3H,OAAO,KAAK,EAAe,iBAAiB,EAAO,MAAM,YAAY,CAAA;AAgBrE;2EAC2E;AAC3E,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAyvBvF"}