@teaflask/assistant 0.0.0 → 0.3.0

package/src/affordances/prefill.ts

@@ -0,0 +1,253 @@
+// Filling without submitting: the reversible half of a form. Each field
+// is resolved by the reader's ref, guarded (secrets, files, disabled
+// controls are refused with no way to opt out — the write-side twin of
+// the snapshot's redaction), written through the element's own prototype
+// setter with real input/change events (a React-controlled input ignores
+// a bare .value assignment), and then read back: a value the page's own
+// scripts rejected is reported as refused, never claimed as filled.
+// Nothing here ever submits, clicks a button, or focuses past the field.
+
+import { theFieldHoldsASecret } from "../reader/redaction.js";
+import { resolvedElementOfRef } from "../reader/snapshot.js";
+import { isContentEditableElement } from "../reader/roles.js";
+
+export interface PrefillField {
+  refId: string;
+  value: string;
+}
+
+interface RefusedFieldReport {
+  ref_id: string;
+  reason: string;
+}
+
+/** The wire shape of PrefillFormResult, synthesized package-side. */
+export interface PrefillReport {
+  filled: string[];
+  refused: RefusedFieldReport[];
+}
+
+const SECRET_FIELD_REASON =
+  "This field holds a secret (a password or payment detail) — the user " +
+  "must type it themselves.";
+const FILE_FIELD_REASON =
+  "File pickers cannot be filled by the assistant — the user must choose " +
+  "the file themselves.";
+const INERT_FIELD_REASON =
+  "This field is disabled or read-only and cannot take a value right now.";
+const NOT_FILLABLE_REASON =
+  "This element is not a fillable form field — take a fresh read and " +
+  "pick a textbox, dropdown, checkbox, or editor ref.";
+const CHECKBOX_VALUE_REASON =
+  'A checkbox takes "true" or "false", nothing else.';
+const RADIO_VALUE_REASON =
+  'A radio button can only be selected — pass "true" on the option to ' +
+  "select instead.";
+const NO_MATCHING_OPTION_REASON =
+  "No option in this dropdown matches that value — read the page to see " +
+  "the options it offers.";
+const VALUE_DID_NOT_LAND_REASON =
+  "The page's own scripts rejected this value — it did not stay in the " +
+  "field.";
+const EDITOR_UNAVAILABLE_REASON =
+  "This editor cannot be filled on this page — tell the user what to " +
+  "type instead.";
+
+/**
+ * Fill every requested field, one report entry per field — a batch is
+ * never all-or-nothing: the fields that landed stay landed, and each
+ * refusal carries its own actionable reason.
+ */
+export function prefilledFieldsReport(fields: PrefillField[]): PrefillReport {
+  const report: PrefillReport = { filled: [], refused: [] };
+  for (const field of fields) {
+    const refusal = _filledFieldRefusalOf(field);
+    if (refusal === null) {
+      report.filled.push(field.refId);
+    } else {
+      report.refused.push({ ref_id: field.refId, reason: refusal });
+    }
+  }
+  return report;
+}
+
+/** Fill one field; the refusal reason, or null when the value landed. */
+function _filledFieldRefusalOf(field: PrefillField): string | null {
+  const resolved = resolvedElementOfRef(field.refId);
+  if (resolved.error !== null) {
+    return resolved.error;
+  }
+  const element = resolved.element;
+  if (element instanceof HTMLInputElement) {
+    return _inputRefusalOf(element, field.value);
+  }
+  if (element instanceof HTMLTextAreaElement) {
+    return _textAreaRefusalOf(element, field.value);
+  }
+  if (element instanceof HTMLSelectElement) {
+    return _selectRefusalOf(element, field.value);
+  }
+  if (isContentEditableElement(element)) {
+    return _editorRefusalOf(element, field.value);
+  }
+  return NOT_FILLABLE_REASON;
+}
+
+// --- inputs ------------------------------------------------------------------
+
+const _NOT_A_FIELD_INPUT_TYPES = new Set([
+  "hidden",
+  "submit",
+  "button",
+  "reset",
+  "image",
+]);
+
+function _inputRefusalOf(
+  input: HTMLInputElement,
+  value: string,
+): string | null {
+  if (input.type === "password" || theFieldHoldsASecret(input)) {
+    return SECRET_FIELD_REASON;
+  }
+  if (input.type === "file") {
+    return FILE_FIELD_REASON;
+  }
+  // Hidden inputs hold machine state the user never sees — writing one
+  // would change what the form submits with nothing to review. The
+  // button family is not a field at all: its value IS the visible
+  // caption, so "filling" one would relabel a button.
+  if (_NOT_A_FIELD_INPUT_TYPES.has(input.type)) {
+    return NOT_FILLABLE_REASON;
+  }
+  if (input.disabled || input.readOnly) {
+    return INERT_FIELD_REASON;
+  }
+  if (input.type === "checkbox" || input.type === "radio") {
+    return _checkedRefusalOf(input, value);
+  }
+  _setThroughThePrototype(input, value);
+  _announceTheEdit(input);
+  return input.value === value ? null : VALUE_DID_NOT_LAND_REASON;
+}
+
+function _checkedRefusalOf(
+  input: HTMLInputElement,
+  value: string,
+): string | null {
+  if (value !== "true" && value !== "false") {
+    return CHECKBOX_VALUE_REASON;
+  }
+  if (input.type === "radio" && value === "false") {
+    return RADIO_VALUE_REASON;
+  }
+  const desired = value === "true";
+  if (input.checked !== desired) {
+    // A real click, not a checked assignment: it is the one event shape
+    // every framework's change handling hears, and on a checkbox it is
+    // still reversible prep — the user can click it right back.
+    input.click();
+  }
+  return input.checked === desired ? null : VALUE_DID_NOT_LAND_REASON;
+}
+
+// --- textareas ----------------------------------------------------------------
+
+function _textAreaRefusalOf(
+  textArea: HTMLTextAreaElement,
+  value: string,
+): string | null {
+  if (theFieldHoldsASecret(textArea)) {
+    return SECRET_FIELD_REASON;
+  }
+  if (textArea.disabled || textArea.readOnly) {
+    return INERT_FIELD_REASON;
+  }
+  _setThroughThePrototype(textArea, value);
+  _announceTheEdit(textArea);
+  return textArea.value === value ? null : VALUE_DID_NOT_LAND_REASON;
+}
+
+// --- selects --------------------------------------------------------------------
+
+function _selectRefusalOf(
+  select: HTMLSelectElement,
+  value: string,
+): string | null {
+  if (select.disabled) {
+    return INERT_FIELD_REASON;
+  }
+  const option = _optionMatching(select, value);
+  if (option === null) {
+    return NO_MATCHING_OPTION_REASON;
+  }
+  _setThroughThePrototype(select, option.value);
+  _announceTheEdit(select);
+  return select.value === option.value ? null : VALUE_DID_NOT_LAND_REASON;
+}
+
+function _optionMatching(
+  select: HTMLSelectElement,
+  value: string,
+): HTMLOptionElement | null {
+  const options = Array.from(select.options);
+  // The model quotes what it saw: sometimes the option's value,
+  // sometimes its visible label.
+  return (
+    options.find((option) => option.value === value) ??
+    options.find((option) => option.label.trim() === value.trim()) ??
+    null
+  );
+}
+
+// --- contenteditable editors ----------------------------------------------------
+
+function _editorRefusalOf(element: Element, value: string): string | null {
+  // The caller established contenteditable; this narrows for focus().
+  if (!(element instanceof HTMLElement)) {
+    return EDITOR_UNAVAILABLE_REASON;
+  }
+  // execCommand is deprecated but is the one path that speaks a rich
+  // editor's own language: it fires the beforeinput/input sequence the
+  // editor's model listens to. jsdom has neither it nor selections.
+  /* eslint-disable @typescript-eslint/no-deprecated -- no substitute
+     fires an editor's own input pipeline; see the comment above. */
+  if (typeof document.execCommand !== "function") {
+    return EDITOR_UNAVAILABLE_REASON;
+  }
+  element.focus();
+  const selection = window.getSelection();
+  if (selection === null) {
+    return EDITOR_UNAVAILABLE_REASON;
+  }
+  selection.selectAllChildren(element);
+  document.execCommand("insertText", false, value);
+  /* eslint-enable @typescript-eslint/no-deprecated -- back to the rule
+     for everything below the editor write. */
+  const landed = element.textContent.includes(value);
+  return landed ? null : VALUE_DID_NOT_LAND_REASON;
+}
+
+// --- the write mechanics ---------------------------------------------------------
+
+type ValueControl = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+
+function _setThroughThePrototype(control: ValueControl, value: string): void {
+  // React tracks a control's value on the instance to dedupe its own
+  // synthetic events; writing through the prototype setter bypasses the
+  // tracker so the input event below is heard as a real user edit.
+  const descriptor = Object.getOwnPropertyDescriptor(
+    Object.getPrototypeOf(control) as object,
+    "value",
+  );
+  if (descriptor?.set !== undefined) {
+    descriptor.set.call(control, value);
+  } else {
+    control.value = value;
+  }
+}
+
+function _announceTheEdit(control: ValueControl): void {
+  control.dispatchEvent(new Event("input", { bubbles: true }));
+  control.dispatchEvent(new Event("change", { bubbles: true }));
+}

