@kortix/ui 0.0.0-stage → 0.14.4

package/dist/session/composer/quote-list.js

@@ -0,0 +1,41 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import { cn } from '../../lib/utils.js';
+import { CaretUpIcon, XIcon } from '@phosphor-icons/react';
+import { useId, useState } from 'react';
+/** The composer's own focus request — see `useComposerFocus`. */
+function focusComposer() {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent('focus-session-textarea'));
+}
+/**
+ * What a row's X does: remove that quote. A keyboard press (`detail === 0`)
+ * also sends focus to the composer, because the focused button unmounts with
+ * its row and focus would otherwise fall to `<body>`. A pointer press leaves
+ * focus alone: on a touch device, focusing the editor opens the keyboard.
+ */
+export function quoteListRemove(event, deps) {
+    deps.onRemove(event.id);
+    if (event.detail === 0)
+        deps.focusComposer();
+}
+/**
+ * The reply quotes waiting to go out with the next message, as a card above
+ * the composer. Same chrome as the queued-messages card: a header with the
+ * count and a collapse toggle, then one row per quote. A row shows one line
+ * of the quote, the full text in its `title`, and an X that removes it.
+ *
+ * Renders nothing for an empty list: the composer mounts it in an
+ * `empty:hidden` wrapper.
+ */
+export function QuoteList({ quotes, labels, onRemove, defaultCollapsed = false }) {
+    const listId = useId();
+    const labelId = useId();
+    // Collapse only hides the rows. Nothing is removed, and the count stays.
+    const [collapsed, setCollapsed] = useState(defaultCollapsed);
+    if (quotes.length === 0)
+        return null;
+    return (_jsxs("section", { "aria-labelledby": labelId, className: "bg-background border-border flex w-full flex-col rounded-lg border p-1", children: [_jsxs("div", { className: "flex items-center gap-2 py-0.5 pr-1 pl-2", children: [_jsx("span", { id: labelId, className: "text-muted-foreground flex min-w-0 flex-1 items-center self-stretch text-xs leading-none", children: labels.count }), _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", className: cn(!collapsed ? 'rotate-180' : 'rotate-0'), "aria-label": collapsed ? labels.expand : labels.collapse, "aria-expanded": !collapsed, "aria-controls": listId, onClick: () => setCollapsed((value) => !value), children: _jsx(CaretUpIcon, { className: "size-3.5" }) })] }), !collapsed && (_jsx("ul", { id: listId, className: "max-h-40 overflow-y-auto", children: quotes.map((quote) => (_jsxs("li", { "data-quote-id": quote.id, title: quote.text, className: "group/quote hover:bg-hover flex min-h-8 items-center gap-x-2 rounded-md border border-transparent px-2 py-0.5", children: [_jsx("p", { className: "text-foreground min-w-0 flex-1 truncate text-sm", children: quote.text }), _jsx("div", { className: "text-muted-foreground flex shrink-0 items-center gap-0.5 opacity-0 group-focus-within/quote:opacity-100 group-hover/quote:opacity-100 pointer-coarse:opacity-100", children: _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", "aria-label": labels.remove, onClick: (event) => quoteListRemove({ id: quote.id, detail: event.detail }, { onRemove, focusComposer }), children: _jsx(XIcon, { className: "size-3.5" }) }) })] }, quote.id))) }))] }));
+}

