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

package/lib/types/commands.js

@@ -39,8 +39,8 @@ export const LOCAL_COMMANDS = [
     { name: 'btw', description: 'Ask a quick side question without interrupting the conversation' },
     { name: 'trace', description: 'Show the session event trace timeline' },
     { name: 'agentview', description: 'Open the agent view (all sessions)' },
-    { name: 'bg', description: 'Background this session and open agent view' },
-    { name: 'background', description: 'Background this session and open agent view', tag: 'alias of /bg' },
+    { name: 'bg', description: 'Open the session manager (DSH backgrounds this session first)' },
+    { name: 'background', description: 'Open the session manager (DSH backgrounds this session first)', tag: 'alias of /bg' },
     // Session / environment
     { name: 'context', description: 'Show loaded context details' },
     { name: 'status', description: 'Show session status' },
@@ -88,11 +88,111 @@ export const LOCAL_COMMANDS = [
     // Help / exit
     { name: 'help', description: 'Show shortcuts and commands' },
     { name: 'tips', description: 'Show usage tips and shortcuts' },
+    { name: 'kernel', description: 'Choose the kernel dsh-tui runs on (DSH or Claude)' },
     { name: 'restart', description: 'Restart dsh-tui and resume this session' },
     { name: 'exit', description: 'Exit dsh-tui' },
     { name: 'quit', description: 'Exit dsh-tui', tag: 'alias of /exit' },
     { name: 'q', description: 'Exit dsh-tui', tag: 'alias of /exit' },
 ];
+/**
+ * `/permission` as a modes-capable backend serves it. Deliberately NOT a
+ * LOCAL_COMMANDS entry: DSH's own /permission comes from the permission-
+ * presets registry row, and a local entry would shadow it in the merged
+ * list (locals win collisions), flipping the external-command route the
+ * DSH pipeline depends on. The backend capability snapshot appends this
+ * shape instead (channel/capabilities.ts → session-controls), so a session
+ * with the typed `modes` capability offers the same command surface
+ * without touching DSH's.
+ */
+export const BACKEND_PERMISSION_COMMAND = {
+    name: 'permission',
+    description: 'Show or switch the permission mode',
+    descriptionKey: 'cmd-desc-permission',
+};
+/**
+ * `/channel` as a channels-capable backend serves it (the Claude backend's
+ * relay channel profiles, backends/claude/channels.ts). Like /permission,
+ * deliberately NOT a LOCAL_COMMANDS entry: the command must appear only on a
+ * backend that declares the typed `channels` capability — a DSH session
+ * (every built-in) and other backends never list it, so typing `/channel`
+ * there keeps today's not-a-command behavior. The capability snapshot
+ * appends the name (channel/capabilities.ts) and session-controls rides it
+ * here.
+ */
+export const BACKEND_CHANNEL_COMMAND = {
+    name: 'channel',
+    description: 'Manage relay channel profiles (switch, import, view mappings)',
+    descriptionKey: 'cmd-desc-channel',
+};
+/**
+ * `/goal` as a goals-capable backend serves it (the typed `goals`
+ * capability; the channel core's `backendGoals` host). Like /permission,
+ * deliberately NOT a LOCAL_COMMANDS entry: DSH's own /goal is the
+ * `dsh-command-goal` registry row, and a local entry would shadow it. The
+ * capability snapshot appends the name (channel/capabilities.ts) and
+ * session-controls rides it here. On a backend without the capability the
+ * typed command is refused as unavailable (`isUnavailableLocalCommand`).
+ */
+export const BACKEND_GOAL_COMMAND = {
+    name: 'goal',
+    description: 'Set or show the session goal',
+    descriptionKey: 'cmd-desc-goal',
+};
+const LOCAL_COMMAND_REQUIREMENTS = new Map([
+    ['new', 'any'], ['clear', 'any'], ['status', 'any'], ['cost', 'any'], ['tokens', 'any'],
+    ['settings', 'any'], ['star', 'any'], ['doctor', 'any'], ['help', 'any'], ['tips', 'any'],
+    ['exit', 'any'], ['quit', 'any'], ['q', 'any'], ['theme', 'any'], ['lang', 'any'],
+    ['activity', 'any'], ['thinking', 'any'], ['vim', 'any'], ['terminal-setup', 'any'],
+    ['connect', 'any'], ['update', 'any'], ['export', 'any'], ['panel', 'any'],
+    // The composition root serves these by respawning the process, so every
+    // backend offers them. /kernel is also the only way back to DSH from
+    // inside a non-DSH conversation (the launchpad's kernel entry is the other).
+    ['kernel', 'any'], ['restart', 'any'],
+    ['compact', 'compact'], ['resume', 'resume'], ['home', 'resume'], ['agentview', 'resume'],
+    ['bg', 'resume'], ['background', 'resume'], ['rewind', 'rewind'], ['fork', 'fork'],
+    ['model', 'models'], ['effort', 'effort'], ['agents', 'subagents'], ['jobs', 'tasks'], ['mcp', 'mcp'],
+    ['context', 'context'], ['login', 'login'], ['logout', 'login'], ['init', 'init'],
+    ['recap', 'sideQuery'], ['btw', 'sideQuery'], ['rename', 'rename'], ['color', 'color'],
+    // /trace opens on every backend; one without trajectory data shows the
+    // unsupported state (channel.trajectorySource() decides, not this table).
+    ['trace', 'any'],
+]);
+/** The requirement of one built-in command name (unlisted → `dsh`). */
+export function localCommandRequirement(name) {
+    return LOCAL_COMMAND_REQUIREMENTS.get(name) ?? 'dsh';
+}
+/**
+ * Names of the built-in commands a backend supports, in catalog order. A DSH
+ * session supports every built-in (today's list, unchanged); any other
+ * session supports the `any` commands plus those whose capability it has.
+ */
+export function supportedLocalCommandNames(backend) {
+    return LOCAL_COMMANDS.filter(command => {
+        if (backend.dsh)
+            return true;
+        const requirement = localCommandRequirement(command.name);
+        if (requirement === 'any')
+            return true;
+        if (requirement === 'dsh')
+            return false;
+        return backend.has(requirement);
+    }).map(command => command.name);
+}
+/**
+ * Whether a typed name is a built-in command the bound backend lacks. Such a
+ * line must neither run nor reach the model: the caller shows
+ * `cmd-unavailable-backend`. An absent snapshot (a partial embedder channel)
+ * means everything is supported. `/goal` counts as one when the snapshot
+ * says goals are not served (a backend without the `goals` capability; a
+ * snapshot without the flag predates it and serves everything).
+ */
+export function isUnavailableLocalCommand(name, capabilities) {
+    if (capabilities === undefined)
+        return false;
+    if (name === BACKEND_GOAL_COMMAND.name)
+        return capabilities.goals === false;
+    return LOCAL_COMMANDS.some(command => command.name === name) && !capabilities.commands.includes(name);
+}
 /**
  * Hidden slash commands: intentionally not exposed in the `/` suggestion
  * menu or Help, but still recognized as local commands when typed. They are
@@ -126,6 +226,100 @@ export function localizedDescription(command) {
         return translated;
     return tOr(command.descriptionKey ?? `cmd-desc-${command.name}`, command.description);
 }
+/**
+ * Commands the channel REFUSES to run while a turn is streaming, mapped to the
+ * i18n key of the refusal notice. This table is the single source of truth for
+ * what a gate SAYS and for the `/` suggestion overlay that sinks the rows
+ * affecting the running conversation — so the refusal text and the overlay
+ * annotation can never drift. WHETHER a command is refused still lives in each
+ * gate's own `state.working` / `channel.working` branch — the 11 bail-outs under
+ * `src/dsh-adapter/` plus the UI-side gates that share the same refusals — so
+ * a new gate means a new entry here: `scripts/verify-command-hold.ts` fails when
+ * a `working` bail-out under `src/dsh-adapter/` notifies with a literal key of
+ * its own, and when a new name joins this dictionary without a conscious edit
+ * there. A `t(...)` call in a gate pins the key type, so removing an entry from
+ * the dict fails the build.
+ */
+export const WORKING_GATE_NOTICES = {
+    new: 'new-session-while-working',
+    compact: 'compact-while-working',
+    fork: 'fork-while-working',
+    model: 'model-switch-while-working',
+    preset: 'preset-agent-running',
+    workspace: 'workspace-switch-working',
+    update: 'update-working',
+    restart: 'update-working',
+    // `/resume` and the core's `/rewind` refuse mid-turn in the session-switch
+    // transaction; under DSH the rewind extension instead CANCELS the turn and
+    // re-arms (session-rewind.ts), so the refusal is the core's own path. The
+    // `/resume` KEY stays here for that core path and for `resumeFailureText`,
+    // but its ROW is not gray-zoned — see GRAY_ZONE_EXEMPT_COMMANDS.
+    resume: 'resume-while-working',
+    rewind: 'rewind-while-working',
+    // Both backend pickers open while a turn runs, but every mutating row inside
+    // them is refused (`/kernel` confirms a switch; `/channel` imports, adds,
+    // manages or switches to a profile that needs a process restart).
+    kernel: 'kernel-switch-while-working',
+    channel: 'channel-switch-while-working',
+};
+/**
+ * Commands that DO have a mid-turn refusal notice of their own, yet whose ROW
+ * stays in the overlay's normal region: the command only OPENS a browser, and
+ * the refusals belong to the separate, separately confirmed actions INSIDE it.
+ *
+ * `/resume` opens the session manager (`Chat.tsx` `setSupervisorOpen`); the
+ * per-row switch is a separate action that PARKS the outgoing session and lets
+ * its turn keep running (`session-resume.ts`), so neither the command nor the
+ * switch interrupts the running turn — the same reason `/tree` is in the normal
+ * region. Its key stays in {@link WORKING_GATE_NOTICES} because the core's own
+ * session-switch transaction still refuses mid-turn on a backend that gets no
+ * DSH extension (Claude, `core/session-switch.ts`), and `resumeFailureText`
+ * reports that reason with it.
+ */
+export const GRAY_ZONE_EXEMPT_COMMANDS = ['resume'];
+/**
+ * Commands that MAY run while a turn is streaming but act ON the conversation
+ * itself rather than on the running turn: `clear` empties the visible view (the
+ * running turn keeps writing into it, `local-actions.ts`), and `exit` (with its
+ * `quit`/`q` aliases) tears the process — and the running turn — down.
+ *
+ * `/rewind` used to live here, because it cancels only once a target is
+ * CONFIRMED (`session-rewind.ts`) and replacing the conversation is its whole
+ * purpose. It moved to {@link WORKING_GATE_NOTICES} when the session-switch
+ * transaction grew its own mid-turn refusal: under DSH the extension still
+ * cancels and re-arms, but the core's rewind path REFUSES, and one command
+ * cannot be both. `/tree` deliberately stays out of both families: it only
+ * opens the family-tree browser (`Chat.tsx` `setTreeOpen(true)`) and leaves the
+ * running turn untouched — its per-node rewind/fork/adopt are separate,
+ * separately confirmed actions (`session-tree-actions.ts`), and browsing the
+ * tree is inspection, not impact (issue #1072 review: measured on a real turn —
+ * `/tree` does not interrupt). `/resume` belongs to that same normal region for
+ * the same reason, even though it does own a notice key for the core's refusal:
+ * see {@link GRAY_ZONE_EXEMPT_COMMANDS}.
+ */
+export const WORKING_CONVERSATION_COMMANDS = [
+    'clear', 'exit', 'quit', 'q',
+];
+/**
+ * Classify a command by its impact on the running conversation.
+ * @param name Bare command name or a completion path (`model deepseek-chat`);
+ *   only the first token is classified, so every child of a gated command
+ *   (`/model <id>`, `/workspace rename <t>`) inherits the parent's hold.
+ * @param skill Whether the entry is a user-invocable skill.
+ * @returns The hold, or `undefined` for the normal region.
+ */
+export function workingHoldOf(name, skill) {
+    if (skill === true)
+        return 'inject';
+    const root = name.replace(/^\//, '').trim().split(/[\t ]+/u)[0]?.toLowerCase() ?? '';
+    if (root === '')
+        return undefined;
+    if (GRAY_ZONE_EXEMPT_COMMANDS.includes(root))
+        return undefined;
+    if (Object.hasOwn(WORKING_GATE_NOTICES, root))
+        return 'gated';
+    return WORKING_CONVERSATION_COMMANDS.includes(root) ? 'conversation' : undefined;
+}
 /**
  * Parse a slash-command line into its name and the verbatim input following
  * the name (separator whitespace included) — the same split the DSH command

package/lib/types/components/AgentMessageComposer.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import type { AgentComposeTarget, AgentMessageControl, AgentMessageView } from './messages/agentTeam.js';
+export interface AgentMessageComposerProps {
+    /** Resolved target: unique name, or the stable id when ambiguous. */
+    readonly target: AgentComposeTarget;
+    /** The channel's message control (`subagentControl.message`); the wiring
+     *  already proved the member exists. */
+    readonly control: AgentMessageControl;
+    /** The durable feed for this child — later facts about our intents. */
+    readonly messages: readonly AgentMessageView[];
+    /** Keyboard focus; the scene yields plain typing here while true. */
+    readonly focused: boolean;
+    onFocusChange(focused: boolean): void;
+    /** Side-panel form: the panel's own key handler forwards keys through
+     *  this ref instead of the composer listening with useInput. The panel
+     *  host swallows every plain key before a later-mounted listener sees it,
+     *  so a direct listener would never get the typing, and one left active
+     *  after focus moves back to chat would pick up the chat's keystrokes. */
+    readonly keyHandlerRef?: React.MutableRefObject<ComposerKeyHandler | null>;
+}
+/** Ink's key flags as the composer reads them (the panel dispatcher passes
+ *  the same runtime object, with `return_` added). */
+type ComposerKey = {
+    readonly escape?: boolean;
+    readonly return?: boolean;
+    readonly return_?: boolean;
+    readonly ctrl?: boolean;
+    readonly meta?: boolean;
+    readonly shift?: boolean;
+    readonly backspace?: boolean;
+    readonly delete?: boolean;
+    readonly leftArrow?: boolean;
+    readonly rightArrow?: boolean;
+    readonly home?: boolean;
+    readonly end?: boolean;
+};
+/** true = the composer consumed the key. */
+export type ComposerKeyHandler = (input: string, key: ComposerKey) => boolean;
+/** Caret steps over whole code points, so an emoji is never split. */
+export declare function previousCodePoint(text: string, caret: number): number;
+export declare function nextCodePoint(text: string, caret: number): number;
+/**
+ * The user→child send box. It owns its own draft (never the parent's
+ * PromptInput, dock or queue) and submits only through the channel's
+ * AgentMessageControl (Claude: relayed by the parent; DSH: a direct prompt
+ * to a continuable child). A failure keeps the draft and says why.
+ */
+export declare function AgentMessageComposer({ target, control, messages, focused, onFocusChange, keyHandlerRef }: AgentMessageComposerProps): React.ReactNode;
+export {};
+//# sourceMappingURL=AgentMessageComposer.d.ts.map

package/lib/types/components/AgentMessageComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentMessageComposer.d.ts","sourceRoot":"","sources":["../../../src/components/AgentMessageComposer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAKzB,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EAGnB,gBAAgB,EACjB,MAAM,yBAAyB,CAAA;AAmChC,MAAM,WAAW,yBAAyB;IACxC,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;IACnC;4CACwC;IACxC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;IACrC,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC9C,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IACrC;;;;8EAI0E;IAC1E,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAA;CAC3E;AAED;sDACsD;AACtD,KAAK,WAAW,GAAG;IACjB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,KAAK,OAAO,CAAA;AAE7E,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKrE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,yBAAyB,GAAG,KAAK,CAAC,SAAS,CA0JrJ"}

package/lib/types/components/AgentMessageComposer.js

@@ -0,0 +1,159 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, useInput } from '../ui.js';
+import { t } from '../i18n.js';
+import { isPlainReturnInput } from '../utils/modifiers.js';
+import { agentMessageStateColor, agentMessageStateText, agentMessageViaText } from './messages/TranscriptLeaves.js';
+/** The control's stable failure reason → the notice word. */
+const NOTICE_OF_REASON = {
+    unavailable: 'agent-message-unavailable',
+    'target-ambiguous': 'agent-message-target-ambiguous',
+    'not-resumable': 'agent-message-target-not-resumable',
+    'parent-unavailable': 'agent-message-parent-unavailable',
+    unauthorized: 'agent-message-unauthorized',
+    'delivery-unavailable': 'agent-message-delivery-unavailable',
+    cancelled: 'agent-message-parent-interrupted',
+    failed: 'agent-message-dispatch-failed',
+};
+/** Caret steps over whole code points, so an emoji is never split. */
+export function previousCodePoint(text, caret) {
+    if (caret <= 0)
+        return 0;
+    const low = text.charCodeAt(caret - 1);
+    const high = caret >= 2 ? text.charCodeAt(caret - 2) : 0;
+    return low >= 0xdc00 && low <= 0xdfff && high >= 0xd800 && high <= 0xdbff ? caret - 2 : caret - 1;
+}
+export function nextCodePoint(text, caret) {
+    if (caret >= text.length)
+        return text.length;
+    return (text.codePointAt(caret) ?? 0) > 0xffff ? caret + 2 : caret + 1;
+}
+/**
+ * The user→child send box. It owns its own draft (never the parent's
+ * PromptInput, dock or queue) and submits only through the channel's
+ * AgentMessageControl (Claude: relayed by the parent; DSH: a direct prompt
+ * to a continuable child). A failure keeps the draft and says why.
+ */
+export function AgentMessageComposer({ target, control, messages, focused, onFocusChange, keyHandlerRef }) {
+    // The draft lives in a ref as well as in state: keys can arrive faster
+    // than React re-renders, and a handler reading a render-time copy would
+    // overwrite the previous keystroke (or submit twice on a double Enter).
+    const draftRef = React.useRef({ text: '', caret: 0 });
+    const [draft, setDraftState] = React.useState(draftRef.current);
+    const setDraft = (next) => {
+        draftRef.current = next;
+        setDraftState(next);
+    };
+    const { text, caret } = draft;
+    const sendingRef = React.useRef(false);
+    const [sending, setSending] = React.useState(false);
+    const [sent, setSent] = React.useState(null);
+    const [notice, setNotice] = React.useState(null);
+    // The display name: the unique name, the stable id when ambiguous, or the
+    // short id when the backend reports no name at all.
+    const shownName = target.ambiguous === true ? target.agentId.slice(0, 8) : target.name ?? target.agentId.slice(0, 8);
+    const canSubmit = target.name !== undefined && !sending;
+    // Later channel facts about our newest intent advance the status line.
+    const latestIntentState = React.useMemo(() => {
+        if (sent === null)
+            return undefined;
+        const advance = [...messages].reverse().find(message => message.intentId === sent.intentId);
+        return advance?.state ?? sent.state;
+    }, [messages, sent]);
+    const submit = (delivery) => {
+        const submitted = draftRef.current.text;
+        if (target.name === undefined || sendingRef.current || submitted.trim() === '')
+            return;
+        sendingRef.current = true;
+        setSending(true);
+        setNotice(null);
+        const settle = () => {
+            sendingRef.current = false;
+            setSending(false);
+        };
+        control.submit({
+            targetId: target.agentId,
+            targetName: target.name,
+            text: submitted,
+            delivery,
+        }).then(outcome => {
+            settle();
+            if (outcome.ok) {
+                // The channel mints the intent id; the receipt state is a FACT the
+                // transport stated (an accepted inbox is 'queued', never more).
+                // Text typed while the submit was in flight stays in the box.
+                if (draftRef.current.text === submitted)
+                    setDraft({ text: '', caret: 0 });
+                setSent({ intentId: outcome.intentId, text: submitted, state: outcome.state });
+                return;
+            }
+            // Failure keeps the draft verbatim; the notice names the stable
+            // reason, never a raw provider error.
+            setNotice({ key: NOTICE_OF_REASON[outcome.reason], failure: true });
+        }, () => {
+            settle();
+            setNotice({ key: 'agent-message-dispatch-failed', failure: true });
+        });
+    };
+    const handleKey = (input, key) => {
+        // Esc: the editor layer consumes it first — hand focus back to the scene
+        // with the draft retained (the next Esc leaves the Agent View).
+        if (key.escape === true) {
+            onFocusChange(false);
+            return true;
+        }
+        const returnKey = key.return === true || key.return_ === true;
+        if (isPlainReturnInput(input, { ...key, return: returnKey })) {
+            submit('queue');
+            return true;
+        }
+        // Ctrl+Enter steers ONLY under an explicit capability; Claude mediation
+        // keeps the followup placement (never interruptAndDeliver).
+        if (returnKey && key.ctrl === true) {
+            submit(control.steer === true ? 'steer' : 'queue');
+            return true;
+        }
+        const current = draftRef.current;
+        if (key.backspace === true || key.delete === true) {
+            if (current.caret > 0) {
+                const at = previousCodePoint(current.text, current.caret);
+                setDraft({ text: current.text.slice(0, at) + current.text.slice(current.caret), caret: at });
+            }
+            return true;
+        }
+        if (key.leftArrow === true) {
+            setDraft({ ...current, caret: previousCodePoint(current.text, current.caret) });
+            return true;
+        }
+        if (key.rightArrow === true) {
+            setDraft({ ...current, caret: nextCodePoint(current.text, current.caret) });
+            return true;
+        }
+        if (key.home === true || (key.ctrl === true && input === 'a')) {
+            setDraft({ ...current, caret: 0 });
+            return true;
+        }
+        if (key.end === true || (key.ctrl === true && input === 'e')) {
+            setDraft({ ...current, caret: current.text.length });
+            return true;
+        }
+        if (input !== '' && key.ctrl !== true && key.meta !== true) {
+            setDraft({ text: current.text.slice(0, current.caret) + input + current.text.slice(current.caret), caret: current.caret + input.length });
+            setNotice(null);
+            return true;
+        }
+        return false;
+    };
+    if (keyHandlerRef !== undefined)
+        keyHandlerRef.current = focused ? handleKey : null;
+    useInput((input, key, event) => {
+        if (handleKey(input, key))
+            event.stopImmediatePropagation();
+    }, { isActive: focused && keyHandlerRef === undefined });
+    const viaLabel = agentMessageViaText(control.via);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: "accent", children: '› ' }), _jsx(Text, { bold: true, children: t('agent-message-compose-title', { name: shownName }) }), _jsx(Text, { dimColor: true, children: ` · ${viaLabel}` })] }), target.ambiguous === true && (_jsx(Text, { dimColor: true, children: t('agent-message-target-ambiguous', { id: target.agentId.slice(0, 8) }) })), target.name === undefined && (_jsx(Text, { color: "warning", children: t('agent-message-target-nameless') })), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: text.slice(0, caret) }), _jsx(Text, { inverse: true, children: ' ' }), _jsx(Text, { children: text.slice(caret) })] }), notice !== null && (_jsx(Text, { color: notice.failure === true ? 'error' : undefined, children: `${t(notice.key)}${notice.failure === true ? ` · ${t('agent-message-draft-retained')}` : ''}` })), latestIntentState !== undefined && sent !== null && (_jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Text, { dimColor: true, children: `${t('agent-message-submitted')}: ` }), _jsx(Text, { color: agentMessageStateColor(latestIntentState), children: agentMessageStateText(latestIntentState) }), _jsx(Text, { dimColor: true, children: ` · ${t('agent-message-inbox-note')}` })] })), _jsx(Text, { dimColor: true, children: canSubmit
+                    ? (control.steer === true
+                        ? t('agent-message-hint-queue-steer')
+                        : t('agent-message-hint-queue'))
+                    : t('agent-message-hint-nameless') })] }));
+}

