From aa3e6997123a9cf84e51d1bd9e6c0bac27f6452b Mon Sep 17 00:00:00 2001
From: John | Elite Encoder <john@eliteencoder.net>
Date: Sat, 5 Sep 2026 02:31:51 -0400
Subject: [PATCH] fix(usage): infer history modality without a competing
 Drizzle genesis.

Keep the in-memory MCP store so this can land on main without racing Codex's waitlist migrations. Output joins stay a no-op until mcp_assets exists on that chain.
---
 app/api/pymthouse/account-requests/route.ts |  10 +-
 components/console/CallDetailDrawer.tsx     | 455 +++++---------------
 components/console/CallsSection.tsx         |   5 +-
 components/console/CallsTable.tsx           | 100 ++---
 lib/console/account-usage.ts                |   6 +
 lib/console/activity-assets.ts              |  15 +
 lib/console/activity-media.test.ts          |  75 ++++
 lib/console/activity-media.ts               | 199 +++++++++
 lib/console/activity-output-match.test.ts   | 165 +++++++
 lib/console/activity-output-match.ts        |  93 ++++
 lib/console/capability-modality.test.ts     | 156 +++++++
 lib/console/capability-modality.ts          | 268 ++++++++++++
 lib/console/dev-mock.ts                     |  30 +-
 lib/console/history-window.test.ts          |  32 ++
 lib/console/history-window.ts               |  35 ++
 lib/console/mock-data.ts                    |   5 +
 lib/console/pymthouse-bff.ts                |  17 +-
 lib/console/request-fee-display.test.ts     |  43 ++
 lib/console/request-fee-display.ts          | 187 ++++++++
 lib/console/signed-ticket-activity.ts       |  31 +-
 lib/console/types.ts                        |   8 +
 lib/console/usage-capability-display.ts     |   6 -
 lib/mcp/jwt.ts                              |   6 +-
 lib/mcp/log.ts                              |   6 +-
 lib/mcp/principal.test.ts                   |  24 ++
 lib/mcp/principal.ts                        |  29 ++
 lib/mcp/run-capability.test.ts              |  11 +
 lib/mcp/run-capability.ts                   |  18 +-
 28 files changed, 1589 insertions(+), 446 deletions(-)
 create mode 100644 lib/console/activity-assets.ts
 create mode 100644 lib/console/activity-media.test.ts
 create mode 100644 lib/console/activity-media.ts
 create mode 100644 lib/console/activity-output-match.test.ts
 create mode 100644 lib/console/activity-output-match.ts
 create mode 100644 lib/console/capability-modality.test.ts
 create mode 100644 lib/console/capability-modality.ts
 create mode 100644 lib/console/history-window.test.ts
 create mode 100644 lib/console/history-window.ts
 create mode 100644 lib/console/request-fee-display.test.ts
 create mode 100644 lib/console/request-fee-display.ts
 create mode 100644 lib/mcp/principal.test.ts
 create mode 100644 lib/mcp/principal.ts

diff --git a/app/api/pymthouse/account-requests/route.ts b/app/api/pymthouse/account-requests/route.ts
index 4d35ea3..95e5663 100644
--- a/app/api/pymthouse/account-requests/route.ts
+++ b/app/api/pymthouse/account-requests/route.ts
@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
+import { attachOutputsToTickets } from "@/lib/console/activity-assets";
 import { fetchAccountRequestsForExternalUser } from "@/lib/console/pymthouse-bff";
 import { requireConsoleSession } from "@/lib/console/session-user";
 import {
@@ -29,7 +30,14 @@ export async function GET(request: NextRequest) {
       cursor,
       limit,
     });
-    return NextResponse.json(payload, { headers: PYMTHOUSE_NO_STORE_HEADERS });
+    const items = await attachOutputsToTickets(
+      session.externalUserId,
+      payload.items
+    );
+    return NextResponse.json(
+      { ...payload, items },
+      { headers: PYMTHOUSE_NO_STORE_HEADERS }
+    );
   } catch (error) {
     return pymthouseErrorResponse(error, "Requests fetch failed");
   }
diff --git a/components/console/CallDetailDrawer.tsx b/components/console/CallDetailDrawer.tsx
index 585bd0c..06fbb1c 100644
--- a/components/console/CallDetailDrawer.tsx
+++ b/components/console/CallDetailDrawer.tsx
@@ -9,284 +9,14 @@ import {
   type WheelEvent as ReactWheelEvent,
 } from "react";
 import { createPortal } from "react-dom";
-import { Maximize2, MoreVertical, Play, VolumeX } from "lucide-react";
-import { modalityTag } from "@/components/console/CallsTable";
 import { formatCallMetric } from "@/lib/console/utils";
-import type {
-  AccountActivityRow,
-  AccountActivityStatus,
-} from "@/lib/console/types";
-
-const STATUS_LABEL: Record<AccountActivityStatus, string> = {
-  active: "Streaming",
-  success: "Succeeded",
-  failed: "Failed",
-  timeout: "Timed out",
-};
-
-type MediaKind = "image" | "video" | "audio" | "text" | "json";
-
-type MediaSpec = {
-  kind: MediaKind;
-  title: string;
-  label: string;
-  format: string;
-  metricLabel: string;
-  metricValue: string;
-  source: string;
-  imageUrl?: string;
-  text?: string;
-  json?: unknown;
-};
-
-const AUDIO_BARS = Array.from({ length: 64 }, (_, i) => {
-  const envelope = Math.sin((i / 64) * Math.PI);
-  const detail = Math.sin(i * 1.3) * 0.32 + Math.sin(i * 0.45) * 0.22;
-  return Math.max(12, Math.round((0.18 + envelope * 0.72 + detail * 0.2) * 96));
-});
-
-function previewSeed(row: AccountActivityRow): string {
-  return encodeURIComponent(
-    `${row.id}-${row.pipeline}`.replace(/[^a-z0-9_-]+/gi, "-")
-  );
-}
-
-function previewImageUrl(row: AccountActivityRow, size = "1200/900"): string {
-  return `https://picsum.photos/seed/${previewSeed(row)}/${size}`;
-}
-
-function samplePayload(row: AccountActivityRow): {
-  request: unknown;
-  response: unknown;
-} {
-  const failed = row.status === "failed" || row.status === "timeout";
-  const error =
-    row.status === "timeout"
-      ? {
-          error: "deadline_exceeded",
-          message: "No orchestrator responded in time.",
-        }
-      : {
-          error: "inference_failed",
-          message: "The pipeline returned a non-2xx status.",
-        };
-
-  switch (row.pipeline) {
-    case "text-to-image":
-    case "image-to-image":
-      return {
-        request: {
-          prompt: "a neon-lit city street at night, cinematic",
-          steps: 4,
-          seed: 41207,
-        },
-        response: failed
-          ? error
-          : {
-              image_url: previewImageUrl(row, "1024/1024"),
-              width: 1024,
-              height: 1024,
-            },
-      };
-    case "image-to-video":
-    case "text-to-video":
-    case "video-to-video":
-    case "live-video-to-video":
-      return {
-        request: {
-          prompt: "wide cinematic production frame, soft natural motion",
-          duration_s: 6,
-        },
-        response: failed
-          ? error
-          : {
-              video_url: "https://gateway.livepeer/out/render.mp4",
-              width: 1920,
-              height: 1080,
-              duration_s: 6,
-            },
-      };
-    case "transcoding":
-    case "live-transcoding":
-      return {
-        request: {
-          source_url: "https://gateway.livepeer/in/feed.mp4",
-          profiles: ["1080p", "720p", "480p"],
-        },
-        response: failed
-          ? error
-          : {
-              playback_url: "https://gateway.livepeer/out/master.m3u8",
-              width: 1920,
-              height: 1080,
-            },
-      };
-    case "language":
-    case "text-generation":
-      return {
-        request: {
-          messages: [
-            {
-              role: "user",
-              content: "Summarize the Livepeer whitepaper in 3 bullets.",
-            },
-          ],
-          max_tokens: 512,
-        },
-        response: failed
-          ? error
-          : {
-              text: "- Decentralized GPU network\n- Pay-per-use inference\n- Open, permissionless apps",
-              tokens: 187,
-            },
-      };
-    case "audio-to-text":
-      return {
-        request: {
-          audio_url: "https://gateway.livepeer/in/clip.wav",
-          language: "en",
-        },
-        response: failed
-          ? error
-          : {
-              text: "Welcome back to the show. Today we're talking real-time AI video.",
-              duration_s: 12.4,
-            },
-      };
-    case "text-to-speech":
-    case "text-to-audio":
-      return {
-        request: { text: "Hello from the Livepeer network.", voice: "am_onyx" },
-        response: failed
-          ? error
-          : {
-              audio_url: "https://gateway.livepeer/out/tts-8821.wav",
-              duration_s: 2.1,
-            },
-      };
-    case "video-understanding":
-      return {
-        request: {
-          video_url: "https://gateway.livepeer/in/feed.mp4",
-          task: "detect",
-        },
-        response: failed
-          ? error
-          : {
-              detections: [
-                { label: "person", confidence: 0.98 },
-                { label: "bicycle", confidence: 0.83 },
-              ],
-            },
-      };
-    default:
-      return {
-        request: { input: "...", pipeline: row.pipeline },
-        response: failed ? error : { output: "...", pipeline: row.pipeline },
-      };
-  }
-}
-
-function readText(value: unknown): string | undefined {
-  if (!value || typeof value !== "object") return undefined;
-  const text = (value as { text?: unknown }).text;
-  return typeof text === "string" ? text : undefined;
-}
-
-function readTokenCount(value: unknown): string {
-  if (!value || typeof value !== "object") return "Text";
-  const tokens = (value as { tokens?: unknown }).tokens;
-  return typeof tokens === "number" ? `${tokens} tokens` : "Text";
-}
-
-function mediaSpecForRow(row: AccountActivityRow): MediaSpec {
-  const payload = samplePayload(row);
-  const pipeline = row.pipeline.toLowerCase();
-  const failed = row.status === "failed" || row.status === "timeout";
-  const source = row.signerLabel || "Livepeer";
-
-  if (failed) {
-    return {
-      kind: "json",
-      title: `${row.model} request`,
-      label: "Error",
-      format: "JSON",
-      metricLabel: "Result",
-      metricValue: STATUS_LABEL[row.status],
-      source,
-      json: payload.response,
-    };
-  }
-
-  if (pipeline.includes("video") || pipeline.includes("transcoding")) {
-    return {
-      kind: "video",
-      title:
-        row.kind === "live" ? `${row.model} session` : `${row.model} video`,
-      label: "Video",
-      format: pipeline.includes("transcoding") ? "HLS" : "MP4",
-      metricLabel: "Dimensions",
-      metricValue: "1920 x 1080",
-      source,
-      imageUrl: previewImageUrl(row, "1280/720"),
-    };
-  }
-
-  if (pipeline.includes("image")) {
-    return {
-      kind: "image",
-      title: `${row.model} image`,
-      label: "Image",
-      format: "PNG",
-      metricLabel: "Dimensions",
-      metricValue: "1024 x 1024",
-      source,
-      imageUrl: previewImageUrl(row, "1024/1024"),
-    };
-  }
-
-  if (pipeline.includes("audio") || pipeline.includes("speech")) {
-    return {
-      kind: "audio",
-      title: `${row.model} audio`,
-      label: "Audio",
-      format: "WAV",
-      metricLabel: "Duration",
-      metricValue:
-        row.pipeline === "audio-to-text" ? "12.4s source" : "2.1s output",
-      source,
-    };
-  }
-
-  if (
-    pipeline === "language" ||
-    pipeline === "llm" ||
-    pipeline.includes("text")
-  ) {
-    const text = readText(payload.response) ?? JSON.stringify(payload.response);
-    return {
-      kind: "text",
-      title: `${row.model} response`,
-      label: "Text",
-      format: "TXT",
-      metricLabel: "Length",
-      metricValue: readTokenCount(payload.response),
-      source,
-      text,
-    };
-  }
-
-  return {
-    kind: "json",
-    title: `${row.model} response`,
-    label: "Data",
-    format: "JSON",
-    metricLabel: "Result",
-    metricValue: STATUS_LABEL[row.status],
-    source,
-    json: payload.response,
-  };
-}
+import Tooltip from "@/components/design-system/Tooltip";
+import {
+  mediaSpecForRow,
+  STATUS_LABEL,
+  type MediaSpec,
+} from "@/lib/console/activity-media";
+import type { AccountActivityRow } from "@/lib/console/types";
 
 function formatTimestamp(iso: string): string {
   const date = new Date(iso);
@@ -322,17 +52,36 @@ function CapabilityChip({ children }: { children: ReactNode }) {
   );
 }
 
