@teaflask/assistant 0.6.0 → 0.7.0

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

@@ -2,14 +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 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 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;
+/** The plain-DOM version of ToolViewScroll, holding the given elements. */
 export declare function scrollRegion(children: readonly HTMLElement[]): HTMLElement;
+/**
+ * The plain-DOM version of ToolViewCard, holding the given elements under an
+ * optional title.
+ */
 export declare function card(children: readonly HTMLElement[], title?: string): HTMLElement;
+/**
+ * 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;
@@ -17,25 +35,73 @@ export declare function listRow(options: {
     icon?: Element;
     below?: HTMLElement;
 }): HTMLElement;
+/**
+ * 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;
+/**
+ * The plain-DOM version of ToolViewCaption, with optional trailing content on
+ * the right.
+ */
 export declare function captionRow(text: string, trailing?: HTMLElement | string): HTMLElement;
 export declare function badge(text: string): HTMLElement;
+/** The plain-DOM version of ToolViewBones, with `count` skeleton lines. */
 export declare function boneRows(count: number): HTMLElement;
+/** 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;
+/**
+ * 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 settledWithResult(call: ToolViewCall): boolean;
+/**
+ * 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[];
+/**
+ * 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'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'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;
@@ -46,6 +112,16 @@ export interface ActionFailure {
         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;
+/**
+ * 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;
 export declare function fileGlyph(): SVGElement;

package/dist/components/transcript.js

@@ -23,9 +23,9 @@ export function Transcript({ surface }) {
     const { pendingSend } = useConversation();
     const connection = useCell(store.connection);
     const { approvalCards, approvalSurface, elicitationSurface } = useDecisionSurfaces(store);
-    const { rows, displayRows, running, turnOpen, decisionsPending, activity } = useTranscript({ surface });
+    const { displayRows, running, turnOpen, decisionsPending, activity } = useTranscript({ surface });
     const rowIndexByToolCallId = useMemo(() => _rowIndexByToolCallIdOf(displayRows), [displayRows]);
-    const dispatches = useThreadDispatches(session, connection?.threadId ?? null, rows, store.noteDispatchSettled, store.noteDispatchPaused);
+    const dispatches = useThreadDispatches(session, connection?.threadId ?? null);
     const dispatchesJoin = useMemo(() => ({ byOrdinal: dispatches }), [dispatches]);
     const coworkerWork = useCell(store.coworkerWork);
     if (connection === null) {

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

@@ -1,2 +1,7 @@
 import type { AssistantActivitySnapshot } from "../core/activity.js";
+/**
+ * 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;

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

@@ -1,23 +1,120 @@
 import type { ServingAssistantThread } from "../contract/threads.js";
-import type { ActiveConversation, ComposerContract } from "../core/conversation-store.js";
+import type { ComposerContract } from "../core/conversation-store.js";
 import type { PendingDecisionGap } from "../core/pending-decision-gap.js";
 import type { ServingApiError } from "../transport/serving-error.js";
+/** The conversation on screen. */
+export interface OpenConversation {
+    /**
+     * The conversation's server record, including its id, title, whether a
+     * reply is running, timestamps and saved model choice.
+     */
+    thread: ServingAssistantThread;
+}
+/**
+ * The open conversation, the visitor's history, the notices worth showing, and
+ * the actions that move between conversations, as returned by
+ * useAssistantConversation().
+ */
 export interface AssistantConversation {
+    /**
+     * Set when the assistant cannot start because of a configuration problem
+     * (code PUBLISHABLE_KEY_INVALID, ORIGIN_NOT_ALLOWED, END_USER_TOKEN_INVALID
+     * or END_USER_ID_MISMATCH); show it instead of the conversation. Null
+     * otherwise, and cleared once a session starts successfully.
+     */
     setupError: ServingApiError | null;
-    conversation: ActiveConversation | null;
+    /**
+     * The conversation on screen, or null when none is open (a fresh
+     * conversation has no record until its first message is sent).
+     */
+    conversation: OpenConversation | null;
+    /**
+     * The visitor's past conversations (up to 200), for a history list. Only
+     * loaded for an identified visitor; empty for anonymous visitors.
+     */
     threads: ServingAssistantThread[];
+    /**
+     * True when the visitor is identified (you passed a userId, or their
+     * session is signed in), so a history list makes sense; false for an
+     * anonymous visitor.
+     */
     historyExpected: boolean;
+    /**
+     * True while a conversation is loading (a stored conversation at startup,
+     * or one picked with openThread); show a loading state rather than the
+     * empty state.
+     */
     threadOpening: boolean;
+    /**
+     * Increases each time the live connection restarts (after each send, a
+     * retry, or an automatic reconnect). Use it with the conversation id as a
+     * React key if you want your transcript subtree to remount on reconnect.
+     */
     reconnectNonce: number;
+    /**
+     * The composer's state and controls for this conversation, the same value
+     * useConversation() returns.
+     */
     composerContract: ComposerContract;
+    /**
+     * A sentence to show the visitor when sending a message, opening a
+     * conversation or stopping a reply failed. Null otherwise; cleared by the
+     * next send, open or new conversation.
+     */
     sendError: string | null;
+    /**
+     * A sentence to show when the newest reply failed. Null when it didn't, and
+     * also once the transcript itself shows that failure as a receipt row, so
+     * you never show it twice.
+     */
     turnFailure: string | null;
+    /**
+     * True when the connection dropped while a reply was in progress; show a
+     * notice with a Retry button that calls retryStream. Never true while the
+     * visitor is stopping a reply.
+     */
     showInterruptionBanner: boolean;
+    /**
+     * Set when the agent is waiting on an approval or question that this page
+     * could not display (after a short grace period). Show a notice with a
+     * Retry button that calls refreshConversation; null otherwise.
+     */
     pendingDecisionGap: PendingDecisionGap | null;
+    /**
+     * Reconnects to the conversation and replays it from the start, clearing
+     * the interruption notice. Use it as the interruption notice's Retry.
+     */
     retryStream: () => void;
+    /**
+     * Re-reads the open conversation from the server and applies what it finds.
+     * Does nothing when no conversation is open; network failures are ignored.
+     */
     refreshConversation: () => Promise<void>;
+    /**
+     * Opens one of the visitor's past conversations (from threads) and makes it
+     * the one resumed next time. While it loads, threadOpening is true; if it
+     * can't be opened, sendError is set, and a conversation that no longer
+     * exists is removed from threads.
+     */
     openThread: (thread: ServingAssistantThread) => void;
+    /**
+     * Leaves the current conversation and shows an empty one. Clears the unsent
+     * draft, staged attachments, unsent question answers and model choice; the
+     * new conversation is created when the first message is sent.
+     */
     startNewConversation: () => void;
+    /**
+     * Re-opens the conversation this browser last used, as saved for this
+     * publishable key; if none is saved, an open conversation is closed. The
+     * provider calls it once at startup; call it again when your UI reopens if
+     * another surface may have switched conversations meanwhile.
+     */
     resumeStoredThread: () => void;
 }