package/lib/types/components/BtwPanel.d.ts

@@ -1,16 +1,17 @@
-import React from 'react';
 /**
- * /btw side-question panel, an inline-pane form like the local pickers:
- * title line with the question, a scrollable answer body (error /
- * markdown answer / answering spinner), and a hint line. Owns the keyboard
- * while open — every key it sees is consumed here.
+ * BtwPanelFallback：btw 侧栏面板未启用时的 /btw 浮层。同一问答只在一处
+ * 呈现，Chat 只在面板未启用时挂它。
+ *
+ * 内容是当前 session 的 btw 线程（只读：无 composer、无 attach）。键位：
+ * Esc/Enter/Space 关闭（关闭即中止在途的一轮，由 Chat 接线）、↑/↓ 滚动、
+ * c 复制；浮层打开时吞掉其余所有键。底部提示如何启用 btw 面板，不替用户
+ * 改面板列表。
  */
-export declare function BtwPanel({ question, answer, error, streaming, onClose, onCopy, }: {
-    question: string;
-    answer: string;
-    error?: string;
-    streaming: boolean;
-    onClose: () => void;
-    onCopy: () => void;
+import React from 'react';
+import type { BtwThreadSnapshot } from './sidePanel/btw/threads.js';
+export declare function BtwPanelFallback({ thread, onClose, onCopy, }: {
+    readonly thread: BtwThreadSnapshot | undefined;
+    readonly onClose: () => void;
+    readonly onCopy: (answer: string) => void;
 }): React.ReactNode;
 //# sourceMappingURL=BtwPanel.d.ts.map

package/lib/types/components/BtwPanel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BtwPanel.d.ts","sourceRoot":"","sources":["../../../src/components/BtwPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAOzB;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,EACvB,QAAQ,EACR,MAAM,EACN,KAAK,EACL,SAAS,EACT,OAAO,EACP,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB,GAAG,KAAK,CAAC,SAAS,CA+DlB"}
+{"version":3,"file":"BtwPanel.d.ts","sourceRoot":"","sources":["../../../src/components/BtwPanel.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,MAAM,OAAO,CAAA;AAKzB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEnE,wBAAgB,gBAAgB,CAAC,EAC/B,MAAM,EACN,OAAO,EACP,MAAM,GACP,EAAE;IACD,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAC1C,GAAG,KAAK,CAAC,SAAS,CA+ClB"}

package/lib/types/components/BtwPanel.js

@@ -1,28 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * BtwPanelFallback：btw 侧栏面板未启用时的 /btw 浮层。同一问答只在一处
+ * 呈现，Chat 只在面板未启用时挂它。
+ *
+ * 内容是当前 session 的 btw 线程（只读：无 composer、无 attach）。键位：
+ * Esc/Enter/Space 关闭（关闭即中止在途的一轮，由 Chat 接线）、↑/↓ 滚动、
+ * c 复制；浮层打开时吞掉其余所有键。底部提示如何启用 btw 面板，不替用户
+ * 改面板列表。
+ */
 import React from 'react';
-import { Box, Text, useInput, ScrollBox, useTerminalSize } from '../ui.js';
-import { Markdown } from './Markdown.js';
-import { SpinnerGlyph } from './Spinner/SpinnerGlyph.js';
+import { Box, Text, useInput, useTerminalSize } from '../ui.js';
 import { t } from '../i18n.js';
 import { isPlainReturnInput } from '../utils/modifiers.js';
-/**
- * /btw side-question panel, an inline-pane form like the local pickers:
- * title line with the question, a scrollable answer body (error /
- * markdown answer / answering spinner), and a hint line. Owns the keyboard
- * while open — every key it sees is consumed here.
- */
-export function BtwPanel({ question, answer, error, streaming, onClose, onCopy, }) {
+import { BtwThreadView } from './sidePanel/btw/BtwThreadView.js';
+export function BtwPanelFallback({ thread, onClose, onCopy, }) {
     const scrollRef = React.useRef(null);
-    const { rows } = useTerminalSize();
-    // Spinner frame (80ms cadence, only while waiting for the first text).
-    const [frame, setFrame] = React.useState(0);
-    React.useEffect(() => {
-        if (!streaming || answer !== '')
-            return;
-        const interval = setInterval(() => setFrame(f => f + 1), 80);
-        return () => clearInterval(interval);
-    }, [streaming, answer]);
+    const { rows, columns } = useTerminalSize();
     useInput((input, key, event) => {
+        // A pasted chunk can carry the return flag; it must not close the
+        // overlay (closing aborts the side question in flight).
         if (key.escape || isPlainReturnInput(input, key) || input === ' ') {
             event.stopImmediatePropagation();
             onClose();
@@ -35,13 +31,28 @@ export function BtwPanel({ question, answer, error, streaming, onClose, onCopy,
         }
         if (input === 'c' && !key.ctrl) {
             event.stopImmediatePropagation();
-            onCopy();
+            const latest = latestAnswer(thread);
+            if (latest !== '')
+                onCopy(latest);
             return;
         }
-        // The overlay owns the keyboard while open: swallow everything else so
-        // nothing leaks into the prompt input behind it.
+        // 浮层拥有键盘：吞掉其余一切，不泄漏进身后的输入框。
         event.stopImmediatePropagation();
     });
-    const settled = answer !== '' || error !== undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "warning", bold: true, children: "/btw " }), _jsx(Text, { dimColor: true, children: question })] }), _jsx(Box, { flexDirection: "column", maxHeight: Math.max(5, rows - 8), children: _jsx(Box, { marginLeft: 2, flexDirection: "column", flexGrow: 1, children: _jsx(ScrollBox, { ref: scrollRef, flexDirection: "column", flexGrow: 1, children: error !== undefined ? (_jsx(Text, { color: "error", children: error })) : answer !== '' ? (_jsx(Markdown, { cacheTokens: false, children: answer })) : (_jsxs(Box, { children: [_jsx(SpinnerGlyph, { frame: frame, messageColor: "warning" }), _jsxs(Text, { color: "warning", children: [" ", t('btw-answering')] })] })) }) }) }), _jsx(Box, { onClick: settled ? onCopy : undefined, children: _jsx(Text, { dimColor: true, children: settled ? t('btw-hint-done') : streaming ? t('btw-hint-loading') : t('btw-hint-done') }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { flexDirection: "column", maxHeight: Math.max(5, rows - 8), children: _jsx(BtwThreadView, { thread: thread, width: columns, height: Math.max(5, rows - 10), alive: true, scrollHandleRef: scrollRef }) }), _jsx(Box, { onClick: settled(thread) ? () => { const latest = latestAnswer(thread); if (latest !== '')
+                    onCopy(latest); } : undefined, children: _jsxs(Text, { dimColor: true, children: [settled(thread) ? t('btw-hint-done') : t('btw-hint-loading'), '  ·  ', t('btw-panel-unavailable')] }) })] }));
+}
+function latestAnswer(thread) {
+    if (thread === undefined)
+        return '';
+    for (let index = thread.turns.length - 1; index >= 0; index -= 1) {
+        const turn = thread.turns[index];
+        if (turn.answer !== '')
+            return turn.answer;
+    }
+    return '';
+}
+function settled(thread) {
+    const active = thread?.turns.find(turn => turn.turnId === thread.activeTurnId);
+    return thread === undefined || active === undefined || active.answer !== '' || active.phase === 'failed';
 }

