@teaflask/assistant 0.3.0 → 0.7.0

package/src/components/markdown/paced-assistant-markdown.tsx

@@ -1,33 +0,0 @@
-"use client";
-
-// The streamed assistant text body, whole: the paced RAW prefix goes
-// through the streaming repair and only then parses, so partial syntax
-// stays the repair layer's job — and a settled row renders its text
-// verbatim. Only text paces; anything else a transcript shows (tool
-// rows, approval cards, receipts) must land the instant it arrives,
-// which is why this component exists at the leaf and not around the row
-// list. While the buffer is non-empty the tail block re-parses per
-// frame instead of per poll; MemoizedBlock confines that to the last
-// block.
-
-import { usePacedReveal } from "./use-paced-reveal.js";
-import { repairedStreamingMarkdown } from "./streaming-repair.js";
-import { AssistantMarkdown } from "./assistant-markdown.js";
-
-export function PacedAssistantMarkdown({
-  text,
-  streaming,
-}: {
-  text: string;
-  streaming: boolean;
-}) {
-  const { revealed, revealHostRef } = usePacedReveal(text, streaming);
-  const settled = !streaming && revealed === text;
-  return (
-    <div ref={revealHostRef} className="tf:min-w-0">
-      <AssistantMarkdown>
-        {settled ? text : repairedStreamingMarkdown(revealed)}
-      </AssistantMarkdown>
-    </div>
-  );
-}

package/src/components/markdown/reveal-pacer.ts

@@ -1,135 +0,0 @@
-// Streamed assistant text arrives in poll-sized lumps (the backend tails
-// persisted rows on a fixed interval), so painting each arrival whole
-// reads as chunky. The pacer buffers arrivals and reveals characters at a
-// rate calibrated to empty the buffer just as the next chunk is expected —
-// the expectation an EWMA over observed inter-arrival gaps, clamped so a
-// long silence cannot teach a crawl nor a burst a flash. Clock-injected
-// and DOM-free so the math is testable with explicit timestamps.
-
-/** The backend tail-poll interval — the correct prior before evidence. */
-const NOMINAL_GAP_MS = 400;
-/** ~90% converged after ~7 chunks if the cadence shifts; one outlier
- *  moves the estimate at most 30%. */
-const GAP_EWMA_ALPHA = 0.3;
-const MIN_GAP_MS = 120;
-const MAX_GAP_MS = 1500;
-/** Gaps below this are frames of the same poll lump — a mounted replay
- *  delivers its whole backlog this way. Revealed instantly, never taught
- *  to the EWMA, so a replay cannot poison the expectation into a flash. */
-const BURST_GAP_MS = 50;
-/** 80 chars/s: a small buffer finishes early and dry-waits honestly
- *  instead of crawling below reading speed. */
-const MIN_RATE_CHARS_PER_MS = 0.08;
-/** 4000 chars/s: beyond visual distinction from instant, and bounds the
- *  per-frame markdown re-parse churn a huge chunk could cause. */
-const MAX_RATE_CHARS_PER_MS = 4;
-/** Terminal flush is constant-time: a 40-char and a 400-char tail both
- *  finish in 200ms, so short tails don't lurch and long tails don't
- *  typewriter an answer the server already completed. */
-const DRAIN_MS = 200;
-
-export class RevealPacer {
-  private arrived: number;
-  /** Fractional revealed length at `committedAt`; advances at `ratePerMs`. */
-  private position: number;
-  private committedAt: number;
-  private ratePerMs = 0;
-  private expectedGapMs = NOMINAL_GAP_MS;
-  private lastArrivalAt: number;
-  /** False until the first real (non-burst) gap: the mount-burst window,
-   *  where everything reveals instantly. */
-  private calibrated = false;
-  private instant = false;
-
-  constructor(arrivedLength: number, nowMs: number) {
-    this.arrived = arrivedLength;
-    this.position = arrivedLength;
-    this.committedAt = nowMs;
-    this.lastArrivalAt = nowMs;
-  }
-
-  observe(arrivedLength: number, nowMs: number): void {
-    if (this._arrivalShrankBelowRevealed(arrivedLength, nowMs)) {
-      this.arrived = arrivedLength;
-      this.revealInstantly();
-      return;
-    }
-    this._commitRevealedAt(nowMs);
-    const gapMs = nowMs - this.lastArrivalAt;
-    this.lastArrivalAt = nowMs;
-    this.arrived = arrivedLength;
-    if (this.instant || this._isStillInTheMountBurst(gapMs)) {
-      this.position = arrivedLength;
-      return;
-    }
-    this.calibrated = true;
-    if (gapMs >= BURST_GAP_MS) {
-      this._foldGapIntoExpectation(gapMs);
-    }
-    this.ratePerMs = _clamp(
-      (this.arrived - this.position) / this.expectedGapMs,
-      MIN_RATE_CHARS_PER_MS,
-      MAX_RATE_CHARS_PER_MS,
-    );
-  }
-
-  /** The stream is over (finished, cancelled, parked or superseded):
-   *  stop gap-calibrated withholding and sweep the remainder within
-   *  DRAIN_MS. Never decelerates an already-faster reveal. */
-  beginDrain(nowMs: number): void {
-    if (this.instant) {
-      return;
-    }
-    this._commitRevealedAt(nowMs);
-    const remaining = this.arrived - this.position;
-    if (remaining <= 0) {
-      return;
-    }
-    this.ratePerMs = Math.max(this.ratePerMs, remaining / DRAIN_MS);
-  }
-
-  revealInstantly(): void {
-    this.instant = true;
-    this.position = this.arrived;
-    this.ratePerMs = 0;
-  }
-
-  revealedLength(nowMs: number): number {
-    const advanced =
-      this.position + this.ratePerMs * Math.max(0, nowMs - this.committedAt);
-    return Math.min(this.arrived, Math.floor(advanced));
-  }
-
-  isCaughtUp(nowMs: number): boolean {
-    return this.revealedLength(nowMs) >= this.arrived;
-  }
-
-  private _arrivalShrankBelowRevealed(
-    arrivedLength: number,
-    nowMs: number,
-  ): boolean {
-    return arrivedLength < this.revealedLength(nowMs);
-  }
-
-  private _isStillInTheMountBurst(gapMs: number): boolean {
-    return !this.calibrated && gapMs < BURST_GAP_MS;
-  }
-
-  private _foldGapIntoExpectation(gapMs: number): void {
-    const taught = _clamp(gapMs, MIN_GAP_MS, MAX_GAP_MS);
-    this.expectedGapMs =
-      GAP_EWMA_ALPHA * taught + (1 - GAP_EWMA_ALPHA) * this.expectedGapMs;
-  }
-
-  private _commitRevealedAt(nowMs: number): void {
-    this.position = Math.min(
-      this.arrived,
-      this.position + this.ratePerMs * Math.max(0, nowMs - this.committedAt),
-    );
-    this.committedAt = nowMs;
-  }
-}
-
-function _clamp(value: number, min: number, max: number): number {
-  return Math.min(max, Math.max(min, value));
-}

