@teaflask/assistant 0.3.0 → 0.7.0

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,17 @@ 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: connectable.some((status) => status.offered)
+                    ? "Models your plan serves run on it; other picks run on this site's own funding."
+                    : undefined })) : null, _jsx(ModelPickerChip, { menu: menu, open: openChip === "picker", onOpenChange: (next) => {
                     setOpenChip(next ? "picker" : null);
                 } })] }));
 }
@@ -144,14 +66,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": "", "data-tf-popover": "", 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 +77,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 +108,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 +141,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 +159,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 +168,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.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.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.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.js

@@ -2,9 +2,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { BrainIcon, CalendarClockIcon, CompassIcon, FileTextIcon, ListTodoIcon, MessageCircleQuestionIcon, SearchIcon, SquareTerminalIcon, UsersIcon, WrenchIcon, } from "lucide-react";
 import { cx } from "./primitives/cx.js";
-// One glyph per resolved vocabulary member — operational meaning, never
-// a brand or a tool name (the presenter already resolved unknown tokens
-// to "generic", so this record is total over what can reach it).
 const OPERATION_GLYPHS = {
     search: SearchIcon,
     file: FileTextIcon,
@@ -13,68 +10,31 @@ const OPERATION_GLYPHS = {
     memory: BrainIcon,
     delegation: UsersIcon,
     routine: CalendarClockIcon,
-    // The plan-progress member (contract §8's recorded conditional):
-    // a checklist, unmistakably not the generic wrench.
     todo: ListTodoIcon,
     navigation: CompassIcon,
     generic: WrenchIcon,
 };
-// The state language, keyed by protocol state alone — the words assistive
-// tech hears where sighted readers get ink and the headline ladder.
 const STATE_WORDS = {
     "input-streaming": "Queued",
     "input-available": "Running",
     "output-available": "Completed",
     "output-error": "Failed",
-    // Its own quiet word: a member declined the approval — not interrupted
-    // (nobody cut it), not failed (nothing broke), and not the door's
-    // "Declined" (TVC-038 — the tool never got to answer).
     denied: "Not approved",
     cancelled: "Interrupted",
-    // Its own quiet word: the tool answered and declined — not
-    // interrupted (nothing cut it), not failed (nothing broke).
     refused: "Declined",
-    // Shares cancelled's outcome word — both landed short of an outcome
-    // through no fault of the tool; the headline frames tell them apart.
     superseded: "Interrupted",
 };
-/** 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 function OperationMarkFrame({ status, children, }) {
-    return (_jsxs("span", { "data-tf-op-mark": "", "data-tf-op-state": status, className: cx("tf:grid tf:size-4 tf:shrink-0 tf:place-items-center", 
-        // Queued (a pending call on a run that is not streaming) dims —
-        // the mark stays semantic, never a dashed mystery circle.
-        status === "input-streaming" && "tf:opacity-45", 
-        // The one loud pixel (the visual spec's Status-Only Color Rule):
-        // failure wears destructive ink; cancellation, refusal and a
-        // member's denial stay neutral.
-        status === "output-error" && "tf:text-tf-destructive"), children: [children, _jsx("span", { className: "tf:sr-only", children: STATE_WORDS[status] })] }));
+    return (_jsxs("span", { "data-tf-op-mark": "", "data-tf-op-state": status, className: cx("tf:grid tf:size-4 tf:shrink-0 tf:place-items-center", status === "input-streaming" && "tf:opacity-45", status === "output-error" && "tf:text-tf-destructive"), children: [children, _jsx("span", { className: "tf:sr-only", children: STATE_WORDS[status] })] }));
 }
-/** 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 function OperationMark({ icon, status, }) {
     const Glyph = OPERATION_GLYPHS[icon];
     return (_jsx(OperationMarkFrame, { status: status, children: _jsx(Glyph, { "aria-hidden": true, className: "tf:size-4" }) }));
 }
-/** 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 function OperationGlyph({ icon, className, }) {
     const Glyph = OPERATION_GLYPHS[icon];
     return _jsx(Glyph, { "aria-hidden": true, className: cx("tf:size-4", className) });
 }
-/** 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 function StatePill({ children, destructive = false, }) {
     return (_jsx("span", { "data-tf-state-pill": "", className: cx("tf:shrink-0 tf:rounded-full tf:border tf:border-tf-border tf:px-1.5 tf:py-px tf:text-xs tf:leading-4 tf:whitespace-nowrap", destructive && "tf:text-tf-destructive"), children: children }));
 }
-//# sourceMappingURL=operation-icons.js.map

package/dist/components/pretty-print.js

@@ -7,4 +7,3 @@ export function prettyPrintParameters(parameters) {
     }
     return JSON.stringify(parameters, null, 2);
 }
-//# sourceMappingURL=pretty-print.js.map

package/dist/components/primitives/autofocus.js

@@ -1,13 +1,3 @@
-// The package's opt-in initial-focus convention, shared by every surface
-// that moves focus on open: content marks its own landing spot with
-// data-tf-autofocus (the composer does), and the surface honors it. What
-// happens without a mark is the surface's own affair — the modal dialog
-// falls back to the native first-focusable, the non-modal panel
-// deliberately moves nothing.
-/** Focuses the surface's marked autofocus target, with one frame of
- * grace for content that mounts a beat after the surface is shown. The
- * predicate guards the deferred attempt: a surface that closed inside
- * that frame must not have focus pulled into it. */
 export function focusAutofocusTarget(surface, stillShowing) {
     const target = surface.querySelector("[data-tf-autofocus]");
     if (target !== null) {
@@ -20,4 +10,3 @@ export function focusAutofocusTarget(surface, stillShowing) {
         }
     });
 }
