@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/message-list.d.ts

@@ -3,95 +3,21 @@ import type { ApprovalCardModel } from "../core/approval-inbox.js";
 import type { MarkerBoundaries } from "../core/transcript-rows.js";
 import type { MessageListSource, MessageViewSlot, ToolRowSlot, TranscriptMarkerProps } from "./message-list-slots.js";
 export type { MessageListSource, MessageViewSlot, ToolRowSlot, ToolRowSlotProps, TranscriptMarkerProps, TranscriptSlotRow, } from "./message-list-slots.js";
-/** MessageList's contract beyond the row source: the host's
- *  declarations. Each member's doc is its contract. */
 interface MessageListOptions {
     cards: readonly ApprovalCardModel[];
-    /** True when the host renders the actionable decision surfaces through the
-     *  activity shelf's suspension slot: pending cards then do NOT mount inline,
-     *  and a settled decision renders no transcript prose (no meta-receipt rows)
-     *  — only an answered ask keeps its Q→A receipt. Shelf-less hosts (bench,
-     *  probes, child previews) keep inline mounting. */
     decisionSurfacesInShelf?: boolean;
-    /** The silence-gap dot. The Transcript composition does NOT pass it
-     *  (chrome makes no run-state claims); the child transcript preview
-     *  still does. Exactly one trailing liveness element renders
-     *  (_trailingLivenessClaimantOf); a host that passes typing elects the
-     *  dot for its silence gap, never the standalone headline. */
     typing?: boolean;
-    /** The identity token this transcript's assistant prose wears (law
-     *  10). The SURFACE supplies it, never a constant baked into the row:
-     *  this component also renders subagent drill-in/preview transcripts
-     *  (child-transcript.tsx), where the prose is the COWORKER's and must
-     *  wear its subagent token, not the primary agent's. Defaults to the
-     *  primary token for the main transcript. */
     identityToken?: string;
-    /** True while the run is the machine's time — queued or working, or a
-     *  non-terminal pause with no live decision surface (run-status.ts's
-     *  runReadsAsWorking) — OR a send POST still in flight (pendingSend).
-     *  Read by the trailing fold's headline (so back-to-back calls never
-     *  blink to "Worked"), the standalone "Working…" headline, and the jump
-     *  affordance's activity treatment. */
     live?: boolean;
-    /** True while the newest turn is still open — non-terminal, i.e.
-     *  queued/working AND the HITL pauses. The open tail turn keeps live
-     *  per-cluster folding; settled turns unify into completed episode
-     *  folds. Keys on the turn's OWN terminality, never on
-     *  stream/tail/lease liveness: a host can be mid-turn without a live
-     *  stream, and unifying there presents an intermediate paragraph as
-     *  the final response only to pop it apart on reconnect. The `live`
-     *  default covers only hosts whose rows never outlive their liveness
-     *  fact; the call-site audit is the episode-fold audit record. */
     turnOpen?: boolean;
-    /** The host's marker composite, blocks mode only: invoked before and
-     *  after every block, inside the slot boundary. */
     markers?: ComponentType<TranscriptMarkerProps>;
-    /** Where the host's markers render — a visible marker splits folds and
-     *  delegation groups exactly as a visible row would (blocks mode). */
     markerBoundaries?: MarkerBoundaries;
-    /** Message ids that begin a turn without a user message (the
-     *  machine-initiated delivery turns), blocks mode only: agent-mode
-     *  hosts ride the delivery anchors in empty — no delivery row is ever
-     *  projected — so the fold pass needs the turn starts declared, or the
-     *  open tail window falls back to the previous member turn and
-     *  re-clusters its settled episode. */
     turnStartIds?: ReadonlySet<string>;
-    /** THE LIVENESS-OWNERSHIP RULE: the host declares whether its own frame
-     *  already states the run's liveness for the whole live window (the run
-     *  viewer's live line does). Declared, the package's standalone trailing
-     *  claimants — the Working… headline and the silence dot — yield in
-     *  EVERY state; content liveness (fold headlines, streaming shimmer) is
-     *  unaffected, being the rows' own words. Undeclared, the package owns
-     *  the claim. One rule, one bypass, both states. */
     frameClaimsLiveness?: boolean;
-    /** Rendered in place of the row list when the host says the log is
-     *  genuinely empty — the HOST owns the gate (AssistantTranscript's
-     *  agent mode withholds it until the first snapshot, so a settled
-     *  run's "recorded no activity" fact never flashes during the connect
-     *  window). */
     emptyFallback?: ReactNode;
-    /** Styles the library's scroll element. A height-capped host puts its
-     *  max-h HERE: the scroll element's inline height:100% cannot resolve
-     *  through an indefinite flex chain, so a cap on any wrapper clips
-     *  instead of scrolling. */
     scrollClassName?: string;
-    /** The host row fill — content only: the package keeps each row's
-     *  wrapper (spacing, identity stamp, pending-echo a11y) and the
-     *  provenance footer outside the slot boundary. */
     messageView?: MessageViewSlot;
-    /** The host tool-row fill — replaces exactly the package ToolRow; the
-     *  settled-ask receipt collapse, the anchored decision surfaces, and
-     *  the frame's status word stay package-owned outside it. */
     toolRow?: ToolRowSlot;
-    /** The placement holds' master switch: false releases every
-     *  view/decision hold to native <details>. The default (true) is right
-     *  wherever history carries turn boundaries, because the last
-     *  user/subagent-delivery row bounds the hold window. A CHILD
-     *  transcript is one turn by construction, so ChildTranscript passes
-     *  its dispatch's own running fact instead — a live coworker's calls
-     *  hold open like a live parent turn; a settled drill-in reads as the
-     *  inspection surface it is. */
     placementHolds?: boolean;
 }
 export declare function MessageList({ cards, typing, live, turnOpen, identityToken, decisionSurfacesInShelf, markers: Markers, markerBoundaries, turnStartIds, frameClaimsLiveness, emptyFallback, scrollClassName, messageView, toolRow, placementHolds, ...source }: MessageListSource & MessageListOptions): import("react").JSX.Element;
