diff --git a/packages/panel/src/file-tree/contract.ts b/packages/panel/src/file-tree/contract.ts
index c450ecd0a4..47d845583e 100644
--- a/packages/panel/src/file-tree/contract.ts
+++ b/packages/panel/src/file-tree/contract.ts
@@ -50,10 +50,25 @@ export const FILE_MARK = {
 
 export type FileMarkStatus = (typeof FILE_MARK)[keyof typeof FILE_MARK];
 
-/** One file's mark: its path and what became of it. */
+/**
+ * One file's mark: its path and what became of it, and, for a pull
+ * request's file, what Files changed knows of it beside: the lines it adds
+ * and removes, how many review threads stand on it, and whether the member
+ * marked it viewed, each drawn at the end of its row where given.
+ */
 export interface FileMark {
   readonly path: string;
   readonly status: FileMarkStatus;
+  /** The lines it adds and removes, drawn compact where the row has room. */
+  readonly lines?: { readonly additions: number; readonly deletions: number } | undefined;
+  /** How many review threads stand on it, drawn by a speech mark where any do. */
+  readonly threads?: number | undefined;
+  /**
+   * Whether the member marked it viewed, which dims its row and draws its
+   * Viewed toggle ticked, the toggle drawn otherwise only while the row is
+   * hovered; none draws no toggle, as before the marks are read.
+   */
+  readonly viewed?: boolean | undefined;
 }
 
 /** What the tab hands the tree when it mounts it. */
@@ -66,6 +81,13 @@ export interface FileTreeProps {
   readonly readFolder: ReadFolder;
   /** A file chosen in the tree, by a press or Return: open it, in a tab of its own where ⌘ was held. */
   readonly onOpen: (path: string, newTab: boolean) => void;
+  /**
+   * A file's Viewed toggle pressed on its row, or V pressed on the row the
+   * tree's keyboard stands on: mark it viewed, or not, as its header's box
+   * does. The press opens nothing, and the tree's keyboard stays where it
+   * stood.
+   */
+  readonly onViewed?: (path: string) => void;
   /**
    * How many rows the repository's tree shows, each time a folder listed,
    * opened, or closed changes it, which a breadcrumb's tree sizes its box
@@ -104,8 +126,8 @@ export interface FileTreeHandle {
   readonly within: (entries: readonly FolderEntry[]) => void;
   /**
    * Marks each file's row with what became of it, as an editor's source
-   * control does, and each folder above one as holding a change; none
-   * marks nothing.
+   * control does, and each folder above one as holding a change, each file's
+   * row drawing too whatever else its mark carries; none marks nothing.
    */
   readonly mark: (marks: readonly FileMark[]) => void;
   readonly unmount: () => void;
diff --git a/packages/panel/src/file-tree/index.test.ts b/packages/panel/src/file-tree/index.test.ts
new file mode 100644
index 0000000000..6781858249
--- /dev/null
+++ b/packages/panel/src/file-tree/index.test.ts
@@ -0,0 +1,157 @@
+// @vitest-environment jsdom
+
+import assert from "node:assert/strict";
+import { afterEach, test } from "vitest";
+import { FILE_MARK, type FileMark, type FileTreeHandle } from "./contract.js";
+import { fileTree } from "./index.js";
+
+/**
+ * index.test.ts -- a change set's tree draws at each file's row's end what
+ * its mark carries past what became of it: how many review threads stand on
+ * it, the lines it adds and removes, and a Viewed toggle, ticked once the
+ * file is viewed; a folder's row says nothing more. A press on the toggle
+ * is the toggle's alone, the row neither opening its file nor taking the
+ * keyboard, while a press anywhere else on the row opens the file, and V
+ * on the row the tree's keyboard stands on presses its toggle. The
+ * tree is the bundle's own, Pierre drawing it in jsdom; synthetic paths.
+ */
+
+const PATHS = ["src/seats.ts", "src/plan.md", "README.md"] as const;
+
+let mounted: { host: HTMLElement; handle: FileTreeHandle } | undefined;
+
+afterEach(() => {
+  mounted?.handle.unmount();
+  mounted = undefined;
+  document.body.innerHTML = "";
+});
+
+/** Lets the tree's listing land, which Pierre draws as it lands, on no clock. */
+async function settle(): Promise<void> {
+  for (let tick = 0; tick < 12; tick += 1) await Promise.resolve();
+}
+
+/** The tree mounted over the change set's files alone, every folder open, marked as given, with what it opened and marked. */
+async function mountMarked(marks: readonly FileMark[]) {
+  const opened: string[] = [];
+  const viewed: string[] = [];
+  const host = document.body.appendChild(document.createElement("div"));
+  const handle = fileTree.mount(host, {
+    readFolder: () => Promise.resolve({ entries: [], truncated: false }),
+    onOpen: (path) => opened.push(path),
+    onViewed: (path) => viewed.push(path),
+  });
+  mounted = { host, handle };
+  await settle();
+  handle.only(PATHS);
+  handle.mark(marks);
+  await settle();
+  return { handle, opened, viewed };
+}
+
+/** The row the tree drew for a path, through its shadow root. */
+function row(path: string): HTMLElement {
+  for (const container of mounted?.host.querySelectorAll("file-tree-container") ?? []) {
+    const found = container.shadowRoot?.querySelector<HTMLElement>(`[data-item-path="${path}"]`);
+    if (found !== null && found !== undefined && container.closest("[hidden]") === null) {
+      return found;
+    }
+  }
+  return assert.fail(`the tree draws ${path}`);
+}
+
+/** The words at the end of a row, part by part. */
+function parts(path: string): string[] {
+  const run = row(path).querySelector('[data-item-section="decoration"] > span');
+  return [...(run?.children ?? [])].map((part) => part.textContent ?? "");
+}
+
+/** A row's Viewed toggle, the last part of its run. */
+function toggle(path: string): HTMLElement {
+  const run = row(path).querySelector('[data-item-section="decoration"] > span');
+  const part = run?.children[4];
+  return part instanceof HTMLElement ? part : assert.fail(`${path} draws a Viewed toggle`);
+}
+
+const MARKS: readonly FileMark[] = [
+  {
+    path: "src/seats.ts",
+    status: FILE_MARK.MODIFIED,
+    lines: { additions: 12, deletions: 4 },
+    threads: 2,
+    viewed: false,
+  },
+  {
+    path: "src/plan.md",
+    status: FILE_MARK.ADDED,
+    lines: { additions: 30, deletions: 0 },
+    threads: 0,
+    viewed: true,
+  },
+  { path: "README.md", status: FILE_MARK.DELETED },
+];
+
+test("a file's row ends in its threads, its lines, and its Viewed toggle; a folder's and a bare mark's say nothing more", async () => {
+  await mountMarked(MARKS);
+
+  assert.deepEqual(parts("src/seats.ts"), ["", "2", "+12", "−4", ""]);
+  assert.deepEqual(parts("src/plan.md"), ["", "", "+30", "", "Viewed"]);
+  assert.match(
+    row("src/seats.ts").querySelector("[title]")?.getAttribute("title") ?? "",
+    /2 comments/u,
+  );
+  assert.deepEqual(parts("README.md"), []);
+  assert.deepEqual(parts("src/"), []);
+});
+
+test("a press on a row's Viewed toggle marks its file and opens nothing; a press on the rest of the row opens it", async () => {
+  const { opened, viewed } = await mountMarked(MARKS);
+
+  toggle("src/seats.ts").dispatchEvent(new MouseEvent("click", { bubbles: true, composed: true }));
+  assert.deepEqual(viewed, ["src/seats.ts"]);
+  assert.deepEqual(opened, []);
+
+  row("src/seats.ts").click();
+  assert.deepEqual(opened, ["src/seats.ts"]);
+  assert.deepEqual(viewed, ["src/seats.ts"]);
+});
+
+test("V on the row the tree's keyboard stands on presses that row's toggle and goes no further than the tree", async () => {
+  const { viewed } = await mountMarked(MARKS);
+  let heard = 0;
+  document.body.addEventListener("keydown", () => {
+    heard += 1;
+  });
+
+  row("src/seats.ts").focus();
+  row("src/seats.ts").dispatchEvent(
+    new KeyboardEvent("keydown", { key: "v", bubbles: true, composed: true }),
+  );
+  row("src/seats.ts").dispatchEvent(
+    new KeyboardEvent("keydown", { key: "v", isComposing: true, bubbles: true, composed: true }),
+  );
+  row("README.md").focus();
+  row("README.md").dispatchEvent(
+    new KeyboardEvent("keydown", { key: "v", bubbles: true, composed: true }),
+  );
+
+  assert.deepEqual(viewed, ["src/seats.ts"]);
+  assert.equal(heard, 2, "a V composed, and V on a row with no toggle, are left to the view");
+});
+
+test("marks handed again redraw the rows, a file marked viewed since ticked", async () => {
+  const { handle } = await mountMarked(MARKS);
+
+  handle.mark(
+    MARKS.map((mark) => ({ ...mark, viewed: mark.viewed === undefined ? undefined : true })),
+  );
+  await settle();
+
+  assert.equal(parts("src/seats.ts")[4], "Viewed");
+});
+
+test("a mark that does not say whether its file is viewed draws no toggle", async () => {
+  await mountMarked([{ path: "src/seats.ts", status: FILE_MARK.MODIFIED, threads: 1 }]);
+
+  assert.deepEqual(parts("src/seats.ts"), ["", "1", "", ""]);
+});
diff --git a/packages/panel/src/file-tree/index.ts b/packages/panel/src/file-tree/index.ts
index 4cd54e8996..c0873f9dc6 100644
--- a/packages/panel/src/file-tree/index.ts
+++ b/packages/panel/src/file-tree/index.ts
@@ -1,4 +1,9 @@
-import { createFileTreeIconResolver, FileTree, getBuiltInSpriteSheet } from "@pierre/trees";
+import {
+  createFileTreeIconResolver,
+  FileTree,
+  type FileTreeRowDecorationRenderer,
+  getBuiltInSpriteSheet,
+} from "@pierre/trees";
 import type {
   FileMark,
   FileTreeHandle,
@@ -15,6 +20,7 @@ import {
   repositoryPath,
   treePath,
 } from "./folder-browser.js";
+import { dress, pressedToggle, rowDecoration } from "./row-marks.js";
 
 /**
  * index.ts -- the file tree bundle: Pierre's tree mounted beside a File tab, listed a folder at a time, a file opened on its press.
@@ -45,7 +51,10 @@ import {
  * open. Each stands in the repository's place while it is asked for, so the
  * folders opened there are as they were when it is let go. A change set's
  * tree marks each file's row with what became of it, through Pierre's own
- * git status, in whichever of them stands.
+ * git status, in whichever of them stands, and a pull request's draws at
+ * each file's row's end its review threads, its lines, and its Viewed
+ * toggle (`row-marks.ts`), a press on which marks the file rather than
+ * opening it, as V does on the row the tree's keyboard stands on.
  *
  * A breadcrumb's tree is this same tree, mounted under the crumb over the
  * folder the crumb stands in, with its rows counted out as they change so
@@ -63,18 +72,14 @@ const ROW = {
 } as const;
 
 /**
- * How both trees draw: compact rows, each file's type in colour, a lone
- * folder sharing its parent's row, and the window's thin scrollbar
- * (`styles/desktop.css`), whose colour inherits into Pierre's shadow root
- * and whose width does not, so it is set there on the scroller and on the
- * box Pierre measures that scroller's gutter from.
+ * How both trees draw: compact rows, each file's type in colour, and a lone
+ * folder sharing its parent's row; the rest of their look is the sheet each
+ * is dressed in (`row-marks.ts`).
  */
 const TREE_LOOK = {
   flattenEmptyDirectories: true,
   density: "compact",
   icons: "complete",
-  unsafeCSS:
-    "[data-file-tree-virtualized-scroll], [data-file-tree-scrollbar-measure] { scrollbar-width: thin; }",
 } as const;
 
 /** The slot Pierre resolves a file's type icon for, and the type of a file no rule names. */
@@ -83,6 +88,9 @@ const FILE_ICON = {
   DEFAULT_TYPE: "default",
 } as const;
 
+/** The key that presses the Viewed toggle of the row the tree's keyboard stands on, as the list's V marks its file. */
+const VIEWED_KEY = "v";
+
 /** What the pane says while the root is listed. */
 const READING = "Reading the files…";
 
@@ -158,9 +166,18 @@ interface View {
   readonly frame: HTMLElement;
 }
 
-/** A tree drawn into a frame of its own over the paths given, Pierre's names for them. */
-function viewOf(paths: readonly string[], expansion: "open" | "closed"): View {
-  const tree = new FileTree({ ...TREE_LOOK, paths, initialExpansion: expansion });
+/** A tree drawn into a frame of its own over the paths given, Pierre's names for them, each row's end drawn by `decorate`. */
+function viewOf(
+  paths: readonly string[],
+  expansion: "open" | "closed",
+  decorate: FileTreeRowDecorationRenderer,
+): View {
+  const tree = new FileTree({
+    ...TREE_LOOK,
+    paths,
+    initialExpansion: expansion,
+    renderRowDecoration: decorate,
+  });
   const frame = document.createElement("div");
   frame.className = "file-tree-view";
   tree.render({ containerWrapper: frame });
@@ -214,6 +231,7 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
   let query = "";
   let marked: string | undefined;
   let marks: readonly FileMark[] = [];
+  let markOf = new Map<string, FileMark>();
   let taken = false;
   // The reveal asked before the tree is drawn.
   let waiting: { path: string; options: RevealOptions } | undefined;
@@ -222,6 +240,10 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
   const cut = notice(CUT_SHORT, undefined);
   cut.classList.add("file-tree-cut");
 
+  // Each file's row ends as its mark says; a folder's says nothing more.
+  const decorate: FileTreeRowDecorationRenderer = ({ item }) =>
+    item.kind === "file" ? rowDecoration(markOf.get(repositoryPath(item.path))) : null;
+
   // The tree standing now, drawn with the search held: the files Luke
   // showed while the filter is on, the whole repository while a search
   // stands and it was handed, the folders listed so far otherwise; or the
@@ -229,11 +251,11 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
   const standing = (): View | undefined => {
     if (browse === undefined) return undefined;
     if (only !== undefined) {
-      shown ??= framed(viewOf(only, "open"));
+      shown ??= framed(viewOf(only, "open", decorate));
       return shown;
     }
     if (query.trim() === "" || everything === undefined) return browse;
-    whole ??= framed(viewOf(everything, "closed"));
+    whole ??= framed(viewOf(everything, "closed", decorate));
     return whole;
   };
   // A view made after the tree was drawn joins it, the tab's file marked.
@@ -241,6 +263,7 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
     if (marked !== undefined) markAlone(view.tree, marked, false);
     view.tree.setGitStatus(marks);
     empty.before(view.frame);
+    dress(view.tree);
     return view;
   };
   const present = () => {
@@ -255,10 +278,11 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
   };
 
   const draw = () => {
-    browse = viewOf([], "closed");
+    browse = viewOf([], "closed", decorate);
     browse.tree.setGitStatus(marks);
     empty.hidden = true;
     host.replaceChildren(browse.frame, empty);
+    dress(browse.tree);
     // Note that a search stands over folders still being listed, so whether
     // it matches anything is asked again as each listing lands.
     const tree = browse.tree;
@@ -293,11 +317,40 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
     if (row?.dataset.itemType !== ROW.FILE || path === undefined) return;
     props.onOpen(repositoryPath(path), event.metaKey || event.ctrlKey);
   };
+  // Note that a press on a Viewed toggle is heard on its way down, before
+  // the row it stands in, so it goes no further: the row neither opens nor
+  // takes the keyboard.
+  const onToggle = (event: MouseEvent) => {
+    const path = pressedToggle(event);
+    if (path === undefined || props.onViewed === undefined) return;
+    event.preventDefault();
+    event.stopPropagation();
+    if (event.type === "click") props.onViewed(repositoryPath(path));
+  };
+  // Note that V on a row whose toggle is drawn is that row's toggle, as
+  // the list's own V is its file's, so it goes no further than the tree.
   const onKey = (event: KeyboardEvent) => {
     const path = standing()?.tree.getFocusedPath() ?? null;
-    if (event.key !== "Enter" || path === null || path.endsWith("/")) return;
-    props.onOpen(repositoryPath(path), event.metaKey || event.ctrlKey);
+    if (path === null || path.endsWith("/")) return;
+    if (event.key === "Enter")
+      return props.onOpen(repositoryPath(path), event.metaKey || event.ctrlKey);
+    const plain =
+      !event.isComposing && !(event.metaKey || event.ctrlKey || event.altKey || event.shiftKey);
+    const toggles = markOf.get(repositoryPath(path))?.viewed !== undefined;
+    if (
+      !plain ||
+      event.key.toLowerCase() !== VIEWED_KEY ||
+      !toggles ||
+      props.onViewed === undefined
+    ) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    props.onViewed(repositoryPath(path));
   };
+  host.addEventListener("mousedown", onToggle, true);
+  host.addEventListener("click", onToggle, true);
   host.addEventListener("click", onClick);
   host.addEventListener("keydown", onKey);
   list();
@@ -329,10 +382,20 @@ function mount(host: HTMLElement, props: FileTreeProps): FileTreeHandle {
     },
     mark: (asked) => {
       marks = asked;
-      for (const view of [browse, shown, whole]) view?.tree.setGitStatus(marks);
+      markOf = new Map(asked.map((mark) => [mark.path, mark]));
+      // Note that Pierre draws its rows again for a change of status alone,
+      // so a change to what else a mark carries is drawn by asking it to.
+      for (const view of [browse, shown, whole]) {
+        if (view === undefined) continue;
+        view.tree.setGitStatus(marks);
+        view.tree.setComposition(view.tree.getComposition());
+        dress(view.tree);
+      }
     },
     unmount: () => {
       taken = true;
+      host.removeEventListener("mousedown", onToggle, true);
+      host.removeEventListener("click", onToggle, true);
       host.removeEventListener("click", onClick);
       host.removeEventListener("keydown", onKey);
       unheard?.();
diff --git a/packages/panel/src/file-tree/row-marks.ts b/packages/panel/src/file-tree/row-marks.ts
new file mode 100644
index 0000000000..968f8ba0ec
--- /dev/null
+++ b/packages/panel/src/file-tree/row-marks.ts
@@ -0,0 +1,201 @@
+import type { FileTree, FileTreeRowDecoration } from "@pierre/trees";
+import type { FileMark } from "./contract.js";
+
+/**
+ * row-marks.ts -- what a pull request's file row says at its end, past what became of it: its review threads, the lines it adds and removes, and its Viewed toggle, as stage-cli's tree draws them; and the sheet the tree draws them by.
+ *
+ * Pierre draws one decoration in each row's lane, a run of words in the
+ * colours given, so a file's are drawn as one run of five parts in a fixed
+ * order (`PART`): a speech mark and the count of the threads standing on
+ * it; the lines it adds; the lines it removes; and its Viewed toggle. A
+ * part with nothing to say holds no words, and the sheet draws no room for
+ * it. The sheet draws the speech mark and the toggle's circle, ticked once
+ * the file is viewed, as Lucide's `MessageSquare`, `Circle`, and
+ * `CircleCheck`, and finds each part by its place in the run.
+ *
+ * The name comes first: the lane holds only the room the name leaves, as
+ * Pierre lays it out, so no mark ever cuts a name short. Where that room
+ * runs out the run gives up its parts from its end, one line of a run that
+ * wraps with its second line out of sight: the lines removed, then the
+ * lines added, then the count, then the speech mark. The toggle takes no
+ * room of its own while the row is hovered or holds the keyboard: it
+ * stands over the run's end, the row's ground behind it, in place of the
+ * counts. Once ticked it stands there always, in room the lane keeps for
+ * it, so a viewed file's name is cut short before it rather than under
+ * it, and the row is dimmed, as stage-cli dims a viewed file. A folder's
+ * row says nothing more.
+ *
+ * Note that the sheet is adopted by the tree's shadow root as a
+ * constructed sheet rather than handed to Pierre's `unsafeCSS`, because
+ * Pierre writes that into a `<style>` element, which the panel's policy
+ * (`style-src 'self'`, `index.html`) refuses, as it admits a constructed
+ * sheet (`../terminal/adopted-styles.ts`). Pierre adopts its own sheet each
+ * time its element joins the document, in this one's place, so the tree
+ * adopts it again after each time it moves one (`dress`).
+ */
+
+/** Each part's place in a file's run of words. */
+const PART = {
+  SPEECH: 0,
+  THREADS: 1,
+  ADDED: 2,
+  REMOVED: 3,
+  VIEWED: 4,
+} as const;
+
+/** What a part says, read out in the run's hint. */
+const MARK_WORDS = {
+  VIEWED: "Viewed",
+  threads: (count: number) => (count === 1 ? "1 comment" : `${count} comments`),
+  lines: (additions: number, deletions: number) =>
+    `${additions} ${additions === 1 ? "line" : "lines"} added, ${deletions} removed`,
+} as const;
+
+/** The colour each part is drawn in, the panel's own, which the tree's shadow root inherits. */
+const PART_COLOUR = {
+  THREADS: "var(--luke-color-text-muted)",
+  ADDED: "var(--luke-color-complete)",
+  REMOVED: "var(--luke-color-danger-text)",
+  VIEWED: "var(--luke-color-complete)",
+  UNVIEWED: "var(--luke-color-text-muted)",
+} as const;
+
+/** Lucide's glyphs as masks, stroked as every Lucide glyph in the window is. */
+const GLYPH = {
+  SPEECH:
+    '<path d="M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"/>',
+  CIRCLE: '<circle cx="12" cy="12" r="10"/>',
+  CHECKED: '<circle cx="12" cy="12" r="10"/><path d="m16 9-5.5 5.5L8 12"/>',
+} as const;
+
+/** A glyph as the address a mask draws it from. */
+function maskOf(shapes: string): string {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${shapes}</svg>`;
+  return `url("data:image/svg+xml,${encodeURIComponent(svg)}")`;
+}
+
+/** A decorated row's lane, and the run of words in it. */
+const LANE = '[data-type="item"] > [data-item-section="decoration"]';
+const RUN = `${LANE} > span`;
+
+/** One part of a row's run, by its place. */
+function part(at: number): string {
+  return `${RUN} > span:nth-child(${at + 1})`;
+}
+
+/** The toggle, and the toggle once ticked, as a part of a run. */
+const TOGGLE = `span:nth-child(${PART.VIEWED + 1})`;
+const TICKED = `${TOGGLE}:not(:empty)`;
+
+/** A row in reach of the pointer or the keyboard, which draws a toggle not yet ticked. */
+const REACHED = '[data-type="item"]:is(:hover, [data-item-focused])';
+
+/** A row whose toggle is ticked. */
+const VIEWED_ROW = `[data-type="item"]:has(> [data-item-section="decoration"] > span > ${TICKED})`;
+
+/**
+ * The row's ground as it stands, hovered or chosen, which Pierre paints
+ * behind a name it cuts short and the toggle paints behind itself.
+ */
+const ROW_GROUND =
+  "linear-gradient(var(--truncate-marker-background-overlay-color, transparent), var(--truncate-marker-background-overlay-color, transparent)), var(--truncate-marker-background-color, transparent)";
+
+/**
+ * The rules the tree draws by: the window's thin scrollbar, whose colour
+ * inherits into Pierre's shadow root and whose width does not, so it is set
+ * here on the scroller and on the box Pierre measures that scroller's
+ * gutter from; and each file's run.
+ */
+const SHEET = `
+[data-file-tree-virtualized-scroll], [data-file-tree-scrollbar-measure] { scrollbar-width: thin; }
+${LANE}:has(> span > span) { position: relative; overflow: visible; }
+${LANE}:has(> span > ${TICKED}) { min-width: calc(var(--luke-space-4) + var(--luke-space-12)); }
+${RUN} { flex-wrap: wrap; justify-content: flex-end; align-content: flex-start; height: 1lh; column-gap: var(--luke-space-4); font-variant-numeric: tabular-nums; }
+${RUN} > span { display: inline-flex; flex: none; height: 100%; align-items: center; }
+${RUN} > span:empty { display: none; }
+${part(PART.SPEECH)}:has(+ span:not(:empty)) { display: inline-flex; margin-inline-end: calc(var(--luke-space-2) - var(--luke-space-4)); }
+${part(PART.SPEECH)}::before { content: ""; width: 1em; height: 1em; background: currentColor; mask: ${maskOf(GLYPH.SPEECH)} center / contain no-repeat; }
+${part(PART.VIEWED)}, ${part(PART.VIEWED)}:empty { position: absolute; inset-block: 0; inset-inline-end: 0; display: none; padding-inline-start: var(--luke-space-4); background: ${ROW_GROUND}; font-size: 0; cursor: default; }
+${part(PART.VIEWED)}::before { content: ""; width: var(--luke-space-12); height: var(--luke-space-12); background: currentColor; mask: ${maskOf(GLYPH.CHECKED)} center / contain no-repeat; }
+${part(PART.VIEWED)}:empty::before { mask-image: ${maskOf(GLYPH.CIRCLE)}; }
+${REACHED} > [data-item-section="decoration"] > span > ${TOGGLE}, ${RUN} > ${TICKED} { display: inline-flex; }
+${REACHED} > [data-item-section="decoration"]:has(> span > ${TOGGLE}) > span > span:not(:nth-child(${PART.VIEWED + 1})), ${RUN}:has(> ${TICKED}) > span:not(:nth-child(${PART.VIEWED + 1})) { visibility: hidden; }
+${VIEWED_ROW}:not([data-item-selected]) { opacity: 0.6; }
+`;
+
+/** The sheet, made the first time a tree is dressed, where the document can make one. */
+let sheet: CSSStyleSheet | undefined;
+
+/**
+ * Adopts the tree's sheet into its shadow root wherever it is not adopted
+ * there, beside Pierre's own; call it each time the tree's element joins the
+ * document, since Pierre then adopts its own sheet alone.
+ */
+export function dress(tree: FileTree): void {
+  const root = tree.getFileTreeContainer()?.shadowRoot;
+  // Note that a document that adopts no sheets, as jsdom's, draws the run unstyled.
+  if (root?.adoptedStyleSheets === undefined) return;
+  if (sheet === undefined) {
+    sheet = new CSSStyleSheet();
+    sheet.replaceSync(SHEET);
+  }
+  if (!root.adoptedStyleSheets.includes(sheet)) {
+    root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];
+  }
+}
+
+/** The words of a count, none where there is nothing to count. */
+function counted(count: number, sign: string): string {
+  return count > 0 ? `${sign}${count}` : "";
+}
+
+/**
+ * A file's run of words at the end of its row, from its mark, or none where
+ * it has nothing to say past what became of it; the toggle is drawn only
+ * where the mark says whether the file is viewed.
+ */
+export function rowDecoration(mark: FileMark | undefined): FileTreeRowDecoration | null {
+  if (mark === undefined) return null;
+  const threads = mark.threads ?? 0;
+  const viewed = mark.viewed;
+  if (threads === 0 && mark.lines === undefined && viewed === undefined) return null;
+  const additions = mark.lines?.additions ?? 0;
+  const deletions = mark.lines?.deletions ?? 0;
+  // Note that the speech mark holds no words: the sheet draws it beside a count.
+  const parts = [
+    { text: "", color: PART_COLOUR.THREADS },
+    { text: counted(threads, ""), color: PART_COLOUR.THREADS },
+    { text: counted(additions, "+"), color: PART_COLOUR.ADDED },
+    { text: counted(deletions, "−"), color: PART_COLOUR.REMOVED },
+  ];
+  if (viewed !== undefined) {
+    parts.push({
+      text: viewed ? MARK_WORDS.VIEWED : "",
+      color: viewed ? PART_COLOUR.VIEWED : PART_COLOUR.UNVIEWED,
+    });
+  }
+  const said = [
+    threads > 0 ? MARK_WORDS.threads(threads) : undefined,
+    mark.lines === undefined ? undefined : MARK_WORDS.lines(additions, deletions),
+    viewed === true ? MARK_WORDS.VIEWED : undefined,
+  ].filter((words) => words !== undefined);
+  return { text: parts.map((each) => each.text).join(""), title: said.join(" · "), parts };
+}
+
+/**
+ * The file whose Viewed toggle a press landed on, by its path as the tree
+ * names it, read through the tree's shadow root: the part of its row's run
+ * standing at the toggle's place.
+ */
+export function pressedToggle(event: Event): string | undefined {
+  const path = event.composedPath();
+  const lane = path.findIndex(
+    (target) => target instanceof HTMLElement && target.dataset.itemSection === "decoration",
+  );
+  const pressed = path[lane - 2];
+  const row = path[lane + 1];
+  if (lane < 2 || !(pressed instanceof HTMLElement) || !(row instanceof HTMLElement))
+    return undefined;
+  const at = Array.prototype.indexOf.call(pressed.parentElement?.children ?? [], pressed);
+  return at === PART.VIEWED && row.dataset.itemType === "file" ? row.dataset.itemPath : undefined;
+}
diff --git a/packages/panel/src/tasks/agent-changes-tab.test.ts b/packages/panel/src/tasks/agent-changes-tab.test.ts
index 580f28ff63..d9dc093503 100644
--- a/packages/panel/src/tasks/agent-changes-tab.test.ts
+++ b/packages/panel/src/tasks/agent-changes-tab.test.ts
@@ -40,7 +40,7 @@ import { appBridge } from "../app-bridge.js";
 import { useAppCommand, useAppKeymap } from "../app-commands.js";
 import type { SideBundles } from "../bundle-loader.js";
 import type { DiffListProps, DiffViewModule } from "../diff-view/contract.js";
-import type { FileTreeModule } from "../file-tree/contract.js";
+import type { FileMark, FileTreeModule, FileTreeProps } from "../file-tree/contract.js";
 import { findRanges, reveal } from "../find-matches.js";
 import { fakeAppBridge, fakeAppBridgeCalls } from "../testing/app-bridge.js";
 import { handSettings } from "../testing/app-state.js";
@@ -171,18 +171,23 @@ const standIn: DiffViewModule = {
 
 /** The doors each tree the view mounted opens a chosen file through, the latest last. */
 let treeOpens: Array<(path: string, newTab: boolean) => void> = [];
+/** What each tree the view mounted was handed, the latest last. */
+let treeProps: FileTreeProps[] = [];
+/** The marks the trees were handed, the latest last. */
+let treeMarks: Array<readonly FileMark[]> = [];
 
-/** The tree bundle, stood in for: it draws nothing and keeps the door its tree opens a file through. */
+/** The tree bundle, stood in for: it draws nothing and keeps the doors and the marks it is handed. */
 const treeStandIn: FileTreeModule = {
   mount: (_host, props) => {
     treeOpens.push(props.onOpen);
+    treeProps.push(props);
     const nothing = () => undefined;
     return {
       reveal: nothing,
       search: nothing,
       only: nothing,
       within: nothing,
-      mark: nothing,
+      mark: (marks) => treeMarks.push(marks),
       unmount: nothing,
     };
   },
@@ -204,6 +209,8 @@ beforeEach(() => {
   drawn = [];
   revealed = [];
   treeOpens = [];
+  treeProps = [];
+  treeMarks = [];
   files = [changed("src/seats.ts")];
   commits = {};
   viewedAnswer = { failure: CODING_AGENT_CALL_FAILURE.UNANSWERED };
@@ -1294,6 +1301,61 @@ test("V marks the file the keys stand on viewed and steps on to the next, and is
   assert.equal(viewedBox("a.ts").checked, true);
 });
 
+/** The marks the tree was last handed, by path. */
+function lastMarks(): ReadonlyMap<string, FileMark> {
+  return new Map((treeMarks.at(-1) ?? []).map((mark) => [mark.path, mark]));
+}
+
+test("each tree row is handed its file's lines, how many review threads stand on it, resolved or not, and whether it is viewed", async () => {
+  viewedAnswer = MARKED;
+  files = [changed("a.ts"), changed("b.ts", { additions: 0, deletions: 7 }), changed("c.ts")];
+  const threads: ChangesThreads = {
+    list: [
+      { ...seatsThread(2, "one"), path: "a.ts" },
+      { ...seatsThread(2, "two"), path: "a.ts", resolved: true },
+      { ...seatsThread(null, "three"), path: "c.ts" },
+    ],
+    draw: () => null,
+  };
+  await drawTab({ threads, treeOpen: true });
+
+  const marks = lastMarks();
+  assert.deepEqual(
+    ["a.ts", "b.ts", "c.ts"].map((path) => {
+      const mark = marks.get(path);
+      return [mark?.threads, mark?.lines, mark?.viewed];
+    }),
+    [
+      [2, { additions: 2, deletions: 1 }, true],
+      [0, { additions: 0, deletions: 7 }, false],
+      [1, { additions: 2, deletions: 1 }, false],
+    ],
+  );
+});
+
+test("a tree row's Viewed toggle marks its file viewed on GitHub as its header's box does, folding it, and the row is handed the mark", async () => {
+  viewedAnswer = MARKED;
+  const asked = answerMarks(() => ({ outcome: PULL_REQUEST_WRITE_OUTCOME.DONE }));
+  files = [changed("a.ts"), changed("b.ts"), changed("c.ts")];
+  await drawTab({ treeOpen: true });
+
+  const onViewed = treeProps.at(-1)?.onViewed ?? assert.fail("the tree is handed a Viewed door");
+  act(() => onViewed("c.ts"));
+  await flush();
+
+  assert.deepEqual(asked, [{ action: PULL_REQUEST_ACTION.MARK_FILE_VIEWED, path: "c.ts" }]);
+  assert.equal(viewedBox("c.ts").checked, true);
+  assert.deepEqual(folds()[2], ["c.ts", true]);
+  assert.equal(lastMarks().get("c.ts")?.viewed, true);
+});
+
+test("no tree row draws a Viewed toggle until the marks are read", async () => {
+  files = [changed("a.ts")];
+  await drawTab({ treeOpen: true });
+
+  assert.equal(lastMarks().get("a.ts")?.viewed, undefined);
+});
+
 test("a member with no GitHub sign-in is offered one, and no Viewed box stands until the marks are read", async () => {
   viewedAnswer = { outcome: PULL_REQUEST_WRITE_OUTCOME.SIGN_IN_REQUIRED };
   files = [changed("a.ts")];
diff --git a/packages/panel/src/tasks/agent-changes-tab.tsx b/packages/panel/src/tasks/agent-changes-tab.tsx
index 4c550347d1..486f2dd555 100644
--- a/packages/panel/src/tasks/agent-changes-tab.tsx
+++ b/packages/panel/src/tasks/agent-changes-tab.tsx
@@ -135,7 +135,10 @@ import { useViewedFiles } from "./viewed-files.js";
  * and Highlight changed words), and the tree's toggle, which shows and
  * hides the tree for every File and Changes tab alike. The tree is a File
  * tab's own pane (`file-tree-pane.tsx`) narrowed to the changed files,
- * every folder open, each row lettered A, M, D, or R, its search the
+ * every folder open, each row lettered A, M, D, or R, and ending, as
+ * stage-cli's do, in how many review threads stand on its file, the lines
+ * it adds and removes where the tree has room, and a Viewed toggle that
+ * marks it as its header's box does, its row dimmed once viewed; its search the
  * list's filter, narrowing the list to the files whose path holds it as it
  * narrows the rows, said over the list while the tree is hidden, with the
  * pull request's count under it, or under the list while the tree is
@@ -1096,7 +1099,7 @@ export function AgentChangesTab({
   const changed = useMemo(() => {
     const files = pullRequest?.files ?? [];
     const paths = files.map((file) => file.path);
-    return { files, paths, marks: changeMarks(files), folders: changedFolders(paths) };
+    return { files, paths, folders: changedFolders(paths) };
   }, [pullRequest]);
   // Note that the marks are read with each answer the changes read lands with, so the two describe the same push.
   const viewedFiles = useViewedFiles(
@@ -1108,6 +1111,10 @@ export function AgentChangesTab({
   const minimize = () =>
     viewSettings.change("diffMinimizeComments", !viewSettings.settings.diffMinimizeComments);
   const list = useChangesList(changed.files, viewedFiles.marks, minimize);
+  const marks = useMemo(
+    () => changeMarks(changed.files, { threads: threads?.list, viewed: list.viewed }),
+    [changed.files, threads?.list, list.viewed],
+  );
   const answered = reads.current.count;
   // Note that the images are named afresh only with an answer, because every changed image's entry is drawn from them.
   const images = useMemo(
@@ -1229,12 +1236,13 @@ export function AgentChangesTab({
           <FileTreePane
             file={shownFile.path}
             only={changed.paths}
-            marks={changed.marks}
+            marks={marks}
             label="Changed files"
             foot={counted}
             listFolder={changed.folders}
             search={{ query: list.query, onQuery: list.onQuery }}
             onOpen={choose}
+            onViewed={list.markViewed}
             pane={room.beside.pane}
             float={room.pane}
             leaving={room.beside.leaving}
diff --git a/packages/panel/src/tasks/changes-model.ts b/packages/panel/src/tasks/changes-model.ts
index 5c9ce07dc3..adb661c9fe 100644
--- a/packages/panel/src/tasks/changes-model.ts
+++ b/packages/panel/src/tasks/changes-model.ts
@@ -456,9 +456,30 @@ export function fileNotice(file: CodingAgentChangedFile): string | undefined {
     : CHANGES_WORDS.NO_HUNKS;
 }
 
-/** Each changed file's row mark in the tree. */
-export function changeMarks(files: readonly CodingAgentChangedFile[]): readonly FileMark[] {
-  return files.map((file) => ({ path: file.path, status: STATUS_MARK[file.status] }));
+/**
+ * Each changed file's row mark in the tree: what became of it, the lines it
+ * adds and removes, and, where Files changed knows them, how many review
+ * threads stand on it, every one counted, resolved or not, as stage-cli's
+ * tree counts them, and whether the member marked it viewed.
+ */
+export function changeMarks(
+  files: readonly CodingAgentChangedFile[],
+  beside: {
+    readonly threads?: readonly ReviewThread[] | undefined;
+    readonly viewed?: ((path: string) => boolean) | undefined;
+  } = {},
+): readonly FileMark[] {
+  const threads = new Map<string, number>();
+  for (const thread of beside.threads ?? []) {
+    threads.set(thread.path, (threads.get(thread.path) ?? 0) + 1);
+  }
+  return files.map((file) => ({
+    path: file.path,
+    status: STATUS_MARK[file.status],
+    lines: { additions: file.additions, deletions: file.deletions },
+    threads: threads.get(file.path) ?? 0,
+    viewed: beside.viewed?.(file.path),
+  }));
 }
 
 /** The lines every file adds and removes, summed. */
diff --git a/packages/panel/src/tasks/file-tree-pane.tsx b/packages/panel/src/tasks/file-tree-pane.tsx
index 646abafa3d..dfc41bda05 100644
--- a/packages/panel/src/tasks/file-tree-pane.tsx
+++ b/packages/panel/src/tasks/file-tree-pane.tsx
@@ -95,6 +95,7 @@ export function FileTreePane({
   listFolder,
   readWhole,
   onOpen,
+  onViewed,
   pane,
   float,
   leaving = false,
@@ -105,7 +106,7 @@ export function FileTreePane({
   shown?: readonly string[] | undefined;
   /** The only files the tree shows, every folder open, in the filter's place: a change set's. */
   only?: readonly string[] | undefined;
-  /** What became of each file of a change set, lettered on its row. */
+  /** What became of each file of a change set, lettered on its row, with whatever else its mark carries drawn at the row's end. */
   marks?: readonly FileMark[] | undefined;
   /** What the search holds and the door that sets it, where its holder narrows more than the tree by it; none keeps it in the pane. */
   search?: { readonly query: string; readonly onQuery: (query: string) => void } | undefined;
@@ -118,6 +119,8 @@ export function FileTreePane({
   readWhole?: (() => Promise<TasksTreeAnswer>) | undefined;
   /** A file chosen in the tree, to open in the tab, or in a tab of its own where ⌘ was held. */
   onOpen: (path: string, newTab: boolean) => void;
+  /** A file's Viewed toggle pressed on its row, drawn where its mark says whether it is viewed. */
+  onViewed?: ((path: string) => void) | undefined;
   /** The pane's own box, which its slide in and out plays on (`file-view.tsx`). */
   pane?: React.Ref<HTMLElement> | undefined;
   /** What the pane answers while it may float over its tab (`hover-pane.ts`). */
@@ -141,8 +144,8 @@ export function FileTreePane({
     only ?? (onlyShown && shown !== undefined && shown.length > 0 ? shown : undefined);
   // Note that the tree is handed doors that read the latest props, so it is
   // mounted once however often the pane is drawn.
-  const latest = useRef({ listFolder, onOpen, file, query, narrowed, marks });
-  latest.current = { listFolder, onOpen, file, query, narrowed, marks };
+  const latest = useRef({ listFolder, onOpen, onViewed, file, query, narrowed, marks });
+  latest.current = { listFolder, onOpen, onViewed, file, query, narrowed, marks };
 
   useEffect(() => {
     const element = host.current;
@@ -150,6 +153,7 @@ export function FileTreePane({
     const mounted = module.mount(element, {
       readFolder: (path) => latest.current.listFolder(path),
       onOpen: (path, newTab) => latest.current.onOpen(path, newTab),
+      onViewed: (path) => latest.current.onViewed?.(path),
     });
     handle.current = mounted;
     if (everything.current !== undefined) mounted.within(everything.current);