package/dist/session/composer/reasoning-effort-selector.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Show/hide + the choices, as a pure function so the rule is testable without
+ * React: the control renders only when the selected model publishes at least
+ * one variant AND the composer can apply one. Order and ids are the model's
+ * own; duplicates (a runtime + catalog merge slip) collapse to one entry.
+ */
+export declare function reasoningEffortChoices(variants: readonly string[] | undefined, canApply: boolean): string[];
+export interface ReasoningEffortSelectorProps {
+    /** The selected model's variant ids (`Object.keys(model.variants)`). */
+    variants: readonly string[] | undefined;
+    /** The session's current variant, or null = model default. */
+    selectedVariant: string | null | undefined;
+    /** Applies a variant to the session; absent = the composer cannot apply one
+     *  (no runtime model store), which hides the control entirely. */
+    onVariantChange?: (variant: string | null) => void;
+    /**
+     * Controlled open state — omit and the trigger owns it. Supplied by
+     * `composer.tsx` so the `/` palette's "Set reasoning effort" row can open
+     * this directly. Same controlled/uncontrolled rule as `ModelSelector`.
+     */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * Thinking effort as its own composer-toolbar control, a peer of the model
+ * pill, stating its value at rest. Renders NOTHING when the model publishes no
+ * variants or the composer cannot apply one — a model without a knob never
+ * grows dead chrome.
+ *
+ * A `DropdownMenu` rather than the `CommandPopover` the model and agent
+ * pickers use: this is a fixed list of a handful of values with no search, no
+ * grouping and no empty state, and `DropdownMenuRadioGroup` gives the
+ * single-select semantics — roving focus, typeahead, `aria-checked` — for
+ * free, where the command palette would need them re-implemented.
+ */
+export declare function ReasoningEffortSelector({ variants, selectedVariant, onVariantChange, open: openProp, onOpenChange, }: ReasoningEffortSelectorProps): import("react").JSX.Element | null;

package/dist/session/composer/reasoning-effort-selector.js

@@ -0,0 +1,121 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Thinking-effort control for the session chat composer — the ONE effort knob.
+ *
+ * It sets the session's model **variant** (`local.model.variant`, sent as
+ * `variant` on every prompt), never a project setting. The sandbox publishes
+ * the variant ids on the `kortix` provider and the harness sends
+ * `reasoning_effort` in the body; the gateway forwards it per upstream family
+ * and REFUSES it (400) for a family it cannot map, instead of stripping it.
+ *
+ * The list is `Object.keys(model.variants)` from the picker source the
+ * composer already holds — the runtime's own list once the sandbox is up, the
+ * ids derived from the API's live `reasoning_options` before that (see
+ * `nativeProviderListFromCatalog` / `projectLlmCatalogToProviderList` in the
+ * SDK). Never a hardcoded ladder, never the web's baked catalog seed.
+ *
+ * "Auto" clears the variant: the model's own default applies, and the
+ * project's Generation defaults (Customize → Gateway → Routing) fill the
+ * field the request left unset.
+ *
+ * History: this used to write the project-level routing policy
+ * (`model_generation_config`) from the composer, was hidden off-gateway
+ * (#6872), and read its values from a hand-regenerated catalog seed that sat
+ * 38 days stale (#6879). Two knobs by mode, three catalog copies. Now one.
+ */
+import { useTranslations } from '../../i18n/index.js';
+import { useCallback, useState } from 'react';
+import { Button } from '../../primitives/button.js';
+import { DropdownMenu, DropdownMenuContent, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuTrigger, } from '../../primitives/dropdown-menu.js';
+import { cn } from '../../lib/utils.js';
+import { CaretDownIcon, CellSignalFullIcon, CellSignalHighIcon, CellSignalLowIcon, CellSignalMediumIcon, CellSignalNoneIcon, GaugeIcon, } from '@phosphor-icons/react';
+/**
+ * The value `onVariantChange(null)` means: no variant, let the model decide.
+ * A sentinel is needed because Radix's radio group addresses items by string
+ * and cannot carry `null`.
+ */
+const AUTO = '__auto__';
+/**
+ * Show/hide + the choices, as a pure function so the rule is testable without
+ * React: the control renders only when the selected model publishes at least
+ * one variant AND the composer can apply one. Order and ids are the model's
+ * own; duplicates (a runtime + catalog merge slip) collapse to one entry.
+ */
+export function reasoningEffortChoices(variants, canApply) {
+    if (!canApply || !variants?.length)
+        return [];
+    return Array.from(new Set(variants.filter((v) => typeof v === 'string' && v.length > 0)));
+}
+/** `medium` → `Medium`. The catalog ships lowercase ids; the trigger and the
+ *  menu should not. */
+function label(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/**
+ * Cell-signal bars for effort — none → full ladder. Extra ladder steps
+ * (`xhigh`, `max`) share Full; unknown ids fall back to Medium so a future
+ * catalog value never renders without an icon.
+ *
+ * `null` (model decides, no variant) gets a Gauge icon instead of a
+ * cell-signal step — it isn't a fixed point on the none→full ladder, it's the
+ * dial that finds its own reading per turn.
+ *
+ * A switch that returns JSX (not a component reference) — assigning
+ * `const Icon = map[value]` and then `<Icon />` trips the React Compiler's
+ * "Cannot create components during render" rule.
+ */
+function EffortIcon({ value, className }) {
+    switch (value) {
+        case null:
+        case 'auto':
+            return _jsx(GaugeIcon, { className: className });
+        case 'none':
+            return _jsx(CellSignalNoneIcon, { className: className, weight: "fill" });
+        case 'minimal':
+        case 'low':
+            return _jsx(CellSignalLowIcon, { className: className, weight: "fill" });
+        case 'medium':
+            return _jsx(CellSignalMediumIcon, { className: className, weight: "fill" });
+        case 'high':
+            return _jsx(CellSignalHighIcon, { className: className, weight: "fill" });
+        case 'xhigh':
+        case 'max':
+        case 'full':
+            return _jsx(CellSignalFullIcon, { className: className, weight: "fill" });
+        default:
+            return _jsx(CellSignalMediumIcon, { className: className, weight: "fill" });
+    }
+}
+/**
+ * Thinking effort as its own composer-toolbar control, a peer of the model
+ * pill, stating its value at rest. Renders NOTHING when the model publishes no
+ * variants or the composer cannot apply one — a model without a knob never
+ * grows dead chrome.
+ *
+ * A `DropdownMenu` rather than the `CommandPopover` the model and agent
+ * pickers use: this is a fixed list of a handful of values with no search, no
+ * grouping and no empty state, and `DropdownMenuRadioGroup` gives the
+ * single-select semantics — roving focus, typeahead, `aria-checked` — for
+ * free, where the command palette would need them re-implemented.
+ */
+export function ReasoningEffortSelector({ variants, selectedVariant, onVariantChange, open: openProp, onOpenChange, }) {
+    const t = useTranslations('threads');
+    const choices = reasoningEffortChoices(variants, !!onVariantChange);
+    const [uncontrolledOpen, setUncontrolledOpen] = useState(false);
+    const isControlled = openProp !== undefined;
+    const open = isControlled ? openProp : uncontrolledOpen;
+    const setOpen = useCallback((next) => {
+        if (!isControlled)
+            setUncontrolledOpen(next);
+        onOpenChange?.(next);
+    }, [isControlled, onOpenChange]);
+    const onValueChange = useCallback((next) => onVariantChange?.(next === AUTO ? null : next), [onVariantChange]);
+    if (choices.length === 0)
+        return null;
+    // A stale per-model pick (a variant the current list no longer carries)
+    // reads as Auto rather than an unlabeled value; the next explicit choice
+    // replaces it.
+    const current = selectedVariant && choices.includes(selectedVariant) ? selectedVariant : null;
+    return (_jsxs(DropdownMenu, { open: open, onOpenChange: setOpen, children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsxs(Button, { type: "button", variant: "ghost", size: "sm", "aria-label": t('thinkingEffort'), className: "text-foreground/70 gap-1.5 rounded-lg hit-area-y-3", children: [_jsx(EffortIcon, { value: current, className: "size-4 shrink-0" }), _jsx("span", { className: "max-w-[7rem] truncate", children: current ? label(current) : t('auto') }), _jsx(CaretDownIcon, { className: cn('size-3 opacity-50 transition-transform duration-200 ease-out', open && 'rotate-180') })] }) }), _jsx(DropdownMenuContent, { side: "top", align: "start", className: "min-w-[10rem]", children: _jsxs(DropdownMenuRadioGroup, { value: current ?? AUTO, onValueChange: onValueChange, children: [_jsxs(DropdownMenuRadioItem, { value: AUTO, children: [_jsx(EffortIcon, { value: null, className: "size-4 shrink-0" }), t('auto')] }), choices.map((value) => (_jsxs(DropdownMenuRadioItem, { value: value, children: [_jsx(EffortIcon, { value: value, className: "size-4 shrink-0" }), label(value)] }, value)))] }) })] }));
+}

