@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/tool-views/view-dom.d.ts

@@ -2,24 +2,32 @@ import type { ToolViewAdapter, ToolViewCall, ToolViewProps } from "../../core/to
 import { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS } from "./parts-classes.js";
 export { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS };
 export declare function el<K extends keyof HTMLElementTagNameMap>(tag: K, className: string, text?: string): HTMLElementTagNameMap[K];
-/** A labeled mono pane — one honest block of recorded text on the muted
- *  ground, flush with its container: standalone it sits on the row like
- *  the file-edit view's diff panes; inside a card the caller insets it
- *  (docs-search). Never a second border. */
+/**
+ * A labelled block of monospace text on a muted background, for raw text such
+ * as output or a diff.
+ */
 export declare function pane(label: string, text: string): HTMLElement;
-/** A command and its streams as one terminal block — `$ command`, then
- *  stdout, then stderr (quiet, never failure ink: stderr is routine). */
+/**
+ * A terminal-style block showing `$ command`, then its output, then stderr in a
+ * quieter tone. Pass `command: null` to show output only; empty parts are left
+ * out.
+ */
 export declare function terminal(options: {
     command: string | null;
     output?: string;
     stderr?: string;
 }): HTMLElement;
-/** A bounded, scrolling region for a long list inside a card. */
+/** The plain-DOM version of ToolViewScroll, holding the given elements. */
 export declare function scrollRegion(children: readonly HTMLElement[]): HTMLElement;
-/** The hairline card every built-in composes its content into. */
+/**
+ * The plain-DOM version of ToolViewCard, holding the given elements under an
+ * optional title.
+ */
 export declare function card(children: readonly HTMLElement[], title?: string): HTMLElement;
