@teaflask/assistant 0.6.0 → 0.7.1

package/dist/core/conversation-store.d.ts

@@ -61,6 +61,7 @@ export declare class AssistantConversationStore {
     _modelPickDirty: boolean;
     readonly _composerInput: ObservableCell<ComposerInput>;
     _nextUnboundScope: number;
+    _composerInputResets: number;
     _composerFocusOwned: string | null;
     _composerCaretReturnPending: string | null;
     _tier: VisitorTier | null;
@@ -78,6 +79,7 @@ export declare class AssistantConversationStore {
     _deliveryProbeRearm: boolean;
     _idleRecheckTimer: ReturnType<typeof setInterval> | null;
     _idleRecheckInFlight: boolean;
+    _disarmDispatchPoll: (() => void) | null;
     _disposed: boolean;
     _epoch: ConnectionEpoch | null;
     _epochResume: StreamResumeStore | null;
@@ -102,6 +104,7 @@ export declare class AssistantConversationStore {
     noteComposerFocus: (owner: string | null) => void;
     takeComposerCaretReturn: (surface: string) => boolean;
     uploadAttachment: (file: File) => Promise<ServingAttachment>;
+    addComposerFiles: (files: Iterable<File>) => Promise<void>;
     mintAttachmentDownloadUrl: (attachmentId: string) => Promise<MintedDownloadUrl>;
     acquireTranscriptLease: (surface: string) => (() => void);
     submitApprovalDecision: (card: ApprovalCardModel, decision: ApprovalDecisionInput) => Promise<void>;

package/dist/core/conversation-store.js

@@ -1,6 +1,7 @@
 import { IDLE_ACTIVITY, } from "./activity.js";
 import { noteDispatchSettledFromStore, refreshConversationFromStore, } from "./conversation-refresh.js";
 import { mintAttachmentDownloadUrlFromStore, uploadAttachmentFromStore, } from "./attachment-uploads.js";
+import { addComposerFilesFromStore } from "./composer-attachments.js";
 import { handleUserMessageInjectedFromStore, markComposerRefocusHandledFromStore, sendMessageFromStore, stopTurnFromStore, } from "./conversation-send.js";
 import { noteComposerFocusFromStore, setComposerAttachmentsFromStore, setComposerDraftFromStore, setModelPickFromStore, takeComposerCaretReturnFromStore, } from "./composer-input-state.js";
 import { submitApprovalDecisionFromStore } from "./approval-decision.js";
@@ -12,6 +13,7 @@ import { SettleRefreshScheduler } from "./settle-refresh.js";
 import { handleStreamClosedQuietlyFromStore, handleStreamErrorFromStore, handleWorkflowRestartedFromStore, retryStreamFromStore, } from "./stream-trouble.js";
 import { acquireTranscriptLeaseFromStore } from "./transcript-lease.js";
 import { clearIdleRecheck, syncIdleRecheck } from "./idle-recheck.js";
+import { armDispatchPoll, disarmDispatchPoll } from "./dispatch-poll.js";
 import { ConsumedInterruptFold } from "./consumed-interrupts.js";
 import { composerSnapshotOf, conversationSnapshotOf, publishStore, } from "./conversation-publish.js";
 import { retireEpoch } from "./epoch-sync.js";
@@ -82,6 +84,7 @@ export class AssistantConversationStore {
         attachments: [],
     });
     _nextUnboundScope = 1;
+    _composerInputResets = 0;
     _composerFocusOwned = null;
     _composerCaretReturnPending = null;
     _tier = null;
@@ -103,6 +106,7 @@ export class AssistantConversationStore {
     _deliveryProbeRearm = false;
     _idleRecheckTimer = null;
     _idleRecheckInFlight = false;
+    _disarmDispatchPoll = null;
     _disposed = false;
     _epoch = null;
     _epochResume = null;
@@ -157,6 +161,7 @@ export class AssistantConversationStore {
         this.resumeStoredThread();
         loadHistoryOnceExpected(this);
         syncIdleRecheck(this);
+        armDispatchPoll(this);
     }
     setTier(tier) {
         if (this._tier === tier) {
@@ -172,6 +177,7 @@ export class AssistantConversationStore {
         this._settleScheduler.dispose();
         this._gapGate.dispose();
         clearIdleRecheck(this);
+        disarmDispatchPoll(this);
         retireEpoch(this);
     }
     resumeStoredThread = () => {
@@ -196,6 +202,7 @@ export class AssistantConversationStore {
     };
     takeComposerCaretReturn = (surface) => takeComposerCaretReturnFromStore(this, surface);
     uploadAttachment = async (file) => uploadAttachmentFromStore(this, file);
+    addComposerFiles = async (files) => addComposerFilesFromStore(this, files);
     mintAttachmentDownloadUrl = async (attachmentId) => mintAttachmentDownloadUrlFromStore(this, attachmentId);
     acquireTranscriptLease = (surface) => acquireTranscriptLeaseFromStore(this, surface);
     submitApprovalDecision = async (card, decision) => submitApprovalDecisionFromStore(this, card, decision);

package/dist/core/dispatch-poll.js

@@ -0,0 +1,81 @@
+import { demandInputOfMessages, dispatchDemandOf, dispatchJoinKeyOf, RESUME_SUBAGENT_TOOL_NAME, staleDeliveredOrdinalsKeyOf, } from "./subagent-ledger-join.js";
+import { DISPATCH_SUBAGENT_TOOL_NAME } from "./subagent-rows.js";
+import { EMPTY_THREAD_DISPATCHES, threadDispatchLedgerFor, } from "./thread-dispatch-ledger.js";
+export function armDispatchPoll(store) {
+    if (store._disarmDispatchPoll !== null) {
+        return;
+    }
+    const ledger = threadDispatchLedgerFor(store.deps.session);
+    ledger.setSettleListener(store, store.noteDispatchSettled);
+    ledger.setPauseListener(store, store.noteDispatchPaused);
+    let queued = false;
+    let lastTapKey = "";
+    const judge = () => {
+        queued = false;
+        if (store._disposed || store._disarmDispatchPoll === null) {
+            return;
+        }
+        lastTapKey = _judgeDemand(store, ledger, lastTapKey);
+    };
+    const schedule = () => {
+        if (queued) {
+            return;
+        }
+        queued = true;
+        queueMicrotask(judge);
+    };
+    const unsubscribes = [
+        store.messages.subscribe(schedule),
+        store.markerAnchors.subscribe(schedule),
+        store.connection.subscribe(schedule),
+        ledger.cell.subscribe(schedule),
+    ];
+    store._disarmDispatchPoll = () => {
+        for (const unsubscribe of unsubscribes) {
+            unsubscribe();
+        }
+        ledger.setDemand(store, null);
+        ledger.setSettleListener(store, null);
+        ledger.setPauseListener(store, null);
+    };
+    schedule();
+}
+export function disarmDispatchPoll(store) {
+    const disarm = store._disarmDispatchPoll;
+    if (disarm === null) {
+        return;
+    }
+    store._disarmDispatchPoll = null;
+    disarm();
+}
+export function noteThreadRead(store, threadId) {
+    threadDispatchLedgerFor(store.deps.session).noteThreadAnswered(threadId);
+}
+function _judgeDemand(store, ledger, lastTapKey) {
+    const threadId = store.connection.get()?.threadId ?? null;
+    const messages = store.messages.get();
+    if (threadId === null || !_delegates(messages)) {
+        ledger.setDemand(store, null);
+        return "";
+    }
+    const input = demandInputOfMessages(messages, store.markerAnchors.get());
+    const read = ledger.cell.get();
+    const map = read !== null && read.threadId === threadId
+        ? read.map
+        : EMPTY_THREAD_DISPATCHES;
+    ledger.setDemand(store, {
+        threadId,
+        ...dispatchDemandOf(input, map),
+        joinKey: dispatchJoinKeyOf(input),
+    });
+    const tapKey = staleDeliveredOrdinalsKeyOf(input, map);
+    if (tapKey !== "" && tapKey !== lastTapKey) {
+        void ledger.refresh(threadId);
+    }
+    return tapKey;
+}
+function _delegates(messages) {
+    return messages.some((message) => message.role === "assistant" &&
+        (message.toolCalls ?? []).some((call) => call.function.name === DISPATCH_SUBAGENT_TOOL_NAME ||
+            call.function.name === RESUME_SUBAGENT_TOOL_NAME));
+}

package/dist/core/elicitation-answers.js

@@ -14,6 +14,7 @@ async function _deliverQuestionSetReport(store, card, result, answered) {
     const epoch = store._epoch;
     const active = store._active;
     if (epoch === null || active === null) {
+        _stampAnswerNotSent(store, card);
         return;
     }
     const inbox = epoch.executionInbox;
@@ -57,6 +58,17 @@ async function _deliverQuestionSetReport(store, card, result, answered) {
         publishIfCurrent();
     }
 }
+function _stampAnswerNotSent(store, card) {
+    store._elicitationErrors.set(card.interruptId, ANSWER_NOT_SENT_SENTENCE);
+    const cards = store._elicitationsCell.get();
+    const next = cards.map((item) => item.interruptId === card.interruptId &&
+        item.errorSentence !== ANSWER_NOT_SENT_SENTENCE
+        ? { ...item, errorSentence: ANSWER_NOT_SENT_SENTENCE }
+        : item);
+    if (next.some((item, index) => item !== cards[index])) {
+        store._elicitationsCell.set(next);
+    }
+}
 function _turnNoLongerAwaitingToolResults(error) {
     return (error instanceof ServingApiError &&
         error.code === "ASSISTANT_TURN_NOT_AWAITING_TOOL_RESULTS");

package/dist/core/elicitation-cards.d.ts

@@ -10,8 +10,18 @@ interface ElicitationCardBase {
     status: ElicitationCardStatus;
     errorSentence: string | null;
 }
+/**
+ * A set of up to five questions the agent asked the visitor, answered together
+ * in one submission or dismissed together.
+ */
 export interface QuestionSetCardModel extends ElicitationCardBase {
+    /** The questions, in the order the visitor should see them. */
     questions: readonly QuestionModel[];
+    /**
+     * What this page submitted, either the answers or a cancellation. Null
+     * before it submits, and for sets answered elsewhere or earlier in the
+     * conversation, where the transcript's tool row shows the outcome.
+     */
     answered: AnsweredQuestions | null;
 }
 export type AnsweredQuestions = {
@@ -23,6 +33,10 @@ export type AnsweredQuestions = {
 } | {
     kind: "cancelled";
 };
+/**
+ * A request from the agent for the visitor to answer questions; currently
+ * always a question set.
+ */
 export type ElicitationCardModel = QuestionSetCardModel;
 export declare function elicitationCardsOf(entries: readonly ExecutionEntryModel[], errorSentences: ReadonlyMap<string, string>, questionAnswers?: ReadonlyMap<string, AnsweredQuestions>): ElicitationCardModel[];
 export declare function sameElicitationCards(a: readonly ElicitationCardModel[], b: readonly ElicitationCardModel[]): boolean;

package/dist/core/elicitation-pickers.d.ts

@@ -1,11 +1,27 @@
+/** One suggested answer to a question. */
 export interface QuestionOptionModel {
+    /**
+     * The suggestion as the visitor reads it; if they pick it, submit this
+     * exact text as their answer.
+     */
     text: string;
+    /** A one-line explanation of the suggestion, or null when there is none. */
     description: string | null;
 }
+/** One question in a question set. */
 export interface QuestionModel {
+    /**
+     * The question's id, unique within its set; use it as the id of its answer.
+     */
     id: string;
+    /** A short label for the question, a few words long. */
     heading: string;
+    /** The question, exactly as the visitor should read it. */
     prompt: string;
+    /**
+     * Suggested answers, up to eight; empty for an open question. Always let
+     * the visitor write their own answer as well.
+     */
     options: readonly QuestionOptionModel[];
 }
 export declare function askQuestionsActionOf(action: Record<string, unknown> | null): {

package/dist/core/execution-handlers.js

@@ -55,7 +55,7 @@ export function executionHandlersFor(navigate, executeActionIntent, threadId) {
     }
     handlers.set(READ_PAGE_REQUEST_KIND, (entry) => _readPageOutcomeOf(threadId, entry));
     handlers.set(HIGHLIGHT_REQUEST_KIND, (entry) => Promise.resolve(_highlightOutcomeOf(entry)));
-    handlers.set(PREFILL_FORM_REQUEST_KIND, (entry) => Promise.resolve(_prefillFormOutcomeOf(entry)));
+    handlers.set(PREFILL_FORM_REQUEST_KIND, (entry) => _prefillFormOutcomeOf(entry));
     return handlers;
 }
 async function _navigateOutcomeOf(navigate, entry) {
@@ -316,13 +316,13 @@ function _highlightFailedOutcome(error) {
         },
     };
 }
-function _prefillFormOutcomeOf(entry) {
+async function _prefillFormOutcomeOf(entry) {
     const fields = _prefillFieldsOf(entry.action);
     if (fields === null) {
         return UNUSABLE_FIELDS_OUTCOME;
     }
     try {
-        const result = prefilledFieldsReport(fields);
+        const result = await prefilledFieldsReport(fields, browserLayoutProbe());
         return { ok: true, result: { ...result } };
     }
     catch (error) {

package/dist/core/memory-provenance-anchors.d.ts

@@ -1,7 +1,23 @@
 import type { AgentSubscriber } from "@ag-ui/client";
+/**
+ * A notice that the assistant saved a memory. It never contains the memory's
+ * content.
+ */
 export interface MemoryUpdated {
+    /**
+     * The saved memory's id; a repeated report of the same save carries the
+     * same id, so use it to de-duplicate.
+     */
     memoryId: string;
+    /**
+     * Who the memory is for: "org" is shared across all your users, "user" is
+     * private to the current user. Show any other value generically.
+     */
     scope: string;
+    /**
+     * A short sentence for the user saying a memory was saved, not the memory
+     * itself.
+     */
     summary: string;
 }
 export declare const EMPTY_MEMORY_PROVENANCE_ANCHORS: ReadonlyMap<string, MemoryUpdated>;

package/dist/core/observable-cell.d.ts

@@ -1,5 +1,17 @@
+/**
+ * An observable value from the assistant, readable without React (use useCell
+ * inside React).
+ */
 export interface ReadonlyCell<T> {
+    /**
+     * Returns the current value. The returned object only changes identity when
+     * the value changes, so you can compare by reference.
+     */
     get: () => T;
+    /**
+     * Calls the listener after every change and returns a function that
+     * unsubscribes it.
+     */
     subscribe: (listener: () => void) => () => void;
 }
 export declare class ObservableCell<T> implements ReadonlyCell<T> {

package/dist/core/pending-decision-gap.d.ts

@@ -9,8 +9,17 @@ export interface GapJudgeableTurn {
 interface InterruptHolder {
     interruptId: string;
 }
+/**
+ * The agent is waiting on requests that nothing on this page can show or
+ * answer, which usually means the conversation needs reloading.
+ */
 export interface PendingDecisionGap {
+    /** The id of the waiting turn. */
     turnId: string;
+    /**
+     * The ids of the waiting requests (approvals, questions or page actions)
+     * that have nothing on this page to answer them.
+     */
     missingInterruptIds: readonly string[];
 }
 export declare function pendingDecisionGapOf(turn: GapJudgeableTurn | null, approvalCards: readonly InterruptHolder[], elicitationCards: readonly InterruptHolder[], executionEntries: readonly InterruptHolder[], consumedInterruptIds?: ReadonlySet<string>): PendingDecisionGap | null;

package/dist/core/question-drafts.d.ts

@@ -4,29 +4,88 @@ type ActiveChoice = {
 } | {
     kind: "custom";
 } | null;
+/** The visitor's unsent answer to one question. */
 export interface QuestionAnswerDraft {
+    /**
+     * The selected answer, either { kind: "option", text } for a suggestion, {
+     * kind: "custom" } for the visitor's own text, or null when nothing is
+     * selected yet.
+     */
     active: ActiveChoice;
+    /**
+     * The visitor's own typed answer. Kept when they select a suggestion
+     * instead, so they can switch back.
+     */
     customText: string;
 }
+/** The visitor's unsent answers to one question set. */
 export interface QuestionSetDraft {
+    /** Index of the question the visitor is on, starting at 0. */
     cursor: number;
+    /**
+     * Unsent answers keyed by question id; questions the visitor hasn't touched
+     * are absent.
+     */
     answers: ReadonlyMap<string, QuestionAnswerDraft>;
 }
 export interface QuestionLike {
     id: string;
 }
 export declare const MAX_ANSWER_TEXT_CHARS = 1900;
+/**
+ * Holds the visitor's unsent answers to question sets, keyed by the card's
+ * interruptId then the question's id. Subscribe to it (for example with React's
+ * useSyncExternalStore and get) to re-render as answers change.
+ */
 export declare class QuestionDraftStore {
     private readonly drafts;
     private readonly listeners;
+    /**
+     * Returns the unsent answers for one question set, or an empty draft
+     * (cursor 0, no answers) if nothing has been entered. The same object is
+     * returned until that draft changes.
+     */
     get: (interruptId: string) => QuestionSetDraft;
+    /**
+     * Calls the listener after any draft changes and returns a function that
+     * unsubscribes it.
+     */
     subscribe: (listener: () => void) => (() => void);
+    /**
+     * True when the visitor has selected or typed anything for this question
+     * set; use it to confirm before discarding on cancel.
+     */
     hasContent(interruptId: string): boolean;
+    /**
+     * Selects the suggestion with this text as the answer to one question,
+     * keeping any text the visitor typed.
+     */
     selectOption(interruptId: string, questionId: string, text: string): void;
+    /**
+     * Selects the visitor's own typed answer for one question, without changing
+     * its text.
+     */
     selectCustom(interruptId: string, questionId: string): void;
+    /**
+     * Sets the visitor's own answer to one question and selects it. Control
+     * characters are removed, except that vertical tabs and form feeds become
+     * line breaks.
+     */
     setCustomText(interruptId: string, questionId: string, text: string): void;
+    /**
+     * Records which question the visitor is on (an index into the set's
+     * questions), so returning to the set shows the same question.
+     */
     setCursor(interruptId: string, cursor: number): void;
+    /**
+     * Discards the unsent answers for one question set. Answers are already
+     * cleared after a successful submit or cancel.
+     */
     clear(interruptId: string): void;
+    /**
+     * Discards the unsent answers for every question set. Already done when the
+     * visitor switches or starts a conversation.
+     */
     clearAll(): void;
     private updateAnswer;
     private notify;

package/dist/core/receipt-anchors.d.ts

@@ -1,6 +1,15 @@
 import type { AgentSubscriber } from "@ag-ui/client";
+/**
+ * Notice sentences attached to one message, split by whether they are shown
+ * before or after it.
+ */
 export interface AnchoredReceipts {
+    /**
+     * Sentences shown before the message. The package places failure notices
+     * after the message, so this is normally empty.
+     */
     before: string[];
+    /** Sentences shown after the message. */
     after: string[];
 }
 export declare function receiptOf(value: unknown): string | null;

package/dist/core/segment-timing.d.ts

@@ -1,13 +1,36 @@
+/**
+ * When a message or tool call started and ended, by the server's clock in
+ * milliseconds since the Unix epoch.
+ */
 export interface BlockTiming {
+    /** The earliest server timestamp seen for it, or null when unknown. */
     startedAtMs: number | null;
+    /**
+     * The latest server timestamp seen for it, or null when unknown. Equals
+     * startedAtMs until its end arrives.
+     */
     settledAtMs: number | null;
 }
+/**
+ * A duration that is either unknown (hide it) or measured in milliseconds;
+ * render a measured value under 1000 as "<1s" rather than "0s".
+ */
 export type SegmentDuration = {
     kind: "unknown";
 } | {
     kind: "measured";
     durationMs: number;
 };
+/**
+ * How long the given blocks took together, from the earliest to the latest
+ * server timestamp among them, or unknown when none has a timestamp.
+ */
 export declare function settledFoldDurationOf(members: readonly BlockTiming[]): SegmentDuration;
 export declare function durationLabelOf(durationMs: number): string;
+/**
+ * Time elapsed from the earliest server timestamp among the given blocks to
+ * `nowMs` (milliseconds since the Unix epoch), or unknown when none has a
+ * timestamp. Passing Date.now() includes any difference between the device
+ * clock and the server clock.
+ */
 export declare function activeFoldElapsedOf(members: readonly BlockTiming[], nowMs: number): SegmentDuration;

package/dist/core/subagent-delivery-anchors.d.ts

@@ -1,7 +1,14 @@
 import type { AgentSubscriber } from "@ag-ui/client";
+/** One finished sub-agent whose result a turn reports. */
 export interface DeliveredResult {
+    /**
+     * The sub-agent's number within the conversation, matching
+     * DispatchReceipt.ordinal of its dispatch.
+     */
     ordinal: number;
+    /** A short excerpt of the task the sub-agent was given. */
     label: string;
+    /** True when the sub-agent succeeded, false when it failed. */
     succeeded: boolean;
 }
 export declare const EMPTY_SUBAGENT_DELIVERY_ANCHORS: ReadonlyMap<string, DeliveredResult[]>;

package/dist/core/subagent-ledger-join.js

@@ -0,0 +1,176 @@
+import { dispatchFailed, dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
+import { subagentIdentityTokenOf } from "./agent-identity.js";
+import { DISPATCH_SUBAGENT_TOOL_NAME, dispatchReceiptOf, withSubagentGroups, } from "./subagent-rows.js";
+export function resolvedSubagentEntryOf(entry, byOrdinal) {
+    const ledger = entry.receipt != null ? byOrdinal.get(entry.receipt.ordinal) : undefined;
+    const ledgerLabel = ledger !== undefined && ledger.label !== "" ? ledger.label : null;
+    const childSessionId = ledger !== undefined && entry.receipt?.childSessionId != null
+        ? entry.receipt.childSessionId
+        : null;
+    const running = ledger !== undefined ? dispatchIsRunning(ledger) : entry.running;
+    const failed = ledger !== undefined ? dispatchFailed(ledger) : entry.failed;
+    return {
+        toolCallId: entry.toolCallId,
+        label: ledgerLabel ?? entry.label,
+        running,
+        failed,
+        cancelled: entry.cancelled,
+        note: (ledger !== undefined && dispatchFailed(ledger) ? ledger.error : null) ??
+            entry.note,
+        childSessionId,
+        identityToken: childSessionId !== null ? subagentIdentityTokenOf(childSessionId) : null,
+        ordinal: entry.receipt?.ordinal ?? null,
+        paused: ledger !== undefined && dispatchIsPaused(ledger),
+        startedAt: ledger !== undefined ? ledger.created_at : null,
+        settledAt: ledger !== undefined && !running ? ledger.updated_at : null,
+    };
+}
+export const RESUME_SUBAGENT_TOOL_NAME = "resume_subagent";
+export function demandInputOfRows(rows) {
+    const entries = [];
+    const resumeResults = [];
+    const deliveredOrdinals = [];
+    for (const row of rows) {
+        if (row.kind === "subagent-group") {
+            entries.push(...row.entries);
+        }
+        else if (row.kind === "tool-call" &&
+            row.toolName === RESUME_SUBAGENT_TOOL_NAME) {
+            resumeResults.push(row.result);
+        }
+        else if (row.kind === "subagent-delivery") {
+            deliveredOrdinals.push(...row.results.map((result) => result.ordinal));
+        }
+    }
+    return { entries, resumeResults, deliveredOrdinals };
+}
+export function demandInputOfMessages(messages, anchors) {
+    const results = new Map();
+    for (const message of messages) {
+        if (message.role === "tool" && typeof message.content === "string") {
+            results.set(message.toolCallId, message.content);
+        }
+    }
+    const calls = [];
+    const resumeResults = [];
+    for (const message of messages) {
+        if (message.role !== "assistant") {
+            continue;
+        }
+        for (const toolCall of message.toolCalls ?? []) {
+            const id = toolCall.id;
+            if (toolCall.function.name === RESUME_SUBAGENT_TOOL_NAME) {
+                resumeResults.push(results.get(id));
+                continue;
+            }
+            if (toolCall.function.name !== DISPATCH_SUBAGENT_TOOL_NAME) {
+                continue;
+            }
+            const failed = anchors.toolErrorAnchors.has(id);
+            const denied = !failed && (anchors.toolDenialAnchors?.has(id) ?? false);
+            const cancelled = !failed && !denied && anchors.toolCancelAnchors.has(id);
+            const refused = !failed && !denied && !cancelled && anchors.toolRefusalAnchors.has(id);
+            if (denied || refused) {
+                continue;
+            }
+            const result = results.get(id);
+            calls.push({
+                toolCallId: id,
+                settled: failed || cancelled || result !== undefined,
+                failed,
+                cancelled,
+                result,
+                errorText: undefined,
+                argsText: toolCall.function.arguments,
+            });
+        }
+    }
+    const entries = withSubagentGroups(calls, (call) => call, (call) => call.toolCallId).flatMap((row) => ("entries" in row ? row.entries : []));
+    const deliveredOrdinals = [];
+    for (const delivered of anchors.subagentDeliveryAnchors.values()) {
+        deliveredOrdinals.push(...delivered.map((result) => result.ordinal));
+    }
+    return { entries, resumeResults, deliveredOrdinals };
+}
+function aResumeAwaitsLedgerTruth(resumeResults, ledger) {
+    return resumeResults.some((result) => {
+        const receipt = dispatchReceiptOf(result);
+        if (receipt === null || receipt.outcome === "already_settled") {
+            return false;
+        }
+        const dispatched = ledger.get(receipt.ordinal);
+        return dispatched === undefined || dispatchIsRunning(dispatched);
+    });
+}
+function anySubagentStillRunning(entries, ledger) {
+    return entries.some((entry) => entry.receipt != null && resolvedSubagentEntryOf(entry, ledger).running);
+}
+export function dispatchDemandOf(input, byOrdinal) {
+    return {
+        delegated: input.entries.length > 0 ||
+            aResumeAwaitsLedgerTruth(input.resumeResults, EMPTY_BY_ORDINAL),
+        stillMoving: anySubagentStillRunning(input.entries, byOrdinal) ||
+            aResumeAwaitsLedgerTruth(input.resumeResults, byOrdinal),
+    };
+}
+const EMPTY_BY_ORDINAL = new Map();
+export function dispatchJoinKeyOf(input) {
+    const ordinals = new Set();
+    for (const entry of input.entries) {
+        if (entry.receipt !== null) {
+            ordinals.add(entry.receipt.ordinal);
+        }
+    }
+    for (const result of input.resumeResults) {
+        const receipt = dispatchReceiptOf(result);
+        if (receipt !== null) {
+            ordinals.add(receipt.ordinal);
+        }
+    }
+    return [...ordinals].sort((a, b) => a - b).join(",");
+}
+export function staleDeliveredOrdinalsKeyOf(input, byOrdinal) {
+    return [...new Set(input.deliveredOrdinals)]
+        .filter((ordinal) => {
+        const ledgerRow = byOrdinal.get(ordinal);
+        return ledgerRow !== undefined && dispatchIsRunning(ledgerRow);
+    })
+        .sort((a, b) => a - b)
+        .join(",");
+}
+export function withDispatchLedger(rows, byOrdinal) {
+    if (byOrdinal.size === 0) {
+        return rows;
+    }
+    let out = null;
+    for (const [index, row] of rows.entries()) {
+        if (row.kind !== "subagent-group") {
+            continue;
+        }
+        const joined = _joinedGroupRowOf(row, byOrdinal);
+        if (joined !== row) {
+            out ??= [...rows];
+            out[index] = joined;
+        }
+    }
+    return out ?? rows;
+}
+function _joinedGroupRowOf(row, byOrdinal) {
+    let entries = null;
+    for (const [index, entry] of row.entries.entries()) {
+        const resolved = resolvedSubagentEntryOf(entry, byOrdinal);
+        if (resolved.running === entry.running &&
+            resolved.failed === entry.failed &&
+            resolved.note === entry.note) {
+            continue;
+        }
+        entries ??= [...row.entries];
+        entries[index] = {
+            ...entry,
+            running: resolved.running,
+            failed: resolved.failed,
+            note: resolved.note,
+        };
+    }
+    return entries === null ? row : { ...row, entries };
+}