package/dist/session/composer/send-blockers.d.ts

@@ -0,0 +1,101 @@
+import type { UiTranslator } from '../../i18n/index.js';
+/**
+ * What still refuses a submission once the server owns prompt ordering.
+ *
+ * The composer used to consult an eleven-field `QueueDrainGates` before every
+ * send — `isServerBusy`, `pendingSendInFlight`, `isOptimisticCompacting`,
+ * `hasIncompleteAssistant`, `hasPendingApproval`, `isPaused`, `runtimeReady`,
+ * and the rest. Every one of those was a browser tab guessing at a session's
+ * state, two tabs guessed differently, and the guess decided whether a message
+ * went out or sat in localStorage. They are gone: a prompt is POSTed to the
+ * session's durable inbox and the control plane's admission gate — reading the
+ * same turn authority `GET .../turn` serves from — decides when it runs.
+ *
+ * What survives for a PROMPT is only what the server cannot know, and there are
+ * three of them. They are refusals, not a queue: nothing is held, the draft
+ * stays in the editor, and the user is told why.
+ *
+ *   - `active_question` — a structured question is on screen. That text would
+ *     answer the wrong prompt.
+ *   - `pending_permission` — a connector action or permission is waiting on the
+ *     user. Sending past it bypasses the gate.
+ *   - `read_only` — a viewer with no send rights (the sub-session modal).
+ *
+ * A `/` COMMAND adds two more (`commandBlocker` below), both for the same
+ * reason: it is not an inbox row, so there is nowhere for it to wait.
+ *
+ * Two gates from the old set are deliberately NOT here:
+ *
+ *   - `revertStaged`. It blocked the auto-drain from firing into a trajectory
+ *     the user had asked to discard. There is no auto-drain, and a staged
+ *     revert is precisely the state in which the user types their REPLACEMENT
+ *     prompt — refusing it would make edit-and-resend impossible. The
+ *     replacement prompt IS what commits the revert: OpenCode truncates on the
+ *     next delivery, from any producer. The server's own guard
+ *     (`queuedContinueHasStagedRevert`,
+ *     `apps/api/src/projects/session-lifecycle/engine.ts`) lets a prompt that
+ *     never waited commit the revert for that reason, and refuses the rows that
+ *     queued BEFORE it — for every client, which a gate in this tab could never
+ *     do.
+ *   - `isServerBusy`, for a PROMPT. That is the inbox's decision now.
+ *   - `runtimeReady`, for a PROMPT. A prompt typed at a sleeping box becomes an
+ *     inbox row and is delivered when the box answers. A COMMAND cannot: see
+ *     `commandBlocker`.
+ */
+export declare function runtimePermissionLocksComposer(pendingPermissions: number, isBusy: boolean): boolean;
+export type SendBlocker = 'active_question' | 'pending_permission' | 'read_only' | 'session_working' | 'runtime_waking';
+export interface SendBlockerInput {
+    /** A structured question is on screen for this session. */
+    hasActiveQuestion: boolean;
+    /**
+     * Connector actions and permissions awaiting the user.
+     *
+     * A count rather than a boolean because that is the quantity the session
+     * actually holds; a caller that only has "something is pending" passes 1.
+     */
+    pendingPermissionCount: number;
+    /** This surface cannot send at all (the read-only sub-session modal). */
+    readOnly: boolean;
+}
+/**
+ * The first reason this submission cannot go out, or `null`.
+ *
+ * Ordered by how total the refusal is: a read-only viewer can do nothing about
+ * a question or a permission, so naming either of those first would send the
+ * user after a fix that is not theirs to make.
+ */
+export declare function sendBlocker(input: SendBlockerInput): SendBlocker | null;
+/**
+ * The same, for a `/` COMMAND — which has two refusals a prompt does not.
+ *
+ * A command is dispatched through `runCommand` (a server-expanded template),
+ * never through `POST .../prompts`, so no admission gate ever sees it. Both
+ * extra refusals follow from that one fact: a prompt has a durable row to wait
+ * in, and a command has nowhere to wait at all.
+ *
+ *   - `session_working` — sent mid-turn the command goes straight onto the wire
+ *     ahead of everything the inbox is holding, and a new prompt aborts the turn
+ *     in progress (the "Interrupted" symptom).
+ *   - `runtime_waking` — the sandbox is stopped or still booting.
+ *     `useSession`'s `runCommand` returns a RESOLVED promise when the runtime is
+ *     not switched yet: no request, no error, nothing queued. The composer read
+ *     that as a successful dispatch, cleared the draft, and left an optimistic
+ *     command bubble waiting on a turn that never starts. A PROMPT typed in the
+ *     same state is fine — it becomes an inbox row and the drain delivers it
+ *     when the box answers, which is what the composer's "Waking this session
+ *     up…" notice promises.
+ *
+ * Both only DELAY a command. `SessionChat` holds one in either state
+ * (`onHoldCommand`, `held-commands.ts`) and runs it when the session can take
+ * it. A host without a hold shows the refusal, and the draft stays in the
+ * editor.
+ */
+export declare function commandBlocker(input: SendBlockerInput & {
+    isWorking: boolean;
+    runtimeReady: boolean;
+}): SendBlocker | null;
+/** User-facing copy. One place, so no call site invents its own wording. */
+export declare function sendBlockerMessage(blocker: SendBlocker, tI18nComplete: UiTranslator): {
+    message: string;
+    description?: string;
+};

