@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/provider-chip.js

@@ -4,27 +4,9 @@ import { useEffect, useRef, useState } from "react";
 import { ChevronDownIcon, OpenAiMarkIcon } from "./icons.js";
 import { TfButton } from "./primitives/button.js";
 import { ProviderConnectSection, providerNameOf, } from "./subscription-connect-flow.js";
+import { useRefreshStandingAndGate } from "./subscription-recheck.js";
 import { useAssistantSession, useOptionalAssistantSession, } from "./teaflask-assistant-provider.js";
 import { useCell } from "./use-store-cell.js";
-// The provider chip: the composer shelf's account & funding control —
-// who serves and funds the conversation. Unconnected it reads "Sign in
-// with ChatGPT" (the acquisition affordance the old header plug hid);
-// connected it is the standing's home ("ChatGPT · Plus") and its menu
-// carries reconnect and disconnect. The menu opens UPWARD over the
-// transcript — the chip lives at the surface's floor.
-//
-// It stands alone on the shelf when the wire serves no model menu, and
-// beside the model picker as an independent sibling when one is served:
-// connecting or disconnecting never touches the pick, and picking never
-// opens this menu. Rendered only for identified visitors on agents that
-// offer (or once offered — a stored credential must stay reachable) a
-// provider: the same gate the drawer's plug used, now on every surface
-// because the composer is shared.
-/** The shelf row below the composer slab when no model menu is served.
- *  Renders nothing when there is nothing to connect — the composer
- *  composite then keeps today's geometry. Tolerates a missing provider
- *  like the composer's paperclip does (welcome-branch tests render the
- *  view bare). */
 export function ProviderChipShelf() {
     const session = useOptionalAssistantSession();
     if (session === null) {
@@ -35,13 +17,7 @@ export function ProviderChipShelf() {
 function MountedProviderChipShelf() {
     const session = useAssistantSession();
     const statuses = useCell(session.subscriptions);
-    // The chip's open state lives on the shelf, not in the chip: the chip
-    // is controlled, so whichever shelf hosts it owns the one-menu
-    // bookkeeping and the parked connect ask below.
     const [open, setOpen] = useState(false);
-    // The standing read is identified-only (the GET 403s an anonymous
-    // bearer): kick it exactly when the tier admits it. tier arrives
-    // already resolved on the context value (the provider subscribes).
     const identified = session.tier === "identified";
     useEffect(() => {
         if (identified) {
@@ -50,24 +26,10 @@ function MountedProviderChipShelf() {
     }, [identified, session]);
     const connectable = (statuses ?? []).filter((status) => status.offered || status.connected);
     const chipShown = identified && connectable.length > 0;
-    // The parked ask (requestSubscriptionConnect — the bench's ring, and
-    // any host that wants to spotlight the chip): consume it by opening
-    // the menu. Living on the shelf means a ring while this surface was
-    // unmounted is honored on the next mount, never dropped. The open
-    // flips as a render-time adjustment of the shelf's OWN state (the
-    // sanctioned shape — never setState in an effect); the effect only
-    // CONSUMES the ask, an external store write, once the menu is
-    // actually rendered. Gated on the chip standing: with nothing to
-    // connect the ask stays parked for a surface that can honor it.
     const openRequested = useCell(session.connectOpenRequested);
     if (openRequested && chipShown && !open) {
         setOpen(true);
     }
-    // A menu cannot outlive its chip: when the offer is withdrawn the
-    // chip unmounts, and a LATER re-offer must render closed — the open
-    // died with the withdrawal, it does not pop back (the state used to
-    // live in the chip and reset by unmounting; the shelf resets it
-    // explicitly, same render-time-adjustment shape).
     if (!chipShown && open) {
         setOpen(false);
     }
@@ -81,21 +43,9 @@ function MountedProviderChipShelf() {
     }
     return (_jsx("div", { className: "tf:relative tf:mt-1.5 tf:flex tf:items-center tf:justify-end tf:px-1", children: _jsx(ProviderChip, { statuses: connectable, open: open, onOpenChange: setOpen }) }));
 }
-/** The account chip itself, shelf-row-agnostic and CONTROLLED: the
- *  no-menu shelf above mounts it in its own row, the model picker's
- *  shelf mounts it beside the picker chip in a shared one. The
- *  hosting shelf owns the open state — that is what makes the shared
- *  row's one-menu-at-most invariant structural — and consumes the
- *  parked connect ask; this chip only renders and reports. */
 export function ProviderChip({ statuses, open, onOpenChange, fundingNote, }) {
-    const session = useAssistantSession();
     const triggerRef = useRef(null);
     const menuRef = useRef(null);
-    // Light dismissal, judged by composedPath() — the script-tag
-    // distribution runs in an open shadow root, where document-level
-    // events retarget to the host element and contains() would call every
-    // in-shadow press an outside one. The trigger is excluded so its own
-    // press doesn't close-then-reopen through the click that follows.
     useEffect(() => {
         const menu = menuRef.current;
         if (!open || menu === null) {
@@ -118,23 +68,24 @@ export function ProviderChip({ statuses, open, onOpenChange, fundingNote, }) {
             doc.removeEventListener("pointerdown", closeUnlessInside);
         };
     }, [open, onOpenChange]);
+    const session = useAssistantSession();
+    const identified = session.tier === "identified";
+    useEffect(() => {
+        if (open && identified) {
+            session.refreshSubscriptions();
+        }
+    }, [open, identified, session]);
     const headline = _chipHeadlineOf(statuses);
     return (_jsxs(_Fragment, { children: [_jsxs(TfButton, { ref: triggerRef, variant: headline.connected ? "chipQuiet" : "chip", "aria-expanded": open, "aria-controls": "tf-provider-chip-menu", "aria-label": headline.accessibleName, onClick: () => {
                     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;
                     }
                     event.preventDefault();
                     event.stopPropagation();
                     onOpenChange(false);
-                }, children: [_jsx(OpenAiMarkIcon, {}), _jsx("span", { className: "tf:whitespace-nowrap", children: headline.label }), _jsx(ChevronDownIcon, {})] }), 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-provider-chip-menu", role: "dialog", "aria-label": headline.accessibleName, "data-tf-glass": "", className: "tf:absolute tf:right-0 tf:bottom-full tf:mb-2 tf:flex tf:w-80 tf:max-w-[calc(100vw-2rem)] tf:flex-col tf:gap-3 tf:overflow-y-auto tf:rounded-2xl tf:border tf:p-3", onKeyDown: (event) => {
-                    // Esc closes the menu and hands focus back to its trigger;
-                    // the hosting surface survives.
+                }, children: [_jsx(OpenAiMarkIcon, {}), _jsx("span", { className: "tf:whitespace-nowrap", children: headline.label }), _jsx(ChevronDownIcon, {})] }), open ? (_jsxs("div", { ref: menuRef, id: "tf-provider-chip-menu", role: "dialog", "aria-label": headline.accessibleName, "data-tf-glass": "", "data-tf-popover": "", className: "tf:absolute tf:right-0 tf:bottom-full tf:mb-2 tf:flex tf:w-80 tf:max-w-[calc(100vw-2rem)] tf:flex-col tf:gap-3 tf:overflow-y-auto tf:rounded-2xl tf:border tf:p-3", onKeyDown: (event) => {
                     if (event.key !== "Escape") {
                         return;
                     }
@@ -142,11 +93,15 @@ export function ProviderChip({ statuses, open, onOpenChange, fundingNote, }) {
                     event.stopPropagation();
                     onOpenChange(false);
                     triggerRef.current?.focus();
-                }, children: [fundingNote !== undefined ? (_jsx("p", { className: "tf:text-xs tf:text-tf-muted-foreground", children: fundingNote })) : null, statuses.map((status) => (_jsx(ProviderConnectSection, { status: status, session: session.session, refreshSubscriptions: session.refreshSubscriptions }, status.provider)))] })) : null] }));
+                }, children: [fundingNote !== undefined ? (_jsx("p", { className: "tf:text-xs tf:text-tf-muted-foreground", children: fundingNote })) : null, _jsx(ProviderMenuSections, { statuses: statuses })] })) : null] }));
+}
+function ProviderMenuSections({ statuses, }) {
+    const session = useAssistantSession();
+    const refreshStandingAndGate = useRefreshStandingAndGate();
+    return (_jsx(_Fragment, { children: statuses.map((status) => (_jsx(ProviderConnectSection, { status: status, session: session.session, refreshSubscriptions: session.refreshSubscriptions, refreshStandingAndGate: refreshStandingAndGate, onSignedIn: () => {
+                session.notePlanSignedIn(status.provider);
+            } }, status.provider))) }));
 }