package/lib/types/components/ChannelPicker.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import type { BackendChannelOption } from '../dsh-adapter/channel.js';
+/**
+ * 渠道档案选择器（/channel，仅 channels 能力的后端——即 Claude）：一行一个
+ * 渠道（当前渠道打 ✓、行尾副行是映射规模），末尾两行固定动作——「从
+ * settings.json 导入」与「查看映射」。
+ *
+ * 视觉照 KernelPicker/ColorPicker 先例（Pane color=permission + 标题 +
+ * 行列表 + 底部提示行）；行是 ListItem 但 **styled=false**，❯ 焦点指针
+ * 恒在、✓ 跟 activeId 走。键盘归宿主（Chat 的 overlay 分支）：↑/↓ 移焦点、
+ * Enter 走确认路径、Esc 关掉，本组件不碰 useInput。
+ *
+ * 名册不冻在 overlay 里（rows 是 Chat 每渲染现读 channels.json 的派生值）：
+ * 切换/导入后 ✓ 与行自己就刷新，选择器留在屏上（管理器姿态，与 /kernel
+ * 的「选完即关」刻意不同——这里还要继续导入/查看）。
+ *
+ * 鼠标契约照仓库规矩：给了 onPick 行才可点（hover 底色随之出现），点击
+ * 回的是**行号**——宿主把它喂给与键盘 Enter 完全相同的那条确认路径。
+ */
+/** 一行：渠道、或固定动作之一（导入 / 新增 / 管理 / 查看映射）。 */
+export type ChannelPickerRow = {
+    readonly kind: 'channel';
+    readonly option: BackendChannelOption;
+    readonly active: boolean;
+} | {
+    readonly kind: 'import';
+} | {
+    readonly kind: 'add';
+} | {
+    readonly kind: 'manage';
+} | {
+    readonly kind: 'view';
+};
+export declare function ChannelPicker({ rows, focusIndex, onPick }: {
+    rows: readonly ChannelPickerRow[];
+    focusIndex: number;
+    /** 鼠标点行（落到 Chat 同一条确认路径） */
+    onPick?: (index: number) => void;
+}): React.ReactNode;
+//# sourceMappingURL=ChannelPicker.d.ts.map