package/dist/session/composer/send-blockers.js

@@ -0,0 +1,122 @@
+/**
+ * What still refuses a submission once the server owns prompt ordering.
+ *
+ * The composer used to consult an eleven-field `QueueDrainGates` before every
+ * send — `isServerBusy`, `pendingSendInFlight`, `isOptimisticCompacting`,
+ * `hasIncompleteAssistant`, `hasPendingApproval`, `isPaused`, `runtimeReady`,
+ * and the rest. Every one of those was a browser tab guessing at a session's
+ * state, two tabs guessed differently, and the guess decided whether a message
+ * went out or sat in localStorage. They are gone: a prompt is POSTed to the
+ * session's durable inbox and the control plane's admission gate — reading the
+ * same turn authority `GET .../turn` serves from — decides when it runs.
+ *
+ * What survives for a PROMPT is only what the server cannot know, and there are
+ * three of them. They are refusals, not a queue: nothing is held, the draft
+ * stays in the editor, and the user is told why.
+ *
+ *   - `active_question` — a structured question is on screen. That text would
+ *     answer the wrong prompt.
+ *   - `pending_permission` — a connector action or permission is waiting on the
+ *     user. Sending past it bypasses the gate.
+ *   - `read_only` — a viewer with no send rights (the sub-session modal).
+ *
+ * A `/` COMMAND adds two more (`commandBlocker` below), both for the same
+ * reason: it is not an inbox row, so there is nowhere for it to wait.
+ *
+ * Two gates from the old set are deliberately NOT here:
+ *
+ *   - `revertStaged`. It blocked the auto-drain from firing into a trajectory
+ *     the user had asked to discard. There is no auto-drain, and a staged
+ *     revert is precisely the state in which the user types their REPLACEMENT
+ *     prompt — refusing it would make edit-and-resend impossible. The
+ *     replacement prompt IS what commits the revert: OpenCode truncates on the
+ *     next delivery, from any producer. The server's own guard
+ *     (`queuedContinueHasStagedRevert`,
+ *     `apps/api/src/projects/session-lifecycle/engine.ts`) lets a prompt that
+ *     never waited commit the revert for that reason, and refuses the rows that
+ *     queued BEFORE it — for every client, which a gate in this tab could never
+ *     do.
+ *   - `isServerBusy`, for a PROMPT. That is the inbox's decision now.
+ *   - `runtimeReady`, for a PROMPT. A prompt typed at a sleeping box becomes an
+ *     inbox row and is delivered when the box answers. A COMMAND cannot: see
+ *     `commandBlocker`.
+ */
+export function runtimePermissionLocksComposer(pendingPermissions, isBusy) {
+    return pendingPermissions > 0 && isBusy;
+}
+/**
+ * The first reason this submission cannot go out, or `null`.
+ *
+ * Ordered by how total the refusal is: a read-only viewer can do nothing about
+ * a question or a permission, so naming either of those first would send the
+ * user after a fix that is not theirs to make.
+ */
+export function sendBlocker(input) {
+    if (input.readOnly)
+        return 'read_only';
+    if (input.hasActiveQuestion)
+        return 'active_question';
+    if (input.pendingPermissionCount > 0)
+        return 'pending_permission';
+    return null;
+}
+/**
+ * The same, for a `/` COMMAND — which has two refusals a prompt does not.
+ *
+ * A command is dispatched through `runCommand` (a server-expanded template),
+ * never through `POST .../prompts`, so no admission gate ever sees it. Both
+ * extra refusals follow from that one fact: a prompt has a durable row to wait
+ * in, and a command has nowhere to wait at all.
+ *
+ *   - `session_working` — sent mid-turn the command goes straight onto the wire
+ *     ahead of everything the inbox is holding, and a new prompt aborts the turn
+ *     in progress (the "Interrupted" symptom).
+ *   - `runtime_waking` — the sandbox is stopped or still booting.
+ *     `useSession`'s `runCommand` returns a RESOLVED promise when the runtime is
+ *     not switched yet: no request, no error, nothing queued. The composer read
+ *     that as a successful dispatch, cleared the draft, and left an optimistic
+ *     command bubble waiting on a turn that never starts. A PROMPT typed in the
+ *     same state is fine — it becomes an inbox row and the drain delivers it
+ *     when the box answers, which is what the composer's "Waking this session
+ *     up…" notice promises.
+ *
+ * Both only DELAY a command. `SessionChat` holds one in either state
+ * (`onHoldCommand`, `held-commands.ts`) and runs it when the session can take
+ * it. A host without a hold shows the refusal, and the draft stays in the
+ * editor.
+ */
+export function commandBlocker(input) {
+    const shared = sendBlocker(input);
+    if (shared)
+        return shared;
+    // Before `session_working`: nothing is running on a box that is not up, so
+    // naming the turn would send the user to wait for something that is not
+    // happening.
+    if (!input.runtimeReady)
+        return 'runtime_waking';
+    return input.isWorking ? 'session_working' : null;
+}
+/** User-facing copy. One place, so no call site invents its own wording. */
+export function sendBlockerMessage(blocker, tI18nComplete) {
+    switch (blocker) {
+        case 'read_only':
+            return { message: tI18nComplete.raw('text9c2b4e67342e') };
+        case 'active_question':
+            return {
+                message: tI18nComplete.raw('text88c2105adecf'),
+                description: tI18nComplete.raw('text9cf511ca5657'),
+            };
+        case 'pending_permission':
+            return { message: tI18nComplete.raw('text3e11e93e0f42') };
+        case 'session_working':
+            return {
+                message: tI18nComplete.raw('text634e8a443a91'),
+                description: tI18nComplete.raw('text1d28e1a19048'),
+            };
+        case 'runtime_waking':
+            return {
+                message: tI18nComplete.raw('text376f3f363e3e'),
+                description: tI18nComplete.raw('text918174950933'),
+            };
+    }
+}

