diff --git a/.gitignore b/.gitignore
index 2b4ad1f6..bf4acb90 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,3 +47,4 @@ sessions/
 html/
 .superset/
 .github/hooks/
+.superpowers/
diff --git a/frontend/e2e/activity-minimap.spec.ts b/frontend/e2e/activity-minimap.spec.ts
new file mode 100644
index 00000000..503d38bb
--- /dev/null
+++ b/frontend/e2e/activity-minimap.spec.ts
@@ -0,0 +1,126 @@
+import { test, expect } from "@playwright/test";
+import { SessionsPage } from "./pages/sessions-page";
+
+test.describe("Activity Minimap", () => {
+  let sp: SessionsPage;
+
+  test.beforeEach(async ({ page }) => {
+    sp = new SessionsPage(page);
+    await sp.goto();
+    await sp.selectSession(0);
+  });
+
+  test("minimap is hidden by default", async ({
+    page,
+  }) => {
+    await expect(
+      page.locator(".activity-minimap"),
+    ).not.toBeVisible();
+  });
+
+  test("toggle button shows and hides minimap", async ({
+    page,
+  }) => {
+    await page.locator(".minimap-btn").click();
+    await expect(
+      page.locator(".activity-minimap"),
+    ).toBeVisible();
+
+    await page.locator(".minimap-btn").click();
+    await expect(
+      page.locator(".activity-minimap"),
+    ).not.toBeVisible();
+  });
+
+  test("minimap shows bars for sessions with timestamps", async ({
+    page,
+  }) => {
+    await page.locator(".minimap-btn").click();
+
+    await expect(
+      page.locator(".minimap-status"),
+    ).not.toBeVisible({ timeout: 3000 });
+
+    const bars = page.locator(".minimap-bar");
+    const count = await bars.count();
+    expect(count).toBeGreaterThan(0);
+  });
+
+  test("clicking a bar scrolls the message list", async ({
+    page,
+  }) => {
+    await page.locator(".minimap-btn").click();
+
+    const clickableBars = page.locator(
+      "g.minimap-bar[role='button']",
+    );
+    await clickableBars.first().waitFor({ timeout: 3000 });
+
+    const barCount = await clickableBars.count();
+    expect(barCount).toBeGreaterThan(0);
+
+    const scrollBefore = await sp.scroller.evaluate(
+      (el) => el.scrollTop,
+    );
+
+    const lastBar = clickableBars.nth(barCount - 1);
+    await lastBar.click();
+
+    if (barCount > 1) {
+      await expect
+        .poll(
+          () =>
+            sp.scroller.evaluate((el) => el.scrollTop),
+          { timeout: 3000 },
+        )
+        .not.toBe(scrollBefore);
+    }
+  });
+
+  test("active indicator moves after reopen without scroll", async ({
+    page,
+  }) => {
+    // Open minimap, wait for multiple bars.
+    await page.locator(".minimap-btn").click();
+    const bars = page.locator("g.minimap-bar[role='button']");
+    await bars.first().waitFor({ timeout: 3000 });
+
+    const barCount = await bars.count();
+    if (barCount < 2) {
+      // Can't test indicator movement with < 2 bars.
+      return;
+    }
+
+    // Record the x position of the active indicator.
+    const indicator = page.locator(".bar-indicator");
+    await expect(indicator).toBeVisible();
+    const xBefore = await indicator.evaluate(
+      (el) => el.getAttribute("x"),
+    );
+
+    // Close minimap, scroll to the bottom.
+    await page.locator(".minimap-btn").click();
+    await expect(
+      page.locator(".activity-minimap"),
+    ).not.toBeVisible();
+
+    await sp.scroller.evaluate((el) => {
+      el.scrollTop = el.scrollHeight;
+    });
+
+    // Reopen — indicator should appear at a different
+    // position reflecting the new scroll location.
+    await page.locator(".minimap-btn").click();
+    await expect(indicator).toBeVisible({ timeout: 3000 });
+
+    await expect
+      .poll(
+        () =>
+          indicator.evaluate(
+            (el) => el.getAttribute("x"),
+          ),
+        { timeout: 3000 },
+      )
+      .not.toBe(xBefore);
+  });
+});
diff --git a/frontend/src/App.svelte b/frontend/src/App.svelte
index 1f2aa660..9c0f208e 100644
--- a/frontend/src/App.svelte
+++ b/frontend/src/App.svelte
@@ -6,6 +6,8 @@
   import StatusBar from "./lib/components/layout/StatusBar.svelte";
   import SessionList from "./lib/components/sidebar/SessionList.svelte";
   import MessageList from "./lib/components/content/MessageList.svelte";
+  import ActivityMinimap from "./lib/components/content/ActivityMinimap.svelte";
+  import { sessionActivity } from "./lib/stores/sessionActivity.svelte.js";
   import CommandPalette from "./lib/components/command-palette/CommandPalette.svelte";
   import AboutModal from "./lib/components/modals/AboutModal.svelte";
   import ShortcutsModal from "./lib/components/modals/ShortcutsModal.svelte";
@@ -84,9 +86,15 @@
           messages.reload();
           sessions.refreshActiveSession();
           sessions.loadChildSessions(id);
