@teaflask/assistant 0.3.0 → 0.6.0

package/src/components/thread-list.tsx

@@ -1,195 +0,0 @@
-"use client";
-
-import type { ServingAssistantThread } from "../contract/threads.js";
-import { RECENT_WINDOW_DAYS, startOfLocalDayMs } from "../core/time-labels.js";
-import { ComposeIcon } from "./icons.js";
-import { TfButton } from "./primitives/button.js";
-import { cx } from "./primitives/cx.js";
-
-export interface ThreadGroup {
-  label: string;
-  threads: ServingAssistantThread[];
-}
-
-/**
- * History bucketed the way people remember it — by calendar day, not by
- * elapsed hours: a conversation from 11pm last night is "Yesterday" at
- * 8am even though it is nine hours old. Grouping is also why the rows
- * carry no timestamp of their own; the heading already said it, and a
- * right-aligned time would eat the title in a 280px rail.
- */
-export function groupThreadsByRecency(
-  threads: readonly ServingAssistantThread[],
-  now: Date,
-): ThreadGroup[] {
-  // Each boundary is a local midnight of its own, counted back in
-  // CALENDAR days (startOfLocalDayMs — hoisted to core/time-labels so
-  // the user-bubble timestamps read this exact recency rule).
-  const startOfDay = (daysBack: number) => startOfLocalDayMs(now, daysBack);
-  const startOfToday = startOfDay(0);
-  const startOfYesterday = startOfDay(1);
-  const startOfRecentWindow = startOfDay(RECENT_WINDOW_DAYS);
-  const buckets = new Map<string, ServingAssistantThread[]>();
-  // Groups come out in the order their first thread arrives, so the sort
-  // decides the headings' order too. An unparseable stamp is therefore ranked
-  // rather than left to arithmetic: it sorts to the very top, which is where
-  // its "Today" bucket belongs.
-  //
-  // Compared, not subtracted, so the comparator is total. Ranking alone did
-  // not achieve that, whatever the older wording here claimed: two
-  // unparseable stamps both rank Infinity, and `Infinity - Infinity` is NaN.
-  // That particular NaN is in fact harmless — SortCompare coerces it to +0,
-  // and "equal" is the honest answer for two threads that are equally
-  // unrankable — but a comparator whose totality rests on a spec footnote is
-  // one refactor away from mattering.
-  const ordered = [...threads].sort((a, b) => {
-    const left = _rankOf(b);
-    const right = _rankOf(a);
-    if (left === right) {
-      return 0;
-    }
-    return left > right ? 1 : -1;
-  });
-
-  for (const thread of ordered) {
-    const at = Date.parse(thread.updated_at);
-    // An unparseable or future stamp is described honestly rather than
-    // being filed under a day it did not happen.
-    const label =
-      Number.isNaN(at) || at >= startOfToday
-        ? "Today"
-        : at >= startOfYesterday
-          ? "Yesterday"
-          : at >= startOfRecentWindow
-            ? "Previous 7 days"
-            : "Older";
-    const bucket = buckets.get(label);
-    if (bucket === undefined) {
-      buckets.set(label, [thread]);
-    } else {
-      bucket.push(thread);
-    }
-  }
-  return [...buckets].map(([label, bucketed]) => ({
-    label,
-    threads: bucketed,
-  }));
-}
-
-/** A thread's place on the timeline, as a number the comparator can always
- * subtract. A stamp that will not parse ranks above every real one. */
-function _rankOf(thread: ServingAssistantThread): number {
-  const at = Date.parse(thread.updated_at);
-  return Number.isNaN(at) ? Number.POSITIVE_INFINITY : at;
-}
-
-interface ThreadHistoryProps {
-  threads: ServingAssistantThread[];
-  activeThreadId: string | null;
-  onSelectThread: (thread: ServingAssistantThread) => void;
-  onNewConversation: () => void;
-  /**
-   * Grows the rows to the 44px touch floor and the 15px step. The rail is
-   * leaned over with a mouse; the drawer is held at arm's length.
-   */
-  touch?: boolean;
-  /**
-   * Whether the scroller owes the phone's home indicator its clearance.
-   * True for surfaces that run to the viewport's bottom edge (the page's
-   * history sheet); false for ones that end mid-panel (the companion
-   * drawer's history menu), where the env() inset would be dead padding.
-   */
-  safeAreaBottom?: boolean;
-}
-
-/**
- * The history body: the one command, then the conversations under their
- * recency headings. Shared verbatim between the rail and the drawer —
- * they are the same list at two densities, and the day a phone's history
- * diverges from a desk's is the day one of them is wrong.
- */
-export function ThreadHistory({
-  threads,
-  activeThreadId,
-  onSelectThread,
-  onNewConversation,
-  touch = false,
-  safeAreaBottom = true,
-}: ThreadHistoryProps) {
-  const groups = groupThreadsByRecency(threads, new Date());
-  return (
-    <div className="tf:flex tf:min-h-0 tf:flex-1 tf:flex-col">
-      {/* Outside the scroller on purpose: an action that scrolls away
-          with the list it commands is an action you have to go find. */}
-      <div className="tf:shrink-0 tf:px-2 tf:pb-1">
-        <TfButton
-          variant={touch ? "rowActionTouch" : "rowAction"}
-          onClick={onNewConversation}
-        >
-          <ComposeIcon />
-          New conversation
-        </TfButton>
-      </div>
-      {/* The page's history sheet runs to the bottom edge of the phone,
-          so its list owes the home indicator its clearance. As a utility
-          rather than a stylesheet rule: the package's hand-written rules
-          and its utilities share one sheet, and which of two
-          equal-specificity declarations wins is not a thing to leave to
-          source order. env() is 0 everywhere else, so this is just pb-2
-          on a desk. */}
-      <div
-        className={cx(
-          "tf:flex tf:min-h-0 tf:flex-1 tf:flex-col tf:overflow-y-auto tf:px-2",
-          safeAreaBottom
-            ? "tf:pb-[calc(0.5rem_+_env(safe-area-inset-bottom))]"
-            : "tf:pb-2",
-        )}
-      >
-        {groups.length === 0 ? (
-          <NoConversationsYet />
-        ) : (
-          groups.map((group) => (
-            <section key={group.label} className="tf:pt-3">
-              {/* Not an eyebrow: these stack down the column and each one
-                  is the answer to "when was that". */}
-              <h3 className="tf:px-2.5 tf:pb-1 tf:text-tf-label tf:font-normal tf:text-tf-muted-foreground">
-                {group.label}
-              </h3>
-              <ul className="tf:flex tf:flex-col tf:gap-px">
-                {group.threads.map((thread) => (
-                  <li key={thread.id}>
-                    <TfButton
-                      variant={touch ? "rowTouch" : "row"}
-                      aria-current={
-                        thread.id === activeThreadId ? "true" : undefined
-                      }
-                      onClick={() => {
-                        onSelectThread(thread);
-                      }}
-                    >
-                      <span className="tf:truncate">{thread.title}</span>
-                    </TfButton>
-                  </li>
-                ))}
-              </ul>
-            </section>
-          ))
-        )}
-      </div>
-    </div>
-  );
-}
-
-// The house empty-state silhouette at rail scale: centred, a line that
-// names the state and a line that says what fills it. No action — the
-// only one there is sits 40px above this.
-function NoConversationsYet() {
-  return (
-    <div className="tf:my-auto tf:flex tf:flex-col tf:items-center tf:gap-1 tf:px-4 tf:py-6 tf:text-center">
-      <p className="tf:text-tf-label tf:font-medium">No conversations yet</p>
-      <p className="tf:text-tf-label tf:text-tf-muted-foreground">
-        Your chats show up here.
-      </p>
-    </div>
-  );
-}

