@agent-native/core 0.79.12 → 0.79.15

package/corpus/templates/clips/chrome-extension/src/background.ts

@@ -146,6 +146,10 @@ type NativeRecording = {
   status: NativeRecordingStatus;
   recordingUrl: string;
   error: string | null;
+  // When an upload fails, the recording is saved to the user's Downloads as a
+  // fallback so it is never lost; these describe that saved file.
+  savedToDisk?: boolean;
+  savedFilename?: string;
 };
 
 type OffscreenStatusMessage = {
@@ -156,6 +160,8 @@ type OffscreenStatusMessage = {
   result?: Record<string, unknown>;
   error?: string;
   storageSetupRequired?: boolean;
+  savedToDisk?: boolean;
+  savedFilename?: string;
 };
 
 type ExtensionErrorMessage = {
@@ -2032,6 +2038,36 @@ async function dispatchRuntimeMessage(message: unknown): Promise<unknown> {
     return { ok: true };
   }
 
+  // The offscreen recorder asks us to save a recording to disk when its upload
+  // fails (storage not connected, network drop, size cap), so the recording is
+  // never lost. The offscreen document holds the blob URL alive until its next
+  // acquire(); we only need the download to be accepted, not fully written.
+  if (type === "CLIPS_SAVE_RECORDING_TO_DISK") {
+    const { url, filename } = message as { url?: string; filename?: string };
+    if (typeof url !== "string" || !url) {
+      return { ok: false, error: "Missing recording URL." };
+    }
+    try {
+      const options: chrome.downloads.DownloadOptions = {
+        url,
+        saveAs: false,
+        conflictAction: "uniquify",
+      };
+      if (typeof filename === "string" && filename) options.filename = filename;
+      const downloadId = await chrome.downloads.download(options);
+      return { ok: typeof downloadId === "number" && downloadId >= 0 };
+    } catch (err) {
+      console.error("[clips-bg] save-to-disk download failed", err);
+      captureExtensionError(err, {
+        tags: { surface: "background", messageType: type },
+      });
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : "Download failed.",
+      };
+    }
+  }
+
   // Status updates streamed from the offscreen recorder.
   if (type === "CLIPS_NATIVE_STATUS") {
     const status = message as OffscreenStatusMessage;
@@ -2060,6 +2096,13 @@ async function dispatchRuntimeMessage(message: unknown): Promise<unknown> {
           activeNativeRecording,
         );
       }
+      if (status.status === "error") {
+        activeNativeRecording.savedToDisk = status.savedToDisk === true;
+        activeNativeRecording.savedFilename =
+          typeof status.savedFilename === "string"
+            ? status.savedFilename
+            : undefined;
+      }
       await saveActiveNativeRecording();
       // The offscreen recorder finished its pre-roll and actually started —
       // advance from countdown to recording (the reliable phase flip).

package/corpus/templates/clips/chrome-extension/src/offscreen.ts

@@ -18,6 +18,7 @@
 
 import { scheduleReadyChime } from "@shared/recording-audio";
 import { chunkUploadUrl, pickMimeType } from "@shared/recording-core";
+import { MAX_UPLOAD_BYTES } from "@shared/upload-limits";
 
 import { captureExtensionError, initExtensionSentry } from "./sentry";
 
@@ -110,6 +111,15 @@ type ActiveRecording = {
   chunkIndex: number;
   uploadPromises: Promise<unknown>[];
   uploadFailure: Error | null;
+  // Local safety buffer: every recorded blob is kept here (browser-managed,
+  // disk-backed Blob refs — not raw heap) so that if the upload fails (storage
+  // not connected, network drop, size cap) we can still save the finished
+  // recording to disk instead of losing it. Mirrors the web/desktop recorders.
+  recordedBlobs: Blob[];
+  recordedBytes: number;
+  // Set if the recording grew past the buffer ceiling and we stopped retaining
+  // — at that point a local save can't be guaranteed, so we don't promise one.
+  localBufferOverflow: boolean;
   cancelled: boolean;
   // Set when the recorder is being torn down to start over on the same source
   // streams, so the stop handler skips the usual track cleanup.
@@ -133,8 +143,24 @@ type ActiveRecording = {
 
 const UPLOAD_SLICE_BYTES = 3 * 1024 * 1024;
 
+// Don't retain more than the upload ceiling — past it the server rejects the
+// recording anyway, so there is nothing a local save could recover.
+const MAX_LOCAL_BUFFER_BYTES = MAX_UPLOAD_BYTES;
+// Below this, a failed recording is too short to be worth dumping a file into
+// the user's Downloads (e.g. the storage gate was bypassed and the very first
+// chunk was rejected ~2s in). The connect-storage message is enough there.
+const MIN_LOCAL_SAVE_BYTES = 2 * 1024 * 1024;
+
 let prepared: PreparedStreams | null = null;
 let activeRecording: ActiveRecording | null = null;
+// Blob URLs handed to the background for save-to-disk recovery downloads. Kept
+// alive until the next recording starts so the download can finish reading.
+const pendingSaveUrls = new Set<string>();
+
+function releasePendingSaveUrls(): void {
+  for (const url of pendingSaveUrls) URL.revokeObjectURL(url);
+  pendingSaveUrls.clear();
+}
 
 function reportStatus(
   sessionId: string,
@@ -454,6 +480,20 @@ async function uploadChunk(
   return data;
 }
 
+// Keep a local copy of every recorded blob so a failed upload can still be
+// saved to disk. Blob references are browser-managed (often disk-backed), so
+// this is far cheaper than holding ArrayBuffers. We stop retaining past the
+// upload ceiling (a larger recording can't be uploaded anyway).
+function retainRecordedBlob(recording: ActiveRecording, blob: Blob): void {
+  if (recording.localBufferOverflow) return;
+  if (recording.recordedBytes + blob.size > MAX_LOCAL_BUFFER_BYTES) {
+    recording.localBufferOverflow = true;
+    return;
+  }
+  recording.recordedBlobs.push(blob);
+  recording.recordedBytes += blob.size;
+}
+
 async function uploadBlobInSlices(
   recording: ActiveRecording,
   blob: Blob,
@@ -501,6 +541,8 @@ async function acquire(message: AcquireMessage): Promise<{
   // Discard any half-prepared capture from a cancelled attempt.
   stopPreparedStreams();
   disposePrepared();
+  // A prior recording's recovery download has finished by now; free its URL.
+  releasePendingSaveUrls();
 
   let displayStream: MediaStream | null = null;
   let micStream: MediaStream | null = null;
@@ -649,6 +691,9 @@ async function begin(message: BeginMessage): Promise<{
     chunkIndex: 0,
     uploadPromises: [],
     uploadFailure: null,
+    recordedBlobs: [],
+    recordedBytes: 0,
+    localBufferOverflow: false,
     cancelled: false,
     restarting: false,
     startTimer: null,
@@ -671,14 +716,15 @@ async function begin(message: BeginMessage): Promise<{
   activeRecording = recording;
 
   recorder.addEventListener("dataavailable", (event) => {
-    if (
-      recording.cancelled ||
-      !event.data ||
-      event.data.size === 0 ||
-      recording.uploadFailure
-    ) {
+    if (recording.cancelled || !event.data || event.data.size === 0) {
       return;
     }
+    // Always keep a local copy first — even after an upload failure — so the
+    // saved-to-disk fallback can assemble the COMPLETE recording. Without this,
+    // a recording whose upload is rejected (storage disconnected, network drop,
+    // size cap) would be lost; the extension has no other on-disk copy.
+    retainRecordedBlob(recording, event.data);
+    if (recording.uploadFailure) return;
     // Record the failure and stop, but do NOT re-throw: re-throwing leaves a
     // rejected promise that surfaces as an "Uncaught (in promise)" error (bad
     // look in a Chrome Web Store review). finalizeStop reads recording.upload-
@@ -782,6 +828,61 @@ function startRecorderNow(recording: ActiveRecording): void {
   }
 }
 
+function recordingDownloadFilename(recording: ActiveRecording): string {
+  const ext = /mp4/i.test(recording.mimeType) ? "mp4" : "webm";
+  const stamp = new Date(recording.startedAtMs || Date.now())
+    .toISOString()
+    .replace(/[:.]/g, "-")
+    .replace("T", "_")
+    .slice(0, 19);
+  return `clip-${stamp}.${ext}`;
+}
+
+// Last-resort recovery: if a finished recording can't be uploaded, save the
+// locally-buffered bytes to the user's Downloads so the recording is never
+// lost. The offscreen document can't call chrome.downloads, so it hands the
+// background a blob URL to download. The URL is revoked on the next acquire().
+async function saveRecordingToDisk(
+  recording: ActiveRecording,
+): Promise<{ savedToDisk: boolean; savedFilename?: string }> {
+  if (
+    recording.cancelled ||
+    recording.localBufferOverflow ||
+    recording.recordedBlobs.length === 0 ||
+    recording.recordedBytes < MIN_LOCAL_SAVE_BYTES
+  ) {
+    return { savedToDisk: false };
+  }
+  try {
+    const blob = new Blob(recording.recordedBlobs, {
+      type: recording.mimeType,
+    });
+    const objectUrl = URL.createObjectURL(blob);
+    pendingSaveUrls.add(objectUrl);
+    const filename = recordingDownloadFilename(recording);
+    const response = (await chrome.runtime.sendMessage({
+      type: "CLIPS_SAVE_RECORDING_TO_DISK",
+      sessionId: recording.sessionId,
+      url: objectUrl,
+      filename,
+    })) as { ok?: boolean } | undefined;
+    if (response?.ok) return { savedToDisk: true, savedFilename: filename };
+    // The download was not accepted — drop the URL we just created.
+    pendingSaveUrls.delete(objectUrl);
+    URL.revokeObjectURL(objectUrl);
+    return { savedToDisk: false };
+  } catch (err) {
+    captureExtensionError(err, {
+      tags: { surface: "offscreen", recordingStep: "save-to-disk" },
+      extra: {
+        recordingId: recording.recordingId,
+        bytes: recording.recordedBytes,
+      },
+    });
+    return { savedToDisk: false };
+  }
+}
+
 async function finalizeStop(recording: ActiveRecording): Promise<void> {
   if (recording.restarting) {
     // restart() re-homes the source streams; do not stop or upload anything.
@@ -866,11 +967,15 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
         durationMs: Math.max(0, Date.now() - recording.startedAtMs),
       },
     });
+    // The upload failed — save the buffered recording to disk so it isn't lost.
+    const saved = await saveRecordingToDisk(recording);
     reportStatus(recording.sessionId, "error", {
       recordingId: recording.recordingId,
       error: error.message,
       storageSetupRequired: (error as { storageSetupRequired?: boolean })
         .storageSetupRequired,
+      savedToDisk: saved.savedToDisk,
+      savedFilename: saved.savedFilename,
     });
     recording.rejectStopped(error);
   }

package/corpus/templates/clips/chrome-extension/src/popup.ts

@@ -45,6 +45,8 @@ type NativeRecording = {
   status: NativeRecordingStatus;
   recordingUrl: string;
   error: string | null;
+  savedToDisk?: boolean;
+  savedFilename?: string;
 };
 
 type PopupStatusResponse = {
@@ -719,22 +721,31 @@ function renderActiveRecording(recording: NativeRecording | null): void {
     titleKey && hostKey && (titleKey === hostKey || hostKey.includes(titleKey));
   recordingUrl.textContent = duplicate ? "" : host;
   recordingUrl.hidden = !host || Boolean(duplicate);
+  const storageFailure = isStorageSetupFailureMessage(recording.error);
+  let errorText = storageFailure
+    ? STORAGE_SETUP_REQUIRED_MESSAGE
+    : recording.error || "Recording needs attention";
+  // If the upload failed but we saved the recording to disk, lead with the
+  // reassurance (it's not lost) and the re-upload action.
+  if (recording.status === "error" && recording.savedToDisk) {
+    const named = recording.savedFilename
+      ? ` (${recording.savedFilename})`
+      : "";
+    errorText = storageFailure
+      ? `Couldn't upload — storage isn't connected. Your clip is saved to your downloads${named}. Connect storage, then re-upload it with "Upload video".`
+      : `Couldn't upload your clip. It's saved to your downloads${named} — try re-uploading it with "Upload video".`;
+  }
   recordingStatus.textContent =
     recording.status === "uploading"
       ? "Saving..."
       : recording.status === "stopping"
         ? "Stopping..."
         : recording.status === "error"
-          ? isStorageSetupFailureMessage(recording.error)
-            ? STORAGE_SETUP_REQUIRED_MESSAGE
-            : recording.error || "Recording needs attention"
+          ? errorText
           : `Recording ${formatDuration(recording.startedAtMs)}`;
   recordingStatus.dataset.kind =
     recording.status === "error" ? "error" : "info";
-  setStorageHelp(
-    recording.status === "error" &&
-      isStorageSetupFailureMessage(recording.error),
-  );
+  setStorageHelp(recording.status === "error" && storageFailure);
 }
 
 async function init(): Promise<void> {

package/corpus/templates/clips/desktop/src/app.tsx

@@ -204,9 +204,21 @@ function serverUrlForPendingUpload(
   return normalizedCurrent || normalizeServerUrl(upload.serverUrl || "");
 }
 
-async function hasConfiguredVideoStorage(serverUrl: string): Promise<boolean> {
+// "configured"/"missing" are definitive answers from the server; "unknown"
+// means the check could not be completed (network error, unreachable server, or
+// an unparseable/non-OK response). An "unknown" result must never downgrade an
+// already-connected user to the setup flow.
+type VideoStorageProbe = "configured" | "missing" | "unknown";
+
+async function hasConfiguredVideoStorage(
+  serverUrl: string,
+): Promise<VideoStorageProbe> {
   const base = serverUrl.replace(/\/+$/, "");
 
+  // Track whether any endpoint gave a definitive answer. If both checks throw
+  // or return non-OK/unparseable responses, we can't tell and return "unknown".
+  let sawDefinitiveAnswer = false;
+
   try {
     const uploadStatus = await fetch(
       `${base}/_agent-native/file-upload/status`,
@@ -215,12 +227,15 @@ async function hasConfiguredVideoStorage(serverUrl: string): Promise<boolean> {
         cache: "no-store",
       },
     );
-    const body = uploadStatus.ok
-      ? ((await uploadStatus.json().catch(() => null)) as {
-          configured?: boolean;
-        } | null)
-      : null;
-    if (body?.configured) return true;
+    if (uploadStatus.ok) {
+      const body = (await uploadStatus.json().catch(() => null)) as {
+        configured?: boolean;
+      } | null;
+      if (body) {
+        sawDefinitiveAnswer = true;
+        if (body.configured) return "configured";
+      }
+    }
   } catch {
     // Fall through to the Builder status endpoint.
   }
@@ -230,15 +245,20 @@ async function hasConfiguredVideoStorage(serverUrl: string): Promise<boolean> {
       credentials: "include",
       cache: "no-store",
     });
-    const body = builderStatus.ok
-      ? ((await builderStatus.json().catch(() => null)) as {
-          configured?: boolean;
-        } | null)
-      : null;
-    return !!body?.configured;
+    if (builderStatus.ok) {
+      const body = (await builderStatus.json().catch(() => null)) as {
+        configured?: boolean;
+      } | null;
+      if (body) {
+        sawDefinitiveAnswer = true;
+        if (body.configured) return "configured";
+      }
+    }
   } catch {
-    return false;
+    // Network error or unreachable server — treat as indeterminate below.
   }
+
+  return sawDefinitiveAnswer ? "missing" : "unknown";
 }
 
 function authTokenStorageKey(serverUrl: string): string {
@@ -658,10 +678,21 @@ export function App() {
       return true;
     }
 
-    setVideoStorageStatus("checking");
-    const configured = await hasConfiguredVideoStorage(serverUrl);
-    setVideoStorageStatus(configured ? "configured" : "missing");
-    return configured;
+    setVideoStorageStatus((prev) => (prev === "missing" ? prev : "checking"));
+    const probe = await hasConfiguredVideoStorage(serverUrl);
+    if (probe === "unknown") {
+      // The check couldn't be completed (offline/unreachable). Never downgrade
+      // an already-connected user to "missing" on an indeterminate result;
+      // preserve the last known status and let the poll retry. If we never
+      // determined a status, fall back to "checking" so the poll keeps trying
+      // rather than hard-blocking the record button.
+      setVideoStorageStatus((prev) =>
+        prev === "configured" || prev === "missing" ? prev : "checking",
+      );
+      return false;
+    }
+    setVideoStorageStatus(probe);
+    return probe === "configured";
   }, [authStatus, localRecordingMode, serverUrl]);
 
   useEffect(() => {
@@ -672,7 +703,10 @@ export function App() {
     if (
       authStatus !== "authed" ||
       localRecordingMode !== "off" ||
-      videoStorageStatus !== "missing"
+      // Re-poll while storage is "missing" (server may become configured) and
+      // while still "checking" (an indeterminate/unreachable first probe should
+      // keep retrying instead of hard-blocking the record button).
+      (videoStorageStatus !== "missing" && videoStorageStatus !== "checking")
     ) {
       return;
     }

package/corpus/templates/clips/server/db/schema.ts

@@ -253,6 +253,32 @@ export const recordingBrowserDiagnostics = table(
   },
 );
 
+export const recordingBugReports = table("recording_bug_reports", {
+  recordingId: text("recording_id").primaryKey(),
+  ownerEmail: text("owner_email").notNull().default("local@localhost"),
+  organizationId: text("workspace_id").notNull(),
+  orgId: text("org_id"),
+  projectId: text("project_id"),
+  title: text("title"),
+  description: text("description").notNull().default(""),
+  severity: text("severity", {
+    enum: ["low", "normal", "high", "urgent"],
+  })
+    .notNull()
+    .default("normal"),
+  sourceUrl: text("source_url"),
+  pageTitle: text("page_title"),
+  appVersion: text("app_version"),
+  environment: text("environment"),
+  reporterEmail: text("reporter_email"),
+  reporterName: text("reporter_name"),
+  reporterId: text("reporter_id"),
+  metadataJson: text("metadata_json").notNull().default("{}"),
+  submittedAt: text("submitted_at").notNull().default(now()),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+});
+
 export const recordingCtas = table("recording_ctas", {
   id: text("id").primaryKey(),
   recordingId: text("recording_id").notNull(),

package/corpus/templates/clips/server/lib/public-agent-context.ts

@@ -33,6 +33,9 @@ export type PublicAgentRecording = typeof schema.recordings._.inferSelect;
 export type PublicAgentTranscript =
   | typeof schema.recordingTranscripts._.inferSelect
   | null;
+export type PublicAgentBugReport =
+  | typeof schema.recordingBugReports._.inferSelect
+  | null;
 
 export interface PublicAgentAccess {
   recording: PublicAgentRecording;
@@ -337,6 +340,17 @@ export async function loadAgentBrowserDiagnostics(recordingId: string) {
   return parseBrowserDiagnosticsRow(row);
 }
 
+export async function loadAgentBugReport(
+  recordingId: string,
+): Promise<PublicAgentBugReport> {
+  const [row] = await getDb()
+    .select()
+    .from(schema.recordingBugReports)
+    .where(eq(schema.recordingBugReports.recordingId, recordingId))
+    .limit(1);
+  return row ?? null;
+}
+
 // Most-recent console logs / network requests surfaced in the public agent
 // context. Bounded to keep the agent payload small; the summary still reports
 // the true total counts.
@@ -412,6 +426,35 @@ function compactBrowserDiagnostics(diagnostics: BrowserDiagnosticsData | null) {
   };
 }
 
+function safeMetadataObject(raw: string | null | undefined) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function compactBugReport(report: PublicAgentBugReport) {
+  if (!report) return null;
+  return {
+    projectId: report.projectId,
+    title: report.title,
+    description: report.description,
+    severity: report.severity,
+    sourceUrl: report.sourceUrl,
+    pageTitle: report.pageTitle,
+    appVersion: report.appVersion,
+    environment: report.environment,
+    metadata: safeMetadataObject(report.metadataJson),
+    submittedAt: report.submittedAt,
+    note: "Reporter identity fields are omitted from public agent context. Host metadata is redacted and bounded at capture time.",
+  };
+}
+
 export function buildPublicAgentContext({
   event,
   access,
@@ -420,6 +463,7 @@ export function buildPublicAgentContext({
   chapters,
   ctas,
   browserDiagnostics,
+  bugReport,
 }: {
   event: H3Event;
   access: PublicAgentAccess;
@@ -428,6 +472,7 @@ export function buildPublicAgentContext({
   chapters: ReturnType<typeof parseAgentChapters>;
   ctas: Awaited<ReturnType<typeof loadAgentCtas>>;
   browserDiagnostics?: BrowserDiagnosticsData | null;
+  bugReport?: PublicAgentBugReport;
 }) {
   const recording = access.recording;
   const requestUrl = getRequestURL(event);
@@ -451,6 +496,11 @@ export function buildPublicAgentContext({
       }));
   const instructions = [
     "Use transcript.segments for timestamped spoken context.",
+    ...(bugReport
+      ? [
+          "Use bugReport for the submitted product context: source URL, page title, app version, environment, severity, and redacted host metadata.",
+        ]
+      : []),
     ...(browserDiagnostics
       ? [
           "Use browserDiagnostics.consoleLogs for the redacted console stream (all levels: debug/log/info/warn/error) and browserDiagnostics.networkRequests for the fetch/XHR requests (method, sanitized URL, status, duration) captured during the recording. browserDiagnostics.consoleIssues highlights just the warnings/errors, and browserDiagnostics.failedNetworkRequests highlights failed requests.",
@@ -515,6 +565,7 @@ export function buildPublicAgentContext({
     },
     chapters,
     recommendedFrames: suggestedFrames,
+    bugReport: compactBugReport(bugReport ?? null),
     browserDiagnostics: compactBrowserDiagnostics(browserDiagnostics ?? null),
     ctas: ctas.map((cta) => ({
       label: cta.label,

package/corpus/templates/clips/server/plugins/auth.ts

@@ -22,6 +22,7 @@ export default createAuthPlugin({
     "/r",
     "/embed",
     "/download",
+    "/bug-report",
     // React Router's lazy route-discovery endpoint. If this is gated by
     // auth it returns an HTML login page; the client tries to parse it
     // as JSON, fails, and can't resolve any public route the user lands

package/corpus/templates/clips/server/plugins/db.ts

@@ -721,6 +721,34 @@ const migrations = runMigrations(
         `CREATE INDEX IF NOT EXISTS slack_installations_org_idx ON slack_installations (org_id, created_at)`,
       ].join("; "),
     },
+    {
+      version: 44,
+      sql: [
+        `CREATE TABLE IF NOT EXISTS recording_bug_reports (
+          recording_id TEXT PRIMARY KEY,
+          owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+          workspace_id TEXT NOT NULL,
+          org_id TEXT,
+          project_id TEXT,
+          title TEXT,
+          description TEXT NOT NULL DEFAULT '',
+          severity TEXT NOT NULL DEFAULT 'normal',
+          source_url TEXT,
+          page_title TEXT,
+          app_version TEXT,
+          environment TEXT,
+          reporter_email TEXT,
+          reporter_name TEXT,
+          reporter_id TEXT,
+          metadata_json TEXT NOT NULL DEFAULT '{}',
+          submitted_at TEXT NOT NULL DEFAULT (datetime('now')),
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )`,
+        `CREATE INDEX IF NOT EXISTS recording_bug_reports_owner_idx ON recording_bug_reports (owner_email, updated_at)`,
+        `CREATE INDEX IF NOT EXISTS recording_bug_reports_project_idx ON recording_bug_reports (project_id, updated_at)`,
+      ].join("; "),
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/server/routes/api/agent-context.json.get.ts

@@ -16,6 +16,7 @@ import {
 import {
   applyAgentJsonHeaders,
   buildPublicAgentContext,
+  loadAgentBugReport,
   loadAgentBrowserDiagnostics,
   loadAgentCtas,
   loadAgentTranscript,
@@ -40,11 +41,12 @@ export default defineEventHandler(async (event: H3Event) => {
   }
 
   const recording = accessResult.access.recording;
-  const [{ transcript, agentSegments }, ctas, browserDiagnostics] =
+  const [{ transcript, agentSegments }, ctas, browserDiagnostics, bugReport] =
     await Promise.all([
       loadAgentTranscript(recording.id, recording.durationMs),
       loadAgentCtas(recording.id),
       loadAgentBrowserDiagnostics(recording.id),
+      loadAgentBugReport(recording.id),
     ]);
   const chapters = parseAgentChapters(recording);
 
@@ -56,5 +58,6 @@ export default defineEventHandler(async (event: H3Event) => {
     chapters,
     ctas,
     browserDiagnostics,
+    bugReport,
   });
 });