package/src/appearance/theme.ts

@@ -0,0 +1,122 @@
+// The JS half of the theming contract: a typed mirror of the 21 public
+// `--tf-*` tokens (src/styles/styles.css) and the pure mapping from the
+// camelCase config object to CSS variable declarations. Deliberately
+// plain data and a plain function — no React — so the script-tag
+// distribution can carry the exact same config object.
+
+export type AssistantThemeMode = "light" | "dark" | "auto";
+
+export interface AssistantThemeTokens {
+  background?: string;
+  foreground?: string;
+  card?: string;
+  cardForeground?: string;
+  popover?: string;
+  popoverForeground?: string;
+  primary?: string;
+  primaryForeground?: string;
+  secondary?: string;
+  secondaryForeground?: string;
+  muted?: string;
+  mutedForeground?: string;
+  accent?: string;
+  accentForeground?: string;
+  destructive?: string;
+  border?: string;
+  input?: string;
+  ring?: string;
+  /** A bare number means pixels. */
+  radius?: string | number;
+  fontSans?: string;
+  /** The UA scheme native form controls draw their indicators from
+   *  ("light" or "dark") — for hosts that dark-theme with tokens alone,
+   *  so native control chrome stays legible. The mode prop and the
+   *  data-tf-theme attribute already flip the default; a set value wins
+   *  in both modes, like every --tf-* token. */
+  colorScheme?: string;
+}
+
+// Dark can flip every color, but never the geometry or the typeface —
+// the stylesheet's dark block holds the same line. colorScheme is also
+// mode-independent by construction: the stylesheet's dark blocks read
+// no --_tf-dark-color-scheme, they already default the scheme to dark.
+export type AssistantThemeDarkTokens = Omit<
+  AssistantThemeTokens,
+  "radius" | "fontSans" | "colorScheme"
+>;
+
+export interface AssistantTheme extends AssistantThemeTokens {
+  /**
+   * Values that take over whenever dark is active — via the provider's
+   * `mode` prop or a `data-tf-theme="dark"` attribute on any ancestor.
+   */
+  dark?: AssistantThemeDarkTokens;
+}
+
+// Typed key lists so the mapping iterates without Object.keys widening,
+// and so the parity test can pin this module to the stylesheet.
+export const THEME_TOKEN_KEYS: readonly (keyof AssistantThemeTokens)[] = [
+  "background",
+  "foreground",
+  "card",
+  "cardForeground",
+  "popover",
+  "popoverForeground",
+  "primary",
+  "primaryForeground",
+  "secondary",
+  "secondaryForeground",
+  "muted",
+  "mutedForeground",
+  "accent",
+  "accentForeground",
+  "destructive",
+  "border",
+  "input",
+  "ring",
+  "radius",
+  "fontSans",
+  "colorScheme",
+];
+
+export const DARK_THEME_TOKEN_KEYS: readonly (keyof AssistantThemeDarkTokens)[] =
+  THEME_TOKEN_KEYS.filter(
+    (key): key is keyof AssistantThemeDarkTokens =>
+      key !== "radius" && key !== "fontSans" && key !== "colorScheme",
+  );
+
+/**
+ * Maps a theme config to the CSS variables the widget roots carry
+ * inline. Base values set the public `--tf-*` tokens — inline beats any
+ * ambient host CSS, which is the prop-wins precedence. Dark values set
+ * the private `--_tf-dark-*` mechanism variables the stylesheet's dark
+ * blocks read first, so they stay out of the public token contract.
+ */
+export function themeToStyleVars(
+  theme: AssistantTheme,
+): Record<string, string> {
+  const vars: Record<string, string> = {};
+  for (const key of THEME_TOKEN_KEYS) {
+    const value = theme[key];
+    if (value !== undefined) {
+      vars[`--tf-${_cssNameOf(key)}`] = _cssValueOf(value);
+    }
+  }
+  for (const key of DARK_THEME_TOKEN_KEYS) {
+    const value = theme.dark?.[key];
+    if (value !== undefined) {
+      vars[`--_tf-dark-${_cssNameOf(key)}`] = _cssValueOf(value);
+    }
+  }
+  return vars;
+}
+
+function _cssNameOf(key: string): string {
+  return key.replace(/[A-Z]/g, (upper) => `-${upper.toLowerCase()}`);
+}
+
+// React does not px-suffix numbers on custom properties the way it does
+// on known style props, so the mapping owns the unit.
+function _cssValueOf(value: string | number): string {
+  return typeof value === "number" ? `${String(value)}px` : value;
+}

