@@ -0,0 +1,5 @@
+---
+area: webapp
+type: feature
+---
+Download a session’s original saved transcript file from the session inspector.
@@ -0,0 +1,122 @@
+// @vitest-environment jsdom
+import { createServer, type Server, type ServerResponse } from "node:http";
+import { once } from "node:events";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, expect, test } from "vitest";
+import { OperatingSystemContextProvider } from "~/components/primitives/OperatingSystemProvider";
+import { ShortcutsProvider } from "~/components/primitives/ShortcutsProvider";
+import { TranscriptDownloadButton } from "./TranscriptDownloadButton";
+
+let server: Server | undefined;
+let root: Root | undefined;
+let container: HTMLDivElement;
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+afterEach(async () => {
+  if (root) await act(async () => root?.unmount());
+  root = undefined;
+  container?.remove();
+  if (server) {
+    server.closeAllConnections();
+    await new Promise<void>((resolve, reject) =>
+      server!.close((error) => (error ? reject(error) : resolve()))
+    );
+    server = undefined;
+  }
+});
+
+async function serve(handler: (response: ServerResponse) => void) {
+  server = createServer((_request, response) => handler(response));
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Expected TCP listener");
+  return `http://127.0.0.1:${address.port}/resources/transcript-download`;
+}
+
+async function render(resourcePath: string, initiallyAvailable: boolean) {
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+  await act(async () =>
+    root!.render(
+      createElement(
+        OperatingSystemContextProvider,
+        { platform: "mac" },
+        createElement(
+          ShortcutsProvider,
+          null,
+          createElement(
+            "div",
+            null,
+            createElement("h1", null, "Session overview"),
+            createElement(TranscriptDownloadButton, { resourcePath, initiallyAvailable })
+          )
+        )
+      )
+    )
+  );
+}
+
+async function settleUntil(condition: () => boolean) {
+  const deadline = Date.now() + 2000;
+  while (!condition() && Date.now() < deadline) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+  }
+  expect(condition()).toBe(true);
+}
+
+test("a seeded transcript uses a native attachment link without fetching the object", async () => {
+  let requests = 0;
+  const url = await serve((response) => {
+    requests++;
+    response.end();
+  });
+  await render(url, true);
+  const link = container.querySelector<HTMLAnchorElement>('a[aria-label="Download transcript"]');
+  expect(link?.href).toBe(url);
+  expect(link?.hasAttribute("download")).toBe(true);
+  expect(requests).toBe(0);
+});
+
+test("an HTML proxy error shows availability guidance and Retry recovers", async () => {
+  let attempts = 0;
+  const url = await serve((response) => {
+    if (++attempts === 1) {
+      response.writeHead(502, { "Content-Type": "text/html" });
+      response.end("<html>Bad gateway</html>");
+    } else {
+      response.writeHead(200, { "Content-Type": "application/json" });
+      response.end(JSON.stringify({ available: true }));
+    }
+  });
+  await render(url, false);
+  await settleUntil(() => !!container.querySelector('[role="alert"]'));
+  expect(container.querySelector('[role="alert"]')?.textContent).toBe(
+    "Could not check transcript availability."
+  );
+  expect(container.textContent).not.toContain("Unexpected token");
+  await act(async () => container.querySelector<HTMLButtonElement>("button")!.click());
+  await settleUntil(() => !!container.querySelector("a[download]"));
+  expect(attempts).toBe(2);
+});
+
+test("a pending availability request does not block the overview and a missing object stays hidden", async () => {
+  let pending: ServerResponse | undefined;
+  const url = await serve((response) => {
+    pending = response;
+  });
+  await render(url, false);
+  await settleUntil(() => !!pending);
+  expect(container.querySelector("h1")?.textContent).toBe("Session overview");
+  expect(container.querySelector("a")).toBeNull();
+  await act(async () => {
+    pending!.writeHead(200, { "Content-Type": "application/json" });
+    pending!.end(JSON.stringify({ available: false }));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  });
+  expect(container.textContent).toBe("Session overview");
+});
@@ -0,0 +1,78 @@
+import { ArrowDownTrayIcon } from "@heroicons/react/20/solid";
+import { useEffect, useState } from "react";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import * as Property from "~/components/primitives/PropertyTable";
+
+export function TranscriptDownloadButton({
+  resourcePath,
+  initiallyAvailable,
+}: {
+  resourcePath: string;
+  initiallyAvailable: boolean;
+}) {
+  const [checkedAvailability, setAvailability] = useState<
+    "loading" | "available" | "missing" | "error"
+  >("loading");
+  const availability = initiallyAvailable ? "available" : checkedAvailability;
+  const [retry, setRetry] = useState(0);
+
+  useEffect(() => {
+    if (initiallyAvailable) return;
+    const controller = new AbortController();
+    fetch(`${resourcePath}?check=1`, { signal: controller.signal })
+      .then(async (response) => {
+        // A proxy may return HTML; all failed checks use the same actionable message.
+        if (response.redirected || !response.ok) throw new Error("Availability check failed");
+        const body: unknown = await response.json();
+        if (
+          !body ||
+          typeof body !== "object" ||
+          !("available" in body) ||
+          typeof body.available !== "boolean"
+        ) {
+          throw new Error("Invalid availability response");
+        }
+        if (!controller.signal.aborted) setAvailability(body.available ? "available" : "missing");
+      })
+      .catch(() => {
+        if (!controller.signal.aborted) setAvailability("error");
+      });
+    return () => controller.abort();
+  }, [resourcePath, initiallyAvailable, retry]);
+
+  if (availability === "loading" || availability === "missing") return null;
+
+  return (
+    <Property.Item>
+      <Property.Label>Transcript</Property.Label>
+      <Property.Value>
+        {availability === "available" ? (
+          <LinkButton
+            to={resourcePath}
+            download
+            variant="secondary/small"
+            LeadingIcon={ArrowDownTrayIcon}
+            aria-label="Download transcript"
+          >
+            Download
+          </LinkButton>
+        ) : (
+          <div className="flex flex-col items-start gap-1">
+            <span role="alert" className="text-xs">
+              Could not check transcript availability.
+            </span>
+            <Button
+              variant="secondary/small"
+              onClick={() => {
+                setAvailability("loading");
+                setRetry((value) => value + 1);
+              }}
+            >
+              Retry
+            </Button>
+          </div>
+        )}
+      </Property.Value>
+    </Property.Item>
+  );
+}
@@ -45,6 +45,7 @@ import {
   descriptionForTaskRunStatus,
   TaskRunStatusCombo,
 } from "~/components/runs/v3/TaskRunStatus";
