diff --git a/app/src-tauri/src/lib.rs b/app/src-tauri/src/lib.rs
index ae76d0ad..97d5472a 100644
--- a/app/src-tauri/src/lib.rs
+++ b/app/src-tauri/src/lib.rs
@@ -65,6 +65,59 @@ async fn open_path(path: String) -> Result<(), String> {
     .await
 }
 
+/// Extensions `open_file` will open with the program Windows picks. Anything
+/// else could be a program or a script that runs when opened.
+const OPENABLE: [&str; 24] = [
+    "pdf", "png", "jpg", "jpeg", "gif", "webp", "svg", "txt", "md", "csv", "json", "log", "html",
+    "htm", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "mp3", "wav", "mp4", "rtf",
+];
+
+fn is_openable(path: &Path) -> bool {
+    path.extension()
+        .and_then(|extension| extension.to_str())
+        .is_some_and(|extension| OPENABLE.contains(&extension.to_ascii_lowercase().as_str()))
+}
+
+/// Opens a file a bot made with the program Windows uses for it. Only
+/// documents, images, sound and video: never something that runs.
+#[tauri::command]
+async fn open_file(path: String) -> Result<(), String> {
+    blocking(move || {
+        let file = Path::new(&path);
+        if !file.is_absolute() || !file.is_file() {
+            return Err(format!("{path} is not a file"));
+        }
+        if !is_openable(file) {
+            return Err("this kind of file is not opened from Botloft".into());
+        }
+        std::process::Command::new("explorer.exe")
+            .arg(file)
+            .spawn()
+            .map(drop)
+            .map_err(|err| format!("cannot open the file: {err}"))
+    })
+    .await
+}
+
+/// Shows a file in its folder, selected. Nothing is run.
+#[tauri::command]
+async fn reveal_file(path: String) -> Result<(), String> {
+    use std::os::windows::process::CommandExt as _;
+    blocking(move || {
+        let file = Path::new(&path);
+        if !file.is_absolute() || !file.exists() || path.contains('"') {
+            return Err(format!("{path} is not a file"));
+        }
+        // Explorer reads `/select,` and the path as one argument.
+        std::process::Command::new("explorer.exe")
+            .raw_arg(format!("/select,\"{path}\""))
+            .spawn()
+            .map(drop)
+            .map_err(|err| format!("cannot open Explorer: {err}"))
+    })
+    .await
+}
+
 /// Whether `url` is a plain web link, safe to hand to the default browser.
 fn is_web_link(url: &str) -> bool {
     let rest = url
@@ -108,6 +161,8 @@ pub fn run() {
             claude_sign_in,
             read_owner_token,
             open_path,
+            open_file,
+            reveal_file,
             open_url
         ])
         .run(tauri::generate_context!())