-//# sourceMappingURL=autofocus.js.map

package/dist/components/primitives/button.js

@@ -2,121 +2,73 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { cx } from "./cx.js";
-// Each variant resets the UA button border itself: no preflight ships with
-// the package, so every shape states its own `border-0` rather than
-// inheriting the host page's idea of what a button looks like.
 const VARIANT_CLASSES = {
     primary: "tf:justify-center tf:rounded-full tf:border-0 tf:px-3 tf:py-1.5 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-primary tf:text-tf-primary-foreground tf:shadow-tf-control " +
         "tf:hover:opacity-90 tf:disabled:opacity-50",
     ghost: "tf:justify-center tf:rounded-tf tf:border-0 tf:px-3 tf:py-1.5 tf:text-tf-label tf:font-medium " +
-        "tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent tf:disabled:opacity-50",
-    // Nothing to send is a resting state, not a broken one: the disabled
-    // circle steps back to the muted wash instead of showing a filled ink
-    // button at 40% — a washed-out primary reads as a rendering fault.
+        "tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent " +
+        "tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
+    secondary: "tf:relative tf:isolate tf:justify-center tf:rounded-tf tf:border-0 tf:px-3 tf:py-1.5 " +
+        "tf:text-tf-label tf:font-medium tf:bg-tf-secondary tf:text-tf-secondary-foreground " +
+        "tf:after:pointer-events-none tf:after:absolute tf:after:inset-0 tf:after:-z-10 " +
+        "tf:after:rounded-tf tf:after:bg-tf-accent tf:after:opacity-0 tf:after:transition-opacity " +
+        "tf:hover:after:opacity-100 tf:disabled:opacity-50",
     send: "tf:size-8 tf:shrink-0 tf:justify-center tf:rounded-full tf:border-0 " +
         "tf:bg-tf-primary tf:text-tf-primary-foreground tf:shadow-tf-control " +
         "tf:hover:opacity-90 tf:disabled:bg-tf-muted tf:disabled:text-tf-muted-foreground " +
         "tf:disabled:opacity-100 tf:disabled:shadow-none",
-    // The send circle's busy-state counterpart: same silhouette, filled-ink
-    // register even through the "Stopping…" beat. That beat is narrated
-    // with aria-disabled, never the disabled attribute — disabling the
-    // focused control drops keyboard focus to <body>.
     stop: "tf:size-8 tf:shrink-0 tf:justify-center tf:rounded-full tf:border-0 " +
         "tf:bg-tf-primary tf:text-tf-primary-foreground tf:shadow-tf-control " +
         "tf:hover:opacity-90 tf:aria-disabled:cursor-not-allowed tf:aria-disabled:opacity-70",
     icon: "tf:size-7 tf:justify-center tf:rounded-tf tf:border-0 tf:bg-tf-transparent tf:text-tf-muted-foreground " +
-        "tf:hover:bg-tf-accent tf:hover:text-tf-foreground tf:disabled:opacity-50",
-    // A floating icon control: round, on its own paper plate with a hairline
-    // and the control wash, for glyphs hovering over arbitrary pixels. A
-    // VARIANT, not a caller className: cx is a plain join, so a caller's
-    // bg-tf-background loses to icon's own bg-tf-transparent by sheet order.
+        "tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
     iconFloating: "tf:justify-center tf:rounded-full tf:border tf:bg-tf-background " +
         "tf:text-tf-muted-foreground tf:shadow-tf-control " +
-        "tf:hover:bg-tf-accent tf:hover:text-tf-foreground tf:disabled:opacity-50",
-    // 32px at 14px medium — the app's measured rail register, so the
-    // assistant's history reads at the same density as the docs tree.
+        "tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
     row: "tf:h-8 tf:w-full tf:justify-start tf:rounded-tf tf:border-0 tf:px-2.5 tf:text-left tf:text-sm tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-muted-foreground tf:hover:bg-tf-accent " +
-        "tf:hover:text-tf-foreground tf:aria-[current=true]:bg-tf-accent " +
-        "tf:aria-[current=true]:text-tf-foreground tf:disabled:opacity-50",
+        "tf:hover:text-tf-accent-foreground tf:aria-[current=true]:bg-tf-accent " +
+        "tf:aria-[current=true]:text-tf-accent-foreground tf:disabled:opacity-50",
     rowAction: "tf:h-9 tf:w-full tf:justify-start tf:gap-2 tf:rounded-tf tf:border-0 tf:px-2.5 tf:text-left tf:text-sm " +
         "tf:font-medium tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent " +
-        "tf:disabled:opacity-50",
-    // The drawer's rows clear the 44px touch floor and read a step larger:
-    // a phone is held further away than a rail is leaned over.
+        "tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
     rowTouch: "tf:h-11 tf:w-full tf:justify-start tf:gap-2 tf:rounded-tf tf:border-0 tf:px-3 tf:text-left " +
         "tf:text-tf-body tf:font-medium tf:bg-tf-transparent tf:text-tf-muted-foreground " +
-        "tf:hover:bg-tf-accent tf:hover:text-tf-foreground " +
-        "tf:aria-[current=true]:bg-tf-accent tf:aria-[current=true]:text-tf-foreground " +
+        "tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground " +
+        "tf:aria-[current=true]:bg-tf-accent tf:aria-[current=true]:text-tf-accent-foreground " +
         "tf:disabled:opacity-50",
-    // The drawer's edition of rowAction. A variant rather than a colour
-    // override on rowTouch: cx is a plain join, so a passed text-tf-foreground
-    // and rowTouch's own muted ink land at equal specificity and the
-    // later-emitted utility (the muted one) wins.
     rowActionTouch: "tf:h-11 tf:w-full tf:justify-start tf:gap-2 tf:rounded-tf tf:border-0 tf:px-3 tf:text-left " +
         "tf:text-tf-body tf:font-medium tf:bg-tf-transparent tf:text-tf-foreground " +
-        "tf:hover:bg-tf-accent tf:disabled:opacity-50",
-    // The opening prompts. A row, not a pill: three pills of unequal width
-    // centre-justified make a ragged line, and rows survive a 390px column.
-    // The trailing arrow is held at zero opacity rather than unmounted so
-    // the right edge never twitches. px-4 puts the leading glyph on the
-    // composer's own text inset, hanging off the chat bar's left edge.
+        "tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
     prompt: "tf:min-h-11 tf:w-full tf:justify-start tf:gap-2.5 tf:rounded-tf tf:border-0 tf:px-4 tf:py-2 " +
         "tf:text-left tf:text-tf-label tf:bg-tf-transparent tf:text-tf-foreground " +
-        "tf:hover:bg-tf-accent tf:disabled:opacity-50 " +
+        "tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground tf:disabled:opacity-50 " +
         "tf:[&_[data-tf-prompt-mark]]:text-tf-muted-foreground " +
         "tf:[&_[data-tf-prompt-go]]:opacity-0 tf:[&_[data-tf-prompt-go]]:transition-opacity " +
         "tf:hover:[&_[data-tf-prompt-go]]:opacity-100 " +
         "tf:focus-visible:[&_[data-tf-prompt-go]]:opacity-100 " +
-        // Touch has no hover to reveal the go arrow; it stays visible there.
         "tf:pointer-coarse:[&_[data-tf-prompt-go]]:opacity-100",
-    // A button that draws nothing of its own — for content that IS the
-    // affordance (the companion perch's mark, the bubble's sentence). Keeps
-    // the focus ring, resets the UA chrome, and takes the surrounding ink:
-    // the UA's buttontext would paint black on a dark popover.
     bare: "tf:rounded-tf tf:border-0 tf:bg-tf-transparent tf:p-0 tf:text-inherit tf:disabled:opacity-50",
-    // The composer shelf's chip (the provider/model slot): a quiet rounded
-    // control at the 13px label step. Two emphases as two variants (cx is a
-    // plain join, so emphasis has to be the variant's): `chip` keeps full
-    // ink for an affordance that asks, `chipQuiet` is the settled standing's.
     chip: "tf:rounded-full tf:border-0 tf:px-2 tf:py-1 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent " +
-        "tf:disabled:opacity-50",
+        "tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
     chipQuiet: "tf:rounded-full tf:border-0 tf:px-2 tf:py-1 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-muted-foreground tf:hover:bg-tf-accent " +
-        "tf:hover:text-tf-foreground tf:disabled:opacity-50",
-    // A bounded secondary action/status control. It shares the pill
-    // silhouette with the composer's chips, but keeps a hairline so it is
-    // unmistakably interactive inside a floating menu.
-    outline: "tf:justify-center tf:rounded-full tf:border tf:px-2.5 tf:py-1 tf:text-tf-label tf:font-medium " +
+        "tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
+    outline: "tf:justify-center tf:rounded-full tf:border tf:px-2.5 tf:py-[5px] tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-background tf:text-tf-foreground tf:shadow-tf-control " +
-        "tf:hover:bg-tf-accent tf:disabled:opacity-50",
-    // The question panel's answer row: one suggestion per line, spanning
-    // the panel, on the 44px touch floor. Selection is the emphasis wash,
-    // via aria-checked — state speaks through the attribute the screen
-    // reader already gets (No-Accent: never a color). Borderless: the
-    // row's edges are the panel's.
+        "tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground tf:disabled:opacity-50",
+    glassChip: "tf:justify-center tf:rounded-full tf:border tf:px-2.5 tf:py-[5px] tf:text-tf-label " +
+        "tf:font-normal tf:disabled:opacity-50",
     answerRow: "tf:min-h-11 tf:w-full tf:items-start tf:justify-start tf:gap-3 tf:rounded-tf tf:border-0 " +
         "tf:bg-tf-transparent tf:px-3 tf:py-2.5 tf:text-left tf:text-tf-label tf:text-tf-foreground " +
-        "tf:wrap-anywhere tf:hover:bg-tf-accent tf:disabled:opacity-50 " +
-        "tf:aria-checked:bg-tf-emphasis",
+        "tf:wrap-anywhere tf:hover:bg-tf-accent tf:hover:text-tf-accent-foreground " +
+        "tf:disabled:opacity-50 tf:aria-checked:bg-tf-emphasis tf:aria-checked:text-tf-foreground",
 };
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props — and callers
-// that anchor to the element (the drawer's history disclosure, the focus
-// hand-backs) need the ref to attach.
 export const TfButton = forwardRef(function TfButton({ variant = "primary", className, type, ...props }, ref) {
-    return (_jsx("button", { ref: ref, type: type ?? "button", className: cx("tf:appearance-none", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", "tf:disabled:cursor-not-allowed", VARIANT_CLASSES[variant], className), ...props }));
+    return (_jsx("button", { ref: ref, type: type ?? "button", ...(variant === "secondary" ? { "data-tf-secondary": "" } : {}), className: cx("tf:appearance-none", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", "tf:disabled:cursor-not-allowed", VARIANT_CLASSES[variant], className), ...props }));
 });
-// A navigation wearing the button grammar — for actions whose "click" is
-// a link (the connect panel's approve CTA). Same class source as
-// TfButton so the pill can never drift; no disabled arm, because anchors
-// have none.
 export function TfLinkButton({ variant = "primary", className, children, ...props }) {
-    return (_jsx("a", { className: cx(
-        // no-underline: the UA underlines anchors and no preflight ships
-        // with the package — a pill with an underline reads as a bug.
-        "tf:appearance-none tf:no-underline", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", VARIANT_CLASSES[variant], className), ...props, children: children }));
+    return (_jsx("a", { ...(variant === "secondary" ? { "data-tf-secondary": "" } : {}), className: cx("tf:appearance-none tf:no-underline", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", VARIANT_CLASSES[variant], className), ...props, children: children }));
 }
-//# sourceMappingURL=button.js.map