+/**
+ * Returns the live state and controls of the assistant conversation, for
+ * building your own UI. Must be called inside <TeaflaskAssistantProvider> (it
+ * throws otherwise); every component that calls it reads the same conversation
+ * as the widget, drawer, palette and full-page assistant.
+ */
 export declare function useAssistantConversation(): AssistantConversation;

package/dist/components/use-store-cell.d.ts

@@ -1,2 +1,7 @@
 import type { ReadonlyCell } from "../core/observable-cell.js";
+/**
+ * Subscribes a React component to an observable value such as composerInput and
+ * returns its current value, re-rendering when it changes. Server rendering
+ * gets the initial value.
+ */
 export declare function useCell<T>(cell: ReadonlyCell<T>): T;

package/dist/components/use-thread-dispatches.js

@@ -1,374 +1,16 @@
 "use client";
 import { useCallback, useEffect, useMemo } from "react";
-import { dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
-import { ObservableCell } from "../core/observable-cell.js";
-import { dispatchReceiptOf } from "../core/subagent-rows.js";
-import { listThreadDispatches } from "../transport/serving-api.js";
-import { resolvedSubagentEntryOf } from "./subagent-group-row.js";
+import { dispatchIsRunning, } from "../contract/dispatches.js";
+import { EMPTY_THREAD_DISPATCHES, newestRowForSession, threadDispatchLedgerFor, } from "../core/thread-dispatch-ledger.js";
 import { useCell } from "./use-store-cell.js";
-const POLL_INTERVAL_MS = 10_000;
-const MAX_CONSECUTIVE_READ_FAILURES = 3;
-const READ_BOUND_MS = 2 * POLL_INTERVAL_MS;
-const EMPTY_LEDGER = new Map();
-const RESUME_SUBAGENT_TOOL_NAME = "resume_subagent";
-function aResumeAwaitsLedgerTruth(rows, ledger) {
-    return rows.some((row) => {
-        if (row.kind !== "tool-call" ||
-            row.toolName !== RESUME_SUBAGENT_TOOL_NAME) {
-            return false;
-        }
-        const receipt = dispatchReceiptOf(row.result);
-        if (receipt === null || receipt.outcome === "already_settled") {
-            return false;
-        }
-        const dispatched = ledger.get(receipt.ordinal);
-        return dispatched === undefined || dispatchIsRunning(dispatched);
-    });
-}
-function newestRowForSession(map, childSessionId) {
-    let newest;
-    for (const dispatch of map.values()) {
-        if (dispatch.child_session_id !== childSessionId) {
-            continue;
-        }
-        if (newest === undefined || dispatch.ordinal > newest.ordinal) {
-            newest = dispatch;
-        }
-    }
-    return newest;
-}
-function anySubagentStillRunning(rows, ledger) {
-    return rows.some((row) => row.kind === "subagent-group" &&
-        row.entries.some((entry) => entry.receipt != null &&
-            resolvedSubagentEntryOf(entry, ledger).running));
-}
-class ThreadDispatchLedger {
-    session;
-    cell = new ObservableCell(null);
-    demands = new Map();
-    timer = null;
-    timerThreadId = null;
-    busy = false;
-    readThreadId = null;
-    pendingThreadId = null;
-    failedThreadId = null;
-    consecutiveFailures = 0;
-    constructor(session) {
-        this.session = session;
-    }
-    settleListeners = new Map();
-    setSettleListener(token, listener) {
-        if (listener === null) {
-            this.settleListeners.delete(token);
-        }
-        else {
-            this.settleListeners.set(token, listener);
-        }
-    }
-    pauseListeners = new Map();
-    setPauseListener(token, listener) {
-        if (listener === null) {
-            this.pauseListeners.delete(token);
-        }
-        else {
-            this.pauseListeners.set(token, listener);
-        }
-    }
-    setDemand(token, demand) {
-        if (demand === null) {
-            this.demands.delete(token);
-        }
-        else {
-            this.demands.set(token, demand);
-        }
-        this._reconcile();
-    }
-    refresh(threadId) {
-        if (!this.busy) {
-            return this._readOnce(threadId);
-        }
-        if (this.followUp === null || this.followUpThreadId !== threadId) {
-            this.followUpThreadId = threadId;
-            this.followUp = (this.flight ?? Promise.resolve()).then(() => {
-                this.followUp = null;
-                this.followUpThreadId = null;
-                return this._readOnce(threadId);
-            });
-        }
-        return this.followUp;
-    }
-    followUp = null;
-    followUpThreadId = null;
-    _reconcile() {
-        let threadId = null;
-        let delegated = false;
-        let stillMoving = false;
-        for (const demand of this.demands.values()) {
-            threadId ??= demand.threadId;
-            delegated ||= demand.delegated;
-            stillMoving ||= demand.stillMoving;
-        }
-        if (this.pendingThreadId !== null && this.pendingThreadId !== threadId) {
-            this.pendingThreadId = null;
-        }
-        if (threadId === null || !delegated) {
-            this._stopTimer();
-            return;
-        }
-        if (this.readThreadId !== threadId) {
-            void this._readOnce(threadId);
-        }
-        if (!stillMoving) {
-            this._stopTimer();
-            return;
-        }
-        if (this.timer === null || this.timerThreadId !== threadId) {
-            this._stopTimer();
-            void this._readOnce(threadId);
-            this.timerThreadId = threadId;
-            this.timer = window.setInterval(() => {
-                void this._readOnce(threadId);
-            }, POLL_INTERVAL_MS);
-        }
-    }
-    _sameAsCurrent(next) {
-        const current = this.cell.get();
-        if (current?.threadId !== next.threadId) {
-            return false;
-        }
-        if (current.map.size !== next.map.size) {
-            return false;
-        }
-        for (const [ordinal, dispatch] of next.map) {
-            const held = current.map.get(ordinal);
-            if (held?.status !== dispatch.status ||
-                held.error !== dispatch.error ||
-                held.updated_at !== dispatch.updated_at) {
-                return false;
-            }
-        }
-        return true;
-    }
-    _stopTimer() {
-        if (this.timer !== null) {
-            window.clearInterval(this.timer);
-            this.timer = null;
-            this.timerThreadId = null;
-        }
-    }
-    _readOnce(threadId) {
-        if (this.busy) {
-            if (threadId !== this.readThreadId) {
-                this.pendingThreadId = threadId;
-            }
-            return this.flight ?? Promise.resolve();
-        }
-        this.busy = true;
-        this.readThreadId = threadId;
-        this.generation += 1;
-        const generation = this.generation;
-        let settleFlight;
-        const flight = new Promise((resolve) => {
-            settleFlight = resolve;
-        });
-        this.flight = flight;
-        window.setTimeout(() => {
-            this._releaseBoundedOutRead(threadId, generation);
-            settleFlight();
-        }, READ_BOUND_MS);
-        void this._read(threadId, generation, settleFlight);
-        return flight;
-    }
-    flight = null;
-    generation = 0;
-    _releaseBoundedOutRead(threadId, generation) {
-        if (generation !== this.generation || !this.busy) {
-            return;
-        }
-        this.generation += 1;
-        this.busy = false;
-        this.flight = null;
-        this._noteReadFailure(threadId);
-        this._replayParkedSwitch();
-    }
-    _noteReadFailure(threadId) {
-        this.consecutiveFailures =
-            this.failedThreadId === threadId ? this.consecutiveFailures + 1 : 1;
-        this.failedThreadId = threadId;
-        if (this.consecutiveFailures >= MAX_CONSECUTIVE_READ_FAILURES &&
-            this.timerThreadId === threadId) {
-            this._stopTimer();
-        }
-        if (this.cell.get()?.threadId !== threadId) {
-            this.readThreadId = null;
-        }
-    }
-    _replayParkedSwitch() {
-        const pending = this.pendingThreadId;
-        this.pendingThreadId = null;
-        if (pending !== null && pending !== this.readThreadId) {
-            void this._readOnce(pending);
-        }
-    }
-    adoptedThrough = 0;
-    async _read(threadId, generation, settleFlight) {
-        const live = () => generation === this.generation;
-        try {
-            const dispatches = await listThreadDispatches(this.session, threadId);
-            const adopts = live() ||
-                (generation > this.adoptedThrough &&
-                    (this.readThreadId === threadId || this.readThreadId === null));
-            if (!adopts) {
-                if (this.failedThreadId === threadId) {
-                    this.failedThreadId = null;
-                    this.consecutiveFailures = 0;
-                }
-                return;
-            }
-            this.readThreadId ??= threadId;
-            this.adoptedThrough = generation;
-            const previous = this.cell.get();
-            const next = {
-                threadId,
-                map: new Map(dispatches.map((dispatch) => [dispatch.ordinal, dispatch])),
-            };
-            if (!this._sameAsCurrent(next)) {
-                this.cell.set(next);
-            }
-            this.failedThreadId = null;
-            this.consecutiveFailures = 0;
-            if (_observedASettle(previous, next)) {
-                _fireEach(this.settleListeners);
-            }
-            if (_observedAPause(previous, next)) {
-                _fireEach(this.pauseListeners);
-            }
-        }
-        catch {
-            if (!live()) {
-                return;
-            }
-            this._noteReadFailure(threadId);
-        }
-        finally {
-            if (live()) {
-                this.busy = false;
-                this.flight = null;
-                settleFlight();
-                this._replayParkedSwitch();
-            }
-        }
-    }
-}
-function _fireEach(listeners) {
-    for (const listener of new Set(listeners.values())) {
-        try {
-            listener();
-        }
-        catch {
-        }
-    }
-}
-function _observedAPause(previous, next) {
-    const comparable = previous?.threadId === next.threadId ? previous : null;
-    for (const [ordinal, dispatch] of next.map) {
-        if (!dispatchIsPaused(dispatch)) {
-            continue;
-        }
-        const held = comparable?.map.get(ordinal);
-        if (held === undefined ||
-            !dispatchIsPaused(held) ||
-            held.updated_at !== dispatch.updated_at) {
-            return true;
-        }
-    }
-    return false;
-}
-function _observedASettle(previous, next) {
-    if (previous?.threadId !== next.threadId) {
-        return false;
-    }
-    for (const [ordinal, dispatch] of next.map) {
-        if (dispatchIsRunning(dispatch)) {
-            continue;
-        }
-        const held = previous.map.get(ordinal);
-        if (held === undefined || dispatchIsRunning(held)) {
-            return true;
-        }
-    }
-    return false;
-}
-const _ledgers = new WeakMap();
-function _ledgerFor(session) {
-    let ledger = _ledgers.get(session);
-    if (ledger === undefined) {
-        ledger = new ThreadDispatchLedger(session);
-        _ledgers.set(session, ledger);
-    }
-    return ledger;
-}
-export function useThreadDispatches(session, threadId, rows, onDispatchSettled, onDispatchPaused) {
-    const ledger = _ledgerFor(session);
-    const read = useCell(ledger.cell);
-    const map = read !== null && read.threadId === threadId ? read.map : EMPTY_LEDGER;
-    const delegated = useMemo(() => rows.some((row) => row.kind === "subagent-group") ||
-        aResumeAwaitsLedgerTruth(rows, EMPTY_LEDGER), [rows]);
-    const stillMoving = useMemo(() => anySubagentStillRunning(rows, map) || aResumeAwaitsLedgerTruth(rows, map), [rows, map]);
-    const token = useMemo(() => ({}), []);
-    useEffect(() => {
-        if (threadId === null) {
-            return;
-        }
-        ledger.setDemand(token, { threadId, delegated, stillMoving });
-        return () => {
-            ledger.setDemand(token, null);
-        };
-    }, [ledger, token, threadId, delegated, stillMoving]);
-    useEffect(() => {
-        if (onDispatchSettled === undefined) {
-            return;
-        }
-        ledger.setSettleListener(token, onDispatchSettled);
-        return () => {
-            ledger.setSettleListener(token, null);
-        };
-    }, [ledger, token, onDispatchSettled]);
-    useEffect(() => {
-        if (onDispatchPaused === undefined) {
-            return;
-        }
-        ledger.setPauseListener(token, onDispatchPaused);
-        return () => {
-            ledger.setPauseListener(token, null);
-        };
-    }, [ledger, token, onDispatchPaused]);
-    const staleDeliveredOrdinals = useMemo(() => {
-        const delivered = new Set();
-        for (const row of rows) {
-            if (row.kind === "subagent-delivery") {
-                for (const result of row.results) {
-                    delivered.add(result.ordinal);
-                }
-            }
-        }
-        return [...delivered]
-            .filter((ordinal) => {
-            const ledgerRow = map.get(ordinal);
-            return ledgerRow !== undefined && dispatchIsRunning(ledgerRow);
-        })
-            .sort((a, b) => a - b)
-            .join(",");
-    }, [rows, map]);
-    useEffect(() => {
-        if (threadId !== null && staleDeliveredOrdinals !== "") {
-            void ledger.refresh(threadId);
-        }
-    }, [ledger, threadId, staleDeliveredOrdinals]);
-    return map;
+export function useThreadDispatches(session, threadId) {
+    const read = useCell(threadDispatchLedgerFor(session).cell);
+    return read !== null && read.threadId === threadId
+        ? read.map
+        : EMPTY_THREAD_DISPATCHES;
 }
 export function useChildDispatch(session, threadId, childSessionId) {
-    const ledger = _ledgerFor(session);
+    const ledger = threadDispatchLedgerFor(session);
     const read = useCell(ledger.cell);
     const dispatch = read !== null && read.threadId === threadId
         ? newestRowForSession(read.map, childSessionId)

package/dist/components/use-transcript-folds.js

@@ -4,7 +4,8 @@ import { hostFillDeclines } from "../core/host-fill.js";
 import { currentTurnStartOf, foldedBlocksOf, runFoldsOf, } from "../core/run-folds.js";
 import { subagentOutcomeCountsOf } from "../core/subagent-rows.js";
 import { ElicitationsContext } from "./elicitation-context.js";
-import { resolvedSubagentEntryOf, SubagentDispatchesContext, } from "./subagent-group-row.js";
+import { resolvedSubagentEntryOf } from "../core/subagent-ledger-join.js";
+import { SubagentDispatchesContext, } from "./subagent-group-row.js";
 export function useMessageListDerivations(source, { live, typing, turnOpen, markerBoundaries, turnStartIds, decisionSurfacesInShelf, frameClaimsLiveness, emptyFallback, }) {
     const { cards: elicitationCards } = useContext(ElicitationsContext);
     const { foldedBlocks, flatRows, displayRows } = useTranscriptFolds(source, {