@@ -116,7 +171,29 @@ pub fn run() {
 
 #[cfg(test)]
 mod tests {
-    use super::is_web_link;
+    use std::path::Path;
+
+    use super::{is_openable, is_web_link};
+
+    #[test]
+    fn only_documents_and_media_open() {
+        for file in [r"C:\w\Report.PDF", r"C:\w\a b\notes.md", r"C:\w\chart.png"] {
+            assert!(is_openable(Path::new(file)), "{file}");
+        }
+        for file in [
+            r"C:\w\setup.exe",
+            r"C:\w\run.bat",
+            r"C:\w\run.cmd",
+            r"C:\w\run.ps1",
+            r"C:\w\link.lnk",
+            r"C:\w\page.hta",
+            r"C:\w\macro.docm",
+            r"C:\w\noextension",
+            r"C:\w\report.pdf.exe",
+        ] {
+            assert!(!is_openable(Path::new(file)), "{file}");
+        }
+    }
 
     #[test]
     fn only_plain_web_links_open() {
diff --git a/app/src-tauri/tauri.conf.json b/app/src-tauri/tauri.conf.json
index c476cbb7..190d0370 100644
--- a/app/src-tauri/tauri.conf.json
+++ b/app/src-tauri/tauri.conf.json
@@ -21,7 +21,7 @@
       }
     ],
     "security": {
-      "csp": "default-src 'self'; connect-src 'self' ipc: http://ipc.localhost ws://127.0.0.1:*; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'"
+      "csp": "default-src 'self'; connect-src 'self' ipc: http://ipc.localhost ws://127.0.0.1:*; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; frame-src blob:; font-src 'self'"
     }
   },
   "plugins": {
diff --git a/app/src/dev/seedChats.ts b/app/src/dev/seedChats.ts
index d06a23f9..6be88bbf 100644
--- a/app/src/dev/seedChats.ts
+++ b/app/src/dev/seedChats.ts
@@ -72,6 +72,19 @@ export function seedChats(fake: FakeBotloft, crew: Crew): void {
     const call = chat.tool(crew.scout, name, { summary, input: JSON.stringify({ path: summary }) });
     chat.finish(call, name === "Write" ? "Wrote 42 lines" : "ok");
   }
+  at(93);
+  const made = fake.files;
+  made.add(crew.scout, "week-39.md", {
+    folder: "summaries",
+    text: SUMMARY,
+    writtenByBot: true,
+    at: fake.now,
+  });
+  made.add(crew.scout, "papers.csv", {
+    text: "paper,pages,deep_read\nRetrieval at scale,14,yes\nAgents that plan,22,yes\nSmall evals,9,maybe\n",
+    at: fake.now + MINUTE,
+  });
+  made.add(crew.scout, "week-39-report.docx", { text: "docx", at: fake.now + 2 * MINUTE });
   at(92);
   chat.reply(crew.scout, SUMMARY);
   const handoff = chat.tool(crew.scout, "mcp__botloft__send_message", {
diff --git a/app/src/features/bots/BotHeader.tsx b/app/src/features/bots/BotHeader.tsx
index 0cd88b7b..d446b10d 100644
--- a/app/src/features/bots/BotHeader.tsx
+++ b/app/src/features/bots/BotHeader.tsx
@@ -2,6 +2,7 @@ import {
   Archive,
   Crown,
   Ellipsis,
+  Files,
   FolderOpen,
   PanelRight,
   Pause,
@@ -32,11 +33,18 @@ export function BotHeader({
   crew,
   detailsOpen,
   onToggleDetails,
+  filesOpen,
+  freshFiles,
+  onToggleFiles,
 }: {
   bot: Bot;
   crew: Crew;
   detailsOpen: boolean;
   onToggleDetails(): void;
+  filesOpen: boolean;
+  /** Files that showed up since the owner last looked. */
+  freshFiles: number;
+  onToggleFiles(): void;
 }) {
   const t = useT();
   const words = t.bots.header;
@@ -99,6 +107,29 @@ export function BotHeader({
       <Button icon={RotateCw} disabled={stopped} onClick={() => restart(false)}>
         {words.restart}
       </Button>
+      <span className="relative">
+        <Button
+          variant={filesOpen ? "secondary" : "ghost"}
+          icon={Files}
+          label={
+            freshFiles > 0
+              ? `${t.files.show}: ${t.files.fresh(freshFiles)}`
+              : filesOpen
+                ? t.files.hide
+                : t.files.show
+          }
+          aria-pressed={filesOpen}
+          onClick={onToggleFiles}
+        />
+        {freshFiles > 0 && (
+          <span
+            aria-hidden
+            className="pointer-events-none absolute -top-1 -right-1 grid min-w-4 place-items-center rounded-full bg-work px-1 font-semibold text-[10px] text-canvas leading-4"
+          >
+            {freshFiles}
+          </span>
+        )}
+      </span>
       <Button
         variant={detailsOpen ? "secondary" : "ghost"}
         icon={PanelRight}
diff --git a/app/src/features/bots/BotView.tsx b/app/src/features/bots/BotView.tsx
index e133f055..77dc4451 100644
--- a/app/src/features/bots/BotView.tsx
+++ b/app/src/features/bots/BotView.tsx
@@ -1,5 +1,5 @@
 import { X } from "lucide-react";
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { useShallow } from "zustand/react/shallow";
 import { useT } from "../../i18n";
 import type { Bot, Crew } from "../../lib/protocol.gen";
@@ -9,12 +9,16 @@ import { Button } from "../../ui/Button";
 import { Callout } from "../../ui/Callout";
 import { type Tab, Tabs, tabId } from "../../ui/Tabs";
 import { ChatView } from "../chat/ChatView";
+import { FilesPanel } from "../files/FilesPanel";
+import { useBotFiles } from "../files/useBotFiles";
 import { SignInButton } from "../onboarding/SignIn";
 import { BotRoutines } from "../routines/RoutineList";
 import { BotHeader } from "./BotHeader";
 import { stateView } from "./BotStateBadge";
 
 type Pane = "chat" | "routines";
+/** What the panel beside the chat shows. */
+type Side = "details" | "files" | null;
 
 /**
  * A bot's conversation and its routines, with its details in a side panel
@@ -22,8 +26,26 @@ type Pane = "chat" | "routines";
  */
 export function BotView({ bot, crew }: { bot: Bot; crew: Crew }) {
   const t = useT();
-  const [details, setDetails] = useState(false);
+  const [side, setSide] = useState<Side>(null);
   const [pane, setPane] = useState<Pane>("chat");
+  const files = useBotFiles(bot);
+  // What the owner has seen: files newer than this are new to them.
+  const [seenAt, setSeenAt] = useState(() => Date.now());
+  const [since, setSince] = useState(seenAt);
+  // biome-ignore lint/correctness/useExhaustiveDependencies: a new bot has its own files to see
+  useEffect(() => {
+    const now = Date.now();
+    setSeenAt(now);
+    setSince(now);
+  }, [bot.id]);
+  const filesOpen = side === "files";
+  const toggleFiles = () => {
+    // What was there when the panel opened or closed counts as seen.
+    setSince(seenAt);
+    setSeenAt(Date.now());
+    setSide(filesOpen ? null : "files");
+  };
+  const fresh = filesOpen ? 0 : files.files.filter((file) => file.modifiedAt > seenAt).length;
   const routines = useApp(useShallow((state) => routinesOf(state, bot.id)));
   const view = stateView(bot, crew.paused, t);
   const tabs: Tab<Pane>[] = [
@@ -39,8 +61,11 @@ export function BotView({ bot, crew }: { bot: Bot; crew: Crew }) {
       <BotHeader
         bot={bot}
         crew={crew}
-        detailsOpen={details}
-        onToggleDetails={() => setDetails(!details)}
+        detailsOpen={side === "details"}
+        onToggleDetails={() => setSide(side === "details" ? null : "details")}
+        filesOpen={filesOpen}
+        freshFiles={fresh}
+        onToggleFiles={toggleFiles}
       />
       <Notices bot={bot} crew={crew} view={view} />
       <Tabs<Pane> label={bot.name} tabs={tabs} value={pane} onChange={setPane} />
@@ -52,7 +77,8 @@ export function BotView({ bot, crew }: { bot: Bot; crew: Crew }) {
             <BotRoutines bot={bot} />
           )}
         </div>
-        {details && <Details bot={bot} onClose={() => setDetails(false)} />}
+        {side === "details" && <Details bot={bot} onClose={() => setSide(null)} />}
+        {filesOpen && <FilesPanel bot={bot} data={files} since={since} onClose={toggleFiles} />}
       </div>
     </section>
   );
diff --git a/app/src/features/chat/rows.test.ts b/app/src/features/chat/rows.test.ts
index fd54ad7f..a5435a5b 100644
--- a/app/src/features/chat/rows.test.ts
+++ b/app/src/features/chat/rows.test.ts
@@ -21,6 +21,7 @@ const tool = (name: string) =>
     input: "{}",
     status: "done",
     output: null,
+    file: null,
   });
 const turn = () => item({ kind: "turn", durationMs: 1000, costUsd: null, error: null });
 const inbound = (body: string, at?: number) =>
diff --git a/app/src/features/files/FilePreview.tsx b/app/src/features/files/FilePreview.tsx
new file mode 100644
index 00000000..257a46c1
--- /dev/null
+++ b/app/src/features/files/FilePreview.tsx
@@ -0,0 +1,173 @@
+// One file of a bot, shown in the panel: images, PDFs, markdown and plain
+// text right there; anything else only offers to open it. A file is read
+// from the daemon once per look, up to 20 MB.
+
+import { ArrowLeft, ExternalLink, FolderOpen, LoaderCircle } from "lucide-react";
+import { useEffect, useState } from "react";
+import { useT } from "../../i18n";
+import { errorText } from "../../lib/api";
+import { decodeBytes } from "../../lib/base64";
+import { fileSize } from "../../lib/format";
+import { type Bot, type BotFile, RpcErrorCode } from "../../lib/protocol.gen";
+import { RpcError } from "../../lib/rpc";
+import { useApi, useHost } from "../../store/context";
+import { Button } from "../../ui/Button";
+import { attempt } from "../../ui/toast";
+import { Markdown } from "../chat/Markdown";
+import { previewKind } from "./kinds";
+
+/** Characters of text shown; a longer file shows its start. */
+const TEXT_MAX = 200_000;
+
+type Shown =
+  | { kind: "loading" }
+  | { kind: "failed"; gone: boolean; tooBig: boolean; detail: string }
+  | { kind: "none" }
+  | { kind: "image"; src: string; alt: string }
+  | { kind: "pdf"; src: string }
+  | { kind: "markdown" | "text"; text: string; cut: boolean };
+
+function useShown(bot: Bot, file: BotFile): Shown {
+  const api = useApi();
+  const [shown, setShown] = useState<Shown>({ kind: "loading" });
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: a file is read again when it changes
+  useEffect(() => {
+    const kind = previewKind(file.mediaType);
+    if (kind === "none") {
+      setShown({ kind: "none" });
+      return;
+    }
+    let alive = true;
+    let url: string | null = null;
+    setShown({ kind: "loading" });
+    api
+      .call("files.read", { botId: bot.id, path: file.path })
+      .then((data) => {
+        if (!alive) {
+          return;
+        }
+        if (kind === "image") {
+          setShown({ kind, src: `data:${data.mediaType};base64,${data.data}`, alt: file.name });
+        } else if (kind === "pdf") {
+          url = URL.createObjectURL(new Blob([decodeBytes(data.data)], { type: data.mediaType }));
+          setShown({ kind, src: url });
+        } else {
+          const text = new TextDecoder().decode(decodeBytes(data.data));
+          setShown({ kind, text: text.slice(0, TEXT_MAX), cut: text.length > TEXT_MAX });
+        }
+      })
+      .catch((failure: unknown) => {
+        if (alive) {
+          const code = failure instanceof RpcError ? failure.code : 0;
+          setShown({
+            kind: "failed",
+            gone: code === RpcErrorCode.notFound,
+            tooBig: code === RpcErrorCode.validation,
+            detail: errorText(failure),
+          });
+        }
+      });
+    return () => {
+      alive = false;
+      if (url) {
+        URL.revokeObjectURL(url);
+      }
+    };
+  }, [api, bot.id, file.path, file.modifiedAt, file.mediaType]);
+
+  return shown;
+}
+
+export function FilePreview({ bot, file, onBack }: { bot: Bot; file: BotFile; onBack(): void }) {
+  const t = useT().files;
+  const host = useHost();
+  const shown = useShown(bot, file);
+  return (
+    <div className="flex min-h-0 flex-1 flex-col">
+      <div className="flex items-center gap-1.5 border-line border-b px-2 py-2">
+        <Button variant="ghost" size="sm" icon={ArrowLeft} onClick={onBack}>
+          {t.back}
+        </Button>
+        <span className="min-w-0 flex-1" />
+        <Button
+          size="sm"
+          icon={FolderOpen}
+          onClick={() => attempt(t.failed.reveal, () => host.revealFile(file.path))}
+        >
+          {t.reveal}
+        </Button>
+        <Button
+          size="sm"
+          variant="primary"
+          icon={ExternalLink}
+          onClick={() => attempt(t.failed.open, () => host.openFile(file.path))}
+        >
+          {t.open}
+        </Button>
+      </div>
+      <div className="border-line border-b px-4 py-3">
+        <h3 className="break-words font-semibold text-sm" data-selectable>
+          {file.name}
+        </h3>
+        <p className="mt-0.5 text-muted text-xs">{fileSize(file.size)}</p>
+      </div>
+      <div className="flex min-h-0 flex-1 flex-col overflow-auto">
+        <Body shown={shown} />
+      </div>
+    </div>
+  );
+}
+
+function Body({ shown }: { shown: Shown }) {
+  const t = useT().files.preview;
+  switch (shown.kind) {
+    case "loading":
+      return (
+        <p role="status" className="flex items-center gap-2 p-4 text-muted text-sm">
+          <LoaderCircle aria-hidden size={14} className="animate-spin" />
+          {t.loading}
+        </p>
+      );
+    case "none":
+      return <p className="p-4 text-muted text-sm">{t.none}</p>;
+    case "failed":
+      return (
+        <div role="alert" className="p-4 text-sm">
+          <p className="text-ink-soft">
+            {shown.gone ? t.gone : shown.tooBig ? t.tooBig : t.failed}
+          </p>
+          {!shown.gone && !shown.tooBig && (
+            <p className="mt-1 break-words font-mono text-muted text-xs">{shown.detail}</p>
+          )}
+        </div>
+      );
+    case "image":
+      return (
+        <div className="grid min-h-0 flex-1 place-items-center bg-sunken p-3">
+          <img src={shown.src} alt={shown.alt} className="max-h-full max-w-full object-contain" />
+        </div>
+      );
+    case "pdf":
+      return <iframe title="PDF" src={shown.src} className="min-h-0 flex-1 border-0 bg-panel" />;
+    case "markdown":
+      return (
+        <div className="p-4">
+          <Markdown text={shown.text} />
+          {shown.cut && <p className="mt-3 text-muted text-xs">{t.cut}</p>}
+        </div>
+      );
+    case "text":
+      return (
+        <div className="p-4">
+          <pre
+            className="whitespace-pre-wrap break-words font-mono text-xs leading-relaxed"
+            data-selectable
+          >
+            {shown.text}
+          </pre>
+          {shown.cut && <p className="mt-3 text-muted text-xs">{t.cut}</p>}
+        </div>
+      );
+  }
+}
diff --git a/app/src/features/files/FilesPanel.tsx b/app/src/features/files/FilesPanel.tsx
new file mode 100644
index 00000000..e8c4515c
--- /dev/null
+++ b/app/src/features/files/FilesPanel.tsx
@@ -0,0 +1,136 @@
+// The panel beside a bot's chat with the files it made (spec 15.1): newest
+// first, the ones that showed up since the owner last looked marked new. A
+// click shows the file in the panel itself.
+
+import { RefreshCw, X } from "lucide-react";
+import { useState } from "react";
+import { useT } from "../../i18n";
+import { fileSize, fromNow } from "../../lib/format";
+import type { Bot, BotFile } from "../../lib/protocol.gen";
+import { Button } from "../../ui/Button";
+import { Callout } from "../../ui/Callout";
+import { BotAvatar } from "../bots/BotAvatar";
+import { FilePreview } from "./FilePreview";
+import { fileIcon } from "./kinds";
+import type { BotFiles } from "./useBotFiles";
+
+export function FilesPanel({
+  bot,
+  data,
+  since,
+  onClose,
+}: {
+  bot: Bot;
+  data: BotFiles;
+  /** Files modified after this (Unix ms) are marked new. */
+  since: number;
+  onClose(): void;
+}) {
+  const t = useT().files;
+  const [path, setPath] = useState<string | null>(null);
+  const chosen = data.files.find((file) => file.path === path);
+
+  return (
+    <aside
+      aria-label={t.panel(bot.name)}
+      className="flex w-[26rem] shrink-0 flex-col border-line border-l bg-panel"
+    >
+      <header className="flex h-11 shrink-0 items-center justify-between border-line border-b pr-1.5 pl-4">
+        <h2 className="font-semibold text-sm">{t.heading}</h2>
+        <div className="flex items-center gap-0.5">
+          <Button
+            variant="ghost"
+            size="sm"
+            icon={RefreshCw}
+            label={t.refresh}
+            onClick={data.refresh}
+          />
+          <Button variant="ghost" size="sm" icon={X} label={t.close} onClick={onClose} />
+        </div>
+      </header>
+      {chosen ? (
+        <FilePreview bot={bot} file={chosen} onBack={() => setPath(null)} />
+      ) : (
+        <List bot={bot} data={data} since={since} onOpen={setPath} />
+      )}
+    </aside>
+  );
+}
+
+function List({
+  bot,
+  data,
+  since,
+  onOpen,
+}: {
+  bot: Bot;
+  data: BotFiles;
+  since: number;
+  onOpen(path: string): void;
+}) {
+  const t = useT().files;
+  if (data.error && data.files.length === 0) {
+    return (
+      <div className="p-3">
+        <Callout tone="danger" title={t.loadFailed}>
+          {data.error}
+        </Callout>
+      </div>
+    );
+  }
+  if (data.files.length === 0 && !data.loading) {
+    return (
+      <div className="flex flex-col items-center gap-3 px-6 py-14 text-center">
+        <BotAvatar color={bot.color} size={44} mood="idle" />
+        <p className="font-semibold text-sm">{t.emptyTitle(bot.name)}</p>
+        <p className="text-muted text-sm">{t.emptyBody}</p>
+      </div>
+    );
+  }
+  return (
+    <ul aria-label={t.list} className="min-h-0 flex-1 overflow-y-auto p-1.5">
+      {data.files.map((file) => (
+        <FileRow key={file.path} file={file} fresh={file.modifiedAt > since} onOpen={onOpen} />
+      ))}
+    </ul>
+  );
+}
+
+function FileRow({
+  file,
+  fresh,
+  onOpen,
+}: {
+  file: BotFile;
+  fresh: boolean;
+  onOpen(path: string): void;
+}) {
+  const t = useT().files;
+  const Icon = fileIcon(file.mediaType, file.name);
+  return (
+    <li>
+      <button
+        type="button"
+        onClick={() => onOpen(file.path)}
+        title={file.path}
+        className="flex w-full min-w-0 items-center gap-3 rounded-lg px-2.5 py-2 text-left transition-colors hover:bg-sunken"
+      >
+        <Icon aria-hidden size={18} className="shrink-0 text-muted" />
+        <span className="min-w-0 flex-1">
+          <span className="flex items-center gap-2">
+            <span className="truncate font-medium text-sm">{file.name}</span>
+            {fresh && (
+              <span className="shrink-0 rounded-full bg-work/12 px-1.5 py-px font-medium text-work text-xs">
+                {t.newTag}
+              </span>
+            )}
+          </span>
+          <span className="block truncate text-muted text-xs">
+            {file.folder ? `${file.folder} · ` : ""}
+            {fileSize(file.size)} · {fromNow(file.modifiedAt)}
+          </span>
+        </span>
+      </button>
+    </li>
+  );
+}
diff --git a/app/src/features/files/files.test.tsx b/app/src/features/files/files.test.tsx
new file mode 100644
index 00000000..51c7e372
--- /dev/null
+++ b/app/src/features/files/files.test.tsx
@@ -0,0 +1,101 @@
+import { act, cleanup, fireEvent, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+import { FakeBotloft } from "../../lib/fake";
+import { crewOpened, openBot, renderApp } from "../../test/app";
+
+afterEach(cleanup);
+
+/** A crew "Ops" with @scout, idle. */
+function crew() {
+  const fake = new FakeBotloft();
+  const ops = fake.addCrew("Ops");
+  const scout = fake.addBot(ops.id, "Scout", "Finds sources");
+  fake.setBotState(scout.id, "idle");
+  return { fake, scout };
+}
+
+async function openScout(fake: FakeBotloft) {
+  const rendered = renderApp(fake);
+  await crewOpened("Ops");
+  openBot("Scout");
+  await screen.findByRole("list", { name: "Messages" });
+  return rendered;
+}
+
+const toggle = () => screen.getByRole("button", { name: /Show files|Hide files/ });
+const panel = () => screen.getByRole("complementary", { name: "Files from Scout" });
+
+describe("files panel", () => {
+  test("shows what the bot made, newest first, and previews text", async () => {
+    const { fake, scout } = crew();
+    const now = fake.now;
+    fake.files.add(scout.id, "sources.md", { text: "# Sources\n\n- one", at: now - 60_000 });
+    fake.files.add(scout.id, "report.pdf", { text: "%PDF", folder: "final", at: now - 1000 });
+    await openScout(fake);
+
+    fireEvent.click(toggle());
+    const list = await within(panel()).findByRole("list", { name: "Files" });
+    const names = within(list)
+      .getAllByRole("button")
+      .map((row) => row.textContent);
+    expect(names[0]).toContain("report.pdf");
+    expect(names[0]).toContain("final");
+    expect(names[1]).toContain("sources.md");
+
+    fireEvent.click(within(list).getByRole("button", { name: /sources\.md/ }));
+    expect(await within(panel()).findByRole("heading", { name: "Sources" })).toBeDefined();
+    fireEvent.click(within(panel()).getByRole("button", { name: "All files" }));
+    expect(within(panel()).getByRole("list", { name: "Files" })).toBeDefined();
+  });
+
+  test("Open and Show in folder go to the shell, for the file's own path", async () => {
+    const { fake, scout } = crew();
+    const file = fake.files.add(scout.id, "plan.csv", { text: "a,b" });
+    const { host } = await openScout(fake);
+    fireEvent.click(toggle());
+    fireEvent.click(await within(panel()).findByRole("button", { name: /plan\.csv/ }));
+    fireEvent.click(await within(panel()).findByRole("button", { name: "Open" }));
+    fireEvent.click(within(panel()).getByRole("button", { name: "Show in folder" }));
+    await waitFor(() => expect(host.openedFiles).toEqual([file.path]));
+    expect(host.revealed).toEqual([file.path]);
+  });
+
+  test("a file with no preview says so instead of reading it", async () => {
+    const { fake, scout } = crew();
+    fake.files.add(scout.id, "deck.docx", { text: "x" });
+    await openScout(fake);
+    fireEvent.click(toggle());
+    fireEvent.click(await within(panel()).findByRole("button", { name: /deck\.docx/ }));
+    expect(await within(panel()).findByText(/no preview for this kind of file/)).toBeDefined();
+    expect(fake.calls.some((call) => call.method === "files.read")).toBe(false);
+  });
+
+  test("an empty bot says it has made nothing yet", async () => {
+    const { fake } = crew();
+    await openScout(fake);
+    fireEvent.click(toggle());
+    expect(await within(panel()).findByText("Scout hasn't made any files yet")).toBeDefined();
+  });
+
+  test("a file that shows up while the panel is closed puts a count on the button", async () => {
+    const { fake, scout } = crew();
+    await openScout(fake);
+    expect(toggle().getAttribute("aria-label")).toBe("Show files");
+
+    // The bot works, makes a file, and stops: the list is read once more.
+    act(() => {
+      fake.setBotState(scout.id, "busy");
+    });
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    act(() => {
+      fake.files.add(scout.id, "result.txt", { text: "done", at: Date.now() });
+      fake.setBotState(scout.id, "idle");
+    });
+    await waitFor(() => expect(toggle().getAttribute("aria-label")).toBe("Show files: 1 new file"));
+
+    fireEvent.click(toggle());
+    expect(await within(panel()).findByText("New")).toBeDefined();
+    fireEvent.click(toggle());
+    expect(toggle().getAttribute("aria-label")).toBe("Show files");
+  });
+});
diff --git a/app/src/features/files/kinds.ts b/app/src/features/files/kinds.ts
new file mode 100644
index 00000000..6d857a28
--- /dev/null
+++ b/app/src/features/files/kinds.ts
@@ -0,0 +1,58 @@
+// What a file is, from its media type: the icon in the list and how the
+// preview shows it.
+
+import {
+  File,
+  FileArchive,
+  FileAudio,
+  FileCode,
+  FileImage,
+  FileSpreadsheet,
+  FileText,
+  FileVideo,
+  type LucideIcon,
+} from "lucide-react";
+
+export type PreviewKind = "image" | "pdf" | "markdown" | "text" | "none";
+
+const IMAGES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/svg+xml"];
+const TEXT = ["application/json", "application/xml", "application/yaml"];
+
+export function previewKind(mediaType: string): PreviewKind {
+  if (IMAGES.includes(mediaType)) {
+    return "image";
+  }
+  if (mediaType === "application/pdf") {
+    return "pdf";
+  }
+  if (mediaType === "text/markdown") {
+    return "markdown";
+  }
+  return mediaType.startsWith("text/") || TEXT.includes(mediaType) ? "text" : "none";
+}
+
+export function fileIcon(mediaType: string, name: string): LucideIcon {
+  if (mediaType.startsWith("image/")) {
+    return FileImage;
+  }
+  if (mediaType.startsWith("audio/")) {
+    return FileAudio;
+  }
+  if (mediaType.startsWith("video/")) {
+    return FileVideo;
+  }
+  if (mediaType === "application/zip") {
+    return FileArchive;
+  }
+  if (mediaType === "text/csv" || mediaType.includes("spreadsheet")) {
+    return FileSpreadsheet;
+  }
+  if (
+    mediaType === "text/html" ||
+    TEXT.includes(mediaType) ||
+    /\.(ts|tsx|js|py|rs|css)$/i.test(name)
+  ) {
+    return FileCode;
+  }
+  return mediaType === "application/octet-stream" ? File : FileText;
+}
diff --git a/app/src/features/files/useBotFiles.ts b/app/src/features/files/useBotFiles.ts
new file mode 100644
index 00000000..2d34a70f
--- /dev/null
+++ b/app/src/features/files/useBotFiles.ts
@@ -0,0 +1,80 @@
+// The files a bot made, kept current (spec 8.5, 15.1): read when the bot is
+// opened, and again while it works and when it stops, since a scan of its
+// folders is the only way to see what a script or a command made.
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { errorText } from "../../lib/api";
+import type { Bot, BotFile } from "../../lib/protocol.gen";
+import { useApi, useApp } from "../../store/context";
+
+/** How often the list is read while the bot works. */
+const WHILE_WORKING_MS = 4000;
+
+export interface BotFiles {
+  /** Newest first. */
+  files: BotFile[];
+  loading: boolean;
+  error: string | null;
+  refresh(): Promise<void>;
+}
+
+export function useBotFiles(bot: Pick<Bot, "id" | "state">): BotFiles {
+  const api = useApi();
+  const open = useApp((state) => state.connection.kind === "open");
+  const [files, setFiles] = useState<BotFile[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  /** Only the newest read counts: a bot opened meanwhile has its own. */
+  const latest = useRef(0);
+  const botId = bot.id;
+
+  const refresh = useCallback(async () => {
+    latest.current += 1;
+    const mine = latest.current;
+    try {
+      const found = await api.call("files.list", { botId });
+      if (mine === latest.current) {
+        setFiles(found);
+        setError(null);
+      }
+    } catch (failure) {
+      if (mine === latest.current) {
+        setError(errorText(failure));
+      }
+    } finally {
+      if (mine === latest.current) {
+        setLoading(false);
+      }
+    }
+  }, [api, botId]);
+
+  // A new bot, or a new connection: start over.
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    setFiles([]);
+    setLoading(true);
+    void refresh();
+  }, [open, refresh]);
+
+  const working = bot.state === "busy" || bot.state === "needs_approval";
+  const wasWorking = useRef(working);
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    // Once more when it stops: the last file lands just before the end.
+    if (wasWorking.current && !working) {
+      void refresh();
+    }
+    wasWorking.current = working;
+    if (!working) {
+      return;
+    }
+    const timer = setInterval(() => void refresh(), WHILE_WORKING_MS);
+    return () => clearInterval(timer);
+  }, [open, working, refresh]);
+
+  return { files, loading, error, refresh };
+}
diff --git a/app/src/i18n/en/files.ts b/app/src/i18n/en/files.ts
new file mode 100644
index 00000000..a53eb3f1
--- /dev/null
+++ b/app/src/i18n/en/files.ts
@@ -0,0 +1,32 @@
+// The files a bot made (spec 15.1, 8.5): the panel beside its chat.
+
+export const files = {
+  heading: "Files",
+  panel: (bot: string) => `Files from ${bot}`,
+  show: "Show files",
+  hide: "Hide files",
+  close: "Close",
+  refresh: "Refresh",
+  fresh: (count: number) => (count === 1 ? "1 new file" : `${count} new files`),
+  newTag: "New",
+  list: "Files",
+  emptyTitle: (bot: string) => `${bot} hasn't made any files yet`,
+  emptyBody: "What it creates for you, like a report or a spreadsheet, shows up here.",
+  loadFailed: "Couldn't load the files",
+  madeByBot: (bot: string) => `Made by ${bot}`,
+  back: "All files",
+  open: "Open",
+  reveal: "Show in folder",
+  failed: {
+    open: "Could not open the file",
+    reveal: "Could not show the file",
+  },
+  preview: {
+    loading: "Loading…",
+    failed: "Couldn't show this file",
+    none: "There's no preview for this kind of file. Open it to see it.",
+    tooBig: "This file is too big to show here. Open it to see it.",
+    cut: "Only the start of the file is shown.",
+    gone: "This file is no longer there.",
+  },
+};
diff --git a/app/src/i18n/en/index.ts b/app/src/i18n/en/index.ts
index df571e57..c63bbaa0 100644
--- a/app/src/i18n/en/index.ts
+++ b/app/src/i18n/en/index.ts
@@ -5,6 +5,7 @@ import { bots } from "./bots";
 import { chat } from "./chat";
 import { common } from "./common";
 import { crews } from "./crews";
+import { files } from "./files";
 import { messages } from "./messages";
 import { onboarding } from "./onboarding";
 import { routines } from "./routines";
@@ -20,6 +21,7 @@ export const en = {
   bots,
   chat,
   crews,
+  files,
   messages,
   routines,
 };
diff --git a/app/src/i18n/es/files.ts b/app/src/i18n/es/files.ts
new file mode 100644
index 00000000..bb54a6ae
--- /dev/null
+++ b/app/src/i18n/es/files.ts
@@ -0,0 +1,34 @@
+// Los archivos que hizo un bot (spec 15.1, 8.5): el panel junto al chat.
+
+import type { Messages } from "../en";
+
+export const files: Messages["files"] = {
+  heading: "Archivos",
+  panel: (bot) => `Archivos de ${bot}`,
+  show: "Mostrar archivos",
+  hide: "Ocultar archivos",
+  close: "Cerrar",
+  refresh: "Actualizar",
+  fresh: (count) => (count === 1 ? "1 archivo nuevo" : `${count} archivos nuevos`),
+  newTag: "Nuevo",
+  list: "Archivos",
+  emptyTitle: (bot) => `${bot} todavía no hizo ningún archivo`,
+  emptyBody: "Lo que cree para ti, como un informe o una hoja de cálculo, aparece aquí.",
+  loadFailed: "No se pudieron cargar los archivos",
+  madeByBot: (bot) => `Hecho por ${bot}`,
+  back: "Todos los archivos",
+  open: "Abrir",
+  reveal: "Mostrar en la carpeta",
+  failed: {
+    open: "No se pudo abrir el archivo",
+    reveal: "No se pudo mostrar el archivo",
+  },
+  preview: {
+    loading: "Cargando…",
+    failed: "No se pudo mostrar este archivo",
+    none: "Este tipo de archivo no tiene vista previa. Ábrelo para verlo.",
+    tooBig: "Este archivo es demasiado grande para mostrarlo aquí. Ábrelo para verlo.",
+    cut: "Solo se muestra el comienzo del archivo.",
+    gone: "Este archivo ya no está allí.",
+  },
+};
diff --git a/app/src/i18n/es/index.ts b/app/src/i18n/es/index.ts
index 0138837e..7bcab64d 100644
--- a/app/src/i18n/es/index.ts
+++ b/app/src/i18n/es/index.ts
@@ -6,6 +6,7 @@ import { bots } from "./bots";
 import { chat } from "./chat";
 import { common } from "./common";
 import { crews } from "./crews";
+import { files } from "./files";
 import { messages } from "./messages";
 import { onboarding } from "./onboarding";
 import { routines } from "./routines";
@@ -21,6 +22,7 @@ export const es: Messages = {
   bots,
   chat,
   crews,
+  files,
   messages,
   routines,
 };
diff --git a/app/src/i18n/pt-BR/files.ts b/app/src/i18n/pt-BR/files.ts
new file mode 100644
index 00000000..d08230be
--- /dev/null
+++ b/app/src/i18n/pt-BR/files.ts
@@ -0,0 +1,34 @@
+// Os arquivos que um bot fez (spec 15.1, 8.5): o painel ao lado do chat.
+
+import type { Messages } from "../en";
+
+export const files: Messages["files"] = {
+  heading: "Arquivos",
+  panel: (bot) => `Arquivos de ${bot}`,
+  show: "Mostrar arquivos",
+  hide: "Ocultar arquivos",
+  close: "Fechar",
+  refresh: "Atualizar",
+  fresh: (count) => (count === 1 ? "1 arquivo novo" : `${count} arquivos novos`),
+  newTag: "Novo",
+  list: "Arquivos",
+  emptyTitle: (bot) => `${bot} ainda não fez nenhum arquivo`,
+  emptyBody: "O que ele criar para você, como um relatório ou uma planilha, aparece aqui.",
+  loadFailed: "Não foi possível carregar os arquivos",
+  madeByBot: (bot) => `Feito por ${bot}`,
+  back: "Todos os arquivos",
+  open: "Abrir",
+  reveal: "Mostrar na pasta",
+  failed: {
+    open: "Não foi possível abrir o arquivo",
+    reveal: "Não foi possível mostrar o arquivo",
+  },
+  preview: {
+    loading: "Carregando…",
+    failed: "Não foi possível mostrar este arquivo",
+    none: "Este tipo de arquivo não tem prévia. Abra para ver.",
+    tooBig: "Este arquivo é grande demais para mostrar aqui. Abra para ver.",
+    cut: "Só o começo do arquivo é mostrado.",
+    gone: "Este arquivo não está mais lá.",
+  },
+};
diff --git a/app/src/i18n/pt-BR/index.ts b/app/src/i18n/pt-BR/index.ts
index 583ab402..0a50f8eb 100644
--- a/app/src/i18n/pt-BR/index.ts
+++ b/app/src/i18n/pt-BR/index.ts
@@ -6,6 +6,7 @@ import { bots } from "./bots";
 import { chat } from "./chat";
 import { common } from "./common";
 import { crews } from "./crews";
+import { files } from "./files";
 import { messages } from "./messages";
 import { onboarding } from "./onboarding";
 import { routines } from "./routines";
@@ -21,6 +22,7 @@ export const ptBR: Messages = {
   bots,
   chat,
   crews,
+  files,
   messages,
   routines,
 };
diff --git a/app/src/lib/base64.ts b/app/src/lib/base64.ts
index 8fad5d7d..b5064ada 100644
--- a/app/src/lib/base64.ts
+++ b/app/src/lib/base64.ts
@@ -10,6 +10,16 @@ export function encodeBytes(bytes: Uint8Array): string {
   return btoa(binary);
 }
 
+/** The bytes `base64` stands for. */
+export function decodeBytes(base64: string): Uint8Array<ArrayBuffer> {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let at = 0; at < binary.length; at += 1) {
+    bytes[at] = binary.charCodeAt(at);
+  }
+  return bytes;
+}
+
 /** Bytes that base64 of `length` characters decodes to. */
 export function decodedSize(base64: string): number {
   const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
diff --git a/app/src/lib/fake.ts b/app/src/lib/fake.ts
index 4bee917c..cce2421a 100644
--- a/app/src/lib/fake.ts
+++ b/app/src/lib/fake.ts
@@ -7,6 +7,7 @@ import { botHandlers } from "./fakeBots";
 import { FakeChat } from "./fakeChat";
 import { FakeConversation } from "./fakeConversation";
 import { crewHandlers } from "./fakeCrews";
+import { FakeFiles } from "./fakeFiles";
 import { FakeRoutines } from "./fakeRoutines";
 import { conflict, invalid, notFound, slugify } from "./fakeRules";
 import {
@@ -58,6 +59,7 @@ export class FakeBotloft implements BotloftApi {
   readonly chat = new FakeChat(this);
   readonly conversation = new FakeConversation(this);
   readonly routines = new FakeRoutines(this);
+  readonly files = new FakeFiles(this);
   /** Clock for created and updated times. */
   now = Date.now();
   closed = false;
@@ -208,6 +210,7 @@ export class FakeBotloft implements BotloftApi {
     ...botHandlers(this),
     ...this.chat.handlers(),
     ...this.conversation.handlers(),
+    ...this.files.handlers(),
     ...this.routines.handlers(),
   };
 }
diff --git a/app/src/lib/fakeChat.ts b/app/src/lib/fakeChat.ts
index 0912bb7e..f14f8fec 100644
--- a/app/src/lib/fakeChat.ts
+++ b/app/src/lib/fakeChat.ts
@@ -90,6 +90,7 @@ export class FakeChat {
       input: "{}",
       status: "running",
       output: null,
+      file: null,
       ...changes,
     });
   }
diff --git a/app/src/lib/fakeFiles.ts b/app/src/lib/fakeFiles.ts
new file mode 100644
index 00000000..b491fb75
--- /dev/null
+++ b/app/src/lib/fakeFiles.ts
@@ -0,0 +1,69 @@
+// The fake daemon's files: what a bot made, for the files panel.
+
+import { encodeBytes } from "./base64";
+import type { FakeBotloft, Handlers } from "./fake";
+import { notFound } from "./fakeRules";
+import type { BotFile, BotId, FileData } from "./protocol.gen";
+
+const TYPES: Record<string, string> = {
+  pdf: "application/pdf",
+  png: "image/png",
+  md: "text/markdown",
+  txt: "text/plain",
+  csv: "text/csv",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+};
+
+export class FakeFiles {
+  private readonly files = new Map<BotId, BotFile[]>();
+  private readonly contents = new Map<string, FileData>();
+
+  constructor(private readonly fake: FakeBotloft) {}
+
+  /**
+   * A file the bot made. `text` is what its preview shows; `folder` is
+   * relative to the work folder.
+   */
+  add(
+    botId: BotId,
+    name: string,
+    options: { text?: string; folder?: string; writtenByBot?: boolean; at?: number } = {},
+  ): BotFile {
+    this.fake.bot(botId);
+    const folder = options.folder ?? "";
+    const text = options.text ?? "";
+    const file: BotFile = {
+      path: `C:\\Work\\${folder ? `${folder}\\` : ""}${name}`,
+      name,
+      folder,
+      mediaType: TYPES[name.split(".").at(-1) ?? ""] ?? "application/octet-stream",
+      size: text.length,
+      modifiedAt: options.at ?? this.fake.now,
+      writtenByBot: options.writtenByBot ?? false,
+    };
+    const list = (this.files.get(botId) ?? []).filter((other) => other.path !== file.path);
+    this.files.set(botId, [file, ...list]);
+    this.contents.set(file.path, {
+      mediaType: file.mediaType,
+      data: encodeBytes(new TextEncoder().encode(text)),
+    });
+    return file;
+  }
+
+  handlers(): Pick<Handlers, "files.list" | "files.read"> {
+    return {
+      "files.list": ({ botId }) => {
+        this.fake.bot(botId, false);
+        return [...(this.files.get(botId) ?? [])].sort((a, b) => b.modifiedAt - a.modifiedAt);
+      },
+      "files.read": ({ botId, path }) => {
+        const known = (this.files.get(botId) ?? []).some((file) => file.path === path);
+        const data = this.contents.get(path);
+        if (!known || !data) {
+          throw notFound(`file ${path}`);
+        }
+        return data;
+      },
+    };
+  }
+}
diff --git a/app/src/lib/fakeHost.ts b/app/src/lib/fakeHost.ts
index 957b18d4..0312ea65 100644
--- a/app/src/lib/fakeHost.ts
+++ b/app/src/lib/fakeHost.ts
@@ -23,6 +23,9 @@ export class FakeHost implements Host {
   afterInstall: DaemonStatus | Error = running();
   token: string | Error = "a".repeat(64);
   readonly opened: string[] = [];
+  /** Files opened with their program, and files shown in their folder. */
+  readonly openedFiles: string[] = [];
+  readonly revealed: string[] = [];
   /** What the folder picker gives back; null is a cancel. */
   nextFolder: string | null = null;
   /** Where each folder picker started. */
@@ -93,6 +96,16 @@ export class FakeHost implements Host {
     return Promise.resolve();
   }
 
+  openFile(path: string): Promise<void> {
+    this.openedFiles.push(path);
+    return Promise.resolve();
+  }
+
+  revealFile(path: string): Promise<void> {
+    this.revealed.push(path);
+    return Promise.resolve();
+  }
+
   pickFolder(_title: string, start?: string): Promise<string | null> {
     this.pickerStarts.push(start ?? null);
     return Promise.resolve(this.nextFolder);
diff --git a/app/src/lib/host.ts b/app/src/lib/host.ts
index c41b33b0..de7da2e5 100644
--- a/app/src/lib/host.ts
+++ b/app/src/lib/host.ts
@@ -64,6 +64,10 @@ export interface Host {
   readOwnerToken(): Promise<string>;
   /** Opens a folder in Explorer. */
   openPath(path: string): Promise<void>;
+  /** Opens a document or media file with the program Windows uses for it. */
+  openFile(path: string): Promise<void>;
+  /** Shows a file in its folder, selected. */
+  revealFile(path: string): Promise<void>;
   /**
    * Asks the owner for a folder with Windows' folder picker, starting at
    * `start` if given. Resolves null if they cancel.
diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts
index bbb1d9f4..0ac2262b 100644
--- a/app/src/lib/protocol.gen.ts
+++ b/app/src/lib/protocol.gen.ts
@@ -409,6 +409,59 @@ export type AttachmentData = { mediaType: string,
  */
 data: string, };
 
+/**
+ * A file in the bot's folder or the crew's work folder, or one the bot's
+ * own `Write`/`Edit` calls changed.
+ */
+export type BotFile = { 
+/**
+ * Absolute path.
+ */
+path: string, 
+/**
+ * File name, without folders.
+ */
+name: string, 
+/**
+ * Folder it is in, relative to the work folder or the bot's folder when
+ * it is inside one, else the absolute folder; empty at the top.
+ */
+folder: string, 
+/**
+ * Guessed from the extension.
+ */
+mediaType: string, 
+/**
+ * Bytes.
+ */
+size: number, 
+/**
+ * Unix time in milliseconds.
+ */
+modifiedAt: number, 
+/**
+ * The bot's own `Write`/`Edit` calls changed it, as opposed to a file
+ * that only showed up in the folder.
+ */
+writtenByBot: boolean, };
+
+export type FilesListParams = { botId: BotId, };
+
+export type FilesReadParams = { botId: BotId, 
+/**
+ * A `BotFile.path`.
+ */
+path: string, };
+
+/**
+ * A file's bytes, for the app to preview.
+ */
+export type FileData = { mediaType: string, 
+/**
+ * The file's bytes, base64.
+ */
+data: string, };
+
 /**
  * Text sent to a bot, by the owner, another bot or the daemon.
  */
@@ -552,7 +605,12 @@ input: string, status: ToolStatus,
 /**
  * The start of what the tool returned, cut at 8 KB.
  */
-output: string | null, };
+output: string | null, 
+/**
+ * The full path of the file a `Write`/`Edit`/`NotebookEdit` call
+ * changes; absent for other tools and for items stored before it existed.
+ */
+file: string | null, };
 
 export type ApprovalItem = { approvalId: ApprovalId, toolName: string, summary: string, input: string, status: ApprovalStatus, 
 /**
@@ -746,6 +804,8 @@ export interface RpcMethods {
   "messages.send": { params: MessagesSendParams; result: Message };
   "messages.list": { params: MessagesListParams; result: Array<Message> };
   "attachments.read": { params: AttachmentIdParams; result: AttachmentData };
+  "files.list": { params: FilesListParams; result: Array<BotFile> };
+  "files.read": { params: FilesReadParams; result: FileData };
   "deliveries.list": { params: DeliveriesListParams; result: Array<Delivery> };
   "deliveries.retry": { params: DeliveryIdParams; result: Delivery };
   "tasks.list": { params: TasksListParams; result: Array<Task> };
diff --git a/app/src/lib/tauriHost.ts b/app/src/lib/tauriHost.ts
index 8c61491a..e563ca3b 100644
--- a/app/src/lib/tauriHost.ts
+++ b/app/src/lib/tauriHost.ts
@@ -76,6 +76,8 @@ export function tauriHost(): Host {
     checkForUpdate,
     readOwnerToken: () => invoke<string>("read_owner_token"),
     openPath: (path) => invoke<void>("open_path", { path }),
+    openFile: (path) => invoke<void>("open_file", { path }),
+    revealFile: (path) => invoke<void>("reveal_file", { path }),
     pickFolder: async (title, start) => {
       const picked = await open({
         directory: true,
diff --git a/crates/botloft-core/src/chat.rs b/crates/botloft-core/src/chat.rs
index 779ffcfa..7198445a 100644
--- a/crates/botloft-core/src/chat.rs
+++ b/crates/botloft-core/src/chat.rs
@@ -101,6 +101,15 @@ pub fn tool_summary(name: &str, input: &Value) -> String {
     one_line(&summary.unwrap_or_default(), SUMMARY_MAX_CHARS)
 }
 
+/// The full path of the file a `Write`/`Edit`/`NotebookEdit` call changes.
+pub fn tool_file(name: &str, input: &Value) -> Option<String> {
+    matches!(name, "Edit" | "MultiEdit" | "Write" | "NotebookEdit")
+        .then(|| field(input, "file_path").or_else(|| field(input, "notebook_path")))
+        .flatten()
+        .filter(|path| !path.is_empty() && path.len() <= 1024)
+        .map(str::to_owned)
+}
+
 /// The last part of a path, whichever slash it uses.
 fn file_name(path: &str) -> String {
     path.rsplit(['/', '\\'])
diff --git a/crates/botloft-core/src/protocol/chat.rs b/crates/botloft-core/src/protocol/chat.rs
index f8ac8ad4..092158a8 100644
--- a/crates/botloft-core/src/protocol/chat.rs
+++ b/crates/botloft-core/src/protocol/chat.rs
@@ -121,6 +121,10 @@ pub struct ToolItem {
     pub status: ToolStatus,
     /// The start of what the tool returned, cut at 8 KB.
     pub output: Option<String>,
+    /// The full path of the file a `Write`/`Edit`/`NotebookEdit` call
+    /// changes; absent for other tools and for items stored before it existed.
+    #[serde(default)]
+    pub file: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -259,6 +263,7 @@ mod tests {
             input: "{}".into(),
             status: ToolStatus::Running,
             output: None,
+            file: None,
         });
         let json = serde_json::to_value(&tool).expect("serialize");
         assert_eq!(json["kind"], "tool");
diff --git a/crates/botloft-core/src/protocol/export.rs b/crates/botloft-core/src/protocol/export.rs
index fd20fbef..6dec278d 100644
--- a/crates/botloft-core/src/protocol/export.rs
+++ b/crates/botloft-core/src/protocol/export.rs
@@ -131,6 +131,10 @@ fn export_bindings() {
     out.decl::<AttachmentUpload>();
     out.decl::<AttachmentIdParams>();
     out.decl::<AttachmentData>();
+    out.decl::<BotFile>();
+    out.decl::<FilesListParams>();
+    out.decl::<FilesReadParams>();
+    out.decl::<FileData>();
     out.decl::<Message>();
     out.decl::<Delivery>();
     out.decl::<Task>();
@@ -255,6 +259,16 @@ fn export_bindings() {
         &out.name::<AttachmentIdParams>(),
         &out.name::<AttachmentData>(),
     );
+    out.method(
+        method::FILES_LIST,
+        &out.name::<FilesListParams>(),
+        &out.name::<Vec<BotFile>>(),
+    );
+    out.method(
+        method::FILES_READ,
+        &out.name::<FilesReadParams>(),
+        &out.name::<FileData>(),
+    );
     out.method(
         method::DELIVERIES_LIST,
         &out.name::<DeliveriesListParams>(),
diff --git a/crates/botloft-core/src/protocol/files.rs b/crates/botloft-core/src/protocol/files.rs
new file mode 100644
index 00000000..d529331b
--- /dev/null
+++ b/crates/botloft-core/src/protocol/files.rs
@@ -0,0 +1,64 @@
+//! The files a bot made, for the app's files panel (spec 8.5).
+
+use serde::{Deserialize, Serialize};
+
+use crate::ids::BotId;
+
+/// A file in the bot's folder or the crew's work folder, or one the bot's
+/// own `Write`/`Edit` calls changed.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct BotFile {
+    /// Absolute path.
+    pub path: String,
+    /// File name, without folders.
+    pub name: String,
+    /// Folder it is in, relative to the work folder or the bot's folder when
+    /// it is inside one, else the absolute folder; empty at the top.
+    pub folder: String,
+    /// Guessed from the extension.
+    pub media_type: String,
+    /// Bytes.
+    pub size: u64,
+    /// Unix time in milliseconds.
+    pub modified_at: i64,
+    /// The bot's own `Write`/`Edit` calls changed it, as opposed to a file
+    /// that only showed up in the folder.
+    pub written_by_bot: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct FilesListParams {
+    pub bot_id: BotId,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct FilesReadParams {
+    pub bot_id: BotId,
+    /// A `BotFile.path`.
+    pub path: String,
+}
+
+/// A file's bytes, for the app to preview.
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct FileData {
+    pub media_type: String,
+    /// The file's bytes, base64.
+    pub data: String,
+}
+
+impl std::fmt::Debug for FileData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FileData")
+            .field("media_type", &self.media_type)
+            .field("data", &format_args!("<{} base64 chars>", self.data.len()))
+            .finish()
+    }
+}
diff --git a/crates/botloft-core/src/protocol/mod.rs b/crates/botloft-core/src/protocol/mod.rs
index 6d4b3a95..bf2a9360 100644
--- a/crates/botloft-core/src/protocol/mod.rs
+++ b/crates/botloft-core/src/protocol/mod.rs
@@ -52,12 +52,14 @@ macro_rules! text_enum {
 mod chat;
 #[cfg(test)]
 mod export;
+mod files;
 mod messaging;
 mod methods;
 mod model;
 mod routines;
 
 pub use chat::*;
+pub use files::*;
 pub use messaging::*;
 pub use methods::*;
 pub use model::*;
@@ -92,6 +94,8 @@ pub mod method {
     pub const MESSAGES_SEND: &str = "messages.send";
     pub const MESSAGES_LIST: &str = "messages.list";
     pub const ATTACHMENTS_READ: &str = "attachments.read";
+    pub const FILES_LIST: &str = "files.list";
+    pub const FILES_READ: &str = "files.read";
     pub const DELIVERIES_LIST: &str = "deliveries.list";
     pub const DELIVERIES_RETRY: &str = "deliveries.retry";
     pub const TASKS_LIST: &str = "tasks.list";
diff --git a/crates/botloft-store/src/chat.rs b/crates/botloft-store/src/chat.rs
index c07099ad..7a81257b 100644
--- a/crates/botloft-store/src/chat.rs
+++ b/crates/botloft-store/src/chat.rs
@@ -131,6 +131,21 @@ impl Store {
             .optional()?)
     }
 
+    /// Paths of the files the bot's `Write`/`Edit` calls changed, newest
+    /// first and without repeats; failed calls do not count.
+    pub fn written_files(&self, bot: &BotId, limit: u32) -> Result<Vec<String>> {
+        let mut stmt = self.conn.prepare(
+            "SELECT json_extract(data, '$.file') FROM chat_items \
+             WHERE bot_id = ?1 AND kind = 'tool' \
+               AND json_extract(data, '$.file') IS NOT NULL \
+               AND json_extract(data, '$.status') != 'failed' \
+             GROUP BY json_extract(data, '$.file') \
+             ORDER BY MAX(rowid) DESC LIMIT ?2",
+        )?;
+        let rows = stmt.query_map(params![bot.as_str(), limit], |row| row.get(0))?;
+        Ok(rows.collect::<rusqlite::Result<_>>()?)
+    }
+
     /// The conversation-list line: the newest item that has one.
     pub fn last_activity(&self, bot: &BotId) -> Result<Option<Activity>> {
         let mut stmt = self.conn.prepare(&format!(
@@ -208,6 +223,7 @@ mod tests {
             input: "{}".into(),
             status: ToolStatus::Running,
             output: None,
+            file: None,
         };
         let entry = item(bot, ChatBody::Tool(running.clone()), 5);
         fx.store.insert_chat_item(&entry).expect("insert");
@@ -235,6 +251,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn written_files_come_newest_first_without_repeats_or_failures() {
+        let fx = Fixture::new();
+        let bot = &fx.bots[0].id;
+        let write = |file: Option<&str>, status: ToolStatus| {
+            ChatBody::Tool(ToolItem {
+                tool_use_id: "t".into(),
+                name: "Write".into(),
+                summary: String::new(),
+                input: "{}".into(),
+                status,
+                output: None,
+                file: file.map(str::to_owned),
+            })
+        };
+        for (n, (file, status)) in [
+            (Some(r"C:\work\a.md"), ToolStatus::Done),
+            (Some(r"C:\work\b.pdf"), ToolStatus::Done),
+            (Some(r"C:\work\bad.md"), ToolStatus::Failed),
+            (None, ToolStatus::Done),
+            (Some(r"C:\work\a.md"), ToolStatus::Done),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            fx.store
+                .insert_chat_item(&item(bot, write(file, status), n as i64))
+                .expect("insert");
+        }
+        let files = fx.store.written_files(bot, 10).expect("files");
+        assert_eq!(files, [r"C:\work\a.md", r"C:\work\b.pdf"]);
+        assert_eq!(
+            fx.store.written_files(bot, 1).expect("one"),
+            [r"C:\work\a.md"]
+        );
+    }
+
     #[test]
     fn the_last_activity_skips_turn_ends() {
         let fx = Fixture::new();
diff --git a/crates/botloftd/src/chat/events.rs b/crates/botloftd/src/chat/events.rs
index 1001380b..be6a088d 100644
--- a/crates/botloftd/src/chat/events.rs
+++ b/crates/botloftd/src/chat/events.rs
@@ -2,7 +2,7 @@
 //! (spec 8.1). Fields are read defensively: the format is not documented
 //! and grows between Claude Code versions.
 
-use botloft_core::chat::{TOOL_OUTPUT_MAX, clip, tool_input_max, tool_summary};
+use botloft_core::chat::{TOOL_OUTPUT_MAX, clip, tool_file, tool_input_max, tool_summary};
 use botloft_core::ids::BotId;
 use botloft_core::protocol::{
     AccountUsage, ChatBody, ChatDelta, NoticeCode, NoticeItem, NoticeLevel, ReplyItem, ToolItem,
@@ -144,6 +144,7 @@ fn assistant(daemon: &Daemon, bot: &BotId, generation: u64, event: &Value) {
                         input: clip(&input.to_string(), tool_input_max(name)),
                         status: ToolStatus::Running,
                         output: None,
+                        file: tool_file(name, input),
                     }),
                 );
             }
diff --git a/crates/botloftd/src/rpc/dispatch.rs b/crates/botloftd/src/rpc/dispatch.rs
index 2f25c020..346ef47d 100644
--- a/crates/botloftd/src/rpc/dispatch.rs
+++ b/crates/botloftd/src/rpc/dispatch.rs
@@ -8,8 +8,8 @@ use serde_json::Value;
 use super::jsonrpc::{RpcError, empty_params};
 use crate::approvals;
 use crate::service::{
-    self, ApiResult, attachments, bots, chat, crews, deliveries, lead, messages, models, modes,
-    routines, tasks,
+    self, ApiResult, attachments, bots, chat, crews, deliveries, files, lead, messages, models,
+    modes, routines, tasks,
 };
 use crate::state::Daemon;
 
@@ -43,6 +43,8 @@ pub fn dispatch(daemon: &Daemon, name: &str, params: Option<Value>) -> Result<Va
         method::MESSAGES_SEND => reply(messages::send(daemon, parse(params)?)),
         method::MESSAGES_LIST => reply(messages::list(daemon, parse(params)?)),
         method::ATTACHMENTS_READ => reply(attachments::read(daemon, parse(params)?)),
+        method::FILES_LIST => reply(files::list(daemon, parse(params)?)),
+        method::FILES_READ => reply(files::read(daemon, parse(params)?)),
         method::DELIVERIES_LIST => reply(deliveries::list(daemon, parse(params)?)),
         method::DELIVERIES_RETRY => reply(deliveries::retry(daemon, parse(params)?)),
         method::ROUTINES_LIST => reply(routines::list(daemon, parse(params)?)),
diff --git a/crates/botloftd/src/service/files/mod.rs b/crates/botloftd/src/service/files/mod.rs
new file mode 100644
index 00000000..b965fed7
--- /dev/null
+++ b/crates/botloftd/src/service/files/mod.rs
@@ -0,0 +1,161 @@
+//! The files a bot made (spec 8.5): what the app's files panel lists and
+//! previews. They are in the crew's work folder or the bot's own folder, or
+//! wherever the bot's `Write`/`Edit` calls put them.
+
+mod scan;
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use base64::Engine as _;
+use base64::engine::general_purpose::STANDARD as BASE64;
+use botloft_core::ids::BotId;
+use botloft_core::protocol::{BotFile, FileData, FilesListParams, FilesReadParams};
+use botloft_store::BotRecord;
+
+use self::scan::{Found, Root, key, keys, media_type, millis, walk};
+use super::{ApiError, ApiResult, bots, crews};
+use crate::state::Daemon;
+
+/// The newest files listed; the rest are older than anything the owner wants.
+const LIST_MAX: usize = 200;
+/// How many of the bot's own writes are looked up.
+const WRITTEN_MAX: u32 = 200;
+/// Largest file the app previews: base64 of it must fit a 32 MiB frame.
+const PREVIEW_MAX_BYTES: u64 = 20 * 1024 * 1024;
+/// Generated for the bot by the daemon: not something it made for the owner.
+const WORKSPACE_SKIP: [&str; 2] = ["attachments", "CLAUDE.md"];
+
+/// Where a bot's files live, and what it wrote by name.
+struct Places {
+    work: PathBuf,
+    workspace: PathBuf,
+    written: Vec<String>,
+}
+
+fn places(daemon: &Daemon, bot_id: &BotId) -> ApiResult<(BotRecord, Places)> {
+    let store = daemon.store();
+    let bot = bots::find(&store, bot_id)?;
+    let crew = crews::find(&store, &bot.crew_id)?;
+    let written = store.written_files(&bot.id, WRITTEN_MAX)?;
+    drop(store);
+    let places = Places {
+        work: daemon.paths.work_folder(&crew),
+        workspace: daemon.paths.bot_workspace(&crew.slug, &bot.slug),
+        written,
+    };
+    Ok((bot, places))
+}
+
+/// `files.list`: the files in the work folder and the bot's folder that are
+/// newer than the bot, plus every file its `Write`/`Edit` calls changed that
+/// still exists. Newest first.
+pub fn list(daemon: &Daemon, params: FilesListParams) -> ApiResult<Vec<BotFile>> {
+    let (bot, places) = places(daemon, &params.bot_id)?;
+    let written = keys(&places.written);
+    let roots = [
+        Root {
+            path: &places.work,
+            skip_top: &[],
+        },
+        Root {
+            path: &places.workspace,
+            skip_top: &WORKSPACE_SKIP,
+        },
+    ];
+    let mut found: HashMap<String, Found> = HashMap::new();
+    for root in &roots {
+        for file in walk(root, bot.created_at) {
+            found.insert(key(&file.path), file);
+        }
+    }
+    for path in &places.written {
+        let path = PathBuf::from(path);
+        if let Ok(meta) = std::fs::metadata(&path)
+            && meta.is_file()
+        {
+            found.entry(key(&path)).or_insert_with(|| Found {
+                size: meta.len(),
+                modified_at: millis(&meta),
+                path,
+            });
+        }
+    }
+    let folders = [places.work.as_path(), places.workspace.as_path()];
+    let mut files: Vec<BotFile> = found
+        .into_iter()
+        .map(|(id, file)| describe(file, written.contains(&id), &folders))
+        .collect();
+    files.sort_by(|a, b| {
+        b.modified_at
+            .cmp(&a.modified_at)
+            .then_with(|| a.path.cmp(&b.path))
+    });
+    files.truncate(LIST_MAX);
+    Ok(files)
+}
+
+fn describe(file: Found, written_by_bot: bool, roots: &[&Path]) -> BotFile {
+    let name = file_name(&file.path);
+    let parent = file.path.parent().unwrap_or(Path::new(""));
+    let folder = roots
+        .iter()
+        .find_map(|root| parent.strip_prefix(root).ok())
+        .unwrap_or(parent)
+        .to_string_lossy()
+        .into_owned();
+    BotFile {
+        media_type: media_type(&name).to_owned(),
+        path: file.path.to_string_lossy().into_owned(),
+        name,
+        folder,
+        size: file.size,
+        modified_at: file.modified_at,
+        written_by_bot,
+    }
+}
+
+fn file_name(path: &Path) -> String {
+    path.file_name()
+        .map_or_else(String::new, |name| name.to_string_lossy().into_owned())
+}
+
+/// `files.read`: the bytes of a file `files.list` can show. A path outside
+/// the bot's folders that the bot did not write is refused, so the panel
+/// cannot be used to read anything else on the computer.
+pub fn read(daemon: &Daemon, params: FilesReadParams) -> ApiResult<FileData> {
+    let (_, places) = places(daemon, &params.bot_id)?;
+    let asked = PathBuf::from(&params.path);
+    let gone = || ApiError::NotFound(format!("{} is no longer there", params.path));
+    let path = asked.canonicalize().map_err(|_| gone())?;
+    let inside = [&places.work, &places.workspace]
+        .into_iter()
+        .filter_map(|root| root.canonicalize().ok())
+        .any(|root| path.starts_with(root));
+    let written = places
+        .written
+        .iter()
+        .filter_map(|file| Path::new(file).canonicalize().ok())
+        .any(|file| file == path);
+    if !asked.is_absolute() || !(inside || written) {
+        return Err(ApiError::NotFound(format!(
+            "{} is not one of this bot's files",
+            params.path
+        )));
+    }
+    let meta = std::fs::metadata(&path).map_err(|_| gone())?;
+    if !meta.is_file() {
+        return Err(gone());
+    }
+    if meta.len() > PREVIEW_MAX_BYTES {
+        return Err(ApiError::validation(format!(
+            "the file is larger than {} MB",
+            PREVIEW_MAX_BYTES / (1024 * 1024)
+        )));
+    }
+    let bytes = std::fs::read(&path).map_err(|_| gone())?;
+    Ok(FileData {
+        media_type: media_type(&file_name(&path)).to_owned(),
+        data: BASE64.encode(bytes),
+    })
+}
diff --git a/crates/botloftd/src/service/files/scan.rs b/crates/botloftd/src/service/files/scan.rs
new file mode 100644
index 00000000..200cdbe5
--- /dev/null
+++ b/crates/botloftd/src/service/files/scan.rs
@@ -0,0 +1,184 @@
+//! Walking a folder for the files a bot made (spec 8.5): bounded, so a work
+//! folder as big as `Documents` costs little, and never through links.
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::time::UNIX_EPOCH;
+
+/// Folders below the top that are never files a bot made for the owner.
+const SKIP_DIRS: [&str; 5] = [
+    "node_modules",
+    "target",
+    "__pycache__",
+    "venv",
+    "site-packages",
+];
+const MAX_DEPTH: usize = 6;
+const MAX_VISITED: usize = 20_000;
+
+/// A file found: its path, size and modification time (Unix ms).
+pub(super) struct Found {
+    pub path: PathBuf,
+    pub size: u64,
+    pub modified_at: i64,
+}
+
+/// What to leave out at the top of a root: the workspace holds the rules and
+/// memory the daemon writes and the files the owner sent.
+pub(super) struct Root<'a> {
+    pub path: &'a Path,
+    pub skip_top: &'a [&'a str],
+}
+
+/// Files below `root` modified at or after `since` (Unix ms), in no order.
+/// Hidden entries, links and generated folders are left out.
+pub(super) fn walk(root: &Root<'_>, since: i64) -> Vec<Found> {
+    let mut found = Vec::new();
+    let mut seen = 0;
+    let mut pending = vec![(root.path.to_path_buf(), 0)];
+    while let Some((dir, depth)) = pending.pop() {
+        let Ok(entries) = std::fs::read_dir(&dir) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            seen += 1;
+            if seen > MAX_VISITED {
+                return found;
+            }
+            let name = entry.file_name().to_string_lossy().into_owned();
+            let left_out = depth == 0 && root.skip_top.contains(&name.as_str());
+            if name.starts_with('.') || name.starts_with("~$") || left_out {
+                continue;
+            }
+            // `DirEntry::metadata` does not follow links.
+            let Ok(meta) = entry.metadata() else { continue };
+            if meta.file_type().is_symlink() {
+                continue;
+            }
+            if meta.is_dir() {
+                if depth < MAX_DEPTH && !SKIP_DIRS.contains(&name.as_str()) {
+                    pending.push((entry.path(), depth + 1));
+                }
+            } else if meta.is_file() {
+                let modified_at = millis(&meta);
+                if modified_at >= since {
+                    found.push(Found {
+                        path: entry.path(),
+                        size: meta.len(),
+                        modified_at,
+                    });
+                }
+            }
+        }
+    }
+    found
+}
+
+/// Modification time of `meta` in Unix milliseconds.
+pub(super) fn millis(meta: &std::fs::Metadata) -> i64 {
+    meta.modified()
+        .ok()
+        .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
+        .map_or(0, |since| {
+            i64::try_from(since.as_millis()).unwrap_or(i64::MAX)
+        })
+}
+
+/// One key for a path however it is spelled: Windows paths do not care about
+/// case or the direction of slashes.
+pub(super) fn key(path: &Path) -> String {
+    let text = path.to_string_lossy().replace('\\', "/");
+    if cfg!(windows) {
+        text.to_lowercase()
+    } else {
+        text
+    }
+}
+
+/// The paths of `files` as keys, to ask "did the bot write this?".
+pub(super) fn keys(files: &[String]) -> HashSet<String> {
+    files.iter().map(|file| key(Path::new(file))).collect()
+}
+
+/// The media type for a file name, by extension.
+pub(super) fn media_type(name: &str) -> &'static str {
+    let extension = name
+        .rsplit_once('.')
+        .map(|(_, extension)| extension.to_ascii_lowercase())
+        .unwrap_or_default();
+    match extension.as_str() {
+        "pdf" => "application/pdf",
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
+        "gif" => "image/gif",
+        "webp" => "image/webp",
+        "svg" => "image/svg+xml",
+        "txt" | "log" => "text/plain",
+        "md" | "markdown" => "text/markdown",
+        "csv" => "text/csv",
+        "html" | "htm" => "text/html",
+        "json" => "application/json",
+        "xml" => "application/xml",
+        "yml" | "yaml" => "application/yaml",
+        "docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "zip" => "application/zip",
+        "mp3" => "audio/mpeg",
+        "wav" => "audio/wav",
+        "mp4" => "video/mp4",
+        // Source and config files read as text.
+        "rs" | "ts" | "tsx" | "js" | "jsx" | "py" | "css" | "toml" | "ini" | "sql" | "sh"
+        | "ps1" | "bat" | "java" | "go" | "c" | "h" | "cpp" | "cs" | "rb" | "php" => "text/plain",
+        _ => "application/octet-stream",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extensions_give_media_types() {
+        assert_eq!(media_type("Report.PDF"), "application/pdf");
+        assert_eq!(media_type("notes.md"), "text/markdown");
+        assert_eq!(media_type("script.ps1"), "text/plain");
+        assert_eq!(media_type("noextension"), "application/octet-stream");
+    }
+
+    #[test]
+    fn a_walk_skips_hidden_generated_and_top_level_leftovers() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let root = dir.path();
+        for file in [
+            "a.md",
+            "sub/deep/b.pdf",
+            ".hidden.txt",
+            ".git/config",
+            "node_modules/x.js",
+            "attachments/2026-01-01/mine.png",
+            "CLAUDE.md",
+            "~$lock.docx",
+        ] {
+            let path = root.join(file);
+            std::fs::create_dir_all(path.parent().expect("parent")).expect("dirs");
+            std::fs::write(path, "x").expect("write");
+        }
+        let skip = ["attachments", "CLAUDE.md"];
+        let top = Root {
+            path: root,
+            skip_top: &skip,
+        };
+        let mut names: Vec<_> = walk(&top, 0)
+            .into_iter()
+            .map(|file| key(file.path.strip_prefix(root).expect("inside")))
+            .collect();
+        names.sort();
+        assert_eq!(names, ["a.md", "sub/deep/b.pdf"]);
+        let all = Root {
+            path: root,
+            skip_top: &[],
+        };
+        assert!(walk(&all, i64::MAX).is_empty(), "nothing is that new");
+    }
+}
diff --git a/crates/botloftd/src/service/mod.rs b/crates/botloftd/src/service/mod.rs
index 8120a9c0..f2acf3a2 100644
--- a/crates/botloftd/src/service/mod.rs
+++ b/crates/botloftd/src/service/mod.rs
@@ -6,6 +6,7 @@ pub mod bots;
 pub mod chat;
 pub mod crews;
 pub mod deliveries;
+pub mod files;
 pub mod lead;
 pub mod messages;
 pub mod models;
diff --git a/crates/botloftd/tests/files.rs b/crates/botloftd/tests/files.rs
new file mode 100644
index 00000000..9557e379
--- /dev/null
+++ b/crates/botloftd/tests/files.rs
@@ -0,0 +1,130 @@
+//! The files a bot made (spec 8.5): listed for the app's panel and read for
+//! its preview, without opening the rest of the computer.
+
+mod common;
+
+use std::fs;
+use std::path::Path;
+use std::time::{Duration, SystemTime};
+
+use base64::Engine as _;
+use base64::engine::general_purpose::STANDARD as BASE64;
+use botloft_core::protocol::BotState;
+use common::{TestDaemon, stream};
+use serde_json::{Value, json};
+
+const NOT_FOUND: i64 = -32002;
+
+fn put(path: &Path, text: &str) {
+    fs::create_dir_all(path.parent().expect("parent")).expect("dirs");
+    fs::write(path, text).expect("write");
+}
+
+fn names(files: &Value) -> Vec<String> {
+    let mut names: Vec<String> = files
+        .as_array()
+        .expect("list")
+        .iter()
+        .map(|file| file["name"].as_str().expect("name").to_owned())
+        .collect();
+    names.sort();
+    names
+}
+
+#[tokio::test]
+async fn the_panel_lists_and_reads_what_the_bot_made() {
+    let t = TestDaemon::start_supervised().await;
+    let mut app = t.session().await;
+    let crew = app
+        .call("crews.create", json!({ "name": "Ops" }))
+        .await
+        .expect("crew");
+    let bot = json!({ "crewId": crew["id"], "name": "Scout", "role": "", "instructions": "" });
+    let bot = app.call("bots.create", bot).await.expect("bot");
+    t.until_state(&bot, BotState::Idle).await;
+    let process = t.process_of(&bot).await;
+
+    let workspace = std::path::PathBuf::from(bot["workspace"].as_str().expect("workspace"));
+    let work = workspace.parent().expect("crew folder").join("shared");
+    put(&work.join("report.pdf"), "pdf");
+    put(&work.join("notes/a.md"), "# notes");
+    put(&work.join(".hidden"), "x");
+    put(&workspace.join("CLAUDE.md"), "memory");
+    put(&workspace.join("attachments/2026-01-01/sent.png"), "png");
+    // Older than the bot: the owner's own file, not something it made.
+    put(&work.join("old.txt"), "old");
+    let hour_ago = SystemTime::now() - Duration::from_secs(3600);
+    fs::File::options()
+        .write(true)
+        .open(work.join("old.txt"))
+        .expect("open")
+        .set_modified(hour_ago)
+        .expect("set mtime");
+
+    // The bot writes a file far from its folders; another one it never touched.
+    let elsewhere = tempfile::tempdir().expect("tempdir");
+    put(&elsewhere.path().join("made.txt"), "made");
+    put(&elsewhere.path().join("private.txt"), "private");
+    let made = elsewhere.path().join("made.txt");
+    let input = json!({ "file_path": made, "content": "made" });
+    process
+        .emit(stream::tool_use("toolu_1", "Write", input))
+        .await;
+
+    let list = json!({ "botId": bot["id"] });
+    let mut files = Value::Null;
+    for _ in 0..100 {
+        files = app.call("files.list", list.clone()).await.expect("list");
+        if names(&files).contains(&"made.txt".to_owned()) {
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    assert_eq!(names(&files), ["a.md", "made.txt", "report.pdf"]);
+    let made_entry = files
+        .as_array()
+        .expect("list")
+        .iter()
+        .find(|file| file["name"] == "made.txt")
+        .expect("made");
+    assert_eq!(made_entry["writtenByBot"], true);
+    let notes = files
+        .as_array()
+        .expect("list")
+        .iter()
+        .find(|file| file["name"] == "a.md")
+        .expect("notes");
+    assert_eq!(notes["folder"], "notes");
+    assert_eq!(notes["mediaType"], "text/markdown");
+    assert_eq!(notes["writtenByBot"], false);
+
+    let read = |path: &Path| json!({ "botId": bot["id"], "path": path });
+    let pdf = app
+        .call("files.read", read(&work.join("report.pdf")))
+        .await
+        .expect("read");
+    assert_eq!(
+        pdf,
+        json!({ "mediaType": "application/pdf", "data": BASE64.encode(b"pdf") })
+    );
+    app.call("files.read", read(&made)).await.expect("written");
+
+    // Nothing else on the computer opens through the panel.
+    let private = elsewhere.path().join("private.txt");
+    // Two levels up from the work folder is the folder of every crew.
+    put(&work.join("..").join("..").join("secret.txt"), "secret");
+    let climbing = work.join("..").join("..").join("secret.txt");
+    for refused in [
+        private,
+        climbing,
+        Path::new("report.pdf").to_path_buf(),
+        work.join("missing.txt"),
+        work.join("notes"),
+    ] {
+        let err = app
+            .call("files.read", read(&refused))
+            .await
+            .expect_err(&format!("{} is refused", refused.display()));
+        assert_eq!(err.code, NOT_FOUND, "{}", refused.display());
+    }
+}
diff --git a/docs/spec.md b/docs/spec.md
index a8417815..80df2a09 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -287,7 +287,7 @@ Todo item tem `id` (`cht_`), `botId`, `kind`, `createdAt` e `updatedAt`.
 |---|---|---|
 | `inbound` | `message` (a `Message`, com anexos) | criado junto com a message para o bot: dono, outro bot ou daemon |
 | `reply` | `text` | texto do bot |
-| `tool` | `toolUseId`, `name`, `summary`, `input`, `status` (`running`, `done`, `failed`), `output` | ferramenta usada pelo bot |
+| `tool` | `toolUseId`, `name`, `summary`, `input`, `status` (`running`, `done`, `failed`), `output`, `file` | ferramenta usada pelo bot; `file` é o caminho completo que uma chamada de `Write`, `Edit`, `MultiEdit` ou `NotebookEdit` altera (ausente nas outras e nos itens antigos) |
 | `approval` | `approvalId`, `toolName`, `summary`, `input`, `status` (`pending`, `allowed`, `denied`, `expired`), `note` | pedido de permissão (10.1) |
 | `turn` | `durationMs`, `costUsd`, `error` | fim de um turno |
 | `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`, `model_unavailable`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro |
@@ -302,7 +302,16 @@ Todo item tem `id` (`cht_`), `botId`, `kind`, `createdAt` e `updatedAt`.
 - `chat.item {item, activity}`: item novo ou atualizado (tool que terminou, aprovação respondida). `activity` é a nova linha da conversa na barra lateral, quando mudou.
 - `chat.delta {botId, text}`: pedaço do texto que o bot está escrevendo, na ordem. O app junta os pedaços num balão provisório, trocado pelo `reply` quando ele chega. Um app que conecta no meio de um turno não vê o texto parcial já passado, só o que vier depois e o `reply` final.
 
-### 8.4 Privacidade
+### 8.4 Arquivos do bot
+
+O app mostra os arquivos que o bot fez num painel ao lado do chat (15.1). O daemon os acha de duas maneiras, porque um script ou comando (um PDF gerado por um `PowerShell`, por exemplo) não diz o que criou:
+
+- **Pastas:** a pasta de trabalho da crew e a pasta do bot (5), percorridas com limites: até 6 níveis, 20 mil entradas vistas, sem links, sem entradas ocultas (`.`, `~$`) nem pastas geradas (`node_modules`, `target`, `__pycache__`, `venv`, `site-packages`). Na pasta do bot ficam de fora `CLAUDE.md` e `attachments\` (o que o daemon escreve e o que o dono mandou). Só entra arquivo alterado **depois de o bot ser criado**: o que já existia na pasta escolhida pelo dono não é do bot.
+- **Chamadas do bot:** os caminhos dos itens `tool` com `file` (8.2), mesmo fora dessas pastas, se o arquivo ainda existe. Esses vêm com `writtenByBot`.
+
+`files.list {botId}` devolve até 200 `BotFile` (`path`, `name`, `folder` relativa à pasta de trabalho ou à do bot, `mediaType` pela extensão, `size`, `modifiedAt`, `writtenByBot`), do mais novo para o mais antigo. `files.read {botId, path}` devolve `{mediaType, data}` (base64) de um arquivo que a lista poderia mostrar: dentro de uma das duas pastas ou escrito pelo bot. Qualquer outro caminho, relativo ou que suba de pasta dá `not_found`, para o painel não ler o resto do computador. Acima de 20 MiB dá `validation`. Nenhum caminho nem conteúdo vai para o log em `info` ou acima (8.5).
+
+### 8.5 Privacidade
 
 Itens do chat são dado pessoal como o corpo das messages: nunca vão para o log em nível `info` ou acima. O log de `debug` registra só tipos de evento e ids.
 
@@ -477,6 +486,8 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co
 | `messages.send` | `botId, body, attachments?` (`[{name, mediaType, data}]`, data em base64) | `Message` |
 | `messages.list` | `crewId?, botId?, before?, limit?` | `Message[]` |
 | `attachments.read` | `attachmentId` | `{mediaType, data}`, data em base64 (9.5) |
+| `files.list` | `botId` | `BotFile[]`: os arquivos que o bot fez, do mais novo ao mais antigo (8.4) |
+| `files.read` | `botId, path` | `{mediaType, data}`, data em base64, de um arquivo da lista (8.4) |
 | `deliveries.list` | `state?, botId?` | `Delivery[]` |
 | `deliveries.retry` | `deliveryId` | `Delivery` |
 | `tasks.list` | `crewId?, status?` | `Task[]` |
@@ -560,6 +571,7 @@ app/src/
     crews/        lista, criar, renomear, pausar; página da crew com timeline e tasks
     bots/         conversas na barra lateral, criar, editar, estado, detalhes
     chat/         conversa com o bot: itens, texto ao vivo, aprovações, compositor com anexos
+    files/        painel dos arquivos que o bot fez: lista, prévia, abrir
     messages/     timeline da crew, estado de entrega, deliveries com falha (botão na barra de título, retry)
     tasks/        tarefas da crew (abertas por padrão, todas sob demanda)
     settings/
@@ -596,6 +608,7 @@ Layout, como um app de mensagens:
 - **Chefe:** uma coroa ao lado do nome na barra lateral e nos cartões da crew, e "Chefe" no cabeçalho do bot, com a dica "Lidera <crew>: planeja o trabalho e sugere bots novos". O menu do bot tem "Tornar chefe da equipe" ou "Deixar de ser chefe".
 - **Sugestão de bot** (10.2): um cartão no chat do chefe, "<chefe> sugere um bot novo", com o porquê e os campos editáveis Nome, Modelo, Função e Instruções, a linha de que o bot começa na hora e recebe o trabalho do chefe, um campo para dizer ao chefe por que não, e os botões Criar bot e Agora não. Respondido, vira uma linha ("Você criou Designer", "Você recusou Designer") que abre o que foi sugerido.
 - **Detalhes do bot** (pasta, instruções, sessão) ficam num painel, fora do caminho da conversa.
+- **Arquivos do bot** (8.4): um botão "Mostrar arquivos" no cabeçalho abre, à direita do chat, um painel com o que o bot fez, do mais novo ao mais antigo (ícone pelo tipo, nome, pasta, tamanho, "há 5 min"). Um clique mostra o arquivo no próprio painel: imagem, PDF, markdown e texto aparecem; o resto diz que não tem prévia. "Abrir" usa o programa que o Windows escolheu e "Mostrar na pasta" abre o Explorer com o arquivo marcado. A lista é lida ao abrir o bot, a cada 4 s enquanto ele trabalha e de novo quando ele para. Com o painel fechado, o botão ganha um contador dos arquivos que apareceram desde a última vez que o dono olhou; abertos, esses levam a etiqueta "Novo". Detalhes e arquivos dividem o mesmo lugar: abrir um fecha o outro.
 
 ### 15.2 Comandos Tauri
 
@@ -608,10 +621,12 @@ Layout, como um app de mensagens:
 | `read_owner_token` | lê `secrets\owner.token` (só no app local) |
 | `open_path` | abre uma pasta no Explorer; recusa arquivos, que o Explorer executaria |
 | seletor de pastas | não é comando próprio: o app usa o `tauri-plugin-dialog` (`open({directory: true})`, permissão `dialog:allow-open`) para a pasta de trabalho da crew (5) |
+| `open_file` | abre um arquivo do bot com o programa que o Windows usa para ele (`explorer.exe <arquivo>`). Só extensões de documento, imagem, som e vídeo (`pdf`, `png`, `md`, `docx`, `xlsx`, `mp4`...); qualquer outra, como `.exe`, `.bat`, `.ps1` ou `.lnk`, é recusada, porque o Explorer a executaria |
+| `reveal_file` | abre o Explorer na pasta do arquivo, com ele marcado (`/select,`). Nada é executado |
 | `open_url` | abre no navegador padrão um link de uma resposta do bot; só `http` e `https`, porque qualquer outro esquema pode iniciar um programa. Seguir o link dentro do app trocaria a janela pela página |
 | overlay na taskbar | não é comando próprio: o app usa `setOverlayIcon` da janela (permissão `core:window:allow-set-overlay-icon`) e marca o ícone com um ponto enquanto algo espera o dono: aprovação pendente, bot em `auth_error`, ou mensagem não entregue a um bot ativo. Entregas mortas para bot arquivado não contam: foram abandonadas de propósito |
 
-O app acha o daemon como o daemon acha a si mesmo (seção 5): `BOTLOFT_HOME` ou `%LOCALAPPDATA%\Botloft`, com a porta lida do `config.toml` dessa pasta (45710 se ausente). Um daemon de dev com seu próprio `BOTLOFT_HOME` é encontrado sem configuração extra. A CSP libera `ws://127.0.0.1:*` pelo mesmo motivo.
+O app acha o daemon como o daemon acha a si mesmo (seção 5): `BOTLOFT_HOME` ou `%LOCALAPPDATA%\Botloft`, com a porta lida do `config.toml` dessa pasta (45710 se ausente). Um daemon de dev com seu próprio `BOTLOFT_HOME` é encontrado sem configuração extra. A CSP libera `ws://127.0.0.1:*` pelo mesmo motivo, e `blob:` para a imagem e o PDF da prévia de arquivos (15.1).
 
 Onboarding (M5): **configuração sem perguntas e sem jargão.** O dono não precisa saber que existe um daemon, uma porta ou uma tarefa agendada; a interface nunca usa essas palavras. Fala de "Botloft" e de "rodar em segundo plano", e o texto técnico (erro do daemon, caminho, porta) fica dobrado sob "Details".
 
@@ -735,6 +750,7 @@ Conferência na documentação oficial (code.claude.com/docs) em 2026-09-28. "Co
 | `--add-dir` em `-p` | 5, 7.4 | Confirmado (`cli-reference`, `memory`): pastas a mais que o Claude Code trata como de trabalho; o `CLAUDE.md` delas só carrega com `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`. **Testado com 2.1.284** (`--setting-sources project,local`, `acceptEdits`): com a flag e a variável, o bot citou o `CLAUDE.md` da pasta sem abrir arquivo e gravou nela sem pedir; sem a flag, o `Write` na mesma pasta foi negado (`permission_denials`). A flag aceita vários valores: a linha de comando do daemon não tem prompt posicional, então nada é engolido | feito |
 | Chefe e `suggest_bot` com o Claude Code real | 10.2 | **Testado com 2.1.284** (daemon e app de dev): a crew criada pelo app subiu o chefe com `--model sonnet` e `--add-dir` na pasta da crew. Pedido um site, o chefe carregou `crew_roster`, `suggest_bot` e `send_message` pelo `ToolSearch` e sugeriu um Designer com papel, instruções, modelo e porquê; a chamada esperou o cartão. Com o modelo trocado para `haiku` no cartão, o bot subiu com `--model haiku`, e o chefe citou a troca. O chefe mandou uma task, o Designer entregou com `complete_task`, e o chefe conferiu o resultado e corrigiu o HTML. O log de `debug` não teve texto de mensagem | feito |
 | Rotinas com o Claude Code real | 20 | **Testado com 2.1.284** (daemon e app de dev): uma rotina "a cada 5 minutos" criada pelo app, num chefe em Haiku, rodou às 09:10 e às 09:15, contadas a partir da criação; cada message chegou com o envelope da rotina, apareceu no chat com "Rotina · <nome>" e fechou como `done` com o `result` do turno. Desligada, não rodou às 09:20. O log de `debug` só teve ids | feito |
+| Prévia de PDF no painel de arquivos | 15.1 | O PDF vai para um `<iframe src="blob:...">` (a CSP libera `frame-src blob:`). Não visto no WebView2 do app: no navegador de dev o painel funciona com imagem, markdown e texto | manual (PR): abrir um PDF no painel com `pnpm tauri dev` |
 | Subagentes em segundo plano e turnos do próprio Claude Code | 7.2 | **Testado com 2.1.284** (`-p`, `stream-json`, Haiku, dois subagentes no `Agent`): o `result` do turno chega enquanto os subagentes ainda rodam. Eles avisam com `system/background_tasks_changed` (`tasks: [{task_id, task_type: "local_agent", description}]`, a lista inteira de quem ainda roda; `[]` no fim), `task_started`, `task_progress`, `task_updated` e `task_notification` (`status`, `summary`). Ao terminarem, o Claude Code abre turnos por conta própria (`system/init` sem `user` com `isReplay` antes, `assistant` e `result`), sem message escrita. Um turno assim já apareceu num chat real: o bot ficou `idle` durante ele. Comandos `local_bash` de dentro de um subagente aparecem em `task_started` com `owned_by_subagent` | feito |
 | Regras `allow` do projeto em `-p` sem confiança | 7.4 | Confirmado (`permissions`): não são aplicadas numa pasta nunca confiada; `deny` vale sempre. Por isso `--allowedTools mcp__botloft` | M4.1 |
 | `--session-id`, `--resume` em `-p` | 7.3 | Confirmado (`cli-reference`, `sessions`): a sessão retoma histórico e modelo; flags como `--mcp-config` têm de ser passadas de novo. **Testado com 2.1.284**: depois de reiniciar o bot e depois de reiniciar o daemon, o bot lembrou arquivos, a imagem e a mensagem de outro bot | feito (M4.1) |