package/src/components/tool-arguments-summary.tsx

@@ -1,213 +0,0 @@
-"use client";
-
-import {
-  CAPTION_ROW_CLASS,
-  CARD_CLASS,
-  FACT_LABEL_CLASS,
-  FACT_LIST_CLASS,
-  FACT_ROW_CLASS,
-  FACT_VALUE_CLASS,
-} from "./tool-views/parts-classes.js";
-import type { ToolViewProps } from "../core/tool-view.js";
-
-const MAX_VISIBLE_ROWS = 8;
-const LONG_TEXT_CHARS = 120;
-const TEXT_PREVIEW_CHARS = 320;
-const ARRAY_PREVIEW_ITEMS = 4;
-
-interface SummaryRow {
-  key: string;
-  label: string;
-  value: unknown;
-  depth: number;
-}
-
-type Scalar = string | number | boolean | bigint | null;
-
-// The section chrome, hoisted so the list stays a greppable literal: the
-// tool-view card vocabulary (tool-views/parts-classes.ts) — a hairline
-// card, a "Request" caption, property rows — so the rung-4 reading is a
-// property card like every other view in the row body. No height floor:
-// the card grows to its rows and never scrolls the transcript twice.
-const SECTION_CLASSES = `tf:flex tf:flex-col ${CARD_CLASS}`;
-
-/**
- * The resolution ladder's rung 4 (tool-views.md): the package default
- * view, over the bounded argument reading below. An INPUT reading by
- * design — it ignores `result` entirely, so an unknown customer tool
- * never grows an inferred result card or a raw output dump (TVC-111).
- * Deterministic like the reading it wraps: two identical calls render
- * byte-identical output, with no clocks and no locale. Its one mount
- * site is the slot's terminal in the tool row's body, where it wears
- * the one card vocabulary every tool view paints with.
- */
-export function DefaultToolView(props: ToolViewProps) {
-  return <ToolArgumentsSummary arguments={props.call.args} />;
-}
-
-/**
- * A deterministic, semantics-free reading of arbitrary tool arguments —
- * general-purpose input furniture (the DOM hooks below keep their
- * approval-card-era names because styles.css and the geometry spec
- * select them). It never chooses a domain component and never prints
- * raw JSON: records become bounded field rows, long strings become a
- * two-line excerpt, and opaque structures become honest type/count
- * summaries. Determinism is contract: Object.keys().sort() at both
- * levels, no clocks, and the one locale call pinned to "en-US".
- */
-function ToolArgumentsSummary({
-  arguments: toolArguments,
-}: {
-  arguments: Record<string, unknown>;
-}) {
-  const rows = _summaryRowsOf(toolArguments);
-  if (rows.length === 0) {
-    return null;
-  }
-  const visible = rows.slice(0, MAX_VISIBLE_ROWS);
-  const hidden = rows.length - visible.length;
-  return (
-    <section
-      data-tf-approval-request-summary=""
-      data-tf-tool-view-card=""
-      aria-label="Request details"
-      className={SECTION_CLASSES}
-    >
-      <div className={CAPTION_ROW_CLASS}>Request</div>
-      <dl className={FACT_LIST_CLASS}>
-        {visible.map((row) => (
-          <SummaryValue key={row.key} row={row} />
-        ))}
-        {hidden > 0 ? (
-          <div className={CAPTION_ROW_CLASS}>
-            {hidden} more {hidden === 1 ? "field" : "fields"}
-          </div>
-        ) : null}
-      </dl>
-    </section>
-  );
-}
-
-function SummaryValue({ row }: { row: SummaryRow }) {
-  return (
-    <div className={`${FACT_ROW_CLASS}${row.depth > 0 ? " tf:ps-6" : ""}`}>
-      <dt className={FACT_LABEL_CLASS}>{row.label}</dt>
-      <dd className={FACT_VALUE_CLASS}>
-        <SummaryValueBody value={row.value} />
-      </dd>
-    </div>
-  );
-}
-
-function SummaryValueBody({ value }: { value: unknown }) {
-  if (typeof value === "string") {
-    if (value.length <= LONG_TEXT_CHARS) {
-      return (
-        <span className="tf:font-mono tf:wrap-anywhere tf:whitespace-pre-wrap">
-          {value === "" ? "Empty text" : value}
-        </span>
-      );
-    }
-    const preview = value.slice(0, TEXT_PREVIEW_CHARS);
-    return (
-      <div>
-        <p
-          data-tf-approval-text-preview=""
-          className="tf:m-0 tf:overflow-hidden tf:wrap-anywhere tf:whitespace-pre-wrap"
-        >
-          {preview}
-          {value.length > preview.length ? "…" : ""}
-        </p>
-        <p className="tf:mt-1 tf:text-xs tf:text-tf-muted-foreground tf:tabular-nums">
-          {value.length.toLocaleString("en-US")} characters
-        </p>
-      </div>
-    );
-  }
-  if (
-    typeof value === "number" ||
-    typeof value === "boolean" ||
-    typeof value === "bigint"
-  ) {
-    return (
-      <span className="tf:font-mono tf:wrap-anywhere">{String(value)}</span>
-    );
-  }
-  if (value === null) {
-    return (
-      <span className="tf:font-mono tf:text-tf-muted-foreground">null</span>
-    );
-  }
-  if (value === undefined) {
-    return <span className="tf:text-tf-muted-foreground">Not provided</span>;
-  }
-  if (Array.isArray(value)) {
-    const preview = value.slice(0, ARRAY_PREVIEW_ITEMS);
-    const primitives = preview.every(_isScalar);
-    return (
-      <div>
-        <span className="tf:text-tf-muted-foreground tf:tabular-nums">
-          {value.length} {value.length === 1 ? "item" : "items"}
-        </span>
-        {primitives && preview.length > 0 ? (
-          <p className="tf:mt-0.5 tf:m-0 tf:font-mono tf:wrap-anywhere">
-            {preview.map(_scalarTextOf).join(", ")}
-            {value.length > preview.length ? ", …" : ""}
-          </p>
-        ) : null}
-      </div>
-    );
-  }
-  if (_isRecord(value)) {
-    const count = Object.keys(value).length;
-    return (
-      <span className="tf:text-tf-muted-foreground tf:tabular-nums">
-        {count} {count === 1 ? "field" : "fields"}
-      </span>
-    );
-  }
-  return <span className="tf:text-tf-muted-foreground">Opaque value</span>;
-}
-
-function _summaryRowsOf(toolArguments: Record<string, unknown>): SummaryRow[] {
-  const rows: SummaryRow[] = [];
-  for (const key of Object.keys(toolArguments).sort()) {
-    const value = toolArguments[key];
-    if (_isRecord(value) && Object.keys(value).length > 0) {
-      for (const childKey of Object.keys(value).sort()) {
-        rows.push({
-          key: `${key}.${childKey}`,
-          label: `${_labelOf(key)} · ${_labelOf(childKey)}`,
-          value: value[childKey],
-          depth: 1,
-        });
-      }
-      continue;
-    }
-    rows.push({ key, label: _labelOf(key), value, depth: 0 });
-  }
-  return rows;
-}
-
-function _labelOf(key: string): string {
-  const words = key.replace(/[-_]+/g, " ").trim();
-  return words === "" ? "Value" : words[0].toUpperCase() + words.slice(1);
-}
-
-function _isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function _isScalar(value: unknown): value is Scalar {
-  return (
-    value === null ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean" ||
-    typeof value === "bigint"
-  );
-}
-
-function _scalarTextOf(value: Scalar): string {
-  return value === null ? "null" : String(value);
-}

