@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/teaflask-assistant-provider.js

@@ -4,6 +4,7 @@ import { createContext, useCallback, useContext, useEffect, useMemo, useRef, } f
 import { themeToStyleVars, } from "../appearance/theme.js";
 import { assistantSessionRegistry, } from "../core/assistant-session-registry.js";
 import { hostFillDeclines } from "../core/host-fill.js";
+import { IDENTITY_PAIR_WARNING, identityPairIsHalfSet, namedIdentityOf, } from "../core/identity-pair.js";
 import { performActionIntent } from "../transport/actions-adapter.js";
 import { AssistantAppearanceContext, } from "./appearance-context.js";
 import { ToolViewRegistryContext } from "./tool-view-registry-context.js";
@@ -17,27 +18,24 @@ export function useAssistantSession() {
     }
     return value;
 }
-/** The tolerant read for components with a degraded no-session rendering
- *  (the composer's paperclip, an attachment's inline image) — outside the
- *  provider they hide the affordance instead of throwing, which is also
- *  what lets welcome-branch tests render the view bare. */
 export function useOptionalAssistantSession() {
     return useContext(AssistantSessionContext);
 }
-/**
- * Owns the visitor-token session and the identity handshake. Deliberately
- * no visitorToken, data, or agent props — the package speaks only the
- * public contract (each of those would be a dogfood escape hatch).
- */
-export function TeaflaskAssistantProvider({ publishableKey, baseUrl, getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, theme, mode, companionMark, suggestions, toolViews, children, }) {
+export function TeaflaskAssistantProvider({ publishableKey, baseUrl, userId, getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, theme, mode, companionMark, suggestions, toolViews, children, }) {
+    const identity = useNamedIdentity({ userId, getEndUserToken });
     const host = useHostCallbackRefs({
-        getEndUserToken,
+        getEndUserToken: identity?.getEndUserToken,
         actionsAdapter,
         onNavigate,
         onError,
         onTelemetry,
     });
-    const value = useSessionRegistration({ publishableKey, baseUrl, host });
+    const value = useSessionRegistration({
+        publishableKey,
+        baseUrl,
+        userId: identity?.userId,
+        host,
+    });
     const appearance = useAppearanceValue({
         theme,
         mode,
@@ -46,12 +44,18 @@ export function TeaflaskAssistantProvider({ publishableKey, baseUrl, getEndUserT
     });
     return (_jsx(AssistantSessionContext.Provider, { value: value, children: _jsx(AssistantAppearanceContext.Provider, { value: appearance, children: _jsx(ToolViewRegistryContext.Provider, { value: toolViews ?? null, children: _jsx(ConversationSurfacesProvider, { store: value.store, children: children }) }) }) }));
 }
-/** The host's callbacks behind identity-stable wrappers, so hosts that
- *  pass inline arrows never disturb the session or the store. */
+let warnedHalfSetPair = false;
+function useNamedIdentity(input) {
+    const halfSet = identityPairIsHalfSet(input);
+    useEffect(() => {
+        if (halfSet && !warnedHalfSetPair) {
+            warnedHalfSetPair = true;
+            console.warn(`[teaflask-assistant] ${IDENTITY_PAIR_WARNING}`);
+        }
+    }, [halfSet]);
+    return namedIdentityOf(input);
+}
 function useHostCallbackRefs({ getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, }) {
-    // Latest-callback refs keep the TokenSession identity stable across
-    // re-renders that only changed the closures (hosts often pass inline
-    // arrows). Updated in an effect per the hooks lint law.
     const getEndUserTokenRef = useRef(getEndUserToken);
     const actionsAdapterRef = useRef(actionsAdapter);
     const onNavigateRef = useRef(onNavigate);
@@ -79,9 +83,6 @@ function useHostCallbackRefs({ getEndUserToken, actionsAdapter, onNavigate, onEr
         onTelemetryRef.current?.(event);
     }, []);
     const telemetryProvided = onTelemetry !== undefined;
-    // What this page can execute, read fresh by the store at each execution
-    // pass — hosts re-wire navigation/actions across renders and the store's
-    // identity must not depend on theirs.
     const hostCapabilitiesRef = useRef({
         navigate: null,
         executeActionIntent: null,
@@ -106,25 +107,11 @@ function useHostCallbackRefs({ getEndUserToken, actionsAdapter, onNavigate, onEr
         hostCapabilitiesOf,
     };
 }
-/** Resolves the shared session entry, holds it retained for the mounted
- *  lifetime, and shapes the context value every surface reads. */
-function useSessionRegistration({ publishableKey, baseUrl, host, }) {
+function useSessionRegistration({ publishableKey, baseUrl, userId, host, }) {
     const { identityProvided, actionsProvided, navigationProvided, telemetryProvided, resolveEndUserToken, hostNavigate, executeActionIntent, reportError, recordTelemetry, hostCapabilitiesOf, } = host;
-    // The registry resolves the session's identity inputs to ONE shared
-    // TokenSession + store pair — same-identity providers, even in other
-    // React roots (two custom elements on one host page), converse through
-    // the same store. Render-safe: entryFor only constructs, never boots.
-    const entry = useMemo(() => assistantSessionRegistry.entryFor({
-        publishableKey,
-        baseUrl,
-        identityProvided,
-    }), [publishableKey, baseUrl, identityProvided]);
+    const entry = useMemo(() => assistantSessionRegistry.entryFor({ publishableKey, baseUrl, userId }), [publishableKey, baseUrl, userId]);
     const session = entry.session;
     const store = entry.store;
-    // This provider's wiring rides the entry for exactly the mounted
-    // lifetime: the first retain boots the store, the last release
-    // disposes store and session (the registry's ref-count replaces the
-    // per-provider dispose that lived here).
     useEffect(() => {
         const registrant = {
             resolveEndUserToken: identityProvided ? resolveEndUserToken : null,
@@ -142,9 +129,6 @@ function useSessionRegistration({ publishableKey, baseUrl, host, }) {
         telemetryProvided,
         recordTelemetry,
     ]);
-    // The mint's verdict lives on the entry, not in provider state: a
-    // provider mounting after the mint answered reads the cached verdict
-    // instead of waiting for a mint that already happened.
     const tier = useCell(entry.tier);
     const setupError = useCell(entry.setupError);
     return useMemo(() => ({
@@ -169,6 +153,9 @@ function useSessionRegistration({ publishableKey, baseUrl, host, }) {
         connectOpenRequested: entry.connectOpenRequested,
         requestSubscriptionConnect: entry.requestSubscriptionConnect,
         acknowledgeSubscriptionConnect: entry.acknowledgeSubscriptionConnect,
+        planNoticeDue: entry.planNoticeDue,
+        notePlanSignedIn: entry.notePlanSignedIn,
+        acknowledgePlanNotice: entry.acknowledgePlanNotice,
         reportError,
     }), [
         session,
@@ -185,19 +172,9 @@ function useSessionRegistration({ publishableKey, baseUrl, host, }) {
         reportError,
     ]);
 }
-/** A host's mark, or null for the package flask — the fall-through rule
- *  (core/host-fill.ts): the idiomatic `companionMark={flag && <Mark />}`
- *  gets the flask on its false arm; renderable emptiness is the host's
- *  deliberate content. Folded once, here, because CompanionMark branches
- *  on null. */
 function _companionMarkOf(companionMark) {
     return hostFillDeclines(companionMark) ? null : companionMark;
 }
-/** The theme and suggestions props travel by value, not identity: hosts
- *  write both as inline literals. Serializing once and keying the memo on
- *  the strings keeps those identities out of every dependency array here.
- *  The companion mark is the exception — a ReactNode has no value form,
- *  so it rides by identity, like toolViews. */
 function useAppearanceValue({ theme, mode, companionMark, suggestions, }) {
     const themeJson = theme === undefined ? null : JSON.stringify(theme);
     const suggestionsJson = suggestions === undefined ? null : JSON.stringify(suggestions);
@@ -218,13 +195,9 @@ function useAppearanceValue({ theme, mode, companionMark, suggestions, }) {
         };
     }, [themeJson, mode, companionMark, suggestionsJson]);
 }
-// The context value only exposes the executor when the adapter prop is
-// present, so an empty ref here is a package bug, not a host mistake —
-// but the narrowing must still be explicit for the lint laws.
 function _wiredAdapterOf(adapter) {
     if (adapter === undefined) {
         throw new Error("The actions adapter was removed while an action was executing.");
     }
     return adapter;
 }
-//# sourceMappingURL=teaflask-assistant-provider.js.map

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

@@ -1,29 +1,11 @@
 import { type AssistantCompanionProps } from "./assistant-companion.js";
 import { type TeaflaskAssistantProviderProps } from "./teaflask-assistant-provider.js";
 export interface TeaflaskAssistantHandle {
-    /**
-     * Opens the palette regardless of the hotkey setting — the imperative
-     * escape hatch for a host that disabled or rebound the chord. Call it
-     * through the ref's optional chain (`ref.current?.openPalette()`): the
-     * handle exists only while the root is mounted, so an early or late
-     * call no-ops instead of throwing. Opening the palette makes the
-     * companion yield (hide) until it closes — by design: the palette
-     * counts as an open assistant surface.
-     */
     openPalette: () => void;
 }
-export interface TeaflaskAssistantProps extends TeaflaskAssistantProviderProps {
-    /**
-     * The palette chord, "mod+k" by default (mod = ⌘ or Ctrl). Rebind with
-     * the same grammar ("mod+j", "ctrl+shift+p") when your app already
-     * spends ⌘K, or pass false to disable — the ref handle still opens the
-     * palette. An unrecognized spec disables the hotkey with a console
-     * warning rather than falling back: a host rebinding away from a
-     * conflict must never be silently rebound into it.
-     */
+export interface TeaflaskAssistantRootProps {
     hotkey?: string | false;
-    /** The viewport corner the companion (and its drawer) anchor to. */
     corner?: AssistantCompanionProps["corner"];
 }
+export type TeaflaskAssistantProps = TeaflaskAssistantProviderProps & TeaflaskAssistantRootProps;
 export declare const TeaflaskAssistant: import("react").ForwardRefExoticComponent<TeaflaskAssistantProps & import("react").RefAttributes<TeaflaskAssistantHandle>>;
-//# sourceMappingURL=teaflask-assistant.d.ts.map

package/dist/components/teaflask-assistant.js

@@ -5,9 +5,6 @@ import { DEFAULT_ASSISTANT_HOTKEY, hotkeyMatches, parseHotkey, } from "../core/h
 import { AssistantCompanion, } from "./assistant-companion.js";
 import { AssistantPalette } from "./assistant-palette.js";
 import { TeaflaskAssistantProvider, } from "./teaflask-assistant-provider.js";
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props. The ref
-// carries TeaflaskAssistantHandle (see its doc above).
 export const TeaflaskAssistant = forwardRef(function TeaflaskAssistant({ hotkey = DEFAULT_ASSISTANT_HOTKEY, corner, children, ...providerProps }, ref) {
     const [paletteOpen, setPaletteOpen] = useState(false);
     const openPalette = useCallback(() => {
@@ -24,18 +21,12 @@ export const TeaflaskAssistant = forwardRef(function TeaflaskAssistant({ hotkey
                 return;
             }
             if (event.repeat) {
-                // OS auto-repeat while the chord is held: one press is one
-                // toggle, not a flicker that lands wherever the key-up falls.
                 return;
             }
             if (event.defaultPrevented) {
-                // A host handler acted on this chord first — cooperate.
                 return;
             }
             event.preventDefault();
-            // A functional toggle: pure under StrictMode, always reads the
-            // committed truth, and keeps the subscription keyed on the binding
-            // alone.
             setPaletteOpen((open) => !open);
         };
         window.addEventListener("keydown", togglePaletteOnHotkey);
@@ -45,13 +36,7 @@ export const TeaflaskAssistant = forwardRef(function TeaflaskAssistant({ hotkey
     }, [binding]);
     return (_jsxs(TeaflaskAssistantProvider, { ...providerProps, children: [children, _jsx(AssistantCompanion, { corner: corner }), _jsx(AssistantPalette, { open: paletteOpen, onOpenChange: setPaletteOpen })] }));
 });
-// Bad specs warn once each, not once per render — a root re-rendering
-// sixty times a second must not flood the console with the same typo.
 const warnedHotkeySpecs = new Set();
-// The active binding, or null when the hotkey is off: disabled by the
-// host, or disabled by an unparseable spec (warn-then-degrade, the
-// companion loader's manner — never a silent fallback to the very chord
-// the host was rebinding away from).
 function _bindingOf(hotkey) {
     if (hotkey === false) {
         return null;
@@ -65,4 +50,3 @@ function _bindingOf(hotkey) {
     }
     return binding;
 }
-//# sourceMappingURL=teaflask-assistant.js.map

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

@@ -3,38 +3,14 @@ export interface ThreadGroup {
     label: string;
     threads: ServingAssistantThread[];
 }
-/**
- * History bucketed the way people remember it — by calendar day, not by
- * elapsed hours: a conversation from 11pm last night is "Yesterday" at
- * 8am even though it is nine hours old. Grouping is also why the rows
- * carry no timestamp of their own; the heading already said it, and a
- * right-aligned time would eat the title in a 280px rail.
- */
 export declare function groupThreadsByRecency(threads: readonly ServingAssistantThread[], now: Date): ThreadGroup[];
 interface ThreadHistoryProps {
     threads: ServingAssistantThread[];
     activeThreadId: string | null;
     onSelectThread: (thread: ServingAssistantThread) => void;
     onNewConversation: () => void;
-    /**
-     * Grows the rows to the 44px touch floor and the 15px step. The rail is
-     * leaned over with a mouse; the drawer is held at arm's length.
-     */
     touch?: boolean;
-    /**
-     * Whether the scroller owes the phone's home indicator its clearance.
-     * True for surfaces that run to the viewport's bottom edge (the page's
-     * history sheet); false for ones that end mid-panel (the companion
-     * drawer's history menu), where the env() inset would be dead padding.
-     */
     safeAreaBottom?: boolean;
 }
-/**
- * The history body: the one command, then the conversations under their
- * recency headings. Shared verbatim between the rail and the drawer —
- * they are the same list at two densities, and the day a phone's history
- * diverges from a desk's is the day one of them is wrong.
- */
 export declare function ThreadHistory({ threads, activeThreadId, onSelectThread, onNewConversation, touch, safeAreaBottom, }: ThreadHistoryProps): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=thread-list.d.ts.map

package/dist/components/thread-list.js

@@ -4,34 +4,12 @@ import { RECENT_WINDOW_DAYS, startOfLocalDayMs } from "../core/time-labels.js";
 import { ComposeIcon } from "./icons.js";
 import { TfButton } from "./primitives/button.js";
 import { cx } from "./primitives/cx.js";
-/**
- * History bucketed the way people remember it — by calendar day, not by
- * elapsed hours: a conversation from 11pm last night is "Yesterday" at
- * 8am even though it is nine hours old. Grouping is also why the rows
- * carry no timestamp of their own; the heading already said it, and a
- * right-aligned time would eat the title in a 280px rail.
- */
 export function groupThreadsByRecency(threads, now) {
-    // Each boundary is a local midnight of its own, counted back in
-    // CALENDAR days (startOfLocalDayMs — hoisted to core/time-labels so
-    // the user-bubble timestamps read this exact recency rule).
     const startOfDay = (daysBack) => startOfLocalDayMs(now, daysBack);
     const startOfToday = startOfDay(0);
     const startOfYesterday = startOfDay(1);
     const startOfRecentWindow = startOfDay(RECENT_WINDOW_DAYS);
     const buckets = new Map();
-    // Groups come out in the order their first thread arrives, so the sort
-    // decides the headings' order too. An unparseable stamp is therefore ranked
-    // rather than left to arithmetic: it sorts to the very top, which is where
-    // its "Today" bucket belongs.
-    //
-    // Compared, not subtracted, so the comparator is total. Ranking alone did
-    // not achieve that, whatever the older wording here claimed: two
-    // unparseable stamps both rank Infinity, and `Infinity - Infinity` is NaN.
-    // That particular NaN is in fact harmless — SortCompare coerces it to +0,
-    // and "equal" is the honest answer for two threads that are equally
-    // unrankable — but a comparator whose totality rests on a spec footnote is
-    // one refactor away from mattering.
     const ordered = [...threads].sort((a, b) => {
         const left = _rankOf(b);
         const right = _rankOf(a);
@@ -42,8 +20,6 @@ export function groupThreadsByRecency(threads, now) {
     });
     for (const thread of ordered) {
         const at = Date.parse(thread.updated_at);
-        // An unparseable or future stamp is described honestly rather than
-        // being filed under a day it did not happen.
         const label = Number.isNaN(at) || at >= startOfToday
             ? "Today"
             : at >= startOfYesterday
@@ -64,18 +40,10 @@ export function groupThreadsByRecency(threads, now) {
         threads: bucketed,
     }));
 }
-/** A thread's place on the timeline, as a number the comparator can always
- * subtract. A stamp that will not parse ranks above every real one. */
 function _rankOf(thread) {
     const at = Date.parse(thread.updated_at);
     return Number.isNaN(at) ? Number.POSITIVE_INFINITY : at;
 }
-/**
- * The history body: the one command, then the conversations under their
- * recency headings. Shared verbatim between the rail and the drawer —
- * they are the same list at two densities, and the day a phone's history
- * diverges from a desk's is the day one of them is wrong.
- */
 export function ThreadHistory({ threads, activeThreadId, onSelectThread, onNewConversation, touch = false, safeAreaBottom = true, }) {
     const groups = groupThreadsByRecency(threads, new Date());
     return (_jsxs("div", { className: "tf:flex tf:min-h-0 tf:flex-1 tf:flex-col", children: [_jsx("div", { className: "tf:shrink-0 tf:px-2 tf:pb-1", children: _jsxs(TfButton, { variant: touch ? "rowActionTouch" : "rowAction", onClick: onNewConversation, children: [_jsx(ComposeIcon, {}), "New conversation"] }) }), _jsx("div", { className: cx("tf:flex tf:min-h-0 tf:flex-1 tf:flex-col tf:overflow-y-auto tf:px-2", safeAreaBottom
@@ -84,10 +52,6 @@ export function ThreadHistory({ threads, activeThreadId, onSelectThread, onNewCo
                                         onSelectThread(thread);
                                     }, children: _jsx("span", { className: "tf:truncate", children: thread.title }) }) }, thread.id))) })] }, group.label)))) })] }));
 }
-// The house empty-state silhouette at rail scale: centred, a line that
-// names the state and a line that says what fills it. No action — the
-// only one there is sits 40px above this.
 function NoConversationsYet() {
     return (_jsxs("div", { className: "tf:my-auto tf:flex tf:flex-col tf:items-center tf:gap-1 tf:px-4 tf:py-6 tf:text-center", children: [_jsx("p", { className: "tf:text-tf-label tf:font-medium", children: "No conversations yet" }), _jsx("p", { className: "tf:text-tf-label tf:text-tf-muted-foreground", children: "Your chats show up here." })] }));
 }
-//# sourceMappingURL=thread-list.js.map

package/dist/components/tool-arguments-summary.d.ts

@@ -1,13 +1,2 @@
 import type { ToolViewProps } from "../core/tool-view.js";
-/**
- * The resolution ladder's rung 4 (tool-views.md): the package default
- * view, over the bounded argument reading below. An INPUT reading by
- * design — it ignores `result` entirely, so an unknown customer tool
- * never grows an inferred result card or a raw output dump (TVC-111).
- * Deterministic like the reading it wraps: two identical calls render
- * byte-identical output, with no clocks and no locale. Its one mount
- * site is the slot's terminal in the tool row's body, where it wears
- * the one card vocabulary every tool view paints with.
- */
 export declare function DefaultToolView(props: ToolViewProps): import("react").JSX.Element;
-//# sourceMappingURL=tool-arguments-summary.d.ts.map

package/dist/components/tool-arguments-summary.js

@@ -5,35 +5,10 @@ const MAX_VISIBLE_ROWS = 8;
 const LONG_TEXT_CHARS = 120;
 const TEXT_PREVIEW_CHARS = 320;
 const ARRAY_PREVIEW_ITEMS = 4;
-// The section chrome, hoisted so the list stays a greppable literal: the
-// tool-view card vocabulary (tool-views/parts-classes.ts) — a hairline
-// card, a "Request" caption, property rows — so the rung-4 reading is a
-// property card like every other view in the row body. No height floor:
-// the card grows to its rows and never scrolls the transcript twice.
 const SECTION_CLASSES = `tf:flex tf:flex-col ${CARD_CLASS}`;
-/**
- * The resolution ladder's rung 4 (tool-views.md): the package default
- * view, over the bounded argument reading below. An INPUT reading by
- * design — it ignores `result` entirely, so an unknown customer tool
- * never grows an inferred result card or a raw output dump (TVC-111).
- * Deterministic like the reading it wraps: two identical calls render
- * byte-identical output, with no clocks and no locale. Its one mount
- * site is the slot's terminal in the tool row's body, where it wears
- * the one card vocabulary every tool view paints with.
- */
 export function DefaultToolView(props) {
     return _jsx(ToolArgumentsSummary, { arguments: props.call.args });
 }
-/**
- * A deterministic, semantics-free reading of arbitrary tool arguments —
- * general-purpose input furniture (the DOM hooks below keep their
- * approval-card-era names because styles.css and the geometry spec
- * select them). It never chooses a domain component and never prints
- * raw JSON: records become bounded field rows, long strings become a
- * two-line excerpt, and opaque structures become honest type/count
- * summaries. Determinism is contract: Object.keys().sort() at both
- * levels, no clocks, and the one locale call pinned to "en-US".
- */
 function ToolArgumentsSummary({ arguments: toolArguments, }) {
     const rows = _summaryRowsOf(toolArguments);
     if (rows.length === 0) {
@@ -112,4 +87,3 @@ function _isScalar(value) {
 function _scalarTextOf(value) {
     return value === null ? "null" : String(value);
 }
-//# sourceMappingURL=tool-arguments-summary.js.map

package/dist/components/tool-call-rows.d.ts

@@ -4,9 +4,7 @@ import type { ToolRowSlot } from "./message-list-slots.js";
 export declare function ToolCallRows({ row, cards, inCurrentTurn, decisionSurfacesInShelf, toolRow, }: {
     row: ToolCallRow;
     cards: readonly ApprovalCardModel[];
-    /** The row-level hold window, forwarded to ToolRow. */
     inCurrentTurn?: boolean;
     decisionSurfacesInShelf?: boolean;
     toolRow?: ToolRowSlot;
 }): import("react").JSX.Element;
-//# sourceMappingURL=tool-call-rows.d.ts.map

package/dist/components/tool-call-rows.js

@@ -11,59 +11,22 @@ import { QuestionPanel } from "./question-panel.js";
 import { HostSlotBoundary, SlotOrDefault } from "./slot-boundary.js";
 import { SurfaceBoundary } from "./surface-boundary.js";
 import { ToolRow } from "./tool-row.js";
-// A HITL-gated call pauses the turn right here. In the shipping shelf
-// composition the actionable card lives in the suspension slot and this
-// row keeps the compact chronology: the "Needs input" pill while the
-// decision pends, then only the row's own state — no settled prose line
-// renders (no meta-receipt rows; the card's footer is the outcome's other
-// surface). Shelf-less hosts mount the cards inline beneath the row
-// (anchored via tool_call_id). An answered ask collapses further either
-// way: once its result carries a settled answer its tool view becomes the
-// Q&A record.
 export function ToolCallRows({ row, cards, inCurrentTurn = false, decisionSurfacesInShelf = false, toolRow, }) {
     const { cards: elicitationCards } = useContext(ElicitationsContext);
-    // Answers stay inspectable in the normal tool view. The durable
-    // result also suppresses the temporary inline question panel.
     const settledQuestions = settledQuestionsReceiptOf(row.toolName, row.argsText, row.result);
-    // Which decisions belong to THIS row: in the shelf composition the
-    // join keys on the RENDERED ROW (tool call id), never the marker-time
-    // `anchored` flag — after a page reload during a pause every card is
-    // a marker-time orphan (no TOOL_CALL_START replayed) while its call's
-    // row is right here, and its settled state must land on it, never
-    // silently vanish (approval-inbox.ts's own rule). The shelf-less mode
-    // keeps the historical anchored selection, which also decides card
-    // MOUNTING there.
     const anchoredApprovals = decisionSurfacesInShelf
         ? cards.filter((card) => card.toolCallId === row.toolCallId)
         : anchoredCardsFor(cards, row.toolCallId);
     const anchoredElicitations = decisionSurfacesInShelf
         ? elicitationCards.filter((card) => card.toolCallId === row.toolCallId)
         : anchoredElicitationsFor(elicitationCards, row.toolCallId);
-    // The row itself says it is the one waiting (state on the affected
-    // operation); answered and stale cards are receipts and mark nothing.
-    // The pill keeps the AWAITING spelling and deliberately does NOT share
-    // the hold's predicate: waiting ends with the decision, the hold with the turn.
     const awaitingInput = settledQuestions === null &&
         _awaitsMemberDecision(anchoredApprovals, anchoredElicitations);
     const stateWord = _mandatoryStateWordOf(row.state, awaitingInput);
-    // The row's hold arm (the durable re-derivation): the row model's
-    // decisionBearing — the replayed marker anchor — is the arm that
-    // survives the card stores' pruning (the gated call's
-    // result, RUN_ERROR, the turn's settle) and a reload; the live
-    // anchored cards are the complement for a REST-hydrated pause whose
-    // stream never ran and for fixture scenes that pose cards without
-    // histories. Never state: both arms are derivations.
     const decisionBearing = row.decisionBearing === true ||
         anchoredApprovals.length > 0 ||
         anchoredElicitations.length > 0;
-    // NOTE: no settled decision statements render here or anywhere else in
-    // the transcript (the meta-receipt rows, the audit-visibility lines among
-    // them, are deleted): a consent outcome's surfaces are the decision
-    // card's own footer and this row's state pill. Do not restore the prose
-    // lines as a bug fix.
     const view = _toolViewOf(row);
-    // Stored asks predate the registered question view. Upgrade their
-    // presentation without rewriting history or overriding an authored view.
     if (settledQuestions !== null && view.display?.view === undefined) {
         view.display = {
             ...view.display,
@@ -72,40 +35,12 @@ export function ToolCallRows({ row, cards, inCurrentTurn = false, decisionSurfac
         };
     }
     const packageToolRow = (_jsx(ToolRow, { view: view, awaitingInput: awaitingInput, decisionBearing: decisionBearing, inCurrentTurn: inCurrentTurn }));
-    return (_jsxs(_Fragment, { children: [toolRow === undefined ? (packageToolRow) : (_jsx(HostSlotBoundary, { slot: "toolRow", fallback: packageToolRow, children: _jsx(SlotOrDefault, { render: () => toolRow({ row, view, awaitingInput }), fallback: packageToolRow, 
-                    // Mandatory status (non-negotiable): a filled toolRow
-                    // cannot mute an error, an interruption, a refusal, a
-                    // member's denial, or a pending decision — package-rendered
-                    // beside the fill, a sibling the fill cannot reach. Keyed
-                    // on the fill having RENDERED, never on the prop being
-                    // supplied: on both fallback routes — a null return, a
-                    // throw — the package ToolRow's own state pill carries the
-                    // status, and this word beside it would make a screen
-                    // reader hear the state twice.
-                    filledAnnex: stateWord !== null ? (_jsx("span", { className: "tf:sr-only", "data-tf-tool-state": row.state, children: stateWord })) : undefined }) })), decisionSurfacesInShelf || settledQuestions !== null ? null : (_jsxs(_Fragment, { children: [anchoredApprovals.map((card) => (
-                    // Adjacency PLACES the banner under its call's row on this
-                    // shelf-less path; the banner reads only the card model.
-                    // Per-card boundary: a poisoned card degrades one banner.
-                    _jsx(SurfaceBoundary, { surface: "approval-card", children: _jsx(ApprovalCard, { card: card }) }, card.interruptId))), anchoredElicitations.map((card) => (_jsx(SurfaceBoundary, { surface: "question-panel", children: _jsx(QuestionPanel, { card: card }) }, card.interruptId)))] }))] }));
+    return (_jsxs(_Fragment, { children: [toolRow === undefined ? (packageToolRow) : (_jsx(HostSlotBoundary, { slot: "toolRow", fallback: packageToolRow, children: _jsx(SlotOrDefault, { render: () => toolRow({ row, view, awaitingInput }), fallback: packageToolRow, filledAnnex: stateWord !== null ? (_jsx("span", { className: "tf:sr-only", "data-tf-tool-state": row.state, children: stateWord })) : undefined }) })), decisionSurfacesInShelf || settledQuestions !== null ? null : (_jsxs(_Fragment, { children: [anchoredApprovals.map((card) => (_jsx(SurfaceBoundary, { surface: "approval-card", children: _jsx(ApprovalCard, { card: card }) }, card.interruptId))), anchoredElicitations.map((card) => (_jsx(SurfaceBoundary, { surface: "question-panel", children: _jsx(QuestionPanel, { card: card }) }, card.interruptId)))] }))] }));
 }
-/** The pending-decision judgement over one row's anchored cards. The
- *  SPELLING of "still waiting on the human" lives in ONE place
- *  (approvalAwaitsMember/elicitationAwaitsMember, core/suspension-queue.ts)
- *  because the row's "Needs input" pill (TVC-036) and the suspension
- *  queue must agree — and the fold's default openness
- *  (_groupAwaitsDecision, activity-rail.tsx) reads the same live
- *  pendency. The ROW's placement hold deliberately keys on ANCHORING,
- *  not awaiting (the decisionBearing derivation above): TVC-014's hold
- *  window is the turn, which outlives the pendency. */
 function _awaitsMemberDecision(anchoredApprovals, anchoredElicitations) {
     return (anchoredApprovals.some(approvalAwaitsMember) ||
         anchoredElicitations.some(elicitationAwaitsMember));
 }
-/** The frame's status word beside a host-filled toolRow — the same
- *  vocabulary the package pills wear (Failed; Not approved; Interrupted
- *  for cancelled and superseded alike; Declined; Needs input, TVC-036).
- *  Null for the quiet states: running and settled-clean carry no
- *  mandatory word. */
 function _mandatoryStateWordOf(state, awaitingInput) {
     if (state === "output-error") {
         return "Failed";
@@ -125,12 +60,6 @@ function _mandatoryStateWordOf(state, awaitingInput) {
     return null;
 }
 function _toolViewOf(row) {
-    // An offloaded call's "result" is the context offloader's model-facing
-    // replacement — retrieval guidance addressed to the model, storage
-    // reference lines — not the tool's output, so it is suppressed like the
-    // cancelled sentinel and the row renders the quiet shortened-result
-    // line instead. Errored and cancelled rows keep their existing stories:
-    // those states already suppress the output, and their panes win.
     const offloaded = row.offloaded &&
         row.errorText === undefined &&
         row.state !== "denied" &&
@@ -141,17 +70,7 @@ function _toolViewOf(row) {
         state: row.state,
         toolCallId: row.toolCallId,
         input: _prettyArgsOf(row.argsText),
-        // The raw argument text rides beside the pretty print: the
-        // presenter parses it into the tool-view call's `args`.
         argsText: row.argsText,
-        // A failed call shows its Error pane, not a Result pane. A cancelled
-        // call shows neither: its "result" is the model-facing cancellation
-        // text, and the row's own Interrupted pill carries the story (the
-        // meta-receipt rows beside it are deleted). A refused call likewise:
-        // the refusal envelope; the reason line carries the story. A denied
-        // call likewise: the same cancellation sentinel a cancel carries —
-        // the wire's stamp this state outranks — and the pill carries the
-        // story.
         output: row.errorText !== undefined ||
             row.state === "denied" ||
             row.state === "cancelled" ||
@@ -163,9 +82,6 @@ function _toolViewOf(row) {
         errorText: row.errorText,
         ...(row.refusalText !== undefined ? { refusalText: row.refusalText } : {}),
         display: row.display,
-        // The anchored schema REFERENCES ride through unwrapped: the
-        // presenter's identity law needs the same object per source, and the
-        // anchors map's first-wins merge already guarantees it.
         ...(row.schemas?.argsSchema !== undefined
             ? { argsSchema: row.schemas.argsSchema }
             : {}),
@@ -174,9 +90,6 @@ function _toolViewOf(row) {
             : {}),
     };
 }
-// The streamed arguments are JSON text, possibly mid-stream: parse when
-// whole (for the stable two-space print), pass through verbatim while
-// the tail is still arriving.
 function _prettyArgsOf(argsText) {
     if (argsText === "") {
         return "";
@@ -188,4 +101,3 @@ function _prettyArgsOf(argsText) {
         return argsText;
     }
 }
-//# sourceMappingURL=tool-call-rows.js.map

package/dist/components/tool-row.d.ts

@@ -1,21 +1,7 @@
 import { type ToolCallViewModel } from "../core/tool-call-display.js";
 export declare function ToolRow({ view, awaitingInput, decisionBearing, inCurrentTurn, }: {
     view: ToolCallViewModel;
-    /** True when a pending approval or elicitation is anchored to this
-     *  call — the card below owns the decision; the row says in text that
-     *  it is the one waiting (state on the affected operation, law 4). */
     awaitingInput?: boolean;
-    /** True when ANY approval or elicitation — pending or settled — is
-     *  anchored to this call: the decision arm of the placement hold, which
-     *  TVC-014 latches for the TURN, not the pendency (approving must not
-     *  snap the pane shut under the member's pointer). Derived from the
-     *  anchored cards, which replay rebuilds, so the latch is replay-identical. */
     decisionBearing?: boolean;
-    /** True while this row belongs to the transcript's current turn — no
-     *  user or subagent-delivery row follows it (the caller derives it
-     *  positionally, never from a clock). The hold window for the
-     *  open-on-arrival behaviour below; defaults to false so narrow
-     *  callers and receipts stay native-manual. */
     inCurrentTurn?: boolean;
 }): import("react").JSX.Element;
-//# sourceMappingURL=tool-row.d.ts.map