package/lib/types/components/ChannelPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChannelPicker.d.ts","sourceRoot":"","sources":["../../../src/components/ChannelPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAKrE;;;;;;;;;;;;;;;;GAgBG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC7F;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7B,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE;IAC1D,IAAI,EAAE,SAAS,gBAAgB,EAAE,CAAA;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACjC,GAAG,KAAK,CAAC,SAAS,CAoElB"}

package/lib/types/components/ChannelPicker.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { t } from '../i18n.js';
+import { Box, Text } from '../ui.js';
+import { Pane } from './design-system/Pane.js';
+import { ListItem } from './design-system/ListItem.js';
+import { HintLine } from './design-system/HintLine.js';
+export function ChannelPicker({ rows, focusIndex, onPick }) {
+    return (_jsx(Pane, { color: "permission", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "remember", bold: true, children: t('channel-picker-title') }) }), !rows.some(row => row.kind === 'channel') && (_jsx(Box, { paddingLeft: 2, marginBottom: 1, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: t('channel-empty-hint') }) })), rows.map((row, index) => {
+                    const focused = index === focusIndex;
+                    if (row.kind === 'channel') {
+                        return (_jsx(ListItem, { isFocused: focused, isSelected: row.active, description: row.option.connection === undefined
+                                ? t('channel-row-summary', { models: String(row.option.models.length), tiers: String(row.option.tiers.length) })
+                                : t('channel-row-summary-conn', {
+                                    url: row.option.connection.baseUrl ?? t('channel-row-no-url'),
+                                    token: row.option.connection.hasToken ? '✓' : '—',
+                                    env: String(row.option.connection.envKeys.length),
+                                    models: String(row.option.models.length),
+                                    tiers: String(row.option.tiers.length),
+                                }), styled: false, onClick: onPick === undefined ? undefined : () => onPick(index), children: _jsx(Text, { color: row.active ? 'success' : focused ? 'suggestion' : undefined, bold: focused, wrap: "truncate-end", children: row.option.name }) }, row.option.id));
+                    }
+                    return (_jsx(ListItem, { isFocused: focused, styled: false, onClick: onPick === undefined ? undefined : () => onPick(index), children: _jsx(Text, { color: focused ? 'suggestion' : undefined, bold: focused, wrap: "truncate-end", children: t(row.kind === 'import' ? 'channel-action-import'
+                                : row.kind === 'add' ? 'channel-action-add'
+                                    : row.kind === 'manage' ? 'channel-action-manage'
+                                        : 'channel-action-view') }) }, row.kind));
+                }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: t('channel-picker-hint') }) })] }) }));
+}