package/dist/session/composer/send-stop-control.d.ts

@@ -0,0 +1,39 @@
+export interface SendStopControlProps {
+    isSending: boolean;
+    isBusy: boolean;
+    onStop?: () => void;
+    stopDisabled: boolean;
+    /**
+     * May this viewer stop the running turn (`useSession().canStop`)? In a
+     * shared session only the member who started it, the session owner or a
+     * project manager may. False shows Send while busy: the message queues.
+     */
+    canStop?: boolean;
+    escCount: number;
+    lockForQuestion: boolean;
+    questionButtonLabel?: string | null;
+    /**
+     * A labeled button that submits, shown in place of send AND stop. Set while
+     * the composer edits a queued message: the send saves the edit back into
+     * the queue, so a busy turn's Stop is not the action on offer.
+     */
+    submitLabel?: string | null;
+    questionCanAct: boolean;
+    hasText: boolean;
+    canSubmit: boolean;
+    submitDisabled: boolean;
+    disabled: boolean;
+    modelUnavailable: boolean;
+    /**
+     * The agent roster is empty for this user, so nothing can run this prompt.
+     * Outranks `modelUnavailable` in the copy: with no agent, the model is not
+     * the thing to go fix.
+     */
+    agentUnavailable?: boolean;
+    /** A selected upload failed. Send is refused until it is retried or removed. */
+    attachmentFailed?: boolean;
+    /** Why the selected model cannot take the attachments. Send is refused while set. */
+    attachmentUnsupported?: string | null;
+    onSubmit: () => void;
+}
+export declare function SendStopControl({ isSending, isBusy, onStop, stopDisabled, canStop, escCount, lockForQuestion, questionButtonLabel, submitLabel, questionCanAct, hasText, canSubmit, submitDisabled, disabled, modelUnavailable, agentUnavailable, attachmentFailed, attachmentUnsupported, onSubmit, }: SendStopControlProps): import("react").JSX.Element;