package/src/components/markdown/shiki-highlighter.ts

@@ -1,61 +0,0 @@
-// The lazy chunk behind markdown/highlight.ts — nothing outside that
-// boundary may import this module (the bundle-weight tripwire enforces
-// it). Fine-grained shiki/core with the JavaScript regex engine: no
-// oniguruma wasm, and only the grammar set below — a fenced block in any
-// other language keeps its plain <pre>. This module ships NO CSS (the
-// esbuild-hoists-lazy-CSS trap): tokens carry `--shiki-*` variables that
-// styles.css maps onto the Graphite ink ladder for both modes.
-
-import {
-  createCssVariablesTheme,
-  createHighlighterCore,
-  type HighlighterCore,
-} from "shiki/core";
-import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
-
-const GRAMMARS = [
-  import("@shikijs/langs/typescript"),
-  import("@shikijs/langs/tsx"),
-  import("@shikijs/langs/javascript"),
-  import("@shikijs/langs/jsx"),
-  import("@shikijs/langs/json"),
-  import("@shikijs/langs/bash"),
-  import("@shikijs/langs/python"),
-  import("@shikijs/langs/html"),
-  import("@shikijs/langs/css"),
-  import("@shikijs/langs/yaml"),
-  import("@shikijs/langs/markdown"),
-  import("@shikijs/langs/sql"),
-];
-
-// Aliases shiki resolves itself (ts→typescript, sh→shellscript…) ride
-// the grammar registrations; this set is what `loadedLanguages` reports.
-const THEME = createCssVariablesTheme({
-  name: "tf-css-variables",
-  variablePrefix: "--shiki-",
-  variableDefaults: {},
-  fontStyle: true,
-});
-
-let highlighter: Promise<HighlighterCore> | null = null;
-
-function loadedHighlighter(): Promise<HighlighterCore> {
-  highlighter ??= createHighlighterCore({
-    themes: [THEME],
-    langs: GRAMMARS,
-    engine: createJavaScriptRegexEngine({ forgiving: true }),
-  });
-  return highlighter;
-}
-
-export async function highlightWithShiki(
-  code: string,
-  language: string,
-): Promise<string | null> {
-  const core = await loadedHighlighter();
-  const resolved = language.toLowerCase();
-  if (!core.getLoadedLanguages().includes(resolved)) {
-    return null;
-  }
-  return core.codeToHtml(code, { lang: resolved, theme: "tf-css-variables" });
-}