-function ImagePreview({
-  src,
-  title,
-}: {
-  src: string;
-  title: string;
-}) {
+function EmptyOutput() {
+  return (
+    <div className="flex h-full w-full items-center justify-center text-sm text-white/50">
+      No output stored for this job
+    </div>
+  );
+}
+
+function PreviewLoader() {
+  return (
+    <div
+      className="absolute inset-0 flex items-center justify-center"
+      aria-busy="true"
+      aria-label="Loading preview"
+    >
+      <span
+        className="h-8 w-8 animate-spin rounded-full border-2 border-white/20 border-t-white/70 motion-reduce:animate-none"
+        aria-hidden="true"
+      />
+    </div>
+  );
+}
+
+function ImagePreview({ src, title }: { src: string; title: string }) {
   const [failed, setFailed] = useState(false);
+  const [loaded, setLoaded] = useState(false);
 
   useEffect(() => {
     setFailed(false);
+    setLoaded(false);
   }, [src]);
 
   if (failed) {
@@ -344,65 +93,39 @@ function ImagePreview({
   }
 
   return (
-    <img
-      src={src}
-      alt={title}
-      decoding="async"
-      onError={() => setFailed(true)}
-      className="h-full w-full object-contain object-top lg:object-center"
-    />
+    <div className="relative h-full w-full">
+      {!loaded && <PreviewLoader />}
+      <img
+        src={src}
+        alt={title}
+        decoding="async"
+        onLoad={() => setLoaded(true)}
+        onError={() => setFailed(true)}
+        className={`h-full w-full object-contain object-top lg:object-center ${
+          loaded ? "opacity-100" : "opacity-0"
+        }`}
+      />
+    </div>
   );
 }
 
-function VideoPreview({ poster }: { poster?: string }) {
+function VideoPreview({ src }: { src?: string }) {
+  if (!src) return <EmptyOutput />;
   return (
-    <div className="relative h-full w-full overflow-hidden bg-background">
-      {poster && (
-        <img
-          src={poster}
-          alt=""
-          decoding="async"
-          aria-hidden="true"
-          className="absolute inset-0 h-full w-full object-cover opacity-20 blur-sm"
-        />
-      )}
-      <div className="absolute inset-0 bg-background/80" />
-      <div className="absolute inset-x-5 bottom-5 text-white/80">
-        <div className="flex items-center gap-3 text-sm">
-          <Play className="h-4 w-4 fill-current" aria-hidden="true" />
-          <span>0:00</span>
-          <div className="ml-auto flex items-center gap-5 text-white/45">
-            <VolumeX className="h-4 w-4" aria-hidden="true" />
-            <Maximize2 className="h-4 w-4" aria-hidden="true" />
-            <MoreVertical className="h-4 w-4" aria-hidden="true" />
-          </div>
-        </div>
-        <div className="mt-5 h-1 overflow-hidden rounded-full bg-white/20">
-          <div className="h-full w-[8%] rounded-full bg-white/65" />
-        </div>
-      </div>
-    </div>
+    <video
+      src={src}
+      controls
+      playsInline
+      className="h-full w-full bg-background object-contain"
+    />
   );
 }
 
-function AudioPreview() {
+function AudioPreview({ src }: { src?: string }) {
+  if (!src) return <EmptyOutput />;
   return (
     <div className="flex w-full max-w-3xl flex-col gap-5 rounded-[6px] bg-black/20 px-8 py-7">
-      <div className="flex h-28 items-center gap-1.5">
-        {AUDIO_BARS.map((height, i) => (
-          <span
-            key={i}
-            className="w-1 flex-1 rounded-full bg-white/45"
-            style={{ height }}
-            aria-hidden="true"
-          />
-        ))}
-      </div>
-      <div className="flex items-center gap-3 text-sm text-white/70">
-        <Play className="h-4 w-4 fill-current" aria-hidden="true" />
-        <span>0:00</span>
-        <div className="h-1 flex-1 rounded-full bg-white/15" />
-      </div>
+      <audio src={src} controls className="w-full" />
     </div>
   );
 }
@@ -426,12 +149,20 @@ function JsonPreview({ value }: { value: unknown }) {
 function MediaStage({ media }: { media: MediaSpec }) {
   return (
     <div className="relative flex aspect-video w-full min-h-0 min-w-0 items-start justify-center overflow-auto bg-background lg:aspect-auto lg:h-full lg:items-center">
-      {media.kind === "image" && media.imageUrl && (
-        <ImagePreview src={media.imageUrl} title={media.title} />
-      )}
-      {media.kind === "video" && <VideoPreview poster={media.imageUrl} />}
-      {media.kind === "audio" && <AudioPreview />}
-      {media.kind === "text" && <TextPreview text={media.text ?? ""} />}
+      {media.kind === "image" &&
+        (media.imageUrl ? (
+          <ImagePreview src={media.imageUrl} title={media.title} />
+        ) : (
+          <EmptyOutput />
+        ))}
+      {media.kind === "video" && <VideoPreview src={media.videoUrl} />}
+      {media.kind === "audio" && <AudioPreview src={media.audioUrl} />}
+      {media.kind === "text" &&
+        (media.text ? (
+          <TextPreview text={media.text} />
+        ) : (
+          <EmptyOutput />
+        ))}
       {media.kind === "json" && <JsonPreview value={media.json} />}
     </div>
   );
@@ -551,7 +282,9 @@ export default function CallDetailDrawer({
   useEffect(() => {
     if (open) {
       previousActiveRef.current = document.activeElement as HTMLElement | null;
-      requestAnimationFrame(() => panelRef.current?.focus({ preventScroll: true }));
+      requestAnimationFrame(() =>
+        panelRef.current?.focus({ preventScroll: true })
+      );
     } else if (previousActiveRef.current) {
       previousActiveRef.current.focus?.({ preventScroll: true });
       previousActiveRef.current = null;
@@ -636,16 +369,31 @@ export default function CallDetailDrawer({
           }`}
         >
           <div className="grid h-auto min-w-0 flex-1 grid-rows-[auto_auto] overflow-hidden rounded-sm bg-background shadow-2xl shadow-black/55 lg:h-full lg:grid-cols-[minmax(0,1fr)_350px] lg:grid-rows-none">
-            <MediaStage media={media} />
+            <MediaStage key={row.id} media={media} />
 
             <aside className="flex min-h-0 flex-col border-t border-hairline bg-background lg:border-l lg:border-t-0">
-              <dl className="min-h-0 overflow-y-auto px-5 py-5" data-detail-scroll>
+              <dl
+                className="min-h-0 overflow-y-auto px-5 py-5"
+                data-detail-scroll
+              >
                 <DetailRow label="Capability">
                   <CapabilityChip>{row.model}</CapabilityChip>
                 </DetailRow>
                 <DetailRow label="Modality">
-                  <CapabilityChip>{modalityTag(row.pipeline)}</CapabilityChip>
+                  <CapabilityChip>{row.modality}</CapabilityChip>
                 </DetailRow>
+                <DetailRow label="Job">
+                  <span className="font-mono text-[13px] tabular-nums">
+                    {row.id}
+                  </span>
+                </DetailRow>
+                {row.providerRequestId ? (
+                  <DetailRow label="Request">
+                    <span className="font-mono text-[13px] tabular-nums">
+                      {row.providerRequestId}
+                    </span>
+                  </DetailRow>
+                ) : null}
                 <DetailRow label="Format">{media.format}</DetailRow>
                 <DetailRow label={media.metricLabel}>
                   {media.metricValue}
@@ -655,7 +403,24 @@ export default function CallDetailDrawer({
                 <DetailRow label={row.kind === "live" ? "Duration" : "Latency"}>
                   {formatCallMetric(row)}
                 </DetailRow>
-                <DetailRow label="Cost">{row.costDisplay}</DetailRow>
+                <DetailRow label="Cost">
+                  {row.costExact && row.costExact !== row.costDisplay ? (
+                    <Tooltip
+                      content={
+                        <span className="font-mono tabular-nums">
+                          {row.costExact}
+                        </span>
+                      }
+                      side="left"
+                    >
+                      <span className="cursor-help font-mono tabular-nums">
+                        {row.costDisplay}
+                      </span>
+                    </Tooltip>
+                  ) : (
+                    row.costDisplay
+                  )}
+                </DetailRow>
                 <DetailRow label="Time">
                   {formatTimestamp(row.timestamp)}
                 </DetailRow>
diff --git a/components/console/CallsSection.tsx b/components/console/CallsSection.tsx
index f82f942..7dae763 100644
--- a/components/console/CallsSection.tsx
+++ b/components/console/CallsSection.tsx
@@ -4,7 +4,7 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import { useRouter, useSearchParams } from "next/navigation";
 import { Loader2, Search, X } from "lucide-react";
 import SectionHeader from "@/components/console/SectionHeader";
-import CallsTable, { modalityTag } from "@/components/console/CallsTable";
+import CallsTable from "@/components/console/CallsTable";
 import CallDetailDrawer from "@/components/console/CallDetailDrawer";
 import { useAuth } from "@/components/console/AuthContext";
 import { useAccountRequests } from "@/lib/console/useAccountRequests";
@@ -59,7 +59,7 @@ export default function CallsSection({
             r.id.toLowerCase().includes(q) ||
             r.model.toLowerCase().includes(q) ||
             r.pipeline.toLowerCase().includes(q) ||
-            modalityTag(r.pipeline).includes(q)
+            r.modality.toLowerCase().includes(q)
         )
       : allRows;
     return [...scoped].sort(
@@ -124,6 +124,7 @@ export default function CallsSection({
         variant="default"
         className="mb-3 flex flex-wrap items-end justify-between gap-3 px-3 md:px-7"
         title="History"
+        description="Last 7 days"
         action={
           <div className="flex h-[26px] w-[240px] items-center gap-1.5 rounded-[4px] border border-hairline bg-dark px-2.5 focus-within:ring-1 focus-within:ring-green-bright/30">
             <Search
diff --git a/components/console/CallsTable.tsx b/components/console/CallsTable.tsx
index 99f6d49..9f94961 100644
--- a/components/console/CallsTable.tsx
+++ b/components/console/CallsTable.tsx
@@ -4,6 +4,7 @@ import Link from "next/link";
 import { formatCallMetric, formatRunRelativeTime } from "@/lib/console/utils";
 import EnvTag from "@/components/console/EnvTag";
 import StatusDot from "@/components/console/StatusDot";
+import Tooltip from "@/components/design-system/Tooltip";
 import { useTickWhileActive } from "@/components/console/useTickWhileActive";
 import type { AccountActivityRow } from "@/lib/console/types";
 
@@ -16,7 +17,7 @@ import type { AccountActivityRow } from "@/lib/console/types";
  * drawer now lives.
  *
  * Full row vocabulary (left → right):
- *   8px status dot · mono short id · model · pipeline pill · latency|duration ·
+ *   8px status dot · mono short id · model · modality pill · latency|duration ·
  *   cost · via (signer) · relative time.
  *
  * History rows are quieter: relative time · model · modality pill · cost.
@@ -55,54 +56,6 @@ export interface CallsTableProps {
   className?: string;
 }
 
-export function modalityTag(pipeline: string): string {
-  const normalized = pipeline.toLowerCase();
-  const exact: Record<string, string> = {
-    "audio-to-text": "a2t",
-    "image-to-image": "i2i",
-    "image-to-video": "i2v",
-    language: "t2t",
-    llm: "t2t",
-    "live-transcoding": "v2v",
-    "live-video-to-video": "v2v",
-    "speech-to-text": "s2t",
-    "text-generation": "t2t",
-    "text-to-audio": "t2a",
-    "text-to-image": "t2i",
-    "text-to-speech": "t2s",
-    "text-to-video": "t2v",
-    transcoding: "v2v",
-    "video-understanding": "v2t",
-    "video-to-video": "v2v",
-  };
-  const mapped = exact[normalized];
-  if (mapped) return mapped;
-
-  const match = normalized.match(
-    /^(text|image|video|audio|speech|live)-to-(text|image|video|audio|speech)$/
-  );
-  if (match) {
-    const token = (part: string) =>
-      part === "text"
-        ? "t"
-        : part === "image"
-          ? "i"
-          : part === "video"
-            ? "v"
-            : part === "audio"
-              ? "a"
-              : "s";
-    return `${token(match[1]!)}2${token(match[2]!)}`;
-  }
-
-  return normalized
-    .split(/[-_./|:]+/)
-    .filter(Boolean)
-    .map((part) => part[0])
-    .join("")
-    .slice(0, 8);
-}
-
 function formatHistoryRelativeTime(iso: string): string {
   const then = new Date(iso).getTime();
   if (Number.isFinite(then)) {
@@ -113,6 +66,39 @@ function formatHistoryRelativeTime(iso: string): string {
   return formatRunRelativeTime(iso).replace(/ ago$/, "");
 }
 
+function HistoryCost({
+  row,
+  compact,
+}: {
+  row: AccountActivityRow;
+  compact: boolean;
+}) {
+  const amount = (
+    <span
+      className={`text-right font-mono tabular-nums text-fg ${
+        compact ? "text-[12.5px]" : "text-[11.5px]"
+      } ${row.costExact && row.costExact !== row.costDisplay ? "cursor-help" : ""}`}
+    >
+      {row.costDisplay}
+    </span>
+  );
+  if (!row.costExact || row.costExact === row.costDisplay) {
+    return amount;
+  }
+  return (
+    <span className="justify-self-end">
+      <Tooltip
+        content={
+          <span className="font-mono tabular-nums">{row.costExact}</span>
+        }
+        side="left"
+      >
+        {amount}
+      </Tooltip>
+    </span>
+  );
+}
+
 export default function CallsTable({
   rows,
   showHeader = false,
@@ -129,8 +115,8 @@ export default function CallsTable({
   // values, so each density preset is spelled out in full.
   const cols = compact
     ? density === "cozy"
-      ? "grid items-center gap-3 px-3 md:px-7 grid-cols-[minmax(0,1fr)_88px]"
-      : "grid items-center gap-3 px-4 grid-cols-[minmax(0,1fr)_76px]"
+      ? "grid items-center gap-3 px-3 md:px-7 grid-cols-[minmax(0,1fr)_4.5rem]"
+      : "grid items-center gap-3 px-4 grid-cols-[minmax(0,1fr)_4.5rem]"
     : density === "cozy"
       ? "grid items-center gap-3 px-5 grid-cols-[minmax(0,1fr)_80px_80px_80px_80px]"
       : "grid items-center gap-3 px-4 grid-cols-[minmax(0,1fr)_70px_70px_70px_70px]";
@@ -171,9 +157,7 @@ export default function CallsTable({
       )}
       {rows.map((row, i) => {
         const active = row.status === "active";
-        const pipelineLabel = compact
-          ? modalityTag(row.pipeline)
-          : row.pipeline;
+        const pipelineLabel = row.modality;
         const timeLabel = compact
           ? formatHistoryRelativeTime(row.timestamp)
           : formatRunRelativeTime(row.timestamp);
@@ -249,13 +233,7 @@ export default function CallsTable({
                 {formatCallMetric(row, nowMs)}
               </span>
             )}
-            <span
-              className={`text-right text-fg ${
-                compact ? "text-[12.5px]" : "font-mono text-[11.5px]"
-              }`}
-            >
-              {row.costDisplay}
-            </span>
+            <HistoryCost row={row} compact={compact} />
             {!compact && (
               <span className="truncate text-right font-mono text-[11.5px] text-fg-faint">
                 {row.signerLabel}
diff --git a/lib/console/account-usage.ts b/lib/console/account-usage.ts
index c2e6aba..77e5211 100644
--- a/lib/console/account-usage.ts
+++ b/lib/console/account-usage.ts
@@ -55,7 +55,13 @@ export type SignedTicketRequestRow = {
   networkFeeUsdMicros: string;
   feeWei?: string;
   pixels?: string;
+  /** ETH/USD at ingest; with `feeWei`, the exact ticket price. */
+  ethUsdPrice?: string;
   eventId: string;
+  /** Neon-stored media URL joined on `gatewayRequestId`. */
+  outputUrl?: string | null;
+  /** fal/runner request id from the asset store (#26). */
+  providerRequestId?: string | null;
 };
 
 export type AccountRequestsPayload = {
diff --git a/lib/console/activity-assets.ts b/lib/console/activity-assets.ts
new file mode 100644
index 0000000..01e68a7
--- /dev/null
+++ b/lib/console/activity-assets.ts
@@ -0,0 +1,15 @@
+import "server-only";
+
+import type { SignedTicketRequestRow } from "@/lib/console/account-usage";
+
+/**
+ * Output joins need the early-access `mcp_assets` table. This PR keeps the
+ * in-memory MCP store so it can land on main without a competing Drizzle
+ * genesis. History still renders; previews stay empty until that chain merges.
+ */
+export async function attachOutputsToTickets(
+  _principalId: string,
+  items: SignedTicketRequestRow[]
+): Promise<SignedTicketRequestRow[]> {
+  return items;
+}
diff --git a/lib/console/activity-media.test.ts b/lib/console/activity-media.test.ts
new file mode 100644
index 0000000..8276a34
--- /dev/null
+++ b/lib/console/activity-media.test.ts
@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { mediaSpecForRow } from "./activity-media";
+import { mapSignedTicketToActivityRow } from "./signed-ticket-activity";
+
+const ticket = {
+  time: "2026-09-04T22:17:00.000Z",
+  clientId: "app_test",
+  appName: "Livepeer Agent",
+  externalUserId: "eu_test",
+  gatewayRequestId: "job_abc",
+  pipeline: "fixed",
+  modelId: "livepeer-example/fal-gpt-image-2",
+  networkFeeUsdMicros: "1000",
+  eventId: "evt_1",
+};
+
+test("signed-ticket join copies output URL and provider request id", () => {
+  const row = mapSignedTicketToActivityRow({
+    ...ticket,
+    outputUrl: "https://v3b.fal.media/files/x.jpg",
+    providerRequestId: "req-fal",
+  });
+  assert.equal(row.id, "job_abc");
+  assert.equal(row.outputUrl, "https://v3b.fal.media/files/x.jpg");
+  assert.equal(row.providerRequestId, "req-fal");
+});
+
+test("media spec uses the stored image URL, not a placeholder", () => {
+  const spec = mediaSpecForRow(
+    mapSignedTicketToActivityRow({
+      ...ticket,
+      outputUrl: "https://v3b.fal.media/files/x.jpg",
+    })
+  );
+  assert.equal(spec.kind, "image");
+  assert.equal(spec.imageUrl, "https://v3b.fal.media/files/x.jpg");
+  assert.equal(spec.format, "JPG");
+  assert.equal(spec.imageUrl?.includes("picsum"), false);
+});
+
+test("media spec plays stored video URLs", () => {
+  const spec = mediaSpecForRow(
+    mapSignedTicketToActivityRow({
+      ...ticket,
+      pipeline: "text-to-video",
+      modelId: "livepeer-example/fal-ltx-25-t2v-fast",
+      outputUrl: "https://v3b.fal.media/files/out.mp4",
+    })
+  );
+  assert.equal(spec.kind, "video");
+  assert.equal(spec.videoUrl, "https://v3b.fal.media/files/out.mp4");
+});
+
+test("media spec does not invent a preview when the job has no stored output", () => {
+  const spec = mediaSpecForRow(mapSignedTicketToActivityRow(ticket));
+  assert.equal(spec.kind, "image");
+  assert.equal(spec.imageUrl, undefined);
+  assert.equal(spec.metricValue, "Not stored");
+});
+
+test("text modalities are not classified as video because the pipeline name contains video", () => {
+  const spec = mediaSpecForRow(
+    mapSignedTicketToActivityRow({
+      ...ticket,
+      pipeline: "video-understanding",
+      modelId: "livepeer-example/fal-video-understand",
+      outputUrl: "https://example.test/notes.txt",
+    })
+  );
+  assert.equal(spec.kind, "text");
+  assert.equal(spec.videoUrl, undefined);
+  assert.equal(spec.text, "https://example.test/notes.txt");
+});
diff --git a/lib/console/activity-media.ts b/lib/console/activity-media.ts
new file mode 100644
index 0000000..6aeff40
--- /dev/null
+++ b/lib/console/activity-media.ts
@@ -0,0 +1,199 @@
+import { outputKindForModality } from "@/lib/console/capability-modality";
+import type {
+  AccountActivityRow,
+  AccountActivityStatus,
+} from "@/lib/console/types";
+
+export type MediaKind = "image" | "video" | "audio" | "text" | "json";
+
+export type MediaSpec = {
+  kind: MediaKind;
+  title: string;
+  label: string;
+  format: string;
+  metricLabel: string;
+  metricValue: string;
+  source: string;
+  imageUrl?: string;
+  videoUrl?: string;
+  audioUrl?: string;
+  text?: string;
+  json?: unknown;
+};
+
+const STATUS_LABEL: Record<AccountActivityStatus, string> = {
+  active: "Streaming",
+  success: "Succeeded",
+  failed: "Failed",
+  timeout: "Timed out",
+};
+
+const IMAGE_EXT = new Set(["avif", "bmp", "gif", "jpeg", "jpg", "png", "webp"]);
+const VIDEO_EXT = new Set(["m3u8", "mov", "mp4", "webm"]);
+const AUDIO_EXT = new Set(["flac", "m4a", "mp3", "ogg", "wav"]);
+
+function urlExtension(url: string): string {
+  try {
+    const path = new URL(url).pathname;
+    const name = path.split("/").pop() ?? "";
+    const dot = name.lastIndexOf(".");
+    if (dot < 0) return "";
+    return name.slice(dot + 1).toLowerCase();
+  } catch {
+    return "";
+  }
+}
+
+function formatFromUrl(url: string | undefined, fallback: string): string {
+  if (!url) return fallback;
+  const ext = urlExtension(url);
+  return ext ? ext.toUpperCase() : fallback;
+}
+
+function failedPayload(row: AccountActivityRow): unknown {
+  return row.status === "timeout"
+    ? {
+        error: "deadline_exceeded",
+        message: "No orchestrator responded in time.",
+      }
+    : {
+        error: "inference_failed",
+        message: "The pipeline returned a non-2xx status.",
+      };
+}
+
+export function mediaSpecForRow(row: AccountActivityRow): MediaSpec {
+  const source = row.signerLabel || "Livepeer";
+  const outputKind = outputKindForModality(row.modality);
+  const outputUrl = row.outputUrl?.trim() || undefined;
+  const failed = row.status === "failed" || row.status === "timeout";
+
+  if (failed) {
+    return {
+      kind: "json",
+      title: `${row.model} request`,
+      label: "Error",
+      format: "JSON",
+      metricLabel: "Result",
+      metricValue: STATUS_LABEL[row.status],
+      source,
+      json: failedPayload(row),
+    };
+  }
+
+  const ext = outputUrl ? urlExtension(outputUrl) : "";
+  if (VIDEO_EXT.has(ext)) {
+    return videoSpec(row, source, outputUrl);
+  }
+  if (IMAGE_EXT.has(ext)) {
+    return imageSpec(row, source, outputUrl);
+  }
+  if (AUDIO_EXT.has(ext)) {
+    return audioSpec(row, source, outputUrl);
+  }
+
+  if (outputKind === "text") {
+    return textSpec(row, source, outputUrl);
+  }
+  if (outputKind === "video") {
+    return videoSpec(row, source, outputUrl);
+  }
+  if (outputKind === "image") {
+    return imageSpec(row, source, outputUrl);
+  }
+  if (outputKind === "audio") {
+    return audioSpec(row, source, outputUrl);
+  }
+
+  if (
+    row.pipeline === "language" ||
+    row.pipeline === "llm" ||
+    row.pipeline.includes("text")
+  ) {
+    return textSpec(row, source, outputUrl);
+  }
+
+  return {
+    kind: "json",
+    title: `${row.model} response`,
+    label: "Data",
+    format: "JSON",
+    metricLabel: "Result",
+    metricValue: STATUS_LABEL[row.status],
+    source,
+    json: outputUrl
+      ? { output_url: outputUrl, request_id: row.providerRequestId ?? null }
+      : { output: "not_stored" },
+  };
+}
+
+function videoSpec(
+  row: AccountActivityRow,
+  source: string,
+  outputUrl: string | undefined
+): MediaSpec {
+  return {
+    kind: "video",
+    title:
+      row.kind === "live" ? `${row.model} session` : `${row.model} video`,
+    label: "Video",
+    format: formatFromUrl(outputUrl, "—"),
+    metricLabel: "Output",
+    metricValue: outputUrl ? "Stored" : "Not stored",
+    source,
+    videoUrl: outputUrl,
+  };
+}
+
+function imageSpec(
+  row: AccountActivityRow,
+  source: string,
+  outputUrl: string | undefined
+): MediaSpec {
+  return {
+    kind: "image",
+    title: `${row.model} image`,
+    label: "Image",
+    format: formatFromUrl(outputUrl, "—"),
+    metricLabel: "Output",
+    metricValue: outputUrl ? "Stored" : "Not stored",
+    source,
+    imageUrl: outputUrl,
+  };
+}
+
+function audioSpec(
+  row: AccountActivityRow,
+  source: string,
+  outputUrl: string | undefined
+): MediaSpec {
+  return {
+    kind: "audio",
+    title: `${row.model} audio`,
+    label: "Audio",
+    format: formatFromUrl(outputUrl, "—"),
+    metricLabel: "Output",
+    metricValue: outputUrl ? "Stored" : "Not stored",
+    source,
+    audioUrl: outputUrl,
+  };
+}
+
+function textSpec(
+  row: AccountActivityRow,
+  source: string,
+  outputUrl: string | undefined
+): MediaSpec {
+  return {
+    kind: "text",
+    title: `${row.model} response`,
+    label: "Text",
+    format: "TXT",
+    metricLabel: "Output",
+    metricValue: outputUrl ? "Stored" : "Not stored",
+    source,
+    text: outputUrl,
+  };
+}
+
+export { STATUS_LABEL };
diff --git a/lib/console/activity-output-match.test.ts b/lib/console/activity-output-match.test.ts
new file mode 100644
index 0000000..0988dc3
--- /dev/null
+++ b/lib/console/activity-output-match.test.ts
@@ -0,0 +1,165 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { matchTicketOutputs } from "./activity-output-match";
+import type { SignedTicketRequestRow } from "./account-usage";
+
+function ticket(
+  partial: Partial<SignedTicketRequestRow> &
+    Pick<SignedTicketRequestRow, "gatewayRequestId" | "time" | "modelId">
+): SignedTicketRequestRow {
+  return {
+    clientId: "app_test",
+    externalUserId: "eu_3ebf",
+    networkFeeUsdMicros: "1000",
+    eventId: partial.eventId ?? partial.gatewayRequestId,
+    pipeline: "fixed",
+    ...partial,
+  };
+}
+
+test("exact gateway_request_id wins over time matching", () => {
+  const items = [
+    ticket({
+      gatewayRequestId: "job_abc",
+      time: "2026-09-05T01:37:43.000Z",
+      modelId: "livepeer-example/fal-flux-schnell",
+    }),
+  ];
+  const matched = matchTicketOutputs(items, [
+    {
+      id: "asset_wrong",
+      url: "https://example.test/wrong.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:40.000Z",
+      gatewayRequestId: "job_other",
+    },
+    {
+      id: "asset_hit",
+      url: "https://example.test/hit.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:00:00.000Z",
+      gatewayRequestId: "job_abc",
+      providerRequestId: "req-fal",
+    },
+  ]);
+  assert.equal(matched.get("job_abc")?.url, "https://example.test/hit.jpg");
+  assert.equal(matched.get("job_abc")?.providerRequestId, "req-fal");
+});
+
+test("orchestrator 8-hex tickets join MCP job_* assets by capability and time", () => {
+  const items = [
+    ticket({
+      gatewayRequestId: "41dfff3c",
+      eventId: "41dfff3c",
+      time: "2026-09-05T01:37:50.000Z",
+      modelId: "livepeer-example/fal-flux-schnell",
+    }),
+  ];
+  const matched = matchTicketOutputs(items, [
+    {
+      id: "asset_1",
+      url: "https://v3b.fal.media/files/b/cube.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:43.000Z",
+      gatewayRequestId: "job_44480a5ff910483e",
+      providerRequestId: "01a06f36-d5fe-7351-a8d1-ce8fa3c11004",
+    },
+  ]);
+  assert.equal(
+    matched.get("41dfff3c")?.url,
+    "https://v3b.fal.media/files/b/cube.jpg"
+  );
+});
+
+test("time match does not attach a different capability", () => {
+  const items = [
+    ticket({
+      gatewayRequestId: "83493a58",
+      time: "2026-09-05T01:37:50.000Z",
+      modelId: "livepeer-example/fal-ltx-25-t2v-fast",
+    }),
+  ];
+  const matched = matchTicketOutputs(items, [
+    {
+      id: "asset_1",
+      url: "https://example.test/flux.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:43.000Z",
+      gatewayRequestId: "job_44480a5ff910483e",
+    },
+  ]);
+  assert.equal(matched.has("83493a58"), false);
+});
+
+test("each asset attaches to at most one ticket", () => {
+  const items = [
+    ticket({
+      gatewayRequestId: "aaaa1111",
+      time: "2026-09-05T01:37:50.000Z",
+      modelId: "livepeer-example/fal-flux-schnell",
+    }),
+    ticket({
+      gatewayRequestId: "bbbb2222",
+      time: "2026-09-05T01:37:51.000Z",
+      modelId: "livepeer-example/fal-flux-schnell",
+    }),
+  ];
+  const matched = matchTicketOutputs(items, [
+    {
+      id: "asset_1",
+      url: "https://example.test/only.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:43.000Z",
+      gatewayRequestId: "job_one",
+    },
+  ]);
+  assert.equal(matched.size, 1);
+});
+
+test("ambiguous same-capability assets in the window are not attached", () => {
+  const items = [
+    ticket({
+      gatewayRequestId: "aaaa1111",
+      time: "2026-09-05T01:37:50.000Z",
+      modelId: "livepeer-example/fal-flux-schnell",
+    }),
+  ];
+  const matched = matchTicketOutputs(items, [
+    {
+      id: "asset_a",
+      url: "https://example.test/a.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:43.000Z",
+      gatewayRequestId: "job_a",
+    },
+    {
+      id: "asset_b",
+      url: "https://example.test/b.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:40.000Z",
+      gatewayRequestId: "job_b",
+    },
+  ]);
+  assert.equal(matched.has("aaaa1111"), false);
+});
+
+test("job_* tickets without an exact id match do not fuzzy-join another job", () => {
+  const items = [
+    ticket({
+      gatewayRequestId: "job_abc",
+      time: "2026-09-05T01:37:50.000Z",
+      modelId: "livepeer-example/fal-flux-schnell",
+    }),
+  ];
+  const matched = matchTicketOutputs(items, [
+    {
+      id: "asset_other",
+      url: "https://example.test/other.jpg",
+      capability: "livepeer-example/fal-flux-schnell",
+      createdAt: "2026-09-05T01:37:43.000Z",
+      gatewayRequestId: "job_other",
+    },
+  ]);
+  assert.equal(matched.has("job_abc"), false);
+});
diff --git a/lib/console/activity-output-match.ts b/lib/console/activity-output-match.ts
new file mode 100644
index 0000000..96a3c16
--- /dev/null
+++ b/lib/console/activity-output-match.ts
@@ -0,0 +1,93 @@
+import type { SignedTicketRequestRow } from "@/lib/console/account-usage";
+
+export type JobOutput = {
+  url: string;
+  providerRequestId?: string | null;
+};
+
+export type MatchableAsset = {
+  id: string;
+  url: string;
+  capability: string;
+  createdAt: string;
+  gatewayRequestId: string;
+  providerRequestId?: string | null;
+};
+
+/** Orchestrator Kafka events use RandomManifestID as CloudEvent id (~8 hex). */
+export const TICKET_ASSET_MATCH_WINDOW_MS = 15 * 60 * 1000;
+
+const ORCHESTRATOR_HEX_ID = /^[0-9a-f]{8}$/i;
+
+export function isOrchestratorTicketId(id: string): boolean {
+  return ORCHESTRATOR_HEX_ID.test(id.trim());
+}
+
+function ticketKeys(ticket: SignedTicketRequestRow): string[] {
+  return [ticket.gatewayRequestId, ticket.eventId]
+    .map((id) => id.trim())
+    .filter((id, index, all) => id.length > 0 && all.indexOf(id) === index);
+}
+
+function outputFromAsset(asset: MatchableAsset): JobOutput {
+  return {
+    url: asset.url,
+    providerRequestId: asset.providerRequestId,
+  };
+}
+
+function needsFuzzyMatch(ticket: SignedTicketRequestRow): boolean {
+  return ticketKeys(ticket).every(isOrchestratorTicketId);
+}
+
+/**
+ * Map each OpenMeter ticket to a stored media URL.
+ * Exact `gateway_request_id` / event id wins. Orchestrator 8-hex tickets
+ * that never received an MCP `job_*` id may join the nearest same-capability
+ * asset in the window — skipped when more than one candidate exists (race).
+ */
+export function matchTicketOutputs(
+  tickets: SignedTicketRequestRow[],
+  assets: MatchableAsset[]
+): Map<string, JobOutput> {
+  const byId = new Map<string, MatchableAsset>();
+  for (const asset of assets) {
+    const key = asset.gatewayRequestId.trim();
+    if (key && !byId.has(key)) byId.set(key, asset);
+  }
+
+  const used = new Set<string>();
+  const out = new Map<string, JobOutput>();
+
+  for (const ticket of tickets) {
+    const keys = ticketKeys(ticket);
+    const exact = keys.map((key) => byId.get(key)).find(Boolean);
+    if (exact) {
+      used.add(exact.id);
+      out.set(ticket.gatewayRequestId, outputFromAsset(exact));
+    }
+  }
+
+  for (const ticket of tickets) {
+    if (out.has(ticket.gatewayRequestId)) continue;
+    if (!needsFuzzyMatch(ticket)) continue;
+    const ticketTime = Date.parse(ticket.time);
+    if (!Number.isFinite(ticketTime) || !ticket.modelId.trim()) continue;
+    const candidates: Array<{ asset: MatchableAsset; delta: number }> = [];
+    for (const asset of assets) {
+      if (used.has(asset.id)) continue;
+      if (asset.capability !== ticket.modelId) continue;
+      const created = Date.parse(asset.createdAt);
+      if (!Number.isFinite(created)) continue;
+      const delta = Math.abs(created - ticketTime);
+      if (delta > TICKET_ASSET_MATCH_WINDOW_MS) continue;
+      candidates.push({ asset, delta });
+    }
+    if (candidates.length !== 1) continue;
+    const hit = candidates[0]!;
+    used.add(hit.asset.id);
+    out.set(ticket.gatewayRequestId, outputFromAsset(hit.asset));
+  }
+
+  return out;
+}
diff --git a/lib/console/capability-modality.test.ts b/lib/console/capability-modality.test.ts
new file mode 100644
index 0000000..005df7a
--- /dev/null
+++ b/lib/console/capability-modality.test.ts
@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { FAL_CAPABILITY_CATALOG } from "../mcp/fal-capability-catalog";
+import { mapSignedTicketToActivityRow } from "./signed-ticket-activity";
+import {
+  outputKindForModality,
+  pipelineForModality,
+  resolveActivityCapability,
+  resolveCapabilityModality,
+} from "./capability-modality";
+
+test("first-party pipeline names map to modality tags", () => {
+  assert.equal(resolveCapabilityModality({ pipeline: "text-to-image" }), "t2i");
+  assert.equal(
+    resolveCapabilityModality({ pipeline: "image-to-video" }),
+    "i2v"
+  );
+  assert.equal(
+    resolveCapabilityModality({ pipeline: "live-video-to-video" }),
+    "v2v"
+  );
+  assert.equal(
+    resolveCapabilityModality({ pipeline: "text-generation" }),
+    "text"
+  );
+});
+
+test("price units are not treated as pipelines", () => {
+  assert.equal(resolveCapabilityModality({ pipeline: "fixed" }), null);
+  assert.equal(resolveCapabilityModality({ pipeline: "hour" }), null);
+});
+
+test("unresolved batch tickets stay unknown, not live video", () => {
+  const unresolved = resolveActivityCapability({ pipeline: "fixed" });
+  assert.equal(unresolved.modality, "unknown");
+  assert.equal(unresolved.pipeline, "unknown");
+  assert.equal(outputKindForModality("unknown"), "json");
+  assert.equal(
+    resolveActivityCapability({
+      pipeline: "fixed",
+      capabilityId: "livepeer-example/brand-new-batch-app",
+    }).modality,
+    "unknown"
+  );
+});
+
+test("persistent live jobs without a media modality are realtime", () => {
+  assert.equal(
+    resolveActivityCapability({
+      pipeline: "hour",
+      capabilityId: "livepeer-example/comfyui-stream",
+    }).modality,
+    "realtime"
+  );
+  assert.equal(resolveCapabilityModality({ pipeline: "live" }), "realtime");
+  assert.equal(
+    resolveActivityCapability({ pipeline: "hour" }).pipeline,
+    "live-video-to-video"
+  );
+  assert.equal(outputKindForModality("realtime"), "video");
+});
+
+test("live-runner app ids infer modality from fal endpoint metadata", () => {
+  assert.equal(
+    resolveCapabilityModality({
+      pipeline: "fixed",
+      capabilityId: "livepeer-example/fal-gpt-image-2",
+    }),
+    "t2i"
+  );
+  assert.equal(
+    resolveCapabilityModality({
+      pipeline: "fixed",
+      capabilityId: "livepeer-example/fal-gpt-image-2-edit",
+    }),
+    "edit"
+  );
+  assert.equal(
+    resolveCapabilityModality({
+      pipeline: "fixed",
+      capabilityId: "livepeer-example/fal-flux-3-i2v",
+    }),
+    "i2v"
+  );
+  assert.equal(
+    resolveCapabilityModality({
+      pipeline: "fixed",
+      capabilityId: "livepeer-example/fal-whisper-transcribe",
+    }),
+    "asr"
+  );
+  assert.equal(
+    resolveCapabilityModality({
+      pipeline: "fixed",
+      capabilityId: "livepeer-example/fal-gemini-tts",
+    }),
+    "tts"
+  );
+});
+
+test("inferred modality restores a first-party pipeline for previews", () => {
+  const resolved = resolveActivityCapability({
+    pipeline: "fixed",
+    capabilityId: "livepeer-example/fal-gpt-image-2",
+  });
+  assert.equal(resolved.modality, "t2i");
+  assert.equal(resolved.pipeline, "text-to-image");
+  assert.equal(pipelineForModality("t2i"), "text-to-image");
+  assert.equal(outputKindForModality("t2i"), "image");
+  assert.equal(outputKindForModality("i2v"), "video");
+  assert.equal(outputKindForModality("tts"), "audio");
+});
+
+test("every fal catalog app resolves to a modality", () => {
+  const missing = FAL_CAPABILITY_CATALOG.filter(
+    (entry) => resolveCapabilityModality({ capabilityId: entry.name }) == null
+  ).map((entry) => entry.name);
+  assert.deepEqual(missing, []);
+});
+
+test("signed-ticket rows with price-unit pipelines surface modality, not f", () => {
+  const row = mapSignedTicketToActivityRow({
+    time: "2026-09-04T22:17:00.000Z",
+    clientId: "app_test",
+    appName: "Livepeer Agent",
+    externalUserId: "eu_test",
+    gatewayRequestId: "1469f5d0",
+    pipeline: "fixed",
+    modelId: "livepeer-example/fal-gpt-image-2",
+    networkFeeUsdMicros: "1000",
+    eventId: "evt_1",
+  });
+  assert.equal(row.modality, "t2i");
+  assert.equal(row.pipeline, "text-to-image");
+  assert.equal(row.signerLabel, "Livepeer Agent");
+  assert.equal(row.costDisplay, "$0.0010");
+});
+
+test("signed-ticket rows without a media modality are realtime live jobs", () => {
+  const row = mapSignedTicketToActivityRow({
+    time: "2026-09-04T22:17:00.000Z",
+    clientId: "app_test",
+    appName: "Livepeer Agent",
+    externalUserId: "eu_test",
+    gatewayRequestId: "persist-1",
+    pipeline: "hour",
+    modelId: "livepeer-example/comfyui-stream",
+    networkFeeUsdMicros: "2500",
+    eventId: "evt_live",
+  });
+  assert.equal(row.modality, "realtime");
+  assert.equal(row.pipeline, "live-video-to-video");
+  assert.equal(row.kind, "live");
+  assert.equal(row.costDisplay, "$0.0025");
+});
diff --git a/lib/console/capability-modality.ts b/lib/console/capability-modality.ts
new file mode 100644
index 0000000..a8756e9
--- /dev/null
+++ b/lib/console/capability-modality.ts
@@ -0,0 +1,268 @@
+import { lookupFalCapability } from "../mcp/fal-capability-catalog";
+
+/**
+ * History used to treat OpenMeter `pipeline` as a first-party pipeline id
+ * (`text-to-image`, `live-video-to-video`, …) and abbreviate it to a modality
+ * tag (`t2i`). Live-runner tickets now write the *price unit* there (`fixed`,
+ * `hour`, `720p`), so the old first-letter fallback rendered "f".
+ *
+ * Capability metadata already carries the missing signal:
+ *   - first-party tickets still have a real pipeline name
+ *   - live-runner apps advertise a fal `endpoint_id` (and an app id whose
+ *     last tokens are i2v / t2v / tts / …)
+ *
+ * Pipeline names, when needed internally (preview kind, live vs batch),
+ * are derived from that modality rather than shown to the user.
+ */
+
+const PRICE_UNITS = new Set(["fixed", "hour", "720p", "seconds", "wei", "usd"]);
+
+const PIPELINE_TO_MODALITY: Record<string, string> = {
+  "audio-to-text": "asr",
+  "image-to-image": "edit",
+  "image-to-text": "text",
+  "image-to-video": "i2v",
+  language: "text",
+  live: "realtime",
+  llm: "text",
+  "live-transcoding": "v2v",
+  "live-video-to-video": "v2v",
+  "speech-to-text": "asr",
+  "text-generation": "text",
+  "text-to-audio": "audio",
+  "text-to-image": "t2i",
+  "text-to-speech": "tts",
+  "text-to-video": "t2v",
+  transcoding: "v2v",
+  "video-understanding": "text",
+  "video-to-video": "v2v",
+};
+
+/** Longest-first so `image-to-video` wins over a later `video` token. */
+const PHRASE_TO_MODALITY: Array<[RegExp, string]> = [
+  [/first-last-frame-to-video|keyframes-to-video/, "transition"],
+  [/reference-to-video|ref2v/, "ref2v"],
+  [/images?-to-video|\bi2v\b/, "i2v"],
+  [/text-to-video|\bt2v\b/, "t2v"],
+  [/audio-to-video|\ba2v\b/, "a2v"],
+  [/video-to-video|\bv2v\b/, "v2v"],
+  [/video-to-music|\bv2m\b|video-soundtrack/, "v2m"],
+  [/text-to-image|\bt2i\b/, "t2i"],
+  [/text-to-audio|\bt2a\b|\bsfx\b/, "audio"],
+  [/text-to-3d|\bt3d\b/, "t3d"],
+  [/image-to-3d|\bi3d\b/, "i3d"],
+  [/text-to-speech|\btts\b/, "tts"],
+  [/whisper|transcribe|\basr\b|subtitles/, "asr"],
+  [/bg-remove|background-removal|birefnet/, "bg-remove"],
+  [/video-upscale|scale-video|upscale/, "upscale"],
+  [/inpaint/, "inpaint"],
+  [/erase/, "erase"],
+  [/fill/, "fill"],
+  [/edit-video|\/edit\b|\bedit\b/, "edit"],
+  [/extend-video|\bextend\b/, "extend"],
+  [/lipsync|talking-head|omnihuman/, "i2v"],
+  [/\breframe\b/, "v2v"],
+  [/\bmusic\b/, "t2m"],
+  [/\bffmpeg\b/, "tool"],
+];
+
+const SLUG_TOKEN_TO_MODALITY: Record<string, string> = {
+  a2t: "asr",
+  a2v: "a2v",
+  asr: "asr",
+  i2i: "edit",
+  i2v: "i2v",
+  i3d: "i3d",
+  ref2v: "ref2v",
+  s2t: "asr",
+  t2a: "audio",
+  t2i: "t2i",
+  t2s: "tts",
+  t2t: "text",
+  t2v: "t2v",
+  t3d: "t3d",
+  tts: "tts",
+  v2m: "v2m",
+  v2t: "text",
+  v2v: "v2v",
+};
+
+const MODALITY_TO_PIPELINE: Record<string, string> = {
+  asr: "audio-to-text",
+  audio: "text-to-audio",
+  "bg-remove": "image-to-image",
+  edit: "image-to-image",
+  erase: "image-to-image",
+  extend: "video-to-video",
+  fill: "image-to-image",
+  i2v: "image-to-video",
+  inpaint: "image-to-image",
+  realtime: "live-video-to-video",
+  ref2v: "image-to-video",
+  t2i: "text-to-image",
+  t2m: "text-to-audio",
+  t2v: "text-to-video",
+  text: "text-generation",
+  transition: "image-to-video",
+  tts: "text-to-speech",
+  upscale: "image-to-image",
+  v2m: "text-to-audio",
+  v2v: "video-to-video",
+};
+
+const IMAGE_MODALITIES = new Set([
+  "bg-remove",
+  "edit",
+  "erase",
+  "fill",
+  "inpaint",
+  "t2i",
+  "upscale",
+  "vto",
+]);
+
+const VIDEO_MODALITIES = new Set([
+  "a2v",
+  "extend",
+  "hdr",
+  "i2v",
+  "ingredient",
+  "realtime",
+  "ref2v",
+  "t2v",
+  "transition",
+  "v2v",
+]);
+
+const AUDIO_MODALITIES = new Set(["audio", "t2m", "tts", "v2m"]);
+
+const TEXT_MODALITIES = new Set(["asr", "text"]);
+
+export type CapabilityMediaKind = "image" | "video" | "audio" | "text" | "json";
+
+function normalize(value: string | null | undefined): string {
+  return (value ?? "").trim().toLowerCase();
+}
+
+function isPriceUnit(value: string): boolean {
+  return PRICE_UNITS.has(value);
+}
+
+function isKnownPipeline(value: string): boolean {
+  return value in PIPELINE_TO_MODALITY;
+}
+
+function lookupCatalog(capabilityId: string) {
+  const direct = lookupFalCapability(capabilityId);
+  if (direct) return direct;
+
+  const slug = normalize(capabilityId);
+  const tail = slug.split("/").pop() ?? slug;
+  const prefixed = lookupFalCapability(`livepeer-example/${tail}`);
+  if (prefixed) return prefixed;
+  if (!tail.startsWith("fal-")) {
+    return lookupFalCapability(`livepeer-example/fal-${tail}`);
+  }
+  return null;
+}
+
+function modalityFromHaystack(haystack: string): string | null {
+  const normalized = `/${haystack.replace(/[_./]+/g, "-")}/`;
+  for (const [pattern, modality] of PHRASE_TO_MODALITY) {
+    if (pattern.test(normalized)) return modality;
+  }
+
+  for (const token of haystack.split(/[-_/]+/)) {
+    const mapped = SLUG_TOKEN_TO_MODALITY[token];
+    if (mapped) return mapped;
+  }
+
+  if (/\bimage\b/.test(normalized) && !/\bvideo\b/.test(normalized)) {
+    return "t2i";
+  }
+  if (/\b(flux|ideogram)\b/.test(normalized) && !/\bvideo\b/.test(normalized)) {
+    return "t2i";
+  }
+  if (/\bvideo\b/.test(normalized)) return "t2v";
+  return null;
+}
+
+export function resolveCapabilityModality(input: {
+  pipeline?: string | null;
+  capabilityId?: string | null;
+}): string | null {
+  const pipeline = normalize(input.pipeline);
+  if (pipeline && isKnownPipeline(pipeline)) {
+    return PIPELINE_TO_MODALITY[pipeline] ?? null;
+  }
+
+  const capabilityId = (input.capabilityId ?? "").trim();
+  const catalog = capabilityId ? lookupCatalog(capabilityId) : null;
+  const haystack = [
+    capabilityId,
+    catalog?.name,
+    catalog?.label,
+    catalog?.endpointId,
+  ]
+    .filter(Boolean)
+    .join("/");
+  const fromMeta = haystack ? modalityFromHaystack(haystack) : null;
+  if (fromMeta) return fromMeta;
+
+  if (pipeline && !isPriceUnit(pipeline)) {
+    const fromPipeline = modalityFromHaystack(pipeline);
+    if (fromPipeline) return fromPipeline;
+  }
+
+  return null;
+}
+
+export function pipelineForModality(modality: string): string | null {
+  return MODALITY_TO_PIPELINE[modality] ?? null;
+}
+
+export function outputKindForModality(modality: string): CapabilityMediaKind {
+  if (IMAGE_MODALITIES.has(modality)) return "image";
+  if (VIDEO_MODALITIES.has(modality)) return "video";
+  if (AUDIO_MODALITIES.has(modality)) return "audio";
+  if (TEXT_MODALITIES.has(modality)) return "text";
+  return "json";
+}
+
+/**
+ * Resolve the display tag and, when the stored pipeline is a price unit,
+ * the inferred first-party pipeline name used by previews.
+ *
+ * Persistent live jobs bill as `hour` (or are named `live`) and have no fal
+ * media modality — those are `realtime`. Unknown *batch* tickets (`fixed`
+ * with no catalog hit) stay `unknown` so they are not shown as live video.
+ */
+export function resolveActivityCapability(input: {
+  pipeline?: string | null;
+  capabilityId?: string | null;
+}): { modality: string; pipeline: string } {
+  const stored = (input.pipeline ?? "").trim();
+  const normalizedStored = normalize(stored);
+  const resolved = resolveCapabilityModality(input);
+  if (resolved) {
+    const inferred = pipelineForModality(resolved);
+    const pipeline =
+      stored && !isPriceUnit(normalizedStored)
+        ? stored
+        : (inferred ?? stored);
+    return { modality: resolved, pipeline: pipeline || "unknown" };
+  }
+
+  if (normalizedStored === "hour" || normalizedStored === "live") {
+    return {
+      modality: "realtime",
+      pipeline: pipelineForModality("realtime") ?? "live-video-to-video",
+    };
+  }
+
+  return {
+    modality: "unknown",
+    pipeline:
+      stored && !isPriceUnit(normalizedStored) ? stored : "unknown",
+  };
+}
diff --git a/lib/console/dev-mock.ts b/lib/console/dev-mock.ts
index ffbdcc9..cc9b268 100644
--- a/lib/console/dev-mock.ts
+++ b/lib/console/dev-mock.ts
@@ -101,6 +101,20 @@ const CAPABILITIES: Array<{
     unit: 0.004,
     trend: 1.0,
   },
+  {
+    pipeline: "fixed",
+    modelId: "livepeer-example/fal-gpt-image-2",
+    base: 160,
+    unit: 0.004,
+    trend: 1.2,
+  },
+  {
+    pipeline: "hour",
+    modelId: "livepeer-example/comfyui-stream",
+    base: 40,
+    unit: 0.012,
+    trend: 0.9,
+  },
   {
     pipeline: "image-to-video",
     modelId: "stable-video-diffusion",
@@ -225,7 +239,8 @@ function buildUsage(
 }
 
 function devRedirect(path: string | null, requestUrl: string): Response {
-  const safePath = path?.startsWith("/") && !path.startsWith("//") ? path : "/home";
+  const safePath =
+    path?.startsWith("/") && !path.startsWith("//") ? path : "/home";
   const baseUrl = process.env.APP_BASE_URL || requestUrl;
 
   return new Response(null, {
@@ -275,7 +290,10 @@ function buildWallet() {
         },
         // builder-sdk 0.6.x omits this from BillingState; the API sends it.
         includedUsage: {
-          total: { usdMicros: usd(INCLUDED_TOTAL_USD), usd: INCLUDED_TOTAL_USD.toFixed(2) },
+          total: {
+            usdMicros: usd(INCLUDED_TOTAL_USD),
+            usd: INCLUDED_TOTAL_USD.toFixed(2),
+          },
           remaining: { usdMicros: usd(remaining), usd: remaining.toFixed(2) },
           consumed: { usdMicros: usd(consumed), usd: consumed.toFixed(2) },
           resetsAt: resetsAt.toISOString(),
@@ -410,7 +428,9 @@ function buildInvoices() {
  */
 function buildRequests(limit: number, cursor: string | null) {
   const offset = cursor ? Number.parseInt(cursor, 10) || 0 : 0;
-  const TOTAL = 180;
+  // 7 days at one call every 30 minutes — enough pages to exercise loadMore.
+  const STEP_MINUTES = 30;
+  const TOTAL = Math.ceil((7 * 24 * 60) / STEP_MINUTES);
   const rand = seeded(0x5ca11 + offset);
 
   // Pick capabilities in proportion to their daily volume.
@@ -429,8 +449,8 @@ function buildRequests(limit: number, cursor: string | null) {
   const items = Array.from({ length: Math.max(0, count) }, (_, i) => {
     const index = offset + i;
     const cap = pick();
-    // Roughly one call every few minutes, walking backwards from now.
-    const minutesAgo = index * 4 + Math.floor(rand() * 4);
+    // Walk backwards from now across the 7-day history window.
+    const minutesAgo = index * STEP_MINUTES + Math.floor(rand() * 8);
     const fee = Math.round(cap.unit * (0.7 + rand() * 0.6) * 1_000_000);
     return {
       time: new Date(Date.now() - minutesAgo * 60_000).toISOString(),
diff --git a/lib/console/history-window.test.ts b/lib/console/history-window.test.ts
new file mode 100644
index 0000000..424dbe8
--- /dev/null
+++ b/lib/console/history-window.test.ts
@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  clipHistoryPage,
+  HISTORY_LOOKBACK_MS,
+  historyWindow,
+} from "./history-window";
+
+test("historyWindow spans seven days", () => {
+  const now = new Date("2026-09-05T12:00:00.000Z");
+  const window = historyWindow(now);
+  assert.equal(window.to, now.toISOString());
+  assert.equal(
+    Date.parse(window.to) - Date.parse(window.from),
+    HISTORY_LOOKBACK_MS
+  );
+});
+
+test("clipHistoryPage stops paging once rows fall outside the window", () => {
+  const now = new Date("2026-09-05T12:00:00.000Z");
+  const clipped = clipHistoryPage(
+    [
+      { time: "2026-09-05T11:00:00.000Z" },
+      { time: "2026-08-20T11:00:00.000Z" },
+    ],
+    "next",
+    now
+  );
+  assert.equal(clipped.items.length, 1);
+  assert.equal(clipped.nextCursor, null);
+});
diff --git a/lib/console/history-window.ts b/lib/console/history-window.ts
new file mode 100644
index 0000000..c92c2a1
--- /dev/null
+++ b/lib/console/history-window.ts
@@ -0,0 +1,35 @@
+/** Console history is a rolling 7-day window, paged in chunks — not a row cap. */
+export const HISTORY_LOOKBACK_DAYS = 7;
+export const HISTORY_LOOKBACK_MS = HISTORY_LOOKBACK_DAYS * 24 * 60 * 60 * 1000;
+
+export function historyWindow(now = new Date()): { from: string; to: string } {
+  return {
+    from: new Date(now.getTime() - HISTORY_LOOKBACK_MS).toISOString(),
+    to: now.toISOString(),
+  };
+}
+
+export function isWithinHistoryWindow(
+  iso: string,
+  now = new Date()
+): boolean {
+  const time = Date.parse(iso);
+  if (!Number.isFinite(time)) return false;
+  return (
+    time >= now.getTime() - HISTORY_LOOKBACK_MS &&
+    time <= now.getTime() + 60_000
+  );
+}
+
+/** Drop rows older than 7 days and stop paging once a page walks past the window. */
+export function clipHistoryPage<T extends { time: string }>(
+  items: T[],
+  nextCursor: string | null,
+  now = new Date()
+): { items: T[]; nextCursor: string | null } {
+  const kept = items.filter((item) => isWithinHistoryWindow(item.time, now));
+  return {
+    items: kept,
+    nextCursor: kept.length < items.length ? null : nextCursor,
+  };
+}
diff --git a/lib/console/mock-data.ts b/lib/console/mock-data.ts
index c3cbfcc..fe59f29 100644
--- a/lib/console/mock-data.ts
+++ b/lib/console/mock-data.ts
@@ -26,6 +26,7 @@ import type {
   UsageSummary,
   RoutingSummary,
 } from "./types";
+import { resolveActivityCapability } from "./capability-modality";
 
 // ─── Environments ─────────────────────────────────────────────────────────────
 //
@@ -3152,6 +3153,10 @@ function generateRecentRequests(): import("./types").AccountActivityRow[] {
       timestamp: new Date(now - s.minutesAgo * 60_000).toISOString(),
       model: s.model,
       pipeline: s.pipeline,
+      modality: resolveActivityCapability({
+        pipeline: s.pipeline,
+        capabilityId: s.model,
+      }).modality,
       status: s.status,
       kind,
       latencyMs: s.latencyMs,
diff --git a/lib/console/pymthouse-bff.ts b/lib/console/pymthouse-bff.ts
index fad51a4..68a4f75 100644
--- a/lib/console/pymthouse-bff.ts
+++ b/lib/console/pymthouse-bff.ts
@@ -20,12 +20,16 @@ import {
   dailyRequestSeriesForPipeline,
   utcDateKeysForPeriod,
 } from "@/lib/console/usage-capability-display";
+import {
+  clipHistoryPage,
+  historyWindow,
+} from "@/lib/console/history-window";
+import { isUserNotFoundError } from "@/lib/console/pymthouse-errors";
 
 export type {
   AccountRequestsPayload,
   AccountUsagePayload,
 } from "@/lib/console/account-usage";
-import { isUserNotFoundError } from "@/lib/console/pymthouse-errors";
 
 export { isUserNotFoundError } from "@/lib/console/pymthouse-errors";
 
@@ -262,6 +266,9 @@ export async function fetchAccountRequestsForExternalUser(input: {
   const accessToken = minted.access_token;
 
   const url = new URL(`${issuerOriginFromConfig()}/api/v1/user/usage/requests`);
+  const window = historyWindow();
+  url.searchParams.set("from", window.from);
+  url.searchParams.set("to", window.to);
   if (input.cursor) url.searchParams.set("cursor", input.cursor);
   if (input.limit != null) url.searchParams.set("limit", String(input.limit));
 
@@ -299,9 +306,13 @@ export async function fetchAccountRequestsForExternalUser(input: {
     );
   }
 
+  const clipped = clipHistoryPage(
+    body?.items ?? [],
+    body?.nextCursor ?? null
+  );
   return {
-    items: body?.items ?? [],
-    nextCursor: body?.nextCursor ?? null,
+    items: clipped.items,
+    nextCursor: clipped.nextCursor,
     openMeterConfigured: body?.openMeterConfigured !== false,
     clientId: body?.clientId ?? publicClientId,
     externalUserId: body?.externalUserId ?? input.externalUserId,
diff --git a/lib/console/request-fee-display.test.ts b/lib/console/request-fee-display.test.ts
new file mode 100644
index 0000000..c22324a
--- /dev/null
+++ b/lib/console/request-fee-display.test.ts
@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  formatExactUsdMicrosString,
+  formatUsdFromWei,
+  requestFeeDisplay,
+} from "./request-fee-display";
+
+test("formatExactUsdMicrosString matches PymtHouse ingest micros", () => {
+  assert.equal(formatExactUsdMicrosString("0.932"), "$0.000000932");
+  assert.equal(formatExactUsdMicrosString("932"), "$0.000932");
+  assert.equal(formatExactUsdMicrosString("1000"), "$0.001");
+  assert.equal(formatExactUsdMicrosString("15"), "< $0.0001");
+  assert.equal(formatExactUsdMicrosString("0"), null);
+  assert.equal(formatExactUsdMicrosString("0.0"), null);
+});
+
+test("formatUsdFromWei renders full sub-micro ticket valuation", () => {
+  const label = formatUsdFromWei("131568070", "1897.485");
+  assert.ok(label);
+  assert.ok(label.startsWith("$0.000000"));
+  assert.equal(formatUsdFromWei("0", "1897.485"), null);
+});
+
+test("requestFeeDisplay rounds history prices to four decimal places", () => {
+  assert.deepEqual(requestFeeDisplay({ networkFeeUsdMicros: "10011.632431" }), {
+    display: "$0.0100",
+    exact: "$0.010011632431",
+  });
+  assert.deepEqual(requestFeeDisplay({ networkFeeUsdMicros: "9940" }), {
+    display: "$0.0099",
+    exact: "$0.00994",
+  });
+  assert.deepEqual(requestFeeDisplay({ networkFeeUsdMicros: "0.932" }), {
+    display: "<$0.0001",
+    exact: "$0.000000932",
+  });
+  assert.deepEqual(requestFeeDisplay({ networkFeeUsdMicros: "0" }), {
+    display: "$0",
+    exact: "$0",
+  });
+});
diff --git a/lib/console/request-fee-display.ts b/lib/console/request-fee-display.ts
new file mode 100644
index 0000000..32a2e2b
--- /dev/null
+++ b/lib/console/request-fee-display.ts
@@ -0,0 +1,187 @@
+/**
+ * Per-request cost from PymtHouse signed-ticket history
+ * (`GET /api/v1/user/usage/requests`). Matches PymtHouse
+ * `requestFeeLabel`: Wei × ETH/USD first, then exact ingest micros
+ * (which may be fractional, e.g. `"0.932"`).
+ */
+
+const USD_MICROS_PER_DOLLAR = BigInt(1_000_000);
+const USD_MICROS_DISPLAY_FLOOR = BigInt(100);
+
+export type RequestFeeFields = {
+  networkFeeUsdMicros: string;
+  feeWei?: string;
+  ethUsdPrice?: string;
+};
+
+function isIntegerMicrosString(value: string): boolean {
+  if (value.length === 0) return false;
+  let i = 0;
+  if (value.startsWith("-")) {
+    if (value.length === 1) return false;
+    i = 1;
+  }
+  for (; i < value.length; i++) {
+    const code = value.codePointAt(i);
+    if (code == null || code < 48 || code > 57) return false;
+  }
+  return true;
+}
+
+function trimFracDigitZeros(fracDigits: string): string {
+  let end = fracDigits.length;
+  while (end > 0 && fracDigits[end - 1] === "0") end -= 1;
+  return fracDigits.slice(0, end);
+}
+
+function parseUsdMicrosString(raw: string | null | undefined): bigint | null {
+  if (raw == null) return null;
+  const t = raw.trim();
+  if (!isIntegerMicrosString(t)) return null;
+  try {
+    return BigInt(t);
+  } catch {
+    return null;
+  }
+}
+
+function formatUsdMicrosString(
+  microsStr: string | undefined | null
+): string | null {
+  if (microsStr == null || microsStr === "") return null;
+  const amount = parseUsdMicrosString(microsStr);
+  if (amount == null) return null;
+  const negative = amount < BigInt(0);
+  const abs = negative ? -amount : amount;
+  if (abs === BigInt(0)) return null;
+  if (abs < USD_MICROS_DISPLAY_FLOOR) {
+    return negative ? "> -$0.0001" : "< $0.0001";
+  }
+  const whole = abs / USD_MICROS_PER_DOLLAR;
+  const frac = abs % USD_MICROS_PER_DOLLAR;
+  const fracStr = trimFracDigitZeros(frac.toString().padStart(6, "0"));
+  const sign = negative ? "-" : "";
+  if (fracStr.length === 0) {
+    return `${sign}$${whole.toString()}`;
+  }
+  return `${sign}$${whole.toString()}.${fracStr}`;
+}
+
+function formatDollarParts(whole: bigint, fracDigits: string): string {
+  const frac = trimFracDigitZeros(
+    fracDigits.length > 12 ? fracDigits.slice(0, 12) : fracDigits
+  );
+  if (frac.length === 0) {
+    return `$${whole.toString()}`;
+  }
+  return `$${whole.toString()}.${frac}`;
+}
+
+function parseWeiString(raw: string): bigint | null {
+  const t = raw.trim();
+  if (!t) return null;
+  if (/^\d+$/.test(t)) {
+    try {
+      const wei = BigInt(t);
+      return wei > BigInt(0) ? wei : null;
+    } catch {
+      return null;
+    }
+  }
+  if (/^\d+\.0+$/.test(t)) {
+    try {
+      const wei = BigInt(t.slice(0, t.indexOf(".")));
+      return wei > BigInt(0) ? wei : null;
+    } catch {
+      return null;
+    }
+  }
+  if (!/^\d+(\.\d+)?([eE][+-]?\d+)?$/.test(t)) return null;
+  const asNumber = Number(t);
+  if (!Number.isFinite(asNumber) || asNumber <= 0) return null;
+  if (asNumber > Number.MAX_SAFE_INTEGER) return null;
+  const wei = BigInt(Math.trunc(asNumber));
+  return wei > BigInt(0) ? wei : null;
+}
+
+/** usd = fee_wei * eth_usd / 1e18 */
+export function formatUsdFromWei(
+  feeWei: string | null | undefined,
+  ethUsdPrice: string | null | undefined
+): string | null {
+  if (feeWei == null || ethUsdPrice == null) return null;
+  const priceTrim = ethUsdPrice.trim();
+  if (!priceTrim) return null;
+  const price = Number(priceTrim);
+  if (!Number.isFinite(price) || price <= 0) return null;
+  try {
+    const wei = parseWeiString(feeWei);
+    if (wei == null) return null;
+    const ethUsdMicros = BigInt(Math.floor(price * 1_000_000));
+    const product = wei * ethUsdMicros;
+    const dollarDiv = BigInt(10) ** BigInt(24);
+    const dollarWhole = product / dollarDiv;
+    const dollarRem = product % dollarDiv;
+    if (dollarWhole === BigInt(0) && dollarRem === BigInt(0)) return null;
+    return formatDollarParts(
+      dollarWhole,
+      dollarRem.toString().padStart(24, "0")
+    );
+  } catch {
+    return null;
+  }
+}
+
+export function formatExactUsdMicrosString(
+  microsStr: string | null | undefined
+): string | null {
+  if (microsStr == null || microsStr === "") return null;
+  const t = microsStr.trim();
+  if (isIntegerMicrosString(t)) {
+    return formatUsdMicrosString(t);
+  }
+  if (!/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(t)) return null;
+  const micros = Number(t);
+  if (!Number.isFinite(micros) || micros === 0) return null;
+  const negative = micros < 0;
+  const dollars = Math.abs(micros) / 1_000_000;
+  let fixed = dollars.toFixed(12);
+  if (fixed.includes(".")) {
+    const [whole, frac = ""] = fixed.split(".");
+    const trimmedFrac = trimFracDigitZeros(frac);
+    fixed = trimmedFrac ? `${whole}.${trimmedFrac}` : whole;
+  }
+  if (fixed === "0") return null;
+  return `${negative ? "-" : ""}$${fixed}`;
+}
+
+/** History cells: four fraction digits (`$0.0100`). */
+const HISTORY_USD_DIGITS = 4;
+
+function roundUsdLabel(label: string): string {
+  if (label === "$0" || label.startsWith("<") || label.startsWith(">")) {
+    return label;
+  }
+  const negative = label.startsWith("-");
+  const body = label.replace(/^-?\$/, "");
+  const n = Number(body);
+  if (!Number.isFinite(n)) return label;
+  const rounded = n.toFixed(HISTORY_USD_DIGITS);
+  if (Number(rounded) === 0) {
+    return negative ? "> -$0.0001" : "<$0.0001";
+  }
+  return `${negative ? "-" : ""}$${rounded}`;
+}
+
+function exactFeeLabel(row: RequestFeeFields): string {
+  const fromWei = formatUsdFromWei(row.feeWei, row.ethUsdPrice);
+  return fromWei ?? formatExactUsdMicrosString(row.networkFeeUsdMicros) ?? "$0";
+}
+
+export function requestFeeDisplay(row: RequestFeeFields): {
+  display: string;
+  exact: string;
+} {
+  const exact = exactFeeLabel(row);
+  return { display: roundUsdLabel(exact), exact };
+}
diff --git a/lib/console/signed-ticket-activity.ts b/lib/console/signed-ticket-activity.ts
index 25c443a..c5111f9 100644
--- a/lib/console/signed-ticket-activity.ts
+++ b/lib/console/signed-ticket-activity.ts
@@ -1,9 +1,8 @@
 import type { AccountActivityRow, PipelineKind } from "@/lib/console/types";
 import type { SignedTicketRequestRow } from "@/lib/console/account-usage";
-import {
-  humanizePipelineModel,
-  microsToUsdDisplay,
-} from "@/lib/console/usage-capability-display";
+import { resolveActivityCapability } from "@/lib/console/capability-modality";
+import { requestFeeDisplay } from "@/lib/console/request-fee-display";
+import { humanizePipelineModel } from "@/lib/console/usage-capability-display";
 
 const LIVE_PIPELINES = new Set([
   "video-to-video",
@@ -11,24 +10,31 @@ const LIVE_PIPELINES = new Set([
   "live-transcoding",
 ]);
 
-function inferKind(pipeline: string): PipelineKind {
-  return LIVE_PIPELINES.has(pipeline) ? "live" : "batch";
+function inferKind(pipeline: string, modality: string): PipelineKind {
+  return LIVE_PIPELINES.has(pipeline) || modality === "realtime"
+    ? "live"
+    : "batch";
 }
 
 /** Map PymtHouse signed-ticket rows into the /calls table shape. */
 export function mapSignedTicketToActivityRow(
   row: SignedTicketRequestRow
 ): AccountActivityRow {
-  const kind = inferKind(row.pipeline);
-  const model = humanizePipelineModel(row.pipeline, row.modelId);
-  const fee = microsToUsdDisplay(row.networkFeeUsdMicros || "0");
+  const { modality, pipeline } = resolveActivityCapability({
+    pipeline: row.pipeline,
+    capabilityId: row.modelId,
+  });
+  const kind = inferKind(pipeline, modality);
+  const model = humanizePipelineModel(pipeline, row.modelId);
+  const { display, exact } = requestFeeDisplay(row);
 
   return {
     id: row.gatewayRequestId || row.eventId,
     environmentId: "env-production",
     timestamp: row.time,
     model,
-    pipeline: row.pipeline,
+    pipeline,
+    modality,
     status: "success",
     kind,
     latencyMs: null,
@@ -37,6 +43,9 @@ export function mapSignedTicketToActivityRow(
     signerLabel: row.appName?.trim() || "PymtHouse",
     tokenId: "",
     tokenName: "",
-    costDisplay: fee,
+    costDisplay: display,
+    costExact: exact,
+    outputUrl: row.outputUrl?.trim() || undefined,
+    providerRequestId: row.providerRequestId?.trim() || undefined,
   };
 }
diff --git a/lib/console/types.ts b/lib/console/types.ts
index 4d9694c..002e47b 100644
--- a/lib/console/types.ts
+++ b/lib/console/types.ts
@@ -411,6 +411,8 @@ export interface AccountActivityRow {
   timestamp: string;
   model: string;
   pipeline: string;
+  /** Capability modality (`t2i`, `i2v`, `realtime`, …). Displayed instead of pipeline. */
+  modality: string;
   status: AccountActivityStatus;
   /** Invocation shape: a batch request/response, or a live streaming session. */
   kind: PipelineKind;
@@ -424,6 +426,12 @@ export interface AccountActivityRow {
   tokenName: string;
   /** Pre-formatted cost string, "—" when failed. */
   costDisplay: string;
+  /** Full-precision cost for hover. */
+  costExact?: string;
+  /** Neon asset URL joined from OpenMeter `gatewayRequestId`. */
+  outputUrl?: string;
+  /** Upstream provider request id when the asset store has one. */
+  providerRequestId?: string;
 }
 
 // ─── Stats: Overview ─────────────────────────────────────────────────────────
diff --git a/lib/console/usage-capability-display.ts b/lib/console/usage-capability-display.ts
index af868d0..01c8ab6 100644
--- a/lib/console/usage-capability-display.ts
+++ b/lib/console/usage-capability-display.ts
@@ -177,12 +177,6 @@ export function buildUsageCapabilityRows(input: {
     .sort((a, b) => b.requestCount - a.requestCount);
 }
 
-export function microsToUsdDisplay(micros: string): string {
-  const usd = microsToUsd(micros);
-  if (usd < 0.01) return "<$0.01";
-  return `$${usd.toFixed(2)}`;
-}
-
 export function formatPeriodResetLabel(periodEndIso: string): string {
   try {
     const end = new Date(periodEndIso);
diff --git a/lib/mcp/jwt.ts b/lib/mcp/jwt.ts
index 012d63c..1362c72 100644
--- a/lib/mcp/jwt.ts
+++ b/lib/mcp/jwt.ts
@@ -1,5 +1,6 @@
 import * as jose from "jose";
 import { pymthouseIssuerUrl, pymthouseJwksUrl } from "./env";
+import { resolveMcpExternalUserId } from "./principal";
 
 const jwks = jose.createRemoteJWKSet(new URL(pymthouseJwksUrl()));
 
@@ -45,7 +46,10 @@ export async function verifyMcpUserJwt(token: string): Promise<McpPrincipal> {
   const publicClientId =
     asString(payload.client_id) || asString(payload.azp) || "";
 
-  const externalUserId = asString(payload.external_user_id) || sub;
+  const externalUserId = await resolveMcpExternalUserId(
+    sub,
+    asString(payload.external_user_id)
+  );
 
   return {
     sub,
diff --git a/lib/mcp/log.ts b/lib/mcp/log.ts
index 835a9c3..deade5e 100644
--- a/lib/mcp/log.ts
+++ b/lib/mcp/log.ts
@@ -1,4 +1,4 @@
-import type { McpPrincipal } from "./jwt";
+export { principalId } from "./principal";
 
 export function logToolCall(input: {
   tool: string;
@@ -37,7 +37,3 @@ export function clientClassFromHeaders(req: Request): string {
   if (ua.includes("chatgpt")) return "chatgpt";
   return "unknown";
 }
-
-export function principalId(principal: McpPrincipal): string {
-  return principal.externalUserId || principal.sub;
-}
diff --git a/lib/mcp/principal.test.ts b/lib/mcp/principal.test.ts
new file mode 100644
index 0000000..eb78d33
--- /dev/null
+++ b/lib/mcp/principal.test.ts
@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { externalUserIdFromSub } from "@/lib/console/external-user-id";
+import { resolveMcpExternalUserId } from "./principal";
+
+test("claimed external_user_id wins", async () => {
+  assert.equal(
+    await resolveMcpExternalUserId("auth0|abc", "eu_from_token"),
+    "eu_from_token"
+  );
+});
+
+test("Auth0 sub is hashed the same way as console sessions", async () => {
+  const sub = "github|12345";
+  assert.equal(
+    await resolveMcpExternalUserId(sub),
+    await externalUserIdFromSub(sub)
+  );
+});
+
+test("already-namespaced ids are kept", async () => {
+  assert.equal(await resolveMcpExternalUserId("eu_abc123"), "eu_abc123");
+});
diff --git a/lib/mcp/principal.ts b/lib/mcp/principal.ts
new file mode 100644
index 0000000..f41a2c5
--- /dev/null
+++ b/lib/mcp/principal.ts
@@ -0,0 +1,29 @@
+import { externalUserIdFromSub } from "@/lib/console/external-user-id";
+
+/**
+ * Console sessions always hash Auth0 `sub` to `eu_<sha256>`. MCP tokens that
+ * omit `external_user_id` used to fall back to the raw `sub`, so assets and
+ * history lived in different namespaces for the same person.
+ */
+export async function resolveMcpExternalUserId(
+  sub: string,
+  claimed?: string | null
+): Promise<string> {
+  const fromToken = claimed?.trim();
+  if (fromToken) return fromToken;
+  const raw = sub.trim();
+  if (!raw) {
+    throw new Error("token is missing sub");
+  }
+  if (raw.includes("|") || raw.includes("/")) {
+    return externalUserIdFromSub(raw);
+  }
+  return raw;
+}
+
+export function principalId(principal: {
+  externalUserId: string;
+  sub: string;
+}): string {
+  return principal.externalUserId || principal.sub;
+}
diff --git a/lib/mcp/run-capability.test.ts b/lib/mcp/run-capability.test.ts
index 608b9c7..b3dc69d 100644
--- a/lib/mcp/run-capability.test.ts
+++ b/lib/mcp/run-capability.test.ts
@@ -69,4 +69,15 @@ test("runCapabilityFailurePayload prefers the id stamped on the thrown error", (
   });
   const payload = runCapabilityFailurePayload(err, "job_minted1");
   assert.equal(payload.gateway_request_id, "job_from_sdk");
+  assert.equal(payload.request_id, undefined);
+});
+
+test("runCapabilityFailurePayload forwards provider request id from #26 errors", () => {
+  const err = Object.assign(new Error("runner 500"), {
+    gatewayRequestId: "job_from_sdk",
+    providerRequestId: "req-fal-abc",
+  });
+  const payload = runCapabilityFailurePayload(err, "job_minted1");
+  assert.equal(payload.gateway_request_id, "job_from_sdk");
+  assert.equal(payload.request_id, "req-fal-abc");
 });
diff --git a/lib/mcp/run-capability.ts b/lib/mcp/run-capability.ts
index 594654b..7ad35c8 100644
--- a/lib/mcp/run-capability.ts
+++ b/lib/mcp/run-capability.ts
@@ -33,20 +33,26 @@ export function validateRunCapabilityEndpoint(
   return null;
 }
 
-function requestIdFromError(err: unknown): string {
-  if (!err || typeof err !== "object" || !("gatewayRequestId" in err)) {
+function stringField(err: unknown, key: string): string {
+  if (!err || typeof err !== "object" || !(key in err)) {
     return "";
   }
-  const id = (err as { gatewayRequestId?: unknown }).gatewayRequestId;
-  return typeof id === "string" ? id.trim() : "";
+  const value = (err as Record<string, unknown>)[key];
+  return typeof value === "string" ? value.trim() : "";
 }
 
 export function runCapabilityFailurePayload(
   err: unknown,
   mintedId: string
-): { error: string; gateway_request_id: string } {
+): {
+  error: string;
+  gateway_request_id: string;
+  request_id?: string;
+} {
+  const providerRequestId = stringField(err, "providerRequestId");
   return {
     error: err instanceof Error ? err.message : String(err),
-    gateway_request_id: requestIdFromError(err) || mintedId,
+    gateway_request_id: stringField(err, "gatewayRequestId") || mintedId,
+    ...(providerRequestId ? { request_id: providerRequestId } : {}),
   };
 }