@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/assistant-palette.js

@@ -6,34 +6,15 @@ import { LazyBody } from "./lazy-body.js";
 import { SurfaceBoundary } from "./surface-boundary.js";
 import { TfDialog } from "./primitives/dialog.js";
 import { useRegisterAssistantSurface } from "./use-register-assistant-surface.js";
-// The body is code-split behind the first open, so mounting a closed
-// palette on every page ships no transcript (the bundle discipline).
 const AssistantPaletteBody = lazy(() => import("./assistant-palette-body.js"));
-/**
- * The cmd-k overlay surface: the same conversation core as <AssistantPage/>
- * in a native-dialog shell — current/new thread only. Controlled: whoever
- * mounts it owns the trigger and open state; Esc and a backdrop click close
- * it from inside. Closing drops the live stream on purpose: reopening
- * remounts the transcript and the full replay-then-tail restores it exactly.
- * The export is the boundary; degrade="silent" because an in-flow fallback
- * card would land as a stray block on the host page.
- */
 export function AssistantPalette(props) {
     return (_jsx(SurfaceBoundary, { surface: "palette", degrade: "silent", children: _jsx(AssistantPaletteInner, { ...props }) }));
 }
 function AssistantPaletteInner({ open, onOpenChange }) {
-    // The provider's theme/mode props ride onto every data-tf-assistant root.
     const { rootProps } = useAssistantAppearance();
-    // Announced only while open: the dialog root stays mounted while closed
-    // (rendering nothing), and a closed palette must not read as an active surface.
     useRegisterAssistantSurface("transient", open);
-    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "aria-label": "Assistant", "data-tf-assistant": "", "data-tf-glass": "", "data-tf-assistant-palette": "", ...rootProps, className: 
-        // Mobile: a near-full-screen sheet with a 4-step margin. Desktop: the
-        // cmd-k idiom — top-anchored, centered, fixed height. The scrim is 20%,
-        // not a classic 40%: the glass blurs its own backdrop; a heavy dim curdles it.
-        "tf:m-auto tf:h-[calc(100dvh-2rem)] tf:w-[calc(100vw-2rem)] tf:flex-col " +
+    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "aria-label": "Assistant", "data-tf-assistant": "", "data-tf-glass": "", "data-tf-assistant-palette": "", ...rootProps, className: "tf:m-auto tf:h-[calc(100dvh-2rem)] tf:w-[calc(100vw-2rem)] tf:flex-col " +
             "tf:overflow-hidden tf:rounded-tf tf:border " +
             "tf:text-tf-foreground tf:backdrop:bg-black/20 " +
             "tf:sm:mt-24 tf:sm:h-[calc(100dvh-12rem)] tf:sm:max-h-144 tf:sm:w-full tf:sm:max-w-2xl", children: open ? (_jsx(LazyBody, { children: _jsx(AssistantPaletteBody, { onOpenChange: onOpenChange }) })) : null }));
 }
-//# sourceMappingURL=assistant-palette.js.map

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

