diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2bd527..c4428cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,6 +37,36 @@ All notable user-visible changes are recorded here. Versions follow [Semantic Ve
   app can add exact account counts and sign-up retention when the two are
   linked.
 - Clicks on the landing page's Sign up free and Web app links are counted.
+- The funnel gains "Copied an install command" from the landing page's copy
+  buttons, and lists sessions created but never connected beside "Started a
+  session". A named `utm_source` or `ref` on a landing link counts as the
+  source when the browser hid the referrer, from a fixed list of names;
+  visits from the web app are their own source.
+- A session's first open records whether typing is allowed and how long the
+  link waited; the first keystroke, how long after the open it came; a
+  viewer's disconnect, how long they stayed. Browsers turned away by a full,
+  expired or unknown session are counted by reason, and a viewer refused
+  input in a read-only session once. The dashboard shows typed rate by
+  device, who was turned away, and the typed share over sessions that allow
+  typing.
+- Machines running the installer or the CLI are keyed by address alone, so
+  the dashboard can say how many machines that installed at least a week ago
+  started a session within seven days. The privacy policy says so.
+- Both install scripts send one word at their end, the outcome, and the
+  binary name, so a platform that keeps failing gets noticed; nothing else
+  goes with it, and `SHELL_ONLINE_INSTALL_REPORT=0` skips it. The dashboard
+  shows how installs ended by the scripts' own account.
+- The accounts app counts what accounts do, by day and by kind and nothing
+  else: machines linked, sessions registered, commands sent, vaults created,
+  invites sent and accepted, feedback sent. The dashboard shows them under
+  Accounts as things done, not as distinct accounts.
+- The statistics dashboard reads top to bottom as a story: what is live now,
+  six headline figures each with its change against the period before, the
+  funnel, then traffic, sessions, retention and accounts, each section opening
+  with the finding in a sentence. Every figure about people leaves crawlers
+  out and says so beside the step: page views by people, the installer run by
+  curl or wget rather than read or crawled, installs completed on a person's
+  machine. The raw totals stay in the ledger.
 
 ### Fixed
 
@@ -47,6 +77,17 @@ All notable user-visible changes are recorded here. Versions follow [Semantic Ve
   as "Not found". Every documentation route, current or versioned, now has its
   own page-view target; unknown paths the site answers with the landing page
   are counted apart from real 404s, and real 404s are counted at all.
+- The statistics dashboard says since when people have been counted. Event
+  counts run from the first event and people from the day the visitor salt was
+  set, so a 30-day range could show thirty days of views beside one day of
+  people. A people figure over fewer days than the count beside it now names
+  that day, in the funnel, the headline tiles and the footer.
+- Crawlers that identify themselves are no longer counted as people. The
+  funnel said they were not, and they were.
+- Deploying to production refuses a Wrangler config that serves a documentation
+  page from the assets binding instead of the Worker, since such a page is
+  never counted. Production served the web app, CLI, Refstream and platforms
+  pages that way.
 
 ### Changed
 
diff --git a/README.md b/README.md
index 8bf926a..4d37b83 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,10 @@ Windows PowerShell:
 irm https://shell.online/install.ps1 | iex
 ```
 
+At the end, and on failure, the installer sends one word back, its outcome,
+so a platform that keeps failing gets noticed and fixed. Nothing else goes
+with it. Set `SHELL_ONLINE_INSTALL_REPORT=0` to skip that.
+
 Homebrew (the tap lives in this repository):
 
 ```sh
diff --git a/app/server/app.test.ts b/app/server/app.test.ts
index 8d9ad9b..f4e76b8 100644
--- a/app/server/app.test.ts
+++ b/app/server/app.test.ts
@@ -236,6 +236,8 @@ describe("session registry", () => {
     const tokens = await login();
     const created = await call("POST", "/api/sessions", { auth: tokens.access_token, body: session });
     expect(created.status).toBe(201);
+    /* Counted for the dashboard: the login linked a machine, the registration a session. */
+    expect(await store.appEvents(0)).toEqual([{ event: "machine_linked", count: 1 }, { event: "session_registered", count: 1 }]);
 
     const listed = await call("GET", "/api/sessions", { auth: await idToken() });
     expect(listed.status).toBe(200);
@@ -556,6 +558,7 @@ describe("driving a machine from the browser", () => {
       body: { device_id: deviceId, kind: "start", command: "top" },
     });
     expect(queued.status).toBe(202);
+    expect((await store.appEvents(0)).find((entry) => entry.event === "command_sent")?.count).toBe(1);
 
     const claimed = await call("GET", "/api/agent/commands", { auth: tokens.access_token });
     expect(claimed.body.commands).toHaveLength(1);
@@ -1041,6 +1044,8 @@ describe("organizations", () => {
     expect(joined.body.joined).toBe(true);
     expect(joined.body.you.role).toBe("member");
     expect(joined.body.members).toHaveLength(2);
+    /* Both halves counted for the dashboard, with nothing about who. */
+    expect(await store.appEvents(0)).toEqual([{ event: "invite_accepted", count: 1 }, { event: "invite_created", count: 1 }]);
   });
 
   it("shows colleagues each other's sessions", async () => {
@@ -2031,6 +2036,7 @@ describe("session vault", () => {
     const { body } = await vaultBody();
     const created = await call("POST", "/api/vault", { auth: await idToken(), body });
     expect(created.status).toBe(201);
+    expect((await store.appEvents(0)).find((entry) => entry.event === "vault_created")?.count).toBe(1);
     const fetched = await call("GET", "/api/vault", { auth: await idToken() });
     expect(fetched.body.vault).toMatchObject({
       publicKey: body.public_key,
@@ -2542,6 +2548,12 @@ describe("feedback", () => {
     const posted = await call("POST", "/api/feedback", { auth: await idToken(), body: message });
     expect(posted.status).toBe(201);
     expect(posted.body.feedback.id).toMatch(/^fbk_/);
+    /* Counted for the dashboard as a thing done, with nothing about who did it. */
+    expect(await store.appEvents(0)).toEqual([{ event: "feedback_sent", count: 1 }]);
+    /* Counting must never change an answer: a store that cannot count still answers 201. */
+    vi.spyOn(store, "recordAppEvent").mockRejectedValueOnce(new Error("db down"));
+    const again = await call("POST", "/api/feedback", { auth: await idToken(), body: message });
+    expect(again.status).toBe(201);
     const [kept] = await store.feedback();
     expect(kept).toMatchObject({
       uid: "uid-1",
@@ -2599,9 +2611,18 @@ describe("account figures for the statistics dashboard", () => {
     expect((await call("GET", "/api/stats/accounts?range=7d", { auth: "stats-token-with-thirty-two-characters?" })).status).toBe(401);
     expect((await call("GET", "/api/stats/accounts?range=7d", { auth: await idToken() })).status).toBe(401);
 
+    await store.recordAppEvent("machine_linked");
+    await store.recordAppEvent("machine_linked");
+    await store.recordAppEvent("command_sent");
     const answer = await call("GET", "/api/stats/accounts?range=7d", { auth: TOKEN });
     expect(answer.status).toBe(200);
-    expect(answer.body).toMatchObject({ total: 1, newInRange: 1, activeInRange: 1 });
+    expect(answer.body).toMatchObject({ total: 1, newInRange: 1, activeInRange: 1, events: { machine_linked: 2, command_sent: 1 } });
+    /* Only the range's days count; the all-time range counts every day kept. */
+    await store.recordAppEvent("vault_created", Date.now() - 40 * 24 * 60 * 60_000);
+    const week = await call("GET", "/api/stats/accounts?range=7d", { auth: TOKEN });
+    expect(week.body.events).toEqual({ machine_linked: 2, command_sent: 1 });
+    const all = await call("GET", "/api/stats/accounts?range=all", { auth: TOKEN });
+    expect(all.body.events).toEqual({ machine_linked: 2, command_sent: 1, vault_created: 1 });
     expect(answer.body.newByDay).toHaveLength(90);
     expect(answer.body.cohorts).toHaveLength(1);
     expect(answer.body.cohorts[0].size).toBe(1);
diff --git a/app/server/app.ts b/app/server/app.ts
index e3ec77f..c0e388b 100644
--- a/app/server/app.ts
+++ b/app/server/app.ts
@@ -1,7 +1,9 @@
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import type { Store } from "./lib/store";
 import type { Invite, Membership } from "./lib/orgs";
-import type { AuditEvent, SessionRecord } from "./lib/types";
+import type { AuditEvent, SessionRecord,
+  AppEvent,
+} from "./lib/types";
 import type { VerifyResult } from "./lib/firebase-token";
 import type { SessionLiveness, SessionLivenessSource } from "./lib/session-liveness";
 import { exchangeCode, issueCode } from "./lib/codes";
@@ -45,7 +47,7 @@ import { recordAudit, assignSession, auditCsv, SEALED_KINDS } from "./routes/aud
 import { addComment, inbox, notifyAssigned, notifySessionStarted } from "./routes/social";
 import { deleteAccount } from "./routes/account";
 import { submitFeedback } from "./routes/feedback";
-import { accountStats, isStatsRange } from "./routes/stats";
+import { accountStats, dayStart, isStatsRange, rangeStart } from "./routes/stats";
 import { timingSafeEqual } from "node:crypto";
 import { callerAddress, rateLimiter } from "./lib/rate-limit";
 import { logMailer, type Mailer } from "./lib/mail";
@@ -378,6 +380,15 @@ export function createApp(options: AppOptions) {
     return membership;
   }
 
+  /*
+   * One count per thing done, never who did it, for the statistics
+   * dashboard. Counting must never change an answer, so a store that cannot
+   * count is nobody's problem here.
+   */
+  const track = (event: AppEvent): void => {
+    void store.recordAppEvent(event).catch(() => undefined);
+  };
+
   /* The CLI authenticates with an opaque access token issued by this service. */
   async function requireCli(request: IncomingMessage) {
     const check = await checkAccessToken(store, bearer(request));
@@ -483,6 +494,7 @@ export function createApp(options: AppOptions) {
           label: String(body.label ?? "shell cli").slice(0, 80),
           machineId,
         });
+        track("machine_linked");
         return send(response, 200, {
           access_token: tokens.accessToken,
           refresh_token: tokens.refreshToken,
@@ -536,6 +548,7 @@ export function createApp(options: AppOptions) {
           return send(response, 400, { error: "invalid browser public key" });
         }
         if (publicKey) await store.setMemberKey(identity.uid, publicKey);
+        if (resolved.joined && invite) track("invite_accepted");
         const described = await describeOrganization(store, resolved.membership);
         return send(response, described.status, {
           ...(described.body as Record<string, unknown>),
@@ -576,6 +589,7 @@ export function createApp(options: AppOptions) {
           const invite = (result.body as { invite?: Invite }).invite;
           if (invite) await notifyInvited(store, mailer, webOrigin, membership, invite, log);
         }
+        if (result.status < 300) track("invite_created");
         return send(response, result.status, result.body);
       }
 
@@ -916,6 +930,7 @@ export function createApp(options: AppOptions) {
           });
           if (!created) return send(response, 409, { error: "this account already has a vault" });
           const stored = await store.accountKey(identity.uid);
+          track("vault_created");
           return send(response, 201, { vault: stored ? vaultForApi(stored) : null });
         }
 
@@ -1068,6 +1083,7 @@ export function createApp(options: AppOptions) {
             result.session.name || result.session.command,
           );
         }
+        track("session_registered");
         return send(response, 201, { session: sessionForApi(result.session) });
       }
 
@@ -1282,6 +1298,7 @@ export function createApp(options: AppOptions) {
             createdAt: Date.now(),
           };
           await store.putCommand(queued);
+          track("command_sent");
           return send(response, 202, { command: queued });
         }
 
@@ -1468,6 +1485,7 @@ export function createApp(options: AppOptions) {
           log,
         );
         if (!result.ok) return send(response, result.status, { error: result.error });
+        track("feedback_sent");
         return send(response, 201, { feedback: { id: result.value.id, at: result.value.at } });
       }
 
@@ -1480,8 +1498,15 @@ export function createApp(options: AppOptions) {
         const matches = presented.length === expected.length &&
           timingSafeEqual(Buffer.from(presented), Buffer.from(expected));
         if (!matches) return send(response, 401, { error: "sign in first" });
-        const range = url.searchParams.get("range");
-        return send(response, 200, accountStats(await store.accountActivity(), isStatsRange(range) ? range : "7d"));
+        const requested = url.searchParams.get("range");
+        const range = isStatsRange(requested) ? requested : "7d";
+        const now = Date.now();
+        return send(response, 200, accountStats(
+          await store.accountActivity(),
+          range,
+          now,
+          await store.appEvents(dayStart(rangeStart(range, now))),
+        ));
       }
 
       /* ---- Inbox ---- */
diff --git a/app/server/lib/migrations/013_app_events.sql b/app/server/lib/migrations/013_app_events.sql
new file mode 100644
index 0000000..1ac6cc9
--- /dev/null
+++ b/app/server/lib/migrations/013_app_events.sql
@@ -0,0 +1,13 @@
+-- What accounts did in the app, counted by day and by kind and nothing else:
+-- no account, no address, no session. The statistics dashboard reads totals
+-- over a range from it, so it can say how many machines were linked or
+-- commands sent next to how many accounts there are. Rows are dropped after
+-- the same 400 days as activity days.
+CREATE TABLE IF NOT EXISTS app_events (
+  event TEXT    NOT NULL,
+  day   BIGINT  NOT NULL,
+  count INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (event, day)
+);
+
+CREATE INDEX IF NOT EXISTS app_events_day ON app_events (day);
diff --git a/app/server/lib/store-conformance.test.ts b/app/server/lib/store-conformance.test.ts
index 069f22c..2c924c4 100644
--- a/app/server/lib/store-conformance.test.ts
+++ b/app/server/lib/store-conformance.test.ts
@@ -149,6 +149,7 @@ function feedback(overrides: Partial<Feedback> = {}): Feedback {
 const TABLES = [
   "feedback",
   "account_activity",
+  "app_events",
   "deleted_accounts",
   "account_keys",
   "session_key_shares",
@@ -943,6 +944,29 @@ for (const implementation of implementations) {
       });
     });
 
+    describe("app events", () => {
+      const day = 24 * 60 * 60_000;
+      const noon = 10 * day + 12 * 60 * 60_000;
+
+      it("counts by kind and day, sums from a day on, and says nothing about who", async () => {
+        await store.recordAppEvent("machine_linked", noon);
+        await store.recordAppEvent("machine_linked", noon + 60_000);
+        await store.recordAppEvent("command_sent", noon + day);
+        expect(await store.appEvents(0)).toEqual([
+          { event: "command_sent", count: 1 },
+          { event: "machine_linked", count: 2 },
+        ]);
+        expect(await store.appEvents(11 * day)).toEqual([{ event: "command_sent", count: 1 }]);
+        expect(await store.appEvents(12 * day)).toEqual([]);
+      });
+
+      it("forgets counts older than the memory window when purging", async () => {
+        await store.recordAppEvent("vault_created", noon);
+        await store.purgeExpired(noon + 401 * day);
+        expect(await store.appEvents(0)).toEqual([]);
+      });
+    });
+
     describe("claiming an organization on first sight", () => {
       /*
        * Signing in fires several requests at once. On a new account none of
diff --git a/app/server/lib/store-memory.ts b/app/server/lib/store-memory.ts
index ed11874..98fe30a 100644
--- a/app/server/lib/store-memory.ts
+++ b/app/server/lib/store-memory.ts
@@ -14,6 +14,8 @@ import {
 } from "./store";
 import type {
   AccountActivity,
+  AppEvent,
+  AppEventCount,
   AccountKey,
   AgentCommand,
   AuditEvent,
@@ -73,6 +75,7 @@ interface Shape {
   accountKeys: AccountKey[];
   deletedAccounts: { uid: string; deletedAt: number }[];
   accountActivity: { uid: string; day: number }[];
+  appEvents: { event: AppEvent; day: number; count: number }[];
   teamKeys: TeamKey[];
   teamKeyShares: TeamKeyShare[];
 }
@@ -81,7 +84,7 @@ const EMPTY: Shape = {
   codes: [], tokens: [], sessions: [], commands: [],
   organizations: [], memberships: [], invites: [], audit: [],
   comments: [], notifications: [], feedback: [], accountKeys: [], deletedAccounts: [],
-  accountActivity: [], teamKeys: [], teamKeyShares: [],
+  accountActivity: [], appEvents: [], teamKeys: [], teamKeyShares: [],
 };
 
 /**
@@ -148,6 +151,7 @@ export class MemoryStore implements Store {
         accountKeys: parsed.accountKeys ?? [],
         deletedAccounts: parsed.deletedAccounts ?? [],
         accountActivity: parsed.accountActivity ?? [],
+        appEvents: parsed.appEvents ?? [],
         teamKeys: parsed.teamKeys ?? [],
         teamKeyShares: parsed.teamKeyShares ?? [],
       };
@@ -823,6 +827,9 @@ export class MemoryStore implements Store {
     this.data.accountActivity = this.data.accountActivity.filter(
       (entry) => entry.day >= now - ACCOUNT_ACTIVITY_MEMORY_MS,
     );
+    this.data.appEvents = this.data.appEvents.filter(
+      (entry) => entry.day >= now - ACCOUNT_ACTIVITY_MEMORY_MS,
+    );
     const before = this.data.codes.length;
     this.data.codes = this.data.codes.filter((entry) => entry.expiresAt > now);
     /* Finished commands are only kept long enough to be reported back. */
@@ -893,6 +900,26 @@ export class MemoryStore implements Store {
     }));
   }
 
+  /* ---- App events ---- */
+
+  async recordAppEvent(event: AppEvent, now = Date.now()): Promise<void> {
+    const day = Math.floor(now / DAY_MS) * DAY_MS;
+    const row = this.data.appEvents.find((entry) => entry.event === event && entry.day === day);
+    if (row) row.count += 1;
+    else this.data.appEvents.push({ event, day, count: 1 });
+    this.flush();
+  }
+
+  async appEvents(sinceDay: number): Promise<AppEventCount[]> {
+    const totals = new Map<AppEvent, number>();
+    for (const entry of this.data.appEvents) {
+      if (entry.day >= sinceDay) totals.set(entry.event, (totals.get(entry.event) ?? 0) + entry.count);
+    }
+    return [...totals.entries()]
+      .map(([event, count]) => ({ event, count }))
+      .sort((left, right) => left.event.localeCompare(right.event));
+  }
+
   async tokensForImport(): Promise<CliToken[]> {
     return this.data.tokens;
   }
diff --git a/app/server/lib/store-postgres.ts b/app/server/lib/store-postgres.ts
index 4331c47..0d2fa99 100644
--- a/app/server/lib/store-postgres.ts
+++ b/app/server/lib/store-postgres.ts
@@ -16,6 +16,8 @@ import {
 } from "./store";
 import type {
   AccountActivity,
+  AppEvent,
+  AppEventCount,
   AccountKey,
   AgentCommand,
   AuditEvent,
@@ -1615,10 +1617,29 @@ export class PostgresStore implements Store {
     }));
   }
 
+  /* ---- App events ---- */
+
+  async recordAppEvent(event: AppEvent, now = Date.now()): Promise<void> {
+    await this.pool.query(
+      `INSERT INTO app_events (event, day, count) VALUES ($1, $2, 1)
+       ON CONFLICT (event, day) DO UPDATE SET count = app_events.count + 1`,
+      [event, Math.floor(now / DAY_MS) * DAY_MS],
+    );
+  }
+
+  async appEvents(sinceDay: number): Promise<AppEventCount[]> {
+    const rows = await this.rows(
+      "SELECT event, SUM(count) AS count FROM app_events WHERE day >= $1 GROUP BY event ORDER BY event",
+      [sinceDay],
+    );
+    return rows.map((row) => ({ event: row.event as AppEvent, count: Number(row.count) }));
+  }
+
   /* ---- Housekeeping ---- */
 
   async purgeExpired(now = Date.now()): Promise<void> {
     await this.pool.query("DELETE FROM account_activity WHERE day < $1", [now - ACCOUNT_ACTIVITY_MEMORY_MS]);
+    await this.pool.query("DELETE FROM app_events WHERE day < $1", [now - ACCOUNT_ACTIVITY_MEMORY_MS]);
     await this.pool.query("DELETE FROM auth_codes WHERE expires_at <= $1", [now]);
     /* Finished commands are only kept long enough to be reported back. */
     await this.pool.query("DELETE FROM agent_commands WHERE done_at IS NOT NULL AND done_at < $1", [
diff --git a/app/server/lib/store.ts b/app/server/lib/store.ts
index 36c30ab..97e1d49 100644
--- a/app/server/lib/store.ts
+++ b/app/server/lib/store.ts
@@ -1,6 +1,8 @@
 import type { Invite, Membership, Organization, Role } from "./orgs";
 import type {
   AccountActivity,
+  AppEvent,
+  AppEventCount,
   AccountKey,
   AgentCommand,
   AuditEvent,
@@ -258,6 +260,12 @@ export interface Store {
   /** Every account's sign-up time and active days, with no identifiers. */
   accountActivity(): Promise<AccountActivity[]>;
 
+  /* ---- App events ---- */
+  /** Counts one thing an account did, on the day it did it. Nothing about who. */
+  recordAppEvent(event: AppEvent, now?: number): Promise<void>;
+  /** Totals per kind over days on or after `sinceDay` (midnight UTC), for the dashboard. */
+  appEvents(sinceDay: number): Promise<AppEventCount[]>;
+
   /* ---- Housekeeping ---- */
   purgeExpired(now?: number): Promise<void>;
   close(): Promise<void>;
diff --git a/app/server/lib/types.ts b/app/server/lib/types.ts
index 24c43fb..248d990 100644
--- a/app/server/lib/types.ts
+++ b/app/server/lib/types.ts
@@ -206,6 +206,27 @@ export interface AccountActivity {
   days: number[];
 }
 
+/**
+ * Things an account can do in the app that the statistics dashboard wants
+ * counted, without ever saying which account: linked a machine, registered
+ * a session, sent a command. Counted by day and by kind, nothing else.
+ */
+export const APP_EVENTS = [
+  "machine_linked",
+  "session_registered",
+  "command_sent",
+  "vault_created",
+  "invite_created",
+  "invite_accepted",
+  "feedback_sent",
+] as const;
+export type AppEvent = (typeof APP_EVENTS)[number];
+
+export interface AppEventCount {
+  event: AppEvent;
+  count: number;
+}
+
 export interface SessionRecord {
   id: string;
   uid: string;
diff --git a/app/server/routes/stats.test.ts b/app/server/routes/stats.test.ts
index f548833..050fdfe 100644
--- a/app/server/routes/stats.test.ts
+++ b/app/server/routes/stats.test.ts
@@ -5,6 +5,14 @@ import { accountStats, buildRetentionCohorts, DAY_MS, WEEK_MS, weekStart } from
 const monday = Date.UTC(2026, 8, 7);
 const now = monday + 2 * WEEK_MS + 3 * DAY_MS + 9 * 60 * 60_000;
 
+describe("accountStats events", () => {
+  it("passes what accounts did through as counts by kind, and an empty object when nothing was counted", () => {
+    const stats = accountStats([], "7d", now, [{ event: "machine_linked", count: 2 }, { event: "command_sent", count: 5 }]);
+    expect(stats.events).toEqual({ machine_linked: 2, command_sent: 5 });
+    expect(accountStats([], "7d", now).events).toEqual({});
+  });
+});
+
 describe("accountStats", () => {
   const accounts = [
     /* signed up week 0, used it in weeks 1 and 2 */
diff --git a/app/server/routes/stats.ts b/app/server/routes/stats.ts
index 6b3ad4a..9528143 100644
--- a/app/server/routes/stats.ts
+++ b/app/server/routes/stats.ts
@@ -1,4 +1,5 @@
 import type { AccountActivity } from "../lib/store";
+import type { AppEventCount } from "../lib/types";
 
 /*
  * Account figures for the statistics dashboard on stats.shell.online.
@@ -35,6 +36,8 @@ export interface AccountStats {
   activeInRange: number;
   newByDay: { day: number; count: number }[];
   cohorts: RetentionCohort[];
+  /** Things done in the range, by kind: machines linked, commands sent. Counts of things, not of accounts. */
+  events: Record<string, number>;
 }
 
 export function isStatsRange(value: unknown): value is StatsRange {
@@ -59,7 +62,12 @@ export function rangeStart(range: StatsRange, now: number): number {
   return 0;
 }
 
-export function accountStats(activity: AccountActivity[], range: StatsRange, now = Date.now()): AccountStats {
+export function accountStats(
+  activity: AccountActivity[],
+  range: StatsRange,
+  now = Date.now(),
+  events: AppEventCount[] = [],
+): AccountStats {
   const start = rangeStart(range, now);
   const startDay = dayStart(start);
   const newByDay = new Map<number, number>();
@@ -86,6 +94,7 @@ export function accountStats(activity: AccountActivity[], range: StatsRange, now
     activeInRange,
     newByDay: [...newByDay.entries()].map(([day, count]) => ({ day, count })),
     cohorts: buildRetentionCohorts(rows, now),
+    events: Object.fromEntries(events.map((entry) => [entry.event, entry.count])),
   };
 }
 
diff --git a/app/src/routes/Privacy.tsx b/app/src/routes/Privacy.tsx
index 02e91e2..673cd11 100644
--- a/app/src/routes/Privacy.tsx
+++ b/app/src/routes/Privacy.tsx
@@ -340,7 +340,9 @@ export function Privacy() {
             page views, installer downloads and sessions opened, with a device
             class, a client name and the referring site. To tell one visitor
             from another they keep, for 120 days, a keyed hash of the network
-            address and browser family. The key never leaves the server, the
+            address and browser family; for the installer and the command-line
+            tool, a keyed hash of the address alone, so an install can be
+            followed to a first session. The key never leaves the server, the
             address itself is not stored, and nothing in that record says who
             a visitor is. They record no session identifiers, URLs, commands,
             terminal content or full user-agent strings.
diff --git a/docs/self-hosting.md b/docs/self-hosting.md
index a5bb176..853a223 100644
--- a/docs/self-hosting.md
+++ b/docs/self-hosting.md
@@ -68,7 +68,9 @@ Set `SHELL_ONLINE_SERVER` to the URL Wrangler prints. Add a `routes` entry to
 the copied config for a custom domain. The Worker path requires Durable
 Objects, Rate Limiting, Analytics Engine, and static assets. Keep every
 documentation path in `run_worker_first`: a page served straight from the
-assets binding is never counted.
+assets binding is never counted. `npm run deploy:production` refuses a
+production config that routes fewer of these paths through the Worker than
+`wrangler.example.jsonc` does.
 
 The private statistics dashboard is optional and configured with Worker
 secrets (`npx wrangler secret put <NAME>`):
@@ -76,7 +78,7 @@ secrets (`npx wrangler secret put <NAME>`):
 | Secret | Purpose |
 |---|---|
 | `STATS_PASSWORD` | Opens the dashboard on the stats hostname; at least 12 characters |
-| `STATS_VISITOR_SALT` | Lets the dashboard count people as keyed hashes of address and browser family; at least 16 characters. Without it every unique, new, returning and retention figure stays at zero |
+| `STATS_VISITOR_SALT` | Lets the dashboard count people as keyed hashes of address and browser family (address alone for machines running the installer or the CLI, so an install can be followed to a first session); at least 16 characters. Without it every unique, new, returning and retention figure stays at zero |
 | `APP_STATS_URL` | The accounts app's origin, for exact account counts and sign-up cohorts |
 | `APP_STATS_TOKEN` | The token the accounts app expects; the same value as its `STATS_TOKEN` |
 
diff --git a/public/install b/public/install
index 0522aa7..0f94ffb 100755
--- a/public/install
+++ b/public/install
@@ -1,11 +1,32 @@
 #!/bin/sh
 set -eu
 
+# When it finishes, and when it fails, this script tells shell.online how it
+# went: one request carrying a single word (ok, unsupported_arch,
+# checksum_mismatch, ...) and the binary name, nothing else, so that a
+# platform that keeps failing gets noticed and fixed. Set
+# SHELL_ONLINE_INSTALL_REPORT=0 to skip it.
+
 fail() {
   printf 'shell.online: %s\n' "$1" >&2
+  report "${2:-failed}"
   exit 1
 }
 
+report() {
+  [ "${SHELL_ONLINE_INSTALL_REPORT:-1}" != 0 ] || return 0
+  case "${base_url:-}" in
+    http://*|https://*) ;;
+    *) return 0 ;;
+  esac
+  report_url="$base_url/install/report?outcome=$1&platform=${binary_name:-unknown}"
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsS -m 5 -o /dev/null "$report_url" >/dev/null 2>&1 || true
+  elif command -v wget >/dev/null 2>&1; then
+    wget -q -T 5 -O /dev/null "$report_url" >/dev/null 2>&1 || true
+  fi
+}
+
 base_url=${SHELL_ONLINE_BASE_URL:-https://shell.online}
 system_name=$(uname -s 2>/dev/null || true)
 machine_name=$(uname -m 2>/dev/null || true)
@@ -18,7 +39,7 @@ case "$system_name" in
   NetBSD) platform=netbsd ;;
   DragonFly) platform=dragonfly ;;
   SunOS) platform=solaris ;;
-  *) fail "unsupported operating system: ${system_name:-unknown} (supported: macOS, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly BSD, and Solaris)" ;;
+  *) fail "unsupported operating system: ${system_name:-unknown} (supported: macOS, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly BSD, and Solaris)" unsupported_os ;;
 esac
 
 case "$machine_name" in
@@ -44,7 +65,7 @@ case "$machine_name" in
   riscv64) architecture=riscv64 ;;
   s390x) architecture=s390x ;;
   loongarch64|loong64) architecture=loong64 ;;
-  *) fail "unsupported architecture: ${machine_name:-unknown}; see https://shell.online/docs/platforms/" ;;
+  *) fail "unsupported architecture: ${machine_name:-unknown}; see https://shell.online/docs/platforms/" unsupported_arch ;;
 esac
 
 if [ -n "${SHELL_ONLINE_INSTALL_DIR:-}" ]; then
@@ -56,23 +77,23 @@ elif [ -n "${XDG_BIN_HOME:-}" ]; then
 elif [ -n "${HOME:-}" ]; then
   install_dir=$HOME/.local/bin
 else
-  fail 'HOME is not set; set SHELL_ONLINE_INSTALL_DIR to an absolute writable directory'
+  fail 'HOME is not set; set SHELL_ONLINE_INSTALL_DIR to an absolute writable directory' no_home
 fi
 
 case "$install_dir" in
   /*) ;;
-  *) fail "install directory must be absolute: $install_dir" ;;
+  *) fail "install directory must be absolute: $install_dir" install_dir_relative ;;
 esac
 case "$install_dir" in
-  *:*) fail "install directory cannot contain a colon: $install_dir" ;;
+  *:*) fail "install directory cannot contain a colon: $install_dir" install_dir_colon ;;
 esac
 
 temporary_root=${TMPDIR:-/tmp}
 if [ ! -d "$temporary_root" ] || [ ! -w "$temporary_root" ]; then
-  fail "temporary directory is not writable: $temporary_root"
+  fail "temporary directory is not writable: $temporary_root" temp_dir_unwritable
 fi
 temporary_dir=$(mktemp -d "$temporary_root/shell-online.XXXXXX") ||
-  fail "could not create a temporary directory under $temporary_root"
+  fail "could not create a temporary directory under $temporary_root" temp_dir
 trap 'rm -rf "$temporary_dir"' EXIT HUP INT TERM
 binary_name="shell-$platform-$architecture"
 binary_url="$base_url/downloads/$binary_name"
@@ -82,14 +103,14 @@ download() {
   destination=$2
   if command -v curl >/dev/null 2>&1; then
     if ! curl -fsSL "$source_url" -o "$destination"; then
-      fail "download failed: $source_url"
+      fail "download failed: $source_url" download_failed
     fi
   elif command -v wget >/dev/null 2>&1; then
     if ! wget -q "$source_url" -O "$destination"; then
-      fail "download failed: $source_url"
+      fail "download failed: $source_url" download_failed
     fi
   else
-    fail 'curl or wget is required; install either tool and run the installer again'
+    fail 'curl or wget is required; install either tool and run the installer again' no_downloader
   fi
 }
 
@@ -98,18 +119,18 @@ download "$base_url/downloads/SHA256SUMS" "$temporary_dir/SHA256SUMS"
 manifest_first_line=$(sed -n '1p' "$temporary_dir/SHA256SUMS")
 case "$manifest_first_line" in
   '<!doctype html'*|'<html'*)
-    fail "expected a checksum manifest, received HTML from $base_url/downloads/SHA256SUMS"
+    fail "expected a checksum manifest, received HTML from $base_url/downloads/SHA256SUMS" manifest_html
     ;;
 esac
 expected=$(awk -v filename="$binary_name" '$2 == filename { print $1; exit }' "$temporary_dir/SHA256SUMS")
 
 case "$expected" in
   *[!0-9a-f]*|'')
-    fail "release manifest has no valid checksum for $binary_name"
+    fail "release manifest has no valid checksum for $binary_name" manifest_missing
     ;;
 esac
 if [ "${#expected}" -ne 64 ]; then
-  fail "release manifest has an invalid checksum for $binary_name"
+  fail "release manifest has an invalid checksum for $binary_name" manifest_invalid
 fi
 
 if command -v sha256sum >/dev/null 2>&1; then
@@ -117,18 +138,18 @@ if command -v sha256sum >/dev/null 2>&1; then
 elif command -v shasum >/dev/null 2>&1; then
   actual=$(shasum -a 256 "$temporary_dir/shell" | awk '{print $1}')
 else
-  fail 'sha256sum or shasum is required to verify the downloaded binary'
+  fail 'sha256sum or shasum is required to verify the downloaded binary' no_sha_tool
 fi
 
 if [ "$actual" != "$expected" ]; then
-  fail "downloaded binary failed checksum verification (expected $expected, received $actual)"
+  fail "downloaded binary failed checksum verification (expected $expected, received $actual)" checksum_mismatch
 fi
 
 if ! mkdir -p "$install_dir"; then
-  fail "could not create install directory: $install_dir"
+  fail "could not create install directory: $install_dir" install_dir_create
 fi
 if [ ! -d "$install_dir" ] || [ ! -w "$install_dir" ]; then
-  fail "install directory is not writable: $install_dir (set SHELL_ONLINE_INSTALL_DIR to another directory)"
+  fail "install directory is not writable: $install_dir (set SHELL_ONLINE_INSTALL_DIR to another directory)" install_dir_unwritable
 fi
 
 target=$install_dir/shell
@@ -143,11 +164,11 @@ fi
 
 if command -v install >/dev/null 2>&1; then
   if ! install -m 0755 "$temporary_dir/shell" "$target"; then
-    fail "could not write executable: $target"
+    fail "could not write executable: $target" write_failed
   fi
 else
   if ! cp "$temporary_dir/shell" "$target" || ! chmod 0755 "$target"; then
-    fail "could not write executable: $target"
+    fail "could not write executable: $target" write_failed
   fi
 fi
 
@@ -207,6 +228,7 @@ if [ -n "$resolved_shell" ] && [ "$resolved_shell" != "$target" ]; then
 fi
 
 "$target" --version
+report ok
 printf '\nNext:\n'
 printf '  shell <your-command>   Run it in the background and print its browser link\n'
 printf '  shell help             See the guided start, share, and stop flow\n'
diff --git a/public/install.ps1 b/public/install.ps1
index 6dec300..82e607c 100644
--- a/public/install.ps1
+++ b/public/install.ps1
@@ -6,7 +6,25 @@ param(
 
 $ErrorActionPreference = "Stop"
 
-function Fail([string]$Message) {
+# When it finishes, and when it fails, this script tells shell.online how it
+# went: one request carrying a single word and the binary name, nothing else,
+# so that a platform that keeps failing gets noticed and fixed. Set
+# SHELL_ONLINE_INSTALL_REPORT=0 to skip it.
+$script:reported = $false
+function Report([string]$Outcome) {
+  if ($env:SHELL_ONLINE_INSTALL_REPORT -eq "0") { return }
+  if ($BaseUrl -notmatch '^https?://') { return }
+  $script:reported = $true
+  $platform = if ($script:artifact) { $script:artifact } else { "unknown" }
+  try {
+    Invoke-WebRequest -UseBasicParsing -TimeoutSec 5 -Uri "$BaseUrl/install/report?outcome=$Outcome&platform=$platform" | Out-Null
+  } catch {
+    # Reporting must never change how the install went.
+  }
+}
+
+function Fail([string]$Message, [string]$Outcome = "failed") {
+  Report $Outcome
   Write-Error "shell.online: $Message"
   exit 1
 }
@@ -16,7 +34,7 @@ $architecture = switch ($nativeArchitecture.ToUpperInvariant()) {
   "AMD64" { "amd64" }
   "X86" { "386" }
   "ARM64" { "arm64" }
-  default { Fail "unsupported Windows architecture: $nativeArchitecture (supported: x86, x64, ARM64)" }
+  default { Fail "unsupported Windows architecture: $nativeArchitecture (supported: x86, x64, ARM64)" "unsupported_arch" }
 }
 
 if (-not $InstallDir) {
@@ -34,10 +52,10 @@ try {
   Invoke-WebRequest -UseBasicParsing -Uri "$BaseUrl/downloads/SHA256SUMS" -OutFile $manifestPath
   $manifest = Get-Content -Raw $manifestPath
   $match = [regex]::Match($manifest, "(?m)^([a-f0-9]{64})  " + [regex]::Escape($artifact) + "$")
-  if (-not $match.Success) { Fail "release manifest has no valid checksum for $artifact" }
+  if (-not $match.Success) { Fail "release manifest has no valid checksum for $artifact" "manifest_missing" }
   $expected = $match.Groups[1].Value
   $actual = (Get-FileHash -Algorithm SHA256 $binaryPath).Hash.ToLowerInvariant()
-  if ($actual -ne $expected) { Fail "downloaded binary failed checksum verification" }
+  if ($actual -ne $expected) { Fail "downloaded binary failed checksum verification" "checksum_mismatch" }
 
   New-Item -ItemType Directory -Force -Path $InstallDir | Out-Null
   $target = Join-Path $InstallDir "shell.exe"
@@ -55,10 +73,15 @@ try {
     Write-Host "  [Environment]::SetEnvironmentVariable('Path', `"$InstallDir;`" + [Environment]::GetEnvironmentVariable('Path', 'User'), 'User')"
   }
   & $target --version
+  Report "ok"
   Write-Host ""
   Write-Host "Next:"
   Write-Host "  shell <your-command>   Run it in the background and print its browser link"
   Write-Host "  shell help             See the guided start, share, and stop flow"
+} catch {
+  # Fail has already reported its own reason; anything else is unspecified.
+  if (-not $script:reported) { Report "failed" }
+  throw
 } finally {
   Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $temporaryDirectory
 }
diff --git a/scripts/check-worker-routing.mjs b/scripts/check-worker-routing.mjs
new file mode 100644
index 0000000..543fe6d
--- /dev/null
+++ b/scripts/check-worker-routing.mjs
@@ -0,0 +1,83 @@
+/*
+ * A page the Worker never sees is never counted. Static assets are served
+ * before the Worker runs unless their path is in `assets.run_worker_first`,
+ * so a deployment config that lists fewer paths than the example config
+ * quietly drops those pages from the statistics dashboard. Production once
+ * served the web app, CLI, Refstream and platforms guides that way, and
+ * "Visited the site" was short by every one of their views and readers.
+ *
+ * The example config is the reference: a deployment config must route at
+ * least what it routes. Run before building, so a bad config costs nothing.
+ *
+ *   node scripts/check-worker-routing.mjs <reference.jsonc> <deployment.jsonc>
+ */
+import { readFileSync } from "node:fs";
+
+const [referencePath, deploymentPath] = process.argv.slice(2);
+if (!referencePath || !deploymentPath) {
+  console.error("usage: check-worker-routing.mjs <reference.jsonc> <deployment.jsonc>");
+  process.exit(2);
+}
+
+const reference = workerFirstPaths(referencePath);
+const deployment = workerFirstPaths(deploymentPath);
+const missing = deployment === true || reference === true
+  ? []
+  : reference.filter((path) => !deployment.includes(path));
+if (missing.length > 0) {
+  console.error(`${deploymentPath} does not route these paths through the Worker, so their views would never be counted:`);
+  for (const path of missing) console.error(`  ${path}`);
+  console.error(`Add them to assets.run_worker_first, as in ${referencePath}.`);
+  process.exit(1);
+}
+console.log(`${deploymentPath} routes every counted path through the Worker.`);
+
+/** The `assets.run_worker_first` list, or true when the config routes everything through the Worker. */
+function workerFirstPaths(path) {
+  let config;
+  try {
+    config = JSON.parse(stripJsonc(readFileSync(path, "utf8")));
+  } catch (error) {
+    console.error(`${path}: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  const paths = config?.assets?.run_worker_first;
+  if (paths === true) return true;
+  if (!Array.isArray(paths) || !paths.every((entry) => typeof entry === "string")) {
+    console.error(`${path}: assets.run_worker_first must be a list of paths, or true`);
+    process.exit(1);
+  }
+  return paths;
+}
+
+/** Comments and trailing commas outside strings, which is all JSONC adds to JSON. */
+function stripJsonc(source) {
+  let output = "";
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === '"') {
+      const end = closingQuote(source, index);
+      output += source.slice(index, end + 1);
+      index = end + 1;
+    } else if (char === "/" && source[index + 1] === "/") {
+      const end = source.indexOf("\n", index);
+      index = end === -1 ? source.length : end;
+    } else if (char === "/" && source[index + 1] === "*") {
+      const end = source.indexOf("*/", index + 2);
+      index = end === -1 ? source.length : end + 2;
+    } else {
+      output += char;
+      index += 1;
+    }
+  }
+  return output.replace(/,(\s*[\]}])/g, "$1");
+}
+
+function closingQuote(source, start) {
+  for (let index = start + 1; index < source.length; index += 1) {
+    if (source[index] === "\\") index += 1;
+    else if (source[index] === '"') return index;
+  }
+  return source.length - 1;
+}
diff --git a/scripts/deploy-production.sh b/scripts/deploy-production.sh
index f1fdded..0e37256 100755
--- a/scripts/deploy-production.sh
+++ b/scripts/deploy-production.sh
@@ -13,6 +13,11 @@ if [ ! -f "$config" ]; then
   exit 1
 fi
 
+# A page served straight from the assets binding never reaches the Worker and
+# is never counted. Refuse a config that routes fewer paths through the Worker
+# than the example does, before anything is built.
+node "$repository_root/scripts/check-worker-routing.mjs" "$repository_root/wrangler.example.jsonc" "$config"
+
 # Wrangler resolves `main` and `assets.directory` beside its config file. A
 # private config kept in another checkout would otherwise deploy that other
 # checkout while this script builds the current one. Stage only the config
diff --git a/scripts/test-deploy-production.sh b/scripts/test-deploy-production.sh
index 27bd37b..d88b1c2 100755
--- a/scripts/test-deploy-production.sh
+++ b/scripts/test-deploy-production.sh
@@ -9,7 +9,9 @@ fake_bin="$test_root/bin"
 command_log="$test_root/commands"
 config="$test_root/wrangler.production.jsonc"
 mkdir -p "$fake_bin"
-printf 'production-test-config\n' > "$config"
+# A production config routes at least what the example routes through the
+# Worker; the example itself, with a comment, stands in for one.
+{ printf '// production-test-config\n'; cat "$repository_root/wrangler.example.jsonc"; } > "$config"
 
 cat > "$fake_bin/npm" <<'SCRIPT'
 #!/bin/sh
@@ -28,7 +30,7 @@ case "$4" in
   "$SHELL_ONLINE_TEST_REPOSITORY_ROOT"/.wrangler.production.*.jsonc) ;;
   *) printf 'config was not staged beside the source: %s\n' "$4" >&2; exit 43 ;;
 esac
-test "$(cat "$4")" = "production-test-config"
+cmp -s "$4" "$SHELL_ONLINE_TEST_CONFIG"
 shift 4
 printf 'npx wrangler deploy --config <repo-local>%s\n' "${*:+ $*}" >> "$SHELL_ONLINE_TEST_COMMAND_LOG"
 SCRIPT
@@ -37,6 +39,7 @@ chmod 755 "$fake_bin/npm" "$fake_bin/npx"
 
 SHELL_ONLINE_TEST_COMMAND_LOG="$command_log" \
 SHELL_ONLINE_TEST_REPOSITORY_ROOT="$repository_root" \
+SHELL_ONLINE_TEST_CONFIG="$config" \
 SHELL_ONLINE_WRANGLER_CONFIG="$config" \
 PATH="$fake_bin:$PATH" \
   sh "$repository_root/scripts/deploy-production.sh"
@@ -50,6 +53,7 @@ set +e
 SHELL_ONLINE_TEST_VERIFY_FAIL=1 \
 SHELL_ONLINE_TEST_COMMAND_LOG="$command_log" \
 SHELL_ONLINE_TEST_REPOSITORY_ROOT="$repository_root" \
+SHELL_ONLINE_TEST_CONFIG="$config" \
 SHELL_ONLINE_WRANGLER_CONFIG="$config" \
 PATH="$fake_bin:$PATH" \
   sh "$repository_root/scripts/deploy-production.sh"
@@ -69,4 +73,22 @@ if SHELL_ONLINE_TEST_COMMAND_LOG="$command_log" \
 fi
 test ! -s "$command_log"
 
+# A config that serves a documentation page from the assets binding would
+# leave that page out of the statistics; the deploy must refuse it before
+# building anything.
+short_config="$test_root/short.jsonc"
+grep -v '"/app/\*",' "$config" > "$short_config"
+: > "$command_log"
+if SHELL_ONLINE_TEST_COMMAND_LOG="$command_log" \
+  SHELL_ONLINE_TEST_REPOSITORY_ROOT="$repository_root" \
+  SHELL_ONLINE_TEST_CONFIG="$short_config" \
+  SHELL_ONLINE_WRANGLER_CONFIG="$short_config" \
+  PATH="$fake_bin:$PATH" \
+  sh "$repository_root/scripts/deploy-production.sh" 2>"$test_root/short.err"; then
+  printf 'Deployment unexpectedly accepted a config that skips the Worker for /app/*.\n' >&2
+  exit 1
+fi
+grep -q '/app/\*' "$test_root/short.err"
+test ! -s "$command_log"
+
 echo "production deployment guard tests passed"
diff --git a/scripts/test-install.sh b/scripts/test-install.sh
index 23de7bd..1d7d9d8 100755
--- a/scripts/test-install.sh
+++ b/scripts/test-install.sh
@@ -1,6 +1,11 @@
 #!/bin/sh
 set -eu
 
+# The installer reports its outcome to its base URL, which for most of these
+# scenarios is the real one. Keep it quiet; one scenario below turns it back
+# on against a mock curl to check what it would send.
+export SHELL_ONLINE_INSTALL_REPORT=0
+
 test_root=$(mktemp -d "${TMPDIR:-/tmp}/shell-online-install-test.XXXXXX")
 trap 'rm -rf "$test_root"' EXIT HUP INT TERM
 
@@ -130,4 +135,32 @@ chmod 0755 "$shadow_dir/shell"
 output=$(PATH=$shadow_dir:$PATH run_installer "$shadow_install" env)
 assert_contains "$output" "Warning: shell currently resolves to $shadow_dir/shell"
 
+# The installer's last word: one request with the outcome and the binary name,
+# through curl when it has it, and nothing at all when told to keep quiet.
+report_bin=$test_root/report-bin
+report_log=$test_root/report.log
+mkdir -p "$report_bin"
+printf '%s\n' '#!/bin/sh' 'printf "%s\\n" "$*" >> "$SHELL_ONLINE_TEST_REPORT_LOG"' 'exit 22' > "$report_bin/curl"
+chmod 0755 "$report_bin/curl"
+: > "$report_log"
+if output=$(SHELL_ONLINE_INSTALL_REPORT=1 SHELL_ONLINE_TEST_REPORT_LOG=$report_log \
+  SHELL_ONLINE_BASE_URL=https://installer.invalid SHELL_ONLINE_INSTALL_DIR=$test_root/report-install \
+  PATH=$report_bin:$PATH sh "$installer" 2>&1); then
+  printf 'Installer with a failing download unexpectedly succeeded.\n' >&2
+  exit 1
+fi
+assert_contains "$output" "download failed"
+assert_contains "$(cat "$report_log")" "https://installer.invalid/install/report?outcome=download_failed&platform=shell-"
+: > "$report_log"
+if output=$(SHELL_ONLINE_INSTALL_REPORT=0 SHELL_ONLINE_TEST_REPORT_LOG=$report_log \
+  SHELL_ONLINE_BASE_URL=https://installer.invalid SHELL_ONLINE_INSTALL_DIR=$test_root/report-install \
+  PATH=$report_bin:$PATH sh "$installer" 2>&1); then
+  printf 'Installer with a failing download unexpectedly succeeded.\n' >&2
+  exit 1
+fi
+if grep -q "install/report" "$report_log"; then
+  printf 'Installer reported its outcome although SHELL_ONLINE_INSTALL_REPORT=0.\n' >&2
+  exit 1
+fi
+
 printf 'Installer integration scenarios passed.\n'
diff --git a/shared/stats-copy.ts b/shared/stats-copy.ts
new file mode 100644
index 0000000..86384a4
--- /dev/null
+++ b/shared/stats-copy.ts
@@ -0,0 +1,253 @@
+import type { StatsSnapshot } from "./stats";
+import { DAY_MS } from "./stats-snapshot";
+
+/*
+ * The words on the statistics dashboard that are computed from its numbers:
+ * the sentence at the top of each panel, the chip beside a headline figure,
+ * and the names and formats everything is shown in. No DOM in here, so the
+ * copy can be tested as plainly as the figures it describes.
+ */
+
+export const numberFormatter = new Intl.NumberFormat("en-US", { maximumFractionDigits: 1 });
+export const integerFormatter = new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 });
+
+export function ratio(numerator: number, denominator: number): number {
+  return denominator === 0 ? 0 : Math.min(1, numerator / denominator);
+}
+
+export function formatPercent(value: number): string {
+  return `${Math.round(Math.max(0, Math.min(1, value)) * 100)}%`;
+}
+
+export function formatDuration(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds <= 0) return "0s";
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  if (seconds < 3_600) return `${Math.round(seconds / 60)}m`;
+  if (seconds < 86_400) return `${numberFormatter.format(seconds / 3_600)}h`;
+  return `${numberFormatter.format(seconds / 86_400)}d`;
+}
+
+export function humanize(value: string): string {
+  const aliases: Record<string, string> = {
+    cli: "CLI",
+    web: "Web",
+    direct: "Direct",
+    internal: "Internal",
+    hacker_news: "Hacker News",
+    task_exit: "Task exited",
+    persistent_task_exit: "Persistent task exited",
+    disconnected_timeout: "Disconnected timeout",
+    never_started: "Never started",
+    expired: "Expired",
+    session_full: "Session was full",
+    typed_into_read_only: "Typed into a read-only session",
+    viewer_read_only: "Read-only",
+    viewer_rejected: "Viewer turned away",
+    input_denied: "Input refused",
+    install_outcome: "Installer outcome",
+    machine_linked: "Linked a machine",
+    session_registered: "Registered a session",
+    command_sent: "Sent a command to a machine",
+    vault_created: "Created a vault",
+    invite_created: "Sent an invite",
+    invite_accepted: "Accepted an invite",
+    feedback_sent: "Sent feedback",
+    ok: "Installed",
+    failed: "Failed, unspecified",
+    unsupported_os: "Unsupported OS",
+    unsupported_arch: "Unsupported architecture",
+    no_home: "HOME not set",
+    install_dir_relative: "Install directory not absolute",
+    install_dir_colon: "Install directory has a colon",
+    install_dir_create: "Could not create install directory",
+    install_dir_unwritable: "Install directory not writable",
+    temp_dir: "Could not create temp directory",
+    temp_dir_unwritable: "Temp directory not writable",
+    download_failed: "Download failed",
+    no_downloader: "No curl or wget",
+    manifest_html: "Manifest came back as HTML",
+    manifest_missing: "No checksum in manifest",
+    manifest_invalid: "Invalid checksum in manifest",
+    no_sha_tool: "No sha256sum or shasum",
+    checksum_mismatch: "Checksum mismatch",
+    write_failed: "Could not write executable",
+    remote_input: "Remote input",
+    cta_click: "Sign-up click",
+    signup_nav: "Sign up free (nav)",
+    signup_hero: "Sign up free (hero)",
+    signup_team: "Manage a team",
+    signup_footer: "Web app (footer)",
+    not_found: "Not found (404)",
+    unknown_path: "Unknown path (served the landing page)",
+    landing: "Landing",
+    docs: "Docs",
+    docs_app: "Docs · Web app",
+    docs_cli: "Docs · CLI",
+    docs_platforms: "Docs · Platforms",
+    docs_mobile: "Docs · Mobile",
+    docs_refstream: "Docs · Refstream",
+    docs_reliability: "Docs · Reliability",
+    docs_security: "Docs · Security",
+    docs_e2ee: "Docs · E2EE",
+    docs_docker: "Docs · Docker",
+    docs_self_hosting: "Docs · Self-hosting",
+    session: "Shared terminal",
+    installer_download: "Installer fetched",
+    binary_download: "Install completed",
+    share_opened: "Opened in a browser",
+    viewer_connected: "Viewer connected",
+    viewer_disconnected: "Viewer disconnected",
+    collaboration_started: "Typed from a browser",
+    session_created: "Session created",
+    session_started: "Session started",
+    session_ended: "Session ended",
+    page_view: "Page view",
+    skill_download: "Skill fetched",
+    stats_view: "Dashboard view",
+    posix: "Install script (POSIX)",
+    powershell: "Install script (PowerShell)",
+    darwin_arm64: "macOS arm64",
+    darwin_amd64: "macOS amd64",
+    linux_arm64: "Linux arm64",
+    linux_amd64: "Linux amd64",
+    bot: "Crawlers",
+    desktop: "Desktop",
+    mobile: "Phone",
+    tablet: "Tablet",
+    unknown: "Unknown",
+    google: "Google",
+    github: "GitHub",
+    reddit: "Reddit",
+    x: "X",
+    app: "Web app",
+    newsletter: "Newsletter or email",
+    product_hunt: "Product Hunt",
+    linkedin: "LinkedIn",
+    youtube: "YouTube",
+    discord: "Discord",
+    slack: "Slack",
+    mastodon: "Mastodon",
+    bluesky: "Bluesky",
+    podcast: "Podcast",
+    other: "Other sites",
+  };
+  const normalized = value.replace(/-/g, "_");
+  if (aliases[normalized]) return aliases[normalized];
+  const platform = normalized.match(/^(darwin|windows|linux|freebsd|openbsd|netbsd|dragonfly|solaris)_([a-z0-9]+)$/);
+  if (platform) {
+    const names: Record<string, string> = { darwin: "macOS", windows: "Windows", linux: "Linux", freebsd: "FreeBSD", openbsd: "OpenBSD", netbsd: "NetBSD", dragonfly: "DragonFly", solaris: "Solaris" };
+    return `${names[platform[1]]} ${platform[2]}`;
+  }
+  return value.replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+}
+
+/** A session outcome as the end of a sentence that begins "the sessions that ended". */
+export function outcomePhrase(outcome: string): string {
+  const phrases: Record<string, string> = {
+    task_exit: "did so because the task exited",
+    persistent_task_exit: "did so because a persistent task exited",
+    disconnected_timeout: "timed out after the host disconnected",
+    never_started: "never started",
+    expired: "expired",
+  };
+  return phrases[outcome] ?? `ended as “${humanize(outcome)}”`;
+}
+
+/*
+ * One sentence per section, computed from the same figures the section
+ * shows, so the reader gets the finding before the numbers. Each guards its
+ * ratios: a range with no sessions says so instead of dividing by zero.
+ */
+export function funnelInsight(snapshot: StatsSnapshot): string {
+  const figures = snapshot.figures;
+  const people = snapshot.uniques;
+  const parts: string[] = [];
+  if (figures.siteViews === 0) {
+    parts.push("No page views from browsers in this range.");
+  } else {
+    const visitors = people.configured ? ` from ${integerFormatter.format(people.surfaces.site.unique)} visitor${people.surfaces.site.unique === 1 ? "" : "s"}` : "";
+    const crawlers = figures.crawlerViews === 0 ? "" : `, and ${integerFormatter.format(figures.crawlerViews)} by crawlers kept out`;
+    parts.push(`${integerFormatter.format(figures.siteViews)} views by people${visitors}${crawlers}.`);
+    if (figures.installCopies > 0) parts.push(`${integerFormatter.format(figures.installCopies)} copied an install command.`);
+    const runs = figures.installerRuns;
+    parts.push(runs === 0
+      ? "Nobody ran the installer."
+      : `${integerFormatter.format(runs)} installer run${runs === 1 ? "" : "s"}, ${integerFormatter.format(figures.installs)} completed (${formatPercent(ratio(figures.installs, runs))}).`);
+  }
+  if (figures.sessionsStarted === 0) {
+    parts.push("No session started.");
+  } else {
+    const machines = people.configured ? ` on ${integerFormatter.format(people.surfaces.cli.unique)} machine${people.surfaces.cli.unique === 1 ? "" : "s"}` : "";
+    if (figures.neverStarted > 0) parts.push(`${integerFormatter.format(figures.neverStarted)} more ${figures.neverStarted === 1 ? "was" : "were"} created but never connected.`);
+    const opened = formatPercent(ratio(figures.sharesOpened, figures.sessionsStarted));
+    const typed = figures.sharesOpened === 0 ? "" : `, and ${formatPercent(ratio(figures.collaborations, figures.sharesOpened))} of those were typed into`;
+    parts.push(`${integerFormatter.format(figures.sessionsStarted)} session${figures.sessionsStarted === 1 ? "" : "s"} started${machines}; ${opened} were opened in a browser${typed}.`);
+  }
+  return parts.join(" ");
+}
+
+export function trafficInsight(snapshot: StatsSnapshot): string {
+  const metrics = snapshot.metrics;
+  const audiences = snapshot.audiences.views;
+  const total = metrics.landingViews + metrics.docsViews;
+  if (total === 0) return "No landing or documentation views in this range.";
+  const parts = [`${formatPercent(ratio(audiences.crawlers, total))} of ${integerFormatter.format(total)} views were crawlers.`];
+  const referrers = snapshot.breakdowns.referrers;
+  const referred = referrers.reduce((sum, item) => sum + item.value, 0);
+  if (referrers.length > 0 && referred > 0) {
+    parts.push(`Top source of landing visits: ${humanize(referrers[0].label)} (${formatPercent(ratio(referrers[0].value, referred))}).`);
+  }
+  if (metrics.unknownPaths > 0) {
+    parts.push(`${integerFormatter.format(metrics.unknownPaths)} request${metrics.unknownPaths === 1 ? "" : "s"} hit a path the site does not know and got the landing page.`);
+  }
+  return parts.join(" ");
+}
+
+export function sessionsInsight(snapshot: StatsSnapshot): string {
+  const metrics = snapshot.metrics;
+  const days = Math.max(1, (snapshot.generatedAt - snapshot.rangeStart) / DAY_MS);
+  if (metrics.sessionsCreated === 0) return "No session was created in this range.";
+  const perDay = metrics.sessionsStarted / days;
+  const parts = [
+    `${integerFormatter.format(metrics.sessionsCreated)} created, ${integerFormatter.format(metrics.sessionsStarted)} started (${formatPercent(ratio(metrics.sessionsStarted, metrics.sessionsCreated))}), about ${perDay >= 10 ? integerFormatter.format(perDay) : numberFormatter.format(perDay)} a day.`,
+  ];
+  const outcomes = snapshot.breakdowns.outcomes;
+  const ended = outcomes.reduce((sum, item) => sum + item.value, 0);
+  if (ended > 0 && outcomes.length > 0) {
+    parts.push(`${formatPercent(ratio(outcomes[0].value, ended))} of the ${integerFormatter.format(ended)} that ended ${outcomePhrase(outcomes[0].label)}; a session lasted ${formatDuration(metrics.averageDurationSeconds)} on average.`);
+  }
+  if (metrics.sharesOpened > 0) {
+    parts.push(`A link waited ${formatDuration(metrics.averageSecondsToOpen)} for its first open on average.`);
+  }
+  if (metrics.viewersRejected > 0) {
+    parts.push(`${integerFormatter.format(metrics.viewersRejected)} viewer${metrics.viewersRejected === 1 ? " was" : "s were"} turned away by a full, expired or unknown session.`);
+  }
+  return parts.join(" ");
+}
+
+export interface DeltaChip {
+  tone: "up" | "down" | "flat";
+  text: string;
+  /** The figure it moved from, for the chip's tooltip. */
+  title: string;
+}
+
+/**
+ * How a headline figure moved against the period before. A period with
+ * nothing in it makes any change infinite, so it says "new" instead; a
+ * change past tenfold is shown as a multiple; under half a percent is the
+ * same. Null when there is nothing to compare with.
+ */
+export function deltaChip(current: number, before: number | null, priorLabel: string): DeltaChip | null {
+  if (before === null || priorLabel === "") return null;
+  const title = `${integerFormatter.format(before)} in ${priorLabel}`;
+  if (before === 0 && current === 0) return { tone: "flat", text: "same", title };
+  if (before === 0) return { tone: "up", text: "new", title };
+  const change = (current - before) / before;
+  if (Math.abs(change) < 0.005) return { tone: "flat", text: "same", title };
+  const arrow = change > 0 ? "▲" : "▼";
+  const text = Math.abs(change) >= 10
+    ? `${arrow}${numberFormatter.format(current / before)}×`
+    : `${arrow}${Math.round(Math.abs(change) * 100)}%`;
+  return { tone: change > 0 ? "up" : "down", text, title };
+}
diff --git a/shared/stats-snapshot.ts b/shared/stats-snapshot.ts
index 386f3b5..e699e90 100644
--- a/shared/stats-snapshot.ts
+++ b/shared/stats-snapshot.ts
@@ -4,7 +4,12 @@ import {
   VISITOR_MEMORY_DAYS,
   isUniqueSurface,
   type StatsAccounts,
+  type StatsAudience,
+  type StatsAudiences,
   type StatsBreakdownItem,
+  type StatsComparison,
+  type StatsFigures,
+  type StatsFunnelExclusion,
   type StatsFunnelStep,
   type StatsRange,
   type StatsRetentionCohort,
@@ -62,6 +67,13 @@ export interface UniqueDayRow extends Record<string, string | number | null> {
   unique_count: number;
 }
 
+/** Machines seen installing, and how many of them went on to a first session. */
+export interface InstallConversionRow extends Record<string, string | number | null> {
+  installers: number | null;
+  matured: number | null;
+  started: number | null;
+}
+
 /** One visitor on one day, with the day they were first seen, for the cohort grids. */
 export interface RetentionRow extends Record<string, string | number | null> {
   surface: string;
@@ -70,18 +82,49 @@ export interface RetentionRow extends Record<string, string | number | null> {
   day: number;
 }
 
+/** One event's count for one device class in the range. */
+export interface AudienceRow extends Record<string, string | number | null> {
+  event: string;
+  target: string;
+  device: string;
+  count: number;
+}
+
+/** Distinct visitor hashes seen on one surface in a period. */
+export interface PeriodUniqueRow extends Record<string, string | number | null> {
+  surface: string;
+  unique_count: number;
+}
+
+/** The period of equal length before the range, for comparison. */
+export interface PreviousPeriodRows {
+  rangeStart: number;
+  summary: MetricSummaryRow[];
+  byDevice: AudienceRow[];
+  uniques: PeriodUniqueRow[];
+}
+
 export interface StatsSnapshotRows {
   summary: MetricSummaryRow[];
+  byDevice: AudienceRow[];
+  /** Null on the all-time range. */
+  previous: PreviousPeriodRows | null;
   trend: MetricTrendRow[];
   devices: BreakdownRow[];
   referrers: BreakdownRow[];
   clients: BreakdownRow[];
+  openedDevices: BreakdownRow[];
+  typedDevices: BreakdownRow[];
   live: LivePresenceRow;
   collectingSince: number | null;
   uniques: UniqueSummaryRow[];
   uniqueDays: UniqueDayRow[];
   retention: RetentionRow[];
+  /** Null when people are not counted. */
+  installConversion: InstallConversionRow | null;
   uniquesConfigured: boolean;
+  /** Midnight UTC of the earliest visitor day still kept, or null when there is none. */
+  uniquesSince: number | null;
 }
 
 /** Midnight UTC of the day that contains `at`. */
@@ -103,9 +146,8 @@ export function buildStatsSnapshot(
   rangeStart: number,
   accounts: StatsAccounts = null,
 ): StatsSnapshot {
-  const total = (event: string, target?: string): number => rows.summary
-    .filter((row) => row.event === event && (target === undefined || row.target === target))
-    .reduce((sum, row) => sum + Number(row.count), 0);
+  const total = (event: string, target?: string): number => sumCounts(rows.summary, event, target);
+  const average = (event: string): number => averageValue(rows.summary, event);
   const ended = rows.summary.filter((row) => row.event === "session_ended");
   const endedCount = ended.reduce((sum, row) => sum + Number(row.count), 0);
   const durationSum = ended.reduce((sum, row) => sum + Number(row.value_sum), 0);
@@ -122,6 +164,8 @@ export function buildStatsSnapshot(
   const binaryDownloads = total("binary_download");
   const trendStepMs = statsTrendStep(range, now - rangeStart);
   const uniques = buildUniques(rows);
+  const audiences = buildAudiences(rows.byDevice);
+  const figures = buildFigures(rows.summary, audiences);
 
   const metrics: StatsSnapshot["metrics"] = {
     activeSessions: Math.max(0, Number(rows.live.active_sessions)),
@@ -129,8 +173,14 @@ export function buildStatsSnapshot(
     sessionsCreated,
     sessionsStarted,
     sharesOpened,
+    sharesOpenedReadOnly: total("share_opened", "viewer_read_only"),
     viewerConnections: total("viewer_connected"),
     collaborations,
+    viewersRejected: total("viewer_rejected"),
+    inputDenied: total("input_denied"),
+    averageSecondsToOpen: average("share_opened"),
+    averageSecondsToType: average("collaboration_started"),
+    averageViewerSeconds: average("viewer_disconnected"),
     landingViews,
     docsViews,
     terminalViews: total("page_view", "session"),
@@ -140,6 +190,8 @@ export function buildStatsSnapshot(
     installs: total("installer_download"),
     skillDownloads: total("skill_download"),
     binaryDownloads,
+    installsReported: total("install_outcome", "ok"),
+    installFailuresReported: total("install_outcome") - total("install_outcome", "ok"),
     copies: total("copy"),
     averageDurationSeconds: endedCount === 0 ? 0 : durationSum / endedCount,
     longestDurationSeconds: ended.reduce(
@@ -168,7 +220,17 @@ export function buildStatsSnapshot(
       signup: ratio(ctaClicks, landingViews),
       installed: ratio(binaryDownloads, landingViews),
     },
-    funnel: buildFunnel(metrics, uniques),
+    figures,
+    audiences,
+    previous: buildComparison(rows.previous, rangeStart, rows.collectingSince, uniques),
+    funnel: buildFunnel(figures, audiences, uniques),
+    installConversion: uniques.configured && rows.installConversion
+      ? {
+        installers: Number(rows.installConversion.installers ?? 0),
+        matured: Number(rows.installConversion.matured ?? 0),
+        started: Number(rows.installConversion.started ?? 0),
+      }
+      : null,
     uniques,
     retention: {
       weeks: RETENTION_WEEKS,
@@ -189,6 +251,10 @@ export function buildStatsSnapshot(
       ].sort((left, right) => right.value - left.value),
       outcomes: targetBreakdown(rows.summary, "session_ended"),
       pages: targetBreakdown(rows.summary, "page_view"),
+      openedDevices: breakdown(rows.openedDevices),
+      typedDevices: breakdown(rows.typedDevices),
+      rejections: targetBreakdown(rows.summary, "viewer_rejected"),
+      installOutcomes: targetBreakdown(rows.summary, "install_outcome"),
     },
     targets: rows.summary.map((row): StatsTargetMetric => ({
       event: row.event,
@@ -202,76 +268,194 @@ export function buildStatsSnapshot(
   };
 }
 
+function sumCounts(rows: MetricSummaryRow[], event: string, target?: string): number {
+  return rows
+    .filter((row) => row.event === event && (target === undefined || row.target === target))
+    .reduce((sum, row) => sum + Number(row.count), 0);
+}
+
+/** The mean of an event's value over its occurrences, or zero when there were none. */
+function averageValue(rows: MetricSummaryRow[], event: string): number {
+  const matching = rows.filter((row) => row.event === event);
+  const count = matching.reduce((sum, row) => sum + Number(row.count), 0);
+  if (count === 0) return 0;
+  return matching.reduce((sum, row) => sum + Number(row.value_sum), 0) / count;
+}
+
+const AUDIENCE_EVENTS: Record<keyof StatsAudiences, (event: string, target: string) => boolean> = {
+  views: (event, target) => event === "page_view" && (target === "landing" || target.startsWith("docs")),
+  installer: (event) => event === "installer_download",
+  installs: (event) => event === "binary_download",
+  viewers: (event) => event === "viewer_connected",
+};
+
+/** Which audience a device class belongs to: the classifier's classes, folded to three that matter and a rest. */
+export function audienceOf(device: string): keyof StatsAudience {
+  if (device === "desktop" || device === "mobile" || device === "tablet") return "browsers";
+  if (device === "cli") return "tools";
+  if (device === "bot") return "crawlers";
+  return "unknown";
+}
+
+export function buildAudiences(rows: AudienceRow[]): StatsAudiences {
+  const empty = (): StatsAudience => ({ browsers: 0, tools: 0, crawlers: 0, unknown: 0 });
+  const audiences: StatsAudiences = { views: empty(), installer: empty(), installs: empty(), viewers: empty() };
+  for (const row of rows) {
+    for (const key of Object.keys(AUDIENCE_EVENTS) as (keyof StatsAudiences)[]) {
+      if (AUDIENCE_EVENTS[key](row.event, row.target)) audiences[key][audienceOf(row.device)] += Number(row.count);
+    }
+  }
+  return audiences;
+}
+
+/** Everything but crawlers: a binary went to a person's machine, whatever fetched it. */
+export function installsCompleted(installs: StatsAudience): number {
+  return installs.browsers + installs.tools + installs.unknown;
+}
+
+export function buildFigures(summary: MetricSummaryRow[], audiences: StatsAudiences): StatsFigures {
+  return {
+    siteViews: audiences.views.browsers,
+    crawlerViews: audiences.views.crawlers,
+    ctaClicks: sumCounts(summary, "cta_click"),
+    installCopies: sumCounts(summary, "copy", "install") + sumCounts(summary, "copy", "brew_install") + sumCounts(summary, "copy", "source_build"),
+    installerRuns: audiences.installer.tools,
+    installs: installsCompleted(audiences.installs),
+    sessionsStarted: sumCounts(summary, "session_started"),
+    neverStarted: sumCounts(summary, "session_ended", "never_started"),
+    sharesOpened: sumCounts(summary, "share_opened"),
+    sharesOpenedWritable: sumCounts(summary, "share_opened") - sumCounts(summary, "share_opened", "viewer_read_only"),
+    collaborations: sumCounts(summary, "collaboration_started"),
+  };
+}
+
+/**
+ * The period before the range, when there is one worth comparing with: not
+ * on the all-time range, and not when it reaches back before collection
+ * began, since a comparison with an empty period says everything doubled.
+ * People are compared only when they were counted for the whole of it.
+ */
+export function buildComparison(
+  previous: PreviousPeriodRows | null,
+  rangeStart: number,
+  collectingSince: number | null,
+  uniques: StatsUniques,
+): StatsComparison | null {
+  if (!previous || collectingSince === null || previous.rangeStart < collectingSince) return null;
+  const audiences = buildAudiences(previous.byDevice);
+  const covered = uniques.configured && uniques.since !== null && uniques.since <= dayStart(previous.rangeStart);
+  let people: StatsComparison["people"] = null;
+  if (covered) {
+    people = Object.fromEntries(UNIQUE_SURFACES.map((surface) => [surface, 0])) as Record<UniqueSurface, number>;
+    for (const row of previous.uniques) {
+      if (isUniqueSurface(row.surface)) people[row.surface] = Number(row.unique_count);
+    }
+  }
+  return {
+    rangeStart: previous.rangeStart,
+    rangeEnd: rangeStart,
+    figures: buildFigures(previous.summary, audiences),
+    people,
+  };
+}
+
 /*
  * The path from a first look to a first keystroke, one row per step, each
- * saying what it counts. A step's count is an event total; its unique figure
- * is how many distinct people were behind it, on the surfaces that count
- * people. The two are shown side by side rather than blended, because a
- * hundred page views from one crawler and a hundred visitors are different
- * news.
+ * saying what it counts and what it leaves out. A step's count is of requests
+ * that a person is plausibly behind; its unique figure is how many distinct
+ * people were, on the surfaces that count people. Crawlers are listed beside
+ * the step they were kept out of, because a hundred page views from one
+ * crawler and a hundred visitors are different news.
  */
 export function buildFunnel(
-  metrics: StatsSnapshot["metrics"],
+  figures: StatsFigures,
+  audiences: StatsAudiences,
   uniques: StatsUniques,
 ): StatsFunnelStep[] {
   const people = (surface: UniqueSurface): number | null =>
     uniques.configured ? uniques.surfaces[surface].unique : null;
+  const excluded = (entries: StatsFunnelExclusion[]): StatsFunnelExclusion[] => entries.filter((entry) => entry.count > 0);
   return [
     {
       key: "visited",
       label: "Visited the site",
-      count: metrics.landingViews + metrics.docsViews,
+      count: figures.siteViews,
       unique: people("site"),
-      note: "Landing and documentation page views. Crawlers count as views, not as people.",
+      note: "Landing and documentation page views from a browser.",
+      excluded: excluded([
+        { label: "by crawlers", count: audiences.views.crawlers },
+        { label: "by tools", count: audiences.views.tools + audiences.views.unknown },
+      ]),
       basis: null,
     },
     {
       key: "signup",
       label: "Clicked Sign up",
-      count: metrics.ctaClicks,
+      count: figures.ctaClicks,
+      unique: null,
+      note: "Any Sign up free or Web app link on the landing page. Most accounts start elsewhere: the app, an invite, the CLI.",
+      excluded: [],
+      basis: "visited",
+    },
+    {
+      key: "copied",
+      label: "Copied an install command",
+      count: figures.installCopies,
       unique: null,
-      note: "Any Sign up free or Web app link on the landing page.",
+      note: "The curl, Homebrew or source-build command copied on the landing page: intent, before a terminal is involved.",
+      excluded: [],
       basis: "visited",
     },
     {
       key: "installer",
-      label: "Fetched the installer",
-      count: metrics.installs,
+      label: "Ran the installer",
+      count: figures.installerRuns,
       unique: people("install"),
-      note: "Requests for the install script. Reading it counts; so does piping it to sh.",
+      note: "The install script fetched by curl or wget, which is how it is run.",
+      excluded: excluded([
+        { label: "read in a browser", count: audiences.installer.browsers },
+        { label: "by crawlers", count: audiences.installer.crawlers },
+        { label: "unknown", count: audiences.installer.unknown },
+      ]),
       basis: "visited",
     },
     {
       key: "installed",
       label: "Completed an install",
-      count: metrics.binaryDownloads,
+      count: figures.installs,
       unique: null,
-      note: "Release binaries served, the installer's last step. Homebrew and source builds are not in this number.",
+      note: "A release binary served, the installer's last step. Homebrew and source builds are not in this number.",
+      excluded: excluded([{ label: "by crawlers", count: audiences.installs.crawlers }]),
       basis: "installer",
     },
     {
       key: "session",
       label: "Started a session",
-      count: metrics.sessionsStarted,
+      count: figures.sessionsStarted,
       unique: people("cli"),
       note: "A shell command connected its process to the relay. Not a share of the step before: sessions come from every install to date.",
+      excluded: excluded([{ label: "created but never connected", count: figures.neverStarted }]),
       basis: null,
     },
     {
       key: "opened",
       label: "Opened it in a browser",
-      count: metrics.sharesOpened,
+      count: figures.sharesOpened,
       unique: people("viewer"),
       note: "Sessions whose link was opened at least once, by anyone, the owner included.",
+      excluded: [],
       basis: "session",
     },
     {
       key: "typed",
       label: "Typed from a browser",
-      count: metrics.collaborations,
+      count: figures.collaborations,
       unique: null,
-      note: "Sessions that received at least one keystroke from a browser.",
+      note: "Sessions that received at least one keystroke from a browser. Read-only sessions cannot, so they are not in the share.",
+      excluded: excluded([{ label: "opened read-only, typing impossible", count: figures.sharesOpened - figures.sharesOpenedWritable }]),
       basis: "opened",
+      basisCount: figures.sharesOpenedWritable,
+      basisLabel: "opened sessions that allow typing",
     },
   ];
 }
@@ -342,11 +526,28 @@ function buildUniques(rows: StatsSnapshotRows): StatsUniques {
   return {
     configured: rows.uniquesConfigured,
     memoryDays: VISITOR_MEMORY_DAYS,
+    since: rows.uniquesConfigured ? rows.uniquesSince : null,
     surfaces,
     daily: [...days.values()].sort((left, right) => left.day - right.day),
   };
 }
 
+/**
+ * The day people counts start from, when that is after the range began, or
+ * null when people cover the whole range. Events are counted from the first
+ * event and people from the day the visitor salt was set, for at most
+ * VISITOR_MEMORY_DAYS, so a 30-day range can hold thirty days of events and
+ * one day of people. A people figure shown beside an event count over such a
+ * range has to say so, or 29,333 views next to 84 people reads as nonsense.
+ */
+export function peopleCountedSince(
+  uniques: Pick<StatsUniques, "configured" | "since">,
+  rangeStart: number,
+): number | null {
+  if (!uniques.configured || uniques.since === null) return null;
+  return uniques.since > dayStart(rangeStart) ? uniques.since : null;
+}
+
 export function statsRangeStart(
   range: StatsRange,
   now: number,
diff --git a/shared/stats.ts b/shared/stats.ts
index 3f7e075..37507ae 100644
--- a/shared/stats.ts
+++ b/shared/stats.ts
@@ -15,6 +15,22 @@ export const VISITOR_MEMORY_DAYS = 120;
 /** How many weekly cohorts the retention grids show. */
 export const RETENTION_WEEKS = 8;
 
+/** How long after installing a machine has to start a session to count as converted. */
+export const INSTALL_CONVERSION_DAYS = 7;
+
+/**
+ * Machines followed from a binary download to a first session, by address:
+ * the one join the dashboard can make between the installer and the CLI.
+ */
+export interface StatsInstallConversion {
+  /** Machines whose first install was in the range. */
+  installers: number;
+  /** Of those, installed at least INSTALL_CONVERSION_DAYS ago, so their window has fully elapsed. */
+  matured: number;
+  /** Of the matured, started a session within the window. */
+  started: number;
+}
+
 export interface StatsSeriesPoint {
   at: number;
   sessions: number;
@@ -59,10 +75,85 @@ export interface StatsUniques {
   /** False until the Worker has a visitor salt; every count is then zero. */
   configured: boolean;
   memoryDays: number;
+  /**
+   * Midnight UTC of the earliest day anyone was counted, or null when nobody
+   * has been. Events are counted from the first event and people from the
+   * day the salt was set, so a range can hold more days of events than of
+   * people; peopleCountedSince says when a figure has to say so.
+   */
+  since: number | null;
   surfaces: Record<UniqueSurface, StatsUniqueCount>;
   daily: StatsUniqueDay[];
 }
 
+/**
+ * One event's requests by who made them, from the user agent. A browser is a
+ * person looking; a tool is a person's machine doing what it was told; a
+ * crawler is neither, and is kept out of every figure about people.
+ */
+export interface StatsAudience {
+  /** Desktop, tablet and phone browsers. */
+  browsers: number;
+  /** curl, wget and the shell CLI. */
+  tools: number;
+  /** Crawlers, monitors and headless browsers that say so. */
+  crawlers: number;
+  /** No user agent, or one the classifier could not place. */
+  unknown: number;
+}
+
+export interface StatsAudiences {
+  /** Landing and documentation page views. */
+  views: StatsAudience;
+  /** Requests for the install script. */
+  installer: StatsAudience;
+  /** Release binaries served. */
+  installs: StatsAudience;
+  /** Browser connections to a shared terminal. */
+  viewers: StatsAudience;
+}
+
+/**
+ * The figures the page is built on, each with the crawlers taken out, so a
+ * step of the funnel and its comparison with the period before mean the same
+ * thing. The raw event totals stay in metrics and the ledger.
+ */
+export interface StatsFigures {
+  /** Landing and documentation views from browsers: people looking. */
+  siteViews: number;
+  /** The same pages fetched by self-identified crawlers. */
+  crawlerViews: number;
+  ctaClicks: number;
+  /** The curl, Homebrew or source-build command copied on the landing page: intent before the terminal. */
+  installCopies: number;
+  /** Install script fetches by curl or wget: the installer actually run, not read. */
+  installerRuns: number;
+  /** Release binaries served to anything but a crawler: an install completed. */
+  installs: number;
+  sessionsStarted: number;
+  /** Sessions that ended without the host ever connecting: a blocked WebSocket, usually. */
+  neverStarted: number;
+  sharesOpened: number;
+  /** Opened sessions that allow typing: the only ones a keystroke can come from. */
+  sharesOpenedWritable: number;
+  collaborations: number;
+}
+
+/** The same figures for the period of equal length before the range. */
+export interface StatsComparison {
+  rangeStart: number;
+  rangeEnd: number;
+  figures: StatsFigures;
+  /** Distinct people per surface in that period, or null when people were not counted for all of it. */
+  people: Record<UniqueSurface, number> | null;
+}
+
+/** Requests a funnel step leaves out, so the reader sees what was not counted and why. */
+export interface StatsFunnelExclusion {
+  label: string;
+  count: number;
+}
+
 export interface StatsFunnelStep {
   key: string;
   label: string;
@@ -71,6 +162,11 @@ export interface StatsFunnelStep {
   unique: number | null;
   /** What the count is, in one sentence, so nobody has to guess. */
   note: string;
+  /** What the count leaves out: crawler views, an installer read in a browser. */
+  excluded: StatsFunnelExclusion[];
+  /** When the share is of part of the basis step, that part and its name: typed, of the opened sessions that allow typing. */
+  basisCount?: number;
+  basisLabel?: string;
   /**
    * The step this one is a share of, or null when it is its own population:
    * sessions in a range come from every install ever made, not from this
@@ -103,6 +199,8 @@ export interface StatsAccountStats {
   activeInRange: number;
   newByDay: { day: number; count: number }[];
   cohorts: StatsRetentionCohort[];
+  /** Things done in the app in the range, by kind: machines linked, commands sent. Counts of things, not of accounts. */
+  events: Record<string, number>;
 }
 
 export type StatsAccounts = StatsAccountStats | { error: string } | null;
@@ -120,8 +218,20 @@ export interface StatsSnapshot {
     sessionsCreated: number;
     sessionsStarted: number;
     sharesOpened: number;
+    /** Of those, sessions the owner made read-only, where nobody can type. */
+    sharesOpenedReadOnly: number;
     viewerConnections: number;
     collaborations: number;
+    /** Browsers that opened a link and were turned away: full, expired or unknown session. */
+    viewersRejected: number;
+    /** Viewers who tried to type into a read-only session, once each. */
+    inputDenied: number;
+    /** From creation to the first browser open, over sessions that were opened. */
+    averageSecondsToOpen: number;
+    /** From the first open to the first keystroke, over sessions that were typed into. */
+    averageSecondsToType: number;
+    /** How long a viewer stayed connected, over viewers that disconnected. */
+    averageViewerSeconds: number;
     landingViews: number;
     docsViews: number;
     terminalViews: number;
@@ -136,6 +246,10 @@ export interface StatsSnapshot {
     skillDownloads: number;
     /** Release binaries served: the installer's last step, so a completed install. */
     binaryDownloads: number;
+    /** Installers that reported finishing, from the script itself. */
+    installsReported: number;
+    /** Installers that reported failing, by their own account. */
+    installFailuresReported: number;
     copies: number;
     averageDurationSeconds: number;
     longestDurationSeconds: number;
@@ -151,7 +265,13 @@ export interface StatsSnapshot {
     /** Completed installs per landing view. */
     installed: number;
   };
+  figures: StatsFigures;
+  audiences: StatsAudiences;
+  /** Null on the all-time range, or when the period before is older than collection. */
+  previous: StatsComparison | null;
   funnel: StatsFunnelStep[];
+  /** Null until people are counted. */
+  installConversion: StatsInstallConversion | null;
   uniques: StatsUniques;
   retention: StatsRetention;
   accounts: StatsAccounts;
@@ -164,6 +284,14 @@ export interface StatsSnapshot {
     downloads: StatsBreakdownItem[];
     outcomes: StatsBreakdownItem[];
     pages: StatsBreakdownItem[];
+    /** Sessions opened, by the device class of the first viewer. */
+    openedDevices: StatsBreakdownItem[];
+    /** Sessions typed into, by the device class of the first typist. */
+    typedDevices: StatsBreakdownItem[];
+    /** Why viewers were turned away. */
+    rejections: StatsBreakdownItem[];
+    /** How installs ended, as the scripts reported. */
+    installOutcomes: StatsBreakdownItem[];
   };
   targets: StatsTargetMetric[];
 }
diff --git a/tests/analytics.test.ts b/tests/analytics.test.ts
index f55717d..ae70c4a 100644
--- a/tests/analytics.test.ts
+++ b/tests/analytics.test.ts
@@ -1,12 +1,15 @@
 import { describe, expect, it, vi } from "vitest";
 import {
   binaryDownloadTarget,
+  campaignSource,
   classifyClient,
   classifyDevice,
   classifyReferrer,
   documentTarget,
   hasVisitorSalt,
+  installReportOutcome,
   isDocumentNavigation,
+  machineKey,
   normalizeAnalyticsRecord,
   requestAnalyticsContext,
   requestVisitor,
@@ -69,6 +72,22 @@ describe("analytics", () => {
       .toBe("internal");
     expect(classifyReferrer("https://example.com/private/path", "https://shell.online"))
       .toBe("other");
+    expect(classifyReferrer("https://app.shell.online/sessions", "https://shell.online")).toBe("app");
+    expect(classifyReferrer("https://app.example.test/", "https://example.test")).toBe("app");
+  });
+
+  it("takes a named campaign over a hidden referrer, and only a named one", () => {
+    expect(campaignSource(new URL("https://shell.online/?utm_source=hn&utm_medium=post"))).toBe("hacker_news");
+    expect(campaignSource(new URL("https://shell.online/?ref=producthunt"))).toBe("product_hunt");
+    expect(campaignSource(new URL("https://shell.online/?utm_source=<script>"))).toBeNull();
+    expect(campaignSource(new URL("https://shell.online/?utm_source=my-private-tracker-42"))).toBeNull();
+    expect(campaignSource(new URL("https://shell.online/"))).toBeNull();
+    const hidden = new Request("https://shell.online/?utm_source=newsletter", { headers: { "User-Agent": "Mozilla/5.0" } });
+    expect(requestAnalyticsContext(hidden).referrer).toBe("newsletter");
+    const shown = new Request("https://shell.online/?utm_source=newsletter", {
+      headers: { "User-Agent": "Mozilla/5.0", Referer: "https://github.com/TeoSlayer/shell.online" },
+    });
+    expect(requestAnalyticsContext(shown).referrer).toBe("github");
   });
 
   it("classifies request context without retaining raw headers", () => {
@@ -135,7 +154,7 @@ describe("analytics", () => {
     await expect(visitorKey("another-salt-of-some-length", "203.0.113.7", "Mozilla/5.0 (Macintosh) Chrome/129.0.0.0 Safari/537.36")).resolves.not.toBe(one);
   });
 
-  it("counts nobody without a salt worth the name or without an address", async () => {
+  it("counts nobody without a salt worth the name, without an address, or behind a crawler", async () => {
     const request = new Request("https://shell.online/", {
       headers: { "CF-Connecting-IP": "203.0.113.7", "User-Agent": "curl/8.4.0" },
     });
@@ -145,5 +164,37 @@ describe("analytics", () => {
     await expect(requestVisitor("short", request)).resolves.toBeUndefined();
     await expect(requestVisitor("a-salt-long-enough-to-count", new Request("https://shell.online/"))).resolves.toBeUndefined();
     await expect(requestVisitor("a-salt-long-enough-to-count", request)).resolves.toMatch(/^[a-f0-9]{20}$/);
+    const crawler = new Request("https://shell.online/", {
+      headers: {
+        "CF-Connecting-IP": "203.0.113.9",
+        "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
+      },
+    });
+    await expect(requestVisitor("a-salt-long-enough-to-count", crawler)).resolves.toBeUndefined();
+  });
+
+  it("takes an install report's outcome only from the list the scripts send", () => {
+    expect(installReportOutcome(new URL("https://shell.online/install/report?outcome=ok&platform=shell-darwin-arm64"))).toBe("ok");
+    expect(installReportOutcome(new URL("https://shell.online/install/report?outcome=checksum_mismatch"))).toBe("checksum_mismatch");
+    expect(installReportOutcome(new URL("https://shell.online/install/report?outcome=rm%20-rf"))).toBeNull();
+    expect(installReportOutcome(new URL("https://shell.online/install/report?outcome=OK"))).toBeNull();
+    expect(installReportOutcome(new URL("https://shell.online/install/report"))).toBeNull();
+  });
+
+  it("keys a machine by address alone, so the installer and the CLI on it are one machine", async () => {
+    const salt = "a-salt-long-enough-to-count";
+    const installer = new Request("https://shell.online/install", {
+      headers: { "CF-Connecting-IP": "203.0.113.7", "User-Agent": "curl/8.4.0" },
+    });
+    const cli = new Request("https://shell.online/api/sessions", {
+      headers: { "CF-Connecting-IP": "203.0.113.7", "User-Agent": "shell/0.15.1" },
+    });
+    const machine = await requestVisitor(salt, installer, "machine");
+    expect(machine).toMatch(/^[a-f0-9]{20}$/);
+    await expect(requestVisitor(salt, cli, "machine")).resolves.toBe(machine);
+    /* A browser at the same address is not that machine, and its key is not made from the same bytes. */
+    await expect(requestVisitor(salt, installer)).resolves.not.toBe(machine);
+    await expect(machineKey(salt, "203.0.113.7")).resolves.toBe(machine);
+    await expect(machineKey(salt, "203.0.113.8")).resolves.not.toBe(machine);
   });
 });
diff --git a/tests/check-worker-routing.test.ts b/tests/check-worker-routing.test.ts
new file mode 100644
index 0000000..115ec3c
--- /dev/null
+++ b/tests/check-worker-routing.test.ts
@@ -0,0 +1,70 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+/*
+ * The deploy guard: a production Wrangler config must route at least the
+ * paths the example routes through the Worker, or their pages are never
+ * counted. It reads JSONC, so comments and trailing commas must not trip it,
+ * and a string holding "//" must not be taken for a comment.
+ */
+const script = fileURLToPath(new URL("../scripts/check-worker-routing.mjs", import.meta.url));
+
+const REFERENCE = `{
+  // the example config, with everything JSONC allows
+  "name": "shell-online", /* block comment */
+  "routes": [{ "pattern": "https://shell.online/*", "custom_domain": true }],
+  "assets": {
+    "run_worker_first": [
+      "/api/*",
+      "/docs/*",
+      "/app/*",
+    ],
+  },
+}
+`;
+
+function guard(reference: string, deployment: string): { status: number | null; stdout: string; stderr: string } {
+  const directory = mkdtempSync(join(tmpdir(), "worker-routing-"));
+  const referencePath = join(directory, "reference.jsonc");
+  const deploymentPath = join(directory, "deployment.jsonc");
+  writeFileSync(referencePath, reference);
+  writeFileSync(deploymentPath, deployment);
+  const result = spawnSync(process.execPath, [script, referencePath, deploymentPath], { encoding: "utf8" });
+  return { status: result.status, stdout: result.stdout, stderr: result.stderr };
+}
+
+describe("the Worker routing guard", () => {
+  it("accepts a deployment that routes everything the reference routes, comments and all", () => {
+    const result = guard(REFERENCE, REFERENCE.replace('"/api/*",', '"/api/*", "/extra/*",'));
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain("routes every counted path through the Worker");
+  });
+
+  it("refuses a deployment missing a path, and names it", () => {
+    const result = guard(REFERENCE, REFERENCE.replace('      "/app/*",\n', ""));
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain("/app/*");
+    expect(result.stderr).toContain("would never be counted");
+  });
+
+  it("accepts a deployment that runs the Worker first for everything", () => {
+    const result = guard(REFERENCE, '{ "assets": { "run_worker_first": true } }');
+    expect(result.status).toBe(0);
+  });
+
+  it("refuses a config it cannot read, and a config without the list", () => {
+    expect(guard(REFERENCE, "{ not json").status).toBe(1);
+    expect(guard(REFERENCE, '{ "assets": { "run_worker_first": "/api/*" } }').status).toBe(1);
+    expect(guard(REFERENCE, "{}").status).toBe(1);
+  });
+
+  it("wants two paths", () => {
+    const result = spawnSync(process.execPath, [script], { encoding: "utf8" });
+    expect(result.status).toBe(2);
+    expect(result.stderr).toContain("usage");
+  });
+});
diff --git a/tests/stats-copy.test.ts b/tests/stats-copy.test.ts
new file mode 100644
index 0000000..e530483
--- /dev/null
+++ b/tests/stats-copy.test.ts
@@ -0,0 +1,131 @@
+import { describe, expect, it } from "vitest";
+import { buildStatsSnapshot, DAY_MS, dayStart, type StatsSnapshotRows } from "../shared/stats-snapshot";
+import {
+  deltaChip,
+  formatDuration,
+  formatPercent,
+  funnelInsight,
+  humanize,
+  outcomePhrase,
+  ratio,
+  sessionsInsight,
+  trafficInsight,
+} from "../shared/stats-copy";
+
+const now = Date.UTC(2026, 8, 15, 12);
+const rangeStart = now - 7 * DAY_MS;
+
+function metric(event: string, target: string, count: number, value = 0) {
+  return { event, target, count, value_sum: value, value_max: value, auxiliary_sum: 0, auxiliary_max: 0 };
+}
+
+/** A week with a little of everything, so every sentence has something to say. */
+function rows(overrides: Partial<StatsSnapshotRows> = {}): StatsSnapshotRows {
+  return {
+    summary: [
+      metric("page_view", "landing", 10),
+      metric("copy", "install", 3),
+      metric("installer_download", "posix", 4),
+      metric("binary_download", "darwin-arm64", 1),
+      metric("session_created", "cli", 6),
+      metric("session_started", "cli", 5),
+      metric("share_opened", "viewer", 2, 40),
+      metric("collaboration_started", "remote_input", 1),
+      metric("session_ended", "task_exit", 3, 300),
+      metric("session_ended", "never_started", 1),
+    ],
+    byDevice: [
+      { event: "page_view", target: "landing", device: "desktop", count: 8 },
+      { event: "page_view", target: "landing", device: "bot", count: 2 },
+      { event: "installer_download", target: "posix", device: "cli", count: 4 },
+      { event: "binary_download", target: "darwin-arm64", device: "cli", count: 1 },
+    ],
+    previous: null,
+    trend: [],
+    devices: [],
+    referrers: [{ name: "direct", count: 6 }, { name: "github", count: 4 }],
+    clients: [],
+    openedDevices: [],
+    typedDevices: [],
+    live: { active_sessions: 0, active_viewers: 0 },
+    collectingSince: now - 30 * DAY_MS,
+    uniques: [{ surface: "site", unique_count: 7, new_count: 7 }, { surface: "cli", unique_count: 3, new_count: 3 }],
+    uniqueDays: [],
+    retention: [],
+    installConversion: null,
+    uniquesConfigured: true,
+    uniquesSince: dayStart(now - 20 * DAY_MS),
+    ...overrides,
+  };
+}
+
+describe("the dashboard's copy", () => {
+  it("says what the funnel found, with crawlers, copies and never-connected sessions in their places", () => {
+    const snapshot = buildStatsSnapshot(rows(), "7d", now, rangeStart);
+    expect(funnelInsight(snapshot)).toBe(
+      "8 views by people from 7 visitors, and 2 by crawlers kept out. 3 copied an install command. " +
+      "4 installer runs, 1 completed (25%). 1 more was created but never connected. " +
+      "5 sessions started on 3 machines; 40% were opened in a browser, and 50% of those were typed into.",
+    );
+  });
+
+  it("says so when there is nothing to describe, instead of dividing by zero", () => {
+    const empty = buildStatsSnapshot(rows({ summary: [], byDevice: [], uniques: [], referrers: [] }), "7d", now, rangeStart);
+    expect(funnelInsight(empty)).toBe("No page views from browsers in this range. No session started.");
+    expect(trafficInsight(empty)).toBe("No landing or documentation views in this range.");
+    expect(sessionsInsight(empty)).toBe("No session was created in this range.");
+  });
+
+  it("says how much of the traffic was crawlers, where the rest came from, and what fell through", () => {
+    const snapshot = buildStatsSnapshot(rows(), "7d", now, rangeStart);
+    expect(trafficInsight(snapshot)).toBe("20% of 10 views were crawlers. Top source of landing visits: Direct (60%).");
+    const lost = buildStatsSnapshot(rows({ summary: [...rows().summary, metric("page_view", "unknown_path", 1)] }), "7d", now, rangeStart);
+    expect(trafficInsight(lost)).toContain("1 request hit a path the site does not know and got the landing page.");
+  });
+
+  it("says how sessions went: rate, outcome, lifetime, the wait for a first open, and who was turned away", () => {
+    const snapshot = buildStatsSnapshot(rows(), "7d", now, rangeStart);
+    const sentence = sessionsInsight(snapshot);
+    expect(sentence).toContain("6 created, 5 started (83%), about 0.7 a day.");
+    expect(sentence).toContain("75% of the 4 that ended did so because the task exited; a session lasted 1m on average.");
+    expect(sentence).toContain("A link waited 20s for its first open on average.");
+    expect(sentence).not.toContain("turned away");
+    const refused = buildStatsSnapshot(rows({ summary: [...rows().summary, metric("viewer_rejected", "session_full", 1)] }), "7d", now, rangeStart);
+    expect(sessionsInsight(refused)).toContain("1 viewer was turned away by a full, expired or unknown session.");
+  });
+
+  it("phrases every outcome the relay records, and quotes one it does not know", () => {
+    expect(outcomePhrase("task_exit")).toBe("did so because the task exited");
+    expect(outcomePhrase("persistent_task_exit")).toBe("did so because a persistent task exited");
+    expect(outcomePhrase("disconnected_timeout")).toBe("timed out after the host disconnected");
+    expect(outcomePhrase("never_started")).toBe("never started");
+    expect(outcomePhrase("expired")).toBe("expired");
+    expect(outcomePhrase("weird_thing")).toBe("ended as “Weird Thing”");
+  });
+
+  it("makes a delta chip that says new, same, a percentage, or a multiple, and nothing without a period before", () => {
+    expect(deltaChip(10, null, "the 7d before")).toBeNull();
+    expect(deltaChip(10, 5, "")).toBeNull();
+    expect(deltaChip(0, 0, "the 7d before")).toEqual({ tone: "flat", text: "same", title: "0 in the 7d before" });
+    expect(deltaChip(3, 0, "the 7d before")).toEqual({ tone: "up", text: "new", title: "0 in the 7d before" });
+    expect(deltaChip(1000, 1002, "the 7d before")).toMatchObject({ tone: "flat", text: "same" });
+    expect(deltaChip(150, 100, "the 7d before")).toEqual({ tone: "up", text: "▲50%", title: "100 in the 7d before" });
+    expect(deltaChip(80, 100, "the 30d before")).toEqual({ tone: "down", text: "▼20%", title: "100 in the 30d before" });
+    expect(deltaChip(1500, 100, "the 7d before")).toEqual({ tone: "up", text: "▲15×", title: "100 in the 7d before" });
+    expect(deltaChip(2, 100, "the 7d before")).toEqual({ tone: "down", text: "▼98%", title: "100 in the 7d before" });
+  });
+
+  it("formats durations, shares and names the way the page shows them", () => {
+    expect([0, 45, 90, 3_600, 5_400, 90_000, Number.NaN].map(formatDuration)).toEqual(["0s", "45s", "2m", "1h", "1.5h", "1d", "0s"]);
+    expect([0.126, 2, -1, 0].map(formatPercent)).toEqual(["13%", "100%", "0%", "0%"]);
+    expect(ratio(1, 0)).toBe(0);
+    expect(ratio(3, 2)).toBe(1);
+    expect(humanize("docs_app")).toBe("Docs · Web app");
+    expect(humanize("darwin-arm64")).toBe("macOS arm64");
+    expect(humanize("freebsd-armv7")).toBe("FreeBSD armv7");
+    expect(humanize("typed_into_read_only")).toBe("Typed into a read-only session");
+    expect(humanize("checksum_mismatch")).toBe("Checksum mismatch");
+    expect(humanize("machine_linked")).toBe("Linked a machine");
+    expect(humanize("some_new_thing")).toBe("Some New Thing");
+  });
+});
diff --git a/tests/stats-database.test.ts b/tests/stats-database.test.ts
new file mode 100644
index 0000000..5ee76fd
--- /dev/null
+++ b/tests/stats-database.test.ts
@@ -0,0 +1,282 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import { INSTALL_CONVERSION_DAYS } from "../shared/stats";
+import { buildStatsSnapshot, DAY_MS, dayStart, STATS_PRESENCE_LEASE_MS, WEEK_MS, weekStart } from "../shared/stats-snapshot";
+import type { AnalyticsEvent } from "../worker/analytics";
+import {
+  clearStatsPresence,
+  collectStatsRows,
+  HOUR_MS,
+  initializeStatsSchema,
+  parseStatsPresence,
+  parseStatsRecord,
+  recordStatsEvent,
+  writeStatsPresence,
+  type StatsEventRecord,
+  type StatsSql,
+} from "../worker/stats-database";
+
+/*
+ * The Durable Object's database code, run against node:sqlite, which is the
+ * same engine the object's storage runs. The adapter is the two cursor
+ * methods the code uses and nothing else.
+ */
+function openDatabase(): StatsSql {
+  const database = new DatabaseSync(":memory:");
+  return {
+    exec(query, ...bindings) {
+      const statement = database.prepare(query);
+      const values = bindings as (string | number | null)[];
+      if (!/^\s*SELECT/i.test(query)) {
+        statement.run(...values);
+        return { toArray: () => [], one: () => { throw new Error("a statement returns no rows"); } };
+      }
+      const rows = statement.all(...values).map((row) => ({ ...row }));
+      return {
+        toArray: () => rows as never,
+        one: () => {
+          if (rows.length !== 1) throw new Error(`expected one row, got ${rows.length}`);
+          return rows[0] as never;
+        },
+      };
+    },
+  };
+}
+
+function freshDatabase(): StatsSql {
+  const sql = openDatabase();
+  initializeStatsSchema(sql);
+  /* A second run must be a no-op: the object runs it on every start. */
+  initializeStatsSchema(sql);
+  return sql;
+}
+
+/* 12:00 UTC on a Tuesday, so weeks and days are easy to read. */
+const now = Date.UTC(2026, 8, 15, 12);
+/** 06:00 UTC, n days before today. */
+const daysAgo = (n: number): number => dayStart(now) - n * DAY_MS + 6 * HOUR_MS;
+/** A visitor hash: twenty hex characters, as the Worker sends them. */
+const hash = (name: string): string => name.charCodeAt(0).toString(16).padStart(2, "0").repeat(10);
+
+function event(at: number, name: AnalyticsEvent, target: string, extras: Partial<StatsEventRecord> = {}): StatsEventRecord {
+  return { event: name, target, device: "desktop", client: "web", referrer: "direct", count: 1, value: 0, auxiliary: 0, at, ...extras };
+}
+
+const bySurface = <T extends { surface: string }>(rows: T[]): T[] => [...rows].sort((left, right) => left.surface.localeCompare(right.surface));
+
+describe("the dashboard's database", () => {
+  it("adds events into hour buckets, keeping sums and maxima per dimension", () => {
+    const sql = freshDatabase();
+    recordStatsEvent(sql, event(daysAgo(1), "session_ended", "task_exit", { device: "cli", value: 100, auxiliary: 3 }));
+    recordStatsEvent(sql, event(daysAgo(1) + 60_000, "session_ended", "task_exit", { device: "cli", value: 50, auxiliary: 5 }));
+    recordStatsEvent(sql, event(daysAgo(1) + HOUR_MS, "session_ended", "task_exit", { device: "cli", value: 10, auxiliary: 1 }));
+    recordStatsEvent(sql, event(daysAgo(1) + HOUR_MS, "session_ended", "task_exit", { device: "desktop", value: 1, auxiliary: 0 }));
+    const { rows } = collectStatsRows(sql, "7d", false, now);
+    expect(rows.summary).toEqual([
+      { event: "session_ended", target: "task_exit", count: 4, value_sum: 161, value_max: 100, auxiliary_sum: 9, auxiliary_max: 5 },
+    ]);
+    expect(rows.live).toEqual({ active_sessions: 0, active_viewers: 0 });
+  });
+
+  it("answers a range with its own buckets, the period before with its own, and all time with everything", () => {
+    const sql = freshDatabase();
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing"));
+    recordStatsEvent(sql, event(daysAgo(1) + 60_000, "page_view", "landing"));
+    recordStatsEvent(sql, event(daysAgo(10), "page_view", "landing"));
+    recordStatsEvent(sql, event(daysAgo(20), "page_view", "landing"));
+
+    const week = collectStatsRows(sql, "7d", false, now);
+    expect(week.rangeStart).toBe(now - 7 * DAY_MS);
+    expect(week.rows.summary).toMatchObject([{ event: "page_view", target: "landing", count: 2 }]);
+    expect(week.rows.trend).toEqual([{ bucket: Math.floor(daysAgo(1) / HOUR_MS) * HOUR_MS, event: "page_view", count: 2 }]);
+    expect(week.rows.previous).toMatchObject({ rangeStart: now - 14 * DAY_MS, summary: [{ count: 1 }], byDevice: [{ device: "desktop", count: 1 }], uniques: [] });
+    expect(week.rows.collectingSince).toBe(Math.floor(daysAgo(20) / HOUR_MS) * HOUR_MS);
+
+    const all = collectStatsRows(sql, "all", false, now);
+    expect(all.rangeStart).toBe(all.rows.collectingSince);
+    expect(all.rows.previous).toBeNull();
+    expect(all.rows.summary).toMatchObject([{ count: 4 }]);
+
+    /* The last 24 hours start at noon yesterday; the 06:00 views fall in the day before that. */
+    const day = collectStatsRows(sql, "24h", false, now);
+    expect(day.rows.summary).toEqual([]);
+    expect(day.rows.previous).toMatchObject({ rangeStart: now - 2 * DAY_MS, summary: [{ count: 2 }] });
+  });
+
+  it("splits the counted events by device class and ranks dimensions by count", () => {
+    const sql = freshDatabase();
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing", { device: "desktop", referrer: "hacker_news" }));
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing", { device: "desktop", referrer: "direct" }));
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing", { device: "bot", client: "bot" }));
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "docs_app", { device: "mobile" }));
+    recordStatsEvent(sql, event(daysAgo(1), "installer_download", "posix", { device: "cli", client: "curl" }));
+    recordStatsEvent(sql, event(daysAgo(1), "session_created", "cli", { device: "cli", client: "shell/0.15.1" }));
+    recordStatsEvent(sql, event(daysAgo(1), "share_opened", "viewer", { device: "mobile" }));
+    recordStatsEvent(sql, event(daysAgo(1), "collaboration_started", "remote_input", { device: "mobile" }));
+    const { rows } = collectStatsRows(sql, "7d", false, now);
+    expect(rows.byDevice).toEqual([
+      { event: "installer_download", target: "posix", device: "cli", count: 1 },
+      { event: "page_view", target: "docs_app", device: "mobile", count: 1 },
+      { event: "page_view", target: "landing", device: "bot", count: 1 },
+      { event: "page_view", target: "landing", device: "desktop", count: 2 },
+    ]);
+    expect(rows.devices).toEqual([{ name: "desktop", count: 2 }, { name: "bot", count: 1 }, { name: "mobile", count: 1 }]);
+    expect(rows.referrers).toEqual([{ name: "direct", count: 3 }, { name: "hacker_news", count: 1 }]);
+    expect(rows.clients).toEqual([{ name: "shell/0.15.1", count: 1 }]);
+    expect(rows.openedDevices).toEqual([{ name: "mobile", count: 1 }]);
+    expect(rows.typedDevices).toEqual([{ name: "mobile", count: 1 }]);
+  });
+
+  it("counts a person once per day per surface, tells new from returning, and says since when", () => {
+    const sql = freshDatabase();
+    recordStatsEvent(sql, event(daysAgo(10), "page_view", "landing", { visitor: hash("a") }));
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing", { visitor: hash("a") }));
+    recordStatsEvent(sql, event(daysAgo(1) + 60_000, "page_view", "docs", { visitor: hash("a") }));
+    recordStatsEvent(sql, event(daysAgo(1), "cta_click", "signup_hero", { visitor: hash("b") }));
+    recordStatsEvent(sql, event(daysAgo(1), "session_created", "cli", { device: "cli", visitor: hash("c") }));
+    /* No person behind these: an unknown path with a hash, and a page view without one. */
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "unknown_path", { visitor: hash("d") }));
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing"));
+
+    const { rows } = collectStatsRows(sql, "7d", true, now);
+    expect(rows.uniquesSince).toBe(dayStart(daysAgo(10)));
+    expect(bySurface(rows.uniques)).toEqual([
+      { surface: "cli", unique_count: 1, new_count: 1 },
+      { surface: "site", unique_count: 2, new_count: 1 },
+    ]);
+    expect(rows.uniqueDays).toEqual([
+      { day: dayStart(daysAgo(1)), surface: "cli", unique_count: 1 },
+      { day: dayStart(daysAgo(1)), surface: "site", unique_count: 2 },
+    ]);
+    expect(rows.previous?.uniques).toEqual([{ surface: "site", unique_count: 1 }]);
+    expect(rows.retention.filter((row) => row.visitor === hash("a")).map((row) => row.day).sort()).toEqual(
+      [dayStart(daysAgo(10)), dayStart(daysAgo(1))].sort(),
+    );
+    expect(rows.retention.every((row) => row.surface === "site" || row.surface === "cli")).toBe(true);
+  });
+
+  it("forgets people past the memory window, and a returning one keeps their first day", () => {
+    const sql = freshDatabase();
+    recordStatsEvent(sql, event(daysAgo(130), "page_view", "landing", { visitor: hash("o") }));
+    recordStatsEvent(sql, event(daysAgo(130), "page_view", "landing", { visitor: hash("a") }));
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing", { visitor: hash("a") }));
+
+    const { rows } = collectStatsRows(sql, "all", true, now);
+    expect(rows.uniquesSince).toBe(dayStart(daysAgo(1)));
+    /* First seen since collection began, so new on the all-time range; returning on a week. */
+    expect(rows.uniques).toEqual([{ surface: "site", unique_count: 1, new_count: 1 }]);
+    expect(collectStatsRows(sql, "7d", true, now).rows.uniques).toEqual([{ surface: "site", unique_count: 1, new_count: 0 }]);
+    /* The metrics keep the old view; only the person is forgotten. */
+    expect(rows.summary).toMatchObject([{ event: "page_view", count: 3 }]);
+    const left = sql.exec<{ visitor: string; first_day: number }>("SELECT visitor, first_day FROM visitors ORDER BY visitor").toArray();
+    expect(left).toEqual([{ visitor: hash("a"), first_day: dayStart(daysAgo(130)) }]);
+  });
+
+  it("follows machines from the installer to a first session within the window", () => {
+    const sql = freshDatabase();
+    const install = (name: string, when: number): void =>
+      recordStatsEvent(sql, event(when, "binary_download", "darwin-arm64", { device: "cli", client: "curl", visitor: hash(name) }));
+    const session = (name: string, when: number): void =>
+      recordStatsEvent(sql, event(when, "session_created", "cli", { device: "cli", client: "shell/0.15.1", visitor: hash(name) }));
+    install("1", daysAgo(20)); session("1", daysAgo(18));                 /* within the window */
+    install("2", daysAgo(20)); session("2", daysAgo(5));                  /* too late */
+    install("3", daysAgo(3));                                            /* too fresh to tell */
+    install("4", daysAgo(20));                                           /* never */
+    session("5", daysAgo(25)); install("5", daysAgo(20));                 /* already had the CLI */
+    install("6", daysAgo(40));                                           /* before the range */
+
+    const { rows } = collectStatsRows(sql, "30d", true, now);
+    expect(rows.installConversion).toEqual({ installers: 5, matured: 4, started: 1 });
+    expect(INSTALL_CONVERSION_DAYS).toBe(7);
+    expect(collectStatsRows(sql, "30d", false, now).rows.installConversion).toBeNull();
+    expect(collectStatsRows(sql, "all", true, now).rows.installConversion).toMatchObject({ installers: 6 });
+  });
+
+  it("keeps a live presence lease until it ends, and drops it when told", () => {
+    const sql = freshDatabase();
+    const key = (letter: string): string => letter.repeat(22);
+    writeStatsPresence(sql, { key: key("a"), activeSessions: 1, activeViewers: 2 }, now);
+    writeStatsPresence(sql, { key: key("b"), activeSessions: 1, activeViewers: 5 }, now - STATS_PRESENCE_LEASE_MS - 1);
+    writeStatsPresence(sql, { key: key("c"), activeSessions: 1, activeViewers: 0 }, now);
+    clearStatsPresence(sql, key("c"));
+    expect(collectStatsRows(sql, "7d", false, now).rows.live).toEqual({ active_sessions: 1, active_viewers: 2 });
+    writeStatsPresence(sql, { key: key("a"), activeSessions: 1, activeViewers: 3 }, now);
+    expect(collectStatsRows(sql, "7d", false, now).rows.live).toEqual({ active_sessions: 1, active_viewers: 3 });
+    writeStatsPresence(sql, { key: key("a"), activeSessions: 0, activeViewers: 0 }, now);
+    expect(collectStatsRows(sql, "7d", false, now).rows.live).toEqual({ active_sessions: 0, active_viewers: 0 });
+  });
+
+  it("hands the cohort grids only people first seen inside them", () => {
+    const sql = freshDatabase();
+    const monday = weekStart(now);
+    recordStatsEvent(sql, event(monday - 2 * WEEK_MS + HOUR_MS, "page_view", "landing", { visitor: hash("r") }));
+    recordStatsEvent(sql, event(monday - WEEK_MS + HOUR_MS, "page_view", "landing", { visitor: hash("r") }));
+    recordStatsEvent(sql, event(monday - 10 * WEEK_MS + HOUR_MS, "page_view", "landing", { visitor: hash("z") }));
+    recordStatsEvent(sql, event(monday - WEEK_MS + HOUR_MS, "page_view", "landing", { visitor: hash("z") }));
+    recordStatsEvent(sql, event(monday - WEEK_MS + HOUR_MS, "viewer_connected", "viewer", { visitor: hash("v") }));
+    const { rows } = collectStatsRows(sql, "7d", true, now);
+    expect(rows.retention.map((row) => [row.visitor, row.first_day, row.day])).toEqual([
+      [hash("r"), monday - 2 * WEEK_MS, monday - 2 * WEEK_MS],
+      [hash("r"), monday - 2 * WEEK_MS, monday - WEEK_MS],
+    ]);
+  });
+
+  it("builds a coherent snapshot from what it recorded", () => {
+    const sql = freshDatabase();
+    for (let index = 0; index < 5; index += 1) {
+      recordStatsEvent(sql, event(daysAgo(1) + index * HOUR_MS, "page_view", "landing", { visitor: hash("p") }));
+    }
+    recordStatsEvent(sql, event(daysAgo(1), "page_view", "landing", { device: "bot", client: "bot" }));
+    recordStatsEvent(sql, event(daysAgo(1), "installer_download", "posix", { device: "cli", client: "curl", visitor: hash("m") }));
+    recordStatsEvent(sql, event(daysAgo(1), "binary_download", "darwin-arm64", { device: "cli", client: "curl", visitor: hash("m") }));
+    recordStatsEvent(sql, event(daysAgo(1), "session_created", "cli", { device: "cli", client: "shell/0.15.1", visitor: hash("m") }));
+    recordStatsEvent(sql, event(daysAgo(1), "session_started", "cli", { device: "cli", client: "shell/0.15.1" }));
+    recordStatsEvent(sql, event(daysAgo(1), "share_opened", "viewer", { value: 30, visitor: hash("p") }));
+    recordStatsEvent(sql, event(daysAgo(1), "viewer_connected", "viewer", { visitor: hash("p") }));
+    recordStatsEvent(sql, event(daysAgo(9), "page_view", "landing", { visitor: hash("q") }));
+    /* Collection began before the period of comparison, or there would be none. */
+    recordStatsEvent(sql, event(daysAgo(16), "page_view", "landing"));
+
+    const { rows, rangeStart } = collectStatsRows(sql, "7d", true, now);
+    const snapshot = buildStatsSnapshot(rows, "7d", now, rangeStart);
+    expect(snapshot.figures).toMatchObject({ siteViews: 5, crawlerViews: 1, installerRuns: 1, installs: 1, sessionsStarted: 1, sharesOpened: 1 });
+    expect(snapshot.uniques.surfaces).toMatchObject({
+      site: { unique: 1, new: 1, returning: 0 },
+      install: { unique: 1 },
+      cli: { unique: 1 },
+      viewer: { unique: 1 },
+    });
+    expect(snapshot.uniques.since).toBe(dayStart(daysAgo(9)));
+    expect(snapshot.metrics.averageSecondsToOpen).toBe(30);
+    expect(snapshot.previous).toMatchObject({ figures: { siteViews: 1 }, people: null });
+    expect(snapshot.installConversion).toEqual({ installers: 1, matured: 0, started: 0 });
+  });
+
+  it("parses only records shaped as the Worker sends them, within ten minutes of its own clock", () => {
+    const base = { event: "page_view", target: "landing", device: "desktop", client: "web", referrer: "direct", count: 1, value: 0, auxiliary: 0, at: now };
+    expect(parseStatsRecord(base, now)).toEqual(base);
+    expect(parseStatsRecord({ ...base, visitor: hash("a") }, now)).toEqual({ ...base, visitor: hash("a") });
+    expect(parseStatsRecord({ ...base, at: now - 9 * 60_000 }, now)).not.toBeNull();
+    expect(parseStatsRecord({ ...base, at: now - 11 * 60_000 }, now)).toBeNull();
+    expect(parseStatsRecord({ ...base, event: "made_up" }, now)).toBeNull();
+    expect(parseStatsRecord({ ...base, target: "Not A Target" }, now)).toBeNull();
+    expect(parseStatsRecord({ ...base, count: 2 }, now)).toBeNull();
+    expect(parseStatsRecord({ ...base, value: "12" }, now)).toBeNull();
+    expect(parseStatsRecord({ ...base, visitor: "not-a-hash" }, now)).toBeNull();
+    expect(parseStatsRecord({ ...base, visitor: 12345 }, now)).toBeNull();
+    expect(parseStatsRecord(undefined, now)).toBeNull();
+    expect(parseStatsRecord("page_view", now)).toBeNull();
+  });
+
+  it("parses a presence lease only from a session object's key and small counts", () => {
+    const key = "k".repeat(22);
+    expect(parseStatsPresence({ key, activeSessions: 1, activeViewers: 3 })).toEqual({ key, activeSessions: 1, activeViewers: 3 });
+    expect(parseStatsPresence({ key, activeSessions: 0, activeViewers: 0 })).toEqual({ key, activeSessions: 0, activeViewers: 0 });
+    expect(parseStatsPresence({ key, activeSessions: 2, activeViewers: 0 })).toBeNull();
+    expect(parseStatsPresence({ key, activeSessions: 1, activeViewers: 17 })).toBeNull();
+    expect(parseStatsPresence({ key, activeSessions: 1, activeViewers: 1.5 })).toBeNull();
+    expect(parseStatsPresence({ key: "short", activeSessions: 1, activeViewers: 0 })).toBeNull();
+    expect(parseStatsPresence({ key }, true)).toEqual({ key, activeSessions: 0, activeViewers: 0 });
+    expect(parseStatsPresence(null)).toBeNull();
+  });
+});
diff --git a/web/stats.css b/web/stats.css
index ab31ed4..a43a6fa 100644
--- a/web/stats.css
+++ b/web/stats.css
@@ -1790,7 +1790,7 @@ html.stats-document #app {
 .funnel-steps {
   display: grid;
   padding: 4px 0 0;
-  grid-template-columns: repeat(7, minmax(0, 1fr));
+  grid-template-columns: repeat(4, minmax(0, 1fr));
   gap: 14px;
 }
 
@@ -2035,3 +2035,83 @@ html.stats-document #app {
 .accounts-panel {
   padding: 20px 22px 18px;
 }
+
+/* The line under the title: what is live this minute, apart from any range. */
+.stats-live {
+  margin: 14px 0 0;
+  color: #9fb0cc;
+  font-size: 12.5px;
+  line-height: 1.5;
+}
+
+.stats-live b {
+  color: #edf2fa;
+  font-weight: 560;
+  font-variant-numeric: tabular-nums;
+}
+
+/* How a headline figure moved against the period before. */
+.kpi-delta {
+  display: inline-block;
+  margin-left: 8px;
+  padding: 2px 7px;
+  border-radius: 999px;
+  background: rgb(255 255 255 / 5%);
+  color: #8490a5;
+  font-size: 9.5px;
+  font-style: normal;
+  font-weight: 600;
+  letter-spacing: 0;
+  line-height: 1.3;
+  vertical-align: middle;
+  font-variant-numeric: tabular-nums;
+}
+
+.kpi-delta.up {
+  background: rgb(117 218 194 / 12%);
+  color: #75dac2;
+}
+
+.kpi-delta.down {
+  background: rgb(240 160 160 / 12%);
+  color: #f0a0a0;
+}
+
+/* The finding before the numbers: one sentence at the top of a panel. */
+.panel-insight {
+  margin: -10px 0 16px;
+  color: #b3bfd2;
+  font-size: 12.5px;
+  line-height: 1.55;
+}
+
+.funnel-step > .funnel-excluded {
+  color: #6e7a8f;
+  font-size: 10px;
+  font-style: normal;
+  font-variant-numeric: tabular-nums;
+  line-height: 1.4;
+}
+
+.traffic-split .split-people i { background: #8eafff; }
+.traffic-split .split-crawlers i { background: #f4bd78; }
+.traffic-split .split-tools i { background: #a6b6d3; }
+.traffic-split .split-page i { background: #6d7992; }
+
+.breakdown-panel > .cohort-empty {
+  margin-top: 12px;
+  font-size: 11px;
+}
+
+.accounts-events {
+  margin-top: 14px;
+  padding-top: 14px;
+  border-top: 1px solid var(--stats-border);
+}
+
+.kind-rate .breakdown-list > div > strong small {
+  margin-left: 6px;
+  color: #6e7a8f;
+  font-size: 9px;
+  font-weight: 500;
+}
diff --git a/web/stats.ts b/web/stats.ts
index 8433f8a..bbdfe99 100644
--- a/web/stats.ts
+++ b/web/stats.ts
@@ -1,4 +1,5 @@
 import {
+  INSTALL_CONVERSION_DAYS,
   STATS_RANGES,
   type StatsBreakdownItem,
   type StatsRange,
@@ -6,6 +7,19 @@ import {
   type StatsSeriesPoint,
   type StatsSnapshot,
 } from "../shared/stats";
+import { peopleCountedSince } from "../shared/stats-snapshot";
+import {
+  deltaChip,
+  formatDuration,
+  formatPercent,
+  funnelInsight,
+  humanize,
+  integerFormatter,
+  numberFormatter,
+  ratio,
+  sessionsInsight,
+  trafficInsight,
+} from "../shared/stats-copy";
 import { RELEASE_CHECKSUMS_PATH, RELEASE_VERSION } from "../shared/release";
 import "./stats.css";
 
@@ -25,8 +39,6 @@ const ACTIVITY_SERIES: ChartSeries[] = [
 const TRAFFIC_SERIES: ChartSeries[] = [
   { key: "pageViews", label: "Page views", color: "#9ab7e8" },
 ];
-const numberFormatter = new Intl.NumberFormat("en-US", { maximumFractionDigits: 1 });
-const integerFormatter = new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 });
 let activeDashboardCleanup: (() => void) | null = null;
 let statsRenderId = 0;
 
@@ -206,6 +218,7 @@ function renderAuthenticatedDashboard(root: HTMLElement): () => void {
           <div>
             <span class="stats-eyebrow">Aggregate product signal</span>
             <h1>What shell.online<br>is doing.</h1>
+            <p id="stats-live" class="stats-live">Checking what is live…</p>
           </div>
           <div class="stats-freshness">
             <span id="stats-state"><i></i> Loading live metrics</span>
@@ -327,16 +340,45 @@ function renderAuthenticatedDashboard(root: HTMLElement): () => void {
 
 function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
   const metrics = snapshot.metrics;
+  const figures = snapshot.figures;
+  const audiences = snapshot.audiences;
+  const previous = snapshot.previous;
   const rangeLabel = snapshot.range === "all" ? "all time" : `last ${snapshot.range}`;
+  const priorLabel = snapshot.range === "all" ? "" : `the ${snapshot.range} before`;
   const outcomes = snapshot.breakdowns.outcomes;
   const endedSessions = outcomes.reduce((sum, item) => sum + item.value, 0);
   const people = snapshot.uniques;
   const site = people.surfaces.site;
   const cli = people.surfaces.cli;
+  /*
+   * People are counted from the day the salt was set, events from the first
+   * event. A people figure over fewer days than the count beside it says so,
+   * or thirty days of views next to one day of people reads as nonsense.
+   */
+  const peopleSince = peopleCountedSince(people, snapshot.rangeStart);
+  /* Plain text: renderKpi escapes its detail. */
+  const sinceNote = peopleSince === null ? "" : ` · counted since ${formatDay(peopleSince)}`;
+  const totalViews = metrics.landingViews + metrics.docsViews;
+  const otherViews = audiences.views.tools + audiences.views.unknown;
   const ctaByLink = snapshot.targets
     .filter((metric) => metric.event === "cta_click")
     .map((metric) => ({ label: metric.target, value: metric.count }))
     .sort((left, right) => right.value - left.value);
+  const installsByPlatform = snapshot.targets
+    .filter((metric) => metric.event === "binary_download")
+    .map((metric) => ({ label: metric.target, value: metric.count }))
+    .sort((left, right) => right.value - left.value);
+  const installerAudience = [
+    { label: "Piped to a shell (curl, wget)", value: audiences.installer.tools },
+    { label: "Read in a browser", value: audiences.installer.browsers },
+    { label: "Fetched by crawlers", value: audiences.installer.crawlers },
+    { label: "No user agent", value: audiences.installer.unknown },
+  ].filter((item) => item.value > 0);
+  const delta = (current: number, before: number | null | undefined): string =>
+    renderDelta(current, before ?? null, priorLabel);
+
+  renderLive(metrics);
+
   container.innerHTML = `
     ${people.configured ? "" : `
       <p class="stats-note">
@@ -346,60 +388,70 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
     `}
     <section class="stats-kpis" aria-label="Headline statistics">
       ${renderKpi(
-        "Active now",
-        metrics.activeSessions,
-        `${integerFormatter.format(metrics.activeViewers)} viewer${metrics.activeViewers === 1 ? "" : "s"} connected now`,
-        snapshot.trend,
-        "sessions",
-        "blue",
-      )}
-      ${renderKpi(
-        "Unique visitors",
+        "Visitors",
         people.configured ? site.unique : "—",
         people.configured
-          ? `${integerFormatter.format(site.new)} new · ${integerFormatter.format(site.returning)} returning`
-          : `${integerFormatter.format(metrics.landingViews)} landing views, people not counted`,
+          ? `${integerFormatter.format(site.new)} new · ${integerFormatter.format(site.returning)} returning${sinceNote}`
+          : "people are not counted yet",
         snapshot.trend,
         "pageViews",
         "silver",
+        people.configured ? delta(site.unique, previous?.people?.site) : "",
+      )}
+      ${renderKpi(
+        "Views by people",
+        figures.siteViews,
+        figures.crawlerViews === 0
+          ? "no crawler views in this range"
+          : `${integerFormatter.format(figures.crawlerViews)} more by crawlers, kept out`,
+        snapshot.trend,
+        "pageViews",
+        "blue",
+        delta(figures.siteViews, previous?.figures.siteViews),
       )}
       ${renderKpi(
         "Installs completed",
-        metrics.binaryDownloads,
-        `${integerFormatter.format(metrics.installs)} installer fetch${metrics.installs === 1 ? "" : "es"}`,
+        figures.installs,
+        figures.installerRuns === 0
+          ? "no installer runs in this range"
+          : `${formatPercent(ratio(figures.installs, figures.installerRuns))} of ${integerFormatter.format(figures.installerRuns)} installer run${figures.installerRuns === 1 ? "" : "s"}`,
         snapshot.trend,
         "sessions",
         "amber",
+        delta(figures.installs, previous?.figures.installs),
       )}
       ${renderKpi(
         "Sessions started",
-        metrics.sessionsStarted,
+        figures.sessionsStarted,
         people.configured
-          ? `from ${integerFormatter.format(cli.unique)} machine${cli.unique === 1 ? "" : "s"}, ${integerFormatter.format(cli.new)} new`
+          ? `on ${integerFormatter.format(cli.unique)} machine${cli.unique === 1 ? "" : "s"}, ${integerFormatter.format(cli.new)} new${sinceNote}`
           : `${integerFormatter.format(metrics.sessionsCreated)} created`,
         snapshot.trend,
         "sessions",
         "violet",
+        delta(figures.sessionsStarted, previous?.figures.sessionsStarted),
       )}
       ${renderKpi(
         "Opened in a browser",
-        metrics.sharesOpened,
-        metrics.sessionsStarted === 0
-          ? "No sessions in this range"
-          : `${formatPercent(ratio(metrics.sharesOpened, metrics.sessionsStarted))} of sessions started`,
+        figures.sharesOpened,
+        figures.sessionsStarted === 0
+          ? "no sessions in this range"
+          : `${formatPercent(ratio(figures.sharesOpened, figures.sessionsStarted))} of sessions started`,
         snapshot.trend,
         "shares",
         "green",
+        delta(figures.sharesOpened, previous?.figures.sharesOpened),
       )}
       ${renderKpi(
         "Typed from a browser",
-        metrics.collaborations,
-        metrics.sharesOpened === 0
-          ? "No opened sessions yet"
-          : `${formatPercent(ratio(metrics.collaborations, metrics.sharesOpened))} of opened sessions`,
+        figures.collaborations,
+        figures.sharesOpened === 0
+          ? "no opened sessions yet"
+          : `${formatPercent(ratio(figures.collaborations, figures.sharesOpened))} of opened sessions`,
         snapshot.trend,
         "collaborations",
         "pink",
+        delta(figures.collaborations, previous?.figures.collaborations),
       )}
     </section>
 
@@ -408,10 +460,53 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
         <div><span class="panel-kicker">From a first look to a first keystroke</span><h2>Funnel</h2></div>
         <span class="panel-range">${escapeHtml(rangeLabel)}</span>
       </header>
-      ${renderFunnel(snapshot)}
+      <p class="panel-insight">${escapeHtml(funnelInsight(snapshot))}</p>
+      ${renderFunnel(snapshot, peopleSince)}
+      ${peopleSince === null ? "" : `<p class="cohort-empty">People have been counted since ${escapeHtml(formatDay(peopleSince))}; event counts run from the start of the range. Until the range begins after that day, a people figure covers fewer days than the count beside it.</p>`}
+      ${renderInstallConversion(snapshot)}
       ${renderUniquesStrip(snapshot)}
     </article>
 
+    <section class="stats-wide-grid">
+      <article class="stats-panel traffic-panel">
+        <header class="panel-heading">
+          <div><span class="panel-kicker">Who came</span><h2>Traffic</h2></div>
+          <strong>${integerFormatter.format(totalViews)} <small>views</small></strong>
+        </header>
+        <p class="panel-insight">${escapeHtml(trafficInsight(snapshot))}</p>
+        ${renderTimeChart("traffic", snapshot.trend, TRAFFIC_SERIES, snapshot.range, true)}
+        <div class="traffic-split is-wide">
+          <span class="split-people"><i></i>People <b>${integerFormatter.format(audiences.views.browsers)}</b></span>
+          <span class="split-crawlers"><i></i>Crawlers <b>${integerFormatter.format(audiences.views.crawlers)}</b></span>
+          <span class="split-tools"><i></i>Tools <b>${integerFormatter.format(otherViews)}</b></span>
+          <span class="split-page"><i></i>Landing <b>${integerFormatter.format(metrics.landingViews)}</b></span>
+          <span class="split-page"><i></i>Docs <b>${integerFormatter.format(metrics.docsViews)}</b></span>
+          <span class="split-page"><i></i>Shared terminals <b>${integerFormatter.format(metrics.terminalViews)}</b></span>
+          <span class="split-page"><i></i>Unknown paths <b>${integerFormatter.format(metrics.unknownPaths)}</b></span>
+          <span class="split-page"><i></i>404s <b>${integerFormatter.format(metrics.notFoundViews)}</b></span>
+        </div>
+      </article>
+      ${renderBreakdown(
+        "Sources",
+        "Where landing visits came from",
+        snapshot.breakdowns.referrers,
+        "referrer",
+        "Landing page only. Most browsers send no referrer, so Direct is also everyone they hid.",
+      )}
+    </section>
+
+    <section class="stats-breakdown-grid">
+      ${renderBreakdown("Pages", "Document views by page, every audience", snapshot.breakdowns.pages, "page")}
+      ${renderBreakdown("Devices", "Page views by device class", snapshot.breakdowns.devices, "device")}
+      ${renderBreakdown(
+        "Sign-up clicks",
+        "Which landing link was clicked",
+        ctaByLink,
+        "cta",
+        "Accounts also start in the app, from an invite, or from the CLI, none of which pass here.",
+      )}
+    </section>
+
     <section class="stats-wide-grid">
       <article class="stats-panel activity-panel">
         <header class="panel-heading">
@@ -420,6 +515,7 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
             ${ACTIVITY_SERIES.map((series) => `<span><i style="--legend:${series.color}"></i>${series.label}</span>`).join("")}
           </div>
         </header>
+        <p class="panel-insight">${escapeHtml(sessionsInsight(snapshot))}</p>
         ${renderTimeChart("activity", snapshot.trend, ACTIVITY_SERIES, snapshot.range)}
       </article>
 
@@ -434,10 +530,64 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
           <span><small>Longest lifetime</small><b>${formatDuration(metrics.longestDurationSeconds)}</b></span>
           <span><small>Avg peak audience</small><b>${numberFormatter.format(metrics.averagePeakViewers)}</b></span>
           <span><small>Largest audience</small><b>${integerFormatter.format(metrics.maximumPeakViewers)}</b></span>
+          <span><small>Link waited for its first open</small><b>${metrics.sharesOpened === 0 ? "—" : formatDuration(metrics.averageSecondsToOpen)}</b></span>
+          <span><small>Open to first keystroke</small><b>${metrics.collaborations === 0 ? "—" : formatDuration(metrics.averageSecondsToType)}</b></span>
+          <span><small>A viewer stayed</small><b>${metrics.averageViewerSeconds === 0 ? "—" : formatDuration(metrics.averageViewerSeconds)}</b></span>
+          <span><small>Viewers turned away</small><b>${integerFormatter.format(metrics.viewersRejected)}</b></span>
         </div>
       </article>
     </section>
 
+    <section class="stats-breakdown-grid">
+      ${renderBreakdown("CLI clients", "Versions creating sessions", snapshot.breakdowns.clients, "client")}
+      ${renderRates(
+        "Typed, by device",
+        "Of sessions opened on each device class, how many were typed into",
+        snapshot.breakdowns.openedDevices.map((opened) => ({
+          label: opened.label,
+          numerator: snapshot.breakdowns.typedDevices.find((typed) => typed.label === opened.label)?.value ?? 0,
+          denominator: opened.value,
+        })),
+        "Device is the first viewer's for opened and the first typist's for typed, so a phone that watched while a laptop typed lands on both sides.",
+      )}
+      ${renderBreakdown(
+        "Turned away",
+        "Browsers that opened a link and got nothing",
+        [
+          ...snapshot.breakdowns.rejections,
+          ...(metrics.inputDenied > 0 ? [{ label: "typed_into_read_only", value: metrics.inputDenied }] : []),
+        ],
+        "rejection",
+        "A full, expired or unknown session closes the link at once; typing into a read-only session is refused but the viewer stays. None of these appear as opened.",
+      )}
+    </section>
+
+    <section class="stats-breakdown-grid">
+      ${renderBreakdown(
+        "Installer",
+        "Who fetched the install script",
+        installerAudience,
+        "download",
+        metrics.skillDownloads === 0
+          ? "Only a fetch by curl or wget counts as a run."
+          : `Only a fetch by curl or wget counts as a run. The agent skill file was fetched ${integerFormatter.format(metrics.skillDownloads)} time${metrics.skillDownloads === 1 ? "" : "s"}.`,
+      )}
+      ${renderBreakdown(
+        "Installs by platform",
+        "Release binaries served",
+        installsByPlatform,
+        "download",
+        "Homebrew and source builds are not counted.",
+      )}
+      ${renderBreakdown(
+        "Installer outcomes",
+        "How installs ended, by the script's own account",
+        snapshot.breakdowns.installOutcomes,
+        "outcome",
+        "One word sent by the installer at its end, unless SHELL_ONLINE_INSTALL_REPORT=0 was set. A machine that never reached the end of the script reports nothing.",
+      )}
+    </section>
+
     <section class="stats-people-grid">
       ${renderCohorts(
         "Machines that came back",
@@ -459,32 +609,8 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
 
     ${renderAccounts(snapshot)}
 
-    <article class="stats-panel traffic-panel">
-      <header class="panel-heading">
-        <div><span class="panel-kicker">Attention</span><h2>Traffic pulse</h2></div>
-        <strong>${integerFormatter.format(metrics.landingViews + metrics.docsViews + metrics.terminalViews)} <small>views</small></strong>
-      </header>
-      ${renderTimeChart("traffic", snapshot.trend, TRAFFIC_SERIES, snapshot.range, true)}
-      <div class="traffic-split is-wide">
-        <span><i></i>Landing <b>${integerFormatter.format(metrics.landingViews)}</b></span>
-        <span><i></i>Docs <b>${integerFormatter.format(metrics.docsViews)}</b></span>
-        <span><i></i>Shared terminals <b>${integerFormatter.format(metrics.terminalViews)}</b></span>
-        <span><i></i>Unknown paths <b>${integerFormatter.format(metrics.unknownPaths)}</b></span>
-        <span><i></i>404s <b>${integerFormatter.format(metrics.notFoundViews)}</b></span>
-      </div>
-    </article>
-
-    <section class="stats-breakdown-grid">
-      ${renderBreakdown("Acquisition", "Where landing visits came from", snapshot.breakdowns.referrers, "referrer")}
-      ${renderBreakdown("Pages", "Document views by page", snapshot.breakdowns.pages, "page")}
-      ${renderBreakdown("Sign-up clicks", "Which link was clicked", ctaByLink, "cta")}
-      ${renderBreakdown("Devices", "Browsers opening shell.online", snapshot.breakdowns.devices, "device")}
-      ${renderBreakdown("CLI clients", "Versions creating sessions", snapshot.breakdowns.clients, "client")}
-      ${renderBreakdown("Delivery", "Installer, skill and binary requests", snapshot.breakdowns.downloads, "download")}
-    </section>
-
     <details class="stats-panel raw-metrics">
-      <summary><span><small>Complete event ledger</small>Every tracked aggregate</span><i></i></summary>
+      <summary><span><small>Complete event ledger</small>Every tracked aggregate, every audience</span><i></i></summary>
       <div class="metrics-table-wrap">
         <table>
           <thead><tr><th>Event</th><th>Target</th><th>Count</th><th>Value sum</th><th>Maximum</th></tr></thead>
@@ -504,8 +630,10 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
     </details>
 
     <div class="collection-note">
-      <span>Showing ${escapeHtml(rangeLabel)}.</span>
+      <span>Showing ${escapeHtml(rangeLabel)}${previous ? `, compared with ${escapeHtml(priorLabel)}` : ""}.</span>
       <span>${snapshot.collectingSince ? `Collecting exact dashboard metrics since ${formatDate(snapshot.collectingSince)}.` : "Waiting for the first event."}</span>
+      ${people.configured && people.since !== null ? `<span>Counting people since ${escapeHtml(formatDay(people.since, "long"))}.</span>` : ""}
+      <span>Crawlers are requests whose user agent says so; they stay in the ledger and out of every figure about people.</span>
       <span>People are keyed hashes of address and browser family, forgotten ${people.memoryDays} days after they were last seen; a person seen again after that counts as new.</span>
     </div>
   `;
@@ -514,6 +642,24 @@ function renderSnapshot(container: HTMLElement, snapshot: StatsSnapshot): void {
   bindChartInteraction(container.querySelector("#traffic-chart"), snapshot.trend, TRAFFIC_SERIES);
 }
 
+/** What is happening this minute, under the page title, so it is not mistaken for a range figure. */
+function renderLive(metrics: StatsSnapshot["metrics"]): void {
+  const live = document.getElementById("stats-live");
+  if (!live) return;
+  if (metrics.activeSessions === 0 && metrics.activeViewers === 0) {
+    live.textContent = "Nothing is live right now.";
+    return;
+  }
+  live.innerHTML = `Live now: <b>${integerFormatter.format(metrics.activeSessions)}</b> session${metrics.activeSessions === 1 ? "" : "s"}, <b>${integerFormatter.format(metrics.activeViewers)}</b> viewer${metrics.activeViewers === 1 ? "" : "s"} connected.`;
+}
+
+/** The chip beside a headline figure: how it moved against the period before, or nothing. */
+function renderDelta(current: number, before: number | null, priorLabel: string): string {
+  const chip = deltaChip(current, before, priorLabel);
+  if (chip === null) return "";
+  return `<em class="kpi-delta ${chip.tone}" title="${escapeHtml(chip.title)}">${chip.text}</em>`;
+}
+
 function renderKpi(
   label: string,
   value: number | string,
@@ -521,10 +667,11 @@ function renderKpi(
   trend: StatsSeriesPoint[],
   key: SeriesKey,
   tone: string,
+  delta = "",
 ): string {
   return `
     <article class="kpi-card tone-${tone}">
-      <div><span>${escapeHtml(label)}</span><strong>${typeof value === "number" ? integerFormatter.format(value) : escapeHtml(value)}</strong></div>
+      <div><span>${escapeHtml(label)}</span><strong>${typeof value === "number" ? integerFormatter.format(value) : escapeHtml(value)}${delta}</strong></div>
       <div class="kpi-spark">${renderSparkline(trend.map((point) => point[key]))}</div>
       <small>${escapeHtml(detail)}</small>
     </article>
@@ -601,8 +748,9 @@ function renderTimeChart(
   `;
 }
 
-function renderFunnel(snapshot: StatsSnapshot): string {
+function renderFunnel(snapshot: StatsSnapshot, peopleSince: number | null): string {
   const steps = snapshot.funnel;
+  const since = peopleSince === null ? "" : ` since ${escapeHtml(formatDay(peopleSince))}`;
   const colors = ["#9ab7e8", "#8eafff", "#819de5", "#f4bd78", "#8eafff", "#75dac2", "#d7a6ff"];
   const maximum = Math.max(1, ...steps.map((step) => step.count));
   return `
@@ -610,17 +758,23 @@ function renderFunnel(snapshot: StatsSnapshot): string {
       ${steps.map((step, index) => {
         const width = step.count === 0 ? 1.5 : Math.max(4, step.count / maximum * 100);
         const basis = step.basis === null ? null : steps.find((candidate) => candidate.key === step.basis) ?? null;
+        const basisCount = step.basisCount ?? basis?.count ?? 0;
+        const basisLabel = step.basisLabel ?? basis?.label.toLowerCase() ?? "";
         const share = basis === null
           ? (index === 0 ? "the whole path starts here" : "its own population")
-          : basis.count === 0
-            ? `no ${basis.label.toLowerCase()} to compare with`
-            : `${formatPercent(ratio(step.count, basis.count))} of ${basis.label.toLowerCase()}`;
+          : basisCount === 0
+            ? `no ${basisLabel} to compare with`
+            : `${formatPercent(ratio(step.count, basisCount))} of ${basisLabel}`;
+        const excluded = step.excluded.length === 0
+          ? ""
+          : `<em class="funnel-excluded">+ ${step.excluded.map((entry) => `${integerFormatter.format(entry.count)} ${escapeHtml(entry.label)}`).join(" · ")}</em>`;
         return `
           <div class="funnel-step">
             <span>${escapeHtml(step.label)}</span>
-            <b>${integerFormatter.format(step.count)}${step.unique === null ? "" : `<small>${integerFormatter.format(step.unique)} ${step.unique === 1 ? "person" : "people"}</small>`}</b>
+            <b>${integerFormatter.format(step.count)}${step.unique === null ? "" : `<small>${integerFormatter.format(step.unique)} ${step.unique === 1 ? "person" : "people"}${since}</small>`}</b>
             <div><i style="width:${width}%;--funnel:${colors[index % colors.length]}"></i></div>
             <em>${escapeHtml(share)}</em>
+            ${excluded}
             <small>${escapeHtml(step.note)}</small>
           </div>
         `;
@@ -629,6 +783,22 @@ function renderFunnel(snapshot: StatsSnapshot): string {
   `;
 }
 
+/**
+ * The one line that crosses from the installer to the CLI: of the machines
+ * that installed long enough ago to tell, how many started a session within
+ * the window. Fresh installs are named separately rather than counted as
+ * misses.
+ */
+function renderInstallConversion(snapshot: StatsSnapshot): string {
+  const conversion = snapshot.installConversion;
+  if (conversion === null || conversion.installers === 0) return "";
+  const fresh = conversion.installers - conversion.matured;
+  const verdict = conversion.matured === 0
+    ? `${integerFormatter.format(conversion.installers)} machine${conversion.installers === 1 ? "" : "s"} installed in this range, all within the last ${INSTALL_CONVERSION_DAYS} days, too recently to tell whether a session followed.`
+    : `Of the ${integerFormatter.format(conversion.matured)} machine${conversion.matured === 1 ? "" : "s"} that installed at least ${INSTALL_CONVERSION_DAYS} days ago, ${integerFormatter.format(conversion.started)} (${formatPercent(ratio(conversion.started, conversion.matured))}) started a session within ${INSTALL_CONVERSION_DAYS} days.${fresh > 0 ? ` ${integerFormatter.format(fresh)} more installed too recently to tell.` : ""}`;
+  return `<p class="cohort-empty">${escapeHtml(verdict)} Machines are followed by address from the binary download to the first session.</p>`;
+}
+
 function renderUniquesStrip(snapshot: StatsSnapshot): string {
   const people = snapshot.uniques;
   const cell = (label: string, surface: keyof typeof people.surfaces): string => {
@@ -721,6 +891,7 @@ function renderAccounts(snapshot: StatsSnapshot): string {
         </div>
         <div class="kpi-spark">${renderSparkline(accounts.newByDay.map((point) => point.count))}</div>
         <p class="cohort-empty">New accounts per day. Active means the account used the app in the range.</p>
+        ${renderAccountEvents(accounts.events)}
       </article>
       ${renderCohorts(
         "Accounts that came back",
@@ -734,8 +905,15 @@ function renderAccounts(snapshot: StatsSnapshot): string {
   `;
 }
 
+/** A dashboard day is a UTC day, so it is named in UTC wherever the reader is. */
+function formatDay(at: number, month: "short" | "long" = "short"): string {
+  return new Date(at).toLocaleDateString([], month === "long"
+    ? { month, day: "numeric", year: "numeric", timeZone: "UTC" }
+    : { month, day: "numeric", timeZone: "UTC" });
+}
+
 function formatWeek(weekStart: number): string {
-  return new Date(weekStart).toLocaleDateString([], { month: "short", day: "numeric", timeZone: "UTC" });
+  return formatDay(weekStart);
 }
 
 function renderDonut(items: StatsBreakdownItem[]): string {
@@ -763,11 +941,65 @@ function renderDonut(items: StatsBreakdownItem[]): string {
   `;
 }
 
+/**
+ * What accounts did, in the order the product hopes for: link a machine,
+ * register a session, send it a command. Counts of things done, not of
+ * accounts, since the app sends no identifiers with them.
+ */
+function renderAccountEvents(events: Record<string, number>): string {
+  const order = ["machine_linked", "session_registered", "command_sent", "vault_created", "invite_created", "invite_accepted", "feedback_sent"];
+  const items = order.filter((key) => (events[key] ?? 0) > 0).map((key) => ({ label: key, value: events[key] }));
+  if (items.length === 0) {
+    return '<p class="cohort-empty">Nothing done in the app in this range yet: no machine linked, session registered, command sent, vault created, invite, or feedback.</p>';
+  }
+  const maximum = Math.max(1, ...items.map((item) => item.value));
+  return `
+    <div class="breakdown-list accounts-events">
+      ${items.map((item) => `
+        <div>
+          <span>${escapeHtml(humanize(item.label))}</span>
+          <i><b style="width:${Math.max(2, item.value / maximum * 100)}%"></b></i>
+          <strong>${integerFormatter.format(item.value)}</strong>
+        </div>
+      `).join("")}
+    </div>
+    <p class="cohort-empty">Things done, not distinct accounts: one account linking three machines counts three times.</p>
+  `;
+}
+
+/** A panel of rates: each row a share of its own denominator, not of a total. */
+function renderRates(
+  title: string,
+  description: string,
+  rows: { label: string; numerator: number; denominator: number }[],
+  footnote = "",
+): string {
+  const shown = rows.filter((row) => row.denominator > 0).sort((left, right) => right.denominator - left.denominator);
+  return `
+    <article class="stats-panel breakdown-panel kind-rate">
+      <header class="panel-heading">
+        <div><span class="panel-kicker">${escapeHtml(description)}</span><h2>${escapeHtml(title)}</h2></div>
+      </header>
+      <div class="breakdown-list">
+        ${shown.slice(0, 7).map((row) => `
+          <div>
+            <span>${escapeHtml(humanize(row.label))}</span>
+            <i><b style="width:${Math.max(2, ratio(row.numerator, row.denominator) * 100)}%"></b></i>
+            <strong>${formatPercent(ratio(row.numerator, row.denominator))} <small>${integerFormatter.format(row.numerator)} of ${integerFormatter.format(row.denominator)}</small></strong>
+          </div>
+        `).join("") || "<em>No opened sessions in this range yet.</em>"}
+      </div>
+      ${footnote ? `<p class="cohort-empty">${escapeHtml(footnote)}</p>` : ""}
+    </article>
+  `;
+}
+
 function renderBreakdown(
   title: string,
   description: string,
   items: StatsBreakdownItem[],
   kind: string,
+  footnote = "",
 ): string {
   const maximum = Math.max(1, ...items.map((item) => item.value));
   return `
@@ -785,6 +1017,7 @@ function renderBreakdown(
           </div>
         `).join("") || "<em>No events in this range yet.</em>"}
       </div>
+      ${footnote ? `<p class="cohort-empty">${escapeHtml(footnote)}</p>` : ""}
     </article>
   `;
 }
@@ -856,18 +1089,6 @@ function renderSkeleton(): string {
   `;
 }
 
-function formatDuration(seconds: number): string {
-  if (!Number.isFinite(seconds) || seconds <= 0) return "0s";
-  if (seconds < 60) return `${Math.round(seconds)}s`;
-  if (seconds < 3_600) return `${Math.round(seconds / 60)}m`;
-  if (seconds < 86_400) return `${numberFormatter.format(seconds / 3_600)}h`;
-  return `${numberFormatter.format(seconds / 86_400)}d`;
-}
-
-function formatPercent(value: number): string {
-  return `${Math.round(Math.max(0, Math.min(1, value)) * 100)}%`;
-}
-
 function formatChartTime(at: number, range: StatsRange): string {
   const date = new Date(at);
   if (range === "24h") return date.toLocaleTimeString([], { hour: "numeric" });
@@ -894,65 +1115,6 @@ function formatDate(at: number): string {
   return new Date(at).toLocaleDateString([], { month: "long", day: "numeric", year: "numeric" });
 }
 
-function humanize(value: string): string {
-  const aliases: Record<string, string> = {
-    cli: "CLI",
-    web: "Web",
-    direct: "Direct",
-    internal: "Internal",
-    hacker_news: "Hacker News",
-    task_exit: "Task exited",
-    disconnected_timeout: "Disconnected timeout",
-    never_started: "Never started",
-    remote_input: "Remote input",
-    cta_click: "Sign-up click",
-    signup_nav: "Sign up free (nav)",
-    signup_hero: "Sign up free (hero)",
-    signup_team: "Manage a team",
-    signup_footer: "Web app (footer)",
-    not_found: "Not found (404)",
-    unknown_path: "Unknown path (served the landing page)",
-    landing: "Landing",
-    docs: "Docs",
-    docs_app: "Docs · Web app",
-    docs_cli: "Docs · CLI",
-    docs_platforms: "Docs · Platforms",
-    docs_mobile: "Docs · Mobile",
-    docs_refstream: "Docs · Refstream",
-    docs_reliability: "Docs · Reliability",
-    docs_security: "Docs · Security",
-    docs_e2ee: "Docs · E2EE",
-    docs_docker: "Docs · Docker",
-    docs_self_hosting: "Docs · Self-hosting",
-    session: "Shared terminal",
-    installer_download: "Installer fetched",
-    binary_download: "Install completed",
-    share_opened: "Opened in a browser",
-    viewer_connected: "Viewer connected",
-    viewer_disconnected: "Viewer disconnected",
-    collaboration_started: "Typed from a browser",
-    session_created: "Session created",
-    session_started: "Session started",
-    session_ended: "Session ended",
-    page_view: "Page view",
-    skill_download: "Skill fetched",
-    stats_view: "Dashboard view",
-    posix: "Install script (POSIX)",
-    powershell: "Install script (PowerShell)",
-    darwin_arm64: "macOS arm64",
-    darwin_amd64: "macOS amd64",
-    linux_arm64: "Linux arm64",
-    linux_amd64: "Linux amd64",
-  };
-  const normalized = value.replace(/-/g, "_");
-  if (aliases[normalized]) return aliases[normalized];
-  return value.replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
-}
-
-function ratio(numerator: number, denominator: number): number {
-  return denominator === 0 ? 0 : Math.min(1, numerator / denominator);
-}
-
 function isClientStatsRange(value: string | undefined): value is StatsRange {
   return STATS_RANGES.includes(value as StatsRange);
 }
diff --git a/worker/analytics.ts b/worker/analytics.ts
index fc7da5a..08e7617 100644
--- a/worker/analytics.ts
+++ b/worker/analytics.ts
@@ -6,6 +6,8 @@ export type AnalyticsEvent =
   | "copy"
   | "cta_click"
   | "installer_download"
+  /** The installer's last word: how it went, from the script itself. */
+  | "install_outcome"
   | "binary_download"
   | "skill_download"
   | "session_created"
@@ -15,6 +17,10 @@ export type AnalyticsEvent =
   | "viewer_disconnected"
   | "collaboration_started"
   | "session_ended"
+  /** A browser opened a link and was turned away: the session was full, expired or never existed. */
+  | "viewer_rejected"
+  /** A viewer tried to type into a read-only session: demand the owner did not allow. Once per viewer. */
+  | "input_denied"
   | "stats_view";
 
 export type DeviceClass = "mobile" | "tablet" | "desktop" | "bot" | "cli" | "unknown";
@@ -53,6 +59,35 @@ export interface AnalyticsRecord {
   auxiliary: number;
 }
 
+/** What the install scripts report at their end. Anything else is not counted. */
+export const INSTALL_OUTCOMES: ReadonlySet<string> = new Set([
+  "ok",
+  "failed",
+  "unsupported_os",
+  "unsupported_arch",
+  "no_home",
+  "install_dir_relative",
+  "install_dir_colon",
+  "install_dir_create",
+  "install_dir_unwritable",
+  "temp_dir",
+  "temp_dir_unwritable",
+  "download_failed",
+  "no_downloader",
+  "manifest_html",
+  "manifest_missing",
+  "manifest_invalid",
+  "no_sha_tool",
+  "checksum_mismatch",
+  "write_failed",
+]);
+
+/** The outcome an install report carries, or null when it is not one the scripts send. */
+export function installReportOutcome(url: URL): string | null {
+  const outcome = url.searchParams.get("outcome") ?? "";
+  return INSTALL_OUTCOMES.has(outcome) ? outcome : null;
+}
+
 /** What the landing page reports when one of its sign-up links is clicked. */
 export const CTA_TARGETS: ReadonlySet<string> = new Set(["signup_nav", "signup_hero", "signup_team", "signup_footer"]);
 
@@ -123,13 +158,52 @@ export function normalizeAnalyticsRecord(
 
 export function requestAnalyticsContext(request: Request): AnalyticsContext {
   const userAgent = request.headers.get("User-Agent") ?? "";
+  const url = new URL(request.url);
+  const referrer = classifyReferrer(request.headers.get("Referer"), url.origin);
+  /* A named campaign beats a referrer the browser hid, and nothing else. */
+  const campaign = campaignSource(url);
   return {
     device: classifyDevice(userAgent, request.headers.get("Sec-CH-UA-Mobile")),
     client: classifyClient(userAgent),
-    referrer: classifyReferrer(request.headers.get("Referer"), new URL(request.url).origin),
+    referrer: campaign !== null && (referrer === "direct" || referrer === "other") ? campaign : referrer,
   };
 }
 
+/**
+ * utm_source or ref on a landing link, folded to the same tokens the referrer
+ * classifier uses, so a launch post still shows as its source when the
+ * browser sent no referrer. Only names on this list count: the dimension has
+ * to stay small, and a stranger's query string is not a source.
+ */
+const CAMPAIGN_SOURCES: Record<string, string> = {
+  hn: "hacker_news",
+  hackernews: "hacker_news",
+  hacker_news: "hacker_news",
+  reddit: "reddit",
+  x: "x",
+  twitter: "x",
+  github: "github",
+  google: "google",
+  newsletter: "newsletter",
+  email: "newsletter",
+  producthunt: "product_hunt",
+  product_hunt: "product_hunt",
+  linkedin: "linkedin",
+  youtube: "youtube",
+  discord: "discord",
+  slack: "slack",
+  mastodon: "mastodon",
+  bluesky: "bluesky",
+  podcast: "podcast",
+};
+
+export function campaignSource(url: URL): string | null {
+  const raw = url.searchParams.get("utm_source") ?? url.searchParams.get("ref");
+  if (!raw) return null;
+  const key = raw.toLowerCase().replace(/[^a-z0-9_]/g, "").slice(0, 40);
+  return CAMPAIGN_SOURCES[key] ?? null;
+}
+
 export function hasVisitorSalt(salt: unknown): salt is string {
   return typeof salt === "string" && salt.length >= MIN_VISITOR_SALT_LENGTH;
 }
@@ -149,12 +223,36 @@ export async function visitorKey(salt: string, address: string, userAgent: strin
   return Array.from(digest.subarray(0, 10), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 
-/** The visitor hash for a request, or nothing when the Worker has no salt or the edge sent no address. */
-export async function requestVisitor(salt: unknown, request: Request): Promise<string | undefined> {
+/**
+ * The hash for a machine: the address alone, under its own label so it can
+ * never collide with a browser's. The installer (curl) and the CLI (shell/x)
+ * on one machine then share a key, and an install can be followed to its
+ * first session. Browsers keep the family in their key: two people behind
+ * one address on different browsers are two visitors, and there is no CLI
+ * to follow them to.
+ */
+export async function machineKey(salt: string, address: string): Promise<string> {
+  const bytes = new TextEncoder().encode(`${salt}\nmachine\n${address}`);
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+  return Array.from(digest.subarray(0, 10), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+/** Who a hash stands for: a person's browser, or a person's machine on the command line. */
+export type VisitorKind = "browser" | "machine";
+
+/**
+ * The visitor hash for a request, or nothing when the Worker has no salt, the
+ * edge sent no address, or the request came from a crawler. A crawler is a
+ * request to count, not a person: it stays in every event total and out of
+ * every people figure, which is what the dashboard says of it.
+ */
+export async function requestVisitor(salt: unknown, request: Request, kind: VisitorKind = "browser"): Promise<string | undefined> {
   if (!hasVisitorSalt(salt)) return undefined;
   const address = request.headers.get("CF-Connecting-IP");
   if (!address) return undefined;
-  return visitorKey(salt, address, request.headers.get("User-Agent") ?? "");
+  const userAgent = request.headers.get("User-Agent") ?? "";
+  if (classifyDevice(userAgent, request.headers.get("Sec-CH-UA-Mobile")) === "bot") return undefined;
+  return kind === "machine" ? machineKey(salt, address) : visitorKey(salt, address, userAgent);
 }
 
 /**
@@ -242,6 +340,8 @@ export function classifyReferrer(referrer: string | null, requestOrigin: string)
     const url = new URL(referrer);
     if (url.origin === requestOrigin) return "internal";
     const hostname = url.hostname.toLowerCase();
+    /* The accounts app is ours: a visit from it is a signed-in person coming back to the docs. */
+    if (hostname === "app.shell.online" || hostname === `app.${new URL(requestOrigin).hostname}`) return "app";
     if (hostname === "news.ycombinator.com") return "hacker_news";
     if (hostname === "github.com" || hostname.endsWith(".github.com")) return "github";
     if (hostname === "reddit.com" || hostname.endsWith(".reddit.com")) return "reddit";
diff --git a/worker/index.ts b/worker/index.ts
index 7c53680..249fce1 100644
--- a/worker/index.ts
+++ b/worker/index.ts
@@ -5,9 +5,11 @@ import {
   isDocumentNavigation,
   requestAnalyticsContext,
   requestVisitor,
+  type VisitorKind,
   hasVisitorSalt,
   documentTarget,
   CTA_TARGETS,
+  installReportOutcome,
   COPY_TARGETS,
   writeAnalytics,
   type AnalyticsContext,
@@ -135,6 +137,10 @@ interface SocketAttachment {
   terminalCols?: number;
   terminalRows?: number;
   portrait?: boolean;
+  /** When the socket was accepted, so a disconnect can say how long the viewer stayed. */
+  connectedAt?: number;
+  /** Set once a viewer has been refused input, so the refusal is counted once per viewer. */
+  inputDeniedAt?: number;
   supportsPortraitGrid?: boolean;
 }
 
@@ -227,6 +233,10 @@ export default {
       return recordEvent(request, env, url, executionContext);
     }
 
+    if (url.pathname === "/install/report" && request.method === "GET") {
+      return recordInstallReport(request, env, url, executionContext);
+    }
+
     if (url.pathname === "/skill" || url.pathname === "/skill/") {
       if (request.method !== "GET") {
         return new Response("Method not allowed", {
@@ -500,13 +510,15 @@ async function fetchAccountStats(env: Env, range: StatsRange): Promise<StatsAcco
     });
     if (!response.ok) return { error: `accounts app answered ${response.status}` };
     const body = await response.json<unknown>();
-    return isAccountStats(body) ? body : { error: "accounts app answered in an unexpected shape" };
+    if (!isAccountStats(body)) return { error: "accounts app answered in an unexpected shape" };
+    /* An older app answers without events; the dashboard then shows none rather than nothing. */
+    return { ...body, events: isCountRecord(body.events) ? body.events : {} };
   } catch {
     return { error: "accounts app did not answer" };
   }
 }
 
-function isAccountStats(value: unknown): value is StatsAccountStats {
+function isAccountStats(value: unknown): value is Omit<StatsAccountStats, "events"> & { events?: unknown } {
   if (typeof value !== "object" || value === null) return false;
   const candidate = value as Record<string, unknown>;
   return typeof candidate.total === "number" &&
@@ -516,6 +528,11 @@ function isAccountStats(value: unknown): value is StatsAccountStats {
     Array.isArray(candidate.cohorts);
 }
 
+function isCountRecord(value: unknown): value is Record<string, number> {
+  return typeof value === "object" && value !== null && !Array.isArray(value) &&
+    Object.values(value as Record<string, unknown>).every((count) => typeof count === "number");
+}
+
 function statsPassword(env: Env): string | null {
   return typeof env.STATS_PASSWORD === "string" && env.STATS_PASSWORD.length >= 12
     ? env.STATS_PASSWORD
@@ -547,9 +564,9 @@ async function recordAssetAnalytics(
   if (request.method !== "GET") return;
 
   const context = requestAnalyticsContext(request);
-  const withVisitor = async (): Promise<AnalyticsContext> => ({
+  const withVisitor = async (kind: VisitorKind = "browser"): Promise<AnalyticsContext> => ({
     ...context,
-    visitor: await requestVisitor(env.STATS_VISITOR_SALT, request),
+    visitor: await requestVisitor(env.STATS_VISITOR_SALT, request, kind),
   });
 
   if (!response.ok) {
@@ -562,7 +579,7 @@ async function recordAssetAnalytics(
 
   if (url.pathname === "/install" || url.pathname === "/install.ps1") {
     const target = url.pathname === "/install.ps1" ? "powershell" : "posix";
-    recordAnalytics(env, executionContext, "installer_download", target, await withVisitor());
+    recordAnalytics(env, executionContext, "installer_download", target, await withVisitor("machine"));
     return;
   }
   if (url.pathname === "/skill" || url.pathname === "/skill/") {
@@ -572,7 +589,7 @@ async function recordAssetAnalytics(
 
   const binaryTarget = binaryDownloadTarget(url.pathname);
   if (binaryTarget) {
-    recordAnalytics(env, executionContext, "binary_download", binaryTarget, await withVisitor());
+    recordAnalytics(env, executionContext, "binary_download", binaryTarget, await withVisitor("machine"));
     return;
   }
 
@@ -637,6 +654,35 @@ async function recordEvent(
   });
 }
 
+/*
+ * The installer's last word: one request with a single outcome code, sent
+ * when the script finishes or fails unless the person set
+ * SHELL_ONLINE_INSTALL_REPORT=0. Only codes the scripts can send count; any
+ * other request gets the same empty answer and records nothing.
+ */
+async function recordInstallReport(
+  request: Request,
+  env: Env,
+  url: URL,
+  executionContext: ExecutionContext,
+): Promise<Response> {
+  const ip = request.headers.get("CF-Connecting-IP") ?? "unknown";
+  const allowed = await env.EVENT_LIMITER.limit({ key: ip });
+  if (!allowed.success) {
+    return json({ error: "too many events" }, 429, { "Retry-After": "60" });
+  }
+  const outcome = installReportOutcome(url);
+  const context = requestAnalyticsContext(request);
+  /* A crawler that follows the report link did not install anything. */
+  if (outcome !== null && context.device !== "bot") {
+    recordAnalytics(env, executionContext, "install_outcome", outcome, context);
+  }
+  return new Response(null, {
+    status: 204,
+    headers: { "Cache-Control": "no-store" },
+  });
+}
+
 async function createSession(
   request: Request,
   env: Env,
@@ -706,7 +752,7 @@ async function createSession(
     executionContext,
     "session_created",
     "cli",
-    { ...requestAnalyticsContext(request), visitor: await requestVisitor(env.STATS_VISITOR_SALT, request) },
+    { ...requestAnalyticsContext(request), visitor: await requestVisitor(env.STATS_VISITOR_SALT, request, "machine") },
   );
 
   const origin = requestOrigin(request, url);
@@ -776,7 +822,7 @@ async function resumeSession(
   if (resumeResult.created === true) {
     recordAnalytics(env, executionContext, "session_created", "persistent_cli", {
       ...requestAnalyticsContext(request),
-      visitor: await requestVisitor(env.STATS_VISITOR_SALT, request),
+      visitor: await requestVisitor(env.STATS_VISITOR_SALT, request, "machine"),
     });
   }
   const origin = requestOrigin(request, url);
@@ -911,9 +957,19 @@ export class TerminalSession extends DurableObject<Env> {
   }
 
   private async acceptSocket(request: Request): Promise<Response> {
-    if (this.meta === undefined) return json({ error: "session not found" }, 404);
+    /*
+     * A browser that opens a dead link is a person the funnel would otherwise
+     * never see: it is counted as turned away, by reason. The host presents a
+     * token, a viewer does not, which is enough to tell them apart here.
+     */
+    const isViewer = request.headers.get("Authorization") === null;
+    if (this.meta === undefined) {
+      if (isViewer) recordAnalytics(this.env, this.state, "viewer_rejected", "not_found", requestAnalyticsContext(request));
+      return json({ error: "session not found" }, 404);
+    }
     if (Date.now() >= this.meta.expiresAt) {
       await this.expire();
+      if (isViewer) recordAnalytics(this.env, this.state, "viewer_rejected", "expired", requestAnalyticsContext(request));
       return json({ error: "session expired" }, 410);
     }
 
@@ -933,6 +989,7 @@ export class TerminalSession extends DurableObject<Env> {
       : 0;
     const admission = viewerAdmission(activeViewerCount);
     if (role === "viewer" && !admission.accepted) {
+      recordAnalytics(this.env, this.state, "viewer_rejected", "session_full", requestAnalyticsContext(request));
       // Browser WebSockets hide an upgrade rejection's status and body. Finish
       // the upgrade, then close with a code the viewer can explain and retry.
       const pair = new WebSocketPair();
@@ -972,6 +1029,7 @@ export class TerminalSession extends DurableObject<Env> {
       referrer: analyticsContext.referrer,
       portrait: role === "viewer" && new URL(request.url).searchParams.get("layout") === "portrait",
       supportsPortraitGrid: role === "host" && request.headers.get("X-Shell-Terminal-Grid") === "80x40",
+      connectedAt: Date.now(),
     };
 
     server.serializeAttachment(attachment);
@@ -1008,7 +1066,16 @@ export class TerminalSession extends DurableObject<Env> {
       await this.persistMeta();
       recordAnalytics(this.env, this.state, "viewer_connected", "viewer", viewerContext);
       if (firstShareOpen) {
-        recordAnalytics(this.env, this.state, "share_opened", "viewer", viewerContext);
+        /*
+         * The first open says two things worth keeping: whether anyone can
+         * type here, and how long the link waited. A read-only session is
+         * its own target so the typed rate is over sessions that allow it.
+         */
+        recordAnalytics(this.env, this.state, "share_opened", this.isReadOnly() ? "viewer_read_only" : "viewer", {
+          ...viewerContext,
+          /* From this run's start, as session lifetimes are measured, so a resumed session does not count its idle days. */
+          value: Math.max(0, (Date.now() - (this.meta.runStartedAt ?? this.meta.createdAt)) / 1_000),
+        });
       }
       await this.refreshLivePresence(true);
       await this.scheduleNextAlarm();
@@ -1258,6 +1325,16 @@ export class TerminalSession extends DurableObject<Env> {
     const action = viewerFrameAction(frame[0], this.isReadOnly());
     if (action === "blocked-input") {
       sendJson(socket, { type: "access_denied", reason: "read_only" });
+      /* Once per viewer: the first refusal is the signal, the rest are the same person retrying. */
+      if (attachment.inputDeniedAt === undefined) {
+        attachment.inputDeniedAt = Date.now();
+        socket.serializeAttachment(attachment);
+        recordAnalytics(this.env, this.state, "input_denied", "read_only", {
+          device: attachment.device,
+          client: attachment.client,
+          referrer: attachment.referrer,
+        });
+      }
       return;
     }
 
@@ -1360,6 +1437,8 @@ export class TerminalSession extends DurableObject<Env> {
         device: attachment.device,
         client: attachment.client,
         referrer: attachment.referrer,
+        /* Seconds connected; absent on sockets accepted before this was recorded. */
+        value: attachment.connectedAt === undefined ? 0 : Math.max(0, (Date.now() - attachment.connectedAt) / 1_000),
       });
       await this.refreshLivePresence(true, socket);
       await this.scheduleNextAlarm();
@@ -1523,6 +1602,8 @@ export class TerminalSession extends DurableObject<Env> {
       device: attachment.device,
       client: attachment.client,
       referrer: "internal",
+      /* Seconds from the first open to the first keystroke. */
+      value: Math.max(0, (this.meta.collaborationStartedAt - (this.meta.shareOpenedAt ?? this.meta.createdAt)) / 1_000),
     });
     const meta = { ...this.meta };
     this.state.waitUntil(this.state.storage.put("meta", meta));
diff --git a/worker/stats-database.ts b/worker/stats-database.ts
new file mode 100644
index 0000000..2611e80
--- /dev/null
+++ b/worker/stats-database.ts
@@ -0,0 +1,458 @@
+import {
+  INSTALL_CONVERSION_DAYS,
+  RETENTION_WEEKS,
+  VISITOR_MEMORY_DAYS,
+  type StatsRange,
+} from "../shared/stats";
+import {
+  DAY_MS,
+  dayStart,
+  STATS_PRESENCE_LEASE_MS,
+  statsRangeStart,
+  WEEK_MS,
+  weekStart,
+  type AudienceRow,
+  type BreakdownRow,
+  type InstallConversionRow,
+  type LivePresenceRow,
+  type MetricSummaryRow,
+  type MetricTrendRow,
+  type PeriodUniqueRow,
+  type PreviousPeriodRows,
+  type RetentionRow,
+  type StatsSnapshotRows,
+  type UniqueDayRow,
+  type UniqueSummaryRow,
+} from "../shared/stats-snapshot";
+import { uniqueSurface, type AnalyticsEvent, type AnalyticsRecord } from "./analytics";
+
+export const HOUR_MS = 60 * 60 * 1_000;
+
+/*
+ * Everything the dashboard's Durable Object does with its database, written
+ * over the two cursor methods it needs, so the same code runs against any
+ * SQLite: the object's own storage in production, node:sqlite in the tests.
+ * The object itself only parses requests and hands them here.
+ */
+export interface StatsSqlCursor<T> {
+  toArray(): T[];
+  /** The single row, or a throw when there is not exactly one. */
+  one(): T;
+}
+
+export interface StatsSql {
+  exec<T extends Record<string, unknown> = Record<string, unknown>>(query: string, ...bindings: unknown[]): StatsSqlCursor<T>;
+}
+
+export type StatsEventRecord = AnalyticsRecord & { at: number; visitor?: string };
+
+export interface StatsPresence {
+  key: string;
+  activeSessions: number;
+  activeViewers: number;
+}
+
+export interface CollectedStatsRows {
+  rows: StatsSnapshotRows;
+  rangeStart: number;
+}
+
+export const ANALYTICS_EVENTS = new Set<AnalyticsEvent>([
+  "page_view",
+  "copy",
+  "cta_click",
+  "installer_download",
+  "install_outcome",
+  "binary_download",
+  "skill_download",
+  "session_created",
+  "session_started",
+  "share_opened",
+  "viewer_connected",
+  "viewer_disconnected",
+  "collaboration_started",
+  "session_ended",
+  "viewer_rejected",
+  "input_denied",
+  "stats_view",
+]);
+
+/** How far an event's own clock may differ from the store's before it is refused. */
+const MAX_EVENT_SKEW_MS = 10 * 60 * 1_000;
+
+interface MinimumRow extends Record<string, unknown> {
+  minimum: number | null;
+}
+
+export function initializeStatsSchema(sql: StatsSql): void {
+  sql.exec(`
+    CREATE TABLE IF NOT EXISTS metric_hourly (
+      bucket INTEGER NOT NULL,
+      event TEXT NOT NULL,
+      target TEXT NOT NULL,
+      device TEXT NOT NULL,
+      client TEXT NOT NULL,
+      referrer TEXT NOT NULL,
+      count INTEGER NOT NULL DEFAULT 0,
+      value_sum REAL NOT NULL DEFAULT 0,
+      value_max REAL NOT NULL DEFAULT 0,
+      auxiliary_sum REAL NOT NULL DEFAULT 0,
+      auxiliary_max REAL NOT NULL DEFAULT 0,
+      PRIMARY KEY (bucket, event, target, device, client, referrer)
+    )
+  `);
+  sql.exec("CREATE INDEX IF NOT EXISTS metric_hourly_event_bucket ON metric_hourly(event, bucket)");
+  sql.exec(`
+    CREATE TABLE IF NOT EXISTS live_presence (
+      presence_key TEXT PRIMARY KEY,
+      active_sessions INTEGER NOT NULL,
+      active_viewers INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL
+    )
+  `);
+  sql.exec("CREATE INDEX IF NOT EXISTS live_presence_expiry ON live_presence(expires_at)");
+  /*
+   * Who was seen, as keyed hashes only: one row per person per day per
+   * surface, and one row per person with their first and last day. Both are
+   * forgotten VISITOR_MEMORY_DAYS after the person was last seen, so "new"
+   * means "not seen in that long" and nothing older than that is kept.
+   */
+  sql.exec(`
+    CREATE TABLE IF NOT EXISTS visitor_days (
+      surface TEXT NOT NULL,
+      visitor TEXT NOT NULL,
+      day INTEGER NOT NULL,
+      PRIMARY KEY (surface, visitor, day)
+    )
+  `);
+  sql.exec("CREATE INDEX IF NOT EXISTS visitor_days_day ON visitor_days(day)");
+  sql.exec(`
+    CREATE TABLE IF NOT EXISTS visitors (
+      surface TEXT NOT NULL,
+      visitor TEXT NOT NULL,
+      first_day INTEGER NOT NULL,
+      last_day INTEGER NOT NULL,
+      PRIMARY KEY (surface, visitor)
+    )
+  `);
+  sql.exec("CREATE INDEX IF NOT EXISTS visitors_last_day ON visitors(last_day)");
+}
+
+/** One event into its hour bucket, and its person into the day's visitors when it has one. */
+export function recordStatsEvent(sql: StatsSql, record: StatsEventRecord): void {
+  const bucket = Math.floor(record.at / HOUR_MS) * HOUR_MS;
+  sql.exec(
+    `INSERT INTO metric_hourly (
+      bucket, event, target, device, client, referrer,
+      count, value_sum, value_max, auxiliary_sum, auxiliary_max
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT (bucket, event, target, device, client, referrer) DO UPDATE SET
+      count = metric_hourly.count + excluded.count,
+      value_sum = metric_hourly.value_sum + excluded.value_sum,
+      value_max = MAX(metric_hourly.value_max, excluded.value_max),
+      auxiliary_sum = metric_hourly.auxiliary_sum + excluded.auxiliary_sum,
+      auxiliary_max = MAX(metric_hourly.auxiliary_max, excluded.auxiliary_max)`,
+    bucket,
+    record.event,
+    record.target,
+    record.device,
+    record.client,
+    record.referrer,
+    record.count,
+    record.value,
+    record.value,
+    record.auxiliary,
+    record.auxiliary,
+  );
+  const surface = record.visitor ? uniqueSurface(record.event, record.target) : null;
+  if (!surface || !record.visitor) return;
+  const day = dayStart(record.at);
+  sql.exec(
+    "INSERT OR IGNORE INTO visitor_days (surface, visitor, day) VALUES (?, ?, ?)",
+    surface,
+    record.visitor,
+    day,
+  );
+  sql.exec(
+    `INSERT INTO visitors (surface, visitor, first_day, last_day) VALUES (?, ?, ?, ?)
+    ON CONFLICT (surface, visitor) DO UPDATE SET
+      first_day = MIN(visitors.first_day, excluded.first_day),
+      last_day = MAX(visitors.last_day, excluded.last_day)`,
+    surface,
+    record.visitor,
+    day,
+    day,
+  );
+}
+
+/** A session object's lease on "live": renewed while it has sockets, dropped when it has none. */
+export function writeStatsPresence(sql: StatsSql, presence: StatsPresence, now = Date.now()): void {
+  if (presence.activeSessions === 0 && presence.activeViewers === 0) {
+    clearStatsPresence(sql, presence.key);
+    return;
+  }
+  sql.exec(
+    `INSERT INTO live_presence (
+      presence_key, active_sessions, active_viewers, expires_at
+    ) VALUES (?, ?, ?, ?)
+    ON CONFLICT (presence_key) DO UPDATE SET
+      active_sessions = excluded.active_sessions,
+      active_viewers = excluded.active_viewers,
+      expires_at = excluded.expires_at`,
+    presence.key,
+    presence.activeSessions,
+    presence.activeViewers,
+    now + STATS_PRESENCE_LEASE_MS,
+  );
+}
+
+export function clearStatsPresence(sql: StatsSql, key: string): void {
+  sql.exec("DELETE FROM live_presence WHERE presence_key = ?", key);
+}
+
+/**
+ * Everything a snapshot is built from, for one range. Expired leases and
+ * people past the memory window are dropped first, so what is counted is
+ * exactly what is kept.
+ */
+export function collectStatsRows(
+  sql: StatsSql,
+  range: StatsRange,
+  uniquesConfigured: boolean,
+  now = Date.now(),
+): CollectedStatsRows {
+  sql.exec("DELETE FROM live_presence WHERE expires_at <= ?", now);
+  const forgetBefore = dayStart(now) - VISITOR_MEMORY_DAYS * DAY_MS;
+  sql.exec("DELETE FROM visitor_days WHERE day < ?", forgetBefore);
+  sql.exec("DELETE FROM visitors WHERE last_day < ?", forgetBefore);
+  const collectingSince = sql.exec<MinimumRow>("SELECT MIN(bucket) AS minimum FROM metric_hourly").one().minimum;
+  /* Taken after the purge, so it is the earliest day people can still be counted from. */
+  const uniquesSince = sql.exec<MinimumRow>("SELECT MIN(day) AS minimum FROM visitor_days").one().minimum;
+  const rangeStart = statsRangeStart(range, now, collectingSince);
+  /* Buckets are hours and events at most ten minutes ahead of this clock, so nothing sits past tomorrow. */
+  const rangeEnd = now + DAY_MS;
+  const summary = metricSummary(sql, rangeStart, rangeEnd);
+  const byDevice = audienceRows(sql, rangeStart, rangeEnd);
+  /*
+   * The period of equal length before the range, for comparison. People are
+   * counted by day, so its days are the whole days before the range's first
+   * day. The all-time range has nothing before it.
+   */
+  let previous: PreviousPeriodRows | null = null;
+  if (range !== "all") {
+    const previousStart = rangeStart - (now - rangeStart);
+    previous = {
+      rangeStart: previousStart,
+      summary: metricSummary(sql, previousStart, rangeStart),
+      byDevice: audienceRows(sql, previousStart, rangeStart),
+      uniques: sql.exec<PeriodUniqueRow>(
+        `SELECT surface, COUNT(DISTINCT visitor) AS unique_count
+        FROM visitor_days
+        WHERE day >= ? AND day < ?
+        GROUP BY surface`,
+        dayStart(previousStart),
+        dayStart(rangeStart),
+      ).toArray(),
+    };
+  }
+  const trend = sql.exec<MetricTrendRow>(
+    `SELECT bucket, event, SUM(count) AS count
+    FROM metric_hourly
+    WHERE bucket >= ?
+      AND event IN ('session_created', 'share_opened', 'collaboration_started', 'page_view')
+    GROUP BY bucket, event
+    ORDER BY bucket`,
+    rangeStart,
+  ).toArray();
+  const live = sql.exec<LivePresenceRow>(
+    `SELECT
+      COALESCE(SUM(active_sessions), 0) AS active_sessions,
+      COALESCE(SUM(active_viewers), 0) AS active_viewers
+    FROM live_presence`,
+  ).one();
+  /*
+   * People are counted by day, so a range that starts mid-day includes the
+   * whole of that day: a day is the finest grain the visitor tables keep.
+   */
+  const uniqueStart = dayStart(rangeStart);
+  const uniques = sql.exec<UniqueSummaryRow>(
+    `SELECT seen.surface AS surface,
+      COUNT(*) AS unique_count,
+      SUM(CASE WHEN visitors.first_day >= ? THEN 1 ELSE 0 END) AS new_count
+    FROM (SELECT DISTINCT surface, visitor FROM visitor_days WHERE day >= ?) AS seen
+    JOIN visitors ON visitors.surface = seen.surface AND visitors.visitor = seen.visitor
+    GROUP BY seen.surface`,
+    uniqueStart,
+    uniqueStart,
+  ).toArray();
+  const uniqueDays = sql.exec<UniqueDayRow>(
+    `SELECT day, surface, COUNT(*) AS unique_count
+    FROM visitor_days
+    WHERE day >= ?
+    GROUP BY day, surface
+    ORDER BY day, surface`,
+    uniqueStart,
+  ).toArray();
+  /*
+   * Installers followed to their first session. Both surfaces key a machine
+   * by address, so the join is on the hash. A machine counts as matured once
+   * its window has fully elapsed, so a fresh install is not a miss, and a
+   * machine whose sessions predate the install already had the CLI.
+   */
+  const conversionWindow = INSTALL_CONVERSION_DAYS * DAY_MS;
+  const installConversion = uniquesConfigured
+    ? sql.exec<InstallConversionRow>(
+      `SELECT COUNT(*) AS installers,
+        SUM(CASE WHEN installs.first_day <= ? THEN 1 ELSE 0 END) AS matured,
+        SUM(CASE WHEN installs.first_day <= ?
+          AND cli.first_day IS NOT NULL
+          AND cli.first_day >= installs.first_day
+          AND cli.first_day < installs.first_day + ? THEN 1 ELSE 0 END) AS started
+      FROM visitors AS installs
+      LEFT JOIN visitors AS cli ON cli.surface = 'cli' AND cli.visitor = installs.visitor
+      WHERE installs.surface = 'install' AND installs.first_day >= ?`,
+      dayStart(now) - conversionWindow,
+      dayStart(now) - conversionWindow,
+      conversionWindow,
+      uniqueStart,
+    ).one()
+    : null;
+  const retention = sql.exec<RetentionRow>(
+    `SELECT visitors.surface AS surface, visitors.visitor AS visitor,
+      visitors.first_day AS first_day, visitor_days.day AS day
+    FROM visitors
+    JOIN visitor_days ON visitor_days.surface = visitors.surface AND visitor_days.visitor = visitors.visitor
+    WHERE visitors.first_day >= ? AND visitors.surface IN ('site', 'cli')`,
+    weekStart(now) - (RETENTION_WEEKS - 1) * WEEK_MS,
+  ).toArray();
+
+  return {
+    rangeStart,
+    rows: {
+      summary,
+      byDevice,
+      previous,
+      trend,
+      devices: dimensionBreakdown(sql, "device", rangeStart, "page_view"),
+      referrers: dimensionBreakdown(sql, "referrer", rangeStart, "page_view"),
+      clients: dimensionBreakdown(sql, "client", rangeStart, "session_created"),
+      openedDevices: dimensionBreakdown(sql, "device", rangeStart, "share_opened"),
+      typedDevices: dimensionBreakdown(sql, "device", rangeStart, "collaboration_started"),
+      live,
+      collectingSince,
+      uniques,
+      uniqueDays,
+      retention,
+      installConversion,
+      uniquesConfigured,
+      uniquesSince,
+    },
+  };
+}
+
+function metricSummary(sql: StatsSql, from: number, to: number): MetricSummaryRow[] {
+  return sql.exec<MetricSummaryRow>(
+    `SELECT event, target,
+      SUM(count) AS count,
+      SUM(value_sum) AS value_sum,
+      MAX(value_max) AS value_max,
+      SUM(auxiliary_sum) AS auxiliary_sum,
+      MAX(auxiliary_max) AS auxiliary_max
+    FROM metric_hourly
+    WHERE bucket >= ? AND bucket < ?
+    GROUP BY event, target
+    ORDER BY count DESC, event, target`,
+    from,
+    to,
+  ).toArray();
+}
+
+/** Who made the requests: the same totals, split by device class, for the events the page tells apart. */
+function audienceRows(sql: StatsSql, from: number, to: number): AudienceRow[] {
+  return sql.exec<AudienceRow>(
+    `SELECT event, target, device, SUM(count) AS count
+    FROM metric_hourly
+    WHERE bucket >= ? AND bucket < ?
+      AND event IN ('page_view', 'installer_download', 'binary_download', 'viewer_connected')
+    GROUP BY event, target, device
+    ORDER BY event, target, device`,
+    from,
+    to,
+  ).toArray();
+}
+
+function dimensionBreakdown(
+  sql: StatsSql,
+  dimension: "device" | "client" | "referrer",
+  rangeStart: number,
+  event: AnalyticsEvent,
+): BreakdownRow[] {
+  return sql.exec<BreakdownRow>(
+    `SELECT ${dimension} AS name, SUM(count) AS count
+    FROM metric_hourly
+    WHERE bucket >= ? AND event = ?
+    GROUP BY ${dimension}
+    ORDER BY count DESC, name
+    LIMIT 12`,
+    rangeStart,
+    event,
+  ).toArray();
+}
+
+/** A record as the Worker sends it, or null for anything else: a stranger's shape, a stale clock, a bad hash. */
+export function parseStatsRecord(candidate: unknown, now = Date.now()): StatsEventRecord | null {
+  if (typeof candidate !== "object" || candidate === null) return null;
+  const value = candidate as Record<string, unknown>;
+  if (
+    typeof value.event !== "string" ||
+    !ANALYTICS_EVENTS.has(value.event as AnalyticsEvent) ||
+    !isDimension(value.target) ||
+    !isDimension(value.device) ||
+    !isDimension(value.client) ||
+    !isDimension(value.referrer) ||
+    value.count !== 1 ||
+    !Number.isFinite(value.value) ||
+    !Number.isFinite(value.auxiliary) ||
+    !Number.isFinite(value.at)
+  ) return null;
+  const at = Number(value.at);
+  if (Math.abs(now - at) > MAX_EVENT_SKEW_MS) return null;
+  if (value.visitor !== undefined && (typeof value.visitor !== "string" || !/^[a-f0-9]{20}$/.test(value.visitor))) {
+    return null;
+  }
+  return {
+    ...(typeof value.visitor === "string" ? { visitor: value.visitor } : {}),
+    event: value.event as AnalyticsEvent,
+    target: value.target,
+    device: value.device as AnalyticsRecord["device"],
+    client: value.client,
+    referrer: value.referrer,
+    count: 1,
+    value: Number(value.value),
+    auxiliary: Number(value.auxiliary),
+    at,
+  };
+}
+
+export function parseStatsPresence(candidate: unknown, keyOnly = false): StatsPresence | null {
+  if (typeof candidate !== "object" || candidate === null) return null;
+  const value = candidate as Record<string, unknown>;
+  if (typeof value.key !== "string" || !/^[A-Za-z0-9_-]{22}$/.test(value.key)) return null;
+  if (keyOnly) return { key: value.key, activeSessions: 0, activeViewers: 0 };
+  if (
+    !Number.isInteger(value.activeSessions) ||
+    (value.activeSessions !== 0 && value.activeSessions !== 1) ||
+    !Number.isInteger(value.activeViewers) ||
+    Number(value.activeViewers) < 0 ||
+    Number(value.activeViewers) > 16
+  ) return null;
+  return {
+    key: value.key,
+    activeSessions: Number(value.activeSessions),
+    activeViewers: Number(value.activeViewers),
+  };
+}
+
+function isDimension(value: unknown): value is string {
+  return typeof value === "string" && /^[a-z0-9._:/-]{1,64}$/.test(value);
+}
diff --git a/worker/stats-store.test.ts b/worker/stats-store.test.ts
index 628d83d..3c84b6a 100644
--- a/worker/stats-store.test.ts
+++ b/worker/stats-store.test.ts
@@ -1,8 +1,13 @@
 import { describe, expect, it } from "vitest";
 import {
+  audienceOf,
+  buildAudiences,
   buildRetentionCohorts,
   buildStatsSnapshot,
   DAY_MS,
+  dayStart,
+  installsCompleted,
+  peopleCountedSince,
   STATS_PRESENCE_LEASE_MS,
   STATS_PRESENCE_REFRESH_MS,
   WEEK_MS,
@@ -23,12 +28,18 @@ describe("statistics live presence", () => {
       devices: [],
       referrers: [],
       clients: [],
+      openedDevices: [],
+      typedDevices: [],
       live: { active_sessions: 1, active_viewers: 3 },
       collectingSince,
+      byDevice: [],
+      previous: null,
       uniques: [],
       uniqueDays: [],
       retention: [],
+      installConversion: null,
       uniquesConfigured: false,
+      uniquesSince: null,
     }, "all", now, collectingSince);
 
     expect(snapshot.metrics).toMatchObject({
@@ -50,12 +61,18 @@ describe("statistics live presence", () => {
       devices: [],
       referrers: [],
       clients: [],
+      openedDevices: [],
+      typedDevices: [],
       live: { active_sessions: 0, active_viewers: 0 },
       collectingSince: now - 60_000,
+      byDevice: [],
+      previous: null,
       uniques: [],
       uniqueDays: [],
       retention: [],
+      installConversion: null,
       uniquesConfigured: false,
+      uniquesSince: null,
     }, "24h", now, now - 24 * 60 * 60 * 1_000);
 
     expect(snapshot.metrics.activeSessions).toBe(0);
@@ -79,13 +96,44 @@ describe("people and the funnel", () => {
       metric("binary_download", "darwin-arm64", 4),
       metric("session_created", "cli", 48),
       metric("session_started", "cli", 48),
-      metric("share_opened", "viewer", 6),
-      metric("collaboration_started", "remote_input", 5),
+      metric("share_opened", "viewer", 5, 100),
+      metric("share_opened", "viewer_read_only", 1, 20),
+      metric("collaboration_started", "remote_input", 5, 50),
+      metric("viewer_disconnected", "viewer", 12, 3_600),
+      metric("viewer_rejected", "session_full", 2),
+      metric("viewer_rejected", "expired", 3),
+      metric("input_denied", "read_only", 1),
+      metric("install_outcome", "ok", 3),
+      metric("install_outcome", "checksum_mismatch", 1),
+      metric("copy", "install", 20),
+      metric("copy", "brew_install", 5),
+      metric("copy", "share", 3),
+      metric("session_ended", "never_started", 4),
+      metric("session_ended", "task_exit", 40, 1_200),
     ],
+    /* The same totals by who made the requests; each event's rows add up to its summary row. */
+    byDevice: [
+      audience("page_view", "landing", "desktop", 700),
+      audience("page_view", "landing", "mobile", 60),
+      audience("page_view", "landing", "bot", 200),
+      audience("page_view", "landing", "cli", 9),
+      audience("page_view", "docs_app", "desktop", 30),
+      audience("page_view", "docs", "bot", 18),
+      audience("page_view", "unknown_path", "bot", 57),
+      audience("installer_download", "posix", "cli", 50),
+      audience("installer_download", "posix", "desktop", 4),
+      audience("installer_download", "posix", "bot", 8),
+      audience("binary_download", "darwin-arm64", "cli", 3),
+      audience("binary_download", "darwin-arm64", "bot", 1),
+      audience("viewer_connected", "viewer", "desktop", 12),
+    ],
+    previous: null,
     trend: [],
     devices: [],
     referrers: [],
     clients: [],
+    openedDevices: [{ name: "desktop", count: 4 }, { name: "mobile", count: 2 }],
+    typedDevices: [{ name: "desktop", count: 4 }, { name: "mobile", count: 1 }],
     live: { active_sessions: 0, active_viewers: 0 },
     collectingSince: now - 30 * DAY_MS,
     uniques: [
@@ -100,7 +148,9 @@ describe("people and the funnel", () => {
       { day: now - DAY_MS, surface: "site", unique_count: 140 },
     ],
     retention: [],
+    installConversion: { installers: 12, matured: 9, started: 4 },
     uniquesConfigured: true,
+    uniquesSince: dayStart(now - 20 * DAY_MS),
   };
 
   it("keeps docs, unknown paths and 404s apart and counts people beside events", () => {
@@ -121,27 +171,182 @@ describe("people and the funnel", () => {
     expect(snapshot.breakdowns.pages.map((page) => page.label)).toEqual(["landing", "unknown_path", "docs_app", "docs", "not_found"]);
   });
 
-  it("lays the funnel out from a first look to a first keystroke", () => {
+  it("folds device classes into audiences, and counts only the events the page tells apart", () => {
+    expect(["desktop", "mobile", "tablet"].map(audienceOf)).toEqual(["browsers", "browsers", "browsers"]);
+    expect(audienceOf("cli")).toBe("tools");
+    expect(audienceOf("bot")).toBe("crawlers");
+    expect(audienceOf("unknown")).toBe("unknown");
+    expect(audienceOf("something-new")).toBe("unknown");
+    expect(installsCompleted({ browsers: 1, tools: 2, crawlers: 5, unknown: 1 })).toBe(4);
+    const audiences = buildAudiences([
+      { event: "session_created", target: "cli", device: "cli", count: 9 },
+      { event: "page_view", target: "not_found", device: "bot", count: 3 },
+      { event: "page_view", target: "session", device: "mobile", count: 2 },
+      { event: "viewer_connected", target: "viewer", device: "mobile", count: 2 },
+    ]);
+    expect(audiences.views).toEqual({ browsers: 0, tools: 0, crawlers: 0, unknown: 0 });
+    expect(audiences.viewers).toEqual({ browsers: 2, tools: 0, crawlers: 0, unknown: 0 });
+  });
+
+  it("tells browsers, tools and crawlers apart in every figure about people", () => {
+    const snapshot = buildStatsSnapshot(rows, "7d", now, rangeStart);
+    expect(snapshot.audiences.views).toEqual({ browsers: 790, tools: 9, crawlers: 218, unknown: 0 });
+    expect(snapshot.audiences.installer).toEqual({ browsers: 4, tools: 50, crawlers: 8, unknown: 0 });
+    expect(snapshot.audiences.installs).toEqual({ browsers: 0, tools: 3, crawlers: 1, unknown: 0 });
+    expect(snapshot.figures).toEqual({
+      siteViews: 790,
+      crawlerViews: 218,
+      ctaClicks: 12,
+      installCopies: 25,
+      installerRuns: 50,
+      installs: 3,
+      sessionsStarted: 48,
+      neverStarted: 4,
+      sharesOpened: 6,
+      sharesOpenedWritable: 5,
+      collaborations: 5,
+    });
+    /* The raw totals are untouched: the ledger still shows every request. */
+    expect(snapshot.metrics.landingViews + snapshot.metrics.docsViews).toBe(1017);
+    expect(snapshot.metrics.installs).toBe(62);
+  });
+
+  /*
+   * The funnel counts what a person is plausibly behind, and lists beside
+   * each step what it left out, so 969 landing views do not read as 969
+   * visitors and 62 installer fetches do not read as 62 installs attempted.
+   */
+  it("lays the funnel out from a first look to a first keystroke, crawlers beside it", () => {
     const snapshot = buildStatsSnapshot(rows, "7d", now, rangeStart);
     expect(snapshot.funnel.map((step) => [step.key, step.count, step.unique])).toEqual([
-      ["visited", 1017, 400],
+      ["visited", 790, 400],
       ["signup", 12, null],
-      ["installer", 62, 40],
-      ["installed", 4, null],
+      ["copied", 25, null],
+      ["installer", 50, 40],
+      ["installed", 3, null],
       ["session", 48, 9],
       ["opened", 6, 5],
       ["typed", 5, null],
     ]);
+    expect(snapshot.funnel.map((step) => step.excluded)).toEqual([
+      [{ label: "by crawlers", count: 218 }, { label: "by tools", count: 9 }],
+      [],
+      [],
+      [{ label: "read in a browser", count: 4 }, { label: "by crawlers", count: 8 }],
+      [{ label: "by crawlers", count: 1 }],
+      [{ label: "created but never connected", count: 4 }],
+      [],
+      [{ label: "opened read-only, typing impossible", count: 1 }],
+    ]);
     for (const step of snapshot.funnel) expect(step.note.length).toBeGreaterThan(20);
-    expect(snapshot.funnel.map((step) => step.basis)).toEqual([null, "visited", "visited", "installer", null, "session", "opened"]);
+    expect(snapshot.funnel.map((step) => step.basis)).toEqual([null, "visited", "visited", "visited", "installer", null, "session", "opened"]);
+  });
+
+  it("keeps what happens after a link is opened: waits, stays, refusals, and read-only sessions apart", () => {
+    const snapshot = buildStatsSnapshot(rows, "7d", now, rangeStart);
+    expect(snapshot.metrics).toMatchObject({
+      sharesOpened: 6,
+      sharesOpenedReadOnly: 1,
+      viewersRejected: 5,
+      inputDenied: 1,
+      averageSecondsToOpen: 20,
+      averageSecondsToType: 10,
+      averageViewerSeconds: 300,
+    });
+    const typed = snapshot.funnel.find((step) => step.key === "typed");
+    expect(typed).toMatchObject({ basis: "opened", basisCount: 5, basisLabel: "opened sessions that allow typing" });
+    expect(typed?.excluded).toEqual([{ label: "opened read-only, typing impossible", count: 1 }]);
+    expect(snapshot.breakdowns.rejections).toEqual([{ label: "expired", value: 3 }, { label: "session_full", value: 2 }]);
+    expect(snapshot.metrics).toMatchObject({ installsReported: 3, installFailuresReported: 1 });
+    expect(snapshot.breakdowns.installOutcomes).toEqual([{ label: "ok", value: 3 }, { label: "checksum_mismatch", value: 1 }]);
+    expect(snapshot.breakdowns.openedDevices).toEqual([{ label: "desktop", value: 4 }, { label: "mobile", value: 2 }]);
+    expect(snapshot.breakdowns.typedDevices).toEqual([{ label: "desktop", value: 4 }, { label: "mobile", value: 1 }]);
+  });
+
+  it("compares with the period before, when there is one worth comparing with", () => {
+    const previous = {
+      rangeStart: rangeStart - 7 * DAY_MS,
+      summary: [
+        metric("cta_click", "signup_hero", 6),
+        metric("session_started", "cli", 40),
+        metric("share_opened", "viewer", 4),
+        metric("collaboration_started", "remote_input", 2),
+      ],
+      byDevice: [
+        audience("page_view", "landing", "desktop", 500),
+        audience("page_view", "landing", "bot", 300),
+        audience("installer_download", "posix", "cli", 40),
+        audience("binary_download", "darwin-arm64", "cli", 2),
+      ],
+      uniques: [{ surface: "site", unique_count: 300 }, { surface: "cli", unique_count: 8 }],
+    };
+    const snapshot = buildStatsSnapshot({ ...rows, previous }, "7d", now, rangeStart);
+    expect(snapshot.previous).toEqual({
+      rangeStart: rangeStart - 7 * DAY_MS,
+      rangeEnd: rangeStart,
+      figures: {
+        siteViews: 500,
+        crawlerViews: 300,
+        ctaClicks: 6,
+        installCopies: 0,
+        installerRuns: 40,
+        installs: 2,
+        sessionsStarted: 40,
+        neverStarted: 0,
+        sharesOpened: 4,
+        sharesOpenedWritable: 4,
+        collaborations: 2,
+      },
+      people: { site: 300, cli: 8, viewer: 0, install: 0 },
+    });
+
+    /* People counted from inside the previous period: figures compare, people do not. */
+    const late = buildStatsSnapshot({ ...rows, previous, uniquesSince: dayStart(now - 10 * DAY_MS) }, "7d", now, rangeStart);
+    expect(late.previous?.figures.siteViews).toBe(500);
+    expect(late.previous?.people).toBeNull();
+
+    /* Collection began inside the previous period: an empty comparison would say everything doubled. */
+    expect(buildStatsSnapshot({ ...rows, previous, collectingSince: now - 10 * DAY_MS }, "7d", now, rangeStart).previous).toBeNull();
+    expect(buildStatsSnapshot({ ...rows, previous: null }, "all", now, now - 30 * DAY_MS).previous).toBeNull();
+  });
+
+  it("follows machines from the installer to a first session", () => {
+    const snapshot = buildStatsSnapshot(rows, "7d", now, rangeStart);
+    expect(snapshot.installConversion).toEqual({ installers: 12, matured: 9, started: 4 });
+    const empty = buildStatsSnapshot({ ...rows, installConversion: { installers: 0, matured: null, started: null } }, "7d", now, rangeStart);
+    expect(empty.installConversion).toEqual({ installers: 0, matured: 0, started: 0 });
   });
 
   it("says when nobody is being counted", () => {
     const snapshot = buildStatsSnapshot({ ...rows, uniques: [], uniquesConfigured: false }, "7d", now, rangeStart);
     expect(snapshot.uniques.configured).toBe(false);
+    expect(snapshot.uniques.since).toBeNull();
+    expect(snapshot.installConversion).toBeNull();
     expect(snapshot.funnel[0].unique).toBeNull();
     expect(snapshot.uniques.surfaces.site).toEqual({ unique: 0, new: 0, returning: 0 });
   });
+
+  /*
+   * The salt was set on the 14th and the dashboard opened on the 15th, on the
+   * 30-day range: thirty days of views beside one day of people. The snapshot
+   * has to carry the day people start from, and say when it is inside the
+   * range, or the funnel reads as 29,333 views from 84 people.
+   */
+  it("says since when people have been counted, and whether that is inside the range", () => {
+    const covered = buildStatsSnapshot(rows, "7d", now, rangeStart);
+    expect(covered.uniques.since).toBe(dayStart(now - 20 * DAY_MS));
+    expect(peopleCountedSince(covered.uniques, covered.rangeStart)).toBeNull();
+
+    const yesterday = dayStart(now - DAY_MS);
+    const partial = buildStatsSnapshot({ ...rows, uniquesSince: yesterday }, "30d", now, now - 30 * DAY_MS);
+    expect(partial.uniques.since).toBe(yesterday);
+    expect(peopleCountedSince(partial.uniques, partial.rangeStart)).toBe(yesterday);
+
+    /* People are kept by day, so a range that starts inside their first day is covered. */
+    expect(peopleCountedSince({ configured: true, since: dayStart(rangeStart) }, rangeStart + 60_000)).toBeNull();
+    expect(peopleCountedSince({ configured: false, since: yesterday }, now - 30 * DAY_MS)).toBeNull();
+    expect(peopleCountedSince({ configured: true, since: null }, now - 30 * DAY_MS)).toBeNull();
+  });
 });
 
 describe("retention cohorts", () => {
@@ -182,6 +387,15 @@ describe("retention cohorts", () => {
   });
 });
 
+function audience(
+  event: string,
+  target: string,
+  device: string,
+  count: number,
+): Record<string, string | number | null> & { event: string; target: string; device: string; count: number } {
+  return { event, target, device, count };
+}
+
 function metric(
   event: string,
   target: string,
diff --git a/worker/stats-store.ts b/worker/stats-store.ts
index a5f68cd..5e71526 100644
--- a/worker/stats-store.ts
+++ b/worker/stats-store.ts
@@ -1,56 +1,20 @@
 import { DurableObject } from "cloudflare:workers";
+import { isStatsRange, type StatsRange } from "../shared/stats";
+import { buildStatsSnapshot } from "../shared/stats-snapshot";
+import { normalizeAnalyticsRecord, type AnalyticsContext, type AnalyticsEvent } from "./analytics";
 import {
-  RETENTION_WEEKS,
-  VISITOR_MEMORY_DAYS,
-  isStatsRange,
-  type StatsRange,
-} from "../shared/stats";
-import {
-  buildStatsSnapshot,
-  DAY_MS,
-  dayStart,
-  STATS_PRESENCE_LEASE_MS,
-  statsRangeStart,
-  WEEK_MS,
-  weekStart,
-  type BreakdownRow,
-  type LivePresenceRow,
-  type MetricSummaryRow,
-  type MetricTrendRow,
-  type RetentionRow,
-  type UniqueDayRow,
-  type UniqueSummaryRow,
-} from "../shared/stats-snapshot";
-import {
-  normalizeAnalyticsRecord,
-  uniqueSurface,
-  type AnalyticsContext,
-  type AnalyticsEvent,
-  type AnalyticsRecord,
-} from "./analytics";
+  clearStatsPresence,
+  collectStatsRows,
+  initializeStatsSchema,
+  parseStatsPresence,
+  parseStatsRecord,
+  recordStatsEvent,
+  writeStatsPresence,
+  type StatsSql,
+  type StatsSqlCursor,
+} from "./stats-database";
 
-const HOUR_MS = 60 * 60 * 1_000;
 const STATS_OBJECT_NAME = "shell-online-global-stats";
-const ANALYTICS_EVENTS = new Set<AnalyticsEvent>([
-  "page_view",
-  "copy",
-  "cta_click",
-  "installer_download",
-  "binary_download",
-  "skill_download",
-  "session_created",
-  "session_started",
-  "share_opened",
-  "viewer_connected",
-  "viewer_disconnected",
-  "collaboration_started",
-  "session_ended",
-  "stats_view",
-]);
-
-interface MinimumRow extends Record<string, string | number | null> {
-  minimum: number | null;
-}
 
 export async function submitStatsEvent(
   namespace: DurableObjectNamespace<StatsStore>,
@@ -124,69 +88,27 @@ export async function removeStatsPresence(
   }
 }
 
+/*
+ * The Durable Object: one per deployment, holding the dashboard's database.
+ * It parses what the Worker and the session objects send and hands the SQL
+ * to stats-database, which is where the counting lives and is tested.
+ */
 export class StatsStore extends DurableObject<Record<string, never>> {
-  private readonly sql: SqlStorage;
+  private readonly sql: StatsSql;
 
   constructor(state: DurableObjectState, env: Record<string, never>) {
     super(state, env);
-    this.sql = state.storage.sql;
-    this.sql.exec(`
-      CREATE TABLE IF NOT EXISTS metric_hourly (
-        bucket INTEGER NOT NULL,
-        event TEXT NOT NULL,
-        target TEXT NOT NULL,
-        device TEXT NOT NULL,
-        client TEXT NOT NULL,
-        referrer TEXT NOT NULL,
-        count INTEGER NOT NULL DEFAULT 0,
-        value_sum REAL NOT NULL DEFAULT 0,
-        value_max REAL NOT NULL DEFAULT 0,
-        auxiliary_sum REAL NOT NULL DEFAULT 0,
-        auxiliary_max REAL NOT NULL DEFAULT 0,
-        PRIMARY KEY (bucket, event, target, device, client, referrer)
-      )
-    `);
-    this.sql.exec("CREATE INDEX IF NOT EXISTS metric_hourly_event_bucket ON metric_hourly(event, bucket)");
-    this.sql.exec(`
-      CREATE TABLE IF NOT EXISTS live_presence (
-        presence_key TEXT PRIMARY KEY,
-        active_sessions INTEGER NOT NULL,
-        active_viewers INTEGER NOT NULL,
-        expires_at INTEGER NOT NULL
-      )
-    `);
-    this.sql.exec("CREATE INDEX IF NOT EXISTS live_presence_expiry ON live_presence(expires_at)");
-    /*
-     * Who was seen, as keyed hashes only: one row per person per day per
-     * surface, and one row per person with their first and last day. Both are
-     * forgotten VISITOR_MEMORY_DAYS after the person was last seen, so "new"
-     * means "not seen in that long" and nothing older than that is kept.
-     */
-    this.sql.exec(`
-      CREATE TABLE IF NOT EXISTS visitor_days (
-        surface TEXT NOT NULL,
-        visitor TEXT NOT NULL,
-        day INTEGER NOT NULL,
-        PRIMARY KEY (surface, visitor, day)
-      )
-    `);
-    this.sql.exec("CREATE INDEX IF NOT EXISTS visitor_days_day ON visitor_days(day)");
-    this.sql.exec(`
-      CREATE TABLE IF NOT EXISTS visitors (
-        surface TEXT NOT NULL,
-        visitor TEXT NOT NULL,
-        first_day INTEGER NOT NULL,
-        last_day INTEGER NOT NULL,
-        PRIMARY KEY (surface, visitor)
-      )
-    `);
-    this.sql.exec("CREATE INDEX IF NOT EXISTS visitors_last_day ON visitors(last_day)");
+    this.sql = durableSql(state.storage.sql);
+    initializeStatsSchema(this.sql);
   }
 
   async fetch(request: Request): Promise<Response> {
     const url = new URL(request.url);
     if (url.pathname === "/internal/record" && request.method === "POST") {
-      return this.record(request);
+      const record = parseStatsRecord(await readJson(request));
+      if (!record) return statsJson({ error: "invalid event" }, 400);
+      recordStatsEvent(this.sql, record);
+      return new Response(null, { status: 204 });
     }
     if (url.pathname === "/internal/stats" && request.method === "GET") {
       const requestedRange = url.searchParams.get("range");
@@ -196,280 +118,45 @@ export class StatsStore extends DurableObject<Record<string, never>> {
       );
     }
     if (url.pathname === "/internal/presence" && request.method === "POST") {
-      return this.updatePresence(request);
+      const presence = parseStatsPresence(await readJson(request));
+      if (!presence) return statsJson({ error: "invalid presence" }, 400);
+      writeStatsPresence(this.sql, presence);
+      return new Response(null, { status: 204 });
     }
     if (url.pathname === "/internal/presence/remove" && request.method === "POST") {
-      return this.removePresence(request);
-    }
-    return statsJson({ error: "not found" }, 404);
-  }
-
-  private async updatePresence(request: Request): Promise<Response> {
-    const presence = await parsePresenceRequest(request);
-    if (!presence) return statsJson({ error: "invalid presence" }, 400);
-    if (presence.activeSessions === 0 && presence.activeViewers === 0) {
-      this.sql.exec("DELETE FROM live_presence WHERE presence_key = ?", presence.key);
+      const presence = parseStatsPresence(await readJson(request), true);
+      if (!presence) return statsJson({ error: "invalid presence" }, 400);
+      clearStatsPresence(this.sql, presence.key);
       return new Response(null, { status: 204 });
     }
-    this.sql.exec(
-      `INSERT INTO live_presence (
-        presence_key, active_sessions, active_viewers, expires_at
-      ) VALUES (?, ?, ?, ?)
-      ON CONFLICT (presence_key) DO UPDATE SET
-        active_sessions = excluded.active_sessions,
-        active_viewers = excluded.active_viewers,
-        expires_at = excluded.expires_at`,
-      presence.key,
-      presence.activeSessions,
-      presence.activeViewers,
-      Date.now() + STATS_PRESENCE_LEASE_MS,
-    );
-    return new Response(null, { status: 204 });
-  }
-
-  private async removePresence(request: Request): Promise<Response> {
-    const presence = await parsePresenceRequest(request, true);
-    if (!presence) return statsJson({ error: "invalid presence" }, 400);
-    this.sql.exec("DELETE FROM live_presence WHERE presence_key = ?", presence.key);
-    return new Response(null, { status: 204 });
-  }
-
-  private async record(request: Request): Promise<Response> {
-    let candidate: unknown;
-    try {
-      candidate = await request.json();
-    } catch {
-      return statsJson({ error: "invalid event" }, 400);
-    }
-    const record = parseStatsRecord(candidate);
-    if (!record) return statsJson({ error: "invalid event" }, 400);
-
-    const bucket = Math.floor(record.at / HOUR_MS) * HOUR_MS;
-    this.sql.exec(
-      `INSERT INTO metric_hourly (
-        bucket, event, target, device, client, referrer,
-        count, value_sum, value_max, auxiliary_sum, auxiliary_max
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT (bucket, event, target, device, client, referrer) DO UPDATE SET
-        count = metric_hourly.count + excluded.count,
-        value_sum = metric_hourly.value_sum + excluded.value_sum,
-        value_max = MAX(metric_hourly.value_max, excluded.value_max),
-        auxiliary_sum = metric_hourly.auxiliary_sum + excluded.auxiliary_sum,
-        auxiliary_max = MAX(metric_hourly.auxiliary_max, excluded.auxiliary_max)`,
-      bucket,
-      record.event,
-      record.target,
-      record.device,
-      record.client,
-      record.referrer,
-      record.count,
-      record.value,
-      record.value,
-      record.auxiliary,
-      record.auxiliary,
-    );
-    const surface = record.visitor ? uniqueSurface(record.event, record.target) : null;
-    if (surface && record.visitor) {
-      const day = dayStart(record.at);
-      this.sql.exec(
-        "INSERT OR IGNORE INTO visitor_days (surface, visitor, day) VALUES (?, ?, ?)",
-        surface,
-        record.visitor,
-        day,
-      );
-      this.sql.exec(
-        `INSERT INTO visitors (surface, visitor, first_day, last_day) VALUES (?, ?, ?, ?)
-        ON CONFLICT (surface, visitor) DO UPDATE SET
-          first_day = MIN(visitors.first_day, excluded.first_day),
-          last_day = MAX(visitors.last_day, excluded.last_day)`,
-        surface,
-        record.visitor,
-        day,
-        day,
-      );
-    }
-    return new Response(null, { status: 204 });
+    return statsJson({ error: "not found" }, 404);
   }
 
   private snapshot(range: StatsRange, uniquesConfigured: boolean): Response {
     const now = Date.now();
-    this.sql.exec("DELETE FROM live_presence WHERE expires_at <= ?", now);
-    const forgetBefore = dayStart(now) - VISITOR_MEMORY_DAYS * DAY_MS;
-    this.sql.exec("DELETE FROM visitor_days WHERE day < ?", forgetBefore);
-    this.sql.exec("DELETE FROM visitors WHERE last_day < ?", forgetBefore);
-    const collectingSince = this.sql.exec<MinimumRow>(
-      "SELECT MIN(bucket) AS minimum FROM metric_hourly",
-    ).one().minimum;
-    const rangeStart = statsRangeStart(range, now, collectingSince);
-    const summary = this.sql.exec<MetricSummaryRow>(
-      `SELECT event, target,
-        SUM(count) AS count,
-        SUM(value_sum) AS value_sum,
-        MAX(value_max) AS value_max,
-        SUM(auxiliary_sum) AS auxiliary_sum,
-        MAX(auxiliary_max) AS auxiliary_max
-      FROM metric_hourly
-      WHERE bucket >= ?
-      GROUP BY event, target
-      ORDER BY count DESC, event, target`,
-      rangeStart,
-    ).toArray();
-    const trend = this.sql.exec<MetricTrendRow>(
-      `SELECT bucket, event, SUM(count) AS count
-      FROM metric_hourly
-      WHERE bucket >= ?
-        AND event IN ('session_created', 'share_opened', 'collaboration_started', 'page_view')
-      GROUP BY bucket, event
-      ORDER BY bucket`,
-      rangeStart,
-    ).toArray();
-    const devices = this.dimensionBreakdown("device", rangeStart, "page_view");
-    const referrers = this.dimensionBreakdown("referrer", rangeStart, "page_view");
-    const clients = this.dimensionBreakdown("client", rangeStart, "session_created");
-    const live = this.sql.exec<LivePresenceRow>(
-      `SELECT
-        COALESCE(SUM(active_sessions), 0) AS active_sessions,
-        COALESCE(SUM(active_viewers), 0) AS active_viewers
-      FROM live_presence`,
-    ).one();
-    /*
-     * People are counted by day, so a range that starts mid-day includes the
-     * whole of that day: a day is the finest grain the visitor tables keep.
-     */
-    const uniqueStart = dayStart(rangeStart);
-    const uniques = this.sql.exec<UniqueSummaryRow>(
-      `SELECT seen.surface AS surface,
-        COUNT(*) AS unique_count,
-        SUM(CASE WHEN visitors.first_day >= ? THEN 1 ELSE 0 END) AS new_count
-      FROM (SELECT DISTINCT surface, visitor FROM visitor_days WHERE day >= ?) AS seen
-      JOIN visitors ON visitors.surface = seen.surface AND visitors.visitor = seen.visitor
-      GROUP BY seen.surface`,
-      uniqueStart,
-      uniqueStart,
-    ).toArray();
-    const uniqueDays = this.sql.exec<UniqueDayRow>(
-      `SELECT day, surface, COUNT(*) AS unique_count
-      FROM visitor_days
-      WHERE day >= ?
-      GROUP BY day, surface
-      ORDER BY day`,
-      uniqueStart,
-    ).toArray();
-    const retention = this.sql.exec<RetentionRow>(
-      `SELECT visitors.surface AS surface, visitors.visitor AS visitor,
-        visitors.first_day AS first_day, visitor_days.day AS day
-      FROM visitors
-      JOIN visitor_days ON visitor_days.surface = visitors.surface AND visitor_days.visitor = visitors.visitor
-      WHERE visitors.first_day >= ? AND visitors.surface IN ('site', 'cli')`,
-      weekStart(now) - (RETENTION_WEEKS - 1) * WEEK_MS,
-    ).toArray();
-
-    const snapshot = buildStatsSnapshot(
-      {
-        summary,
-        trend,
-        devices,
-        referrers,
-        clients,
-        live,
-        collectingSince,
-        uniques,
-        uniqueDays,
-        retention,
-        uniquesConfigured,
-      },
-      range,
-      now,
-      rangeStart,
-    );
-    return statsJson(snapshot, 200, {
+    const { rows, rangeStart } = collectStatsRows(this.sql, range, uniquesConfigured, now);
+    return statsJson(buildStatsSnapshot(rows, range, now, rangeStart), 200, {
       "Cache-Control": "private, no-store",
       "X-Robots-Tag": "noindex, nofollow, noarchive",
     });
   }
-
-  private dimensionBreakdown(
-    dimension: "device" | "client" | "referrer",
-    rangeStart: number,
-    event: AnalyticsEvent,
-  ): BreakdownRow[] {
-    return this.sql.exec<BreakdownRow>(
-      `SELECT ${dimension} AS name, SUM(count) AS count
-      FROM metric_hourly
-      WHERE bucket >= ? AND event = ?
-      GROUP BY ${dimension}
-      ORDER BY count DESC
-      LIMIT 12`,
-      rangeStart,
-      event,
-    ).toArray();
-  }
 }
 
-async function parsePresenceRequest(
-  request: Request,
-  keyOnly = false,
-): Promise<{ key: string; activeSessions: number; activeViewers: number } | null> {
-  let candidate: unknown;
-  try {
-    candidate = await request.json();
-  } catch {
-    return null;
-  }
-  if (typeof candidate !== "object" || candidate === null) return null;
-  const value = candidate as Record<string, unknown>;
-  if (typeof value.key !== "string" || !/^[A-Za-z0-9_-]{22}$/.test(value.key)) return null;
-  if (keyOnly) return { key: value.key, activeSessions: 0, activeViewers: 0 };
-  if (
-    !Number.isInteger(value.activeSessions) ||
-    (value.activeSessions !== 0 && value.activeSessions !== 1) ||
-    !Number.isInteger(value.activeViewers) ||
-    Number(value.activeViewers) < 0 ||
-    Number(value.activeViewers) > 16
-  ) return null;
+/** The object's SqlStorage behind the two cursor methods the database code uses. */
+function durableSql(storage: SqlStorage): StatsSql {
   return {
-    key: value.key,
-    activeSessions: Number(value.activeSessions),
-    activeViewers: Number(value.activeViewers),
+    exec<T extends Record<string, unknown>>(query: string, ...bindings: unknown[]): StatsSqlCursor<T> {
+      return storage.exec(query, ...bindings) as unknown as StatsSqlCursor<T>;
+    },
   };
 }
 
-function parseStatsRecord(candidate: unknown): (AnalyticsRecord & { at: number; visitor?: string }) | null {
-  if (typeof candidate !== "object" || candidate === null) return null;
-  const value = candidate as Record<string, unknown>;
-  if (
-    typeof value.event !== "string" ||
-    !ANALYTICS_EVENTS.has(value.event as AnalyticsEvent) ||
-    !isDimension(value.target) ||
-    !isDimension(value.device) ||
-    !isDimension(value.client) ||
-    !isDimension(value.referrer) ||
-    value.count !== 1 ||
-    !Number.isFinite(value.value) ||
-    !Number.isFinite(value.auxiliary) ||
-    !Number.isFinite(value.at)
-  ) return null;
-  const at = Number(value.at);
-  if (Math.abs(Date.now() - at) > 10 * 60 * 1_000) return null;
-  if (value.visitor !== undefined && (typeof value.visitor !== "string" || !/^[a-f0-9]{20}$/.test(value.visitor))) {
-    return null;
+async function readJson(request: Request): Promise<unknown> {
+  try {
+    return await request.json();
+  } catch {
+    return undefined;
   }
-  return {
-    ...(typeof value.visitor === "string" ? { visitor: value.visitor } : {}),
-    event: value.event as AnalyticsEvent,
-    target: value.target,
-    device: value.device as AnalyticsRecord["device"],
-    client: value.client,
-    referrer: value.referrer,
-    count: 1,
-    value: Number(value.value),
-    auxiliary: Number(value.auxiliary),
-    at,
-  };
-}
-
-function isDimension(value: unknown): value is string {
-  return typeof value === "string" && /^[a-z0-9._:/-]{1,64}$/.test(value);
 }
 
 function statsJson(
diff --git a/wrangler.example.jsonc b/wrangler.example.jsonc
index ec7d185..32087c6 100644
--- a/wrangler.example.jsonc
+++ b/wrangler.example.jsonc
@@ -14,6 +14,7 @@
       "/downloads/*",
       "/install",
       "/install.ps1",
+      "/install/report",
       "/llms.txt",
       "/skill",
       "/skill/*",