-// The chip speaks for the first credential that exists, else the first
-// offered provider — one provider today, and a second one's standing
-// still reaches the menu below.
 function _chipHeadlineOf(statuses) {
     const holding = statuses.find((status) => status.connected) ?? statuses[0];
     const name = providerNameOf(holding.provider);
@@ -157,6 +112,13 @@ function _chipHeadlineOf(statuses) {
             connected: false,
         };
     }
+    if (!holding.offered) {
+        return {
+            label: `${name} · not in use`,
+            accessibleName: `${name} plan — not in use`,
+            connected: true,
+        };
+    }
     if (holding.state === "verifying") {
         return {
             label: `${name} · verifying…`,
@@ -165,20 +127,16 @@ function _chipHeadlineOf(statuses) {
         };
     }
     if (holding.state === "bounced") {
+        const remedy = holding.bounce_cause === "quota" ? "limit reached" : "reconnect";
         return {
-            label: `${name} · reconnect`,
-            accessibleName: `${name} plan — reconnect`,
+            label: `${name} · ${remedy}`,
+            accessibleName: `${name} plan — ${remedy}`,
             connected: true,
         };
     }
-    const plan = holding.plan_type;
     return {
-        label: plan === null ? `${name} plan` : `${name} · ${_titleCased(plan)}`,
-        accessibleName: `${name} plan`,
+        label: `Using ${name} plan`,
+        accessibleName: `Using ${name} plan`,
         connected: true,
     };
 }