@@ -5,76 +5,21 @@ import { type MarkerBoundaries, type TranscriptRow } from "../core/transcript-ro
 import type { TurnAttachment } from "../contract/threads.js";
 import { type MessageViewSlot, type ToolRowSlot, type TranscriptMarkerProps } from "./message-list.js";
 interface TranscriptSlotProps {
-    /** Styles the library's scroll element (a height-capped host puts its
-     *  max-h here — see MessageList's prop). */
     scrollClassName?: string;
-    /** The host row fill — content only; the package keeps each row's
-     *  frame. Returning null/undefined falls through to the package
-     *  rendering per row. */
     messageView?: MessageViewSlot;
-    /** The host tool-row fill — replaces exactly the package ToolRow;
-     *  receipt collapse, decision surfaces, and the frame's status word
-     *  stay package-owned outside it. */
     toolRow?: ToolRowSlot;
-    /** In-flow input region under the scroll viewport (a composer).
-     *  Unfilled renders nothing: watch-only is the honest default (the
-     *  package Composer needs the session store an agent-mode host lacks;
-     *  the store binder composes its chrome as siblings). THE INPUT-REGION RULE:
-     *  this slot mounts its fill WITHOUT an error boundary — the input
-     *  region is the surface's ability to act, and a null-fallback latch
-     *  would turn a crash into a paused run that looks idle and cannot be
-     *  answered. A throw propagates to the host's own boundary on EVERY
-     *  binder, enforced at this one seam. The other four slots keep their
-     *  latching boundaries. */
     input?: ReactNode;
-    /** Rendered in place of the row list when the log is genuinely empty.
-     *  Agent mode withholds it until the first snapshot arrives: a settled
-     *  run's fallback states a fact ("recorded no activity"), and stating
-     *  it during the connect window would be a falsehood every mount
-     *  flashes. Unfilled renders nothing — the package's own welcome
-     *  surfaces live a level up (conversation-view), which never mounts a
-     *  transcript while empty. */
     welcomeScreen?: ReactNode;
-    /** Chrome beside the transcript, above the scroll viewport — never a
-     *  row source. Unfilled renders nothing. DELIBERATELY UNCONSUMED: the
-     *  slot is part of the surface's contract and ships with its filled
-     *  and unfilled tests; the package's ThreadHistory is the intended
-     *  filler. Not scaffolding to delete. */
     threadList?: ReactNode;
 }
 export interface AgentTranscriptSource extends TranscriptSlotProps {
     agent: AbstractAgent;
-    /** The stream's failure tap (pre-stream failures, verify errors, and
-     *  RUN_ERROR terminals — including replayed historical ones; the hosts
-     *  absorb those). */
     onStreamError: (error: Error) => void;
-    /** Module-level composite of the host's marker rows, invoked before
-     *  and after every message block. */
     markers?: ComponentType<TranscriptMarkerProps>;
-    /** Where the host's marker rows anchor — a marker splits folds and
-     *  delegation groups exactly as a visible row would. Omit ONLY where
-     *  no marker can fall between two delegation moments. */
     markerBoundaries?: MarkerBoundaries;
-    /** The retry-marker anchor ids alone — never the merged boundary sets
-     *  above, which say nothing about an attempt restart. Tool calls left
-     *  open behind the last of these read severed instead of spinning
-     *  forever. */
     resumeAnchoredIds?: ReadonlySet<string>;
-    /** The delivery-marker anchor ids — the turn-start boundary for
-     *  machine-initiated delivery turns, which begin with no user
-     *  message. The host's own marker draws the divider; the projection
-     *  renders none (the anchors ride in empty). */
     deliveryAnchoredIds?: ReadonlySet<string>;
-    /** Each injected user message's attachments keyed by its stable id
-     *  (`user:{turnId}`) — the turn rows' side table; attachments never
-     *  ride the AG-UI Message itself. */
     turnAttachments?: ReadonlyMap<string, TurnAttachment[]>;
-    /** True when the host's own chrome already states the run's liveness
-     *  for the whole live window (the run viewer's live line). The
-     *  package's standalone trailing claimants then yield in every state —
-     *  MessageList's liveness-ownership rule — so the frame never carries
-     *  two live claims. Content liveness (fold headlines, streaming prose)
-     *  is unaffected. */
     frameClaimsLiveness?: boolean;
     rows?: never;
     cards?: never;
@@ -83,7 +28,6 @@ export interface AgentTranscriptSource extends TranscriptSlotProps {
     decisionSurfacesInShelf?: never;
 }
 export interface RowsTranscriptSource extends TranscriptSlotProps {
-    /** The host-projected flat rows (the store path). */
     rows: readonly TranscriptRow[];
     cards?: readonly ApprovalCardModel[];
     live?: boolean;
@@ -101,4 +45,3 @@ export interface RowsTranscriptSource extends TranscriptSlotProps {
 export type AssistantTranscriptProps = AgentTranscriptSource | RowsTranscriptSource;
 export declare function AssistantTranscript(props: AssistantTranscriptProps): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=assistant-transcript.d.ts.map

package/dist/components/assistant-transcript.js

@@ -14,9 +14,6 @@ import { MessageList, } from "./message-list.js";
 import { HostSlotBoundary } from "./slot-boundary.js";
 import { useLatestRef } from "./use-latest-ref.js";
 export function AssistantTranscript(props) {
-    // Two internal components so each mode's hook list stays static;
-    // switching source kinds remounts, which is the honest lifecycle (an
-    // agent-mode mount owns a connection the rows mode never opened).
     if (props.agent !== undefined) {
         return _jsx(AgentModeTranscript, { ...props });
     }
@@ -25,62 +22,22 @@ export function AssistantTranscript(props) {
 const EMPTY_SNAPSHOT = { messages: [], running: false };
 const NO_CARDS = [];
 const NO_IDS = new Set();
-// The anchor families this surface has no recorder for (the ./transcript
-// entry's scope note): passable empty by design — absent facts degrade
-// the rows honestly (no timing → "Worked", no memory attribution → no
-// footer), never crash.
 const NO_MAP = new Map();
-/** A recorder callback that folds its arguments into an anchor map:
- *  `setter(previous => merge(previous, ...args))`, typed once for the
- *  five anchor families the transcript records. */
 function anchorInto(setter, merge) {
     return (...args) => {
         setter((previous) => merge(previous, ...args));
     };
 }
-/** The connection agent mode owns — recorders subscribed before connect,
- *  unsubscribe-then-abort on teardown — and the snapshot and anchor maps
- *  those recorders publish. */
 function useAgentRecording(agent, onStreamError) {
-    // Null until the recorder publishes its first snapshot — even an empty
-    // settled log delivers one (the synthesized RUN_STARTED), so null means
-    // exactly "still connecting" and gates the welcome screen.
     const [snapshot, setSnapshot] = useState(null);
-    // Anchor maps for wire facts the message list does not carry as such:
-    // backend-authored display copy rides CUSTOM markers, never a message,
-    // and the tool-outcome extras reach agent.messages only as lifted
-    // metadata (core/tool-outcome.ts) — the recorders keep these maps as the
-    // read path, stable across remounts. First-wins merges return the
-    // previous map by identity on replayed re-delivery, so StrictMode reruns
-    // and reconnect replays no-op these setStates.
     const [displayAnchors, setDisplayAnchors] = useState(EMPTY_TOOL_CALL_DISPLAY_ANCHORS);
     const [errorAnchors, setErrorAnchors] = useState(EMPTY_TOOL_ERROR_ANCHORS);
     const [cancelAnchors, setCancelAnchors] = useState(EMPTY_TOOL_CANCEL_ANCHORS);
-    // The offload stamp: an offloaded result's content is the offloader's
-    // model-facing replacement, not the tool's output — without this set
-    // the row would render that replacement as if the tool had said it.
     const [offloadAnchors, setOffloadAnchors] = useState(EMPTY_TOOL_OFFLOAD_ANCHORS);
-    // The refusal signal: a door that answered and declined stamps
-    // `refused` (a sentence) INSTEAD of `error`, so a surface reading only
-    // `error` would render the refusal as a clean success whose Result pane
-    // shows the refusal envelope — and group a refused dispatch as a
-    // coworker that ran.
     const [refusalAnchors, setRefusalAnchors] = useState(EMPTY_TOOL_REFUSAL_ANCHORS);
-    // The denial ledger: a member's denial reaches the wire as a
-    // `cancelled` result, so a surface reading only the cancel stamp
-    // renders it "Interrupted". The ledger joins approval_requested to
-    // approval_resolved{approved:false} by interrupt id; only its DENIED
-    // half reaches the snapshot, and the fold returns the same object when
-    // nothing changed, so replays no-op this setState too.
     const [denialLedger, setDenialLedger] = useState(EMPTY_TOOL_DENIAL_LEDGER);
-    // The error tap rides a ref so a host handing a fresh closure per
-    // render never tears the connection down and replays it.
     const streamErrorRef = useLatestRef(onStreamError);
     useEffect(() => {
-        // Subscribe before connect: the recorders must see the replay's
-        // first event. Sibling recorder components (markers, approvals)
-        // render before this component in the hosts, so their effects — and
-        // therefore their subscriptions — run earlier still.
         const taps = [
             agent.subscribe(messagesSnapshotRecorder(setSnapshot)),
             agent.subscribe(connectionErrorRecorder((error) => {
@@ -93,13 +50,8 @@ function useAgentRecording(agent, onStreamError) {
             agent.subscribe(toolRefusalRecorder(anchorInto(setRefusalAnchors, withToolRefusalAnchored))),
             agent.subscribe(toolDenialRecorder(anchorInto(setDenialLedger, withToolDenialMarkerFolded))),
         ];
-        // The recorder carries connection failures (onRunFailed); the
-        // rejection here would only duplicate it.
         agent.connectAgent().catch(() => undefined);
         return () => {
-            // Unsubscribe BEFORE aborting: the teardown's own synthesized
-            // abort RUN_ERROR must never reach the error tap or repaint the
-            // message state.
             for (const tap of taps) {
                 tap.unsubscribe();
             }
@@ -120,29 +72,12 @@ function useAgentRecording(agent, onStreamError) {
 function AgentModeTranscript({ agent, onStreamError, markers, markerBoundaries, resumeAnchoredIds = NO_IDS, deliveryAnchoredIds = NO_IDS, turnAttachments, frameClaimsLiveness, scrollClassName, messageView, toolRow, input, welcomeScreen, threadList, }) {
     const { snapshot, displayAnchors, errorAnchors, cancelAnchors, offloadAnchors, refusalAnchors, denialLedger, } = useAgentRecording(agent, onStreamError);
     const delivered = snapshot ?? EMPTY_SNAPSHOT;
-    // Where each declared value lands is enumerated in
-    // docs/transcript-surfaces.md, "The agent binder's declared values".
-    // The arms easiest to get wrong: deliveryAnchoredIds feeds BOTH the
-    // severance scan (presence-based) and MessageList's turnStartIds (the
-    // fold pass is ROW-based, so the empty arrays do not suffice);
-    // turnAttachments → transcriptBlocksOf's side-table join only;
-    // scrollClassName, the five slots → render only.
     const anchors = useMemo(() => ({
-        // Presence drives the severance window; the payload is the host's
-        // marker state, not the projection's to read.
         resumeAnchors: new Map([...resumeAnchoredIds].map((id) => [id, null])),
-        // Empty on purpose: a boundary without a row — the host's own
-        // marker draws the divider, so a projected one would double it (the
-        // row guard is `results.length > 0`). Every consumer that must see
-        // the delivery boundary reads the anchor MAP's keys or an explicit
-        // id set (the severance scan, the turnStartIds below); only the
-        // divider ROW rides the array length — the one thing suppressed.
         subagentDeliveryAnchors: new Map([...deliveryAnchoredIds].map((id) => [id, []])),
         toolErrorAnchors: errorAnchors,
         toolCancelAnchors: cancelAnchors,
         toolRefusalAnchors: refusalAnchors,
-        // The ledger's presentation half only; the ask map stays
-        // in the fold's own state.
         toolDenialAnchors: denialLedger.denied,
         toolCallDisplayAnchors: displayAnchors,
         turnFailedAnchors: NO_MAP,
@@ -162,23 +97,13 @@ function AgentModeTranscript({ agent, onStreamError, markers, markerBoundaries,
         denialLedger.denied,
         displayAnchors,
     ]);
-    // Memoized on the snapshot AND the marker boundaries: marker positions
-    // are part of the block derivation (they split delegation groups), so
-    // a newly anchored marker legitimately re-runs the dedupe — a rare
-    // event, anchors move a handful of times per run.
     const blocks = useMemo(() => transcriptBlocksOf(delivered.messages, anchors, delivered.running, undefined, {
         markerBoundaries,
         attachmentsByMessageId: turnAttachments,
     }), [delivered, anchors, markerBoundaries, turnAttachments]);
     const showWelcome = _welcomeMomentOf(snapshot, blocks.length, welcomeScreen);
-    return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { blocks: blocks, cards: NO_CARDS, turnStartIds: deliveryAnchoredIds, 
-            // The dashboard wire has no turn-status cell: the snapshot's
-            // running bit is this surface's one liveness fact, so it carries
-            // both the live register and the open-tail fold regime.
-            live: delivered.running, turnOpen: delivered.running, markers: markers, markerBoundaries: markerBoundaries, frameClaimsLiveness: frameClaimsLiveness, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
+    return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { blocks: blocks, cards: NO_CARDS, turnStartIds: deliveryAnchoredIds, live: delivered.running, turnOpen: delivered.running, markers: markers, markerBoundaries: markerBoundaries, frameClaimsLiveness: frameClaimsLiveness, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
 }
-/** The welcome screen's moment: a connected, genuinely empty log with a
- *  host welcome to show (agent mode waits for the first snapshot). */
 function _welcomeMomentOf(snapshot, blockCount, welcomeScreen) {
     return (snapshot !== null && blockCount === 0 && !hostFillDeclines(welcomeScreen));
 }
@@ -186,15 +111,6 @@ function RowsModeTranscript({ rows, cards = NO_CARDS, live, turnOpen, decisionSu
     const showWelcome = rows.length === 0 && !hostFillDeclines(welcomeScreen);
     return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { rows: rows, cards: cards, live: live, turnOpen: turnOpen, decisionSurfacesInShelf: decisionSurfacesInShelf, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
 }
-/** The frame — a fragment, never a box: chrome above the log inside its
- *  slot boundary, the input region below it deliberately unbounded (the
- *  input-region rule above — a throw propagates to the host's own
- *  boundary), each absent from the DOM entirely when unfilled. */
 function TranscriptFrame({ threadList, input, children, }) {
-    return (_jsxs(_Fragment, { children: [!hostFillDeclines(threadList) ? (
-            // The chrome hook div rides INSIDE the boundary (the keying law): it
-            // exists to be host-styled, so a latched-away fill takes it along
-            // rather than leave an empty strip wearing the host's padding.
-            _jsx(HostSlotBoundary, { slot: "threadList", fallback: null, children: _jsx("div", { "data-tf-transcript-chrome": "", children: threadList }) })) : null, children, input ?? null] }));
+    return (_jsxs(_Fragment, { children: [!hostFillDeclines(threadList) ? (_jsx(HostSlotBoundary, { slot: "threadList", fallback: null, children: _jsx("div", { "data-tf-transcript-chrome": "", children: threadList }) })) : null, children, input ?? null] }));
 }
-//# sourceMappingURL=assistant-transcript.js.map

package/dist/components/attachment-chips.d.ts

@@ -2,4 +2,3 @@ import type { TurnAttachment } from "../contract/threads.js";
 export declare function AttachmentChips({ attachments, }: {
     attachments: readonly TurnAttachment[];
 }): import("react").JSX.Element | null;
-//# sourceMappingURL=attachment-chips.d.ts.map

package/dist/components/attachment-chips.js

@@ -4,12 +4,6 @@ import { useEffect, useState } from "react";
 import { humanFileSize } from "./human-file-size.js";
 import { FileIcon } from "./icons.js";
 import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
-// A user message's attachments, the quiet register: images render inline
-// (an inset hairline contains uncontrolled customer imagery on any
-// ground — the org-logo law), everything else is a small muted chip
-// naming the file. Bytes are a download-url exchange away: the id is
-// stable, a URL is minted on mount and re-minted as it expires — a
-// widget stays open far longer than a URL lives, and nothing persists.
 export function AttachmentChips({ attachments, }) {
     if (attachments.length === 0) {
         return null;
@@ -19,9 +13,6 @@ export function AttachmentChips({ attachments, }) {
 function AttachmentImage({ attachment }) {
     const url = useAttachmentUrl(attachment.id);
     if (url === null) {
-        // The mint is in flight (or refused — a swept upload): the chip is
-        // the truthful fallback either way, and the image swaps in if the
-        // URL lands.
         return _jsx(FileChip, { attachment: attachment });
     }
     return (_jsx("img", { src: url, alt: attachment.filename, loading: "lazy", className: "tf:max-h-48 tf:max-w-full tf:rounded-lg tf:ring-1 tf:ring-tf-border tf:ring-inset" }));
@@ -31,10 +22,6 @@ function FileChip({ attachment }) {
             "tf:bg-tf-background tf:px-2.5 tf:py-1.5 tf:text-xs tf:text-tf-foreground " +
             "tf:ring-1 tf:ring-tf-border tf:ring-inset", title: attachment.filename, children: [_jsx("span", { className: "tf:text-tf-muted-foreground", children: _jsx(FileIcon, {}) }), _jsx("span", { className: "tf:min-w-0 tf:truncate", children: attachment.filename }), _jsx("span", { className: "tf:shrink-0 tf:text-tf-muted-foreground", children: humanFileSize(attachment.byte_size) })] }));
 }
-// The fastest the hook ever goes back to the mint endpoint: the retry
-// delay after a blipped refresh, and the floor under the expiry timer —
-// a served TTL at or under the store's safety margin puts the expiry in
-// the past, which must slow the cadence, never become a tight loop.
 const URL_REFRESH_FLOOR_MS = 30_000;
 function useAttachmentUrl(attachmentId) {
     const session = useOptionalAssistantSession();
@@ -52,9 +39,6 @@ function useAttachmentUrl(attachmentId) {
                     return;
                 }
                 setUrl(minted.url);
-                // The URL dies at its short TTL while this mount may live for
-                // hours: re-mint as the expiry lands, so a lazy <img> that
-                // fetches late never holds an expired URL.
                 timer = setTimeout(() => {
                     mintAndScheduleRefresh(true);
                 }, Math.max(URL_REFRESH_FLOOR_MS, minted.expiresAtMs - Date.now()));
@@ -62,10 +46,6 @@ function useAttachmentUrl(attachmentId) {
                 if (cancelled) {
                     return;
                 }
-                // A refused first mint (a swept upload) keeps the chip
-                // fallback — decoration never surfaces an error. A refused
-                // refresh is a blip on a URL that already worked: try again,
-                // or the image freezes on an expired URL.
                 if (isRefresh) {
                     timer = setTimeout(() => {
                         mintAndScheduleRefresh(true);
@@ -81,4 +61,3 @@ function useAttachmentUrl(attachmentId) {
     }, [store, attachmentId]);
     return url;
 }
-//# sourceMappingURL=attachment-chips.js.map

package/dist/components/child-transcript.d.ts

@@ -3,28 +3,15 @@ type ChildStatus = "running" | "failed" | "finished";
 export declare function ChildTranscriptPanel({ threadId, childSessionId, variantIndex, opener, onBack, }: {
     threadId: string;
     childSessionId: string;
-    /** The coworker's deterministic color slot (coworkerIndicesOf) — the host
-     *  passes it so the panel wears the same variant as the row that
-     *  opened it; absent metadata disappears cleanly. */
     variantIndex?: number;
-    /** The element Back restores focus to, captured by the host INSIDE the
-     *  opening click — before the commit that inerts the conversation box
-     *  blurs it to <body> (the floating-panel ordering; no effect, layout
-     *  or passive, runs early enough to capture it here). */
     opener: HTMLElement | null;
     onBack: () => void;
 }): import("react").JSX.Element;
-/** A compact read-only scan of the same child stream. It is mounted only
- * while its roster row is hovered, focused, or tapped, so opening the
- * roster itself remains a ledger-only operation. */
 export declare function ChildTranscriptPreview({ threadId, childSessionId, variantIndex, }: {
     threadId: string;
     childSessionId: string;
     variantIndex?: number;
 }): import("react").JSX.Element;
-/** The preview's deterministic presentation shell, exported for the
- * package's screenshot fixture. Production fills it with the live child
- * driver below; the fixture fills it with canned transcript rows. */
 export declare function ChildTranscriptPreviewFrame({ label, status, duration, variantIndex, children, }: {
     label: string;
     status: ChildStatus;
@@ -33,4 +20,3 @@ export declare function ChildTranscriptPreviewFrame({ label, status, duration, v
     children: ReactNode;
 }): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=child-transcript.d.ts.map

package/dist/components/child-transcript.js

@@ -1,13 +1,5 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-// One dispatched subagent's own run, replayed in full and tailed live
-// while it runs — the full panel and the compact roster preview share one
-// driver. Deliberately NOT a second <Transcript/>: that renders the
-// store's parent-thread cells. This panel owns, through
-// useChildReplayStream, one ServingReplayStreamAgent at the child stream
-// URL, the messages recorder, and the parent's row derivation; the
-// stream opens on drill-in only and leases the one child tail slot
-// first, so child and parent streams share a bounded budget.
 import { activityTitleOf } from "../core/activity-title.js";
 import { CheckIcon, ChevronLeftIcon, XCircleIcon } from "lucide-react";
 import { useEffect, useMemo, useRef, useSyncExternalStore, } from "react";
@@ -30,37 +22,14 @@ import { useChildDispatch } from "./use-thread-dispatches.js";
 export function ChildTranscriptPanel({ threadId, childSessionId, variantIndex, opener, onBack, }) {
     return (_jsx(ChildTranscript, { mode: "panel", threadId: threadId, childSessionId: childSessionId, variantIndex: variantIndex, opener: opener, onBack: onBack }));
 }
-/** A compact read-only scan of the same child stream. It is mounted only
- * while its roster row is hovered, focused, or tapped, so opening the
- * roster itself remains a ledger-only operation. */
 export function ChildTranscriptPreview({ threadId, childSessionId, variantIndex, }) {
     return (_jsx(ChildTranscript, { mode: "preview", threadId: threadId, childSessionId: childSessionId, variantIndex: variantIndex, opener: null, onBack: () => undefined }));
 }
-/** The preview's deterministic presentation shell, exported for the
- * package's screenshot fixture. Production fills it with the live child
- * driver below; the fixture fills it with canned transcript rows. */
 export function ChildTranscriptPreviewFrame({ label, status, duration, variantIndex, children, }) {
-    return (_jsxs("div", { role: "region", "aria-label": `Conversation preview: ${label}`, "data-tf-glass": "", "data-tf-child-transcript-preview": "", className: "tf:flex tf:h-full tf:w-full tf:min-h-0 tf:min-w-0 tf:flex-col tf:overflow-hidden tf:rounded-2xl tf:border tf:bg-tf-background", children: [_jsxs("div", { className: "tf:flex tf:items-center tf:gap-2 tf:border-b tf:px-3 tf:py-2.5", children: [_jsx("span", { className: "tf:flex tf:h-6 tf:min-w-6 tf:shrink-0 tf:items-center tf:justify-center tf:px-1", children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex }) }), _jsx(ChildStatusMark, { status: status }), status === "running" ? (
-                    // The live header's liveness claim is the label's own shimmer
-                    // (the one motion register — the same treatment as the inline
-                    // coworker row), in the muted live-work ink every moving label
-                    // wears. The shimmer root is an atomic inline-grid, so the
-                    // ellipsis lives on the blockified span inside.
-                    _jsx(ShimmerText, { className: "tf:min-w-0 tf:flex-1 tf:grid-cols-1 tf:text-tf-label tf:font-medium tf:text-tf-muted-foreground", children: _jsx("span", { className: "tf:block tf:truncate", title: label, children: activityTitleOf(label) }) })) : (_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-label tf:font-medium", title: label, children: activityTitleOf(label) })), status === "running" ? (
-                    // The state in visible words, in the slot the settled clock
-                    // takes over: the header's shimmering label carries no state
-                    // word of its own, and under reduced motion the shimmer
-                    // collapses to plain text — this word is what keeps a running
-                    // header distinguishable from a settled one there.
-                    _jsx(ShimmerText, { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: "Working" })) : null, duration != null ? (_jsx("span", { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: duration })) : null] }), children] }));
+    return (_jsxs("div", { role: "region", "aria-label": `Conversation preview: ${label}`, "data-tf-glass": "", "data-tf-child-transcript-preview": "", className: "tf:flex tf:h-full tf:w-full tf:min-h-0 tf:min-w-0 tf:flex-col tf:overflow-hidden tf:rounded-2xl tf:border tf:bg-tf-background", children: [_jsxs("div", { className: "tf:flex tf:items-center tf:gap-2 tf:border-b tf:px-3 tf:py-2.5", children: [_jsx("span", { className: "tf:flex tf:h-6 tf:min-w-6 tf:shrink-0 tf:items-center tf:justify-center tf:px-1", children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex }) }), _jsx(ChildStatusMark, { status: status }), status === "running" ? (_jsx(ShimmerText, { className: "tf:min-w-0 tf:flex-1 tf:grid-cols-1 tf:text-tf-label tf:font-medium tf:text-tf-muted-foreground", children: _jsx("span", { className: "tf:block tf:truncate", title: label, children: activityTitleOf(label) }) })) : (_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-label tf:font-medium", title: label, children: activityTitleOf(label) })), status === "running" ? (_jsx(ShimmerText, { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: "Working" })) : null, duration != null ? (_jsx("span", { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: duration })) : null] }), children] }));
 }
 function ChildStatusMark({ status }) {
     if (status === "running") {
-        // Liveness is the header label's shimmer plus the visible "Working"
-        // word in the trailing slot (the one motion register — no spinner
-        // beside a shimmering line). The invisible spacer holds the settled
-        // glyph's size-4 slot so the label never shifts when the check
-        // lands. No sr-only twin: the trailing word is visible text.
         return _jsx("span", { "aria-hidden": true, className: "tf:size-4 tf:shrink-0" });
     }
     if (status === "failed") {
@@ -76,42 +45,19 @@ function ChildTranscript({ mode, threadId, childSessionId, variantIndex, opener,
     const backRef = usePanelBackFocus(mode, opener);
     const brief = useOpeningBrief(store, childSessionId);
     const rows = useMemo(() => transcriptRowsOf(withOpeningBrief(messages, brief, childSessionId), anchors, running), [messages, brief, childSessionId, anchors, running]);
-    // The end-state table's render half, all derived from streamEnd + the
-    // ledger row (docs/transcript-surfaces.md): the stream is LIVE only
-    // while it is open at the tail of a running dispatch — never dropped,
-    // never finished. typing and the trailing group's hold-open both key
-    // on this one spelling.
     const streamLive = running && tailed && streamEnd === "open";
     const typing = streamLive && !trailingRowIsStreaming(rows);
     useChildCurrentWorkPublish(childSessionId, rows, streamLive);
     const duration = dispatch !== undefined
         ? settledDurationLabelOf(dispatch.created_at, running ? null : dispatch.updated_at)
         : null;
-    // The empty-string guard every neighbouring surface keeps: a
-    // whitespace-only task stores '' (question_excerpt_of collapses it),
-    // and ?? alone would blank the header.
     const label = dispatch !== undefined && dispatch.label !== ""
         ? dispatch.label
         : "Delegated task";
-    // The one reason to drill into a FAILED child is to learn why: the
-    // ledger's sentence leads the panel, not just the header glyph — the
-    // dashboard drill-in's outcome line, in this surface's register.
     const failed = dispatch !== undefined && dispatchFailed(dispatch);
-    // error is nullable on the wire: a failed row with no sentence still
-    // owes the member an explanation (the neighbouring surfaces' fallback).
     const failureSentence = failed
         ? (dispatch.error ?? "The subagent failed before it could report back.")
         : null;
-    // A failed child's stream legitimately ENDS in RUN_ERROR (recorded, or
-    // synthesized by the door's settled fallback) — that is its honest
-    // terminal, not a dropped connection, and a Retry would replay onto
-    // the same ending. The interruption banner speaks only when the ledger
-    // does not already explain the ending — and the error end lands AFTER
-    // the ledger catch-up (the table's judge order), so a child failing
-    // mid-watch reads failed here, never interrupted. A QUIET ending was
-    // judged into "error" or "clean" when it landed, so this reads ONE
-    // latched fact — never the live row, which would un-paint the banner
-    // the moment the child settled.
     const interrupted = streamEnd === "error" && !failed;
     const status = running ? "running" : failed ? "failed" : "finished";
     const transcript = (_jsx(ChildTranscriptBody, { failureSentence: failureSentence, interrupted: interrupted, onRetry: retry, waitingForSlot: slotDenied && streamEnd === "open", rows: rows, typing: typing, streamLive: streamLive, running: running, childSessionId: childSessionId }));
@@ -120,18 +66,6 @@ function ChildTranscript({ mode, threadId, childSessionId, variantIndex, opener,
     }
     return (_jsx(ChildTranscriptPanelFrame, { label: label, status: status, duration: duration, variantIndex: variantIndex, backRef: backRef, onBack: onBack, children: transcript }));
 }
-// Opening moves focus here; closing hands it back to the opener the
-// host captured INSIDE the opening click — no effect (layout or
-// passive) runs before the sibling inert commit's focus-fixup blurs a
-// covered opener to <body>, so a capture here would read body and
-// restore nothing. The roster refocuses its trigger before asking for
-// the panel, so its captured opener survives the roster's unmount; a
-// tree row survives under the inert cover. Under StrictMode's
-// mount-cleanup-remount the first cleanup's restore hits the
-// still-inert opener and no-ops; the real close restores once the same
-// commit lifted the cover. A thread switch unmounts the panel too; a
-// disconnected opener is simply skipped. Esc anywhere in the panel is
-// the back gesture.
 function usePanelBackFocus(mode, opener) {
     const backRef = useRef(null);
     useEffect(() => {
@@ -144,23 +78,13 @@ function usePanelBackFocus(mode, opener) {
                 opener.focus();
             }
         };
-        // Fixed for the panel's lifetime: the host keys this panel by child,
-        // so a different drill-in is a fresh mount with a fresh opener.
     }, [mode, opener]);
     return backRef;
 }
-// The brief is a string snapshot, so parent deltas that leave it
-// unchanged never re-render the panel.
 function useOpeningBrief(store, childSessionId) {
     const briefNow = () => openingBriefOf(store.messages.get(), childSessionId);
     return useSyncExternalStore(store.messages.subscribe, briefNow, briefNow);
 }
-// The current-work publish (TVC-072): while THIS surface holds the live
-// tail, its newest live call feeds the inline group row's current-work
-// line — the drill-in stream is the seam's only honest writer (no extra
-// streams ever open for it). publishedRef guards the clear: a second
-// surface on the same child that never held the tail (slot-denied, or a
-// settled replay) must not blank the holder's entry.
 function useChildCurrentWorkPublish(childSessionId, rows, streamLive) {
     const publishCurrentWork = useSubagentCurrentWorkPublisher();
     const publishedRef = useRef(false);
@@ -181,59 +105,16 @@ function useChildCurrentWorkPublish(childSessionId, rows, streamLive) {
         }
     }, [publishCurrentWork, childSessionId]);
 }
-// The child's transcript proper: the ledger's failure sentence, the
-// interruption banner with Retry, the slot-wait notice, then the rows.
 function ChildTranscriptBody({ failureSentence, interrupted, onRetry, waitingForSlot, rows, typing, streamLive, running, childSessionId, }) {
-    return (_jsxs(_Fragment, { children: [failureSentence !== null ? (_jsx("div", { className: "tf:border-b", children: _jsx("p", { className: "tf:mx-auto tf:m-0 tf:w-full tf:max-w-3xl tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: failureSentence }) })) : null, interrupted ? (_jsx("div", { role: "alert", className: "tf:border-b", children: _jsxs("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: ["The connection to this subagent was interrupted.", _jsx(TfButton, { variant: "ghost", onClick: onRetry, children: "Retry" })] }) })) : null, waitingForSlot ? (_jsx("p", { className: "tf:mx-auto tf:m-0 tf:w-full tf:max-w-3xl tf:px-4 tf:py-3 tf:text-tf-label tf:text-tf-muted-foreground", children: "Waiting for another subagent view to finish\u2026" })) : null, _jsx(SubagentDrillInContext.Provider, { value: null, children: _jsx(SurfaceBoundary, { surface: "child-transcript", children: _jsx(MessageList, { rows: rows, cards: [], typing: typing, live: streamLive, 
-                        // Episode unification keys on the child's TURN terminality,
-                        // never on stream liveness: a dropped or untailed stream over
-                        // a still-running dispatch — the interruption banner, the
-                        // slot-denied wait, a second view without the tail lease —
-                        // must not unify the turn mid-flight and present its latest
-                        // paragraph as the final response, only to pop it apart when
-                        // Retry reopens the stream.
-                        turnOpen: running, 
-                        // The placement holds ride the dispatch's own running fact: a
-                        // child thread is one turn by construction — its only user
-                        // row is the opening brief — so the next-user-turn decay can
-                        // never fire here. While the coworker works, its
-                        // view/decision-bearing calls hold open exactly like a live
-                        // parent turn; once the dispatch settles, the drill-in is an
-                        // inspection surface and every disclosure is native — never a
-                        // wall of held-open panes over a finished history.
-                        placementHolds: running, 
-                        // The coworker's own transcript: its
-                        // prose wears the child's identity
-                        // token, never the primary agent's
-                        // (law 10; the token is the same one
-                        // the group row and roster wear for
-                        // this coworker).
-                        identityToken: subagentIdentityTokenOf(childSessionId) }) }) })] }));
+    return (_jsxs(_Fragment, { children: [failureSentence !== null ? (_jsx("div", { className: "tf:border-b", children: _jsx("p", { className: "tf:mx-auto tf:m-0 tf:w-full tf:max-w-3xl tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: failureSentence }) })) : null, interrupted ? (_jsx("div", { role: "alert", className: "tf:border-b", children: _jsxs("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: ["The connection to this subagent was interrupted.", _jsx(TfButton, { variant: "ghost", onClick: onRetry, children: "Retry" })] }) })) : null, waitingForSlot ? (_jsx("p", { className: "tf:mx-auto tf:m-0 tf:w-full tf:max-w-3xl tf:px-4 tf:py-3 tf:text-tf-label tf:text-tf-muted-foreground", children: "Waiting for another subagent view to finish\u2026" })) : null, _jsx(SubagentDrillInContext.Provider, { value: null, children: _jsx(SurfaceBoundary, { surface: "child-transcript", children: _jsx(MessageList, { rows: rows, cards: [], typing: typing, live: streamLive, turnOpen: running, placementHolds: running, identityToken: subagentIdentityTokenOf(childSessionId) }) }) })] }));
 }
-// The full panel's frame: a non-modal dialog over the conversation box
-// with the Back row, the coworker's identity and status, and the clock.
 function ChildTranscriptPanelFrame({ label, status, duration, variantIndex, backRef, onBack, children, }) {
-    return (
-    // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions -- the keydown is the panel's own Esc-to-back; every control inside is a real button.
-    _jsxs("div", { role: "dialog", "aria-label": "Subagent transcript", "data-tf-child-transcript": "", 
-        // Focusable on purpose (the roster card's own posture): a click on
-        // the panel's passive ink — selecting a failure sentence, message
-        // text — moves focus HERE instead of dropping it to body, so the
-        // Esc-to-back below keeps routing through this subtree. "Esc
-        // anywhere in the panel" has to survive a click anywhere in it.
-        tabIndex: -1, className: "tf:absolute tf:inset-0 tf:flex tf:min-h-0 tf:min-w-0 tf:flex-col tf:bg-tf-background", onKeyDown: (event) => {
+    return (_jsxs("div", { role: "dialog", "aria-label": "Subagent transcript", "data-tf-child-transcript": "", tabIndex: -1, className: "tf:absolute tf:inset-0 tf:flex tf:min-h-0 tf:min-w-0 tf:flex-col tf:bg-tf-background", onKeyDown: (event) => {
             if (event.key !== "Escape") {
                 return;
             }
             event.preventDefault();
             event.stopPropagation();
             onBack();
-        }, children: [_jsx("div", { className: "tf:border-b", children: _jsxs("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2", children: [_jsxs(TfButton, { ref: backRef, variant: "ghost", onClick: onBack, children: [_jsx(ChevronLeftIcon, { "aria-hidden": true, className: "tf:size-4 tf:shrink-0" }), "Back"] }), _jsx("span", { className: "tf:flex tf:h-6 tf:min-w-6 tf:shrink-0 tf:items-center tf:justify-center tf:px-1", children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex }) }), _jsx(ChildStatusMark, { status: status }), status === "running" ? (
-                        // The preview frame's running treatment, verbatim (the two
-                        // headers are the same surface at two sizes): shimmering
-                        // muted label plus the visible "Working" word in the slot
-                        // the settled clock takes over — the words are what survive
-                        // the reduced-motion collapse.
-                        _jsxs(_Fragment, { children: [_jsx(ShimmerText, { className: "tf:min-w-0 tf:flex-1 tf:grid-cols-1 tf:text-tf-label tf:font-medium tf:text-tf-muted-foreground", children: _jsx("span", { className: "tf:block tf:truncate", title: label, children: activityTitleOf(label) }) }), _jsx(ShimmerText, { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: "Working" })] })) : (_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-label tf:font-medium", title: label, children: activityTitleOf(label) })), duration !== null ? (_jsx("span", { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: duration })) : null] }) }), children] }));
+        }, children: [_jsx("div", { className: "tf:border-b", children: _jsxs("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2", children: [_jsxs(TfButton, { ref: backRef, variant: "ghost", onClick: onBack, children: [_jsx(ChevronLeftIcon, { "aria-hidden": true, className: "tf:size-4 tf:shrink-0" }), "Back"] }), _jsx("span", { className: "tf:flex tf:h-6 tf:min-w-6 tf:shrink-0 tf:items-center tf:justify-center tf:px-1", children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex }) }), _jsx(ChildStatusMark, { status: status }), status === "running" ? (_jsxs(_Fragment, { children: [_jsx(ShimmerText, { className: "tf:min-w-0 tf:flex-1 tf:grid-cols-1 tf:text-tf-label tf:font-medium tf:text-tf-muted-foreground", children: _jsx("span", { className: "tf:block tf:truncate", title: label, children: activityTitleOf(label) }) }), _jsx(ShimmerText, { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: "Working" })] })) : (_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-label tf:font-medium", title: label, children: activityTitleOf(label) })), duration !== null ? (_jsx("span", { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: duration })) : null] }) }), children] }));
 }
-//# sourceMappingURL=child-transcript.js.map

package/dist/components/companion-drawer-body.d.ts

@@ -1,2 +1 @@
 export default function CompanionDrawerBody(): import("react").JSX.Element;
-//# sourceMappingURL=companion-drawer-body.d.ts.map