package/src/components/markdown/streaming-repair.ts

@@ -1,83 +0,0 @@
-// Mid-stream markdown arrives syntactically unfinished — an open code
-// fence swallows the rest of the answer as code, a dangling ** bolds it,
-// a half-streamed table row renders as prose — and the renderer re-parses
-// on every delta, so each glitch flashes at the reader. This repair
-// closes what the stream will close anyway and holds back what cannot
-// render sensibly yet. Deliberately conservative: only the constructs
-// whose unfinished form is visually loud are touched (fences, inline
-// code, ** strong, table rows); a half-typed link or _emphasis_ renders
-// as plain text harmlessly and is left alone.
-
-export function repairedStreamingMarkdown(text: string): string {
-  let repaired = _withoutAHalfTypedFenceOpener(text);
-  if (_endsInsideACodeFence(repaired)) {
-    return `${repaired}\n\`\`\``;
-  }
-  repaired = _withoutAnUnfinishedTrailingTableRow(repaired);
-  repaired = _withInlineCodeClosed(repaired);
-  repaired = _withStrongEmphasisClosed(repaired);
-  return repaired;
-}
-
-// A fence opener being typed ("`" or "``" alone on the last line) must be
-// held back: counting its backticks would mis-balance inline code and
-// close it into a real fence.
-function _withoutAHalfTypedFenceOpener(text: string): string {
-  const lines = text.split("\n");
-  const last = lines[lines.length - 1];
-  if (/^`{1,2}$/.test(last.trim())) {
-    return lines.slice(0, -1).join("\n");
-  }
-  return text;
-}
-
-function _endsInsideACodeFence(text: string): boolean {
-  let insideAFence = false;
-  for (const line of text.split("\n")) {
-    if (/^\s*(```|~~~)/.test(line)) {
-      insideAFence = !insideAFence;
-    }
-  }
-  return insideAFence;
-}
-
-// A table row missing its closing pipe is still streaming; rendered now
-// it would flash as a paragraph and snap into the table a delta later.
-function _withoutAnUnfinishedTrailingTableRow(text: string): string {
-  const lines = text.split("\n");
-  const last = lines[lines.length - 1];
-  if (/^\s*\|/.test(last) && !/\|\s*$/.test(last)) {
-    return lines.slice(0, -1).join("\n");
-  }
-  return text;
-}
-
-function _withInlineCodeClosed(text: string): string {
-  const fenceless = _outsideCodeFences(text);
-  const backticks = (fenceless.match(/`/g) ?? []).length;
-  return backticks % 2 === 1 ? `${text}\`` : text;
-}
-
-function _withStrongEmphasisClosed(text: string): string {
-  const fenceless = _outsideCodeFences(text);
-  const strongMarkers = (fenceless.match(/\*\*/g) ?? []).length;
-  return strongMarkers % 2 === 1 ? `${text}**` : text;
-}
-
-// The text with fenced blocks removed, so fence contents never count
-// toward inline balancing. Only called once the trailing fence (if any)
-// is known to be closed.
-function _outsideCodeFences(text: string): string {
-  const kept: string[] = [];
-  let insideAFence = false;
-  for (const line of text.split("\n")) {
-    if (/^\s*(```|~~~)/.test(line)) {
-      insideAFence = !insideAFence;
-      continue;
-    }
-    if (!insideAFence) {
-      kept.push(line);
-    }
-  }
-  return kept.join("\n");
-}

package/src/components/markdown/use-highlighted-html.ts

@@ -1,48 +0,0 @@
-"use client";
-
-import { useEffect, useState } from "react";
-
-import { highlightToHtml } from "./highlight.js";
-
-interface HighlightedCode {
-  key: string;
-  html: string;
-}
-
-function keyOf(code: string, language: string): string {
-  return `${language} ${code}`;
-}
-
-/** The async highlight upgrade both code-block variants ride: null until
- *  (unless) shiki's lazy chunk lands and knows the language — the caller
- *  renders its plain <pre> meanwhile, so a slow or absent chunk is never
- *  a blank block. The result is keyed to its input, so a content change
- *  falls back to plain instantly instead of flashing stale highlights. */
-export function useHighlightedHtml(
-  code: string,
-  language: string | null,
-): string | null {
-  const [highlighted, setHighlighted] = useState<HighlightedCode | null>(null);
-  useEffect(() => {
-    if (language === null) {
-      return;
-    }
-    let disposed = false;
-    const key = keyOf(code, language);
-    highlightToHtml(code, language).then(
-      (html) => {
-        if (!disposed && html !== null) {
-          setHighlighted({ key, html });
-        }
-      },
-      () => undefined,
-    );
-    return () => {
-      disposed = true;
-    };
-  }, [code, language]);
-  if (language === null || highlighted === null) {
-    return null;
-  }
-  return highlighted.key === keyOf(code, language) ? highlighted.html : null;
-}

package/src/components/markdown/use-paced-reveal.ts

@@ -1,142 +0,0 @@
-"use client";
-
-// The reveal side of the pacer: watches a streaming row's text grow in
-// poll-sized lumps and returns the smoothly-advancing prefix to render.
-// Everything present at mount paints on the first render (a mount is a
-// replay; the first chunk is the first paint — neither is ever delayed),
-// only growth observed while the row streams is paced, and the prefix is
-// raw text — the caller repairs and parses it, so partial markdown is the
-// repair layer's job, not this one's.
-
-import { useEffect, useRef, useState, type RefObject } from "react";
-
-import { RevealPacer } from "./reveal-pacer.js";
-
-const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
-
-export function usePacedReveal(
-  text: string,
-  streaming: boolean,
-): { revealed: string; revealHostRef: RefObject<HTMLDivElement | null> } {
-  const revealHostRef = useRef<HTMLDivElement | null>(null);
-  const [revealedLength, setRevealedLength] = useState(text.length);
-  const pacerRef = useRef<RevealPacer | null>(null);
-  const frameRef = useRef<number | null>(null);
-  const mountedAtRef = useRef<number | null>(null);
-  const lastSeenLengthRef = useRef(text.length);
-  const wasStreamingRef = useRef(streaming);
-
-  useEffect(() => {
-    const now = performance.now();
-    mountedAtRef.current ??= now;
-    const previousLength = lastSeenLengthRef.current;
-    lastSeenLengthRef.current = text.length;
-    const endedSinceLastRender = wasStreamingRef.current && !streaming;
-    wasStreamingRef.current = streaming;
-
-    const advanceRevealLoop = () => {
-      frameRef.current = null;
-      const pacer = pacerRef.current;
-      if (pacer === null) {
-        return;
-      }
-      const frameNow = performance.now();
-      setRevealedLength(pacer.revealedLength(frameNow));
-      if (!pacer.isCaughtUp(frameNow)) {
-        frameRef.current = requestAnimationFrame(advanceRevealLoop);
-      }
-    };
-    const ensureRevealLoop = () => {
-      frameRef.current ??= requestAnimationFrame(advanceRevealLoop);
-    };
-
-    if (text.length < previousLength) {
-      // Replaced rather than grown (a resume dedupe edge): pacing a
-      // rewrite would lie about what arrived — show it whole.
-      pacerRef.current?.revealInstantly();
-      setRevealedLength(text.length);
-      return;
-    }
-    if (streaming && text.length > previousLength) {
-      if (_reducedMotionIsOnFor(revealHostRef.current)) {
-        pacerRef.current?.revealInstantly();
-        setRevealedLength(text.length);
-        return;
-      }
-      // Lazily constructed at the first paced growth, but anchored to the
-      // mount time: the gap since mount is what separates a live tail
-      // (~one poll interval) from a replay backlog (back-to-back frames).
-      pacerRef.current ??= new RevealPacer(
-        previousLength,
-        mountedAtRef.current,
-      );
-      pacerRef.current.observe(text.length, now);
-      ensureRevealLoop();
-      return;
-    }
-    if (endedSinceLastRender && pacerRef.current !== null) {
-      if (_reducedMotionIsOnFor(revealHostRef.current)) {
-        pacerRef.current.revealInstantly();
-        setRevealedLength(text.length);
-        return;
-      }
-      // The final delta and the terminal often share one network chunk;
-      // React batches the recorder's two publishes into a single commit,
-      // so this effect can see the text grow and the stream end at once.
-      // The growth branch above was skipped (streaming is already false)
-      // — feed the pacer the final length before draining, or the sweep
-      // stops at the previous arrival and the tail never reveals.
-      pacerRef.current.observe(text.length, now);
-      pacerRef.current.beginDrain(now);
-      ensureRevealLoop();
-      return;
-    }
-    if (!streaming) {
-      // A settled row whose text moved without streaming (a park's REST
-      // re-read replacing the stream's partial tail) has no pacer and no
-      // frame loop — this sync is the only writer left.
-      // eslint-disable-next-line react-hooks/set-state-in-effect -- see above; bails out when the length is unchanged
-      setRevealedLength(text.length);
-    }
-  }, [text, streaming]);
-
-  useEffect(() => {
-    return () => {
-      if (frameRef.current !== null) {
-        cancelAnimationFrame(frameRef.current);
-      }
-    };
-  }, []);
-
-  const cappedLength = Math.min(revealedLength, text.length);
-  return {
-    revealed:
-      cappedLength >= text.length
-        ? text
-        : text.slice(0, _notSplittingASurrogatePair(text, cappedLength)),
-    revealHostRef,
-  };
-}
-
-// A prefix cut between the halves of a surrogate pair leaves a lone
-// surrogate that paints as � for a frame. Backing off one unit stays
-// monotone: the underlying boundary only ever moves forward, so the
-// rounded-down boundary never retreats either.
-function _notSplittingASurrogatePair(text: string, length: number): number {
-  const lastCode = text.charCodeAt(length - 1);
-  const cutsAPairInHalf = lastCode >= 0xd800 && lastCode <= 0xdbff;
-  return cutsAPairInHalf ? length - 1 : length;
-}
-
-// Reduced motion is resolved per decision, before any pacer exists — the
-// animating variant is never constructed (the package's motion
-// doctrine). Both channels: the OS media query and the app's
-// data-reduce-motion kill switch, read from the rendered host so the
-// ancestor walk starts inside whatever tree the row mounted in.
-function _reducedMotionIsOnFor(element: HTMLElement | null): boolean {
-  return (
-    window.matchMedia(REDUCED_MOTION_QUERY).matches ||
-    (element !== null &&
-      element.closest('[data-reduce-motion="true"]') !== null)
-  );
-}

package/src/components/memory-updated-footer.tsx

@@ -1,166 +0,0 @@
-"use client";
-
-// The message-level memory provenance footer: a quiet affordance under
-// the assistant prose whose run caused one or more memory writes. The
-// trigger coalesces the batch into one line ("Memory updated", counted
-// past one write); the reveal lists each write's canned sentence and
-// destination label.
-//
-// Audience decision, recorded where the rendering happens: this footer
-// renders identically on the embedded widget (anonymous visitors) and the
-// dashboard concierge, because the payload is end-user safe BY
-// CONSTRUCTION at the producer — verified, not assumed. The backend's
-// MemoryWritten record is deliberately content-free (memory_id + scope
-// enum only; the serving side's memory store), the emitter interpolates
-// nothing (the summary is always the module constant
-// MEMORY_UPDATED_SUMMARY_SENTENCE at its single construction site, the
-// assistant-turn activity), and the exact payload shape is pinned by the
-// serving side's approval story so an accidental content leak fails CI.
-// This component still narrows at its own layer (the serving pipeline has
-// no marker sanitizer): it renders ONLY the narrowed summary sentence and
-// a generic destination label — never the memory id, raw payloads,
-// storage paths, or an uncapped token.
-
-import { BrainIcon, ChevronDownIcon } from "lucide-react";
-import { useEffect, useId, useRef, useState } from "react";
-
-import type { MemoryUpdated } from "../core/memory-provenance-anchors.js";
-import { TfButton } from "./primitives/button.js";
-import { cx } from "./primitives/cx.js";
-
-/** The destination label: an open vocabulary rendered generically past
- *  the two known scopes — an unknown token never renders verbatim. */
-function memoryScopeLabelOf(scope: string): string {
-  if (scope === "user") {
-    return "Your memory";
-  }
-  if (scope === "org") {
-    return "Shared memory";
-  }
-  return "Memory";
-}
-
-/** The trigger's coalesced line: one quiet phrase however many writes
- *  the run made, counted only past one — and the number names its noun
- *  (the transcript's grammar: "3 results", "1 failed", never a bare
- *  count). */
-function memoryFooterLabelOf(count: number): string {
-  return count > 1
-    ? `Memory updated · ${String(count)} notes`
-    : "Memory updated";
-}
-
-export function MemoryUpdatedFooter({
-  updates,
-}: {
-  updates: readonly MemoryUpdated[];
-}) {
-  const [open, setOpen] = useState(false);
-  const panelId = useId();
-  const triggerRef = useRef<HTMLButtonElement | null>(null);
-  const panelRef = useRef<HTMLDivElement | null>(null);
-
-  // Light dismissal by composedPath() — the script-tag distribution runs
-  // in an open shadow root, where contains() would misjudge every
-  // in-shadow press (the provider chip's rationale, verbatim). Escape
-  // rides listeners on the trigger and panel (the roster card's idiom)
-  // rather than a handler on the static wrapper.
-  useEffect(() => {
-    const panelElement = panelRef.current;
-    const trigger = triggerRef.current;
-    if (!open || panelElement === null) {
-      return;
-    }
-    const closeUnlessInside = (event: Event) => {
-      const path = event.composedPath();
-      if (path.includes(panelElement)) {
-        return;
-      }
-      if (trigger !== null && path.includes(trigger)) {
-        return;
-      }
-      setOpen(false);
-    };
-    const closeOnEscape = (event: KeyboardEvent) => {
-      if (event.key !== "Escape") {
-        return;
-      }
-      event.stopPropagation();
-      setOpen(false);
-      trigger?.focus();
-    };
-    const doc = panelElement.ownerDocument;
-    doc.addEventListener("pointerdown", closeUnlessInside);
-    panelElement.addEventListener("keydown", closeOnEscape);
-    trigger?.addEventListener("keydown", closeOnEscape);
-    return () => {
-      doc.removeEventListener("pointerdown", closeUnlessInside);
-      panelElement.removeEventListener("keydown", closeOnEscape);
-      trigger?.removeEventListener("keydown", closeOnEscape);
-    };
-  }, [open]);
-
-  if (updates.length === 0) {
-    return null;
-  }
-
-  return (
-    <div data-tf-memory-footer="" className="tf:relative tf:mt-1 tf:w-fit">
-      <TfButton
-        ref={triggerRef}
-        variant="bare"
-        aria-expanded={open}
-        aria-controls={open ? panelId : undefined}
-        className="tf:py-1 tf:text-xs tf:text-tf-muted-foreground tf:hover:text-tf-foreground"
-        onClick={() => {
-          setOpen((wasOpen) => !wasOpen);
-        }}
-      >
-        <BrainIcon aria-hidden className="tf:size-3.5 tf:shrink-0" />
-        <span>{memoryFooterLabelOf(updates.length)}</span>
-        {/* The disclosure cue (design review): on the notices screen
-            three muted lines share one voice and only this one does
-            anything — the transcript's own chevron says so without
-            raising it, and hover-color alone does not exist on touch. */}
-        <ChevronDownIcon
-          aria-hidden
-          className={cx(
-            "tf:size-3 tf:shrink-0 tf:transition-transform",
-            !open && "tf:-rotate-90",
-          )}
-        />
-      </TfButton>
-      {open ? (
-        // Opens UPWARD (bottom-full), away from the composer, so the
-        // reveal can never cover its controls (TVC-120's posture). The
-        // card is static provenance text, so a note — not a dialog: no
-        // focus trap to manage, Escape and light dismissal close it.
-        <div
-          ref={panelRef}
-          id={panelId}
-          role="note"
-          aria-label="Memory updates"
-          data-tf-glass=""
-          className="tf:absolute tf:bottom-full tf:start-0 tf:mb-1 tf:flex tf:w-72 tf:flex-col tf:rounded-2xl tf:border tf:p-2"
-        >
-          <ul className="tf:m-0 tf:flex tf:max-h-64 tf:list-none tf:flex-col tf:overflow-y-auto tf:ps-0">
-            {updates.map((update) => (
-              <li
-                key={update.memoryId}
-                data-tf-memory-entry=""
-                className="tf:flex tf:flex-col tf:gap-0.5 tf:px-2 tf:py-1.5"
-              >
-                <span className="tf:text-tf-label tf:text-tf-foreground">
-                  {update.summary}
-                </span>
-                <span className="tf:text-xs tf:text-tf-muted-foreground">
-                  {memoryScopeLabelOf(update.scope)}
-                </span>
-              </li>
-            ))}
-          </ul>
-        </div>
-      ) : null}
-    </div>
-  );
-}