@teaflask/assistant 0.0.0 → 0.3.0

package/src/components/thread-list.tsx

@@ -0,0 +1,195 @@
+"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

@@ -0,0 +1,213 @@
+"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

@@ -0,0 +1,274 @@
+"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;
+  }
+}