+          if (ui.activityMinimapOpen) {
+            sessionActivity.reload(id);
+          } else {
+            sessionActivity.invalidate();
+          }
         });
         pins.loadForSession(id);
       } else {
+        sessionActivity.clear();
         messages.clear();
         sessions.childSessions = new Map();
         sync.unwatchSession();
@@ -380,6 +388,11 @@
           session={session}
           onBack={() => sessions.deselectSession()}
         />
+        {#if ui.activityMinimapOpen && sessions.activeSessionId}
+          <ActivityMinimap
+            sessionId={sessions.activeSessionId}
+          />
+        {/if}
         <MessageList bind:this={messageListRef} />
       {:else}
         <AnalyticsPage />
diff --git a/frontend/src/lib/api/client.ts b/frontend/src/lib/api/client.ts
index a58b11c6..bdb01c50 100644
--- a/frontend/src/lib/api/client.ts
+++ b/frontend/src/lib/api/client.ts
@@ -2,7 +2,6 @@ import type {
   SessionPage,
   Session,
   MessagesResponse,
-  MinimapResponse,
   SearchResponse,
   ProjectsResponse,
   MachinesResponse,
@@ -34,6 +33,7 @@ import type {
   PinsResponse,
   TrashResponse,
 } from "./types.js";
+import type { SessionActivityResponse } from "./types/session-activity.js";
 
 const SERVER_URL_KEY = "agentsview-server-url";
 const AUTH_TOKEN_KEY = "agentsview-auth-token";
@@ -171,6 +171,14 @@ export function getChildSessions(
   return fetchJSON(`/sessions/${id}/children`, init);
 }
 
+export function getSessionActivity(
+  sessionId: string,
+): Promise<SessionActivityResponse> {
+  return fetchJSON(
+    `/sessions/${sessionId}/activity`,
+  );
+}
+
 /* Messages */
 
 export interface GetMessagesParams {
@@ -190,20 +198,6 @@ export function getMessages(
   );
 }
 
-export interface GetMinimapParams {
-  from?: number;
-  max?: number;
-}
-
-export function getMinimap(
-  sessionId: string,
-  params: GetMinimapParams = {},
-): Promise<MinimapResponse> {
-  return fetchJSON(
-    `/sessions/${sessionId}/minimap${buildQuery({ ...params })}`,
-  );
-}
-
 /* Search */
 
 export function search(
diff --git a/frontend/src/lib/api/types/core.ts b/frontend/src/lib/api/types/core.ts
index 2cb1cc13..5018db56 100644
--- a/frontend/src/lib/api/types/core.ts
+++ b/frontend/src/lib/api/types/core.ts
@@ -72,12 +72,6 @@ export interface Message {
   is_system: boolean;
 }
 
-/** Matches Go MinimapEntry struct */
-export type MinimapEntry = Pick<
-  Message,
-  "ordinal" | "role" | "content_length" | "has_thinking" | "has_tool_use"
->;
-
 /** Matches Go SearchResult struct in internal/db/search.go */
 export interface SearchResult {
   session_id: string;
@@ -104,11 +98,6 @@ export interface MessagesResponse {
   count: number;
 }
 
-export interface MinimapResponse {
-  entries: MinimapEntry[];
-  count: number;
-}
-
 export interface SearchResponse {
   query: string;
   results: SearchResult[];
diff --git a/frontend/src/lib/api/types/index.ts b/frontend/src/lib/api/types/index.ts
index e32c84dd..5e4f1f46 100644
--- a/frontend/src/lib/api/types/index.ts
+++ b/frontend/src/lib/api/types/index.ts
@@ -3,3 +3,4 @@ export type * from "./sync.js";
 export type * from "./analytics.js";
 export type * from "./github.js";
 export type * from "./insights.js";
+export type * from "./session-activity.js";
diff --git a/frontend/src/lib/api/types/session-activity.ts b/frontend/src/lib/api/types/session-activity.ts
new file mode 100644
index 00000000..4632dde2
--- /dev/null
+++ b/frontend/src/lib/api/types/session-activity.ts
@@ -0,0 +1,13 @@
+export interface SessionActivityBucket {
+  start_time: string;
+  end_time: string;
+  user_count: number;
+  assistant_count: number;
+  first_ordinal: number | null;
+}
+
+export interface SessionActivityResponse {
+  buckets: SessionActivityBucket[];
+  interval_seconds: number;
+  total_messages: number;
+}
diff --git a/frontend/src/lib/components/content/ActivityMinimap.svelte b/frontend/src/lib/components/content/ActivityMinimap.svelte
new file mode 100644
index 00000000..5e2c12e9
--- /dev/null
+++ b/frontend/src/lib/components/content/ActivityMinimap.svelte
@@ -0,0 +1,347 @@
+<script lang="ts">
+  import { sessionActivity } from "../../stores/sessionActivity.svelte.js";
+  import { ui } from "../../stores/ui.svelte.js";
+  import type { SessionActivityBucket } from "../../api/types/session-activity.js";
+
+  const BAR_HEIGHT = 48;
+  const BAR_GAP = 2;
+  const MIN_BAR_WIDTH = 4;
+
+  interface Props {
+    sessionId: string;
+  }
+
+  let { sessionId }: Props = $props();
+
+  let containerRef = $state<HTMLDivElement | null>(null);
+  let containerWidth = $state(300);
+
+  $effect(() => {
+    void sessionActivity.load(sessionId);
+  });
+
+  $effect(() => {
+    if (!containerRef) return;
+    const obs = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        containerWidth = entry.contentRect.width;
+      }
+    });
+    obs.observe(containerRef);
+    return () => obs.disconnect();
+  });
+
+  const chart = $derived.by(() => {
+    const buckets = sessionActivity.buckets;
+    if (buckets.length === 0) return null;
+
+    const n = buckets.length;
+    const barWidth = Math.max(
+      MIN_BAR_WIDTH,
+      Math.floor((containerWidth - n * BAR_GAP) / n),
+    );
+
+    let maxCount = 0;
+    for (const b of buckets) {
+      const total = b.user_count + b.assistant_count;
+      if (total > maxCount) maxCount = total;
+    }
+    if (maxCount === 0) maxCount = 1;
+
+    const bars = buckets.map((bucket, i) => {
+      const total =
+        bucket.user_count + bucket.assistant_count;
+      const height = (total / maxCount) * BAR_HEIGHT;
+      return {
+        x: i * (barWidth + BAR_GAP),
+        height,
+        width: barWidth,
+        populated: total > 0,
+        bucket,
+        index: i,
+      };
+    });
+
+    const svgWidth =
+      bars.length > 0
+        ? bars[bars.length - 1]!.x + barWidth
+        : containerWidth;
+
+    return { bars, svgWidth };
+  });
+
+  let tooltip = $state<{
+    x: number;
+    y: number;
+    text: string;
+  } | null>(null);
+
+  function handleBarHover(
+    e: MouseEvent,
+    bar: NonNullable<typeof chart>["bars"][number],
+  ) {
+    if (!bar.populated) return;
+    const rect = (
+      e.currentTarget as SVGElement
+    ).getBoundingClientRect();
+    const range =
+      formatTime(bar.bucket.start_time) +
+      "\u2013" +
+      formatTime(bar.bucket.end_time);
+    const total =
+      bar.bucket.user_count + bar.bucket.assistant_count;
+    tooltip = {
+      x: rect.left + rect.width / 2,
+      y: rect.top - 4,
+      text:
+        `${range} \u2014 ${bar.bucket.user_count} user, ` +
+        `${bar.bucket.assistant_count} assistant`,
+    };
+  }
+
+  function handleBarLeave() {
+    tooltip = null;
+  }
+
+  function handleBarClick(bucket: SessionActivityBucket) {
+    if (bucket.first_ordinal == null) return;
+    if (ui.hasBlockFilters) {
+      ui.showAllBlocks();
+    }
+    ui.scrollToOrdinal(bucket.first_ordinal);
+  }
+
+  function handleBarKeydown(
+    e: KeyboardEvent,
+    bucket: SessionActivityBucket,
+  ) {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      handleBarClick(bucket);
+    }
+  }
+
+  function formatTime(iso: string): string {
+    const d = new Date(iso);
+    return d.toLocaleTimeString(undefined, {
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+  }
+
+  function handleRetry() {
+    void sessionActivity.reload(sessionId);
+  }
+
+  const activeIndex = $derived(
+    sessionActivity.activeBucketIndex,
+  );
+
+  const startTime = $derived(
+    sessionActivity.buckets.length > 0
+      ? formatTime(sessionActivity.buckets[0]!.start_time)
+      : "",
+  );
+
+  const endTime = $derived(
+    sessionActivity.buckets.length > 0
+      ? formatTime(
+          sessionActivity.buckets[
+            sessionActivity.buckets.length - 1
+          ]!.end_time,
+        )
+      : "",
+  );
+</script>
+
+<div class="activity-minimap" bind:this={containerRef}>
+  {#if sessionActivity.loading || !sessionActivity.loaded || !sessionActivity.isForSession(sessionId)}
+    <div class="minimap-status">Loading activity...</div>
+  {:else if sessionActivity.error}
+    <div class="minimap-error">
+      {sessionActivity.error}
+      <button class="retry-btn" onclick={handleRetry}>
+        Retry
+      </button>
+    </div>
+  {:else if sessionActivity.buckets.length === 0}
+    <div class="minimap-status">
+      No timestamp data available
+    </div>
+  {:else if chart}
+    <div class="minimap-chart">
+      <svg
+        width={chart.svgWidth}
+        height={BAR_HEIGHT}
+        class="minimap-svg"
+      >
+        {#each chart.bars as bar}
+          {#if bar.populated}
+            <g
+              class="minimap-bar minimap-bar--clickable"
+              role="button"
+              tabindex={0}
+              aria-label="{formatTime(bar.bucket.start_time)}–{formatTime(bar.bucket.end_time)}: {bar.bucket.user_count} user, {bar.bucket.assistant_count} assistant"
+              onclick={() => handleBarClick(bar.bucket)}
+              onkeydown={(e) =>
+                handleBarKeydown(e, bar.bucket)}
+              onmouseenter={(e) => handleBarHover(e, bar)}
+              onmouseleave={handleBarLeave}
+            >
+              <rect
+                x={bar.x}
+                y={BAR_HEIGHT - bar.height}
+                width={bar.width}
+                height={bar.height}
+                rx="1"
+                class="bar-fill"
+              />
+            </g>
+          {:else}
+            <rect
+              x={bar.x}
+              y={BAR_HEIGHT - 1}
+              width={bar.width}
+              height={1}
+              class="bar-empty"
+            />
+          {/if}
+          {#if activeIndex === bar.index}
+            <rect
+              x={bar.x - 1}
+              y={bar.populated
+                ? BAR_HEIGHT - bar.height - 1
+                : BAR_HEIGHT - 2}
+              width={bar.width + 2}
+              height={bar.populated
+                ? bar.height + 2
+                : 3}
+              rx="2"
+              class="bar-indicator"
+            />
+          {/if}
+        {/each}
+      </svg>
+    </div>
+
+    {#if tooltip}
+      <div
+        class="minimap-tooltip"
+        style="left: {tooltip.x}px; top: {tooltip.y}px;"
+      >
+        {tooltip.text}
+      </div>
+    {/if}
+
+    <div class="minimap-axis">
+      <span class="axis-time">{startTime}</span>
+      <span class="axis-time">{endTime}</span>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .activity-minimap {
+    padding: 6px 14px 4px;
+    border-bottom: 1px solid var(--border-muted);
+  }
+
+  .minimap-status {
+    color: var(--text-muted);
+    font-size: 11px;
+    padding: 4px 0;
+    text-align: center;
+  }
+
+  .minimap-error {
+    color: var(--accent-red);
+    font-size: 11px;
+    padding: 4px 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+  }
+
+  .retry-btn {
+    padding: 1px 6px;
+    border: 1px solid currentColor;
+    border-radius: var(--radius-sm);
+    font-size: 10px;
+    color: inherit;
+    cursor: pointer;
+    background: transparent;
+  }
+
+  .retry-btn:hover {
+    background: var(--bg-surface-hover);
+  }
+
+  .minimap-chart {
+    position: relative;
+    overflow-x: auto;
+  }
+
+  .minimap-svg {
+    display: block;
+  }
+
+  .bar-fill {
+    fill: var(--accent-blue, #58a6ff);
+  }
+
+  .bar-empty {
+    fill: var(--border-muted);
+  }
+
+  .bar-indicator {
+    fill: none;
+    stroke: var(--text-primary);
+    stroke-width: 1.5;
+    pointer-events: none;
+  }
+
+  .minimap-bar--clickable {
+    cursor: pointer;
+  }
+
+  .minimap-bar--clickable:hover {
+    opacity: 0.8;
+  }
+
+  .minimap-bar--clickable:focus-visible {
+    outline: none;
+  }
+
+  .minimap-bar--clickable:focus-visible .bar-fill {
+    opacity: 0.85;
+  }
+
+  .minimap-tooltip {
+    position: fixed;
+    transform: translateX(-50%) translateY(-100%);
+    padding: 3px 8px;
+    background: var(--text-primary);
+    color: var(--bg-primary);
+    font-size: 10px;
+    border-radius: var(--radius-sm);
+    white-space: nowrap;
+    pointer-events: none;
+    z-index: 100;
+  }
+
+  .minimap-axis {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 9px;
+    color: var(--text-muted);
+    padding-top: 2px;
+    height: 16px;
+    user-select: none;
+  }
+
+  .axis-time {
+    flex-shrink: 0;
+  }
+</style>
diff --git a/frontend/src/lib/components/content/MessageList.svelte b/frontend/src/lib/components/content/MessageList.svelte
index ce8f820f..dc0c16c7 100644
--- a/frontend/src/lib/components/content/MessageList.svelte
+++ b/frontend/src/lib/components/content/MessageList.svelte
@@ -18,6 +18,7 @@
   } from "../../utils/content-parser.js";
   import { isSystemMessage } from "../../utils/messages.js";
   import { inSessionSearch } from "../../stores/inSessionSearch.svelte.js";
+  import { sessionActivity } from "../../stores/sessionActivity.svelte.js";
   import SessionFindBar from "./SessionFindBar.svelte";
 
   let containerRef: HTMLDivElement | undefined = $state(undefined);
@@ -126,25 +127,71 @@
     };
   }
 
+  function publishVisibleTimestamp() {
+    const v = virtualizer.instance;
+    if (!v) return;
+    const items = v.getVirtualItems();
+    // Skip overscanned items above the viewport.
+    const scrollTop = v.scrollOffset ?? 0;
+    for (const vi of items) {
+      if (vi.end <= scrollTop) continue;
+      const item =
+        displayItemsAsc[
+          ui.sortNewestFirst
+            ? displayItemsAsc.length - 1 - vi.index
+            : vi.index
+        ];
+      if (!item) continue;
+      const ts =
+        item.kind === "message"
+          ? item.message.timestamp
+          : item.timestamp;
+      if (ts) {
+        sessionActivity.firstVisibleTimestamp = ts;
+        return;
+      }
+    }
+    sessionActivity.firstVisibleTimestamp = null;
+  }
+
+  // Recompute visible timestamp when minimap opens or
+  // message content changes (e.g. SSE reload).
+  $effect(() => {
+    if (ui.activityMinimapOpen) {
+      // Track message array so the effect re-runs after
+      // content changes while the minimap is open.
+      void messages.messages.length;
+      publishVisibleTimestamp();
+    }
+  });
+
   function handleScroll() {
     if (!containerRef) return;
     if (scrollRaf !== null) return;
     scrollRaf = requestAnimationFrame(() => {
       scrollRaf = null;
       if (!containerRef) return;
-      const items = virtualizer.instance?.getVirtualItems() ?? [];
+      const items =
+        virtualizer.instance?.getVirtualItems() ?? [];
       if (items.length > 0 && messages.hasOlder) {
         const firstVisible = items[0]!.index;
-        const lastVisible = items[items.length - 1]!.index;
+        const lastVisible =
+          items[items.length - 1]!.index;
         const threshold = 30;
         if (
           (ui.sortNewestFirst &&
-            lastVisible >= displayItemsAsc.length - threshold) ||
-          (!ui.sortNewestFirst && firstVisible <= threshold)
+            lastVisible >=
+              displayItemsAsc.length - threshold) ||
+          (!ui.sortNewestFirst &&
+            firstVisible <= threshold)
         ) {
           messages.loadOlder();
         }
       }
+
+      if (ui.activityMinimapOpen) {
+        publishVisibleTimestamp();
+      }
     });
   }
 
diff --git a/frontend/src/lib/components/layout/SessionBreadcrumb.svelte b/frontend/src/lib/components/layout/SessionBreadcrumb.svelte
index c58a280b..456c76dd 100644
--- a/frontend/src/lib/components/layout/SessionBreadcrumb.svelte
+++ b/frontend/src/lib/components/layout/SessionBreadcrumb.svelte
@@ -20,6 +20,7 @@
 
   import { inSessionSearch } from "../../stores/inSessionSearch.svelte.js";
   import { messages as messagesStore } from "../../stores/messages.svelte.js";
+  import { ui } from "../../stores/ui.svelte.js";
 
   interface Props {
     session: Session | undefined;
@@ -46,15 +47,27 @@
       .catch(() => {});
   });
 
+  let resolvedSessionDirId: string | null = null;
   $effect(() => {
-    sessionDir = null;
-    if (!session) return;
+    if (!session) {
+      sessionDir = null;
+      resolvedSessionDirId = null;
+      return;
+    }
     const id = session.id;
+    if (id === resolvedSessionDirId) return;
+    sessionDir = null;
     getSessionDirectory(id)
       .then(({ path }) => {
-        if (session?.id === id) sessionDir = path || null;
+        if (session?.id === id) {
+          sessionDir = path || null;
+          resolvedSessionDirId = id;
+        }
       })
-      .catch(() => {});
+      .catch(() => {
+        // Don't cache the ID on failure so the next
+        // session refresh retries the lookup.
+      });
   });
 
   let sessionContextTokens = $derived(session?.peak_context_tokens ?? 0);
@@ -494,6 +507,17 @@
             </svg>
           {/if}
         </button>
+        <button
+          class="minimap-btn"
+          class:minimap-btn--active={ui.activityMinimapOpen}
+          title="Activity minimap"
+          onclick={() => ui.toggleActivityMinimap()}
+          aria-label="Toggle activity minimap"
+        >
+          <svg width="13" height="13" viewBox="0 0 16 16" fill="currentColor">
+            <path d="M1 14V8h2v6H1zm4 0V2h2v12H5zm4 0V5h2v9H9zm4 0V9h2v5h-2z"/>
+          </svg>
+        </button>
         <button
           class="find-btn"
           class:find-btn--active={inSessionSearch.isOpen}
@@ -790,6 +814,35 @@
     color: var(--accent-green, #2ea043);
   }
 
+  .minimap-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 22px;
+    height: 22px;
+    border: none;
+    border-radius: var(--radius-sm, 4px);
+    background: transparent;
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: background 0.15s, color 0.15s;
+    flex-shrink: 0;
+  }
+
+  .minimap-btn:hover {
+    background: var(--bg-surface-hover);
+    color: var(--accent-blue);
+  }
+
+  .minimap-btn--active {
+    color: var(--accent-blue);
+    background: color-mix(
+      in srgb,
+      var(--accent-blue) 12%,
+      transparent
+    );
+  }
+
   .find-btn {
     display: flex;
     align-items: center;
diff --git a/frontend/src/lib/stores/messages.svelte.ts b/frontend/src/lib/stores/messages.svelte.ts
index 7e5edd6f..731637b5 100644
--- a/frontend/src/lib/stores/messages.svelte.ts
+++ b/frontend/src/lib/stores/messages.svelte.ts
@@ -19,8 +19,13 @@ class MessagesStore {
   messageCount: number = $state(0);
   hasOlder: boolean = $state(false);
   loadingOlder: boolean = $state(false);
+  private _stableMainModel: string = $state("");
   mainModel: string = $derived(
-    !this.loading ? computeMainModel(this.messages) : "",
+    this.loading
+      ? this._stableMainModel
+      : this.messages.length > 0
+        ? computeMainModel(this.messages)
+        : "",
   );
   private abortController: AbortController | null = null;
   private reloadPromise: Promise<void> | null = null;
@@ -36,6 +41,7 @@ class MessagesStore {
       return;
     }
     this.clear();
+    this._stableMainModel = "";
     this.sessionId = id;
     this.loading = true;
 
@@ -75,6 +81,10 @@ class MessagesStore {
     } finally {
       if (this.sessionId === id) {
         this.loading = false;
+        this._stableMainModel =
+          this.messages.length > 0
+            ? computeMainModel(this.messages)
+            : "";
       }
     }
   }
@@ -113,6 +123,7 @@ class MessagesStore {
     this.messages = [];
     this.sessionId = null;
     this.loading = false;
+    this._stableMainModel = "";
     this.messageCount = 0;
     this.hasOlder = false;
     this.loadingOlder = false;
@@ -443,6 +454,10 @@ class MessagesStore {
     } finally {
       if (this.sessionId === id) {
         this.loading = false;
+        this._stableMainModel =
+          this.messages.length > 0
+            ? computeMainModel(this.messages)
+            : "";
       }
     }
   }
diff --git a/frontend/src/lib/stores/messages.test.ts b/frontend/src/lib/stores/messages.test.ts
index 6ce7eb00..04cb1aad 100644
--- a/frontend/src/lib/stores/messages.test.ts
+++ b/frontend/src/lib/stores/messages.test.ts
@@ -4,14 +4,12 @@ import * as api from '../api/client.js';
 import type {
   Message,
   MessagesResponse,
-  MinimapResponse,
   Session,
 } from '../api/types.js';
 
 // Mock the API client
 vi.mock('../api/client.js', () => ({
   getMessages: vi.fn(),
-  getMinimap: vi.fn(),
   getSession: vi.fn(),
 }));
 
@@ -73,13 +71,6 @@ function makeMessagesResponse(
   };
 }
 
-function emptyMinimap(): MinimapResponse {
-  return {
-    entries: [],
-    count: 0,
-  };
-}
-
 async function setupSession(
   sessionId: string,
   messageCount: number,
@@ -91,7 +82,6 @@ async function setupSession(
   vi.mocked(api.getMessages).mockResolvedValue(
     makeMessagesResponse(msgs),
   );
-  vi.mocked(api.getMinimap).mockResolvedValue(emptyMinimap());
   await messages.loadSession(sessionId);
 }
 
@@ -133,6 +123,57 @@ describe('MessagesStore', () => {
     await Promise.all([p1, p2]);
   });
 
+  it('should retain mainModel during reload', async () => {
+    const msgs = Array.from({ length: 5 }, (_, i) => ({
+      ...makeMessage(i),
+      model: 'claude-3-opus',
+    }));
+    await setupSession('s1', 5, msgs);
+
+    expect(messages.mainModel).toBe('claude-3-opus');
+
+    // Start a reload that hangs — mainModel must stay stable.
+    const { promise: hang, resolve: resolveHang } =
+      createDeferred<Session>();
+    vi.mocked(api.getSession).mockReturnValue(hang);
+
+    const p = messages.reload();
+
+    // While reload is in flight, mainModel should still be
+    // computed from the existing messages, not blank.
+    expect(messages.mainModel).toBe('claude-3-opus');
+
+    resolveHang(makeSession('s1', 5));
+    await p;
+
+    expect(messages.mainModel).toBe('claude-3-opus');
+  });
+
+  it('should not carry over mainModel to a different session', async () => {
+    const s1Msgs = Array.from({ length: 3 }, (_, i) => ({
+      ...makeMessage(i),
+      model: 'claude-3-opus',
+    }));
+    await setupSession('s1', 3, s1Msgs);
+    expect(messages.mainModel).toBe('claude-3-opus');
+
+    // Switch to s2 with a different model.
+    const s2Msgs = Array.from({ length: 3 }, (_, i) => ({
+      ...makeMessage(i),
+      model: 'claude-3-sonnet',
+    }));
+    vi.mocked(api.getSession).mockResolvedValue(
+      makeSession('s2', 3),
+    );
+    vi.mocked(api.getMessages).mockResolvedValue(
+      makeMessagesResponse(s2Msgs),
+    );
+    await messages.loadSession('s2');
+
+    // Must show s2's model, not s1's.
+    expect(messages.mainModel).toBe('claude-3-sonnet');
+  });
+
   it('should not reuse reload promise from different session', async () => {
     await setupSession('s1', 10);
 
@@ -187,7 +228,6 @@ describe('MessagesStore', () => {
     vi.mocked(api.getSession).mockResolvedValue(
       makeSession('s1', 20),
     );
-    vi.mocked(api.getMinimap).mockResolvedValue(emptyMinimap());
     vi.mocked(api.getMessages).mockResolvedValueOnce(
       makeMessagesResponse(
         Array.from(
@@ -284,7 +324,6 @@ describe('MessagesStore', () => {
     vi.mocked(api.getSession).mockResolvedValue(
       makeSession('s1', 2),
     );
-    vi.mocked(api.getMinimap).mockResolvedValue(emptyMinimap());
     vi.mocked(api.getMessages).mockResolvedValueOnce(
       makeMessagesResponse([makeMessage(0), makeMessage(1)]),
     );
@@ -338,7 +377,6 @@ describe('MessagesStore', () => {
     vi.mocked(api.getSession).mockResolvedValue(
       makeSession('s1', 2),
     );
-    vi.mocked(api.getMinimap).mockResolvedValue(emptyMinimap());
     vi.mocked(api.getMessages).mockResolvedValueOnce(
       makeMessagesResponse([makeMessage(0), makeMessage(1)]),
     );
@@ -398,9 +436,6 @@ describe('MessagesStore', () => {
       vi.mocked(api.getSession).mockResolvedValue(
         makeSession('s1', count),
       );
-      vi.mocked(api.getMinimap).mockResolvedValue(
-        emptyMinimap(),
-      );
       const descPage = Array.from(
         { length: 100 },
         (_, i) => makeMessage(999 - i),
diff --git a/frontend/src/lib/stores/sessionActivity.svelte.ts b/frontend/src/lib/stores/sessionActivity.svelte.ts
new file mode 100644
index 00000000..2f73d47c
--- /dev/null
+++ b/frontend/src/lib/stores/sessionActivity.svelte.ts
@@ -0,0 +1,114 @@
+import { getSessionActivity } from "../api/client.js";
+import type {
+  SessionActivityBucket,
+  SessionActivityResponse,
+} from "../api/types/session-activity.js";
+
+export function findActiveBucketIndex(
+  buckets: SessionActivityBucket[],
+  timestamp: string | null,
+): number | null {
+  if (!timestamp || buckets.length === 0) return null;
+  const ts = new Date(timestamp).getTime();
+  for (let i = 0; i < buckets.length; i++) {
+    const start = new Date(buckets[i]!.start_time).getTime();
+    const end = new Date(buckets[i]!.end_time).getTime();
+    if (ts >= start && ts < end) return i;
+  }
+  return null;
+}
+
+class SessionActivityStore {
+  buckets: SessionActivityBucket[] = $state([]);
+  intervalSeconds: number = $state(0);
+  totalMessages: number = $state(0);
+  loading: boolean = $state(false);
+  loaded: boolean = $state(false);
+  error: string | null = $state(null);
+  firstVisibleTimestamp: string | null = $state(null);
+
+  private cachedSessionId: string | null = null;
+  private loadVersion = 0;
+
+  /** True when buckets are loaded for the given session. */
+  isForSession(sessionId: string): boolean {
+    return this.cachedSessionId === sessionId;
+  }
+
+  get activeBucketIndex(): number | null {
+    return findActiveBucketIndex(
+      this.buckets,
+      this.firstVisibleTimestamp,
+    );
+  }
+
+  async load(sessionId: string) {
+    if (
+      this.cachedSessionId === sessionId &&
+      (this.buckets.length > 0 || this.loaded)
+    ) {
+      return;
+    }
+    // Clear stale data from a different session before
+    // fetching so the component never renders old buckets.
+    if (this.cachedSessionId !== sessionId) {
+      this.buckets = [];
+      this.loaded = false;
+    }
+    const version = ++this.loadVersion;
+    this.loading = true;
+    this.error = null;
+    this.firstVisibleTimestamp = null;
+    try {
+      const resp: SessionActivityResponse =
+        await getSessionActivity(sessionId);
+      // Ignore stale responses from previous sessions.
+      if (version !== this.loadVersion) return;
+      this.buckets = resp.buckets;
+      this.intervalSeconds = resp.interval_seconds;
+      this.totalMessages = resp.total_messages;
+      this.cachedSessionId = sessionId;
+      this.loaded = true;
+    } catch (e) {
+      if (version !== this.loadVersion) return;
+      this.error =
+        e instanceof Error
+          ? e.message
+          : "Failed to load activity";
+      this.buckets = [];
+      this.cachedSessionId = sessionId;
+      this.loaded = true;
+    } finally {
+      if (version === this.loadVersion) {
+        this.loading = false;
+      }
+    }
+  }
+
+  reload(sessionId: string) {
+    this.cachedSessionId = null;
+    return this.load(sessionId);
+  }
+
+  /** Mark cached data as stale so the next load() refetches.
+   *  Also discards any in-flight response. */
+  invalidate() {
+    this.loadVersion++;
+    this.cachedSessionId = null;
+    this.loaded = false;
+  }
+
+  clear() {
+    this.loadVersion++;
+    this.buckets = [];
+    this.intervalSeconds = 0;
+    this.totalMessages = 0;
+    this.loading = false;
+    this.loaded = false;
+    this.error = null;
+    this.cachedSessionId = null;
+    this.firstVisibleTimestamp = null;
+  }
+}
+
+export const sessionActivity = new SessionActivityStore();
diff --git a/frontend/src/lib/stores/sessionActivity.test.ts b/frontend/src/lib/stores/sessionActivity.test.ts
new file mode 100644
index 00000000..68e923ef
--- /dev/null
+++ b/frontend/src/lib/stores/sessionActivity.test.ts
@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  findActiveBucketIndex,
+  sessionActivity,
+} from "./sessionActivity.svelte.js";
+import * as api from "../api/client.js";
+import type { SessionActivityBucket } from "../api/types/session-activity.js";
+import type { SessionActivityResponse } from "../api/types/session-activity.js";
+
+vi.mock("../api/client.js", () => ({
+  getSessionActivity: vi.fn(),
+}));
+
+function bucket(
+  start: string,
+  end: string,
+  firstOrdinal: number | null = 0,
+): SessionActivityBucket {
+  return {
+    start_time: start,
+    end_time: end,
+    user_count: 1,
+    assistant_count: 1,
+    first_ordinal: firstOrdinal,
+  };
+}
+
+function makeResponse(
+  bucketCount: number,
+): SessionActivityResponse {
+  const buckets: SessionActivityBucket[] = [];
+  for (let i = 0; i < bucketCount; i++) {
+    buckets.push(
+      bucket(
+        `2026-03-26T${String(10 + i).padStart(2, "0")}:00:00Z`,
+        `2026-03-26T${String(11 + i).padStart(2, "0")}:00:00Z`,
+        i * 10,
+      ),
+    );
+  }
+  return {
+    buckets,
+    interval_seconds: 3600,
+    total_messages: bucketCount * 5,
+  };
+}
+
+function createDeferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+describe("SessionActivityStore", () => {
+  beforeEach(() => {
+    sessionActivity.clear();
+    vi.resetAllMocks();
+  });
+
+  it("ignores stale response after session switch", async () => {
+    const { promise: s1Hang, resolve: resolveS1 } =
+      createDeferred<SessionActivityResponse>();
+    vi.mocked(api.getSessionActivity).mockReturnValueOnce(
+      s1Hang,
+    );
+
+    // Start loading session 1 (hangs).
+    const p1 = sessionActivity.load("s1");
+
+    // Switch to session 2 before s1 resolves.
+    vi.mocked(api.getSessionActivity).mockResolvedValueOnce(
+      makeResponse(3),
+    );
+    const p2 = sessionActivity.load("s2");
+    await p2;
+
+    expect(sessionActivity.buckets.length).toBe(3);
+
+    // Now s1 resolves — should be ignored.
+    resolveS1(makeResponse(5));
+    await p1;
+
+    // Buckets should still be from s2, not s1.
+    expect(sessionActivity.buckets.length).toBe(3);
+  });
+
+  it("does not retry after a failed fetch", async () => {
+    vi.mocked(api.getSessionActivity).mockRejectedValueOnce(
+      new Error("network error"),
+    );
+    await sessionActivity.load("s1");
+
+    expect(sessionActivity.error).toBe("network error");
+    expect(sessionActivity.loading).toBe(false);
+    expect(sessionActivity.loaded).toBe(true);
+
+    // A second load for the same session should not re-fetch
+    // because the session is already marked as loaded (even
+    // though it failed). The user must use reload() to retry.
+    vi.mocked(api.getSessionActivity).mockResolvedValueOnce(
+      makeResponse(2),
+    );
+    await sessionActivity.load("s1");
+
+    // Still shows the error, did not auto-retry.
+    expect(sessionActivity.error).toBe("network error");
+    expect(
+      vi.mocked(api.getSessionActivity),
+    ).toHaveBeenCalledTimes(1);
+  });
+
+  it("invalidate discards in-flight load and forces refetch", async () => {
+    const { promise: s1Hang, resolve: resolveS1 } =
+      createDeferred<SessionActivityResponse>();
+    vi.mocked(api.getSessionActivity).mockReturnValueOnce(
+      s1Hang,
+    );
+
+    // Start a load that hangs.
+    const p1 = sessionActivity.load("s1");
+
+    // SSE fires while minimap is hidden — invalidate.
+    sessionActivity.invalidate();
+
+    // Stale response arrives — should be discarded.
+    resolveS1(makeResponse(3));
+    await p1;
+
+    expect(sessionActivity.buckets.length).toBe(0);
+    expect(sessionActivity.loaded).toBe(false);
+
+    // Reopen triggers load — should refetch, not short-circuit.
+    vi.mocked(api.getSessionActivity).mockResolvedValueOnce(
+      makeResponse(5),
+    );
+    await sessionActivity.load("s1");
+
+    expect(sessionActivity.buckets.length).toBe(5);
+    expect(
+      vi.mocked(api.getSessionActivity),
+    ).toHaveBeenCalledTimes(2);
+  });
+
+  it("tracks loaded lifecycle", async () => {
+    expect(sessionActivity.loaded).toBe(false);
+    expect(sessionActivity.loading).toBe(false);
+
+    // Successful load sets loaded=true.
+    vi.mocked(api.getSessionActivity).mockResolvedValueOnce(
+      makeResponse(2),
+    );
+    await sessionActivity.load("s1");
+    expect(sessionActivity.loaded).toBe(true);
+    expect(sessionActivity.loading).toBe(false);
+
+    // clear() resets to pre-load state.
+    sessionActivity.clear();
+    expect(sessionActivity.loaded).toBe(false);
+    expect(sessionActivity.loading).toBe(false);
+  });
+
+  it("sets loaded on fetch error", async () => {
+    vi.mocked(api.getSessionActivity).mockRejectedValueOnce(
+      new Error("network error"),
+    );
+    await sessionActivity.load("s1");
+    expect(sessionActivity.loaded).toBe(true);
+    expect(sessionActivity.error).toBe("network error");
+  });
+
+  it("clears active indicator when timestamp set to null", async () => {
+    // This tests the store-level contract: setting
+    // firstVisibleTimestamp to null clears the active bucket.
+    // The component-level publishVisibleTimestamp() path that
+    // sets this value is covered by the E2E test "active
+    // indicator moves after reopen without scroll."
+    vi.mocked(api.getSessionActivity).mockResolvedValueOnce(
+      makeResponse(2),
+    );
+    await sessionActivity.load("s1");
+
+    // Set a visible timestamp — indicator should be active.
+    sessionActivity.firstVisibleTimestamp =
+      "2026-03-26T10:05:00Z";
+    expect(sessionActivity.activeBucketIndex).toBe(0);
+
+    // Clear it (simulates publishVisibleTimestamp finding
+    // no visible items with timestamps).
+    sessionActivity.firstVisibleTimestamp = null;
+    expect(sessionActivity.activeBucketIndex).toBeNull();
+  });
+
+  it("clears firstVisibleTimestamp on new load", async () => {
+    vi.mocked(api.getSessionActivity).mockResolvedValue(
+      makeResponse(2),
+    );
+    await sessionActivity.load("s1");
+
+    sessionActivity.firstVisibleTimestamp =
+      "2026-03-26T10:05:00Z";
+    expect(sessionActivity.activeBucketIndex).toBe(0);
+
+    // Loading a new session should clear it.
+    await sessionActivity.load("s2");
+    expect(sessionActivity.firstVisibleTimestamp).toBeNull();
+  });
+});
+
+describe("findActiveBucketIndex", () => {
+  const buckets: SessionActivityBucket[] = [
+    bucket("2026-03-26T10:00:00Z", "2026-03-26T10:15:00Z", 0),
+    bucket("2026-03-26T10:15:00Z", "2026-03-26T10:30:00Z", null),
+    bucket("2026-03-26T10:30:00Z", "2026-03-26T10:45:00Z", 10),
+  ];
+
+  it("maps timestamp to correct bucket", () => {
+    expect(
+      findActiveBucketIndex(buckets, "2026-03-26T10:05:00Z"),
+    ).toBe(0);
+    expect(
+      findActiveBucketIndex(buckets, "2026-03-26T10:35:00Z"),
+    ).toBe(2);
+  });
+
+  it("returns null for null timestamp", () => {
+    expect(findActiveBucketIndex(buckets, null)).toBeNull();
+  });
+
+  it("returns null for timestamp outside range", () => {
+    expect(
+      findActiveBucketIndex(buckets, "2026-03-26T09:00:00Z"),
+    ).toBeNull();
+    expect(
+      findActiveBucketIndex(buckets, "2026-03-26T11:00:00Z"),
+    ).toBeNull();
+  });
+
+  it("maps timestamp at bucket boundary to that bucket", () => {
+    expect(
+      findActiveBucketIndex(buckets, "2026-03-26T10:15:00Z"),
+    ).toBe(1);
+  });
+
+  it("returns empty bucket index (for highlight, not click)", () => {
+    expect(
+      findActiveBucketIndex(buckets, "2026-03-26T10:20:00Z"),
+    ).toBe(1);
+  });
+});
diff --git a/frontend/src/lib/stores/ui.svelte.ts b/frontend/src/lib/stores/ui.svelte.ts
index c968ae98..7785dcef 100644
--- a/frontend/src/lib/stores/ui.svelte.ts
+++ b/frontend/src/lib/stores/ui.svelte.ts
@@ -35,6 +35,7 @@ export const ALL_BLOCK_TYPES: BlockType[] = [
 
 const BLOCK_FILTER_KEY = "agentsview-block-filters";
 const TRANSCRIPT_MODE_KEY = "agentsview-transcript-mode";
+const MINIMAP_KEY = "agentsview-activity-minimap";
 
 function readBlockFilters(): Set<BlockType> {
   try {
@@ -142,6 +143,16 @@ function readStoredSidebarWidth(): number {
   }
 }
 
+function readStoredBool(key: string, fallback: boolean): boolean {
+  try {
+    const raw = localStorage?.getItem(key);
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+  } catch {
+    // ignore
+  }
+  return fallback;
+}
 class UIStore {
   theme: Theme = $state(readStoredTheme() || "light");
   sortNewestFirst: boolean = $state(false);
@@ -159,6 +170,9 @@ class UIStore {
 
   sidebarOpen: boolean = $state(true);
   isMobileViewport: boolean = $state(false);
+  activityMinimapOpen: boolean = $state(
+    readStoredBool(MINIMAP_KEY, false),
+  );
 
   /** Set of block types currently visible. */
   visibleBlocks: Set<BlockType> = $state(readBlockFilters());
@@ -231,6 +245,17 @@ class UIStore {
         }
       });
 
+      $effect(() => {
+        try {
+          localStorage?.setItem(
+            MINIMAP_KEY,
+            String(this.activityMinimapOpen),
+          );
+        } catch {
+          // ignore
+        }
+      });
+
       // Initialize sidebar based on viewport width
       if (typeof window !== "undefined" && typeof window.matchMedia === "function") {
         const mq = window.matchMedia("(min-width: 768px)");
@@ -384,6 +409,10 @@ class UIStore {
     this.sidebarOpen = false;
   }
 
+  toggleActivityMinimap() {
+    this.activityMinimapOpen = !this.activityMinimapOpen;
+  }
+
   closeAll() {
     this.activeModal = null;
   }
diff --git a/internal/db/activity.go b/internal/db/activity.go
new file mode 100644
index 00000000..8c671803
--- /dev/null
+++ b/internal/db/activity.go
@@ -0,0 +1,212 @@
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+)
+
+// SessionActivityBucket holds message counts for one time interval.
+type SessionActivityBucket struct {
+	StartTime      string `json:"start_time"`
+	EndTime        string `json:"end_time"`
+	UserCount      int    `json:"user_count"`
+	AssistantCount int    `json:"assistant_count"`
+	FirstOrdinal   *int   `json:"first_ordinal"` // nil for empty buckets
+}
+
+// SessionActivityResponse is the response for the activity endpoint.
+type SessionActivityResponse struct {
+	Buckets         []SessionActivityBucket `json:"buckets"`
+	IntervalSeconds int64                   `json:"interval_seconds"`
+	TotalMessages   int                     `json:"total_messages"`
+}
+
+// intervalSteps are preferred bucket widths in seconds.
+// For sessions longer than the last step * maxBuckets, the
+// interval scales beyond this list to keep bucket count bounded.
+var intervalSteps = []int64{
+	60, 120, 300, 600, 900, 1800, 3600, 7200,
+}
+
+const maxBuckets = 50
+
+// SnapInterval picks a bucket interval targeting ~30 buckets.
+// For very long sessions the interval scales beyond the fixed
+// step list so the total bucket count never exceeds maxBuckets.
+func SnapInterval(durationSec int64) int64 {
+	if durationSec <= 0 {
+		return intervalSteps[0]
+	}
+	target := durationSec / 30
+	if target <= intervalSteps[0] {
+		return intervalSteps[0]
+	}
+
+	// Try the fixed step list first.
+	best := intervalSteps[0]
+	bestDist := abs64(intervalSteps[0] - target)
+	for _, step := range intervalSteps {
+		d := abs64(step - target)
+		if d < bestDist || (d == bestDist && step > best) {
+			bestDist = d
+			best = step
+		}
+	}
+
+	// If the best fixed step would produce too many buckets,
+	// scale up to keep the count bounded. Bucket count is
+	// floor(duration/interval) + 1, so divide by maxBuckets-1.
+	if durationSec/best+1 > maxBuckets {
+		best = (durationSec + maxBuckets - 2) / (maxBuckets - 1)
+	}
+	return best
+}
+
+func abs64(x int64) int64 {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+// GetSessionActivity returns time-bucketed message counts for a
+// session. Only visible messages are counted (system and
+// prefix-detected injected messages excluded).
+func (d *DB) GetSessionActivity(
+	ctx context.Context, sessionID string,
+) (*SessionActivityResponse, error) {
+	return getSessionActivitySQLite(d, ctx, sessionID)
+}
+
+func getSessionActivitySQLite(
+	d *DB, ctx context.Context, sessionID string,
+) (*SessionActivityResponse, error) {
+	// Count all messages, including system (for TotalMessages field).
+	var total int
+	err := d.getReader().QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM messages WHERE session_id = ?`,
+		sessionID,
+	).Scan(&total)
+	if err != nil {
+		return nil, fmt.Errorf("counting messages: %w", err)
+	}
+
+	// Visible-message filter: exclude persisted system messages and
+	// prefix-detected injected user messages.
+	visibleFilter := "m.is_system = 0 AND " + SystemPrefixSQL("m.content", "m.role")
+
+	// Get min and max timestamps from visible messages with valid timestamps.
+	// Use julianday() for sub-second precision — strftime('%s') truncates.
+	tsFilter := "m.timestamp IS NOT NULL AND m.timestamp != '' AND julianday(m.timestamp) IS NOT NULL"
+	var minEpoch, maxEpoch sql.NullFloat64
+	err = d.getReader().QueryRowContext(ctx, fmt.Sprintf(`
+		SELECT
+			MIN((julianday(m.timestamp) - 2440587.5) * 86400.0),
+			MAX((julianday(m.timestamp) - 2440587.5) * 86400.0)
+		FROM messages m
+		WHERE m.session_id = ?
+		  AND %s
+		  AND %s`,
+		visibleFilter, tsFilter,
+	), sessionID).Scan(&minEpoch, &maxEpoch)
+	if err != nil {
+		return nil, fmt.Errorf("querying timestamp range: %w", err)
+	}
+
+	// If no timestamps, return empty buckets with total count.
+	if !minEpoch.Valid || !maxEpoch.Valid {
+		return &SessionActivityResponse{
+			Buckets:       []SessionActivityBucket{},
+			TotalMessages: total,
+		}, nil
+	}
+
+	// Use floor of min epoch as anchor so bucket boundaries
+	// align to whole seconds. Compute duration from the exact
+	// float values to preserve sub-second precision.
+	epochMin := int64(minEpoch.Float64)
+	durationSec := int64(maxEpoch.Float64 - minEpoch.Float64)
+	interval := SnapInterval(durationSec)
+
+	// Query: group visible messages into buckets using float epoch
+	// for sub-second precision. The anchor is truncated to whole
+	// seconds so bucket boundaries align cleanly.
+	rows, err := d.getReader().QueryContext(ctx, fmt.Sprintf(`
+		SELECT
+			CAST(((julianday(m.timestamp) - 2440587.5) * 86400.0 - ?) / ? AS INTEGER) AS bucket_idx,
+			SUM(CASE WHEN m.role = 'user' THEN 1 ELSE 0 END) AS user_count,
+			SUM(CASE WHEN m.role = 'assistant' THEN 1 ELSE 0 END) AS asst_count,
+			MIN(m.ordinal) AS first_ordinal
+		FROM messages m
+		WHERE m.session_id = ?
+		  AND %s
+		  AND %s
+		GROUP BY bucket_idx
+		ORDER BY bucket_idx`,
+		visibleFilter, tsFilter,
+	), epochMin, interval, sessionID)
+	if err != nil {
+		return nil, fmt.Errorf("querying activity buckets: %w", err)
+	}
+	defer rows.Close()
+
+	type bucketRow struct {
+		idx          int
+		userCount    int
+		asstCount    int
+		firstOrdinal int
+	}
+	var populated []bucketRow
+	maxIdx := 0
+	for rows.Next() {
+		var br bucketRow
+		if err := rows.Scan(
+			&br.idx, &br.userCount, &br.asstCount, &br.firstOrdinal,
+		); err != nil {
+			return nil, fmt.Errorf("scanning bucket row: %w", err)
+		}
+		populated = append(populated, br)
+		if br.idx > maxIdx {
+			maxIdx = br.idx
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterating bucket rows: %w", err)
+	}
+
+	// Build the full bucket array including empty gaps.
+	bucketCount := maxIdx + 1
+	buckets := make([]SessionActivityBucket, bucketCount)
+
+	// Precompute a lookup from bucket index to populated row.
+	popMap := make(map[int]bucketRow, len(populated))
+	for _, br := range populated {
+		popMap[br.idx] = br
+	}
+
+	for i := range buckets {
+		startSec := epochMin + int64(i)*interval
+		endSec := startSec + interval
+		startTime := time.Unix(startSec, 0).UTC()
+		endTime := time.Unix(endSec, 0).UTC()
+		bucket := SessionActivityBucket{
+			StartTime: startTime.Format(time.RFC3339),
+			EndTime:   endTime.Format(time.RFC3339),
+		}
+		if br, ok := popMap[i]; ok {
+			bucket.UserCount = br.userCount
+			bucket.AssistantCount = br.asstCount
+			ord := br.firstOrdinal
+			bucket.FirstOrdinal = &ord
+		}
+		buckets[i] = bucket
+	}
+
+	return &SessionActivityResponse{
+		Buckets:         buckets,
+		IntervalSeconds: interval,
+		TotalMessages:   total,
+	}, nil
+}
diff --git a/internal/db/activity_test.go b/internal/db/activity_test.go
new file mode 100644
index 00000000..573ef052
--- /dev/null
+++ b/internal/db/activity_test.go
@@ -0,0 +1,283 @@
+package db
+
+import (
+	"context"
+	"testing"
+)
+
+func TestGetSessionActivity(t *testing.T) {
+	d := testDB(t)
+	sid := "test-activity"
+
+	err := d.UpsertSession(Session{
+		ID:        sid,
+		Agent:     "claude",
+		StartedAt: Ptr("2026-03-26T10:00:00Z"),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Insert messages spanning ~29 minutes.
+	msgs := []Message{
+		{SessionID: sid, Ordinal: 0, Role: "user", Content: "hello", Timestamp: "2026-03-26T10:00:00Z", ContentLength: 5},
+		{SessionID: sid, Ordinal: 1, Role: "assistant", Content: "hi", Timestamp: "2026-03-26T10:00:30Z", ContentLength: 2},
+		{SessionID: sid, Ordinal: 2, Role: "user", Content: "next", Timestamp: "2026-03-26T10:01:30Z", ContentLength: 4},
+		{SessionID: sid, Ordinal: 3, Role: "assistant", Content: "resp", Timestamp: "2026-03-26T10:02:00Z", ContentLength: 4},
+		// Gap: no messages from 10:02 to 10:28.
+		{SessionID: sid, Ordinal: 4, Role: "user", Content: "back", Timestamp: "2026-03-26T10:28:00Z", ContentLength: 4},
+		{SessionID: sid, Ordinal: 5, Role: "assistant", Content: "wb", Timestamp: "2026-03-26T10:29:00Z", ContentLength: 2},
+		// System message — should be excluded from counts.
+		{SessionID: sid, Ordinal: 6, Role: "user", Content: "This session is being continued from a previous conversation.", Timestamp: "2026-03-26T10:29:30Z", ContentLength: 60, IsSystem: true},
+	}
+	if err := d.InsertMessages(msgs); err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := d.GetSessionActivity(context.Background(), sid)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 29 min span => 1min buckets (snapInterval(1740) = 60).
+	if resp.IntervalSeconds != 60 {
+		t.Errorf("interval = %d, want 60", resp.IntervalSeconds)
+	}
+
+	// System message should still count toward total (7 total messages).
+	if resp.TotalMessages != 7 {
+		t.Errorf("total = %d, want 7", resp.TotalMessages)
+	}
+
+	// Should have 30 buckets (min 0 to min 29).
+	if len(resp.Buckets) < 28 {
+		t.Errorf("bucket count = %d, want >= 28", len(resp.Buckets))
+	}
+
+	// First bucket (10:00-10:01) should have user=1, assistant=1.
+	first := resp.Buckets[0]
+	if first.UserCount != 1 || first.AssistantCount != 1 {
+		t.Errorf("first bucket: user=%d asst=%d, want 1,1", first.UserCount, first.AssistantCount)
+	}
+	if first.FirstOrdinal == nil || *first.FirstOrdinal != 0 {
+		t.Errorf("first bucket first_ordinal: got %v, want 0", first.FirstOrdinal)
+	}
+
+	// Middle empty bucket should have nil FirstOrdinal.
+	mid := resp.Buckets[15]
+	if mid.UserCount != 0 || mid.AssistantCount != 0 {
+		t.Errorf("mid bucket: user=%d asst=%d, want 0,0", mid.UserCount, mid.AssistantCount)
+	}
+	if mid.FirstOrdinal != nil {
+		t.Errorf("mid bucket first_ordinal: got %v, want nil", mid.FirstOrdinal)
+	}
+}
+
+func TestGetSessionActivity_NoMessages(t *testing.T) {
+	d := testDB(t)
+	sid := "test-empty"
+
+	err := d.UpsertSession(Session{ID: sid, Agent: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := d.GetSessionActivity(context.Background(), sid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(resp.Buckets) != 0 {
+		t.Errorf("buckets = %d, want 0", len(resp.Buckets))
+	}
+}
+
+func TestGetSessionActivity_NullTimestamps(t *testing.T) {
+	d := testDB(t)
+	sid := "test-null-ts"
+
+	err := d.UpsertSession(Session{ID: sid, Agent: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msgs := []Message{
+		{SessionID: sid, Ordinal: 0, Role: "user", Content: "hi", ContentLength: 2},
+		{SessionID: sid, Ordinal: 1, Role: "assistant", Content: "hello", ContentLength: 5},
+	}
+	if err := d.InsertMessages(msgs); err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := d.GetSessionActivity(context.Background(), sid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(resp.Buckets) != 0 {
+		t.Errorf("buckets = %d, want 0", len(resp.Buckets))
+	}
+	if resp.TotalMessages != 2 {
+		t.Errorf("total = %d, want 2", resp.TotalMessages)
+	}
+}
+
+func TestGetSessionActivity_SingleMessage(t *testing.T) {
+	d := testDB(t)
+	sid := "test-single"
+
+	err := d.UpsertSession(Session{ID: sid, Agent: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msgs := []Message{
+		{SessionID: sid, Ordinal: 0, Role: "user", Content: "hi", Timestamp: "2026-03-26T10:00:00Z", ContentLength: 2},
+	}
+	if err := d.InsertMessages(msgs); err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := d.GetSessionActivity(context.Background(), sid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(resp.Buckets) != 1 {
+		t.Fatalf("buckets = %d, want 1", len(resp.Buckets))
+	}
+	if resp.Buckets[0].UserCount != 1 {
+		t.Errorf("user count = %d, want 1", resp.Buckets[0].UserCount)
+	}
+}
+
+func TestGetSessionActivity_MalformedTimestamps(t *testing.T) {
+	d := testDB(t)
+	sid := "test-malformed-ts"
+
+	err := d.UpsertSession(Session{ID: sid, Agent: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msgs := []Message{
+		{SessionID: sid, Ordinal: 0, Role: "user", Content: "hi", Timestamp: "2026-03-26T10:00:00Z", ContentLength: 2},
+		{SessionID: sid, Ordinal: 1, Role: "assistant", Content: "hello", Timestamp: "not-a-timestamp", ContentLength: 5},
+		{SessionID: sid, Ordinal: 2, Role: "user", Content: "bye", Timestamp: "2026-03-26T10:00:30Z", ContentLength: 3},
+	}
+	if err := d.InsertMessages(msgs); err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := d.GetSessionActivity(context.Background(), sid)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Malformed timestamp excluded from buckets; valid ones bucketed.
+	if len(resp.Buckets) < 1 {
+		t.Fatal("expected at least 1 bucket")
+	}
+	// Both valid user messages (ord 0 and 2) are within 30s,
+	// so they land in the same bucket.
+	if resp.Buckets[0].UserCount != 2 || resp.Buckets[0].AssistantCount != 0 {
+		t.Errorf(
+			"first bucket: user=%d asst=%d, want 2,0",
+			resp.Buckets[0].UserCount, resp.Buckets[0].AssistantCount,
+		)
+	}
+	if resp.TotalMessages != 3 {
+		t.Errorf("total = %d, want 3", resp.TotalMessages)
+	}
+}
+
+func TestGetSessionActivity_FractionalTimestamps(t *testing.T) {
+	d := testDB(t)
+	sid := "test-frac-ts"
+
+	err := d.UpsertSession(Session{ID: sid, Agent: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Two messages within the same 60s bucket but with fractional
+	// timestamps that would be mis-bucketed by whole-second truncation.
+	// 10:00:00.900 and 10:00:59.100 are 58.2s apart — same 60s bucket.
+	msgs := []Message{
+		{SessionID: sid, Ordinal: 0, Role: "user", Content: "a", Timestamp: "2026-03-26T10:00:00.900Z", ContentLength: 1},
+		{SessionID: sid, Ordinal: 1, Role: "assistant", Content: "b", Timestamp: "2026-03-26T10:00:59.100Z", ContentLength: 1},
+		// This message is in the next bucket (60.1s after the anchor).
+		{SessionID: sid, Ordinal: 2, Role: "user", Content: "c", Timestamp: "2026-03-26T10:01:01.000Z", ContentLength: 1},
+	}
+	if err := d.InsertMessages(msgs); err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := d.GetSessionActivity(context.Background(), sid)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.IntervalSeconds != 60 {
+		t.Fatalf("interval = %d, want 60", resp.IntervalSeconds)
+	}
+
+	// First bucket should have both fractional-second messages.
+	if len(resp.Buckets) < 1 {
+		t.Fatal("expected at least 1 bucket")
+	}
+	first := resp.Buckets[0]
+	if first.UserCount != 1 || first.AssistantCount != 1 {
+		t.Errorf(
+			"first bucket: user=%d asst=%d, want 1,1",
+			first.UserCount, first.AssistantCount,
+		)
+	}
+
+	// Second bucket should have the third message.
+	if len(resp.Buckets) < 2 {
+		t.Fatal("expected at least 2 buckets")
+	}
+	second := resp.Buckets[1]
+	if second.UserCount != 1 {
+		t.Errorf(
+			"second bucket user=%d, want 1",
+			second.UserCount,
+		)
+	}
+}
+
+func TestSnapInterval(t *testing.T) {
+	tests := []struct {
+		name     string
+		duration int64 // seconds
+		want     int64
+	}{
+		{"30s session", 30, 60},
+		{"5m session", 300, 60},
+		{"10m session", 600, 60},
+		{"20m session", 1200, 60},
+		{"30m session", 1800, 60},
+		{"1h session", 3600, 120},
+		{"2h session", 7200, 300},
+		{"4h session", 14400, 600},
+		{"8h session", 28800, 900},
+		{"12h session", 43200, 1800},
+		{"16h session", 57600, 1800},
+		{"24h session", 86400, 3600},
+		{"48h session", 172800, 7200},
+		// Extreme: 30 days. 7200s would give 361 buckets,
+		// so interval scales up to keep count <= 50.
+		// ceil(2592000 / 49) = 52898
+		{"30d session", 2592000, 52898},
+		{"0s session", 0, 60},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SnapInterval(tt.duration)
+			if got != tt.want {
+				t.Errorf(
+					"SnapInterval(%d) = %d, want %d",
+					tt.duration, got, tt.want,
+				)
+			}
+		})
+	}
+}
diff --git a/internal/db/db_test.go b/internal/db/db_test.go
index bbf3b02f..a20990a2 100644
--- a/internal/db/db_test.go
+++ b/internal/db/db_test.go
@@ -1033,32 +1033,6 @@ func TestMessageCRUD(t *testing.T) {
 	}
 }
 
-func TestMinimap(t *testing.T) {
-	d := testDB(t)
-
-	insertSession(t, d, "s1", "p", func(s *Session) {
-		s.MessageCount = 2
-	})
-
-	m2 := asstMsg("s1", 1, "Hi")
-	m2.HasThinking = true
-	m2.HasToolUse = true
-
-	insertMessages(t, d,
-		userMsg("s1", 0, "Hello"),
-		m2,
-	)
-
-	entries, err := d.GetMinimap(context.Background(), "s1")
-	requireNoError(t, err, "GetMinimap")
-	if len(entries) != 2 {
-		t.Fatalf("got %d entries, want 2", len(entries))
-	}
-	if !entries[1].HasThinking {
-		t.Error("expected HasThinking on second entry")
-	}
-}
-
 func TestReplaceSessionMessages(t *testing.T) {
 	d := testDB(t)
 
@@ -2141,94 +2115,6 @@ func TestSetCursorSecretDefensiveCopy(t *testing.T) {
 	}
 }
 
-func TestSampleMinimap(t *testing.T) {
-	// Create a helper to generate n entries
-	makeEntries := func(n int) []MinimapEntry {
-		entries := make([]MinimapEntry, 0, n)
-		for i := range n {
-			entries = append(entries, MinimapEntry{
-				Ordinal: i,
-				Role:    "user",
-			})
-		}
-		return entries
-	}
-
-	tests := []struct {
-		name    string
-		entries []MinimapEntry
-		max     int
-		wantLen int
-		// simple check function for ordinals
-		check func([]MinimapEntry) error
-	}{
-		{
-			name:    "SampleDown",
-			entries: makeEntries(10),
-			max:     3,
-			wantLen: 3,
-			check: func(got []MinimapEntry) error {
-				if got[0].Ordinal != 0 || got[1].Ordinal != 4 || got[2].Ordinal != 9 {
-					return fmt.Errorf("ordinals = [%d %d %d], want [0 4 9]",
-						got[0].Ordinal, got[1].Ordinal, got[2].Ordinal)
-				}
-				return nil
-			},
-		},
-		{
-			name:    "ExactSize",
-			entries: makeEntries(5),
-			max:     5,
-			wantLen: 5,
-		},
-		{
-			name:    "SmallerThanMax",
-			entries: makeEntries(3),
-			max:     5,
-			wantLen: 3,
-		},
-		{
-			name:    "Empty",
-			entries: makeEntries(0),
-			max:     5,
-			wantLen: 0,
-		},
-		{
-			name:    "MaxOne",
-			entries: makeEntries(10),
-			max:     1,
-			wantLen: 1,
-			check: func(got []MinimapEntry) error {
-				if got[0].Ordinal != 0 {
-					return fmt.Errorf("ordinal = %d, want 0", got[0].Ordinal)
-				}
-				return nil
-			},
-		},
-		{
-			name:    "MaxZero",
-			entries: makeEntries(10),
-			max:     0,
-			wantLen: 10, // Returns original if max <= 0
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := SampleMinimap(tt.entries, tt.max)
-			if len(got) != tt.wantLen {
-				t.Errorf("len = %d, want %d", len(got), tt.wantLen)
-				return
-			}
-			if tt.check != nil {
-				if err := tt.check(got); err != nil {
-					t.Error(err)
-				}
-			}
-		})
-	}
-}
-
 func TestDeleteSession(t *testing.T) {
 	d := testDB(t)
 
diff --git a/internal/db/messages.go b/internal/db/messages.go
index 283159cb..a3967e57 100644
--- a/internal/db/messages.go
+++ b/internal/db/messages.go
@@ -73,15 +73,6 @@ type Message struct {
 	IsSystem      bool            `json:"is_system"` // persisted, filters search/analytics
 }
 
-// MinimapEntry is a lightweight message summary for minimap rendering.
-type MinimapEntry struct {
-	Ordinal       int    `json:"ordinal"`
-	Role          string `json:"role"`
-	ContentLength int    `json:"content_length"`
-	HasThinking   bool   `json:"has_thinking"`
-	HasToolUse    bool   `json:"has_tool_use"`
-}
-
 // GetMessages returns paginated messages for a session.
 // from: starting ordinal (inclusive)
 // limit: max messages to return
@@ -148,64 +139,6 @@ func (db *DB) GetAllMessages(
 	return msgs, nil
 }
 
-// GetMinimap returns lightweight metadata for all messages in a session.
-func (db *DB) GetMinimap(
-	ctx context.Context, sessionID string,
-) ([]MinimapEntry, error) {
-	return db.GetMinimapFrom(ctx, sessionID, 0)
-}
-
-// GetMinimapFrom returns lightweight metadata for messages in a
-// session starting at ordinal >= from.
-func (db *DB) GetMinimapFrom(
-	ctx context.Context, sessionID string, from int,
-) ([]MinimapEntry, error) {
-	rows, err := db.getReader().QueryContext(ctx, `
-		SELECT ordinal, role, content_length, has_thinking, has_tool_use
-		FROM messages
-		WHERE session_id = ? AND ordinal >= ?
-		ORDER BY ordinal ASC`, sessionID, from)
-	if err != nil {
-		return nil, fmt.Errorf("querying minimap: %w", err)
-	}
-	defer rows.Close()
-
-	var entries []MinimapEntry
-	for rows.Next() {
-		var e MinimapEntry
-		if err := rows.Scan(
-			&e.Ordinal, &e.Role, &e.ContentLength,
-			&e.HasThinking, &e.HasToolUse,
-		); err != nil {
-			return nil, fmt.Errorf("scanning minimap entry: %w", err)
-		}
-		entries = append(entries, e)
-	}
-	return entries, rows.Err()
-}
-
-// SampleMinimap downsamples entries to at most max points while
-// preserving ordering and both endpoints.
-func SampleMinimap(
-	entries []MinimapEntry, max int,
-) []MinimapEntry {
-	if max <= 0 || len(entries) <= max {
-		return entries
-	}
-	if max == 1 {
-		return []MinimapEntry{entries[0]}
-	}
-
-	sampled := make([]MinimapEntry, 0, max)
-	lastIdx := len(entries) - 1
-	den := max - 1
-	for i := range max {
-		idx := (i * lastIdx) / den
-		sampled = append(sampled, entries[idx])
-	}
-	return sampled
-}
-
 // insertMessagesTx batch-inserts messages within an existing
 // transaction. Returns a slice of message IDs parallel to the
 // input msgs slice. The caller must hold db.mu.
diff --git a/internal/db/store.go b/internal/db/store.go
index 98c5c45a..4b6b3e8e 100644
--- a/internal/db/store.go
+++ b/internal/db/store.go
@@ -28,8 +28,7 @@ type Store interface {
 	// Messages.
 	GetMessages(ctx context.Context, sessionID string, from, limit int, asc bool) ([]Message, error)
 	GetAllMessages(ctx context.Context, sessionID string) ([]Message, error)
-	GetMinimap(ctx context.Context, sessionID string) ([]MinimapEntry, error)
-	GetMinimapFrom(ctx context.Context, sessionID string, from int) ([]MinimapEntry, error)
+	GetSessionActivity(ctx context.Context, sessionID string) (*SessionActivityResponse, error)
 
 	// Search.
 	HasFTS() bool
diff --git a/internal/postgres/activity.go b/internal/postgres/activity.go
new file mode 100644
index 00000000..46eae497
--- /dev/null
+++ b/internal/postgres/activity.go
@@ -0,0 +1,145 @@
+package postgres
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/wesm/agentsview/internal/db"
+)
+
+// GetSessionActivity returns time-bucketed message counts for a
+// session, using PostgreSQL-specific timestamp functions.
+func (s *Store) GetSessionActivity(
+	ctx context.Context, sessionID string,
+) (*db.SessionActivityResponse, error) {
+	// 1. Count total messages (ALL, including system).
+	var totalMessages int
+	err := s.pg.QueryRowContext(ctx,
+		"SELECT COUNT(*) FROM messages WHERE session_id = $1",
+		sessionID,
+	).Scan(&totalMessages)
+	if err != nil {
+		return nil, fmt.Errorf("counting messages: %w", err)
+	}
+
+	// 2. Visible-message filter (same as SQLite).
+	visFilter := "m.is_system = FALSE AND " +
+		db.SystemPrefixSQL("m.content", "m.role")
+
+	// 3. Get min/max timestamps from visible messages.
+	// PG stores timestamp as TIMESTAMPTZ, so scan into *time.Time.
+	var minTS, maxTS *time.Time
+	err = s.pg.QueryRowContext(ctx, `
+		SELECT MIN(m.timestamp), MAX(m.timestamp)
+		FROM messages m
+		WHERE m.session_id = $1
+			AND m.timestamp IS NOT NULL
+			AND `+visFilter,
+		sessionID,
+	).Scan(&minTS, &maxTS)
+	if err != nil {
+		return nil, fmt.Errorf("getting timestamp range: %w", err)
+	}
+
+	if minTS == nil || maxTS == nil {
+		return &db.SessionActivityResponse{
+			Buckets:       []db.SessionActivityBucket{},
+			TotalMessages: totalMessages,
+		}, nil
+	}
+
+	// Use floor of min timestamp as anchor so bucket boundaries
+	// align to whole seconds. Compute duration from exact values
+	// to preserve sub-second precision.
+	epochMin := minTS.Unix()
+	durationSec := int64(maxTS.Sub(*minTS).Seconds())
+	interval := db.SnapInterval(durationSec)
+
+	// 4. Bucket query with PG-specific EXTRACT(EPOCH FROM ...).
+	// Use floor() on the float division to handle sub-second
+	// timestamps correctly — integer truncation via ::bigint on
+	// the difference can shift messages near bucket boundaries.
+	rows, err := s.pg.QueryContext(ctx, `
+		SELECT
+			floor((EXTRACT(EPOCH FROM m.timestamp) - $1) / $2)::bigint
+				AS bucket,
+			SUM(CASE WHEN m.role = 'user'
+				THEN 1 ELSE 0 END)::int,
+			SUM(CASE WHEN m.role = 'assistant'
+				THEN 1 ELSE 0 END)::int,
+			MIN(m.ordinal)
+		FROM messages m
+		WHERE m.session_id = $3
+			AND m.timestamp IS NOT NULL
+			AND `+visFilter+`
+		GROUP BY bucket
+		ORDER BY bucket ASC`,
+		epochMin, interval, sessionID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("bucketing activity: %w", err)
+	}
+	defer rows.Close()
+
+	// 5. Collect populated buckets.
+	type rawBucket struct {
+		idx      int64
+		userCt   int
+		asstCt   int
+		firstOrd int
+	}
+	populated := map[int64]rawBucket{}
+	var maxIdx int64
+	for rows.Next() {
+		var rb rawBucket
+		if err := rows.Scan(
+			&rb.idx, &rb.userCt, &rb.asstCt, &rb.firstOrd,
+		); err != nil {
+			return nil, fmt.Errorf("scanning bucket: %w", err)
+		}
+		populated[rb.idx] = rb
+		if rb.idx > maxIdx {
+			maxIdx = rb.idx
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	if len(populated) == 0 {
+		return &db.SessionActivityResponse{
+			Buckets:         []db.SessionActivityBucket{},
+			IntervalSeconds: interval,
+			TotalMessages:   totalMessages,
+		}, nil
+	}
+
+	// 6. Build full bucket array with empty gaps.
+	buckets := make(
+		[]db.SessionActivityBucket, 0, maxIdx+1,
+	)
+	for i := int64(0); i <= maxIdx; i++ {
+		start := time.Unix(epochMin+i*interval, 0).UTC()
+		end := time.Unix(
+			epochMin+(i+1)*interval, 0,
+		).UTC()
+		b := db.SessionActivityBucket{
+			StartTime: start.Format(time.RFC3339),
+			EndTime:   end.Format(time.RFC3339),
+		}
+		if rb, ok := populated[i]; ok {
+			b.UserCount = rb.userCt
+			b.AssistantCount = rb.asstCt
+			ord := rb.firstOrd
+			b.FirstOrdinal = &ord
+		}
+		buckets = append(buckets, b)
+	}
+
+	return &db.SessionActivityResponse{
+		Buckets:         buckets,
+		IntervalSeconds: interval,
+		TotalMessages:   totalMessages,
+	}, nil
+}
diff --git a/internal/postgres/messages.go b/internal/postgres/messages.go
index 2dcd18ee..b2b30c41 100644
--- a/internal/postgres/messages.go
+++ b/internal/postgres/messages.go
@@ -85,48 +85,6 @@ func (s *Store) GetAllMessages(
 	return msgs, nil
 }
 
-// GetMinimap returns lightweight metadata for all messages
-// in a session.
-func (s *Store) GetMinimap(
-	ctx context.Context, sessionID string,
-) ([]db.MinimapEntry, error) {
-	return s.GetMinimapFrom(ctx, sessionID, 0)
-}
-
-// GetMinimapFrom returns lightweight metadata for messages
-// starting at ordinal >= from.
-func (s *Store) GetMinimapFrom(
-	ctx context.Context, sessionID string, from int,
-) ([]db.MinimapEntry, error) {
-	rows, err := s.pg.QueryContext(ctx, `
-		SELECT ordinal, role, content_length,
-			has_thinking, has_tool_use
-		FROM messages
-		WHERE session_id = $1 AND ordinal >= $2
-		ORDER BY ordinal ASC`, sessionID, from)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"querying minimap: %w", err,
-		)
-	}
-	defer rows.Close()
-
-	entries := []db.MinimapEntry{}
-	for rows.Next() {
-		var e db.MinimapEntry
-		if err := rows.Scan(
-			&e.Ordinal, &e.Role, &e.ContentLength,
-			&e.HasThinking, &e.HasToolUse,
-		); err != nil {
-			return nil, fmt.Errorf(
-				"scanning minimap entry: %w", err,
-			)
-		}
-		entries = append(entries, e)
-	}
-	return entries, rows.Err()
-}
-
 // SearchSession performs ILIKE substring search within a single
 // session's messages, returning matching ordinals.
 func (s *Store) SearchSession(
diff --git a/internal/postgres/store_test.go b/internal/postgres/store_test.go
index f7cf0d65..a11e4f10 100644
--- a/internal/postgres/store_test.go
+++ b/internal/postgres/store_test.go
@@ -257,7 +257,7 @@ func TestStoreSearch(t *testing.T) {
 	t.Logf("search results: %d", len(page.Results))
 }
 
-func TestStoreGetMinimap(t *testing.T) {
+func TestStoreAnalyticsSummary(t *testing.T) {
 	pgURL := testPGURL(t)
 	ensureStoreSchema(t, pgURL)
 
@@ -268,18 +268,80 @@ func TestStoreGetMinimap(t *testing.T) {
 	defer store.Close()
 
 	ctx := context.Background()
-	entries, err := store.GetMinimap(
-		ctx, "store-test-001",
+	summary, err := store.GetAnalyticsSummary(
+		ctx, db.AnalyticsFilter{
+			From: "2026-01-01",
+			To:   "2026-12-31",
+		},
 	)
 	if err != nil {
-		t.Fatalf("GetMinimap: %v", err)
+		t.Fatalf("GetAnalyticsSummary: %v", err)
 	}
-	if len(entries) != 2 {
-		t.Errorf("got %d entries, want 2", len(entries))
+	if summary.TotalSessions == 0 {
+		t.Error("expected at least 1 session in summary")
 	}
+	t.Logf("summary: %+v", summary)
 }
 
-func TestStoreAnalyticsSummary(t *testing.T) {
+func seedActivitySession(
+	t *testing.T, store *Store, sid string, msgs []struct {
+		ordinal int
+		role    string
+		content string
+		ts      string
+		system  bool
+	},
+) {
+	t.Helper()
+	pg := store.DB()
+
+	// PG doesn't allow multi-statement prepared queries,
+	// so run each statement separately.
+	if _, err := pg.Exec(
+		`DELETE FROM messages WHERE session_id = $1`, sid,
+	); err != nil {
+		t.Fatalf("deleting messages: %v", err)
+	}
+	if _, err := pg.Exec(
+		`DELETE FROM sessions WHERE id = $1`, sid,
+	); err != nil {
+		t.Fatalf("deleting session: %v", err)
+	}
+	if _, err := pg.Exec(`
+		INSERT INTO sessions
+			(id, machine, project, agent, first_message,
+			 started_at, ended_at, message_count,
+			 user_message_count)
+		VALUES
+			($1, 'test-machine', 'test-project',
+			 'claude', 'activity test',
+			 '2026-03-26T10:00:00Z'::timestamptz,
+			 '2026-03-26T11:00:00Z'::timestamptz,
+			 $2, 0)
+	`, sid, len(msgs)); err != nil {
+		t.Fatalf("inserting session: %v", err)
+	}
+
+	for _, m := range msgs {
+		var tsVal interface{} = nil
+		if m.ts != "" {
+			tsVal = m.ts
+		}
+		if _, err := pg.Exec(`
+			INSERT INTO messages
+				(session_id, ordinal, role, content,
+				 timestamp, content_length, is_system)
+			VALUES ($1, $2, $3, $4,
+				$5::timestamptz, $6, $7)
+		`, sid, m.ordinal, m.role, m.content,
+			tsVal, len(m.content), m.system); err != nil {
+			t.Fatalf("inserting message ord=%d: %v",
+				m.ordinal, err)
+		}
+	}
+}
+
+func TestStoreGetSessionActivity(t *testing.T) {
 	pgURL := testPGURL(t)
 	ensureStoreSchema(t, pgURL)
 
@@ -289,20 +351,291 @@ func TestStoreAnalyticsSummary(t *testing.T) {
 	}
 	defer store.Close()
 
+	sid := "store-test-activity"
+	seedActivitySession(t, store, sid, []struct {
+		ordinal int
+		role    string
+		content string
+		ts      string
+		system  bool
+	}{
+		{0, "user", "hello", "2026-03-26T10:00:00Z", false},
+		{1, "assistant", "hi", "2026-03-26T10:00:30Z", false},
+		{2, "user", "next", "2026-03-26T10:01:30Z", false},
+		{3, "assistant", "resp", "2026-03-26T10:02:00Z", false},
+		{4, "user", "back", "2026-03-26T10:28:00Z", false},
+		{5, "assistant", "wb", "2026-03-26T10:29:00Z", false},
+		// System message — excluded from buckets.
+		{6, "user", "This session is being continued from a previous conversation.", "2026-03-26T10:29:30Z", true},
+	})
+
 	ctx := context.Background()
-	summary, err := store.GetAnalyticsSummary(
-		ctx, db.AnalyticsFilter{
-			From: "2026-01-01",
-			To:   "2026-12-31",
-		},
+	resp, err := store.GetSessionActivity(ctx, sid)
+	if err != nil {
+		t.Fatalf("GetSessionActivity: %v", err)
+	}
+
+	if resp.IntervalSeconds != 60 {
+		t.Errorf("interval = %d, want 60",
+			resp.IntervalSeconds)
+	}
+
+	if resp.TotalMessages != 7 {
+		t.Errorf("total = %d, want 7",
+			resp.TotalMessages)
+	}
+
+	if len(resp.Buckets) < 28 {
+		t.Errorf("bucket count = %d, want >= 28",
+			len(resp.Buckets))
+	}
+
+	first := resp.Buckets[0]
+	if first.UserCount != 1 || first.AssistantCount != 1 {
+		t.Errorf("first bucket: user=%d asst=%d, want 1,1",
+			first.UserCount, first.AssistantCount)
+	}
+	if first.FirstOrdinal == nil || *first.FirstOrdinal != 0 {
+		t.Errorf("first bucket first_ordinal: got %v, want 0",
+			first.FirstOrdinal)
+	}
+
+	mid := resp.Buckets[15]
+	if mid.UserCount != 0 || mid.AssistantCount != 0 {
+		t.Errorf("mid bucket: user=%d asst=%d, want 0,0",
+			mid.UserCount, mid.AssistantCount)
+	}
+	if mid.FirstOrdinal != nil {
+		t.Errorf("mid bucket first_ordinal: got %v, want nil",
+			mid.FirstOrdinal)
+	}
+}
+
+func TestStoreGetSessionActivity_NoMessages(t *testing.T) {
+	pgURL := testPGURL(t)
+	ensureStoreSchema(t, pgURL)
+
+	store, err := NewStore(pgURL, testSchema, true)
+	if err != nil {
+		t.Fatalf("NewStore: %v", err)
+	}
+	defer store.Close()
+
+	sid := "store-test-activity-empty"
+	seedActivitySession(t, store, sid, nil)
+
+	resp, err := store.GetSessionActivity(
+		context.Background(), sid,
 	)
 	if err != nil {
-		t.Fatalf("GetAnalyticsSummary: %v", err)
+		t.Fatalf("GetSessionActivity: %v", err)
 	}
-	if summary.TotalSessions == 0 {
-		t.Error("expected at least 1 session in summary")
+	if len(resp.Buckets) != 0 {
+		t.Errorf("buckets = %d, want 0",
+			len(resp.Buckets))
+	}
+}
+
+func TestStoreGetSessionActivity_NullTimestamps(
+	t *testing.T,
+) {
+	pgURL := testPGURL(t)
+	ensureStoreSchema(t, pgURL)
+
+	store, err := NewStore(pgURL, testSchema, true)
+	if err != nil {
+		t.Fatalf("NewStore: %v", err)
+	}
+	defer store.Close()
+
+	sid := "store-test-activity-nullts"
+	seedActivitySession(t, store, sid, []struct {
+		ordinal int
+		role    string
+		content string
+		ts      string
+		system  bool
+	}{
+		{0, "user", "hi", "", false},
+		{1, "assistant", "hello", "", false},
+	})
+
+	resp, err := store.GetSessionActivity(
+		context.Background(), sid,
+	)
+	if err != nil {
+		t.Fatalf("GetSessionActivity: %v", err)
+	}
+	if len(resp.Buckets) != 0 {
+		t.Errorf("buckets = %d, want 0",
+			len(resp.Buckets))
+	}
+	if resp.TotalMessages != 2 {
+		t.Errorf("total = %d, want 2",
+			resp.TotalMessages)
+	}
+}
+
+func TestStoreGetSessionActivity_SingleMessage(
+	t *testing.T,
+) {
+	pgURL := testPGURL(t)
+	ensureStoreSchema(t, pgURL)
+
+	store, err := NewStore(pgURL, testSchema, true)
+	if err != nil {
+		t.Fatalf("NewStore: %v", err)
+	}
+	defer store.Close()
+
+	sid := "store-test-activity-single"
+	seedActivitySession(t, store, sid, []struct {
+		ordinal int
+		role    string
+		content string
+		ts      string
+		system  bool
+	}{
+		{0, "user", "hi", "2026-03-26T10:00:00Z", false},
+	})
+
+	resp, err := store.GetSessionActivity(
+		context.Background(), sid,
+	)
+	if err != nil {
+		t.Fatalf("GetSessionActivity: %v", err)
+	}
+	if len(resp.Buckets) != 1 {
+		t.Fatalf("buckets = %d, want 1",
+			len(resp.Buckets))
+	}
+	if resp.Buckets[0].UserCount != 1 {
+		t.Errorf("user count = %d, want 1",
+			resp.Buckets[0].UserCount)
+	}
+}
+
+func TestStoreGetSessionActivity_PrefixInjectedExcluded(
+	t *testing.T,
+) {
+	pgURL := testPGURL(t)
+	ensureStoreSchema(t, pgURL)
+
+	store, err := NewStore(pgURL, testSchema, true)
+	if err != nil {
+		t.Fatalf("NewStore: %v", err)
+	}
+	defer store.Close()
+
+	sid := "store-test-activity-prefix"
+	seedActivitySession(t, store, sid, []struct {
+		ordinal int
+		role    string
+		content string
+		ts      string
+		system  bool
+	}{
+		{0, "user", "hello", "2026-03-26T10:00:00Z", false},
+		{1, "assistant", "hi", "2026-03-26T10:00:30Z", false},
+		// Prefix-detected injected message: is_system=false but
+		// content starts with a system prefix.
+		{2, "user", "This session is being continued from a previous conversation.", "2026-03-26T10:01:00Z", false},
+	})
+
+	ctx := context.Background()
+	resp, err := store.GetSessionActivity(ctx, sid)
+	if err != nil {
+		t.Fatalf("GetSessionActivity: %v", err)
+	}
+
+	// The prefix-detected message should be excluded from
+	// buckets but still count toward TotalMessages.
+	if resp.TotalMessages != 3 {
+		t.Errorf("total = %d, want 3",
+			resp.TotalMessages)
+	}
+
+	// Only ordinals 0 and 1 should appear in buckets.
+	totalBucketed := 0
+	for _, b := range resp.Buckets {
+		totalBucketed += b.UserCount + b.AssistantCount
+	}
+	if totalBucketed != 2 {
+		t.Errorf("bucketed messages = %d, want 2",
+			totalBucketed)
+	}
+
+	// The excluded message at 10:01:00 must not extend the
+	// timestamp range. With only 10:00:00-10:00:30 visible,
+	// a single bucket should cover the entire span.
+	if len(resp.Buckets) != 1 {
+		t.Errorf("bucket count = %d, want 1",
+			len(resp.Buckets))
+	}
+}
+
+func TestStoreGetSessionActivity_FractionalTimestamps(
+	t *testing.T,
+) {
+	pgURL := testPGURL(t)
+	ensureStoreSchema(t, pgURL)
+
+	store, err := NewStore(pgURL, testSchema, true)
+	if err != nil {
+		t.Fatalf("NewStore: %v", err)
+	}
+	defer store.Close()
+
+	sid := "store-test-frac-ts"
+	seedActivitySession(t, store, sid, []struct {
+		ordinal int
+		role    string
+		content string
+		ts      string
+		system  bool
+	}{
+		{0, "user", "a", "2026-03-26T10:00:00.900Z", false},
+		{1, "assistant", "b", "2026-03-26T10:00:59.100Z", false},
+		{2, "user", "c", "2026-03-26T10:01:01.000Z", false},
+	})
+
+	ctx := context.Background()
+	resp, err := store.GetSessionActivity(ctx, sid)
+	if err != nil {
+		t.Fatalf("GetSessionActivity: %v", err)
+	}
+
+	if resp.IntervalSeconds != 60 {
+		t.Fatalf(
+			"interval = %d, want 60",
+			resp.IntervalSeconds,
+		)
+	}
+
+	if len(resp.Buckets) < 2 {
+		t.Fatalf(
+			"buckets = %d, want >= 2",
+			len(resp.Buckets),
+		)
+	}
+
+	// First bucket should have both sub-second messages.
+	first := resp.Buckets[0]
+	if first.UserCount != 1 || first.AssistantCount != 1 {
+		t.Errorf(
+			"first bucket: user=%d asst=%d, want 1,1",
+			first.UserCount, first.AssistantCount,
+		)
+	}
+
+	// Second bucket should have the third message.
+	second := resp.Buckets[1]
+	if second.UserCount != 1 {
+		t.Errorf(
+			"second bucket user=%d, want 1",
+			second.UserCount,
+		)
 	}
-	t.Logf("summary: %+v", summary)
 }
 
 func TestStoreWriteMethodsReturnReadOnly(t *testing.T) {
diff --git a/internal/server/activity.go b/internal/server/activity.go
new file mode 100644
index 00000000..fbdc35ba
--- /dev/null
+++ b/internal/server/activity.go
@@ -0,0 +1,25 @@
+package server
+
+import "net/http"
+
+// handleGetSessionActivity returns time-bucketed message counts.
+func (s *Server) handleGetSessionActivity(
+	w http.ResponseWriter, r *http.Request,
+) {
+	sessionID := r.PathValue("id")
+
+	resp, err := s.db.GetSessionActivity(
+		r.Context(), sessionID,
+	)
+	if err != nil {
+		if handleContextError(w, err) {
+			return
+		}
+		writeError(
+			w, http.StatusInternalServerError, err.Error(),
+		)
+		return
+	}
+
+	writeJSON(w, http.StatusOK, resp)
+}
diff --git a/internal/server/activity_test.go b/internal/server/activity_test.go
new file mode 100644
index 00000000..7fd2620a
--- /dev/null
+++ b/internal/server/activity_test.go
@@ -0,0 +1,52 @@
+package server_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/wesm/agentsview/internal/db"
+)
+
+func TestGetSessionActivity(t *testing.T) {
+	te := setup(t)
+	te.seedSession(t, "s1", "my-app", 10)
+	te.seedMessages(t, "s1", 10)
+
+	w := te.get(t, "/api/v1/sessions/s1/activity")
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", w.Code)
+	}
+
+	var body db.SessionActivityResponse
+	if err := json.NewDecoder(w.Body).Decode(&body); err != nil {
+		t.Fatal(err)
+	}
+
+	if body.TotalMessages == 0 {
+		t.Error("expected non-zero total_messages")
+	}
+	if len(body.Buckets) == 0 {
+		t.Error("expected non-empty buckets")
+	}
+	if body.IntervalSeconds <= 0 {
+		t.Error("expected positive interval_seconds")
+	}
+}
+
+func TestGetSessionActivity_NotFound(t *testing.T) {
+	te := setup(t)
+
+	w := te.get(t, "/api/v1/sessions/nonexistent/activity")
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", w.Code)
+	}
+
+	var body db.SessionActivityResponse
+	if err := json.NewDecoder(w.Body).Decode(&body); err != nil {
+		t.Fatal(err)
+	}
+	if len(body.Buckets) != 0 {
+		t.Error("expected empty buckets for nonexistent session")
+	}
+}
diff --git a/internal/server/deadline_internal_test.go b/internal/server/deadline_internal_test.go
index 213c455b..beea4864 100644
--- a/internal/server/deadline_internal_test.go
+++ b/internal/server/deadline_internal_test.go
@@ -32,11 +32,11 @@ func TestHandlers_Internal_DeadlineExceeded(t *testing.T) {
 		{"ListSessions", s.handleListSessions, false},
 		{"GetSession", s.handleGetSession, false},
 		{"GetMessages", s.handleGetMessages, false},
-		{"GetMinimap", s.handleGetMinimap, false},
 		{"GetStats", s.handleGetStats, false},
 		{"ListProjects", s.handleListProjects, false},
 		{"ListMachines", s.handleListMachines, false},
 		{"Search", s.handleSearch, true},
+		{"GetSessionActivity", s.handleGetSessionActivity, false},
 	}
 
 	for _, tt := range tests {
diff --git a/internal/server/deadline_test.go b/internal/server/deadline_test.go
index 4cf0a202..18add993 100644
--- a/internal/server/deadline_test.go
+++ b/internal/server/deadline_test.go
@@ -21,10 +21,10 @@ func TestMiddleware_Timeout(t *testing.T) {
 		{"ListSessions", http.MethodGet, "/api/v1/sessions"},
 		{"GetSession", http.MethodGet, "/api/v1/sessions/s1"},
 		{"GetMessages", http.MethodGet, "/api/v1/sessions/s1/messages"},
-		{"GetMinimap", http.MethodGet, "/api/v1/sessions/s1/minimap"},
 		{"GetStats", http.MethodGet, "/api/v1/stats"},
 		{"ListProjects", http.MethodGet, "/api/v1/projects"},
 		{"ListMachines", http.MethodGet, "/api/v1/machines"},
+		{"GetSessionActivity", http.MethodGet, "/api/v1/sessions/s1/activity"},
 	}
 
 	for _, tt := range tests {
diff --git a/internal/server/messages.go b/internal/server/messages.go
index 9346e9e4..3c2e7c3b 100644
--- a/internal/server/messages.go
+++ b/internal/server/messages.go
@@ -48,48 +48,3 @@ func (s *Server) handleGetMessages(
 	})
 }
 
-func (s *Server) handleGetMinimap(
-	w http.ResponseWriter, r *http.Request,
-) {
-	sessionID := r.PathValue("id")
-	from := 0
-	if r.URL.Query().Get("from") != "" {
-		var ok bool
-		from, ok = parseIntParam(w, r, "from")
-		if !ok {
-			return
-		}
-	}
-	max := 0
-	if r.URL.Query().Get("max") != "" {
-		var ok bool
-		max, ok = parseIntParam(w, r, "max")
-		if !ok {
-			return
-		}
-		if max <= 0 {
-			writeError(w, http.StatusBadRequest,
-				"invalid max parameter")
-			return
-		}
-	}
-
-	entries, err := s.db.GetMinimapFrom(
-		r.Context(), sessionID, from,
-	)
-	if err != nil {
-		if handleContextError(w, err) {
-			return
-		}
-		writeError(w, http.StatusInternalServerError, err.Error())
-		return
-	}
-	if max > 0 {
-		entries = dbpkg.SampleMinimap(entries, max)
-	}
-
-	writeJSON(w, http.StatusOK, map[string]any{
-		"entries": entries,
-		"count":   len(entries),
-	})
-}
diff --git a/internal/server/server.go b/internal/server/server.go
index b6f5c848..1238d3ca 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -165,7 +165,7 @@ func (s *Server) routes() {
 		"GET /api/v1/sessions/{id}/children", s.withTimeout(s.handleGetChildSessions),
 	)
 	s.mux.Handle(
-		"GET /api/v1/sessions/{id}/minimap", s.withTimeout(s.handleGetMinimap),
+		"GET /api/v1/sessions/{id}/activity", s.withTimeout(s.handleGetSessionActivity),
 	)
 	// SSE: Do not use timeout, as this is a long-lived connection.
 	s.mux.HandleFunc(
diff --git a/internal/server/server_test.go b/internal/server/server_test.go
index e86e621a..7580a2c3 100644
--- a/internal/server/server_test.go
+++ b/internal/server/server_test.go
@@ -567,11 +567,6 @@ type messageListResponse struct {
 	Count    int          `json:"count"`
 }
 
-type minimapResponse struct {
-	Entries []db.MinimapEntry `json:"entries"`
-	Count   int               `json:"count"`
-}
-
 type searchResponse struct {
 	Query   string            `json:"query"`
 	Results []db.SearchResult `json:"results"`
@@ -948,103 +943,6 @@ func TestSearch_InvalidParams(t *testing.T) {
 	}
 }
 
-func TestGetMinimap(t *testing.T) {
-	te := setup(t)
-	te.seedSession(t, "s1", "my-app", 5)
-	te.seedMessages(t, "s1", 5)
-
-	w := te.get(t, "/api/v1/sessions/s1/minimap")
-	assertStatus(t, w, http.StatusOK)
-
-	resp := decode[minimapResponse](t, w)
-	if len(resp.Entries) != 5 {
-		t.Fatalf("expected 5 entries, got %d",
-			len(resp.Entries))
-	}
-	if resp.Entries[0].Role == "" {
-		t.Fatal("minimap should include role")
-	}
-
-	// Verify "content" is not present in raw JSON
-	var raw map[string]any
-	if err := json.Unmarshal(w.Body.Bytes(), &raw); err != nil {
-		t.Fatalf("decoding raw JSON: %v", err)
-	}
-	entriesRaw, ok := raw["entries"].([]any)
-	if !ok {
-		t.Fatal("expected entries to be a list")
-	}
-	if len(entriesRaw) > 0 {
-		first, ok := entriesRaw[0].(map[string]any)
-		if !ok {
-			t.Fatal("expected entry to be a map")
-		}
-		if _, ok := first["content"]; ok {
-			t.Fatal("minimap should not include content")
-		}
-	}
-}
-
-func TestGetMinimap_FromOrdinal(t *testing.T) {
-	te := setup(t)
-	te.seedSession(t, "s1", "my-app", 5)
-	te.seedMessages(t, "s1", 5)
-
-	w := te.get(t, "/api/v1/sessions/s1/minimap?from=3")
-	assertStatus(t, w, http.StatusOK)
-
-	resp := decode[minimapResponse](t, w)
-	if len(resp.Entries) != 2 {
-		t.Fatalf("expected 2 entries, got %d",
-			len(resp.Entries))
-	}
-	if got := resp.Entries[0].Ordinal; got != 3 {
-		t.Fatalf("first ordinal = %d, want 3", got)
-	}
-}
-
-func TestGetMinimap_InvalidFrom(t *testing.T) {
-	te := setup(t)
-	te.seedSession(t, "s1", "my-app", 1)
-	te.seedMessages(t, "s1", 1)
-
-	w := te.get(t, "/api/v1/sessions/s1/minimap?from=bad")
-	assertStatus(t, w, http.StatusBadRequest)
-}
-
-func TestGetMinimap_MaxSampled(t *testing.T) {
-	te := setup(t)
-	te.seedSession(t, "s1", "my-app", 10)
-	te.seedMessages(t, "s1", 10)
-
-	w := te.get(t, "/api/v1/sessions/s1/minimap?max=3")
-	assertStatus(t, w, http.StatusOK)
-
-	resp := decode[minimapResponse](t, w)
-	if len(resp.Entries) != 3 {
-		t.Fatalf("expected 3 entries, got %d",
-			len(resp.Entries))
-	}
-	if got := resp.Entries[0].Ordinal; got != 0 {
-		t.Fatalf("first ordinal = %d, want 0", got)
-	}
-	if got := resp.Entries[1].Ordinal; got != 4 {
-		t.Fatalf("second ordinal = %d, want 4", got)
-	}
-	if got := resp.Entries[2].Ordinal; got != 9 {
-		t.Fatalf("third ordinal = %d, want 9", got)
-	}
-}
-
-func TestGetMinimap_InvalidMax(t *testing.T) {
-	te := setup(t)
-	te.seedSession(t, "s1", "my-app", 1)
-	te.seedMessages(t, "s1", 1)
-
-	w := te.get(t, "/api/v1/sessions/s1/minimap?max=0")
-	assertStatus(t, w, http.StatusBadRequest)
-}
-
 func TestSearch_WithResults(t *testing.T) {
 	te := setup(t)
 	if !te.db.HasFTS() {