+import { TranscriptDownloadButton } from "~/components/sessions/v1/TranscriptDownloadButton";
 import { CloseSessionDialog } from "~/components/sessions/v1/CloseSessionDialog";
 import { SessionStatusCombo } from "~/components/sessions/v1/SessionStatus";
 import { $replica } from "~/db.server";
@@ -946,6 +947,11 @@ function OverviewTab({
             )}
           </Property.Value>
         </Property.Item>
+        <TranscriptDownloadButton
+          key={session.friendlyId}
+          initiallyAvailable={!!session.agentView.transcriptSeed}
+          resourcePath={`/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/sessions/${encodeURIComponent(session.friendlyId)}/transcript-download`}
+        />
         {session.currentRun ? (
           <Property.Item>
             <Property.Label>Current run</Property.Label>
 
@@ -0,0 +1,67 @@
+import { json, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { logger } from "~/services/logger.server";
+import { chatSnapshotStorageKey } from "~/services/realtime/chatSnapshot.server";
+import { resolveSessionByIdOrExternalId } from "~/services/realtime/sessions.server";
+import {
+  downloadTranscript,
+  isTranscriptNotFound,
+} from "~/services/realtime/transcriptDownload.server";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import {
+  objectExistsInObjectStore,
+  downloadObjectResponseFromObjectStore,
+} from "~/v3/objectStore.server";
+
+const ParamsSchema = EnvironmentParamSchema.extend({ sessionParam: z.string() });
+const headers = { "Cache-Control": "private, no-store" };
+
+// Cookie-auth only: saved runtime state must never be exposed to public session tokens.
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam, sessionParam } = ParamsSchema.parse(params);
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) return json({ error: "Project not found" }, { status: 404, headers });
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) return json({ error: "Environment not found" }, { status: 404, headers });
+  const session = await resolveSessionByIdOrExternalId($replica, environment.id, sessionParam);
+  if (!session) return json({ error: "Session not found" }, { status: 404, headers });
+
+  try {
+    const storagePath = chatSnapshotStorageKey(session);
+    const packet = { dataType: "application/store", data: storagePath };
+    const location = { projectRef: project.externalRef, envSlug: environment.slug };
+    if (new URL(request.url).searchParams.get("check") === "1") {
+      return json({ available: await objectExistsInObjectStore(packet, location) }, { headers });
+    }
+    const object = await downloadObjectResponseFromObjectStore(packet, location);
+    return downloadTranscript(object, storagePath, (error) => {
+      logger.error("Session transcript download stream failed", {
+        projectId: project.id,
+        environmentId: environment.id,
+        sessionId: session.friendlyId,
+        error,
+      });
+    });
+  } catch (error) {
+    if (isTranscriptNotFound(error)) {
+      return json({ error: "No saved transcript is available." }, { status: 404, headers });
+    }
+    logger.error("Failed to access session transcript", {
+      projectId: project.id,
+      environmentId: environment.id,
+      sessionId: session.friendlyId,
+      error,
+    });
+    return json(
+      {
+        error: "Could not download the saved transcript. Please try again.",
+      },
+      { status: 502, headers }
+    );
+  }
+}