-//# sourceMappingURL=message-list.d.ts.map

package/dist/components/message-list.js

@@ -24,24 +24,13 @@ export function MessageList({ cards, typing = false, live = false, turnOpen, ide
         emptyFallback,
     });
     const rowAt = (row, flatIndex) => (_jsx(Row, { row: row, cards: cards, turnLive: live && flatIndex === liveIndex, inCurrentTurn: placementHolds && flatIndex >= currentTurnStart, identityToken: identityToken, decisionSurfacesInShelf: decisionSurfacesInShelf, messageView: messageView, toolRow: toolRow }, row.key));
-    return (
-    // No overflow class here: the scroll element is the div
-    // StickToBottom.Content renders around the rows; scrolling this
-    // wrapper too would stack a second scroll container over the same region.
-    _jsxs(StickToBottom, { "data-tf-message-list": "", className: "tf:relative tf:min-h-0 tf:flex-1", resize: "instant", initial: "instant", role: "log", children: [_jsxs(StickToBottom.Content, { scrollClassName: scrollClassName, className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:flex-col tf:px-4 tf:py-4", children: [hostEmptySurfaceShown ? emptyFallback : null, foldedBlocks !== null ? (_jsx(MarkedBlocks, { blocks: foldedBlocks, blockStarts: blockStarts, markers: Markers, rowAt: rowAt })) : (displayRows.map((row, index) => rowAt(row, index))), _jsx(TranscriptTail, { unrowedAnsweredAsks: unrowedAnsweredAsks, livenessClaimant: livenessClaimant })] }), _jsx(ScrollFollowGuards, {}), _jsx(ScrollToBottom, { live: live })] }));
+    return (_jsxs(StickToBottom, { "data-tf-message-list": "", className: "tf:relative tf:min-h-0 tf:flex-1", resize: "instant", initial: "instant", role: "log", children: [_jsxs(StickToBottom.Content, { scrollClassName: scrollClassName, className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:flex-col tf:px-4 tf:py-4", children: [hostEmptySurfaceShown ? emptyFallback : null, foldedBlocks !== null ? (_jsx(MarkedBlocks, { blocks: foldedBlocks, blockStarts: blockStarts, markers: Markers, rowAt: rowAt })) : (displayRows.map((row, index) => rowAt(row, index))), _jsx(TranscriptTail, { unrowedAnsweredAsks: unrowedAnsweredAsks, livenessClaimant: livenessClaimant })] }), _jsx(ScrollFollowGuards, {}), _jsx(ScrollToBottom, { live: live })] }));
 }
-/** Blocks mode's rows: each block's rows at their flat display offsets,
- *  bracketed by the host's marker composite inside the slot boundary. */
 function MarkedBlocks({ blocks, blockStarts, markers: Markers, rowAt, }) {
     return blocks.map((block, blockIndex) => (_jsxs(Fragment, { children: [Markers !== undefined ? (_jsx(HostSlotBoundary, { slot: "markers", fallback: null, children: _jsx(Markers, { message: { id: block.messageId }, position: "before" }) })) : null, block.rows.map((row, index) => rowAt(row, blockStarts[blockIndex] + index)), Markers !== undefined ? (_jsx(HostSlotBoundary, { slot: "markers", fallback: null, children: _jsx(Markers, { message: { id: block.messageId }, position: "after" }) })) : null] }, block.messageId)));
 }
-/** The transcript tail after the rows: the unrowed answered asks'
- *  receipts, the elected standalone liveness claimant, and the activity
- *  tail sentinel. */
 function TranscriptTail({ unrowedAnsweredAsks, livenessClaimant, }) {
     return (_jsxs(_Fragment, { children: [unrowedAnsweredAsks.map((card) => {
-                // The set's own receipt — or nothing for a dismissal: a decision with
-                // no answers and no transcript prose (no meta-receipt row).
                 const receipt = settledQuestionsReceiptOfCard(card.questions, card.answered);
                 return receipt === null ? null : (_jsx(QuestionSetReceiptRow, { receipt: receipt }, card.interruptId));
             }), livenessClaimant === "standalone-headline" ? (_jsx("div", { "data-tf-working-headline": "", className: "tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground", children: _jsx(ShimmerText, { children: "Working\u2026" }) })) : null, livenessClaimant === "typing-dot" ? (_jsx("div", { className: "tf:py-2", children: _jsx(TypingIndicator, {}) })) : null, _jsx("div", { "data-tf-activity-tail": "", "aria-hidden": true, className: "tf:shrink-0" })] }));
@@ -49,14 +38,6 @@ function TranscriptTail({ unrowedAnsweredAsks, livenessClaimant, }) {
 function ScrollToBottom({ live = false }) {
     const { isAtBottom, scrollToBottom } = useStickToBottomContext();
     const buttonRef = useRef(null);
-    // The yield-time focus rescue: the moment this affordance renders, the
-    // compact-activity overlay goes visibility:hidden (the styles.css
-    // yield rule), and a focused pill trigger inside it would be BLURRED
-    // to <body> by the browser's next rendering update. A layout effect
-    // runs after this button reaches the DOM but before that update, so
-    // the trigger still holds focus here — hand it to the one control that
-    // replaced the pill. Root-aware: the script-tag build runs in a shadow
-    // root, where document.activeElement is the host.
     useLayoutEffect(() => {
         const button = buttonRef.current;
         if (isAtBottom || button === null) {
@@ -75,11 +56,7 @@ function ScrollToBottom({ live = false }) {
     if (isAtBottom) {
         return null;
     }
-    return (
-    // The jump arrow replaces the activity pill during scrollback.
-    // Neither control takes space from the transcript.
-    _jsx("div", { "data-tf-scroll-away-jump": "", className: "tf:pointer-events-none tf:absolute tf:inset-x-0 tf:bottom-3 tf:flex tf:justify-center", children: _jsxs(TfButton, { ref: buttonRef, variant: "iconFloating", "data-tf-scroll-away-activity": live ? "" : undefined, "aria-label": live ? "New activity below — scroll to bottom" : "Scroll to bottom", className: "tf:pointer-events-auto tf:relative tf:size-9", onClick: () => {
+    return (_jsx("div", { "data-tf-scroll-away-jump": "", className: "tf:pointer-events-none tf:absolute tf:inset-x-0 tf:bottom-3 tf:flex tf:justify-center", children: _jsxs(TfButton, { ref: buttonRef, variant: "iconFloating", "data-tf-scroll-away-activity": live ? "" : undefined, "aria-label": live ? "New activity below — scroll to bottom" : "Scroll to bottom", className: "tf:pointer-events-auto tf:relative tf:size-9", onClick: () => {
                 void scrollToBottom();
             }, children: [_jsx(ArrowDownIcon, { "aria-hidden": true, className: "tf:size-4" }), live ? (_jsx("span", { "aria-hidden": true, "data-tf-working-dot": "", className: "tf:absolute tf:-end-0.5 tf:-top-0.5 tf:size-2 tf:animate-tf-pulse tf:rounded-full tf:border tf:border-tf-background tf:bg-tf-muted-foreground tf:motion-reduce:animate-none" })) : null] }) }));
 }
-//# sourceMappingURL=message-list.js.map

package/dist/components/model-picker-chip.d.ts

@@ -1,6 +1 @@
-/** The shelf row below the composer slab: the picker chip when the wire
- *  serves a menu, else today's provider chip. Tolerates a missing
- *  provider like the composer's paperclip does (welcome-branch tests
- *  render the view bare). */
 export declare function ModelPickerShelf(): import("react").JSX.Element | null;
-//# sourceMappingURL=model-picker-chip.d.ts.map

package/dist/components/model-picker-chip.js

@@ -9,25 +9,6 @@ import { TfButton } from "./primitives/button.js";
 import { ProviderChip, ProviderChipShelf } from "./provider-chip.js";
 import { useAssistantSession, useOptionalAssistantSession, } from "./teaflask-assistant-provider.js";
 import { useCell } from "./use-store-cell.js";
-// The model picker: the composer shelf hosts TWO independent controls —
-// this chip for the model & reasoning choice, and the provider chip
-// (reused whole) for the ChatGPT account & funding standing. Selecting
-// a model never opens or alters the account menu; connecting or
-// disconnecting never touches the pick. Without a served menu the shelf
-// renders the provider chip alone.
-//
-// The chip names the model and effort that will answer (the thread's
-// pick, else the served defaults); its menu opens UPWARD over the
-// transcript — the same anchoring, glass, light-dismiss, and Esc
-// discipline as the provider chip's. The compact root has exactly two
-// drill-ins: Model and Effort. Selection rides aria-pressed and a
-// visible check (the mode menu's register, never menuitemradio), and
-// display names come off the wire: the package carries no model catalog
-// of its own.
-/** The shelf row below the composer slab: the picker chip when the wire
- *  serves a menu, else today's provider chip. Tolerates a missing
- *  provider like the composer's paperclip does (welcome-branch tests
- *  render the view bare). */
 export function ModelPickerShelf() {
     const session = useOptionalAssistantSession();
     if (session === null) {
@@ -37,65 +18,25 @@ export function ModelPickerShelf() {
 }
 function MountedModelPickerShelf() {
     const session = useAssistantSession();
-    // ONE open menu, held as ONE value: the row's mutual exclusion is
-    // structural — a single variable cannot name two menus — not an
-    // emergent effect of light dismiss, which only fires on pointerdown
-    // and would miss a keyboard open or a programmatic connect ask.
     const [openChip, setOpenChip] = useState(null);
-    // The menu rides the config fetch the hosting Composer already kicks
-    // for its paperclip — no kick of its own here.
     const answered = useCell(session.configAnswered);
     const menu = useCell(session.modelChoice);
-    // The standing read is kicked ABOVE the settle gate, so it flies in
-    // parallel with the config read — gating it below would serialize
-    // the two round trips and paint the connect chip an RTT late on
-    // every cold session. Single-flight, so the chips' own kicks below
-    // become no-ops.
     const identified = session.tier === "identified";
     useEffect(() => {
         if (identified) {
             session.ensureSubscriptions();
         }
     }, [identified, session]);
-    // The account chip's gate, applied here because the shared row mounts
-    // the inner chip directly (the provider shelf's own wrapper would nest
-    // a second row): identified-only — the standing GET 403s an anonymous
-    // bearer, credentials belong to vouched end users — and only when a
-    // provider is offered or once connected.
     const statuses = useCell(session.subscriptions);
     const connectable = identified
         ? (statuses ?? []).filter((status) => status.offered || status.connected)
         : [];
-    // TENANCY, derived once and used everywhere below: this shelf owns a
-    // chip's open state exactly when it will RENDER that chip. Until the
-    // config read settles it owns neither (the slot's identity is
-    // unknown); with no served menu it owns neither (the provider shelf
-    // branch runs its own bookkeeping). Every open/close/acknowledge
-    // predicate routes through these two values — a second spelling of
-    // the same rule is how the open adjustment and the close guard came
-    // to fight each other into a render loop.
     const ownsPickerChip = answered && menu !== null;
     const ownsAccountChip = ownsPickerChip && connectable.length > 0;
-    // The parked connect ask (requestSubscriptionConnect): consumed HERE,
-    // by the state owner, so honoring it structurally closes the picker's
-    // menu — an ask consumed behind another menu would never become
-    // visible. A render-time adjustment of the shelf's OWN state (the
-    // sanctioned shape); the effect only CONSUMES the ask, an external
-    // store write, once the account menu is actually rendered. Gated on
-    // OWNERSHIP, not just a connectable provider: pre-settle, or with no
-    // served menu, this shelf renders no account chip, and consuming the
-    // ask here would silently burn a ring that the provider shelf (or
-    // this shelf, once the read lands) would honor visibly. With nothing
-    // to connect it stays parked exactly as on an empty shelf.
     const openRequested = useCell(session.connectOpenRequested);
     if (openRequested && ownsAccountChip && openChip !== "account") {
         setOpenChip("account");
     }
-    // A menu cannot outlive its tenancy: a withdrawn offer unmounts the
-    // account chip and a withdrawn menu swaps this whole row for the
-    // provider shelf — in both cases the open state dies with the tenant
-    // rather than popping the menu back open on a later re-offer (the
-    // same render-time-adjustment shape as the ask above).
     if (openChip === "account" && !ownsAccountChip) {
         setOpenChip(null);
     }
@@ -107,36 +48,15 @@ function MountedModelPickerShelf() {
             session.acknowledgeSubscriptionConnect();
         }
     }, [openRequested, ownsAccountChip, openChip, session]);
-    // Until the config read SETTLES, the slot's identity is unknown — a
-    // provider chip mounted for the fetch window would flash, and an ask
-    // consumed in it would be burnt on behalf of whichever shelf is about
-    // to take the slot (the ownership gate above keeps the ask parked
-    // through this window). Once settled, a null menu means "no picker"
-    // whether the toggle is off or the read failed, and the provider chip
-    // falls back honestly (it renders off the separate subscriptions
-    // read).
     if (!answered) {
         return null;
     }
     if (menu === null) {
         return _jsx(ProviderChipShelf, {});
     }
-    // One shelf row, two independent controls: the account chip when there
-    // is an account standing to speak for, and the picker as the row's
-    // primary tenant, rightmost. Both menus anchor to this row's right
-    // edge and open upward. At most one is ever open BY CONSTRUCTION —
-    // both chips are controlled by the single openChip above, so a
-    // pointer, keyboard, or programmatic open of one is the close of the
-    // other; light dismiss still handles clicks that land nowhere.
     return (_jsxs("div", { className: "tf:relative tf:mt-1.5 tf:flex tf:items-center tf:justify-end tf:gap-2 tf:px-1", children: [ownsAccountChip ? (_jsx(ProviderChip, { statuses: connectable, open: openChip === "account", onOpenChange: (next) => {
                     setOpenChip(next ? "account" : null);
-                }, 
-                // The one sentence relating the pick to the plan: the account
-                // menu answers "who pays?", and the picker beside it changes
-                // the question. Funding stays per provider — a connected plan
-                // serves its own models, everything else runs on the
-                // workspace's own funding.
-                fundingNote: "Models your plan serves run on it; other picks run on this site's own funding." })) : null, _jsx(ModelPickerChip, { menu: menu, open: openChip === "picker", onOpenChange: (next) => {
+                }, fundingNote: "Models your plan serves run on it; other picks run on this site's own funding." })) : null, _jsx(ModelPickerChip, { menu: menu, open: openChip === "picker", onOpenChange: (next) => {
                     setOpenChip(next ? "picker" : null);
                 } })] }));
 }
@@ -144,14 +64,7 @@ function ModelPickerChip({ menu, open, onOpenChange, }) {
     const { modelPick, setModelPick } = useConversation();
     const { panel, setPanel, showPanel, triggerRef, menuRef, rootPanelRef, modelPanelRef, effortPanelRef, } = useModelPickerPanels({ open, onOpenChange });
     const { currentModelId, renderedLadder, currentEffort, currentName } = pickerSelectionOf(menu, modelPick);
-    return (_jsxs(_Fragment, { children: [_jsx(ModelPickerTrigger, { triggerRef: triggerRef, open: open, onOpenChange: onOpenChange, setPanel: setPanel, currentName: currentName, currentEffort: currentEffort }), open ? (
-            // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions -- the keydown is the menu's own Esc-to-close; every focusable inside is a real button.
-            _jsxs("div", { ref: menuRef, id: "tf-model-picker-menu", role: "dialog", "aria-label": "Choose model and effort", "data-tf-glass": "", 
-                // The root is deliberately compact: model and effort are two
-                // drill-in choices, not one wide catalogue/settings table.
-                // Each submenu uses the same measured surface, so opening one
-                // changes the content rather than making the menu jump.
-                className: "tf:absolute tf:right-0 tf:bottom-full tf:mb-2 tf:flex tf:max-h-[min(32rem,calc(100vh-6rem))] tf:w-80 tf:max-w-full tf:flex-col tf:overflow-y-auto tf:rounded-2xl tf:border tf:p-2", onKeyDown: (event) => {
+    return (_jsxs(_Fragment, { children: [_jsx(ModelPickerTrigger, { triggerRef: triggerRef, open: open, onOpenChange: onOpenChange, setPanel: setPanel, currentName: currentName, currentEffort: currentEffort }), open ? (_jsxs("div", { ref: menuRef, id: "tf-model-picker-menu", role: "dialog", "aria-label": "Choose model and effort", "data-tf-glass": "", className: "tf:absolute tf:right-0 tf:bottom-full tf:mb-2 tf:flex tf:max-h-[min(32rem,calc(100vh-6rem))] tf:w-80 tf:max-w-full tf:flex-col tf:overflow-y-auto tf:rounded-2xl tf:border tf:p-2", onKeyDown: (event) => {
                     if (event.key !== "Escape") {
                         return;
                     }
@@ -162,26 +75,15 @@ function ModelPickerChip({ menu, open, onOpenChange, }) {
                     triggerRef.current?.focus();
                 }, children: [_jsx(ModelPickerRootPanel, { panelRef: rootPanelRef, panel: panel, currentName: currentName, currentEffort: currentEffort, showPanel: showPanel }), _jsx(ModelPickerServedModelsPanel, { panelRef: modelPanelRef, panel: panel, menu: menu, currentModelId: currentModelId, modelPick: modelPick, setModelPick: setModelPick, showPanel: showPanel }), _jsx(ModelPickerEffortPanel, { panelRef: effortPanelRef, panel: panel, ladder: renderedLadder, currentEffort: currentEffort, modelPick: modelPick, setModelPick: setModelPick, showPanel: showPanel })] })) : null] }));
 }
-// The menu's panel state and its two focus disciplines: a drill-in or
-// back moves focus onto the revealed panel, and a press outside the menu
-// closes it.
 function useModelPickerPanels({ open, onOpenChange, }) {
     const triggerRef = useRef(null);
     const menuRef = useRef(null);
     const [panel, setPanel] = useState("root");
-    // Drill-in, back, and selection all hide the container holding the
-    // just-clicked button, which would drop keyboard focus to <body> —
-    // Esc then stops closing the menu (its handler lives on the menu div)
-    // and Tab restarts from the document top. Focus follows the navigation
-    // onto the revealed panel instead; the close paths keep their own
-    // focus story (the trigger).
     const rootPanelRef = useRef(null);
     const modelPanelRef = useRef(null);
     const effortPanelRef = useRef(null);
     const panelAwaitingFocus = useRef(null);
     const showPanel = (next) => {
-        // A same-value call re-renders nothing (React bails out), so a
-        // pending mark here would fire on some later unrelated render.
         if (next === panel) {
             return;
         }
@@ -204,13 +106,6 @@ function useModelPickerPanels({ open, onOpenChange, }) {
                 : effortPanelRef;
         panelRef.current?.focus();
     });
-    // No connect concerns here: the shelf owns the open state and the
-    // parked connect ask, and the account chip beside this one owns
-    // the standing and the sign-in flow — this menu is models and
-    // effort only.
-    // Light dismissal by composedPath() — the script-tag distribution runs
-    // in an open shadow root, where contains() would misjudge every
-    // in-shadow press (the provider chip's rationale, verbatim).
     useEffect(() => {
         const menuElement = menuRef.current;
         if (!open || menuElement === null) {
@@ -244,48 +139,17 @@ function useModelPickerPanels({ open, onOpenChange, }) {
         effortPanelRef,
     };
 }
-// What the chip and its panels display for a menu and a pick: the
-// answering model, its own effort ladder, and the display effort
-// clamped into that ladder.
 function pickerSelectionOf(menu, modelPick) {
-    // A null pin (or no pick) shows — and checks — the served default:
-    // the configured model answers there.
     const currentModelId = modelPick?.modelId ?? menu.default_model_id;
-    // The rendered ladder is the SELECTED model's own supported set
-    // (the per-option efforts, consumed here — menu ⊆ pickable per
-    // model). The root intersection survives only as the fallback for a
-    // stored pin naming a model the wire no longer offers.
     const selectedOption = menu.models.find((option) => option.id === currentModelId);
     const renderedLadder = selectedOption?.efforts ?? menu.efforts;
-    // The DISPLAY selection, clamped into the rendered ladder. The
-    // preselected default is configured_effort — the config's effort
-    // VERBATIM (the root-clamped default_effort survives as the
-    // one-ladder fallback for a wire that predates it) — so a config
-    // tuned above the root intersection preselects honestly on its own
-    // model. The clamp still bites where the SELECTED model genuinely
-    // cannot express the value (a stored pin meeting a narrower model's
-    // set): display only — the stored pin is untouched, the
-    // already-current guard in the effort panel keeps the clamped value
-    // from being written back as a pin, and the runtime clamps the real
-    // pair per answering model.
     const configuredEffort = menu.configured_effort ?? menu.default_effort ?? null;
-    // The fallback default is default_effort FIRST: root-clamped, so a
-    // member of every option's ladder — the one value guaranteed to
-    // render when the selection is outside this bundle's vocabulary
-    // entirely (configuredEffort may BE that unknown value).
     const currentEffort = displayEffortOf(renderedLadder, modelPick?.effort ?? configuredEffort, menu.default_effort ?? configuredEffort);
     const currentName = selectedOption?.display_name ?? currentModelId;
     return { currentModelId, renderedLadder, currentEffort, currentName };
 }
-// The chip itself: the trigger naming the answering model and effort,
-// which opens and closes the menu.
 function ModelPickerTrigger({ triggerRef, open, onOpenChange, setPanel, currentName, currentEffort, }) {
-    return (_jsxs(TfButton, { ref: triggerRef, variant: "chipQuiet", 
-        // The shelf row's designated shrinker: beside the account chip's
-        // never-wrapping label, this chip gives up width first — the
-        // model name truncates (one tap from its full spelling in the
-        // menu) instead of either chip wrapping to two lines.
-        className: "tf:min-w-0", "aria-expanded": open, "aria-controls": "tf-model-picker-menu", "aria-label": currentEffort === null
+    return (_jsxs(TfButton, { ref: triggerRef, variant: "chipQuiet", className: "tf:min-w-0", "aria-expanded": open, "aria-controls": "tf-model-picker-menu", "aria-label": currentEffort === null
             ? `Model: ${currentName}`
             : `Model: ${currentName}, effort: ${effortLabelOf(currentEffort)}`, onClick: () => {
             if (!open) {
@@ -293,8 +157,6 @@ function ModelPickerTrigger({ triggerRef, open, onOpenChange, setPanel, currentN
             }
             onOpenChange(!open);
         }, onKeyDown: (event) => {
-            // Escape with focus on the trigger closes the menu, not the
-            // hosting surface — stopped so a drawer's own Esc never sees it.
             if (!open || event.key !== "Escape") {
                 return;
             }
@@ -304,4 +166,3 @@ function ModelPickerTrigger({ triggerRef, open, onOpenChange, setPanel, currentN
             onOpenChange(false);
         }, children: [_jsxs("span", { className: "tf:flex tf:max-w-56 tf:min-w-0 tf:items-baseline tf:gap-1.5 tf:truncate", children: [_jsx("span", { className: "tf:truncate", children: currentName }), currentEffort !== null ? (_jsx("span", { className: "tf:shrink-0 tf:text-tf-muted-foreground", children: effortLabelOf(currentEffort) })) : null] }), _jsx(ChevronDownIcon, {})] }));
 }
-//# sourceMappingURL=model-picker-chip.js.map

package/dist/components/model-picker-effort.d.ts

@@ -2,4 +2,3 @@ import type { ServedThinkingEffort } from "../contract/assistant-config.js";
 export declare function nearestEffortIn(ladder: readonly ServedThinkingEffort[], effort: ServedThinkingEffort): ServedThinkingEffort | null;
 export declare function displayEffortOf(ladder: readonly ServedThinkingEffort[], effort: ServedThinkingEffort | null, servedDefault: ServedThinkingEffort | null): ServedThinkingEffort | null;
 export declare function effortLabelOf(effort: ServedThinkingEffort): string;
-//# sourceMappingURL=model-picker-effort.d.ts.map

package/dist/components/model-picker-effort.js

@@ -1,11 +1,4 @@
 import { ThinkingEffort } from "../generated/models/index.js";
-// The nearest ladder member by the generated enum's rank order,
-// equidistant ties DOWN — the platform's one clamp rule (the backend's
-// nearest_effort_in and the operator editor's nearestEffortFor are its
-// siblings; the package boundary keeps this the widget's own copy).
-// Null when the effort is outside the bundle's vocabulary or the ladder
-// holds nothing rankable — ladder members the bundle doesn't know are
-// skipped rather than mis-ranked.
 export function nearestEffortIn(ladder, effort) {
     const ranks = Object.values(ThinkingEffort);
     const requested = ranks.indexOf(effort);
@@ -30,11 +23,6 @@ export function nearestEffortIn(ladder, effort) {
     }
     return best;
 }
-// A selection the rendered ladder can express: the value itself when the
-// ladder holds it, otherwise its nearest member, and the served default —
-// itself expressed on THIS ladder — when the value is outside the
-// bundle's vocabulary entirely. Null is the honest no-selection
-// presentation (the config sends no thinking at all).
 export function displayEffortOf(ladder, effort, servedDefault) {
     if (effort === null || ladder.includes(effort)) {
         return effort;
@@ -48,11 +36,6 @@ export function displayEffortOf(ladder, effort, servedDefault) {
     }
     return nearestEffortIn(ladder, servedDefault);
 }
-// The known ladder's labels, mirroring the dashboard's operator
-// vocabulary for agent config — without this a five-level ladder renders
-// "Xhigh" by accident. The wire's vocabulary may grow, so an unknown
-// value still renders (title-cased) rather than vanishing: render what
-// the wire names.
 const EFFORT_LABELS = {
     low: "Low",
     medium: "Medium",
@@ -63,4 +46,3 @@ const EFFORT_LABELS = {
 export function effortLabelOf(effort) {
     return (EFFORT_LABELS[effort] ?? effort.charAt(0).toUpperCase() + effort.slice(1));
 }
-//# sourceMappingURL=model-picker-effort.js.map

package/dist/components/model-picker-panels.d.ts

@@ -20,4 +20,3 @@ export declare function ModelPickerEffortPanel({ panelRef, panel, ladder, curren
     currentEffort: ServedThinkingEffort | null;
 }): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=model-picker-panels.d.ts.map

package/dist/components/model-picker-panels.js

@@ -3,7 +3,6 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { CheckIcon, ChevronDownIcon } from "./icons.js";
 import { effortLabelOf, nearestEffortIn } from "./model-picker-effort.js";
 import { TfButton } from "./primitives/button.js";
-// The compact root: Model and Effort as the menu's two drill-ins.
 export function ModelPickerRootPanel({ panelRef, panel, currentName, currentEffort, showPanel, }) {
     return (_jsxs("div", { ref: panelRef, tabIndex: -1, hidden: panel !== "root", role: "group", "aria-label": "Model and effort", className: (panel === "root" ? "tf:flex " : "tf:hidden ") +
             "tf:flex-col tf:gap-0.5 tf:outline-none", children: [_jsxs(TfButton, { variant: "row", className: "tf:gap-3", onClick: () => {
@@ -12,21 +11,11 @@ export function ModelPickerRootPanel({ panelRef, panel, currentName, currentEffo
                     showPanel("effort");
                 }, children: [_jsx("span", { className: "tf:flex-1 tf:text-left", children: "Effort" }), _jsx("span", { className: "tf:min-w-0 tf:truncate tf:text-tf-muted-foreground", children: currentEffort === null ? "Default" : effortLabelOf(currentEffort) }), _jsx("span", { className: "tf:-rotate-90 tf:text-tf-muted-foreground", children: _jsx(ChevronDownIcon, {}) })] })] }));
 }
-// The model drill-in: one row per served option, the current one checked.
 export function ModelPickerServedModelsPanel({ panelRef, panel, menu, currentModelId, modelPick, setModelPick, showPanel, }) {
     return (_jsxs("div", { ref: panelRef, tabIndex: -1, hidden: panel !== "model", role: "group", "aria-label": "Model", className: (panel === "model" ? "tf:flex " : "tf:hidden ") +
             "tf:flex-col tf:gap-0.5 tf:outline-none", children: [_jsx(PickerPanelHeading, { label: "Model", onBack: () => {
                     showPanel("root");
                 } }), menu.models.map((option) => (_jsxs(TfButton, { variant: "row", "aria-pressed": option.id === currentModelId, onClick: () => {
-                    // The default row is the way back: it stores NO pin,
-                    // so the thread keeps following operator changes. A
-                    // stored effort re-resolves against the chosen model's
-                    // OWN set (nearest, ties down — Amendment C): kept
-                    // when supported, rewritten when not, never
-                    // materialized from the display default (a null pin
-                    // stays null — the config answers), and never
-                    // rewritten when it is outside this bundle's
-                    // vocabulary.
                     const stored = modelPick?.effort ?? null;
                     setModelPick({
                         modelId: option.id === menu.default_model_id ? null : option.id,
@@ -37,18 +26,12 @@ export function ModelPickerServedModelsPanel({ panelRef, panel, menu, currentMod
                     showPanel("root");
                 }, children: [_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate", children: option.display_name }), _jsx("span", { "aria-hidden": option.id !== currentModelId, className: "tf:w-4", children: option.id === currentModelId ? _jsx(CheckIcon, {}) : null })] }, option.id)))] }));
 }
-// The effort drill-in: the selected model's own ladder, the displayed
-// (clamped) value checked.
 export function ModelPickerEffortPanel({ panelRef, panel, ladder, currentEffort, modelPick, setModelPick, showPanel, }) {
     return (_jsxs("div", { ref: panelRef, tabIndex: -1, hidden: panel !== "effort", role: "group", "aria-label": "Reasoning effort", className: (panel === "effort" ? "tf:flex " : "tf:hidden ") +
             "tf:flex-col tf:gap-0.5 tf:outline-none", children: [_jsx(PickerPanelHeading, { label: "Effort", onBack: () => {
                     showPanel("root");
                 } }), ladder.map((effort) => (_jsxs(TfButton, { variant: "row", "aria-pressed": effort === currentEffort, onClick: () => {
-                    // Clicking the already-current row writes NOTHING: the
-                    // displayed value may be a clamp of configured truth.
                     if (effort !== currentEffort) {
-                        // Effort-only never pins a model: the pin stays
-                        // whatever it was (null follows the configured model).
                         setModelPick({
                             modelId: modelPick?.modelId ?? null,
                             effort,
@@ -60,4 +43,3 @@ export function ModelPickerEffortPanel({ panelRef, panel, ladder, currentEffort,
 function PickerPanelHeading({ label, onBack, }) {
     return (_jsxs("div", { className: "tf:mb-1 tf:flex tf:items-center tf:gap-1 tf:border-b tf:px-1 tf:pb-1", children: [_jsx(TfButton, { variant: "icon", "aria-label": "Back", onClick: onBack, children: _jsx("span", { className: "tf:rotate-90", children: _jsx(ChevronDownIcon, {}) }) }), _jsx("span", { className: "tf:text-tf-label tf:font-medium", children: label })] }));
 }
-//# sourceMappingURL=model-picker-panels.js.map

package/dist/components/notice-banner.d.ts

@@ -1,21 +1,8 @@
 import type { ReactNode } from "react";
 export declare function NoticeBanner({ children, hook, }: {
     children: ReactNode;
-    /** Optional data-tf hook, stamped on the banner's OWN box. Never wrap
-     *  a banner in a display:contents element to carry a hook:
-     *  a boxless element no-ops `filter`, so the
-     *  roster-defocus blur (styles.css, [data-tf-conversation-body]
-     *  children) left the wrapped banner crisp while its siblings
-     *  receded. */
     hook?: string;
 }): import("react").JSX.Element;
-/** The pending-decision gap's one spelling. Its own module so
- *  `./transcript-ui` can export it without dragging the conversation
- *  chrome into that entry's graph: the widget chrome and the dashboard
- *  playground both render it, and the fixture bench poses it over a
- *  populated transcript — the composition it actually ships in — rather
- *  than re-spelling the copy. */
 export declare function PendingDecisionGapNotice({ onRetry }: {
     onRetry: () => void;
 }): import("react").JSX.Element;
-//# sourceMappingURL=notice-banner.d.ts.map

package/dist/components/notice-banner.js

@@ -4,13 +4,6 @@ import { TfButton } from "./primitives/button.js";
 export function NoticeBanner({ children, hook, }) {
     return (_jsx("div", { role: "alert", className: "tf:border-b", ...(hook ? { [hook]: "" } : {}), children: _jsx("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: children }) }));
 }
-/** The pending-decision gap's one spelling. Its own module so
- *  `./transcript-ui` can export it without dragging the conversation
- *  chrome into that entry's graph: the widget chrome and the dashboard
- *  playground both render it, and the fixture bench poses it over a
- *  populated transcript — the composition it actually ships in — rather
- *  than re-spelling the copy. */
 export function PendingDecisionGapNotice({ onRetry }) {
     return (_jsxs(NoticeBanner, { hook: "data-tf-pending-decision-gap", children: ["The assistant is waiting on a request that couldn't be shown.", _jsx(TfButton, { variant: "ghost", onClick: onRetry, children: "Retry" })] }));
 }
-//# sourceMappingURL=notice-banner.js.map

package/dist/components/operation-icons.d.ts

@@ -1,38 +1,19 @@
 import type { ReactNode } from "react";
 import type { ToolCallState } from "../core/tool-call-display.js";
 import type { ToolCallIcon } from "../core/tool-call-presentation.js";
-/** The mark's package-owned chrome — identity, state attribute, ink
- *  rules and the assistive state word — around any glyph. Shared by the
- *  package mark below and the tool-view icon slot, so a registered icon
- *  can replace the GLYPH and nothing else (tool-views.md: one
- *  registration, two roles; the mark's state semantics are never the
- *  adapter's to lose). */
 export declare function OperationMarkFrame({ status, children, }: {
     status: ToolCallState;
     children: ReactNode;
 }): import("react").JSX.Element;
-/** The process row's leading mark: semantic identity with local state.
- *  Rendered as the row summary's FIRST child — that position is contract
- *  (TVC-050 measures the icon column on it). */
 export declare function OperationMark({ icon, status, }: {
     icon: ToolCallIcon;
     status: ToolCallState;
 }): import("react").JSX.Element;
-/** The bare semantic glyph, for consent frames: the decision card's title
- *  carries the words and the frame carries the state, so the glyph arrives
- *  silent — no state word, no ink rule, aria-hidden. Same
- *  one-glyph-per-member table as the operation mark, never a fork. */
 export declare function OperationGlyph({ icon, className, }: {
     icon: ToolCallIcon;
     className?: string;
 }): import("react").JSX.Element;
-/** The inline state pill (Layer A's state badge): a small textual badge
- *  on the affected row for the states that must never read as quiet —
- *  failure, interruption, awaiting input. Mechanical state words only
- *  (the headline ladder owns authored copy); text is the signal, colour
- *  merely underlines it. */
 export declare function StatePill({ children, destructive, }: {
     children: string;
     destructive?: boolean;
 }): import("react").JSX.Element;
-//# sourceMappingURL=operation-icons.d.ts.map