-function _titleCased(plan) {
-    return plan.charAt(0).toUpperCase() + plan.slice(1);
-}
-//# sourceMappingURL=provider-chip.js.map

package/dist/components/question-panel-answers.js

@@ -5,24 +5,17 @@ import { Kbd } from "./primitives/kbd.js";
 import { TfButton } from "./primitives/button.js";
 import { TfTextarea } from "./primitives/textarea.js";
 const CUSTOM_ANSWER_PLACEHOLDER = "Custom answer";
-/** The answer list: the suggested answers as a radiogroup of numbered
- *  rows, the custom row last, and the over-limit sentence under them. */
 export function QuestionPanelAnswers({ question, active, customText, disabled, ids, openDescription, onToggleDescription, overLimitSentence, answersRef, foldBelow, onScroll, rowsRef, customRef, selectOption, activateCustomIfDrafted, setCustomText, optionKeys, customKeys, }) {
     const tabStopIndex = tabStopIndexOf(question, active);
     const customActive = active?.kind === "custom";
     const reserveInfoColumn = reserveInfoColumnOf(question);
     return (_jsxs("div", { ref: answersRef, className: "tf:mt-3 tf:flex tf:flex-col tf:gap-1", "data-tf-question-answers": "", "data-tf-has-options": question.options.length > 0 ? "" : undefined, "data-tf-fold-below": foldBelow ? "" : undefined, onScroll: onScroll, children: [_jsx("div", { ref: rowsRef, role: "radiogroup", "aria-labelledby": ids.prompt, "aria-describedby": ids.hint, className: "tf:flex tf:flex-col tf:gap-0.5", children: question.options.map((option, index) => (_jsx(AnswerOptionRow, { option: option, index: index, checked: active?.kind === "option" && active.text === option.text, tabStop: index === tabStopIndex, disabled: disabled, reserveInfoColumn: reserveInfoColumn, descriptionId: `${ids.descriptionBase}-${String(index)}`, descriptionOpen: openDescription === option.text, onToggleDescription: onToggleDescription, onSelect: selectOption, onKeyDown: optionKeys(index) }, option.text))) }), _jsx(CustomAnswerRow, { optionCount: question.options.length, customText: customText, customActive: customActive, disabled: disabled, ids: ids, reserveInfoColumn: reserveInfoColumn, customRef: customRef, onTextChange: setCustomText, onPointerDown: activateCustomIfDrafted, onKeyDown: customKeys }), overLimitSentence !== null ? (_jsx("p", { className: "tf:px-3 tf:text-tf-label tf:text-tf-destructive", "data-tf-question-over-limit": "", children: overLimitSentence })) : null] }));
 }
-/** The radiogroup's one tab stop: the chosen option's row, else the
- *  first row. */
 function tabStopIndexOf(question, active) {
     return active?.kind === "option"
         ? Math.max(question.options.findIndex((option) => option.text === active.text), 0)
         : 0;
 }
-// Rows stay full width: when any suggestion carries a description the
-// (i) column is reserved on every row, so the active row's key caps
-// never jump as the member arrows through.
 function reserveInfoColumnOf(question) {
     return question.options.some((option) => option.description !== null);
 }
@@ -40,15 +33,10 @@ function CustomAnswerRow({ optionCount, customText, customActive, disabled, ids,
                     onTextChange(event.target.value);
                 }, onPointerDown: onPointerDown, onKeyDown: onKeyDown }), customActive ? (_jsx(KeyHints, { className: "tf:pt-1.5", hints: ["up", "down", "modifier"] })) : null, reserveInfoColumn ? (_jsx("span", { "aria-hidden": true, className: "tf:mt-1 tf:size-7 tf:shrink-0" })) : null] }));
 }
-// Icons, not glyph text: the widget is embedded in arbitrary hosts, and a
-// host font cannot be trusted to carry U+21B5 or the arrows.
 function KeyHints({ hints, className, }) {
     return (_jsx("span", { "aria-hidden": true, "data-tf-key-hints": "", className: "tf:flex tf:shrink-0 tf:items-center tf:gap-1 " + (className ?? ""), children: hints.map((hint) => (_jsx(Kbd, { children: hint === "up" ? (_jsx(ArrowUpIcon, { className: "tf:size-3" })) : hint === "down" ? (_jsx(ArrowDownIcon, { className: "tf:size-3" })) : hint === "enter" ? (_jsx(CornerDownLeftIcon, { className: "tf:size-3" })) : (_jsxs(_Fragment, { children: [_jsx("span", { children: modifierLabel() }), _jsx(CornerDownLeftIcon, { className: "tf:size-3" })] })) }, hint))) }));
 }