-/** One list row: an optional icon tile, a title line, a muted second
- *  line, and trailing content (a badge, a fact). */
+/**
+ * The plain-DOM version of ToolViewRow, without a link; `below` adds an element
+ * under the title and second line.
+ */
 export declare function listRow(options: {
     title: string;
     secondary?: string;
@@ -27,74 +35,73 @@ export declare function listRow(options: {
     icon?: Element;
     below?: HTMLElement;
 }): HTMLElement;
-/** Property rows: a muted label column and a value column. */
+/**
+ * The plain-DOM version of ToolViewFacts, from `[label, value]` pairs in order.
+ */
 export declare function factRows(facts: readonly (readonly [label: string, value: string | HTMLElement])[]): HTMLElement;
-/** A quiet caption row inside a card, with optional trailing content. */
+/**
+ * The plain-DOM version of ToolViewCaption, with optional trailing content on
+ * the right.
+ */
 export declare function captionRow(text: string, trailing?: HTMLElement | string): HTMLElement;
-/** A trailing badge on a list row — the vanilla twin of ToolViewBadge,
- *  for the wait on a built-in's proposal row. */
 export declare function badge(text: string): HTMLElement;
-/** Skeleton lines where the result will land — pending is a shape. */
+/** The plain-DOM version of ToolViewBones, with `count` skeleton lines. */
 export declare function boneRows(count: number): HTMLElement;
-/** One quiet sentence in the muted register — for what is absent,
- *  degraded, or not renderable, never for invented structure. */
+/** The plain-DOM version of ToolViewNote. */
 export declare function note(text: string): HTMLElement;
+/**
+ * Returns the value if it is a plain object (not null and not an array), else
+ * null. Handy for reading `call.args` or `call.result` safely.
+ */
 export declare function recordOf(value: unknown): Record<string, unknown> | null;
 export declare function stringOf(value: unknown): string | null;
+export declare function statelessToolView(render: (props: ToolViewProps) => HTMLElement): ToolViewAdapter;
 /**
- * The lifecycle factory every built-in rides: `render` is a pure
- * function of the props, so a full re-render IS the contract's
- * update-in-place — the state the update law protects is state these
- * views deliberately don't hold. A throw from `render` propagates as
- * the adapter's one failure channel and the slot advances a rung.
+ * True when the call finished successfully and its own result is available
+ * (status "output-available" and not offloaded). Check it before drawing a
+ * result.
  */
-export declare function statelessToolView(render: (props: ToolViewProps) => HTMLElement): ToolViewAdapter;
-/** True when the call settled cleanly with its own recorded output —
- *  the only state in which a built-in may draw a result shape. */
 export declare function settledWithResult(call: ToolViewCall): boolean;
 /**
- * The honesty ladder every built-in applies before any success shape:
- * a call that didn't finish cleanly never wears success furniture, and
- * a result the transcript doesn't hold is said to be missing, never
- * invented. The row narrates these states with richer copy of its own
- * (the pill, the refusal reason, the error pane).
- *
- * REACHABILITY, recorded (re-derived from this function's own switch):
- * the refused, output-error, denied, cancelled, superseded and offloaded
- * arms are REACHABLE in production — tool-row no longer gates output, so
- * a view mounts for the call's whole lifecycle while the view model
- * withholds output on exactly these settles. A still-RUNNING call
- * renders none of them: input-streaming and input-available break out to
- * the empty list below. That is the difference from the action view's
- * deleted ok:false arm, which needed output-available PLUS a failure
- * envelope — a pairing the producers can never emit under any gating.
+ * The same as settledOutcomeNoteOf, as a list of zero or one note elements
+ * ready to append in a plain-DOM view.
  */
 export declare function settledOutcomeNotesOf(call: ToolViewCall): HTMLElement[];
-/** The same honesty ladder as one sentence, for React hosts that render
- *  text rather than package DOM — the vocabulary exists once. */
+/**
+ * A short sentence for a call that ended without a usable result (failed,
+ * declined, not approved, didn't run, interrupted, or result replaced by a
+ * preview). Null while the call is running or when it finished normally.
+ */
 export declare function settledOutcomeNoteOf(call: ToolViewCall): string | null;
-/** An action call's recorded response: the http_intent success envelope
- *  `{"ok": true, "result": {status, body, truncated}}` that
- *  tool_return_of (toolresultv1.py) serializes whole into resultText.
- *  The core unwrapper hands `call.result` the BODY alone, so the HTTP
- *  status is recoverable only here. Null for anything that is not
- *  exactly this envelope (ok:false shapes included) — a view then says
- *  so, never guesses. Authored knowledge of our own tool's format,
- *  exported so hosts re-use it instead of respelling the parse. */
+/** An action's recorded HTTP response, as read by actionEnvelopeOf. */
 export interface ActionEnvelope {
+    /** The HTTP status code your API returned, or null if none was recorded. */
     status: number | null;
+    /** Your API's response body as recorded. */
     body: unknown;
+    /**
+     * True when the body was cut to fit a size limit, so it is not complete.
+     */
     truncated: boolean;
 }
+/**
+ * Reads an action call's `resultText` into your API's HTTP status, response
+ * body and whether the body was cut short. Returns null when the text is not an
+ * action's successful result.
+ */
 export declare function actionEnvelopeOf(resultText: string | undefined): ActionEnvelope | null;
-/** A failed action call's recorded reason: the failure envelope
- *  `{"ok": false, "error": {code, message, detail?}, instruction}` that
- *  tool_return_of serializes into the call's error text. `detail` is the
- *  API's own account when the adapter's error carried one
- *  (execution-kinds.ts ExecutionFailureDetail). Null for any other text
- *  — the row's own error pane still shows the raw reason. */
+/** A failed action's reason, as read by actionFailureOf. */
 export interface ActionFailure {
+    /**
+     * The failure sentence as recorded, including wording meant for the agent.
+     * Use humanFailureSentenceOf to show it to a user.
+     */
     message: string;
+    /**
+     * The HTTP status, your API's error code and its per-field problems (`path`
+     * and `message`, in the API's order) when the failure named them, else
+     * null. `fieldsOmitted` counts further problems left out of `fields`.
+     */
     detail: {
         status: number;
         code: string;
@@ -102,22 +109,19 @@ export interface ActionFailure {
             path: string;
             message: string;
         }[];
-        /** Problems the API named beyond `fields` — the producer's cap or
-         *  door fit dropped them from the tail (execution-handlers.ts);
-         *  present only when positive, so a partial list never reads whole. */
         fieldsOmitted?: number;
     } | null;
 }
+/**
+ * Reads a failed action call's `errorText` into its message plus, when the
+ * failure named them, the HTTP status, error code and per-field problems.
+ * Returns null when there is no error text or it is not a failure.
+ */
 export declare function actionFailureOf(errorText: string | undefined): ActionFailure | null;
-/** The member-facing sentence of a recorded failure: the failure
- *  envelope's message with its model-facing parts removed — the
- *  "HTTP 422 CODE — " prefix, the "Field problems: …" clause and the
- *  "Do not assume …" tail — or the error text itself when it is not the
- *  envelope. The status, code and fields stay machine facts a view reads
- *  through actionFailureOf; a row never prints wire vocabulary at a
- *  member. */
+/**
+ * Turns a call's `errorText` into a sentence fit to show the user, removing the
+ * HTTP status and code, the field problems and the instructions meant for the
+ * agent. Text that is not an action failure comes back unchanged.
+ */
 export declare function humanFailureSentenceOf(errorText: string): string;
-/** A document glyph for a row's icon tile (the package's file mark, as
- *  an inline SVG so vanilla built-ins carry no icon dependency). */
 export declare function fileGlyph(): SVGElement;
-//# sourceMappingURL=view-dom.d.ts.map

package/dist/components/tool-views/view-dom.js

@@ -1,13 +1,3 @@
-// Shared DOM vocabulary for the package's built-in tool views (rung 3,
-// tool-views.md). Vanilla imperative adapters on purpose: the frozen
-// registration table lives in core/tool-view.ts, which is
-// runtime-React-free by design, and these views hold no local UI state
-// — the canonical mount/update/destroy adapter costs nothing and keeps
-// React out of the core closure. The directory is load-bearing: the
-// Tailwind source scan is `@source "../components"` (styles.css), so
-// utility classes referenced outside src/components are never emitted.
-// The class strings are parts-classes.ts — the same vocabulary the React
-// parts (parts.tsx) hand to host views, so ours and theirs are one look.
 import { BADGE_CLASS, BONES_CLASS, BONE_CLASS, CAPTION_ROW_CLASS, CARD_CLASS, CARD_TITLE_CLASS, FACT_LABEL_CLASS, FACT_LIST_CLASS, FACT_ROW_CLASS, FACT_VALUE_CLASS, LABEL_CLASS, NOTE_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS, ROW_CLASS, ROW_ICON_CLASS, ROW_SECONDARY_CLASS, ROW_TEXT_CLASS, ROW_TITLE_CLASS, ROW_TRAIL_CLASS, SCROLL_REGION_CLASS, TERMINAL_CLASS, TERMINAL_OUTPUT_CLASS, TERMINAL_PROMPT_CLASS, TERMINAL_STDERR_CLASS, } from "./parts-classes.js";
 export { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS };
 export function el(tag, className, text) {
@@ -20,10 +10,6 @@ export function el(tag, className, text) {
     }
     return node;
 }
-/** A labeled mono pane — one honest block of recorded text on the muted
- *  ground, flush with its container: standalone it sits on the row like
- *  the file-edit view's diff panes; inside a card the caller insets it
- *  (docs-search). Never a second border. */
 export function pane(label, text) {
     const wrapper = el("div", PANE_WRAPPER_CLASS);
     wrapper.append(el("p", LABEL_CLASS, label));
@@ -32,8 +18,6 @@ export function pane(label, text) {
     wrapper.append(pre);
     return wrapper;
 }
-/** A command and its streams as one terminal block — `$ command`, then
- *  stdout, then stderr (quiet, never failure ink: stderr is routine). */
 export function terminal(options) {
     const block = el("pre", TERMINAL_CLASS);
     block.dataset.tfTerminal = "";
@@ -56,14 +40,12 @@ export function terminal(options) {
     }
     return block;
 }
-/** A bounded, scrolling region for a long list inside a card. */
 export function scrollRegion(children) {
     const region = el("div", SCROLL_REGION_CLASS);
     region.dataset.tfScrollRegion = "";
     region.append(...children);
     return region;
 }
-/** The hairline card every built-in composes its content into. */
 export function card(children, title) {
     const wrapper = el("div", "");
     if (title !== undefined) {
@@ -75,8 +57,6 @@ export function card(children, title) {
     wrapper.append(body);
     return wrapper;
 }
-/** One list row: an optional icon tile, a title line, a muted second
- *  line, and trailing content (a badge, a fact). */
 export function listRow(options) {
     const row = el("div", ROW_CLASS);
     if (options.icon !== undefined) {
@@ -100,7 +80,6 @@ export function listRow(options) {
     }
     return row;
 }
-/** Property rows: a muted label column and a value column. */
 export function factRows(facts) {
     const list = el("dl", FACT_LIST_CLASS);
     for (const [label, value] of facts) {
@@ -113,7 +92,6 @@ export function factRows(facts) {
     }
     return list;
 }
-/** A quiet caption row inside a card, with optional trailing content. */
 export function captionRow(text, trailing) {
     const row = el("div", CAPTION_ROW_CLASS);
     row.append(el("span", "tf:min-w-0", text));
@@ -124,12 +102,9 @@ export function captionRow(text, trailing) {
     }
     return row;
 }
-/** A trailing badge on a list row — the vanilla twin of ToolViewBadge,
- *  for the wait on a built-in's proposal row. */
 export function badge(text) {
     return el("span", BADGE_CLASS, text);
 }
-/** Skeleton lines where the result will land — pending is a shape. */
 export function boneRows(count) {
     const wrapper = el("div", BONES_CLASS);
     wrapper.setAttribute("aria-hidden", "true");
@@ -138,8 +113,6 @@ export function boneRows(count) {
     }
     return wrapper;
 }
-/** One quiet sentence in the muted register — for what is absent,
- *  degraded, or not renderable, never for invented structure. */
 export function note(text) {
     return el("p", NOTE_CLASS, text);
 }
@@ -151,13 +124,6 @@ export function recordOf(value) {
 export function stringOf(value) {
     return typeof value === "string" ? value : null;
 }
-/**
- * The lifecycle factory every built-in rides: `render` is a pure
- * function of the props, so a full re-render IS the contract's
- * update-in-place — the state the update law protects is state these
- * views deliberately don't hold. A throw from `render` propagates as
- * the adapter's one failure channel and the slot advances a rung.
- */
 export function statelessToolView(render) {
     return {
         mount(container, props) {
@@ -173,34 +139,13 @@ export function statelessToolView(render) {
         },
     };
 }
-/** True when the call settled cleanly with its own recorded output —
- *  the only state in which a built-in may draw a result shape. */
 export function settledWithResult(call) {
     return call.status === "output-available" && call.offloaded !== true;
 }
-/**
- * The honesty ladder every built-in applies before any success shape:
- * a call that didn't finish cleanly never wears success furniture, and
- * a result the transcript doesn't hold is said to be missing, never
- * invented. The row narrates these states with richer copy of its own
- * (the pill, the refusal reason, the error pane).
- *
- * REACHABILITY, recorded (re-derived from this function's own switch):
- * the refused, output-error, denied, cancelled, superseded and offloaded
- * arms are REACHABLE in production — tool-row no longer gates output, so
- * a view mounts for the call's whole lifecycle while the view model
- * withholds output on exactly these settles. A still-RUNNING call
- * renders none of them: input-streaming and input-available break out to
- * the empty list below. That is the difference from the action view's
- * deleted ok:false arm, which needed output-available PLUS a failure
- * envelope — a pairing the producers can never emit under any gating.
- */
 export function settledOutcomeNotesOf(call) {
     const sentence = settledOutcomeNoteOf(call);
     return sentence === null ? [] : [note(sentence)];
 }
-/** The same honesty ladder as one sentence, for React hosts that render
- *  text rather than package DOM — the vocabulary exists once. */
 export function settledOutcomeNoteOf(call) {
     switch (call.status) {
         case "refused":
@@ -257,8 +202,6 @@ export function actionFailureOf(errorText) {
         parsed = JSON.parse(errorText);
     }
     catch {
-        // The transcript's error channel carries the SENTENCE alone (the
-        // mapper keeps error.message): the facts ride in its words.
         return { message: errorText, detail: _failureDetailInSentence(errorText) };
     }
     const envelope = recordOf(parsed);
@@ -276,19 +219,10 @@ export function actionFailureOf(errorText) {
             _failureDetailInSentence(message),
     };
 }
-/** The failure sentence's grammar, exactly as execution-handlers.ts
- *  writes it: after the frame's own words, a three-digit status (the
- *  producer admits 100–599 and nothing else) and a whitespace-free code
- *  (any casing or punctuation the API spells) before the dash; then the field clause — each path and message a JSON string
- *  literal, `"path": "message"` or a bare `"message"`, joined by "; " —
- *  closed by the model-facing tail. A clause that does not tokenize to
- *  the end is not the producer's and yields no fields, never a guess. */
 const SENTENCE_STATUS = / failed in this page: HTTP (\d{3}) (\S{1,80}) — /;
 const FIELDS_CLAUSE_OPEN = "Field problems: ";
 const FIELDS_CLAUSE_CLOSE = ". Do not assume";
 const JSON_STRING_LITERAL = /^"(?:[^"\\]|\\.)*"/;
-/** The status, code and field problems as the failure sentence spells
- *  them (execution-handlers.ts) — null when the sentence names none. */
 function _failureDetailInSentence(sentence) {
     const status = SENTENCE_STATUS.exec(sentence);
     if (status === null) {
@@ -351,8 +285,6 @@ function _fieldsInClauseOf(sentence) {
 function _jsonStringAt(text, at) {
     return JSON_STRING_LITERAL.exec(text.slice(at))?.[0] ?? null;
 }
-/** A literal the producer never writes (a raw control character inside
- *  the quotes) decodes to nothing rather than throwing. */
 function _decodedStringOf(literal) {
     try {
         const decoded = JSON.parse(literal);
@@ -392,13 +324,6 @@ function _failureDetailRecordOf(value) {
             : {}),
     };
 }
-/** The member-facing sentence of a recorded failure: the failure
- *  envelope's message with its model-facing parts removed — the
- *  "HTTP 422 CODE — " prefix, the "Field problems: …" clause and the
- *  "Do not assume …" tail — or the error text itself when it is not the
- *  envelope. The status, code and fields stay machine facts a view reads
- *  through actionFailureOf; a row never prints wire vocabulary at a
- *  member. */
 export function humanFailureSentenceOf(errorText) {
     const failure = actionFailureOf(errorText);
     const sentence = failure === null ? errorText : failure.message;
@@ -410,8 +335,6 @@ function _beforeMarker(text, marker) {
     const at = text.indexOf(marker);
     return at === -1 ? text : text.slice(0, at);
 }
-/** A document glyph for a row's icon tile (the package's file mark, as
- *  an inline SVG so vanilla built-ins carry no icon dependency). */
 export function fileGlyph() {
     const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
     svg.setAttribute("viewBox", "0 0 24 24");
@@ -435,4 +358,3 @@ export function fileGlyph() {
     }
     return svg;
 }
-//# sourceMappingURL=view-dom.js.map

package/dist/components/transcript.js

@@ -18,65 +18,21 @@ import { useCell } from "./use-store-cell.js";
 import { useThreadDispatches } from "./use-thread-dispatches.js";
 import { useConversation } from "./conversation-context.js";
 import { useTranscript } from "./use-transcript.js";
-/** The streamed conversation, drawn entirely from the store's cells (the
- *  message list, marker anchors and approval cards ride their recorders);
- *  the store is the only connection driver. Mounting registers this
- *  surface's transcript lease — what guarantees the epoch connects once,
- *  so history paints by full replay; unmounting mid-turn changes nothing,
- *  because the store's own run keeps streaming. Any number may render
- *  concurrently. */
 export function Transcript({ surface }) {
     const { session, store } = useAssistantSession();
     const { pendingSend } = useConversation();
     const connection = useCell(store.connection);
     const { approvalCards, approvalSurface, elicitationSurface } = useDecisionSurfaces(store);
-    // The cells-to-rows derivation lives in useTranscript, public on ./headless.
-    const { rows, displayRows, running, turnOpen, decisionsPending, activity } = useTranscript({ surface });
-    // The decision join: where each pausable call sits in the projected
-    // transcript, for the suspension queue's deterministic order — order
-    // is ALL the tenant needs from the transcript.
+    const { displayRows, running, turnOpen, decisionsPending, activity } = useTranscript({ surface });
     const rowIndexByToolCallId = useMemo(() => _rowIndexByToolCallIdOf(displayRows), [displayRows]);
-    // The dispatch ledger join: a delegated child may settle after its turn
-    // ends, freezing its wire receipt at running — the thread's ledger rows,
-    // polled only while any coworker is unsettled, are the truth.
-    const dispatches = useThreadDispatches(session, connection?.threadId ?? null, rows, 
-    // The settle relay: an observed settle's wake may have opened a
-    // delivery turn — the store probes for it and attaches.
-    store.noteDispatchSettled, 
-    // The pause relay: a coworker read paused has a request on its
-    // dispatching turn's snapshot — the store re-reads and the
-    // execution driver carries it.
-    store.noteDispatchPaused);
+    const dispatches = useThreadDispatches(session, connection?.threadId ?? null);
     const dispatchesJoin = useMemo(() => ({ byOrdinal: dispatches }), [dispatches]);
     const coworkerWork = useCell(store.coworkerWork);
     if (connection === null) {
         return null;
     }
-    return (_jsx(ApprovalsContext.Provider, { value: approvalSurface, children: _jsx(ElicitationsContext.Provider, { value: elicitationSurface, children: _jsxs(SubagentDelegationSurface, { dispatches: dispatches, threadId: connection.threadId, children: [_jsx(SubagentDispatchesContext.Provider, { value: dispatchesJoin, children: _jsx(SubagentExecutionWorkContext.Provider, { value: coworkerWork, children: _jsx(SurfaceBoundary, { surface: "message-list", children: _jsx(AssistantTranscript, { rows: displayRows, cards: approvalCards, 
-                                    // pendingSend joins the liveness from the instant of send:
-                                    // `running` reads newestTurnStatus, which stays null until
-                                    // the send POST returns. NOT fed into useTranscript's
-                                    // `running`, which would re-mark the prior turn's settled
-                                    // answer as streaming.
-                                    live: running || pendingSend, turnOpen: turnOpen, 
-                                    // The actionable surfaces live on the shelf: rows keep the
-                                    // compact chronology; a settled decision renders no
-                                    // transcript line — the meta-receipt rows are gone. No pause
-                                    // flag: the pause itself neither claims "Working…" nor holds
-                                    // a fold open — the anchored decision does the holding (the
-                                    // decision arm); a decision-less pause is the machine's
-                                    // time.
-                                    decisionSurfacesInShelf: true }) }) }) }), _jsx(SurfaceBoundary, { surface: "status-announcer", degrade: "silent", children: _jsx(RunStatusAnnouncer, { status: activity.newestTurnStatus, 
-                            // The same predicate the fold's liveness reads:
-                            // one fact, every carrier in agreement.
-                            decisionsPending: decisionsPending }) }), _jsxs("div", { "data-tf-composer-anchor": "", className: "tf:relative", children: [_jsx(SurfaceBoundary, { surface: "activity-overlay", children: _jsx(ComposerActivityOverlay, { activity: _jsx(SubagentCountPill, { dispatches: dispatches, threadId: connection.threadId }) }) }), _jsx(SurfaceBoundary, { surface: "activity-shelf", children: _jsx(ActivityShelf, { suspension: 
-                                    // shelfItem: when the boundary replaces the tenant, the fallback
-                                    // card IS the tenant and must carry data-tf-shelf-item (the landlord contract).
-                                    _jsx(SurfaceBoundary, { surface: "decisions", shelfItem: true, children: _jsx(SuspensionSurfaces, { rowIndexByToolCallId: rowIndexByToolCallId }) }) }) }), _jsx(Composer, { surface: surface })] })] }) }) }));
+    return (_jsx(ApprovalsContext.Provider, { value: approvalSurface, children: _jsx(ElicitationsContext.Provider, { value: elicitationSurface, children: _jsxs(SubagentDelegationSurface, { dispatches: dispatches, threadId: connection.threadId, children: [_jsx(SubagentDispatchesContext.Provider, { value: dispatchesJoin, children: _jsx(SubagentExecutionWorkContext.Provider, { value: coworkerWork, children: _jsx(SurfaceBoundary, { surface: "message-list", children: _jsx(AssistantTranscript, { rows: displayRows, cards: approvalCards, live: running || pendingSend, turnOpen: turnOpen, decisionSurfacesInShelf: true }) }) }) }), _jsx(SurfaceBoundary, { surface: "status-announcer", degrade: "silent", children: _jsx(RunStatusAnnouncer, { status: activity.newestTurnStatus, decisionsPending: decisionsPending }) }), _jsxs("div", { "data-tf-composer-anchor": "", className: "tf:relative", children: [_jsx(SurfaceBoundary, { surface: "activity-overlay", children: _jsx(ComposerActivityOverlay, { activity: _jsx(SubagentCountPill, { dispatches: dispatches, threadId: connection.threadId }) }) }), _jsx(SurfaceBoundary, { surface: "activity-shelf", children: _jsx(ActivityShelf, { suspension: _jsx(SurfaceBoundary, { surface: "decisions", shelfItem: true, children: _jsx(SuspensionSurfaces, { rowIndexByToolCallId: rowIndexByToolCallId }) }) }) }), _jsx(Composer, { surface: surface })] })] }) }) }));
 }
-/** The two decision seams the transcript provides — approvals and
- *  elicitations — each as the store's cards beside the store's submit
- *  methods. */
 function useDecisionSurfaces(store) {
     const approvalCards = useCell(store.approvals);
     const approvalSurface = useMemo(() => ({
@@ -101,4 +57,3 @@ function _rowIndexByToolCallIdOf(displayRows) {
     });
     return indexByToolCallId;
 }
-//# sourceMappingURL=transcript.js.map

package/dist/components/use-answer-list-fold.js

@@ -1,8 +1,5 @@
 "use client";
 import { useCallback, useEffect, useRef, useState, } from "react";
-// The fold cue: the answer list is the panel's one scroller under the
-// well's height budget, so it declares when rows sit below the fold
-// (the Scroll-Well Rule) — re-measured on scroll and on content growth.
 export function useAnswerListFold(cursor, openDescription, customText) {
     const [foldBelow, setFoldBelow] = useState(false);
     const answersRef = useRef(null);
@@ -32,4 +29,3 @@ export function useAnswerListFold(cursor, openDescription, customText) {
     }, [declareFold, cursor, openDescription, customText]);
     return { answersRef, foldBelow, declareFold };
 }
-//# sourceMappingURL=use-answer-list-fold.js.map

package/dist/components/use-assistant-activity.d.ts

@@ -1,11 +1,7 @@
 import type { AssistantActivitySnapshot } from "../core/activity.js";
 /**
- * The read-only activity feed of the shared conversation core: enough to
- * render presence — a busy pulse, a pending-approval badge, the last
- * result — without mounting (or bundling) the transcript. Any component
- * under <TeaflaskAssistantProvider> may subscribe; the feed reads the
- * same store every chrome writes through, so a turn started in the page
- * pulses here too.
+ * Returns a live summary of the assistant's state for badges or presence
+ * indicators elsewhere in your UI, updating as the conversation changes on any
+ * surface. Call it inside the provider or `TeaflaskAssistant`.
  */
 export declare function useAssistantActivity(): AssistantActivitySnapshot;
-//# sourceMappingURL=use-assistant-activity.d.ts.map

package/dist/components/use-assistant-activity.js

@@ -1,16 +1,7 @@
 "use client";
 import { useAssistantSession } from "./teaflask-assistant-provider.js";
 import { useCell } from "./use-store-cell.js";
-/**
- * The read-only activity feed of the shared conversation core: enough to
- * render presence — a busy pulse, a pending-approval badge, the last
- * result — without mounting (or bundling) the transcript. Any component
- * under <TeaflaskAssistantProvider> may subscribe; the feed reads the
- * same store every chrome writes through, so a turn started in the page
- * pulses here too.
- */
 export function useAssistantActivity() {
     const { store } = useAssistantSession();
     return useCell(store.activity);
 }
-//# sourceMappingURL=use-assistant-activity.js.map