package/dist/session/composer/send-stop-control.js

@@ -0,0 +1,68 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import Hint from '../../primitives/hint.js';
+import { Kbd } from '../../primitives/kbd.js';
+import Loading from '../../primitives/loading.js';
+import { ArrowUpIcon as ArrowUp, SquareIcon } from '@phosphor-icons/react';
+import { AnimatePresence, m } from 'motion/react';
+import { useTranslations } from '../../i18n/index.js';
+import { NO_MODEL_AVAILABLE_ACTION_MESSAGE } from '../models/model-availability.js';
+import { NO_AGENT_ACCESS_MESSAGE } from './composer-agent-access.js';
+const ICON_BUTTON = 'shrink-0 rounded-full p-0 hit-area-3 z-20 transition-[color,background-color,opacity,scale] active:scale-[0.96] active:duration-(--duration-normal) duration-(--duration-slow) ease-out';
+/**
+ * Send ⇄ stop ⇄ pending cross-fade. The three states used to be three separate
+ * `return`s, so the glyph hard-cut between them on every turn boundary — the
+ * most-watched control in the app changing identity with no transition.
+ */
+const ICON_SWAP = {
+    initial: { scale: 0.25, opacity: 0, filter: 'blur(4px)' },
+    animate: { scale: 1, opacity: 1, filter: 'blur(0px)' },
+    exit: { scale: 0.25, opacity: 0, filter: 'blur(4px)' },
+    transition: { type: 'spring', duration: 0.3, bounce: 0 },
+};
+export function SendStopControl({ isSending, isBusy, onStop, stopDisabled, canStop = true, escCount, lockForQuestion, questionButtonLabel, submitLabel = null, questionCanAct, hasText, canSubmit, submitDisabled, disabled, modelUnavailable, agentUnavailable = false, attachmentFailed = false, attachmentUnsupported = null, onSubmit, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const t = useTranslations('threads');
+    const tAttachments = useTranslations('hardcodedUi.composerAttachments');
+    // One line, the same one the agent picker's tooltip carries — the two
+    // controls are refusing for one reason and must not word it two ways.
+    const refusal = agentUnavailable
+        ? NO_AGENT_ACCESS_MESSAGE
+        : modelUnavailable
+            ? NO_MODEL_AVAILABLE_ACTION_MESSAGE
+            : attachmentFailed
+                ? tAttachments('failedBlocksSend')
+                : attachmentUnsupported;
+    const sendButton = (_jsx(Hint, { side: "top", label: refusal ?? t('sendMessage'), children: _jsx("span", { className: "inline-flex", children: _jsx(Button, { size: "icon-base", disabled: lockForQuestion
+                    ? (!canSubmit && !questionCanAct) || disabled
+                    : !canSubmit || submitDisabled, onClick: onSubmit, "aria-label": t('sendMessage'), title: refusal ?? undefined, className: ICON_BUTTON, children: _jsx(AnimatePresence, { mode: "popLayout", initial: false, children: _jsx(m.span, { className: "flex items-center", ...ICON_SWAP, children: disabled ? (_jsx(Loading, { className: "size-3.5 shrink-0" })) : (_jsx(ArrowUp, { className: "size-4" })) }, disabled ? 'busy' : 'send') }) }) }) }));
+    if (isSending && !lockForQuestion) {
+        return (_jsx(Button, { size: "icon-base", "aria-label": t('sending'), disabled: true, className: ICON_BUTTON, children: _jsx(AnimatePresence, { mode: "popLayout", initial: false, children: _jsx(m.span, { className: "flex items-center", ...ICON_SWAP, children: _jsx(Loading, { className: "size-4" }) }, "pending") }) }));
+    }
+    if (submitLabel && !lockForQuestion) {
+        return (_jsx(Hint, { side: "top", label: refusal ?? submitLabel, children: _jsx("span", { className: "inline-flex", children: _jsx(Button, { size: "sm", disabled: !canSubmit || submitDisabled, onClick: onSubmit, title: refusal ?? undefined, className: "hit-area-1 shrink-0 rounded-lg transition-[color,background-color,opacity,scale] duration-(--duration-slow) ease-out active:scale-[0.96] active:duration-(--duration-normal)", children: submitLabel }) }) }));
+    }
+    // The session is working, so STOP is the only honest control here — even
+    // while the host has not handed one down yet. It used to require
+    // `onStop || stopDisabled`, and with neither the whole component fell
+    // through to `return null` and the button VANISHED mid-turn. A disabled stop
+    // says "working, cannot cancel yet"; nothing at all says "broken", and
+    // `project-home.tsx:249` had to pass a dummy `stopDisabled` to work around it.
+    if (!isSending && isBusy && canStop && !lockForQuestion) {
+        // A follow-up typed during the turn gets Send too (KRTX-2556): with Stop
+        // alone, a click meant to send it ended the run and left it unsent. Send
+        // goes out the way Enter does; Stop steps back to secondary beside it.
+        const followUp = hasText || canSubmit;
+        const stop = (_jsxs("div", { className: "relative flex items-center", children: [escCount > 0 && (_jsx("div", { className: "animate-in fade-in-0 zoom-in-95 slide-in-from-bottom-2 pointer-events-none absolute right-1/2 bottom-full mb-2 translate-x-1/2 duration-(--duration-normal)", children: _jsxs("div", { className: "bg-background text-foreground z-[9999] inline-flex w-fit items-center gap-1.5 overflow-hidden rounded-sm border p-1 px-1.5 text-xs whitespace-nowrap", children: [_jsx(Kbd, { children: "ESC" }), _jsx("span", { children: escCount === 1
+                                    ? tI18nComplete.raw('textb9ef397631ca')
+                                    : tI18nComplete.raw('text9754e2d14f9e') })] }) })), _jsx(Hint, { side: "top", label: _jsxs("p", { children: [tI18nComplete.raw('textcae7d57bc067'), " ", _jsx(Kbd, { children: "ESC" }), " \u00D73"] }), children: _jsx(Button, { size: "icon-base", variant: followUp ? 'secondary' : 'default', "aria-label": t('stop'), onClick: onStop, disabled: stopDisabled || !onStop, className: ICON_BUTTON, children: _jsx(AnimatePresence, { mode: "popLayout", initial: false, children: _jsx(m.span, { className: "flex items-center", ...ICON_SWAP, children: _jsx(SquareIcon, { weight: "fill", className: "size-4 shrink-0" }) }, "stop") }) }) })] }));
+        if (!followUp)
+            return stop;
+        return (_jsxs("div", { className: "flex items-center gap-1.5", children: [stop, sendButton] }));
+    }
+    if (lockForQuestion && questionButtonLabel && !hasText) {
+        return (_jsx(Button, { size: "sm", disabled: !questionCanAct || disabled, onClick: onSubmit, className: "hit-area-1 shrink-0 rounded-lg transition-[color,background-color,opacity,scale] duration-(--duration-slow) ease-out active:scale-[0.96] active:duration-(--duration-normal)", children: questionButtonLabel }));
+    }
+    return sendButton;
+}

package/dist/session/composer/sent-attachment-previews.d.ts

@@ -0,0 +1,59 @@
+import type { AttachedFile } from './types.js';
+/** One file a Send carried: its identity (absent for a remote file), name and type. */
+export interface SentAttachment {
+    id?: string;
+    filename: string;
+    mime: string;
+}
+/** The picture the composer showed for this attachment, while a sent tile still needs it. */
+export declare function sentAttachmentPreview(id: string | undefined): string | undefined;
+/**
+ * Remember the identities a session's first prompt was sent with.
+ *
+ * The first-prompt store drops its copy the frame the transcript carries the files. Those
+ * delivered parts cannot draw a picture until the sandbox copy loads (~24 s, browser timeline
+ * 2026-09-15), so the first turn and the boot shell read the identities from here instead.
+ */
+export declare function rememberFirstPromptAttachments(sessionId: string, attachments: ReadonlyArray<SentAttachment>): void;
+/** The identities `rememberFirstPromptAttachments` kept for this session. */
+export declare function firstPromptAttachments(sessionId: string | undefined): ReadonlyArray<SentAttachment> | undefined;
+/**
+ * The composer tile converted a HEIC upload to JPEG. A Send takes that JPEG.
+ * The returned function runs when the tile lets go: it revokes the JPEG unless a Send took it.
+ */
+export declare function holdConvertedPreview(id: string, url: string): () => void;
+/** At Send: retain file bytes for previews and downloads. HEIC hands over its JPEG, or nothing. */
+export declare function adoptSentAttachmentPreviews(files: readonly AttachedFile[]): void;
+/**
+ * A refused send: its files are back in the composer tray, which draws their object URLs again.
+ * The cache lets go of them without revoking. A HEIC send's JPEG is revoked unless a tile still
+ * holds it: a tile that unmounted at Send converts again when it remounts.
+ */
+export declare function disownSentAttachmentPreviews(files: readonly AttachedFile[]): void;
+/** The composer revokes its object URLs through this. A URL a Send took stays alive. */
+export declare function revokeUnsentPreview(url: string): void;
+/** The delivered source decoded on screen, so the composer's picture is no longer needed. */
+export declare function releaseSentAttachmentPreview(id: string): void;
+/**
+ * A mounted session holds the cache. When the last holder unmounts, every preview is revoked.
+ * The check waits one microtask, so a StrictMode unmount-and-remount keeps the previews.
+ */
+export declare function retainSentAttachmentPreviews(): () => void;
+/**
+ * The list a turn's strip draws until each delivered part renders (`mergeSentAttachments`), so
+ * the strip never shrinks while the echo streams.
+ *
+ * Order: the list this tab's send remembered under the id its bubble was painted with (`originId`
+ * when the server re-minted the echo); then, for the first turn only, the first-prompt handover,
+ * and after it stops, the first prompt's remembered identities (`firstTurnSent`); then the names
+ * on the turn's queued inbox row, for a turn this tab did not send (a reload or another tab).
+ */
+export declare function sentAttachmentsForTurn(input: {
+    sentByMessage: Readonly<Record<string, ReadonlyArray<SentAttachment>>>;
+    messageId: string;
+    originId?: string;
+    isFirstTurn: boolean;
+    firstTurnHandover?: ReadonlyArray<SentAttachment>;
+    firstTurnSent?: ReadonlyArray<SentAttachment>;
+    queuedRowAttachments?: ReadonlyArray<SentAttachment>;
+}): ReadonlyArray<SentAttachment> | undefined;