diff --git a/cmd/agentsview/activity.go b/cmd/agentsview/activity.go
index 3bcb40679..1987cd7eb 100644
--- a/cmd/agentsview/activity.go
+++ b/cmd/agentsview/activity.go
@@ -17,7 +17,6 @@ import (
 	"go.kenn.io/agentsview/internal/db"
 )
 
-// ActivityReportConfig holds the flags for `agentsview activity report`.
 type ActivityReportConfig struct {
 	Preset   string
 	Date     string
@@ -33,7 +32,6 @@ type ActivityReportConfig struct {
 	Offline  bool
 }
 
-// runActivityReport syncs, resolves the range, runs the report, and prints it.
 func runActivityReport(cfg ActivityReportConfig) {
 	ctx := context.Background()
 	backend, cleanup, err := resolveArchiveQueryBackend(ctx, archiveQueryPolicy{
@@ -180,9 +178,6 @@ func todayIn(tz string) string {
 	return time.Now().In(loc).Format("2006-01-02")
 }
 
-// printActivityReport renders the human-readable report: a header, totals,
-// peak concurrency, top breakdowns, and top sessions. It deliberately omits
-// the dense per-bucket timeline, which only the --json output exposes.
 func printActivityReport(r activity.Report) {
 	loc, err := time.LoadLocation(r.Timezone)
 	if err != nil {
@@ -205,10 +200,10 @@ func printActivityReport(r activity.Report) {
 	printKeyMinutes("By project", r.ByProject)
 	printKeyMinutes("By model", r.ByModel)
 	printKeyMinutes("By agent", r.ByAgent)
+	printBranchKeyMinutes("By branch", r.ByBranch)
 	printActivitySessions(r.BySession)
 }
 
-// printActivityTotals prints the totals block via a tabwriter.
 func printActivityTotals(t activity.Totals) {
 	w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
 	fmt.Fprintf(w, "Active minutes\t%.1f\n", t.ActiveMinutes)
@@ -222,14 +217,24 @@ func printActivityTotals(t activity.Totals) {
 	w.Flush()
 }
 
-// printActivityPeak prints peak concurrency and when it occurred, in loc.
 func printActivityPeak(p activity.Peak, loc *time.Location) {
 	fmt.Printf("Peak concurrency: %d agents at %s\n",
 		p.Agents, fmtInstant(p.At, loc))
 }
 
-// printKeyMinutes prints the top 5 rows of a key/agent-minutes breakdown.
 func printKeyMinutes(label string, rows []activity.KeyMinutes) {
+	printLabeledKeyMinutes(label, rows, nil)
+}
+
+func printBranchKeyMinutes(label string, rows []activity.KeyMinutes) {
+	printLabeledKeyMinutes(label, rows, activity.BranchKeyLabel)
+}
+
+func printLabeledKeyMinutes(
+	label string,
+	rows []activity.KeyMinutes,
+	labelKey func(string) string,
+) {
 	fmt.Printf("%s (top 5):\n", label)
 	if len(rows) == 0 {
 		fmt.Println("  (none)")
@@ -238,14 +243,17 @@ func printKeyMinutes(label string, rows []activity.KeyMinutes) {
 	}
 	w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
 	for _, row := range topKeyMinutes(rows, 5) {
+		key := row.Key
+		if labelKey != nil {
+			key = labelKey(key)
+		}
 		fmt.Fprintf(w, "  %s\t%.1f min\n",
-			sanitizeTerminal(row.Key), row.AgentMinutes)
+			sanitizeTerminal(key), row.AgentMinutes)
 	}
 	w.Flush()
 	fmt.Println()
 }
 
-// printActivitySessions prints the top 5 sessions by appearance order.
 func printActivitySessions(rows []activity.SessionRow) {
 	fmt.Println("Top sessions (top 5):")
 	if len(rows) == 0 {
@@ -265,7 +273,6 @@ func printActivitySessions(rows []activity.SessionRow) {
 	w.Flush()
 }
 
-// topKeyMinutes returns the first n rows of rows (already sorted by the query).
 func topKeyMinutes(rows []activity.KeyMinutes, n int) []activity.KeyMinutes {
 	return rows[:min(len(rows), n)]
 }
@@ -284,8 +291,6 @@ func fmtRangeBound(ts string, loc *time.Location) string {
 	return t.Format("2006-01-02 15:04")
 }
 
-// fmtMinutes renders an agent-minutes value, printing a dash for untimed
-// sessions whose pointer is nil.
 func fmtMinutes(m *float64) string {
 	if m == nil {
 		return "—"
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 1af05cef1..0502eabda 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -778,6 +778,7 @@
   "activity_project": "Project",
   "activity_model": "Model",
   "activity_agent": "Agent",
+  "activity_branch": "Branch",
   "activity_min_unit": " min",
   "activity_int_auto_split": "int {int} / auto {auto}",
   "activity_breakdown": "Breakdown",
diff --git a/frontend/messages/zh-CN.json b/frontend/messages/zh-CN.json
index 9bad54a70..0362577bf 100644
--- a/frontend/messages/zh-CN.json
+++ b/frontend/messages/zh-CN.json
@@ -757,6 +757,7 @@
   "activity_project": "项目",
   "activity_model": "模型",
   "activity_agent": "代理",
+  "activity_branch": "分支",
   "activity_min_unit": " 分钟",
   "activity_int_auto_split": "交互 {int} / 自动 {auto}",
   "activity_breakdown": "细分",
diff --git a/frontend/src/lib/api/generated/models/ActivityReport.ts b/frontend/src/lib/api/generated/models/ActivityReport.ts
index fd1923026..fb3c55804 100644
--- a/frontend/src/lib/api/generated/models/ActivityReport.ts
+++ b/frontend/src/lib/api/generated/models/ActivityReport.ts
@@ -11,6 +11,7 @@ export type ActivityReport = {
   bucket_unit: string;
   buckets: any[] | null;
   by_agent: any[] | null;
+  by_branch: any[] | null;
   by_model: any[] | null;
   by_project: any[] | null;
   by_session: any[] | null;
diff --git a/frontend/src/lib/api/types/activity.ts b/frontend/src/lib/api/types/activity.ts
index 94e34597e..e58975775 100644
--- a/frontend/src/lib/api/types/activity.ts
+++ b/frontend/src/lib/api/types/activity.ts
@@ -6,8 +6,55 @@ import type {
   ActivityKeyMinutes,
 } from "../generated/index";
 
-export type Report = ActivityReport;
 export type Bucket = ActivityBucket;
 export type ReportInterval = ActivityReportInterval;
-export type SessionRow = ActivitySessionRow;
+export type SessionRow = Omit<ActivitySessionRow, "models"> & {
+  models: string[] | null;
+};
 export type KeyMinutes = ActivityKeyMinutes;
+
+export type Report = Omit<
+  ActivityReport,
+  | "buckets"
+  | "by_agent"
+  | "by_branch"
+  | "by_model"
+  | "by_project"
+  | "by_session"
+  | "intervals"
+> & {
+  buckets: Bucket[] | null;
+  by_agent: KeyMinutes[] | null;
+  by_branch: KeyMinutes[] | null;
+  by_model: KeyMinutes[] | null;
+  by_project: KeyMinutes[] | null;
+  by_session: SessionRow[] | null;
+  intervals: ReportInterval[] | null;
+};
+
+function generatedRows<T>(rows: unknown): T[] | null {
+  if (!Array.isArray(rows)) return null;
+  return rows as T[];
+}
+
+function sessionRowsFromGenerated(rows: unknown): SessionRow[] | null {
+  const sessions = generatedRows<ActivitySessionRow>(rows);
+  if (sessions === null) return null;
+  return sessions.map((session) => ({
+    ...session,
+    models: generatedRows<string>(session.models),
+  }));
+}
+
+export function activityReportFromGenerated(report: ActivityReport): Report {
+  return {
+    ...report,
+    buckets: generatedRows<Bucket>(report.buckets),
+    by_agent: generatedRows<KeyMinutes>(report.by_agent),
+    by_branch: generatedRows<KeyMinutes>(report.by_branch),
+    by_model: generatedRows<KeyMinutes>(report.by_model),
+    by_project: generatedRows<KeyMinutes>(report.by_project),
+    by_session: sessionRowsFromGenerated(report.by_session),
+    intervals: generatedRows<ReportInterval>(report.intervals),
+  };
+}
diff --git a/frontend/src/lib/components/activity/Breakdowns.svelte b/frontend/src/lib/components/activity/Breakdowns.svelte
index 104c961d6..90f31a616 100644
--- a/frontend/src/lib/components/activity/Breakdowns.svelte
+++ b/frontend/src/lib/components/activity/Breakdowns.svelte
@@ -1,41 +1,29 @@
 <script lang="ts">
   import { m } from "../../i18n/index.js";
-  import type { Report } from "../../api/types.js";
-  import type { ActivityKeyMinutes } from "../../api/generated/index";
+  import type { KeyMinutes, Report } from "../../api/types.js";
+  import { branchTokenLabel } from "../../branchFilters.js";
 
   let { report }: { report: Report } = $props();
 
   type Metric = "minutes" | "cost";
   let metric = $state<Metric>("minutes");
 
-  // by_* fields are typed `any[] | null` by the codegen; cast each
-  // to the generated element model for field-level type safety.
-  function asKeyMinutes(arr: any[] | null): ActivityKeyMinutes[] {
-    return (arr ?? []) as ActivityKeyMinutes[];
-  }
-
-  function rowValue(row: ActivityKeyMinutes): number {
+  function rowValue(row: KeyMinutes): number {
     return metric === "cost" ? row.cost : row.agent_minutes;
   }
 
-  // Per-row automation split for the active metric. Interactive + automated
-  // sum to rowValue, so the two bar segments stack to the full bar width.
-  function interactiveValue(row: ActivityKeyMinutes): number {
+  function interactiveValue(row: KeyMinutes): number {
     return metric === "cost"
       ? row.interactive_cost
       : row.interactive_agent_minutes;
   }
 
-  function automatedValue(row: ActivityKeyMinutes): number {
+  function automatedValue(row: KeyMinutes): number {
     return metric === "cost" ? row.automated_cost : row.automated_agent_minutes;
   }
 
-  // Rank by the selected metric and drop rows that are zero for it: an untimed
-  // cost-only row contributes nothing to the minutes view (and would otherwise
-  // render as an empty "0" bar), and a zero-cost row drops from the cost view.
-  // The backend pre-sorts by minutes, so re-sort for the cost view.
-  function rankedRows(arr: any[] | null): ActivityKeyMinutes[] {
-    return asKeyMinutes(arr)
+  function rankedRows(arr: KeyMinutes[] | null): KeyMinutes[] {
+    return (arr ?? [])
       .filter((r) => rowValue(r) > 0)
       .sort((a, b) => rowValue(b) - rowValue(a));
   }
@@ -43,23 +31,33 @@
   const byProject = $derived(rankedRows(report.by_project));
   const byModel = $derived(rankedRows(report.by_model));
   const byAgent = $derived(rankedRows(report.by_agent));
+  const byBranch = $derived(rankedRows(report.by_branch));
+  const noBranchLabel = $derived(m.shared_no_branch());
 
   interface Panel {
     title: string;
-    rows: ActivityKeyMinutes[];
+    rows: KeyMinutes[];
+    label: (key: string) => string;
+  }
+
+  function identityLabel(key: string): string {
+    return key;
+  }
+
+  function branchDisplayLabel(key: string): string {
+    return branchTokenLabel(key, noBranchLabel);
   }
 
   const panels = $derived.by((): Panel[] => [
-    { title: m.activity_project(), rows: byProject },
-    { title: m.activity_model(), rows: byModel },
-    { title: m.activity_agent(), rows: byAgent },
+    { title: m.activity_project(), rows: byProject, label: identityLabel },
+    { title: m.activity_model(), rows: byModel, label: identityLabel },
+    { title: m.activity_agent(), rows: byAgent, label: identityLabel },
+    { title: m.activity_branch(), rows: byBranch, label: branchDisplayLabel },
   ]);
 
-  function maxValue(rows: ActivityKeyMinutes[]): number {
+  function maxValue(rows: KeyMinutes[]): number {
     if (rows.length === 0) return 1;
     const m = Math.max(...rows.map(rowValue));
-    // Fall back to 1 only when the max is non-positive, so the largest bar
-    // reaches 100% even when every value is under one unit.
     return m > 0 ? m : 1;
   }
 
@@ -75,7 +73,7 @@
     return `$${v.toFixed(2)}`;
   }
 
-  function fmtValue(row: ActivityKeyMinutes): string {
+  function fmtValue(row: KeyMinutes): string {
     return metric === "cost" ? fmtCost(row.cost) : fmtMinutes(row.agent_minutes);
   }
 
@@ -90,13 +88,18 @@
 
   let tooltip = $state<{ x: number; y: number; text: string } | null>(null);
 
-  function sumValue(rows: ActivityKeyMinutes[]): number {
+  function sumValue(rows: KeyMinutes[]): number {
     let total = 0;
     for (const r of rows) total += rowValue(r);
     return total;
   }
 
-  function showTip(e: MouseEvent, row: ActivityKeyMinutes, total: number) {
+  function showTip(
+    e: MouseEvent,
+    row: KeyMinutes,
+    total: number,
+    label: string,
+  ) {
     const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
     const pct = total > 0 ? Math.round((rowValue(row) / total) * 100) : 0;
     const unit = metric === "cost" ? "" : m.activity_min_unit();
@@ -104,7 +107,7 @@
     tooltip = {
       x: rect.left + rect.width / 2,
       y: rect.top - 4,
-      text: `${row.key} · ${fmtValue(row)}${unit} · ${pct}% · ${split}`,
+      text: `${label} · ${fmtValue(row)}${unit} · ${pct}% · ${split}`,
     };
   }
 
@@ -157,14 +160,15 @@
         {#if panel.rows.length > 0}
           <div class="bar-list">
             {#each panel.rows as row (row.key)}
+              {@const label = panel.label(row.key)}
               <!-- svelte-ignore a11y_no_static_element_interactions -->
               <div
                 class="bar-row"
-                onmouseenter={(e) => showTip(e, row, total)}
+                onmouseenter={(e) => showTip(e, row, total, label)}
                 onmouseleave={hideTip}
               >
-                <span class="bar-label" title={row.key}>
-                  {truncate(row.key, 22)}
+                <span class="bar-label" title={label}>
+                  {truncate(label, 22)}
                 </span>
                 <div class="bar-track">
                   <div
diff --git a/frontend/src/lib/components/activity/Breakdowns.test.ts b/frontend/src/lib/components/activity/Breakdowns.test.ts
index 09910146a..2ed70168a 100644
--- a/frontend/src/lib/components/activity/Breakdowns.test.ts
+++ b/frontend/src/lib/components/activity/Breakdowns.test.ts
@@ -40,6 +40,7 @@ function makeReport(): Report {
     ],
     by_model: [],
     by_agent: [],
+    by_branch: [],
     by_session: [],
     intervals: [],
   } as Report;
diff --git a/frontend/src/lib/components/activity/ConcurrencyTimeline.svelte b/frontend/src/lib/components/activity/ConcurrencyTimeline.svelte
index 1ce4e539f..9cf7ae94a 100644
--- a/frontend/src/lib/components/activity/ConcurrencyTimeline.svelte
+++ b/frontend/src/lib/components/activity/ConcurrencyTimeline.svelte
@@ -1,16 +1,15 @@
 <script lang="ts">
   import { formatDateTime, m } from "../../i18n/index.js";
-  import type { Report } from "../../api/types.js";
+  import type {
+    Bucket,
+    Report,
+    ReportInterval,
+    SessionRow,
+  } from "../../api/types.js";
   import { activeSessionsInSlot } from "./activeSessions.js";
   import OptionTypeahead, {
     type TypeaheadOption,
   } from "../layout/OptionTypeahead.svelte";
-  import type {
-    ActivityBucket,
-    ActivityReportInterval,
-    ActivitySessionRow,
-  } from "../../api/generated/index";
-
   let {
     report,
     selectedBucket = null,
@@ -30,16 +29,10 @@
   const Y_LABEL_W = 32;
   const RIGHT_PAD = 8;
   const OVERLAY_AXIS_W = 48;
-  // Reserved headroom so the tallest bar, its grid line, and
-  // the top y-axis label do not clip against the viewBox edge.
   const TOP_PAD = 10;
   const TICK_TARGET = 4;
 
-  // buckets/by_* are typed `any[] | null` by the codegen, so cast
-  // to the generated element model for field-level type safety.
-  const buckets = $derived(
-    (report.buckets ?? []) as ActivityBucket[],
-  );
+  const buckets = $derived(report.buckets ?? []);
 
   let tooltip = $state<{ x: number; y: number; text: string } | null>(null);
 
@@ -88,7 +81,7 @@
     return `${dateLabel(startMs)}–${dateLabel(endMs - 1)}`;
   }
 
-  function fmtBucketRange(b: ActivityBucket): string {
+  function fmtBucketRange(b: Bucket): string {
     const startMs = Date.parse(b.start);
     const endMs = Date.parse(b.end);
     if (Number.isNaN(startMs) || Number.isNaN(endMs)) return "";
@@ -102,7 +95,7 @@
   // cost stay combined (the API does not break those down per bucket), so the
   // split annotation sits on "peak" alone and shows only when an automated
   // agent was running at the peak.
-  function showSlotTip(e: MouseEvent, b: ActivityBucket) {
+  function showSlotTip(e: MouseEvent, b: Bucket) {
     const rect = (e.currentTarget as Element).getBoundingClientRect();
     const peakSplit =
       b.automated_at_peak > 0
@@ -126,14 +119,10 @@
     tooltip = null;
   }
 
-  const intervals = $derived(
-    (report.intervals ?? []) as ActivityReportInterval[],
-  );
+  const intervals: ReportInterval[] = $derived(report.intervals ?? []);
   const bySession = $derived(
-    new Map(
-      ((report.by_session ?? []) as ActivitySessionRow[]).map(
-        (r) => [r.session_id, r],
-      ),
+    new Map<string, SessionRow>(
+      (report.by_session ?? []).map((r) => [r.session_id, r]),
     ),
   );
 
@@ -148,10 +137,6 @@
     return { startMs: Date.parse(b.start), endMs: Date.parse(b.end) };
   }
 
-  // Clicking a bucket hands its active-session membership to the parent, which
-  // owns the page-local sessions-table filter. Clicking the already selected
-  // bucket clears the filter. The parent resets `selectedBucket` to null
-  // whenever the report reloads, so a stale slot never points at a wrong bucket.
   function selectSlot(idx: number) {
     if (!onSelectBucket) return;
     if (selectedBucket === idx) {
@@ -176,9 +161,6 @@
     }
   }
 
-  // Optional secondary series overlaid on the bars: none, output tokens, or
-  // cost. Each metric scales to its own max so the line reads as a shape over
-  // the concurrency bars, not an absolute count on the agent axis.
   let overlayMetric = $state<"none" | "tokens" | "cost">("none");
   const overlayOptions: TypeaheadOption[] = $derived([
     { name: "none", label: m.activity_overlay_none(), displayLabel: m.activity_overlay_none() },
@@ -186,7 +168,7 @@
     { name: "cost", label: m.activity_cost(), displayLabel: m.activity_cost() },
   ]);
 
-  function bucketOverlayValue(b: ActivityBucket): number {
+  function bucketOverlayValue(b: Bucket): number {
     return overlayMetric === "cost" ? b.cost : b.output_tokens;
   }
 
@@ -235,7 +217,6 @@
   const rangeEndMs = $derived(Date.parse(report.range_end));
   const rangeSpanMs = $derived(Math.max(rangeEndMs - rangeStartMs, 1));
 
-  // x pixel for a given instant within the range.
   function xForMs(ms: number): number {
     return Y_LABEL_W + ((ms - rangeStartMs) / rangeSpanMs) * plotWidth;
   }
@@ -273,8 +254,6 @@
     return h - (val / max) * plotH;
   }
 
-  // Each bucket owns a full contiguous cell [cellX, cellX+cellW); the visible
-  // bar is inset by a small gap. Strip cells and hit targets reuse the cell.
   const bars = $derived.by(() => {
     const out: Array<{
       x: number;
@@ -297,9 +276,6 @@
       const cellW = Math.max(((bEnd - bStart) / rangeSpanMs) * plotWidth, 1);
       const barGap = Math.min(cellW * 0.2, 2);
       const top = scaleY(b.max_agents, scale.max, CHART_H);
-      // Split the peak bar into a blue interactive base and an orange automated
-      // cap. interactive_at_peak + automated_at_peak == max_agents, so the two
-      // segments stack to the full bar; interactiveTop is the seam between them.
       const interactiveTop = scaleY(b.interactive_at_peak, scale.max, CHART_H);
       out.push({
         x: cellX + barGap / 2,
@@ -366,7 +342,6 @@
     return ticks;
   });
 
-  // Local clock fields in the report timezone, used to pick tick boundaries.
   function localHour(ms: number): number {
     return Number(
       new Date(ms).toLocaleString("en-US", {
@@ -433,7 +408,6 @@
     return minuteUnitTicks();
   });
 
-  // Partial future region: shade from effective_end to range_end.
   const effEndMs = $derived(Date.parse(report.effective_end));
   const futureStartMs = $derived(Math.min(effEndMs, rangeEndMs));
   const futureX = $derived(xForMs(futureStartMs));
@@ -581,7 +555,6 @@
         </text>
       {/each}
 
-      <!-- Active/idle strip: one full-width cell per elapsed bucket. -->
       {#each bars as bar (bar.idx)}
         {@const b = buckets[bar.idx]}
         <rect
@@ -603,9 +576,6 @@
         />
       {/if}
 
-      <!-- Transparent full-cell per-bucket hover/click target (one per bucket).
-           data-bucket-bar lives here, not on the visible bar, because the hover
-           handler that drives the tooltip is on this interactive rect. -->
       {#each bars as bar (bar.idx)}
         {@const b = buckets[bar.idx]}
         <rect
diff --git a/frontend/src/lib/components/activity/ConcurrencyTimeline.test.ts b/frontend/src/lib/components/activity/ConcurrencyTimeline.test.ts
index 793993606..eba977e61 100644
--- a/frontend/src/lib/components/activity/ConcurrencyTimeline.test.ts
+++ b/frontend/src/lib/components/activity/ConcurrencyTimeline.test.ts
@@ -3,14 +3,33 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test"
 import { fireEvent, render } from "@testing-library/svelte";
 import { mount, tick, unmount } from "svelte";
 import ConcurrencyTimeline from "./ConcurrencyTimeline.svelte";
-import type { Report } from "../../api/types.js";
+import type { Bucket, Report } from "../../api/types.js";
 
 class ResizeObserverMock {
   observe = vi.fn();
   disconnect = vi.fn();
 }
 
-function makeReport(overrides: Partial<Report> = {}): Report {
+type TestBucket = Omit<
+  Bucket,
+  "automated_at_peak" | "interactive_at_peak"
+> &
+  Partial<Pick<Bucket, "automated_at_peak" | "interactive_at_peak">>;
+
+type TestReportOverrides = Partial<Omit<Report, "buckets">> & {
+  buckets?: TestBucket[] | null;
+};
+
+function withBucketDefaults(buckets: TestBucket[] | null): Bucket[] | null {
+  if (buckets === null) return null;
+  return buckets.map((b) => ({
+    ...b,
+    interactive_at_peak: b.interactive_at_peak ?? b.max_agents,
+    automated_at_peak: b.automated_at_peak ?? 0,
+  }));
+}
+
+function makeReport(overrides: TestReportOverrides = {}): Report {
   // idx 2 (peak 3) carries a mixed split (2 interactive / 1 automated) for the
   // stacking and split-tooltip tests; idx 3 (peak 1) is all-interactive.
   const buckets = [
@@ -65,7 +84,8 @@ function makeReport(overrides: Partial<Report> = {}): Report {
       automated_at_peak: 0,
     },
   ];
-  const report = {
+  const { buckets: overrideBuckets, ...rest } = overrides;
+  return {
     peak: { agents: 3, at: "2026-06-16T06:00:00Z" },
     totals: {
       active_minutes: 50,
@@ -90,23 +110,16 @@ function makeReport(overrides: Partial<Report> = {}): Report {
     bucket_seconds: 10800,
     bucket_count: 8,
     elapsed_bucket_count: 5,
-    buckets,
+    buckets: withBucketDefaults(
+      overrideBuckets === undefined ? buckets : overrideBuckets,
+    ),
     by_project: null,
     by_model: null,
     by_agent: null,
     by_session: null,
     intervals: [],
-    ...overrides,
+    ...rest,
   } as Report;
-  // Backfill the peak-automation split onto any bucket literal that omits it
-  // (most fixtures only set max_agents), so the stacked bars get real geometry
-  // instead of NaN. Unspecified buckets default to all-interactive.
-  report.buckets = (report.buckets ?? []).map((b) => ({
-    interactive_at_peak: b.max_agents,
-    automated_at_peak: 0,
-    ...b,
-  }));
-  return report;
 }
 
 function popoverReport(): Report {
@@ -164,7 +177,7 @@ function popoverReport(): Report {
 }
 
 // A minute-bucketed quarter-hour range used by the per-bucket geometry tests.
-function minuteReport(overrides: Partial<Report> = {}): Report {
+function minuteReport(overrides: TestReportOverrides = {}): Report {
   return makeReport({
     range_start: "2026-06-16T00:00:00Z",
     range_end: "2026-06-16T00:15:00Z",
@@ -198,7 +211,7 @@ function minuteReport(overrides: Partial<Report> = {}): Report {
         output_tokens: 5,
         cost: 0,
       },
-    ] as Report["buckets"],
+    ],
     ...overrides,
   });
 }
diff --git a/frontend/src/lib/components/activity/SessionsTable.svelte b/frontend/src/lib/components/activity/SessionsTable.svelte
index eab5e237b..85dfe2bd7 100644
--- a/frontend/src/lib/components/activity/SessionsTable.svelte
+++ b/frontend/src/lib/components/activity/SessionsTable.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import { formatDateTime, m } from "../../i18n/index.js";
-  import type { Report } from "../../api/types.js";
-  import type { ActivitySessionRow } from "../../api/generated/index";
+  import type { Report, SessionRow } from "../../api/types.js";
   import { router } from "../../stores/router.svelte.js";
   import {
     ArrowDownIcon,
@@ -21,16 +20,8 @@
     onClearFilter?: () => void;
   } = $props();
 
-  // by_session is typed `any[] | null` by the codegen; cast to the
-  // generated element model for field-level type safety.
-  const allRows = $derived(
-    (report.by_session ?? []) as ActivitySessionRow[],
-  );
+  const allRows = $derived(report.by_session ?? []);
 
-  // Page-local time-slot filter from the Concurrency chart: a non-null id list
-  // restricts the table to the sessions active in the clicked slot. An empty
-  // set (an idle slot was clicked) correctly yields no rows but still shows the
-  // dismissible badge so the selection can be cleared.
   const filterSet = $derived(filterIds ? new Set(filterIds) : null);
   const rows = $derived(
     filterSet
@@ -54,20 +45,18 @@
       sortDir = sortDir === "asc" ? "desc" : "asc";
     } else {
       sortKey = key;
-      // Numeric/time columns read best high-to-low first; text
-      // columns alphabetically.
       sortDir =
         key === "project" || key === "agent" ? "asc" : "desc";
     }
   }
 
-  function isUntimed(row: ActivitySessionRow): boolean {
+  function isUntimed(row: SessionRow): boolean {
     return row.agent_minutes === null;
   }
 
   function compare(
-    a: ActivitySessionRow,
-    b: ActivitySessionRow,
+    a: SessionRow,
+    b: SessionRow,
     key: SortKey,
   ): number {
     switch (key) {
@@ -88,22 +77,15 @@
   }
 
   function byKeyThenId(
-    a: ActivitySessionRow,
-    b: ActivitySessionRow,
+    a: SessionRow,
+    b: SessionRow,
     dir: number,
   ): number {
     const primary = compare(a, b, sortKey) * dir;
     if (primary !== 0) return primary;
-    // Stable tiebreak: equal primary keys order by session_id
-    // ascending regardless of direction, so toggling sortDir never
-    // reorders peers.
     return a.session_id.localeCompare(b.session_id);
   }
 
-  // Untimed rows only have a null value for the timing keys
-  // (agent_minutes, first_active); their cost/project/agent are real.
-  // Partition them to the bottom only when sorting by a timing key, so
-  // a high-cost untimed session still participates in the cost sort.
   const sortedRows = $derived.by(() => {
     const dir = sortDir === "asc" ? 1 : -1;
     const partitionUntimed =
@@ -111,15 +93,13 @@
     if (!partitionUntimed) {
       return [...rows].sort((a, b) => byKeyThenId(a, b, dir));
     }
-    const timed: ActivitySessionRow[] = [];
-    const untimed: ActivitySessionRow[] = [];
+    const timed: SessionRow[] = [];
+    const untimed: SessionRow[] = [];
     for (const row of rows) {
       if (isUntimed(row)) untimed.push(row);
       else timed.push(row);
     }
     timed.sort((a, b) => byKeyThenId(a, b, dir));
-    // Keep appended untimed rows in a stable session_id order so they
-    // don't jump around between renders.
     untimed.sort((a, b) => a.session_id.localeCompare(b.session_id));
     return [...timed, ...untimed];
   });
@@ -133,8 +113,8 @@
     return Math.round(v).toLocaleString();
   }
 
-  function rowModel(row: ActivitySessionRow): string {
-    const models = (row.models ?? []) as string[];
+  function rowModel(row: SessionRow): string {
+    const models = row.models ?? [];
     if (models.length > 1) return m.activity_mixed();
     return row.primary_model || "—";
   }
diff --git a/frontend/src/lib/components/activity/SummaryCards.test.ts b/frontend/src/lib/components/activity/SummaryCards.test.ts
index 1a44d921c..5eba3d16b 100644
--- a/frontend/src/lib/components/activity/SummaryCards.test.ts
+++ b/frontend/src/lib/components/activity/SummaryCards.test.ts
@@ -39,6 +39,7 @@ function makeReport(totals: Partial<Report["totals"]> = {}): Report {
     by_project: [],
     by_model: [],
     by_agent: [],
+    by_branch: [],
     by_session: [],
     intervals: [],
   } as Report;
diff --git a/frontend/src/lib/components/activity/activeSessions.ts b/frontend/src/lib/components/activity/activeSessions.ts
index 2b8b7dfb1..630b14750 100644
--- a/frontend/src/lib/components/activity/activeSessions.ts
+++ b/frontend/src/lib/components/activity/activeSessions.ts
@@ -1,7 +1,4 @@
-import type {
-  ActivityReportInterval,
-  ActivitySessionRow,
-} from "../../api/generated/index";
+import type { ReportInterval, SessionRow } from "../../api/types.js";
 
 /**
  * The unique sessions whose interval overlaps the half-open slot
@@ -10,11 +7,11 @@ import type {
  * in the slot appears once. Ids absent from `bySession` are skipped.
  */
 export function activeSessionsInSlot(
-  intervals: ActivityReportInterval[],
+  intervals: ReportInterval[],
   slotStartMs: number,
   slotEndMs: number,
-  bySession: Map<string, ActivitySessionRow>,
-): ActivitySessionRow[] {
+  bySession: Map<string, SessionRow>,
+): SessionRow[] {
   const earliestStart = new Map<string, number>();
   for (const iv of intervals) {
     const start = Date.parse(iv.start);
@@ -35,7 +32,7 @@ export function activeSessionsInSlot(
     const d = earliestStart.get(a)! - earliestStart.get(b)!;
     return d !== 0 ? d : a.localeCompare(b);
   });
-  const rows: ActivitySessionRow[] = [];
+  const rows: SessionRow[] = [];
   for (const id of ids) {
     const r = bySession.get(id);
     if (r) rows.push(r);
diff --git a/frontend/src/lib/stores/activity.svelte.ts b/frontend/src/lib/stores/activity.svelte.ts
index ce0119af5..c2327472c 100644
--- a/frontend/src/lib/stores/activity.svelte.ts
+++ b/frontend/src/lib/stores/activity.svelte.ts
@@ -1,5 +1,8 @@
 import type { AgentInfo, ProjectInfo } from "../api/types.js";
-import type { Report } from "../api/types/activity.js";
+import {
+  activityReportFromGenerated,
+  type Report,
+} from "../api/types/activity.js";
 import { ActivityService, MetadataService } from "../api/generated/index";
 import { configureGeneratedClient } from "../api/runtime.js";
 import { sync } from "./sync.svelte.js";
@@ -167,7 +170,7 @@ class ActivityStore {
         automation: this.automation,
       });
       if (v !== this.loadVersion) return;
-      this.report = res as unknown as Report;
+      this.report = activityReportFromGenerated(res);
       this.lastUpdatedAt = Date.now();
       this.hasNewData = false;
       this.loading = false;
diff --git a/internal/activity/activity.go b/internal/activity/activity.go
index 81e94fda8..0d83961a8 100644
--- a/internal/activity/activity.go
+++ b/internal/activity/activity.go
@@ -7,6 +7,7 @@ package activity
 
 import (
 	"sort"
+	"strings"
 	"time"
 )
 
@@ -32,6 +33,7 @@ type SessionMeta struct {
 	Project     string
 	Agent       string
 	Machine     string
+	GitBranch   string // "" when unknown
 	StartedAt   string // RFC3339 or ""
 	EndedAt     string // RFC3339 or ""
 	IsAutomated bool   // automated (e.g. roborev) vs interactive session
@@ -81,6 +83,7 @@ type Report struct {
 	ByProject          []KeyMinutes     `json:"by_project"`
 	ByModel            []KeyMinutes     `json:"by_model"`
 	ByAgent            []KeyMinutes     `json:"by_agent"`
+	ByBranch           []KeyMinutes     `json:"by_branch"`
 	BySession          []SessionRow     `json:"by_session"`
 	Intervals          []ReportInterval `json:"intervals"`
 }
@@ -678,6 +681,7 @@ func buildSessionsTable(r *Report, start, end, effEnd time.Time,
 	byProject := map[string]*keyAgg{}
 	byAgent := map[string]*keyAgg{}
 	byModel := map[string]*keyAgg{}
+	byBranch := map[string]*keyAgg{}
 	r.BySession = make([]SessionRow, 0, len(sessions))
 	for _, s := range sessions {
 		au := s.IsAutomated
@@ -701,6 +705,7 @@ func buildSessionsTable(r *Report, start, end, effEnd time.Time,
 			row.PrimaryModel, row.Models = primaryAndModels(a.modelMins)
 			addKey(byProject, s.Project, mins, 0, au)
 			addKey(byAgent, s.Agent, mins, 0, au)
+			addKey(byBranch, branchBreakdownKey(s.Project, s.GitBranch), mins, 0, au)
 			for m, mm := range a.modelMins {
 				addKey(byModel, m, mm, 0, au)
 			}
@@ -717,6 +722,7 @@ func buildSessionsTable(r *Report, start, end, effEnd time.Time,
 			// cost breakdown sums to Totals.Cost. Minutes stay timed-only above.
 			addKey(byProject, s.Project, 0, c.cost, au)
 			addKey(byAgent, s.Agent, 0, c.cost, au)
+			addKey(byBranch, branchBreakdownKey(s.Project, s.GitBranch), 0, c.cost, au)
 			for m, mc := range c.models {
 				addKey(byModel, m, 0, mc, au)
 			}
@@ -734,9 +740,34 @@ func buildSessionsTable(r *Report, start, end, effEnd time.Time,
 	r.Totals.DistinctModels = len(modelSet)
 	r.ByProject = breakdownRows(byProject, false)
 	r.ByAgent = breakdownRows(byAgent, false)
+	r.ByBranch = breakdownRows(byBranch, false)
 	r.ByModel = breakdownRows(byModel, true)
 }
 
+// branchBreakdownKey keys the ByBranch rollup by (project, branch). The
+// separator matches db.branchFilterSep so a key round-trips as a filter token.
+const branchBreakdownSep = "\x1f"
+const noBranchLabel = "(no branch)"
+
+func branchBreakdownKey(project, branch string) string {
+	return project + branchBreakdownSep + branch
+}
+
+// BranchKeyLabel renders a ByBranch key for display as project/branch.
+func BranchKeyLabel(key string) string {
+	project, branch, ok := strings.Cut(key, branchBreakdownSep)
+	if !ok {
+		return key
+	}
+	if branch == "" {
+		branch = noBranchLabel
+	}
+	if project == "" {
+		return branch
+	}
+	return project + "/" + branch
+}
+
 // keyAgg accumulates a breakdown key's combined agent-minutes and cost plus the
 // automated/interactive split of each. Minutes come from timed intervals; cost
 // from deduped usage (all sessions, timed or not).
diff --git a/internal/activity/branch_rollup_test.go b/internal/activity/branch_rollup_test.go
new file mode 100644
index 000000000..c68cc0ff5
--- /dev/null
+++ b/internal/activity/branch_rollup_test.go
@@ -0,0 +1,50 @@
+package activity
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSessionsTable_ByBranch(t *testing.T) {
+	p := baseParams(t, "2026-06-16", "UTC")
+	sessions := []SessionMeta{
+		{SessionID: "a", Project: "proj1", GitBranch: "main", Agent: "claude"},
+		{SessionID: "b", Project: "proj1", GitBranch: "feature-x", Agent: "claude"},
+		// Same branch name as "a" but a different project: the (project, branch)
+		// grain keeps them in separate buckets.
+		{SessionID: "c", Project: "proj2", GitBranch: "main", Agent: "claude"},
+		{SessionID: "d", Project: "proj1", GitBranch: "", Agent: "claude"},
+		{SessionID: "e", Project: "proj1", GitBranch: "unknown", Agent: "claude"},
+	}
+	usage := []UsageRow{
+		{SessionID: "a", Model: "m", Timestamp: "2026-06-16T11:00:00Z", Cost: 1.0, UsageDedupKey: "ka"},
+		{SessionID: "b", Model: "m", Timestamp: "2026-06-16T11:00:00Z", Cost: 2.0, UsageDedupKey: "kb"},
+		{SessionID: "c", Model: "m", Timestamp: "2026-06-16T11:00:00Z", Cost: 3.0, UsageDedupKey: "kc"},
+		{SessionID: "d", Model: "m", Timestamp: "2026-06-16T11:00:00Z", Cost: 4.0, UsageDedupKey: "kd"},
+		{SessionID: "e", Model: "m", Timestamp: "2026-06-16T11:00:00Z", Cost: 5.0, UsageDedupKey: "ke"},
+	}
+	r := Aggregate(p, sessions, nil, usage)
+
+	byBranch := map[string]KeyMinutes{}
+	for _, b := range r.ByBranch {
+		byBranch[b.Key] = b
+	}
+	require.Len(t, r.ByBranch, 5, "one bucket per distinct (project, branch)")
+	assert.InDelta(t, 1.0, byBranch[branchBreakdownKey("proj1", "main")].Cost, 1e-9)
+	assert.InDelta(t, 2.0, byBranch[branchBreakdownKey("proj1", "feature-x")].Cost, 1e-9)
+	assert.InDelta(t, 3.0, byBranch[branchBreakdownKey("proj2", "main")].Cost, 1e-9,
+		"proj2/main is distinct from proj1/main")
+	assert.InDelta(t, 4.0, byBranch[branchBreakdownKey("proj1", "")].Cost, 1e-9,
+		"empty branch stays distinct from a branch named unknown")
+	assert.InDelta(t, 5.0, byBranch[branchBreakdownKey("proj1", "unknown")].Cost, 1e-9)
+}
+
+func TestBranchKeyLabel(t *testing.T) {
+	assert.Equal(t, "proj/main", BranchKeyLabel(branchBreakdownKey("proj", "main")))
+	assert.Equal(t, "proj/(no branch)", BranchKeyLabel(branchBreakdownKey("proj", "")))
+	assert.Equal(t, "(no branch)", BranchKeyLabel(branchBreakdownKey("", "")))
+	assert.Equal(t, "proj/unknown", BranchKeyLabel(branchBreakdownKey("proj", "unknown")))
+	assert.Equal(t, "plain", BranchKeyLabel("plain"))
+}
diff --git a/internal/activity/parity_pgtest_test.go b/internal/activity/parity_pgtest_test.go
index 68254a637..8ec2703b7 100644
--- a/internal/activity/parity_pgtest_test.go
+++ b/internal/activity/parity_pgtest_test.go
@@ -51,9 +51,10 @@ const paritySchema = "agentsview_daily_report_parity_test"
 // the parity fixture. Assistant messages carry token_usage JSON so cost is
 // exercised through the message-source usage path (no usage_events needed).
 type parityFixtureSession struct {
-	id      string
-	project string
-	model   string
+	id        string
+	project   string
+	gitBranch string
+	model     string
 	// events is an ordered (role, RFC3339-timestamp) list. Assistant rows get
 	// token_usage with the given outputTokens so they contribute cost.
 	events       []parityEvent
@@ -89,7 +90,7 @@ type parityEvent struct {
 func parityFixture() []parityFixtureSession {
 	return []parityFixtureSession{
 		{
-			id: "parity-a", project: "alpha", model: "model-x",
+			id: "parity-a", project: "alpha", gitBranch: "main", model: "model-x",
 			outputTokens: 1200,
 			events: []parityEvent{
 				{role: "user", ts: parityDate + "T10:00:00Z"},
@@ -99,7 +100,9 @@ func parityFixture() []parityFixtureSession {
 			},
 		},
 		{
-			id: "parity-b", project: "beta", model: "model-y",
+			// Same branch name "main" as parity-a but a different project; the
+			// (project, branch) grain must keep them in separate buckets.
+			id: "parity-b", project: "beta", gitBranch: "main", model: "model-y",
 			outputTokens: 800,
 			events: []parityEvent{
 				{role: "user", ts: parityDate + "T10:01:00Z"},
@@ -109,7 +112,8 @@ func parityFixture() []parityFixtureSession {
 			},
 		},
 		{
-			id: "parity-c", project: "alpha", model: "model-x",
+			// Second branch within alpha, so a project carries multiple branches.
+			id: "parity-c", project: "alpha", gitBranch: "feature-x", model: "model-x",
 			outputTokens: 300,
 			events: []parityEvent{
 				{role: "user", ts: parityDate + "T14:00:00Z"},
@@ -198,6 +202,7 @@ func paritySessionWrite(fs parityFixtureSession) db.SessionBatchWrite {
 	sess := db.Session{
 		ID:               fs.id,
 		Project:          fs.project,
+		GitBranch:        fs.gitBranch,
 		Machine:          "local",
 		Agent:            "claude",
 		FirstMessage:     &firstMsg,
@@ -335,6 +340,9 @@ func canonicalizeReport(r *activity.Report) {
 	sort.Slice(r.ByAgent, func(i, j int) bool {
 		return r.ByAgent[i].Key < r.ByAgent[j].Key
 	})
+	sort.Slice(r.ByBranch, func(i, j int) bool {
+		return r.ByBranch[i].Key < r.ByBranch[j].Key
+	})
 	sort.Slice(r.BySession, func(i, j int) bool {
 		return r.BySession[i].SessionID < r.BySession[j].SessionID
 	})
@@ -467,4 +475,20 @@ func assertDayMinuteFixtureSanity(t *testing.T, r activity.Report) {
 		"the later fractional duplicate is dropped")
 	require.Equal(t, "model-x", bySession["parity-f"].PrimaryModel,
 		"zero-cost usage still reports its known model as primary")
+
+	// ByBranch is keyed by the raw (project, branch) pair. Empty branches
+	// survive only when they carry minutes or cost.
+	const sep = "\x1f"
+	byBranch := map[string]activity.KeyMinutes{}
+	for _, b := range r.ByBranch {
+		byBranch[b.Key] = b
+	}
+	require.Contains(t, byBranch, "alpha"+sep+"main", "alpha/main bucket")
+	require.Contains(t, byBranch, "beta"+sep+"main",
+		"beta/main is distinct from alpha/main under the (project, branch) grain")
+	require.Contains(t, byBranch, "alpha"+sep+"feature-x",
+		"a project can carry multiple branches")
+	require.Contains(t, byBranch, "gamma"+sep, "empty branch bucket")
+	require.NotContains(t, byBranch, "delta"+sep,
+		"zero-cost zero-minute branch bucket is dropped like any zero row")
 }
diff --git a/internal/db/activityreport.go b/internal/db/activityreport.go
index e304f17ea..4897fb4cf 100644
--- a/internal/db/activityreport.go
+++ b/internal/db/activityreport.go
@@ -102,7 +102,8 @@ func (db *DB) activityReportSessions(
 		s.machine,
 		COALESCE(s.started_at, ''),
 		COALESCE(s.ended_at, ''),
-		COALESCE(s.is_automated, 0)
+		COALESCE(s.is_automated, 0),
+		s.git_branch
 	FROM sessions s
 	WHERE ` + where + `
 		AND COALESCE(NULLIF(s.ended_at, ''),
@@ -125,6 +126,7 @@ func (db *DB) activityReportSessions(
 		if err := rows.Scan(
 			&s.SessionID, &s.Title, &s.Project, &s.Agent,
 			&s.Machine, &s.StartedAt, &s.EndedAt, &s.IsAutomated,
+			&s.GitBranch,
 		); err != nil {
 			return nil, nil, fmt.Errorf(
 				"scanning activity report session: %w", err)
diff --git a/internal/duckdb/activityreport.go b/internal/duckdb/activityreport.go
index de171086f..065d0d5cd 100644
--- a/internal/duckdb/activityreport.go
+++ b/internal/duckdb/activityreport.go
@@ -99,7 +99,8 @@ func (s *Store) activityReportSessions(
 		s.machine,
 		s.started_at,
 		s.ended_at,
-		COALESCE(s.is_automated, false) AS is_automated
+		COALESCE(s.is_automated, false) AS is_automated,
+		s.git_branch
 	FROM sessions s
 	WHERE ` + where + `
 		AND COALESCE(s.ended_at,
@@ -123,6 +124,7 @@ func (s *Store) activityReportSessions(
 		if err := rows.Scan(
 			&m.SessionID, &m.Title, &m.Project, &m.Agent,
 			&m.Machine, &startedAt, &endedAt, &m.IsAutomated,
+			&m.GitBranch,
 		); err != nil {
 			return nil, nil, fmt.Errorf(
 				"scanning duckdb activity report session: %w", err)
diff --git a/internal/postgres/activityreport.go b/internal/postgres/activityreport.go
index 3f76e1648..d6c4d3178 100644
--- a/internal/postgres/activityreport.go
+++ b/internal/postgres/activityreport.go
@@ -96,7 +96,8 @@ func (s *Store) activityReportSessions(
 		s.machine,
 		s.started_at,
 		s.ended_at,
-		COALESCE(s.is_automated, false) AS is_automated
+		COALESCE(s.is_automated, false) AS is_automated,
+		s.git_branch
 	FROM sessions s
 	WHERE ` + where + `
 		AND COALESCE(s.ended_at,
@@ -122,6 +123,7 @@ func (s *Store) activityReportSessions(
 		if err := rows.Scan(
 			&m.SessionID, &m.Title, &m.Project, &m.Agent,
 			&m.Machine, &startedAt, &endedAt, &m.IsAutomated,
+			&m.GitBranch,
 		); err != nil {
 			return nil, nil, fmt.Errorf(
 				"scanning activity report session: %w", err)