-// Detected from the platform, never a clock or locale: the custom row's
-// continue gesture reads ⌘↵ on Apple hardware and Ctrl↵ everywhere else.
 function modifierLabel() {
     const agent = typeof navigator === "undefined" ? "" : navigator.userAgent;
     return /Mac|iPhone|iPad|iPod/.test(agent) ? "⌘" : "Ctrl";
 }
-//# sourceMappingURL=question-panel-answers.js.map

package/dist/components/question-panel-footer.js

@@ -4,30 +4,22 @@ import { Fragment, useContext, useEffect, useRef, useState, } from "react";
 import { ElicitationsContext } from "./elicitation-context.js";
 import { TfButton } from "./primitives/button.js";
 import { Spinner } from "./streaming-states.js";
-/** The footer's three states: sending, the discard confirm, or the
- *  actions (the gate's reason, Cancel, and the one continue). */
 export function QuestionPanelFooter({ card, cursor, gateReason, disabled, submitGated, onProceed, }) {
     const total = card.questions.length;
     const isLast = cursor === total - 1;
     const { confirming, cancelRef, keepEditingRef, requestCancel, keepEditing, discard, } = useCancelConfirm(card);
-    return (_jsx("div", { "data-tf-question-footer": "", className: "tf:mt-3 tf:flex tf:flex-wrap tf:items-center tf:justify-end tf:gap-2", children: card.status === "submitting" ? (_jsx("p", { className: "tf:flex tf:items-center tf:gap-2 tf:text-tf-label tf:text-tf-muted-foreground", children: _jsx(Spinner, { label: "Sending\u2026" }) })) : confirming ? (_jsxs(Fragment, { children: [_jsx("span", { className: "tf:text-tf-label tf:text-tf-muted-foreground", children: "Discard answers?" }), _jsx(TfButton, { ref: keepEditingRef, variant: "ghost", onClick: keepEditing, children: "Keep editing" }), _jsx(TfButton, { variant: "outline", onClick: discard, children: "Discard" })] }, "confirm")) : (_jsxs(Fragment, { children: [gateReason !== null ? (_jsx("span", { "data-tf-question-gate": "", className: "tf:me-auto tf:text-tf-label tf:text-tf-muted-foreground", children: gateReason })) : null, _jsx(TfButton, { ref: cancelRef, variant: "ghost", disabled: disabled, onClick: requestCancel, children: "Cancel" }), _jsx(TfButton, { variant: "primary", disabled: disabled || submitGated, onClick: onProceed, children: isLast
+    return (_jsx("div", { "data-tf-question-footer": "", className: "tf:mt-3 tf:flex tf:flex-wrap tf:items-center tf:justify-end tf:gap-2", children: card.status === "submitting" ? (_jsx("p", { className: "tf:flex tf:items-center tf:gap-2 tf:text-tf-label tf:text-tf-muted-foreground", children: _jsx(Spinner, { label: "Sending\u2026" }) })) : confirming ? (_jsxs(Fragment, { children: [_jsx("span", { className: "tf:text-tf-label tf:text-tf-muted-foreground", children: "Discard answers?" }), _jsx(TfButton, { ref: keepEditingRef, variant: "secondary", onClick: keepEditing, children: "Keep editing" }), _jsx(TfButton, { variant: "outline", onClick: discard, children: "Discard" })] }, "confirm")) : (_jsxs(Fragment, { children: [gateReason !== null ? (_jsx("span", { "data-tf-question-gate": "", className: "tf:me-auto tf:text-tf-label tf:text-tf-muted-foreground", children: gateReason })) : null, _jsx(TfButton, { ref: cancelRef, variant: "secondary", disabled: disabled, onClick: requestCancel, children: "Cancel" }), _jsx(TfButton, { variant: "primary", disabled: disabled || submitGated, onClick: onProceed, children: isLast
                         ? total === 1
                             ? "Submit answer"
                             : "Submit answers"
                         : "Next question" })] }, "actions")) }));
 }
-// The Cancel confirm: entering and leaving it hands focus to the control
-// that replaced the one under the pointer.
 function useCancelConfirm(card) {
     const { drafts, cancelQuestionSet } = useContext(ElicitationsContext);
     const [confirming, setConfirming] = useState(false);
     const cancelRef = useRef(null);
     const keepEditingRef = useRef(null);
     const wasConfirmingRef = useRef(false);
-    // The Cancel confirm swaps the footer's controls out from under the
-    // pointer and the keyboard alike; hand focus to the control that took
-    // the place (Keep editing on the way in, Cancel on the way back) so a
-    // keyboard member never lands on <body>.
     useEffect(() => {
         if (confirming) {
             keepEditingRef.current?.focus();
@@ -57,4 +49,3 @@ function useCancelConfirm(card) {
         },
     };
 }
-//# sourceMappingURL=question-panel-footer.js.map

package/dist/components/question-panel.js

@@ -11,35 +11,6 @@ import { QuestionPanelAnswers, } from "./question-panel-answers.js";
 import { QuestionPanelFooter } from "./question-panel-footer.js";
 import { useAnswerListFold } from "./use-answer-list-fold.js";
 import { useQuestionPanelKeys } from "./use-question-panel-keys.js";
-// The question panel: one pending question SET as one surface in the
-// suspension slot. Heading top-left, the pager (‹ n/N ›) top-right, the
-// question, then the suggested answers as full-width numbered rows with a
-// directly editable "Custom answer" row last, and a footer of Cancel +
-// Next question / Submit answers. Navigation is LOCAL — it moves a cursor
-// in the store's draft, never a byte over the wire — and the one Submit
-// posts the whole set at once. Every draft (choice, custom text, cursor)
-// lives in the store's QuestionDraftStore, so the pager's keyed remount, a
-// reconnect and a workflow restart all return the member to exactly where
-// they were.
-//
-// The active choice is explicit — a suggestion OR the custom row. Picking
-// a suggestion keeps the custom text (the member may return to it);
-// typing in the custom row makes it active, and reaching the custom row
-// by pointer or arrow re-activates it only once it holds an answer (the
-// table beside activateCustomIfDrafted). Nothing is ever judged about
-// the text: Submit is gated only on "every question has an answer" and
-// the transport bound, and the answer posted is the suggestion's visible
-// text or the member's words verbatim. While Submit is gated the footer
-// names the first unanswered question, and a continue from the last
-// question jumps there instead of doing nothing.
-// The settled forms, on the panel itself (the meta-receipt rule: a settled
-// decision's surfaces are the card's own footer and the operation row's
-// state, never transcript prose). Module-private: an expired set keeps
-// its heading with controls gone and one muted sentence; a set the
-// member dismissed, the same shape with the dismissed sentence — stated
-// once, never a failure. Both render only where the panel mounts inline
-// (shelf-less hosts); in the shipping shelf composition a settled set
-// leaves the slot (TVC-064).
 const STALE_NOTE = "These questions were already answered or expired.";
 const CANCELLED_NOTE = "The assistant's questions were dismissed.";
 export function QuestionPanel({ card }) {
@@ -48,10 +19,6 @@ export function QuestionPanel({ card }) {
     }
     return _jsx(PendingQuestionPanel, { card: card });
 }
-/** The settled set where the panel stood: the Q→A receipt (this tab's
- *  own answers, or the plain answered fact per question when another
- *  client answered), or the heading over one muted sentence for a
- *  dismissed or expired set. */
 function SettledQuestionPanel({ card }) {
     if (card.status === "answered") {
         const receipt = settledQuestionsReceiptOfCard(card.questions, card.answered);
@@ -93,13 +60,9 @@ function PendingQuestionPanel({ card }) {
     });
     const { answersRef, foldBelow, declareFold } = useAnswerListFold(cursor, openDescription, customText);
     const gate = submitGateOf(card.questions, draft, cursor, customText);
-    // The one announced fact: the question under the member's hands first
-    // (its own over-limit sentence), else the Submit gate's reason.
     const statusSentence = gate.overLimitSentence ?? gate.gateReason ?? "";
     return (_jsxs("div", { "data-tf-elicitation-card": "", "data-tf-question-panel": "", role: "group", "aria-label": "The assistant asked questions", className: "tf:my-1 tf:rounded-xl tf:border tf:p-4", children: [_jsx(QuestionPanelHeader, { card: card, cursor: cursor, goTo: goTo }), _jsx(QuestionPanelPrompt, { card: card, question: question, ids: ids }), _jsx("span", { role: "status", className: "tf:sr-only", "data-tf-question-status": "", children: statusSentence }), _jsx(QuestionPanelAnswers, { question: question, active: active, customText: customText, disabled: !answerable, ids: ids, openDescription: openDescription, onToggleDescription: setOpenDescription, overLimitSentence: gate.overLimitSentence, answersRef: answersRef, foldBelow: foldBelow, onScroll: declareFold, rowsRef: rowsRef, customRef: customRef, selectOption: selectOption, activateCustomIfDrafted: activateCustomIfDrafted, setCustomText: setCustomText, optionKeys: optionKeys, customKeys: customKeys }), _jsx(QuestionPanelFooter, { card: card, cursor: cursor, gateReason: gate.gateReason, disabled: !answerable, submitGated: gate.submitGated, onProceed: proceed })] }));
 }
-/** Heading top-left, the pager (‹ n/N ›) top-right — the pager only
- *  when the set has more than one question. */
 function QuestionPanelHeader({ card, cursor, goTo, }) {
     const total = card.questions.length;
     return (_jsxs("div", { className: "tf:flex tf:items-center tf:justify-between tf:gap-3", children: [_jsx("p", { className: "tf:min-w-0 tf:truncate tf:text-tf-label tf:text-tf-muted-foreground", "data-tf-question-heading": "", children: card.questions[cursor].heading }), total > 1 ? (_jsxs("div", { className: "tf:flex tf:shrink-0 tf:items-center tf:gap-1", "data-tf-question-pager": "", children: [_jsx(TfButton, { variant: "icon", "aria-label": "Previous question", disabled: cursor === 0, onClick: () => {
@@ -108,14 +71,9 @@ function QuestionPanelHeader({ card, cursor, goTo, }) {
                             goTo(cursor + 1);
                         }, children: _jsx(ChevronRightIcon, { "aria-hidden": true, className: "tf:size-4" }) })] })) : null] }));
 }
-/** The question, the parked note and the error alert when the card
- *  carries them, and the screen-reader-only keyboard hint. */
 function QuestionPanelPrompt({ card, question, ids, }) {
     return (_jsxs(_Fragment, { children: [_jsx("p", { id: ids.prompt, className: "tf:mt-1 tf:text-tf-heading tf:font-medium tf:text-tf-foreground", "data-tf-question-prompt": "", children: question.prompt }), card.errorSentence !== null ? (_jsx("p", { role: "alert", className: "tf:mt-2 tf:text-tf-label tf:text-tf-destructive", children: card.errorSentence })) : null, _jsx("p", { id: ids.hint, className: "tf:sr-only", children: "Use the up and down arrow keys to choose a suggested answer and Enter to continue. In the custom answer, Enter adds a line and Command or Control with Enter continues." })] }));
 }
-// EVERY gate names its reason: an over-bound custom
-// answer — possibly two questions back — outranks an unanswered one,
-// because it is the harder gap to find.
 function submitGateOf(questions, draft, cursor, customText) {
     const answers = answersOf(questions, draft);
     const firstUnanswered = firstUnansweredIndexOf(questions, draft);
@@ -126,9 +84,6 @@ function submitGateOf(questions, draft, cursor, customText) {
     const firstOverLimit = overLimit.length > 0
         ? questions.findIndex((entry) => entry.id === overLimit[0])
         : -1;
-    // Every count the member reads is pinned to en-US digits and grouping
-    // (tool-arguments-summary's rule): the widget embeds in arbitrary
-    // host pages, and a host locale must not reshape "1,900".
     const gateReason = !isLast
         ? null
         : firstOverLimit >= 0
@@ -141,4 +96,3 @@ function submitGateOf(questions, draft, cursor, customText) {
         : null;
     return { submitGated, gateReason, overLimitSentence };
 }
-//# sourceMappingURL=question-panel.js.map

package/dist/components/react-tool-view.d.ts

@@ -1,19 +1,11 @@
 import { type ComponentType } from "react";
 import type { ToolViewAdapter, ToolViewProps } from "../core/tool-view.js";
-/** Wrap a React component as a canonical tool-view adapter. Also the
- *  icon spelling — IconAdapter shares the lifecycle, so the same
- *  wrapper serves `{ version, icon: reactToolView(MyMark) }`. Generic
- *  like the adapter it produces: a component written against generated
- *  per-org argument types (`ToolViewProps<MyArgs>`) wraps without a
- *  cast, and the typed adapter assigns to the registration through
- *  method bivariance (core/tool-view.ts). */
+/**
+ * Wraps a React component as a tool view (or as an icon) for a registration;
+ * the component receives ToolViewProps and keeps its state across updates. It
+ * renders in its own React root, so your app's providers (router, theme, data
+ * clients) don't reach it, and a render error makes the assistant show the next
+ * matching view.
+ */
 export declare function reactToolView<TArgs = Record<string, unknown>, TResult = unknown>(component: ComponentType<ToolViewProps<TArgs, TResult>>): ToolViewAdapter<TArgs, TResult>;
-/** The package-internal late-failure channel between the React sugar
- *  and the mount slot: a passive-effect throw cannot surface as a
- *  synchronous mount/update throw, so the sugar dispatches it on the
- *  mount container — the one object both sides share — and the slot
- *  treats it exactly like a thrown adapter (report, clear, advance).
- *  Not part of the public adapter contract: a vanilla adapter's own
- *  async failures remain the adapter's to handle. */
 export declare const TOOL_VIEW_LATE_FAILURE_EVENT = "teaflask-tool-view-late-failure";
-//# sourceMappingURL=react-tool-view.d.ts.map

package/dist/components/react-tool-view.js

@@ -1,47 +1,17 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-// The React spelling of the tool-view contract: thin sugar over the
-// imperative {mount → {update, destroy}} lifecycle — one contract, two
-// spellings, never two systems (tool-views.md). The component renders
-// into its own react-dom root inside the package-owned container;
-// `update` re-renders the same element type, so React reconciles and
-// component-local state survives a status advance; `destroy` unmounts.
 import { Component } from "react";
 import { flushSync } from "react-dom";
 import { createRoot } from "react-dom/client";
-/** Wrap a React component as a canonical tool-view adapter. Also the
- *  icon spelling — IconAdapter shares the lifecycle, so the same
- *  wrapper serves `{ version, icon: reactToolView(MyMark) }`. Generic
- *  like the adapter it produces: a component written against generated
- *  per-org argument types (`ToolViewProps<MyArgs>`) wraps without a
- *  cast, and the typed adapter assigns to the registration through
- *  method bivariance (core/tool-view.ts). */
 export function reactToolView(component) {
     const View = component;
     return {
         mount(container, props) {
             const root = createRoot(container);
-            // PREMISE — which throw phases the latch can observe inside the
-            // flushSync window, and which it cannot (settled empirically, r3):
-            // render, layout-effect AND passive-effect throws belonging to a
-            // renderInto flush all surface before flushSync returns — React
-            // flushes the forced work's passive effects synchronously — so
-            // renderInto rethrows them all: the adapter contract's one
-            // failure channel. What no mount/update return can ever observe
-            // is a throw from a render the view schedules for ITSELF — its
-            // own setState from a timer, a promise, a subscription —
-            // committed by the nested root with no renderInto in flight.
-            // componentDidCatch then fires with the window closed, and the
-            // failure travels the container's late-failure event instead —
-            // the mount slot listens and advances the ladder, restoring the
-            // replaced React boundary's any-phase fallback-and-report
-            // behaviour across the imperative seam.
             let unmounted = false;
             const unmountLate = () => {
                 if (!unmounted) {
                     unmounted = true;
-                    // Asynchronously: react-dom forbids unmounting while its own
-                    // commit or effect flush is still on the stack.
                     queueMicrotask(() => {
                         root.unmount();
                     });
@@ -57,15 +27,8 @@ export function reactToolView(component) {
                 },
             };
             const renderInto = (next) => {
-                // Read through a local: componentDidCatch mutates the latch from
-                // inside the flushSync call below, which control-flow narrowing
-                // cannot see — narrowing the property itself would mis-read the
-                // post-flush check as always-false.
                 const alreadyFailed = latch.failed;
                 if (alreadyFailed) {
-                    // Already failed and reported (sync throw or late event); the
-                    // slot never reuses a failed instance, so a straggling update
-                    // is a no-op rather than a stale re-throw and double report.
                     return;
                 }
                 latch.inSyncWindow = true;
@@ -95,19 +58,7 @@ export function reactToolView(component) {
         },
     };
 }
-/** The package-internal late-failure channel between the React sugar
- *  and the mount slot: a passive-effect throw cannot surface as a
- *  synchronous mount/update throw, so the sugar dispatches it on the
- *  mount container — the one object both sides share — and the slot
- *  treats it exactly like a thrown adapter (report, clear, advance).
- *  Not part of the public adapter contract: a vanilla adapter's own
- *  async failures remain the adapter's to handle. */
 export const TOOL_VIEW_LATE_FAILURE_EVENT = "teaflask-tool-view-late-failure";
-/** Records a child throw into the mount's latch. Inside the flushSync
- *  window the wrapper above rethrows on the adapter's stack; outside it
- *  (a passive-effect throw) the latch's late channel carries it.
- *  Latching — a component that threw never flickers back in on a later
- *  commit of the same root. */
 class _CatchBoundary extends Component {
     state = { failed: false };
     static getDerivedStateFromError() {
@@ -129,4 +80,3 @@ class _CatchBoundary extends Component {
         return this.props.children;
     }
 }
-//# sourceMappingURL=react-tool-view.js.map

package/dist/components/reasoning-row.js

@@ -1,22 +1,11 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-// The adopted register — assistant-ui `reasoning` as the visual reference:
-// the model's native reasoning as a quiet collapsible line above the
-// answer. While the reasoning streams the line reads "Thinking…" under
-// the moving gradient and the body holds itself open so the thought reads
-// as it arrives; once the answer starts it collapses to a static
-// "Thought about it". No duration on the label: the run events carry no
-// timestamps, and a client-side clock would lie on every replay.
 import { LightbulbIcon } from "lucide-react";
 import { REASONING_SETTLED_LABEL, REASONING_STREAMING_LABEL, } from "../core/reasoning-copy.js";
 import { Disclosure, DisclosureChevron } from "./primitives/disclosure.js";
 import { ShimmerText } from "./streaming-states.js";
-// One form only: every reasoning row lives on an activity rail (the
-// grouping in use-transcript-folds.ts folds all reasoning into a group), so the
-// rail geometry — leading state mark, gap-3, ps-7 body — IS the row.
 export function ReasoningRow({ view }) {
     return (_jsx(Disclosure, { variant: "bare", open: view.streaming || undefined, className: "tf:w-full", summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-3 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground", bodyClassName: "tf:ps-7 tf:pt-1 tf:pb-2", summary: _jsxs(_Fragment, { children: [_jsxs("span", { "data-tf-reasoning-mark": "", className: view.streaming
                         ? "tf:grid tf:size-4 tf:shrink-0 tf:place-items-center tf:opacity-45"
                         : "tf:grid tf:size-4 tf:shrink-0 tf:place-items-center", children: [_jsx(LightbulbIcon, { "aria-hidden": true, className: "tf:size-4" }), _jsx("span", { className: "tf:sr-only", children: view.streaming ? "Thinking" : "Thought" })] }), view.streaming ? (_jsx(ShimmerText, { className: "tf:leading-none", children: REASONING_STREAMING_LABEL })) : (_jsx("span", { className: "tf:leading-none", children: REASONING_SETTLED_LABEL })), _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: _jsx("p", { className: "tf:text-tf-label tf:whitespace-pre-wrap tf:text-tf-muted-foreground", children: view.text }) }));
 }
-//# sourceMappingURL=reasoning-row.js.map

package/dist/components/receipt-rows.js

@@ -1,25 +1,6 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { CircleAlertIcon } from "lucide-react";
-// The turn-level failure receipt — the ONE standalone receipt row left
-// after the meta-receipt class was deleted: a turn that dies mid-way
-// otherwise stops with no answer and no explanation. Its quiet
-// siblings (the turn_voided stamp rows, the approval/decline settled
-// statements, the resume divider) no longer render at all; their
-// markers stay on the wire and in the store, but the transcript carries
-// no narration for them. A member's own stop (turn_stopped) projects no
-// row either; the paired quiet RUN_FINISHED — not any marker — is what
-// closes a pause's cards and settles the composer.
-// The turn-level terminal failure receipt: a turn that ended failed
-// outside any single tool, rendered where the answer broke off —
-// explicit and calm, never an assistant-voiced paragraph and never a
-// detached banner. Deliberately distinct from an operation-level
-// failure, which is an in-row pill on the affected tool row. The glyph
-// shape plus the sentence are the non-colour signal; the sentence
-// itself is the wire's reader-aware copy, so the row exposes exactly
-// the safe detail the REST wire already serves. Zero motion — a failed
-// turn never leaves anything spinning.
 export function TurnFailedReceiptRows({ receipts, }) {
     return (_jsx("div", { className: "tf:flex tf:flex-col tf:gap-1 tf:py-1", children: receipts.map((receipt, index) => (_jsxs("p", { "data-tf-turn-failed-receipt": "", className: "tf:flex tf:items-center tf:gap-2 tf:text-xs tf:text-tf-muted-foreground", children: [_jsx(CircleAlertIcon, { "aria-hidden": true, className: "tf:size-3.5 tf:shrink-0 tf:text-tf-destructive" }), _jsx("span", { className: "tf:sr-only", children: "Turn failed:" }), _jsx("span", { className: "tf:min-w-0", children: receipt })] }, `${receipt}-${String(index)}`))) }));
 }
-//# sourceMappingURL=receipt-rows.js.map

package/dist/components/run-status-announcer.js

@@ -1,28 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { announcedStatusOf } from "../core/run-status.js";
-// The transcript's status live region. The conversation chrome makes no
-// visible run-state claims — the shelf's status line was deleted (its
-// work-in-progress story belongs to the subagent pill, the fold's own
-// "Working…" content headline, and the Stop control; its waiting story
-// belongs to the decision surface itself) — but a screen reader still
-// needs the transitions the visuals no longer spell out. Rules carried
-// over from the line it replaces:
-//
-// - Mounted UNCONDITIONALLY (an empty sr-only span while idle): screen
-//   readers announce MUTATIONS of an existing live region, and generally
-//   skip a node that arrives already carrying role="status" and its
-//   text — so the element must pre-exist every phrase change. sr-only is
-//   absolutely positioned, so it costs the region no layout height, and
-//   it lives OUTSIDE the shelf's slots so a permanent occupant cannot
-//   defeat their :empty collapse.
-// - Throttled by construction: the phrase changes only on status-class
-//   transitions (idle ↔ working ↔ waiting), never per streamed token and
-//   never per elapsed second.
-// - Honest about who is waited on: "Waiting for your input" is claimed
-//   only while an actionable decision surface exists — a pause with no
-//   pending decision (a subagent park, the execution driver's window)
-//   announces the machine's time, "The assistant is working".
 export function RunStatusAnnouncer({ status, decisionsPending, }) {
     const state = announcedStatusOf(status, decisionsPending);
     return (_jsx("span", { "data-tf-status-announcer": "", role: "status", className: "tf:sr-only", children: state === "waiting"
@@ -31,4 +9,3 @@ export function RunStatusAnnouncer({ status, decisionsPending, }) {
                 ? ""
                 : "The assistant is working" }));
 }
-//# sourceMappingURL=run-status-announcer.js.map