package/src/components/activity-rail.tsx

@@ -0,0 +1,277 @@
+"use client";
+
+import { useContext } from "react";
+
+import { activityTitleOf } from "../core/activity-title.js";
+import type { ApprovalCardModel } from "../core/approval-inbox.js";
+import type { ElicitationCardModel } from "../core/elicitation-cards.js";
+import {
+  liveFoldHeadlineOf,
+  settledFoldHeadlineOf,
+  type RunFoldMember,
+  type RunFoldRow,
+  type RunFoldStep,
+} from "../core/run-folds.js";
+
+import {
+  approvalAwaitsMember,
+  elicitationAwaitsMember,
+} from "../core/suspension-queue.js";
+import { anchoredCardsFor } from "./approval-context.js";
+import {
+  anchoredElicitationsFor,
+  ElicitationsContext,
+} from "./elicitation-context.js";
+import { AssistantMarkdown } from "./markdown/assistant-markdown.js";
+import { MemoryUpdatedFooter } from "./memory-updated-footer.js";
+import type { ToolRowSlot } from "./message-list-slots.js";
+import {
+  Disclosure,
+  DisclosureChevron,
+  useDisclosureVisualState,
+} from "./primitives/disclosure.js";
+import { ReasoningRow } from "./reasoning-row.js";
+import { ShimmerText } from "./streaming-states.js";
+import { SurfaceBoundary } from "./surface-boundary.js";
+import { ToolCallRows } from "./tool-call-rows.js";
+import { useMemberToggleOutrank } from "./use-member-toggle-outrank.js";
+import { _foldClaimsLiveness } from "./use-transcript-folds.js";
+
+export function ActivityRail({
+  fold,
+  cards,
+  turnLive,
+  inCurrentTurn,
+  identityToken,
+  decisionSurfacesInShelf,
+  toolRow,
+}: {
+  fold: RunFoldRow;
+  cards: readonly ApprovalCardModel[];
+  turnLive: boolean;
+  /** True while this fold belongs to the transcript's current turn — no
+   *  user or subagent-delivery row follows it. Read by the member rows'
+   *  own hold (a resolved view or a decision keeps the ROW open for its
+   *  turn); the fold itself opens on liveness alone. */
+  inCurrentTurn: boolean;
+  /** The surface's provenance token — folded narration is assistant
+   *  prose and must wear it exactly as the top-level row does (law 10). */
+  identityToken: string;
+  decisionSurfacesInShelf: boolean;
+  toolRow?: ToolRowSlot;
+}) {
+  const { cards: elicitationCards } = useContext(ElicitationsContext);
+  const rows = fold.members;
+  // The one shared spelling (see _foldClaimsLiveness): the trailing
+  // arbiter must judge this fold exactly as this headline renders it.
+  const running = _foldClaimsLiveness(rows, turnLive);
+  // The fold's default openness: the section that is WORKING is the one
+  // expanded — a fold claiming liveness, or one whose member awaits the
+  // member's decision (the row it holds open is the consent reading).
+  // Once the work settles the prop releases (true→undefined) and the
+  // fold collapses, so a finished section reads as one "Worked for …"
+  // line and the transcript stays scannable. A settled member's view,
+  // a settled decision and a failed step no longer hold a fold open:
+  // the failed step's own row pill names the failure (the headline
+  // carries no tally), and the member's explicit toggle outranks every
+  // arm, permanently for the fold.
+  const awaitingDecision = _groupAwaitsDecision(
+    rows,
+    cards,
+    elicitationCards,
+    decisionSurfacesInShelf,
+  );
+  const foldOpenByDefault = running || awaitingDecision;
+  const { groupRef, memberToggled, onGroupActivation } =
+    useMemberToggleOutrank();
+  const steps = fold.steps.map((step) => (
+    <ActivityRailStep
+      key={step.kind === "tool-call" ? step.row.key : step.view.key}
+      step={step}
+      cards={cards}
+      inCurrentTurn={inCurrentTurn}
+      identityToken={identityToken}
+      decisionSurfacesInShelf={decisionSurfacesInShelf}
+      toolRow={toolRow}
+    />
+  ));
+  return (
+    // Every protocol sequence is ONE piece of work in the transcript,
+    // including a one-step run. A stable outer level prevents the visual
+    // model from changing based on how many calls the model happened to
+    // choose. Its children keep their own disclosures, so expanding the
+    // group reveals the timeline and expanding a tool reveals its evidence.
+    <div
+      data-tf-activity-group=""
+      className="tf:my-2"
+      ref={groupRef}
+      onClickCapture={onGroupActivation}
+    >
+      <Disclosure
+        variant="bare"
+        // Open while working or awaiting a decision, released to native
+        // once settled (true→undefined collapses once, never remounting
+        // this <details>). The member's own toggle outranks it, permanently.
+        open={memberToggled ? undefined : foldOpenByDefault || undefined}
+        summaryClassName="tf:flex tf:w-fit tf:items-center tf:gap-1.5 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground"
+        bodyClassName="tf:pt-1"
+        summary={
+          <>
+            <FoldHeadline fold={fold} running={running} />
+            <DisclosureChevron revealOnInteraction />
+          </>
+        }
+      >
+        {/* The rail grows to its content: an open fold shows every step in
+            the transcript's own flow — no inner scroller, no height cap, so
+            a tool view inside it is never clipped or scrolled twice. */}
+        <div data-tf-activity-rail="">
+          <div>{steps}</div>
+        </div>
+      </Disclosure>
+      {/* No settled decision lines render here — the meta-receipt rows were
+          deleted: a consent outcome's surfaces are the decision card's own
+          footer and the operation row's state pill. Do not restore the lines
+          as a bug fix. */}
+    </div>
+  );
+}
+
+/** One step of the rail, in transcript order: a reasoning view, the
+ *  narration a completed episode folded, or a tool call inside its own
+ *  boundary. */
+function ActivityRailStep({
+  step,
+  cards,
+  inCurrentTurn,
+  identityToken,
+  decisionSurfacesInShelf,
+  toolRow,
+}: {
+  step: RunFoldStep;
+  cards: readonly ApprovalCardModel[];
+  inCurrentTurn: boolean;
+  identityToken: string;
+  decisionSurfacesInShelf: boolean;
+  toolRow?: ToolRowSlot;
+}) {
+  if (step.kind === "reasoning") {
+    return (
+      <div data-tf-activity-step="">
+        <ReasoningRow view={step.view} />
+      </div>
+    );
+  }
+  if (step.kind === "narration") {
+    // Narration that folded into a completed episode: the same prose the
+    // top-level assistant-text case renders, in a second home. Carried:
+    // the identity token (law 10) and MemoryUpdatedFooter. Deliberately
+    // not: the paced reveal (a narration step is settled by construction),
+    // the py-2 wrapper (py-1 here is rail geometry, not message padding),
+    // the rows' ps-7 label gutter (prose sits flush with the fold's
+    // headline, as top-level prose sits flush with the marks — law 5:
+    // disclosure adds detail, never indentation), and the copy affordance
+    // (that belongs to top-level messages). Item by item: the episode-fold
+    // audit record.
+    return (
+      <div
+        data-tf-activity-step=""
+        data-tf-activity-narration=""
+        data-tf-agent-identity={identityToken}
+        className="tf:py-1"
+      >
+        <AssistantMarkdown>{step.view.text}</AssistantMarkdown>
+        {step.view.memoryUpdates !== undefined ? (
+          <MemoryUpdatedFooter updates={step.view.memoryUpdates} />
+        ) : null}
+      </div>
+    );
+  }
+  return (
+    <div data-tf-activity-step="">
+      {/* Per-row boundary, same contract as the top-level tool-call
+          case: the projection runs inside ToolCallRows, inside this
+          boundary. */}
+      <SurfaceBoundary surface="tool-row">
+        <ToolCallRows
+          row={step.row}
+          cards={cards}
+          inCurrentTurn={inCurrentTurn}
+          decisionSurfacesInShelf={decisionSurfacesInShelf}
+          toolRow={toolRow}
+        />
+      </SurfaceBoundary>
+    </div>
+  );
+}
+
+/** The fold summary's words. Live, the one shimmered label tracks the work
+ *  by disclosure state (TVC-010): COLLAPSED reads the latest step's own
+ *  label (liveFoldHeadlineOf); EXPANDED reads the generic "Working…",
+ *  because the rail below says what the steps are. The open bit is the
+ *  DOM-backed disclosure mirror (useDisclosureVisualState), never the open
+ *  prop. Settled, the label is the work's cost ("Worked for 4m 49s",
+ *  degrading to "Worked"), NEVER a step label and never an outcome tally: a
+ *  step that failed, was interrupted, declined or not approved wears that
+ *  word on its own row's pill, where the member who opens the fold reads
+ *  it. */
+function FoldHeadline({
+  fold,
+  running,
+}: {
+  fold: RunFoldRow;
+  running: boolean;
+}) {
+  const open = useDisclosureVisualState()?.open ?? false;
+  if (running) {
+    const rawLabel = open ? "Working…" : liveFoldHeadlineOf(fold.steps);
+    const label = open ? rawLabel : activityTitleOf(rawLabel);
+    return (
+      // The measured truncation shape (subagent-group-row's idiom): the
+      // shimmer root is an atomic inline-grid, so the ellipsis lives on the
+      // blockified span inside and grid-cols-1 + max-w-full + min-w-0 make
+      // the track shrinkable — one line, never overflowing the 390px
+      // contract. The RAW step label rides the wrapper's title (never the
+      // inner span: ShimmerText duplicates its children).
+      <span className="tf:min-w-0" title={open ? undefined : rawLabel}>
+        <ShimmerText className="tf:max-w-full tf:grid-cols-1">
+          <span className="tf:block tf:truncate">{label}</span>
+        </ShimmerText>
+      </span>
+    );
+  }
+  return <span>{settledFoldHeadlineOf(fold.duration)}</span>;
+}
+
+/** The fold's decision arm: LIVE pendency only — a member row whose
+ *  anchored approval or elicitation card is still actionable or
+ *  submitting (approvalAwaitsMember / elicitationAwaitsMember, the one
+ *  spelling of "waiting on the human"). The durable `row.decisionBearing`
+ *  anchor is the ROW's hold (tool-call-rows.tsx, its decisionBearing
+ *  derivation), never the fold's: an answered decision is finished work,
+ *  and finished work folds. The cards are read through the same join the
+ *  row uses — the shelf tenant's by toolCallId, else the anchored join —
+ *  so fold and row agree on which cards are this call's. Every card-store
+ *  consumer, classified: docs/transcript-surfaces.md. */
+function _groupAwaitsDecision(
+  rows: readonly RunFoldMember[],
+  approvalCards: readonly ApprovalCardModel[],
+  elicitationCards: readonly ElicitationCardModel[],
+  decisionSurfacesInShelf: boolean,
+): boolean {
+  return rows.some((row) => {
+    if (row.kind !== "tool-call") {
+      return false;
+    }
+    const approvals = decisionSurfacesInShelf
+      ? approvalCards.filter((card) => card.toolCallId === row.toolCallId)
+      : anchoredCardsFor(approvalCards, row.toolCallId);
+    const elicitations = decisionSurfacesInShelf
+      ? elicitationCards.filter((card) => card.toolCallId === row.toolCallId)
+      : anchoredElicitationsFor(elicitationCards, row.toolCallId);
+    return (
+      approvals.some(approvalAwaitsMember) ||
+      elicitations.some(elicitationAwaitsMember)
+    );
+  });
+}