@teaflask/assistant 0.3.0 → 0.7.0

package/dist/appearance/theme.js

@@ -1,10 +1,3 @@
-// The JS half of the theming contract: a typed mirror of the 21 public
-// `--tf-*` tokens (src/styles/styles.css) and the pure mapping from the
-// camelCase config object to CSS variable declarations. Deliberately
-// plain data and a plain function — no React — so the script-tag
-// distribution can carry the exact same config object.
-// Typed key lists so the mapping iterates without Object.keys widening,
-// and so the parity test can pin this module to the stylesheet.
 export const THEME_TOKEN_KEYS = [
     "background",
     "foreground",
@@ -29,13 +22,6 @@ export const THEME_TOKEN_KEYS = [
     "colorScheme",
 ];
 export const DARK_THEME_TOKEN_KEYS = THEME_TOKEN_KEYS.filter((key) => key !== "radius" && key !== "fontSans" && key !== "colorScheme");
-/**
- * Maps a theme config to the CSS variables the widget roots carry
- * inline. Base values set the public `--tf-*` tokens — inline beats any
- * ambient host CSS, which is the prop-wins precedence. Dark values set
- * the private `--_tf-dark-*` mechanism variables the stylesheet's dark
- * blocks read first, so they stay out of the public token contract.
- */
 export function themeToStyleVars(theme) {
     const vars = {};
     for (const key of THEME_TOKEN_KEYS) {
@@ -55,9 +41,6 @@ export function themeToStyleVars(theme) {
 function _cssNameOf(key) {
     return key.replace(/[A-Z]/g, (upper) => `-${upper.toLowerCase()}`);
 }
-// React does not px-suffix numbers on custom properties the way it does
-// on known style props, so the mapping owns the unit.
 function _cssValueOf(value) {
     return typeof value === "number" ? `${String(value)}px` : value;
 }
-//# sourceMappingURL=theme.js.map

package/dist/components/activity-rail.js

@@ -18,93 +18,31 @@ import { _foldClaimsLiveness } from "./use-transcript-folds.js";
 export function ActivityRail({ fold, cards, turnLive, inCurrentTurn, identityToken, decisionSurfacesInShelf, toolRow, }) {
     const { cards: elicitationCards } = useContext(ElicitationsContext);
     const rows = fold.members;
-    // The one shared spelling (see _foldClaimsLiveness): the trailing
-    // arbiter must judge this fold exactly as this headline renders it.
     const running = _foldClaimsLiveness(rows, turnLive);
-    // The fold's default openness: the section that is WORKING is the one
-    // expanded — a fold claiming liveness, or one whose member awaits the
-    // member's decision (the row it holds open is the consent reading).
-    // Once the work settles the prop releases (true→undefined) and the
-    // fold collapses, so a finished section reads as one "Worked for …"
-    // line and the transcript stays scannable. A settled member's view,
-    // a settled decision and a failed step no longer hold a fold open:
-    // the failed step's own row pill names the failure (the headline
-    // carries no tally), and the member's explicit toggle outranks every
-    // arm, permanently for the fold.
     const awaitingDecision = _groupAwaitsDecision(rows, cards, elicitationCards, decisionSurfacesInShelf);
     const foldOpenByDefault = running || awaitingDecision;
     const { groupRef, memberToggled, onGroupActivation } = useMemberToggleOutrank();
     const steps = fold.steps.map((step) => (_jsx(ActivityRailStep, { step: step, cards: cards, inCurrentTurn: inCurrentTurn, identityToken: identityToken, decisionSurfacesInShelf: decisionSurfacesInShelf, toolRow: toolRow }, step.kind === "tool-call" ? step.row.key : step.view.key)));
-    return (
-    // Every protocol sequence is ONE piece of work in the transcript,
-    // including a one-step run. A stable outer level prevents the visual
-    // model from changing based on how many calls the model happened to
-    // choose. Its children keep their own disclosures, so expanding the
-    // group reveals the timeline and expanding a tool reveals its evidence.
-    _jsx("div", { "data-tf-activity-group": "", className: "tf:my-2", ref: groupRef, onClickCapture: onGroupActivation, children: _jsx(Disclosure, { variant: "bare", 
-            // Open while working or awaiting a decision, released to native
-            // once settled (true→undefined collapses once, never remounting
-            // this <details>). The member's own toggle outranks it, permanently.
-            open: memberToggled ? undefined : foldOpenByDefault || undefined, summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-1.5 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground", bodyClassName: "tf:pt-1", summary: _jsxs(_Fragment, { children: [_jsx(FoldHeadline, { fold: fold, running: running }), _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: _jsx("div", { "data-tf-activity-rail": "", children: _jsx("div", { children: steps }) }) }) }));
+    return (_jsx("div", { "data-tf-activity-group": "", className: "tf:my-2", ref: groupRef, onClickCapture: onGroupActivation, children: _jsx(Disclosure, { variant: "bare", open: memberToggled ? undefined : foldOpenByDefault || undefined, summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-1.5 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground", bodyClassName: "tf:pt-1", summary: _jsxs(_Fragment, { children: [_jsx(FoldHeadline, { fold: fold, running: running }), _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: _jsx("div", { "data-tf-activity-rail": "", children: _jsx("div", { children: steps }) }) }) }));
 }
-/** One step of the rail, in transcript order: a reasoning view, the
- *  narration a completed episode folded, or a tool call inside its own
- *  boundary. */
 function ActivityRailStep({ step, cards, inCurrentTurn, identityToken, decisionSurfacesInShelf, toolRow, }) {
     if (step.kind === "reasoning") {
         return (_jsx("div", { "data-tf-activity-step": "", children: _jsx(ReasoningRow, { view: step.view }) }));
     }
     if (step.kind === "narration") {
-        // Narration that folded into a completed episode: the same prose the
-        // top-level assistant-text case renders, in a second home. Carried:
-        // the identity token (law 10) and MemoryUpdatedFooter. Deliberately
-        // not: the paced reveal (a narration step is settled by construction),
-        // the py-2 wrapper (py-1 here is rail geometry, not message padding),
-        // the rows' ps-7 label gutter (prose sits flush with the fold's
-        // headline, as top-level prose sits flush with the marks — law 5:
-        // disclosure adds detail, never indentation), and the copy affordance
-        // (that belongs to top-level messages). Item by item: the episode-fold
-        // audit record.
         return (_jsxs("div", { "data-tf-activity-step": "", "data-tf-activity-narration": "", "data-tf-agent-identity": identityToken, className: "tf:py-1", children: [_jsx(AssistantMarkdown, { children: step.view.text }), step.view.memoryUpdates !== undefined ? (_jsx(MemoryUpdatedFooter, { updates: step.view.memoryUpdates })) : null] }));
     }
     return (_jsx("div", { "data-tf-activity-step": "", children: _jsx(SurfaceBoundary, { surface: "tool-row", children: _jsx(ToolCallRows, { row: step.row, cards: cards, inCurrentTurn: inCurrentTurn, decisionSurfacesInShelf: decisionSurfacesInShelf, toolRow: toolRow }) }) }));
 }
-/** The fold summary's words. Live, the one shimmered label tracks the work
- *  by disclosure state (TVC-010): COLLAPSED reads the latest step's own
- *  label (liveFoldHeadlineOf); EXPANDED reads the generic "Working…",
- *  because the rail below says what the steps are. The open bit is the
- *  DOM-backed disclosure mirror (useDisclosureVisualState), never the open
- *  prop. Settled, the label is the work's cost ("Worked for 4m 49s",
- *  degrading to "Worked"), NEVER a step label and never an outcome tally: a
- *  step that failed, was interrupted, declined or not approved wears that
- *  word on its own row's pill, where the member who opens the fold reads
- *  it. */
 function FoldHeadline({ fold, running, }) {
     const open = useDisclosureVisualState()?.open ?? false;
     if (running) {
         const rawLabel = open ? "Working…" : liveFoldHeadlineOf(fold.steps);
         const label = open ? rawLabel : activityTitleOf(rawLabel);
-        return (
-        // The measured truncation shape (subagent-group-row's idiom): the
-        // shimmer root is an atomic inline-grid, so the ellipsis lives on the
-        // blockified span inside and grid-cols-1 + max-w-full + min-w-0 make
-        // the track shrinkable — one line, never overflowing the 390px
-        // contract. The RAW step label rides the wrapper's title (never the
-        // inner span: ShimmerText duplicates its children).
-        _jsx("span", { className: "tf:min-w-0", title: open ? undefined : rawLabel, children: _jsx(ShimmerText, { className: "tf:max-w-full tf:grid-cols-1", children: _jsx("span", { className: "tf:block tf:truncate", children: label }) }) }));
+        return (_jsx("span", { className: "tf:min-w-0", title: open ? undefined : rawLabel, children: _jsx(ShimmerText, { className: "tf:max-w-full tf:grid-cols-1", children: _jsx("span", { className: "tf:block tf:truncate", children: label }) }) }));
     }
     return _jsx("span", { children: settledFoldHeadlineOf(fold.duration) });
 }
-/** The fold's decision arm: LIVE pendency only — a member row whose
- *  anchored approval or elicitation card is still actionable or
- *  submitting (approvalAwaitsMember / elicitationAwaitsMember, the one
- *  spelling of "waiting on the human"). The durable `row.decisionBearing`
- *  anchor is the ROW's hold (tool-call-rows.tsx, its decisionBearing
- *  derivation), never the fold's: an answered decision is finished work,
- *  and finished work folds. The cards are read through the same join the
- *  row uses — the shelf tenant's by toolCallId, else the anchored join —
- *  so fold and row agree on which cards are this call's. Every card-store
- *  consumer, classified: docs/transcript-surfaces.md. */
 function _groupAwaitsDecision(rows, approvalCards, elicitationCards, decisionSurfacesInShelf) {
     return rows.some((row) => {
         if (row.kind !== "tool-call") {
@@ -120,4 +58,3 @@ function _groupAwaitsDecision(rows, approvalCards, elicitationCards, decisionSur
             elicitations.some(elicitationAwaitsMember));
     });
 }
-//# sourceMappingURL=activity-rail.js.map

package/dist/components/activity-shelf.js

@@ -1,18 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-/** The decision shelf holds active approval and question surfaces. */
 export function ActivityShelf({ suspension, }) {
     return (_jsx("div", { "data-tf-activity-shelf": "", "data-tf-composer-ground": "", className: "tf:bg-tf-background tf:empty:hidden", children: _jsx("div", { className: "tf:mx-auto tf:w-full tf:max-w-3xl tf:px-4 tf:empty:hidden", children: _jsx("div", { "data-tf-suspension-slot": "", className: "tf:flex tf:flex-col tf:gap-2 tf:pt-1 tf:empty:hidden", children: suspension }) }) }));
 }
-/**
- * Floating activity anchored to the top edge of the shelf+composer
- * anchor (Transcript's [data-tf-composer-anchor]) — above the decision
- * shelf when it is populated, directly above the composer when it is
- * empty, so a floating pill can never sit over a pending card's
- * Approve/Deny row. The overlay never catches input;
- * compact interactive tenants opt back in at their own boundary. No
- * background is painted here.
- */
 export function ComposerActivityOverlay({ activity, }) {
     return (_jsx("div", { "data-tf-activity-slot": "", "data-tf-composer-activity-overlay": "", className: "tf:pointer-events-none tf:absolute tf:inset-x-0 tf:bottom-full tf:flex tf:flex-col tf:items-center tf:gap-1.5 tf:pb-4 tf:empty:hidden", children: activity }));
 }
-//# sourceMappingURL=activity-shelf.js.map

package/dist/components/agent-identity-mark.js

@@ -1,21 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// The TeaFlask agent identity mark (law 10): ONE canonical mark
-// component for the primary agent and its subagents, so no surface ever
-// borrows a mascot or a provider logo. The flask geometry is the brand
-// SVG the marketing site ships (the dashboard's logo component is its
-// copy of the same pair) — the package cannot import the dashboard's
-// tree, so the two rects are minted here from that source.
-//
-// Subagents use the real filled TeaFlask geometry. A replay-stable
-// dispatch index selects a color, echoing the reference UI's colored
-// coworker avatars without borrowing its ghost mascot. Color is an
-// identity channel here, never a status channel; the accessible name
-// remains textual and the index is intentionally not painted as a badge.
-//
-// data-tf-agent-mark carries the register (TVC-092 reads it); the
-// identity TOKEN hooks (data-tf-agent-identity / data-tf-subagent-
-// identity, TVC-090/091) stay on the surfaces that mint them — this
-// component is the visible treatment, not a second token spelling.
 import { cx } from "./primitives/cx.js";
 import { useId } from "react";
 const SUBAGENT_GRADIENTS = [
@@ -31,19 +14,10 @@ const SUBAGENT_GRADIENTS = [
 export function AgentIdentityMark({ register, variantIndex, size = "sm", className, }) {
     const subagent = register === "subagent";
     const gradientId = `tf-agent-${useId().replace(/:/g, "")}`;
-    // The palette is the identity channel (the visual spec's Agent Identity
-    // Exception), and identity needs a coworker: with no variantIndex there
-    // is nothing to encode, so the aggregate mark (the count-pill trigger,
-    // the group header) paints currentColor and stays theme- and
-    // surface-adaptive — the pill's muted ink, a failed row's destructive
-    // tint — instead of pinning a gray pair that ignores both.
     const gradient = subagent && variantIndex !== undefined
         ? SUBAGENT_GRADIENTS[(variantIndex - 1) % SUBAGENT_GRADIENTS.length]
         : null;
-    return (_jsxs("span", { "data-tf-agent-mark": register, "data-tf-agent-variant": subagent ? variantIndex : undefined, className: cx("tf:flex tf:shrink-0 tf:items-center", 
-        // A percentage-sized svg inside a fit-content parent collapses,
-        // so fill widens the wrapper to the box instead of to the glyph.
-        size === "fill" ? "tf:size-full tf:justify-center" : "tf:w-fit", className), children: [_jsxs("svg", { viewBox: "0 0 172 172", "aria-hidden": "true", className: cx("tf:shrink-0", size === "fill"
+    return (_jsxs("span", { "data-tf-agent-mark": register, "data-tf-agent-variant": subagent ? variantIndex : undefined, className: cx("tf:flex tf:shrink-0 tf:items-center", size === "fill" ? "tf:size-full tf:justify-center" : "tf:w-fit", className), children: [_jsxs("svg", { viewBox: "0 0 172 172", "aria-hidden": "true", className: cx("tf:shrink-0", size === "fill"
                     ? "tf:size-full"
                     : size === "sm"
                         ? "tf:size-3.5"
@@ -53,4 +27,3 @@ export function AgentIdentityMark({ register, variantIndex, size = "sm", classNa
                         : "Subagent"
                     : "TeaFlask" })] }));
 }
-//# sourceMappingURL=agent-identity-mark.js.map

package/dist/components/appearance-context.js

@@ -8,4 +8,3 @@ export function useAssistantAppearance() {
     }
     return value;
 }
-//# sourceMappingURL=appearance-context.js.map

package/dist/components/approval-card.js

@@ -9,25 +9,11 @@ import { TfTextarea } from "./primitives/textarea.js";
 import { Spinner } from "./streaming-states.js";
 export const APPROVED_NOTE = "Approved";
 export const TRUSTED_NOTE = "Approved — the assistant won't ask about this again in this conversation.";
-// The coworker's twin: the grant is its own session's, so the note names
-// the actor and the scope the button promised.
 const COWORKER_TRUSTED_NOTE = "Approved — the coworker won't ask about this again in this task.";
-// "Not approved", not "Denied": the row this decision settles into
-// wears the same word on its pill and headline, so the banner's footer
-// — the decision's only other rendered home — says one word for one
-// fact. "Declined" stays the door's (TVC-038).
 export const DENIED_NOTE = "Not approved — the assistant has been told.";
-// A coworker's card speaks of the coworker: who asked is who
-// hears the answer.
 const COWORKER_DENIED_NOTE = "Not approved — the coworker has been told.";
 const STALE_NOTE = "This request was already answered or expired.";
-// The gate's asks are strictly per-call; saying so is what makes the
-// third ask read as policy instead of amnesia (and explains why the
-// approve-and-stop-asking control is missing).
 const GATED_NOTE = "This action asks every time.";
-// Module-private: the transcript's settled decision lines that shared
-// this spelling went with the meta-receipt rows; the card's own footer
-// below is the note's one rendered home.
 function approvalSettledNoteOf(status, asker) {
     switch (status.kind) {
         case "answered":
@@ -47,43 +33,8 @@ function approvalSettledNoteOf(status, asker) {
             return null;
     }
 }
-/**
- * One approval entry point: the package's generic banner. It asks one
- * question — the backend-authored consent sentence over a mechanically
- * spelled tool label — and no longer presents the tool call.
- *
- * The consent doctrine: informed consent is carried by the TRANSCRIPT
- * ROW, which a pending decision always opens — the placement guarantee:
- * `heldRowOpen` in tool-row.tsx holds the affected row and its fold open
- * from the durable decision arm that core/tool-decision-anchors.ts folds
- * out of the event history, so the arguments are on screen
- * (replay-identically, reload included) without this banner carrying
- * them. The "Show request" affordance below scrolls to that row.
- *
- * Moving the arguments off this surface weakens no enforcement, because
- * the re-ask rule — "ask again iff the card would render differently" —
- * was doctrine in a comment, never a mechanism: trust is recorded and
- * looked up by EXACT tool name (the serving side's interventions module;
- * the vended SDK's ledger is `hitl:trusted_tools`, a plain list of
- * tool-name strings in agent state), and no argument digest exists
- * anywhere in the codebase (no trust key, storage column or inbox key
- * anywhere derives from a call's arguments). Nothing mechanical ever
- * depended on this surface's fidelity to the arguments.
- *
- * Everything rendered stays a pure function of the card model: stable
- * ordering, no clocks, no locale — two identical requests render
- * byte-identical banners.
- *
- * The durable status (submitting, answered, stale) lives in the inbox so
- * a transcript remount can never resurrect the buttons; the local state
- * is the deny-reveals-textarea step and the synchronous double-click
- * guard — and local state may only ever ADD dead-ness: the buttons'
- * existence stays the inbox's call, the guard merely disables them in
- * the same tick the click lands, before any store round-trip.
- */
 export function ApprovalCard({ card }) {
     const { submitDecision } = useContext(ApprovalsContext);
-    const rootRef = useRef(null);
     const [denying, setDenying] = useState(false);
     const [feedback, setFeedback] = useState("");
     const submittedForStatusRef = useRef(null);
@@ -98,9 +49,7 @@ export function ApprovalCard({ card }) {
         setSubmittedForStatus(card.status);
         void submitDecision(card, decision);
     };
-    return (_jsxs("div", { ref: rootRef, "data-tf-approval-card": "", className: "tf:my-2 tf:rounded-2xl tf:border tf:border-tf-border tf:bg-tf-card tf:p-4", role: "group", "aria-label": "Approval request", children: [_jsx(CardHeader, { card: card, onShowRequest: () => {
-                    _showRequest(rootRef.current, card.toolCallId);
-                } }), _jsx("p", { "data-tf-approval-prompt": "", className: "tf:mt-3 tf:m-0 tf:text-tf-label tf:leading-relaxed tf:text-tf-muted-foreground", children: card.prompt.trim() === ""
+    return (_jsxs("div", { "data-tf-approval-card": "", className: "tf:my-2 tf:rounded-2xl tf:border tf:border-tf-border tf:bg-tf-card tf:p-4 tf:text-tf-card-foreground", role: "group", "aria-label": "Approval request", children: [_jsx(CardHeader, { card: card }), _jsx("p", { "data-tf-approval-prompt": "", className: "tf:mt-3 tf:m-0 tf:text-tf-label tf:leading-relaxed tf:text-tf-muted-foreground", children: card.prompt.trim() === ""
                     ? "This tool needs your approval before it can run."
                     : card.prompt }), _jsx("div", { "data-tf-approval-footer": "", children: _jsx(CardFooter, { card: card, denying: denying, submitted: submitted, feedback: feedback, onFeedbackChange: setFeedback, onApprove: () => {
                         submitOnce({ approved: true });
@@ -118,22 +67,8 @@ export function ApprovalCard({ card }) {
                         });
                     } }) })] }));
 }
-function CardHeader({ card, onShowRequest, }) {
-    return (_jsxs("div", { className: "tf:flex tf:min-w-0 tf:items-start tf:justify-between tf:gap-3", children: [_jsxs("div", { className: "tf:min-w-0", children: [_jsx("p", { "data-tf-approval-title": "", className: "tf:m-0 tf:text-tf-heading tf:font-semibold", children: "Approval required" }), _jsx("p", { className: "tf:mt-0.5 tf:m-0 tf:truncate tf:font-mono tf:text-xs tf:text-tf-muted-foreground", children: _toolDisplayNameOf(card.toolName) }), card.asker.kind === "coworker" ? (_jsxs("p", { "data-tf-approval-asker": "", className: "tf:mt-1 tf:m-0 tf:truncate tf:text-xs tf:text-tf-muted-foreground", children: ["Asked by a coworker \u2014 ", _coworkerLabelOf(card.asker.label)] })) : null] }), card.toolCallId !== null && card.asker.kind === "assistant" ? (
-            // Gated on MODEL data alone, stated premise: on a row-less
-            // REST-recovered pause this button renders and its click is a
-            // quiet no-op — an inert-but-present control is the accepted
-            // cost there, pinned by its test. Gating on DOM presence
-            // instead (a layout-effect lookup of the row) would make the
-            // render a function of the mount environment — breaking "two
-            // identical requests render byte-identical banners" and
-            // re-introducing, as a DOM probe, exactly the row join this
-            // reshape deleted.
-            //
-            // shrink-0 + nowrap: the affordance never wraps to two lines
-            // at the narrow measure — the title column beside it owns the
-            // squeeze (its label already truncates).
-            _jsx(TfButton, { variant: "ghost", className: "tf:shrink-0 tf:whitespace-nowrap", "data-tf-approval-show-request": "", onClick: onShowRequest, children: "Show request" })) : null] }));
+function CardHeader({ card }) {
+    return (_jsxs("div", { className: "tf:min-w-0", children: [_jsx("p", { "data-tf-approval-title": "", className: "tf:m-0 tf:text-tf-heading tf:font-semibold", children: "Approval required" }), _jsx("p", { className: "tf:mt-0.5 tf:m-0 tf:truncate tf:font-mono tf:text-xs tf:text-tf-muted-foreground", children: _toolDisplayNameOf(card.toolName) }), card.asker.kind === "coworker" ? (_jsxs("p", { "data-tf-approval-asker": "", className: "tf:mt-1 tf:m-0 tf:truncate tf:text-xs tf:text-tf-muted-foreground", children: ["Asked by a coworker \u2014 ", _coworkerLabelOf(card.asker.label)] })) : null] }));
 }
 function CardFooter({ card, denying, submitted, feedback, onFeedbackChange, onApprove, onApproveAndTrust, onStartDenying, onStopDenying, onSendDenial, }) {
     switch (card.status.kind) {
@@ -151,77 +86,14 @@ function DenialForm({ asker, feedback, submitted, onFeedbackChange, onSend, onBa
                     ? "Tell the coworker why (optional)"
                     : "Tell the assistant why (optional)", "aria-label": "Reason for denying", onChange: (event) => {
                     onFeedbackChange(event.target.value);
-                } }), _jsxs("div", { className: "tf:flex tf:gap-2", children: [_jsx(TfButton, { disabled: submitted, onClick: onSend, children: "Send denial" }), _jsx(TfButton, { variant: "ghost", disabled: submitted, onClick: onBack, children: "Back" })] })] }));
+                } }), _jsxs("div", { className: "tf:flex tf:gap-2", children: [_jsx(TfButton, { disabled: submitted, onClick: onSend, children: "Send denial" }), _jsx(TfButton, { variant: "secondary", disabled: submitted, onClick: onBack, children: "Back" })] })] }));
 }
 function DecisionButtons({ card, submitted, onApprove, onApproveAndTrust, onStartDenying, }) {
-    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:flex-wrap tf:gap-2", children: [_jsx(TfButton, { disabled: submitted, onClick: onApprove, children: "Approve" }), _cardOffersTrust(card) ? (_jsx(TfButton, { variant: "ghost", disabled: submitted, onClick: onApproveAndTrust, children: _trustLabelOf(card.asker) })) : null, _jsx(TfButton, { variant: "ghost", disabled: submitted, onClick: onStartDenying, children: "Deny" })] }), card.gated ? (_jsx("p", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: GATED_NOTE })) : null] }));
-}
-/** The Show-request navigation: reveal the banner's call's transcript
- *  row and scroll it into view. Scoped to the closest
- *  [data-tf-conversation], like the tenant's own focus hand-off
- *  (suspension-surfaces.tsx): surfaces can mount Transcript concurrently
- *  (the page under an open palette), and a root-scoped query would
- *  resolve the FIRST column's row; the root node (document or shadow
- *  root) is the fallback for bare hosts. A missing row (a REST-recovered
- *  pause whose call never reached the transcript, a pruned history) is a
- *  quiet no-op — never a throw. Scroll only, no focus move: the member
- *  is going to READ the request and come back to Approve/Deny, and
- *  yanking focus would exercise the tenant's blur-disarm for nothing. */
-function _showRequest(from, toolCallId) {
-    if (from === null || toolCallId === null) {
-        return;
-    }
-    const scope = from.closest("[data-tf-conversation]") ??
-        from.getRootNode();
-    const row = scope.querySelector(`[data-tf-tool-call-id="${CSS.escape(toolCallId)}"]`);
-    if (row === null) {
-        return;
-    }
-    // ESTABLISH the state the navigation needs, don't assume it: the
-    // placement hold is releasable in both directions on purpose — a
-    // member's collapse of a held-open row sticks until a genuine arrival
-    // (tool-row.tsx), and one explicit toggle pins the enclosing fold to
-    // native <details> for its lifetime (use-member-toggle-outrank.ts).
-    // Both rulings stand untouched: this imperative open is a
-    // MEMBER-INITIATED reveal — the member just clicked "Show request" —
-    // which is categorically different from a hold re-asserting itself
-    // over a member's toggle.
-    // It writes only the native open state (each set fires a toggle
-    // event, so the Disclosure mirror stays honest), and the walk covers
-    // the row itself plus every enclosing fold, since a closed fold gives
-    // the row no box for scrollIntoView to target at all.
-    for (let enclosing = row.closest("details"); enclosing !== null; enclosing = enclosing.parentElement?.closest("details") ?? null) {
-        enclosing.open = true;
-    }
-    // The row's own summary, not the details: an open pending row can be
-    // taller than the viewport, and centering the whole pane would put its
-    // header off screen.
-    const target = row.querySelector(":scope > summary") ?? row;
-    // jsdom has no scrollIntoView (same guard as affordances/highlight.ts).
-    if (typeof target.scrollIntoView !== "function") {
-        return;
-    }
-    target.scrollIntoView({
-        block: "center",
-        inline: "nearest",
-        behavior: _reducedMotionIsOn(target) ? "auto" : "smooth",
-    });
-}
-function _reducedMotionIsOn(target) {
-    // Both switches, like every animated surface in the package
-    // (streaming-states.tsx): the OS preference and the host kill switch —
-    // walked from the scroll TARGET so the check is shadow-root correct
-    // for the row being scrolled to.
-    return ((typeof window.matchMedia === "function" &&
-        window.matchMedia("(prefers-reduced-motion: reduce)").matches) ||
-        target.closest('[data-reduce-motion="true"]') !== null);
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:flex-wrap tf:gap-2", children: [_jsx(TfButton, { disabled: submitted, onClick: onApprove, children: "Approve" }), _cardOffersTrust(card) ? (_jsx(TfButton, { variant: "secondary", disabled: submitted, onClick: onApproveAndTrust, children: _trustLabelOf(card.asker) })) : null, _jsx(TfButton, { variant: "secondary", disabled: submitted, onClick: onStartDenying, children: "Deny" })] }), card.gated ? (_jsx("p", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: GATED_NOTE })) : null] }));
 }
 function _cardOffersTrust(card) {
-    // Off the wire for either asker; the locked gate never offers it.
     return !card.gated && card.trustAvailable;
 }
-// The consent sentence names the grant's scope, which is the asker's
-// session: the thread for the assistant, the task for a coworker.
 function _trustLabelOf(asker) {
     return asker.kind === "coworker"
         ? "Approve for this task"
@@ -243,4 +115,3 @@ function _toolDisplayNameOf(toolName) {
         ? toolName
         : humanized[0].toUpperCase() + humanized.slice(1);
 }
-//# sourceMappingURL=approval-card.js.map

package/dist/components/approval-context.d.ts

@@ -1,12 +1,28 @@
 import type { ApprovalCardModel, ApprovalDecisionInput } from "../core/approval-inbox.js";
+/**
+ * The approval requests to show and the function that answers them, as returned
+ * by useApprovals().
+ */
 export interface ApprovalSurface {
+    /**
+     * Approval requests in the open conversation, from the assistant and its
+     * sub-agents. Requests already answered or no longer answerable can stay in
+     * the list for a while, so render by each card's status.
+     */
     cards: readonly ApprovalCardModel[];
+    /**
+     * Sends the visitor's decision on one request; the card shows submitting,
+     * then answered. It does not reject on a server error: the card returns to
+     * actionable with an error sentence instead, and repeat submits while one
+     * is in flight are ignored.
+     */
     submitDecision: (card: ApprovalCardModel, decision: ApprovalDecisionInput) => Promise<void>;
 }
 export declare const ApprovalsContext: import("react").Context<ApprovalSurface>;
-/** The approval surface — live under <TeaflaskAssistantProvider>;
- *  outside one it is the inert-but-loud guard above, so a stray
- *  submit still refuses to dissolve into a no-op. */
+/**
+ * Returns the approval requests in the open conversation and the function that
+ * answers them. Live inside <TeaflaskAssistantProvider>; outside it the list is
+ * empty and submitting rejects with an error.
+ */
 export declare function useApprovals(): ApprovalSurface;
 export declare function anchoredCardsFor(cards: readonly ApprovalCardModel[], toolCallId: string): ApprovalCardModel[];
-//# sourceMappingURL=approval-context.d.ts.map

package/dist/components/approval-context.js

@@ -1,11 +1,5 @@
 "use client";
 import { createContext, useContext } from "react";
-// Inert for rendering, loud on use: the empty-state composer renders
-// outside any transcript, where nothing can be paused — but a decision
-// on a safety-critical control must never dissolve into a successful
-// no-op, so an out-of-surface submit says so in the console and
-// rejects. Callers void the promise, which makes the rejection an
-// unhandled one on purpose: it reaches the host's exception capture.
 const EMPTY_APPROVAL_SURFACE = {
     cards: [],
     submitDecision: (card) => {
@@ -15,13 +9,9 @@ const EMPTY_APPROVAL_SURFACE = {
     },
 };
 export const ApprovalsContext = createContext(EMPTY_APPROVAL_SURFACE);
-/** The approval surface — live under <TeaflaskAssistantProvider>;
- *  outside one it is the inert-but-loud guard above, so a stray
- *  submit still refuses to dissolve into a no-op. */
 export function useApprovals() {
     return useContext(ApprovalsContext);
 }
 export function anchoredCardsFor(cards, toolCallId) {
     return cards.filter((card) => card.anchored && card.toolCallId === toolCallId);
 }
-//# sourceMappingURL=approval-context.js.map

package/dist/components/assistant-companion.d.ts

@@ -1,15 +1,20 @@
+/** Props for `AssistantCompanion`. */
 export interface AssistantCompanionProps {
-    /** The viewport corner the companion (and its drawer) anchor to. */
+    /**
+     * The screen corner where the widget and its drawer sit. The default is
+     * `"bottom-right"`.
+     */
     corner?: "bottom-right" | "bottom-left";
-    /** Accessible name of the open-assistant control. */
+    /**
+     * The accessible name of the button that opens the drawer, which defaults
+     * to `"Open assistant"`.
+     */
     "aria-label"?: string;
 }
-/** The export is the boundary: a throw anywhere in this surface — its
- *  own hooks included — never unmounts the host's tree.
- *  degrade="silent": this is an overlay mount sitting as a sibling at
- *  the end of the host's tree, so the in-flow fallback card would land
- *  as a stray block on the host page — absence is the honest degraded
- *  state, and onError + the console report identically. Unkeyed
- *  backstop: it clears when the host remounts the surface. */
+/**
+ * The corner widget: your mark in a corner of the screen, which opens the chat
+ * drawer when clicked. On wide screens the user can switch the drawer between a
+ * floating card and a docked sidebar. It hides while a full-page assistant or
+ * the palette is open, and `TeaflaskAssistant` already includes one.
+ */
 export declare function AssistantCompanion(props: AssistantCompanionProps): import("react").JSX.Element;
-//# sourceMappingURL=assistant-companion.d.ts.map

package/dist/components/assistant-companion.js

@@ -13,23 +13,7 @@ import { SurfaceBoundary } from "./surface-boundary.js";
 import { useAssistantSurfacePresence } from "./use-assistant-surface-presence.js";
 import { usePerchClearance } from "./use-perch-clearance.js";
 import { useCell } from "./use-store-cell.js";
-// How long a dismissed drawer stays mounted so the stylesheet's 220ms
-// exit run gets to paint (unmounting kills it before hidePopover() can
-// start it), with room for a busy frame. A timer, not transitionend:
-// the widget holds no ref into the panel two components down, and a
-// listener that never fires would hold the mount forever (dock-reflow's
-// law). Erring long is invisible — once the run lands the closed
-// popover is display:none. Reduced motion deliberately takes the same
-// path: the stylesheet already collapses the run to a 1ms cut, and the
-// rest of the hold keeps only a hidden node mounted.
 const DRAWER_EXIT_HOLD_MS = 400;
-/** The export is the boundary: a throw anywhere in this surface — its
- *  own hooks included — never unmounts the host's tree.
- *  degrade="silent": this is an overlay mount sitting as a sibling at
- *  the end of the host's tree, so the in-flow fallback card would land
- *  as a stray block on the host page — absence is the honest degraded
- *  state, and onError + the console report identically. Unkeyed
- *  backstop: it clears when the host remounts the surface. */
 export function AssistantCompanion(props) {
     return (_jsx(SurfaceBoundary, { surface: "companion", degrade: "silent", children: _jsx(AssistantCompanionInner, { ...props }) }));
 }
@@ -40,10 +24,6 @@ function AssistantCompanionInner({ corner = "bottom-right", "aria-label": ariaLa
     const drawer = useCompanionDrawer();
     const panelMode = usePanelMode(publishableKey);
     const sidebarFits = useViewportFitsSidebar();
-    // Below the floor a 26rem sidebar is nonsense — the floating card is
-    // already full-width there. The preference survives untouched; only
-    // the rendering is forced, so a tablet rotated back gets its sidebar
-    // back without re-choosing.
     const dock = sidebarFits && panelMode === "sidebar" ? "sidebar" : "floating";
     const changeDock = useCallback((next) => {
         writePanelMode(publishableKey, next);
@@ -55,19 +35,10 @@ function AssistantCompanionInner({ corner = "bottom-right", "aria-label": ariaLa
     usePerchClearance(dockRef, dockVisible);
     return (_jsxs(_Fragment, { children: [_jsx("div", { ref: dockRef, popover: "manual", "data-tf-assistant": "", "data-tf-companion-dock": corner, onToggle: parkOnForcedHide, ...rootProps, children: chrome === "companion" ? (_jsx(MinimizedCompanion, { ariaLabel: ariaLabel, onOpen: drawer.open })) : null }), chrome === "drawer" || drawer.expanded || drawer.exiting ? (_jsx(CompanionDrawer, { open: chrome === "drawer", exiting: drawer.exiting, focusOnOpen: drawer.openedByGesture, onOpenChange: drawer.changeOpen, corner: corner, dock: dock, onDockChange: sidebarFits ? changeDock : null })) : null] }));
 }
-/** The drawer's open flag — page-level state (core/companion-drawer-flag),
- *  so a tool navigation and a full surface taking the floor write it from
- *  outside this tree and a host remount lands on the same flag — plus the
- *  exit hold, the one clock that is this instance's own. A transient
- *  yield (the palette) never touches the flag, so the drawer returns when
- *  the palette closes. */
 function useCompanionDrawer() {
     const expanded = useCell(companionDrawerOpen);
     const [drawerExiting, setDrawerExiting] = useState(false);
     const [openedByGesture, setOpenedByGesture] = useState(false);
-    // A reopen mid-exit cancels the hold in the same paint (render-time
-    // adjustment), so a minimize that follows starts a full-length hold —
-    // a stale timer from the first exit would truncate the second.
     if (drawerExiting && expanded) {
         setDrawerExiting(false);
     }
@@ -75,11 +46,6 @@ function useCompanionDrawer() {
         setOpenedByGesture(true);
         openCompanionDrawer();
     }, []);
-    // Every deliberate dismissal — the dash, Esc, a swipe — rings this
-    // with false (a yield never does), and the exit hold keeps the panel
-    // mounted through the very commit that flips `open`, so hidePopover()
-    // gets to run and the stylesheet's exit paints instead of a one-frame
-    // cut. The timer below lets go once the run has landed.
     const changeDrawerOpen = useCallback((next) => {
         setOpenedByGesture(next);
         if (next) {
@@ -111,19 +77,9 @@ function useCompanionDrawer() {
 function MinimizedCompanion({ ariaLabel, onOpen, }) {
     return (_jsx("div", { "data-tf-companion-perch": "", children: _jsx(TfButton, { variant: "bare", "data-tf-companion-body": "", "aria-label": ariaLabel, onClick: onOpen, children: _jsx(CompanionMark, {}) }) }));
 }
-/** The durable per-key dock preference, live across every consumer in
- *  this tab. The server snapshot is floating: registration-free SSR, and
- *  hydration corrects itself without a mismatch. */
 function usePanelMode(publishableKey) {
     return useSyncExternalStore(subscribePanelMode, () => readPanelMode(publishableKey), () => "floating");
 }
-// The sidebar's viewport floor. The margin push is invisible to the
-// host's own media queries — a pushed host still *believes* the full
-// viewport width — so below this floor the 26rem pane leaves hosts in
-// a layout their breakpoints never planned for (the dashboard at 800px
-// kept its expanded nav over a ~90px content sliver). 1024 leaves every
-// host at least ~608px, and the phone/tablet cases the ticket named are
-// already covered by the full-width floating card.
 const SIDEBAR_MIN_VIEWPORT_QUERY = "(min-width: 1024px)";
 function _subscribeSidebarViewport(onChange) {
     const media = window.matchMedia(SIDEBAR_MIN_VIEWPORT_QUERY);
@@ -132,21 +88,9 @@ function _subscribeSidebarViewport(onChange) {
         media.removeEventListener("change", onChange);
     };
 }
-/** Whether the viewport clears the sidebar's floor, live across resizes
- *  and rotations. The server snapshot says no — SSR renders the floating
- *  default and hydration corrects without a mismatch. */
 function useViewportFitsSidebar() {
     return useSyncExternalStore(_subscribeSidebarViewport, () => window.matchMedia(SIDEBAR_MIN_VIEWPORT_QUERY).matches, () => false);
 }
-/**
- * The dock's edition of the floating panel's popover discipline: the
- * `visible` argument stays authoritative (machine-driven hides are ours;
- * this effect is the only writer), a forced external hide — a host
- * modal's hide-all-popovers, a meddling hidePopover() — PARKS the dock
- * rather than closing it, and the way-is-clear watcher restores it
- * without touching focus. In a browser without popover support the dock
- * simply never shows (the stylesheet keeps it hidden at rest).
- */
 function useDockPresence(dockRef, visible) {
     const parkedRef = useRef(false);
     useEffect(() => {
@@ -157,9 +101,6 @@ function useDockPresence(dockRef, visible) {
         const doc = dock.ownerDocument;
         const showing = dock.matches(":popover-open");
         if (visible && !showing && !parkedRef.current) {
-            // The same way-must-be-clear check as the restore path: a machine
-            // flip while a host modal is up must park, not punch the dock into
-            // the top layer above the modal's backdrop.
             if (doc.querySelector("dialog:modal") !== null ||
                 doc.fullscreenElement !== null) {
                 parkedRef.current = true;
@@ -204,4 +145,3 @@ function useDockPresence(dockRef, visible) {
         }
     }, [visible]);
 }
-//# sourceMappingURL=assistant-companion.js.map