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

package/lib/types/commands.js

@@ -1,9 +1,15 @@
 /**
  * Local slash commands for dsh-tui, presented as `/name — description`.
- * The built-in set is merged with plugin-registered
- * commands (plan/goal/…) from the DSH command registry (`dsh-commands`) —
- * `runCommand` in the Chat screen dispatches either kind, with the registry
- * handler winning for names both sides declare.
+ * The built-in set is merged with plugin-registered commands (plan/goal/…)
+ * from the DSH command registry (`dsh-commands`); `runCommand` in the Chat
+ * screen dispatches either kind.
+ *
+ * Locals win on name collisions: the merge skips a registry descriptor whose
+ * name a local command already declares (`channel/skill-catalog.ts`), and the
+ * Chat switch answers the local name before the registry path. `/compact` is
+ * the live case — the TUI's own transaction is the primary route and the
+ * official `dsh-command-compact` handler is only the fallback when the local
+ * path cannot run (see `dsh-adapter/channel/capabilities.ts`).
  */
 import { getLang, tOr } from './i18n.js';
 /**
@@ -33,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' },
@@ -42,12 +48,14 @@ export const LOCAL_COMMANDS = [
     { name: 'config', description: 'Show the dsh-tui configuration source' },
     { name: 'reload', description: 'Reload preference files from disk and apply live' },
     { name: 'settings', description: 'View and edit plugin settings' },
+    { name: 'setup', description: 'Re-run the first-run guide (API key / language + theme / model + workspace / shortcuts)' },
     { name: 'star', description: 'Star this project on GitHub (one-key via the gh CLI)' },
     { name: 'doctor', description: 'Run environment checks' },
     { name: 'migrate', description: 'Import conversations from other coding agents (claude-code / codex / omp / zcode / grok-build)' },
     { name: 'init', description: 'Create AGENTS.md in the working directory' },
     { name: 'agents', description: 'Show subagents of this session' },
     { name: 'jobs', description: 'Show background jobs of this session' },
+    { name: 'panel', description: 'Side panel: toggle / focus / zoom / switch panels' },
     // Model / display
     { name: 'activity', description: 'Switch the working-activity indicator preset' },
     { name: 'preset', description: 'Switch the agent preset (including Liangshen mode)' },
@@ -80,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
@@ -118,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/ActivityLine.d.ts

@@ -1,16 +1,13 @@
 import React from 'react';
 import type { ActivityView } from '../dsh-adapter/activity-store.js';
+import type { ContextOccupancy } from '../adapter/ports/channel-view.js';
 /**
- * Context-pressure percentage (0–100) from the last usage snapshot, or
- * undefined when unknown — shared by the spinner-line and status-line
- * placements of the working-activity line (pi working-activity style:
- * amber ≥ 80%, red ≥ 95%).
+ * Context-pressure percentage (0–100) from the channel's SINGLE occupancy
+ * reading (see `dsh-adapter/context-occupancy.ts`), or undefined when unknown —
+ * shared by the spinner-line and status-line placements of the
+ * working-activity line (pi working-activity style: amber ≥ 80%, red ≥ 95%).
  */
-export declare function contextPressurePct(usage: {
-    input: number;
-    cacheRead: number;
-    cacheWrite: number;
-} | undefined, contextWindow: number | undefined): number | undefined;
+export declare function contextPressurePct(occupancy: ContextOccupancy | undefined): number | undefined;
 /**
  * The working-activity line, rendered either in the spinner slot (while a
  * turn runs — alongside the random-verb spinner) or on the status bar

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

@@ -1 +1 @@
-{"version":3,"file":"ActivityLine.d.ts","sourceRoot":"","sources":["../../../src/components/ActivityLine.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAQzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EAC3E,aAAa,EAAE,MAAM,GAAG,SAAS,GAChC,MAAM,GAAG,SAAS,CAMpB;AAED;;;;;;;GAOG;AACH,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,cAAc,EACd,OAAO,EACP,UAAU,EACV,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,KAAK,CAAC,SAAS,CAuClB"}
+{"version":3,"file":"ActivityLine.d.ts","sourceRoot":"","sources":["../../../src/components/ActivityLine.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAQzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAExE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,GAAG,SAAS,GACtC,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;;;GAOG;AACH,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,cAAc,EACd,OAAO,EACP,UAAU,EACV,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,KAAK,CAAC,SAAS,CAuClB"}

package/lib/types/components/ActivityLine.js

@@ -8,17 +8,16 @@ import { getTheme } from '../theme.js';
 import { useTheme } from './design-system/ThemeProvider.js';
 import { parseRGB } from './Spinner/spinnerUtils.js';
 /**
- * Context-pressure percentage (0–100) from the last usage snapshot, or
- * undefined when unknown — shared by the spinner-line and status-line
- * placements of the working-activity line (pi working-activity style:
- * amber ≥ 80%, red ≥ 95%).
+ * Context-pressure percentage (0–100) from the channel's SINGLE occupancy
+ * reading (see `dsh-adapter/context-occupancy.ts`), or undefined when unknown —
+ * shared by the spinner-line and status-line placements of the
+ * working-activity line (pi working-activity style: amber ≥ 80%, red ≥ 95%).
  */
-export function contextPressurePct(usage, contextWindow) {
-    if (usage === undefined || contextWindow === undefined || contextWindow <= 0) {
+export function contextPressurePct(occupancy) {
+    if (occupancy === undefined || occupancy.contextWindow === undefined || occupancy.contextWindow <= 0) {
         return undefined;
     }
-    const occupied = usage.input + usage.cacheRead + usage.cacheWrite;
-    return Math.round((occupied / contextWindow) * 100);
+    return Math.round((occupancy.usedTokens / occupancy.contextWindow) * 100);
 }
 export function ActivityLine({ activity, activityFrames, warnPct, warnDanger, suffix, }) {
     // 60ms frames: the shimmer sweep advances one column per frame (3.3× the

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"}