package/src/components/tool-call-rows.tsx

@@ -1,274 +0,0 @@
-"use client";
-
-import { useContext } from "react";
-
-import type { ApprovalCardModel } from "../core/approval-inbox.js";
-import type { ElicitationCardModel } from "../core/elicitation-cards.js";
-import {
-  approvalAwaitsMember,
-  elicitationAwaitsMember,
-} from "../core/suspension-queue.js";
-import type { ToolCallViewModel } from "../core/tool-call-display.js";
-import type { ToolCallRow } from "../core/transcript-rows.js";
-import { ApprovalCard } from "./approval-card.js";
-import { anchoredCardsFor } from "./approval-context.js";
-import {
-  anchoredElicitationsFor,
-  ElicitationsContext,
-} from "./elicitation-context.js";
-import { settledQuestionsReceiptOf } from "../core/question-receipt.js";
-import type { ToolRowSlot } from "./message-list-slots.js";
-import { prettyPrintParameters } from "./pretty-print.js";
-import { QuestionPanel } from "./question-panel.js";
-import { HostSlotBoundary, SlotOrDefault } from "./slot-boundary.js";
-import { SurfaceBoundary } from "./surface-boundary.js";
-import { ToolRow } from "./tool-row.js";
-
-// A HITL-gated call pauses the turn right here. In the shipping shelf
-// composition the actionable card lives in the suspension slot and this
-// row keeps the compact chronology: the "Needs input" pill while the
-// decision pends, then only the row's own state — no settled prose line
-// renders (no meta-receipt rows; the card's footer is the outcome's other
-// surface). Shelf-less hosts mount the cards inline beneath the row
-// (anchored via tool_call_id). An answered ask collapses further either
-// way: once its result carries a settled answer its tool view becomes the
-// Q&A record.
-export function ToolCallRows({
-  row,
-  cards,
-  inCurrentTurn = false,
-  decisionSurfacesInShelf = false,
-  toolRow,
-}: {
-  row: ToolCallRow;
-  cards: readonly ApprovalCardModel[];
-  /** The row-level hold window, forwarded to ToolRow. */
-  inCurrentTurn?: boolean;
-  decisionSurfacesInShelf?: boolean;
-  toolRow?: ToolRowSlot;
-}) {
-  const { cards: elicitationCards } = useContext(ElicitationsContext);
-  // Answers stay inspectable in the normal tool view. The durable
-  // result also suppresses the temporary inline question panel.
-  const settledQuestions = settledQuestionsReceiptOf(
-    row.toolName,
-    row.argsText,
-    row.result,
-  );
-  // Which decisions belong to THIS row: in the shelf composition the
-  // join keys on the RENDERED ROW (tool call id), never the marker-time
-  // `anchored` flag — after a page reload during a pause every card is
-  // a marker-time orphan (no TOOL_CALL_START replayed) while its call's
-  // row is right here, and its settled state must land on it, never
-  // silently vanish (approval-inbox.ts's own rule). The shelf-less mode
-  // keeps the historical anchored selection, which also decides card
-  // MOUNTING there.
-  const anchoredApprovals = decisionSurfacesInShelf
-    ? cards.filter((card) => card.toolCallId === row.toolCallId)
-    : anchoredCardsFor(cards, row.toolCallId);
-  const anchoredElicitations = decisionSurfacesInShelf
-    ? elicitationCards.filter((card) => card.toolCallId === row.toolCallId)
-    : anchoredElicitationsFor(elicitationCards, row.toolCallId);
-  // The row itself says it is the one waiting (state on the affected
-  // operation); answered and stale cards are receipts and mark nothing.
-  // The pill keeps the AWAITING spelling and deliberately does NOT share
-  // the hold's predicate: waiting ends with the decision, the hold with the turn.
-  const awaitingInput =
-    settledQuestions === null &&
-    _awaitsMemberDecision(anchoredApprovals, anchoredElicitations);
-  const stateWord = _mandatoryStateWordOf(row.state, awaitingInput);
-  // The row's hold arm (the durable re-derivation): the row model's
-  // decisionBearing — the replayed marker anchor — is the arm that
-  // survives the card stores' pruning (the gated call's
-  // result, RUN_ERROR, the turn's settle) and a reload; the live
-  // anchored cards are the complement for a REST-hydrated pause whose
-  // stream never ran and for fixture scenes that pose cards without
-  // histories. Never state: both arms are derivations.
-  const decisionBearing =
-    row.decisionBearing === true ||
-    anchoredApprovals.length > 0 ||
-    anchoredElicitations.length > 0;
-  // NOTE: no settled decision statements render here or anywhere else in
-  // the transcript (the meta-receipt rows, the audit-visibility lines among
-  // them, are deleted): a consent outcome's surfaces are the decision
-  // card's own footer and this row's state pill. Do not restore the prose
-  // lines as a bug fix.
-  const view = _toolViewOf(row);
-  // Stored asks predate the registered question view. Upgrade their
-  // presentation without rewriting history or overriding an authored view.
-  if (settledQuestions !== null && view.display?.view === undefined) {
-    view.display = {
-      ...view.display,
-      icon: "question",
-      view: { key: "teaflask.questions", version: 1 },
-    };
-  }
-  const packageToolRow = (
-    <ToolRow
-      view={view}
-      awaitingInput={awaitingInput}
-      decisionBearing={decisionBearing}
-      inCurrentTurn={inCurrentTurn}
-    />
-  );
-  return (
-    <>
-      {toolRow === undefined ? (
-        packageToolRow
-      ) : (
-        <HostSlotBoundary slot="toolRow" fallback={packageToolRow}>
-          <SlotOrDefault
-            render={() => toolRow({ row, view, awaitingInput })}
-            fallback={packageToolRow}
-            // Mandatory status (non-negotiable): a filled toolRow
-            // cannot mute an error, an interruption, a refusal, a
-            // member's denial, or a pending decision — package-rendered
-            // beside the fill, a sibling the fill cannot reach. Keyed
-            // on the fill having RENDERED, never on the prop being
-            // supplied: on both fallback routes — a null return, a
-            // throw — the package ToolRow's own state pill carries the
-            // status, and this word beside it would make a screen
-            // reader hear the state twice.
-            filledAnnex={
-              stateWord !== null ? (
-                <span className="tf:sr-only" data-tf-tool-state={row.state}>
-                  {stateWord}
-                </span>
-              ) : undefined
-            }
-          />
-        </HostSlotBoundary>
-      )}
-      {decisionSurfacesInShelf || settledQuestions !== null ? null : (
-        <>
-          {anchoredApprovals.map((card) => (
-            // Adjacency PLACES the banner under its call's row on this
-            // shelf-less path; the banner reads only the card model.
-            // Per-card boundary: a poisoned card degrades one banner.
-            <SurfaceBoundary key={card.interruptId} surface="approval-card">
-              <ApprovalCard card={card} />
-            </SurfaceBoundary>
-          ))}
-          {anchoredElicitations.map((card) => (
-            <SurfaceBoundary key={card.interruptId} surface="question-panel">
-              <QuestionPanel card={card} />
-            </SurfaceBoundary>
-          ))}
-        </>
-      )}
-    </>
-  );
-}
-
-/** The pending-decision judgement over one row's anchored cards. The
- *  SPELLING of "still waiting on the human" lives in ONE place
- *  (approvalAwaitsMember/elicitationAwaitsMember, core/suspension-queue.ts)
- *  because the row's "Needs input" pill (TVC-036) and the suspension
- *  queue must agree — and the fold's default openness
- *  (_groupAwaitsDecision, activity-rail.tsx) reads the same live
- *  pendency. The ROW's placement hold deliberately keys on ANCHORING,
- *  not awaiting (the decisionBearing derivation above): TVC-014's hold
- *  window is the turn, which outlives the pendency. */
-function _awaitsMemberDecision(
-  anchoredApprovals: readonly ApprovalCardModel[],
-  anchoredElicitations: readonly ElicitationCardModel[],
-): boolean {
-  return (
-    anchoredApprovals.some(approvalAwaitsMember) ||
-    anchoredElicitations.some(elicitationAwaitsMember)
-  );
-}
-
-/** The frame's status word beside a host-filled toolRow — the same
- *  vocabulary the package pills wear (Failed; Not approved; Interrupted
- *  for cancelled and superseded alike; Declined; Needs input, TVC-036).
- *  Null for the quiet states: running and settled-clean carry no
- *  mandatory word. */
-function _mandatoryStateWordOf(
-  state: ToolCallRow["state"],
-  awaitingInput: boolean,
-): string | null {
-  if (state === "output-error") {
-    return "Failed";
-  }
-  if (state === "denied") {
-    return "Not approved";
-  }
-  if (state === "cancelled" || state === "superseded") {
-    return "Interrupted";
-  }
-  if (state === "refused") {
-    return "Declined";
-  }
-  if (awaitingInput) {
-    return "Needs input";
-  }
-  return null;
-}
-
-function _toolViewOf(row: ToolCallRow): ToolCallViewModel {
-  // An offloaded call's "result" is the context offloader's model-facing
-  // replacement — retrieval guidance addressed to the model, storage
-  // reference lines — not the tool's output, so it is suppressed like the
-  // cancelled sentinel and the row renders the quiet shortened-result
-  // line instead. Errored and cancelled rows keep their existing stories:
-  // those states already suppress the output, and their panes win.
-  const offloaded =
-    row.offloaded &&
-    row.errorText === undefined &&
-    row.state !== "denied" &&
-    row.state !== "cancelled" &&
-    row.state !== "refused";
-  return {
-    toolName: row.toolName,
-    state: row.state,
-    toolCallId: row.toolCallId,
-    input: _prettyArgsOf(row.argsText),
-    // The raw argument text rides beside the pretty print: the
-    // presenter parses it into the tool-view call's `args`.
-    argsText: row.argsText,
-    // A failed call shows its Error pane, not a Result pane. A cancelled
-    // call shows neither: its "result" is the model-facing cancellation
-    // text, and the row's own Interrupted pill carries the story (the
-    // meta-receipt rows beside it are deleted). A refused call likewise:
-    // the refusal envelope; the reason line carries the story. A denied
-    // call likewise: the same cancellation sentinel a cancel carries —
-    // the wire's stamp this state outranks — and the pill carries the
-    // story.
-    output:
-      row.errorText !== undefined ||
-      row.state === "denied" ||
-      row.state === "cancelled" ||
-      row.state === "refused" ||
-      offloaded
-        ? undefined
-        : row.result,
-    offloaded: offloaded || undefined,
-    errorText: row.errorText,
-    ...(row.refusalText !== undefined ? { refusalText: row.refusalText } : {}),
-    display: row.display,
-    // The anchored schema REFERENCES ride through unwrapped: the
-    // presenter's identity law needs the same object per source, and the
-    // anchors map's first-wins merge already guarantees it.
-    ...(row.schemas?.argsSchema !== undefined
-      ? { argsSchema: row.schemas.argsSchema }
-      : {}),
-    ...(row.schemas?.resultSchema !== undefined
-      ? { resultSchema: row.schemas.resultSchema }
-      : {}),
-  };
-}
-
-// The streamed arguments are JSON text, possibly mid-stream: parse when
-// whole (for the stable two-space print), pass through verbatim while
-// the tail is still arriving.
-function _prettyArgsOf(argsText: string): string {
-  if (argsText === "") {
-    return "";
-  }
-  try {
-    return prettyPrintParameters(JSON.parse(argsText));
-  } catch {
-    return argsText;
-  }
-}