diff --git a/CHANGELOG.md b/CHANGELOG.md
index b875a43..e0d9598 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.0
+
+### Features
+
+- Added **Since last commit** usage window: plan % burned while the working tree is dirty, re-anchored on every HEAD move (automatic; no manual reset). Hidden when the tree is clean or the workspace is not a git repo
+- Added **This branch** usage window: plan % while a feature branch is checked out, with active-time pause/resume so spend on other branches does not inflate the counter (hidden on the default branch)
+- Optional status bar modes `sinceLastCommit` and `thisBranch`
+- **Last hour** usage now persists across IDE reloads when sampling continued in the prior hour
+
+### UI
+
+- Timestamps use 24-hour format
+- Git-aware windows wait for the built-in git API before rendering (no flicker / stale placeholders on startup)
+
+### Docs
+
+- Landing page and README updated for the git-aware windows
+
 ## 0.2.0
 
 ### Features
diff --git a/README.md b/README.md
index d9428d7..f50bdbd 100644
--- a/README.md
+++ b/README.md
@@ -2,10 +2,10 @@
 
 **See your Cursor plan usage without leaving the editor.**
 
-[Website](https://codykoinabox.github.io/cursor-plan-usage/) · Live **Cursor Models** and **Other Models** percentages in a dockable sidebar and status bar chip — so you always know where you stand in the billing cycle.
+[Website](https://codykoinabox.github.io/cursor-plan-usage/) · Live **Cursor Models** and **Other Models** percentages in a dockable sidebar and status bar — plus git-aware windows for spend since your last commit or while you’re on a feature branch.
 
 #### You can easily install the extension through the Extensions tab inside Cursor:
-<img width="268" height="228" alt="image" src="https://github.com/user-attachments/assets/2e36d629-3784-4ecd-b4be-677fd1a1ce41" />
+<img width="268" height="228" alt="Installing Cursor Plan Usage from the Extensions tab" src="https://github.com/user-attachments/assets/2e36d629-3784-4ecd-b4be-677fd1a1ce41" />
 
 
 [Install on Open VSX](https://open-vsx.org/extension/CodyKoInABox/cursor-plan-usage) · [Report an issue](https://github.com/CodyKoInABox/cursor-plan-usage/issues)
@@ -15,15 +15,17 @@
 ## Features
 
 - **Sidebar panel** — CM / OM usage at a glance in the activity bar
-- **Status bar chip** — `CM n% · OM n%` always visible while you work, or your **Usage so far** deltas instead
+- **Status bar chip** — `CM n% · OM n%` cycle totals, or deltas for **Usage so far** / **Since last commit** / **This branch**
 - **Billing cycle** — progress through the period, end time, and a simple projection
-- **Session deltas** — last-hour and IDE-session usage while the extension is sampling
-- **Usage so far** — custom resettable window that persists across reloads; track any period you care about. Auto-resets when a new billing cycle starts
+- **Session deltas** — last-hour usage persists across reloads; IDE-session usage is since this Cursor window opened
+- **Usage so far** — resettable window that persists across reloads; auto-resets on a new billing cycle
+- **Since last commit** — plan % burned while the working tree is dirty; resets on each commit. Hidden when the tree is clean
+- **This branch** — plan % while a feature branch is checked out; pauses on `main` / other branches and restores when you return. Hidden on the default branch
 - **Smart refresh** — updates on focus and AI activity; pauses when Cursor is unfocused
 
 
 ## UI Example
-<img width="374" height="808" alt="Screenshot_1509" src="https://github.com/user-attachments/assets/42b61e48-6113-4b0e-b246-ec3a56f383bf" />
+<img width="281" height="1024" alt="Plan Usage sidebar showing Cursor Models, Other Models, and git-aware usage windows" src="docs/assets/sidebar.png" />
 
 
 ## Cursor only
@@ -66,7 +68,7 @@ After install, open the **Plan Usage** icon in the activity bar, or run **Plan U
 | --- | --- | --- |
 | `cursorPlanUsage.pollIntervalSeconds` | `0` | Idle poll interval (seconds) while focused. `0` = adaptive (30s burst for 2 min after AI activity, then 3 min). Polling pauses while unfocused. |
 | `cursorPlanUsage.refreshOnAiActivity` | `true` | Refresh when Cursor’s local AI tracking DB updates |
-| `cursorPlanUsage.statusBarMode` | `absolute` | `absolute` shows cycle totals (`CM 45% · OM 20%`); `usageSoFar` shows deltas since your last Reset (`CM +4% · OM +2%`) |
+| `cursorPlanUsage.statusBarMode` | `absolute` | `absolute` shows cycle totals (`CM 45% · OM 20%`); `usageSoFar` shows deltas since your last Reset (`CM +4% · OM +2%`); `sinceLastCommit` shows deltas since HEAD while dirty; `thisBranch` shows deltas while the current feature branch is checked out |
 | `cursorPlanUsage.apiBaseUrl` | `https://api2.cursor.sh` | Dashboard API base URL |
 
 There is no `sessionToken` setting — use the Set / Clear Session Token commands instead.
@@ -77,7 +79,7 @@ There is no `sessionToken` setting — use the Set / Clear Session Token command
 | --- | --- |
 | **No token found** | Sign in to Cursor, or run **Plan Usage: Set Session Token** with a valid session token / JWT. |
 | **401 / unauthorized** | Re-sign into Cursor, or set a fresh token via **Plan Usage: Set Session Token**. |
-| **Remote-SSH / WSL** | The extension runs in the **local** Cursor UI and uses the local session DB. If usage looks wrong in a remote window, use a local window or set a session token override. |
+| **Remote-SSH / WSL** | The extension runs in the **local** Cursor UI and uses the local session DB. If usage looks wrong in a remote window, use a local window or set a session token override. **Since last commit** / **This branch** need the built-in git API and stay hidden when it is unavailable in remote UI hosts. |
 
 ## Notes
 
diff --git a/docs/assets/sidebar.png b/docs/assets/sidebar.png
index b82b176..7cbf8d9 100644
Binary files a/docs/assets/sidebar.png and b/docs/assets/sidebar.png differ
diff --git a/docs/index.html b/docs/index.html
index 0938cf3..c56f5f7 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -6,7 +6,7 @@
     <title>Cursor Plan Usage</title>
     <meta
       name="description"
-      content="See your Cursor plan usage without leaving the editor. Live CM and OM percentages in a sidebar and status bar."
+      content="See your Cursor plan usage without leaving the editor. Live CM and OM percentages, plus since-last-commit and this-branch deltas in a sidebar and status bar."
     />
     <link rel="icon" href="assets/icon.png" type="image/png" />
     <link rel="preconnect" href="https://fonts.googleapis.com" />
@@ -37,9 +37,11 @@
         <a href="#features">Features</a>
         <a href="#install">Install</a>
         <a
+          class="gh-link"
           href="https://github.com/CodyKoInABox/cursor-plan-usage"
+          target="_blank"
           rel="noopener noreferrer"
-          >GitHub</a
+          ><svg class="gh-icon" viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path fill="currentColor" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg>GitHub</a
         >
       </nav>
     </header>
@@ -47,40 +49,60 @@
     <main id="top">
       <section class="hero">
         <div class="hero-copy reveal">
-          <p class="brand-hero">Cursor Plan Usage</p>
+          <img
+            class="brand-hero-icon"
+            src="assets/icon.png"
+            alt=""
+            width="128"
+            height="128"
+          />
+          <h1 class="brand-hero">Cursor Plan Usage</h1>
           <p class="tagline">
             See your Cursor plan usage without leaving the editor.
           </p>
           <p class="lede">
             Live Cursor Models and Other Models percentages in a dockable
-            sidebar and status bar chip — so you always know where you stand in
-            the billing cycle.
+            sidebar and status bar — plus git-aware windows for spend since your
+            last commit or while you’re on a feature branch.
           </p>
           <div class="cta-row">
             <a class="btn btn-primary" href="#install">Install in Cursor</a>
             <a
-              class="btn btn-ghost"
+              class="btn btn-ghost gh-link"
               href="https://github.com/CodyKoInABox/cursor-plan-usage"
+              target="_blank"
               rel="noopener noreferrer"
-              >View on GitHub</a
+              ><svg class="gh-icon" viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path fill="currentColor" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg>View on GitHub</a
             >
           </div>
         </div>
         <div class="hero-visual reveal reveal-delay">
           <img
             src="assets/sidebar.png"
-            alt="Plan Usage sidebar showing Cursor Models and Other Models percentages"
-            width="374"
-            height="808"
+            alt="Plan Usage sidebar showing Cursor Models, Other Models, and git-aware usage windows"
+            width="281"
+            height="1024"
             fetchpriority="high"
           />
+          <p class="shot-credit">
+            Captured with
+            <a
+              href="https://github.com/CodyKoInABox/rustshot"
+              target="_blank"
+              rel="noopener noreferrer"
+              >Rustshot</a
+            >
+          </p>
         </div>
       </section>
 
       <section class="section features" id="features">
         <div class="section-intro reveal">
           <h2>What you get</h2>
-          <p>Everything you need to track plan burn without leaving Cursor.</p>
+          <p>
+            Cycle totals, custom windows, and git-aware deltas — without leaving
+            Cursor.
+          </p>
         </div>
         <ul class="feature-list">
           <li class="reveal">
@@ -90,8 +112,8 @@ <h2>What you get</h2>
           <li class="reveal">
             <strong>Status bar chip</strong>
             <span
-              >Always-visible <code>CM n% · OM n%</code> — or Usage so far
-              deltas</span
+              ><code>CM n% · OM n%</code> cycle totals, or deltas for Usage so
+              far / Since last commit / This branch</span
             >
           </li>
           <li class="reveal">
@@ -100,7 +122,10 @@ <h2>What you get</h2>
           </li>
           <li class="reveal">
             <strong>Session deltas</strong>
-            <span>Last-hour and IDE-session usage while the extension is sampling</span>
+            <span
+              >Last-hour usage persists across reloads; IDE-session usage is
+              since this Cursor window opened</span
+            >
           </li>
           <li class="reveal">
             <strong>Usage so far</strong>
@@ -109,6 +134,21 @@ <h2>What you get</h2>
               new billing cycle</span
             >
           </li>
+          <li class="reveal">
+            <strong>Since last commit</strong>
+            <span
+              >Plan % burned while the working tree is dirty; resets on each
+              commit. Hidden when the tree is clean</span
+            >
+          </li>
+          <li class="reveal">
+            <strong>This branch</strong>
+            <span
+              >Plan % while a feature branch is checked out; pauses on
+              <code>main</code> / other branches and restores when you return.
+              Hidden on the default branch</span
+            >
+          </li>
           <li class="reveal">
             <strong>Smart refresh</strong>
             <span>Updates on focus and AI activity; pauses when Cursor is unfocused</span>
@@ -132,13 +172,14 @@ <h2>Install in Cursor</h2>
           <div class="install-copy">
             <ol>
               <li>Open Extensions</li>
-              <li>Search <strong>Cursor Plan Usage</strong></li>
+              <li>Search <strong>Cursor Plan Usage by CodyKoInABox</strong></li>
               <li>Install</li>
             </ol>
             <p>
               Also on
               <a
                 href="https://open-vsx.org/extension/CodyKoInABox/cursor-plan-usage"
+                target="_blank"
                 rel="noopener noreferrer"
                 >Open VSX</a
               >.
@@ -150,17 +191,24 @@ <h2>Install in Cursor</h2>
       <section class="section feedback" id="feedback">
         <div class="feedback-inner reveal">
           <h2>Feedback</h2>
-          <p>Found a bug or have an idea? Open an issue on GitHub.</p>
+          <p>
+            Found a bug or have an idea? Open an issue on
+            <span class="gh-inline"
+              ><svg class="gh-icon" viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path fill="currentColor" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg>GitHub</span
+            >.
+          </p>
           <div class="cta-row">
             <a
               class="btn btn-primary"
               href="https://github.com/CodyKoInABox/cursor-plan-usage/issues/new?labels=bug&title=Bug%3A%20"
+              target="_blank"
               rel="noopener noreferrer"
               >Report a bug</a
             >
             <a
               class="btn btn-ghost"
               href="https://github.com/CodyKoInABox/cursor-plan-usage/issues/new?labels=enhancement&title=Feature%3A%20"
+              target="_blank"
               rel="noopener noreferrer"
               >Suggest a feature</a
             >
@@ -174,9 +222,11 @@ <h2>Open source</h2>
           <p>
             MIT licensed and fully readable on
             <a
+              class="gh-link"
               href="https://github.com/CodyKoInABox/cursor-plan-usage"
+              target="_blank"
               rel="noopener noreferrer"
-              >GitHub</a
+              ><svg class="gh-icon" viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path fill="currentColor" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg>GitHub</a
             >. Audit it, fork it, or send a pull request.
           </p>
         </div>
@@ -206,11 +256,17 @@ <h2>Native to Cursor</h2>
 
     <footer class="site-footer">
       <p>
-        <a href="https://github.com/CodyKoInABox/cursor-plan-usage" rel="noopener noreferrer"
+        <a
+          href="https://github.com/CodyKoInABox/cursor-plan-usage"
+          target="_blank"
+          rel="noopener noreferrer"
           >MIT</a
         >
         · Created by
-        <a href="https://github.com/CodyKoInABox" rel="noopener noreferrer"
+        <a
+          href="https://github.com/CodyKoInABox"
+          target="_blank"
+          rel="noopener noreferrer"
           >CodyKoInABox</a
         >
       </p>
diff --git a/docs/script.js b/docs/script.js
index bc5967b..0761e49 100644
--- a/docs/script.js
+++ b/docs/script.js
@@ -1,4 +1,11 @@
 (() => {
+  document.querySelectorAll("a[href]").forEach((a) => {
+    const href = a.getAttribute("href");
+    if (!href || href.startsWith("#")) return;
+    a.setAttribute("target", "_blank");
+    a.setAttribute("rel", "noopener noreferrer");
+  });
+
   const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
   const nodes = document.querySelectorAll(".reveal");
 
diff --git a/docs/styles.css b/docs/styles.css
index 0b56ce7..1eeb3d8 100644
--- a/docs/styles.css
+++ b/docs/styles.css
@@ -53,6 +53,24 @@ a:hover {
   color: color-mix(in srgb, var(--cm) 75%, white);
 }
 
+.gh-link,
+.gh-inline {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35em;
+}
+
+.gh-icon {
+  width: 1em;
+  height: 1em;
+  flex-shrink: 0;
+}
+
+.btn.gh-link .gh-icon {
+  width: 1.05em;
+  height: 1.05em;
+}
+
 code {
   font-size: 0.92em;
   padding: 0.1em 0.35em;
@@ -198,6 +216,13 @@ code {
   margin-top: -6vh;
 }
 
+.brand-hero-icon {
+  width: clamp(5.5rem, 12vw, 8rem);
+  height: auto;
+  margin: 0 0 1.15rem;
+  border-radius: 18px;
+}
+
 .brand-hero {
   margin: 0 0 0.85rem;
   font-family: var(--font-display);
@@ -285,7 +310,8 @@ code {
 .hero-visual {
   justify-self: end;
   display: flex;
-  align-items: center;
+  flex-direction: column;
+  align-items: flex-end;
   margin-right: calc(-1 * var(--pad));
   max-height: calc(100svh - 5.5rem);
 }
@@ -298,6 +324,23 @@ code {
   object-position: center right;
 }
 
+.shot-credit {
+  margin: 0.65rem 0 0;
+  font-size: 0.78rem;
+  color: var(--muted);
+  letter-spacing: 0.01em;
+}
+
+.shot-credit a {
+  color: var(--muted);
+  text-decoration: underline;
+  text-underline-offset: 0.15em;
+}
+
+.shot-credit a:hover {
+  color: var(--fg);
+}
+
 .section {
   max-width: var(--max);
   margin: 0 auto;
@@ -462,6 +505,10 @@ code {
 }
 
 @media (max-width: 960px) {
+  .site-header {
+    display: none;
+  }
+
   .hero {
     grid-template-columns: 1fr;
     align-items: start;
@@ -491,6 +538,7 @@ code {
 
   .hero-visual {
     justify-self: center;
+    align-items: center;
     width: 100%;
     margin-right: 0;
     margin-left: 0;
@@ -506,6 +554,11 @@ code {
     object-position: top center;
   }
 
+  .shot-credit {
+    text-align: center;
+    align-self: center;
+  }
+
   .usage-bars {
     display: none;
   }
@@ -529,15 +582,6 @@ code {
 }
 
 @media (max-width: 560px) {
-  .site-header {
-    padding-inline: var(--pad);
-  }
-
-  .site-header nav a:first-child,
-  .site-header nav a:nth-child(2) {
-    display: none;
-  }
-
   .brand-hero {
     font-size: clamp(2.1rem, 11vw, 2.8rem);
   }
diff --git a/package-lock.json b/package-lock.json
index f5dff60..87f22c1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "cursor-plan-usage",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "cursor-plan-usage",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "license": "MIT",
       "dependencies": {
         "sql.js": "^1.12.0"
diff --git a/package.json b/package.json
index fae2849..7096269 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "cursor-plan-usage",
   "displayName": "Cursor Plan Usage",
   "description": "Dockable sidebar showing Cursor Models and Other Models plan usage percentages.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "publisher": "CodyKoInABox",
   "license": "MIT",
   "icon": "resources/icon.png",
@@ -111,11 +111,15 @@
           "default": "absolute",
           "enum": [
             "absolute",
-            "usageSoFar"
+            "usageSoFar",
+            "sinceLastCommit",
+            "thisBranch"
           ],
           "enumDescriptions": [
             "Total usage in the current billing cycle (CM 45% · OM 20%).",
-            "Usage since you last pressed Reset in the sidebar (CM +4% · OM +2%)."
+            "Usage since you last pressed Reset in the sidebar (CM +4% · OM +2%).",
+            "Usage since last commit while the working tree is dirty (CM +1% · OM +0%).",
+            "Usage while the current feature branch was checked out (CM +3% · OM +1%)."
           ],
           "description": "What the status bar chip shows."
         },
diff --git a/src/extension.ts b/src/extension.ts
index 511e595..e3da379 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -10,10 +10,17 @@ import {
   setSessionTokenSecret,
 } from './auth';
 import { CursorApiError, fetchUsageSnapshot } from './api';
+import { type GitContext, watchGitContext } from './git';
 import { UsageViewProvider } from './usageViewProvider';
 import type { UsageSnapshot } from './types';
 import {
+  parseAnchoredBaseline,
+  parseBranchBaselinesState,
+  parseUsageSamples,
   parseUsageSoFarState,
+  SINCE_LAST_COMMIT_BASELINE_KEY,
+  THIS_BRANCH_BASELINES_KEY,
+  USAGE_SAMPLES_KEY,
   USAGE_SO_FAR_BASELINE_KEY,
   UsageWindowTracker,
 } from './usageWindows';
@@ -29,8 +36,8 @@ const BURST_WINDOW_MS = 2 * 60 * 1000;
 const BURST_POLL_MS = 30_000;
 const IDLE_POLL_MS = 3 * 60 * 1000;
 
-type RefreshReason = 'manual' | 'poll' | 'focus' | 'activity' | 'config';
-type StatusBarMode = 'absolute' | 'usageSoFar';
+type RefreshReason = 'manual' | 'poll' | 'focus' | 'activity' | 'config' | 'git';
+type StatusBarMode = 'absolute' | 'usageSoFar' | 'sinceLastCommit' | 'thisBranch';
 
 let pollTimer: ReturnType<typeof setTimeout> | undefined;
 let debounceTimer: ReturnType<typeof setTimeout> | undefined;
@@ -42,8 +49,34 @@ let lastActivityAt = 0;
 let lastStatusKey = '';
 let windowFocused = true;
 let lastSnapshot: UsageSnapshot | undefined;
+let lastGitContext: GitContext | undefined;
+/** False until watchGitContext emits once — avoids flashing stale git windows. */
+let gitReady = false;
 const windowTracker = new UsageWindowTracker();
 
+function stampGit(snapshot: UsageSnapshot): UsageSnapshot {
+  if (!gitReady || !lastGitContext) {
+    const { git: _g, sinceLastCommit: _s, thisBranch: _t, ...rest } = snapshot;
+    return rest;
+  }
+  const next: UsageSnapshot = {
+    ...snapshot,
+    git: {
+      repoName: lastGitContext.repoName,
+      branch: lastGitContext.branchName,
+      dirtyFiles: lastGitContext.dirtyFiles,
+      isDefaultBranch: lastGitContext.isDefaultBranch,
+    },
+  };
+  if (!lastGitContext.sinceLastCommitKey) {
+    delete next.sinceLastCommit;
+  }
+  if (!lastGitContext.thisBranchKey) {
+    delete next.thisBranch;
+  }
+  return next;
+}
+
 export function activate(context: vscode.ExtensionContext): void {
   const provider = new UsageViewProvider(context.extensionUri);
   const statusBar = vscode.window.createStatusBarItem(
@@ -64,20 +97,54 @@ export function activate(context: vscode.ExtensionContext): void {
     windowTracker.loadCustomBaseline(storedBaseline);
   }
 
-  const persistCustomBaselineIfNeeded = async (): Promise<void> => {
+  const storedSamples = parseUsageSamples(
+    context.globalState.get(USAGE_SAMPLES_KEY)
+  );
+  if (storedSamples.length) {
+    windowTracker.loadSamples(storedSamples);
+  }
+
+  // Defer loading git-derived baselines until git has spoken once.
+  let pendingStoredAnchor = parseAnchoredBaseline(
+    context.workspaceState.get(SINCE_LAST_COMMIT_BASELINE_KEY)
+  );
+  let pendingStoredBranches = parseBranchBaselinesState(
+    context.workspaceState.get(THIS_BRANCH_BASELINES_KEY)
+  );
+
+  const persistWindowsIfNeeded = async (): Promise<void> => {
     const toSave = windowTracker.takeCustomBaselineIfNeedsPersist();
     if (toSave) {
       await context.globalState.update(USAGE_SO_FAR_BASELINE_KEY, toSave);
     }
+    const samples = windowTracker.takeSamplesIfNeedsPersist();
+    if (samples) {
+      await context.globalState.update(USAGE_SAMPLES_KEY, samples);
+    }
+    const anchor = windowTracker.takeAnchorIfNeedsPersist();
+    if (anchor !== undefined) {
+      await context.workspaceState.update(
+        SINCE_LAST_COMMIT_BASELINE_KEY,
+        anchor === null ? undefined : anchor
+      );
+    }
+    const branches = windowTracker.takeBranchBaselinesIfNeedsPersist();
+    if (branches !== undefined) {
+      await context.workspaceState.update(
+        THIS_BRANCH_BASELINES_KEY,
+        branches === null ? undefined : branches
+      );
+    }
   };
 
   const applySnapshot = async (
     snapshot: UsageSnapshot,
     opts?: { force?: boolean }
   ): Promise<boolean> => {
-    lastSnapshot = snapshot;
-    await persistCustomBaselineIfNeeded();
-    return provider.showUsage(snapshot, opts);
+    const stamped = stampGit(snapshot);
+    lastSnapshot = stamped;
+    await persistWindowsIfNeeded();
+    return provider.showUsage(stamped, opts);
   };
 
   const runRefresh = async (opts: {
@@ -123,7 +190,7 @@ export function activate(context: vscode.ExtensionContext): void {
         lastSuccessAt = Date.now();
         const changed = await applySnapshot(snapshot, { force: !opts.silent });
         if (changed || !opts.silent) {
-          updateStatusBar(statusBar, snapshot);
+          updateStatusBar(statusBar, lastSnapshot ?? snapshot);
         }
       } catch (err) {
         if (err instanceof CursorApiError && err.status === 401) {
@@ -133,7 +200,7 @@ export function activate(context: vscode.ExtensionContext): void {
           const snapshot = windowTracker.attachWindows(raw);
           lastSuccessAt = Date.now();
           await applySnapshot(snapshot, { force: true });
-          updateStatusBar(statusBar, snapshot);
+          updateStatusBar(statusBar, lastSnapshot ?? snapshot);
           return;
         }
         throw err;
@@ -165,7 +232,7 @@ export function activate(context: vscode.ExtensionContext): void {
     }
     await context.globalState.update(USAGE_SO_FAR_BASELINE_KEY, state);
     if (lastSnapshot) {
-      const updated = windowTracker.overlayWindows(lastSnapshot);
+      const updated = stampGit(windowTracker.overlayWindows(lastSnapshot));
       lastSnapshot = updated;
       provider.showUsage(updated, { force: true });
       updateStatusBar(statusBar, updated);
@@ -178,7 +245,11 @@ export function activate(context: vscode.ExtensionContext): void {
     reason: RefreshReason,
     opts?: { silent?: boolean; force?: boolean }
   ): void => {
-    const force = opts?.force === true || reason === 'manual' || reason === 'config';
+    const force =
+      opts?.force === true ||
+      reason === 'manual' ||
+      reason === 'config' ||
+      reason === 'git';
     const silent = opts?.silent ?? reason !== 'manual';
     void runRefresh({ silent, force });
   };
@@ -251,6 +322,95 @@ export function activate(context: vscode.ExtensionContext): void {
 
   const activityWatcher = watchAiTrackingDb(onAiActivity);
 
+  const gitWatcher = watchGitContext((ctx) => {
+    const firstEmit = !gitReady;
+    gitReady = true;
+
+    if (firstEmit) {
+      if (pendingStoredBranches) {
+        windowTracker.loadBranchBaselines(pendingStoredBranches);
+        pendingStoredBranches = undefined;
+      }
+      if (
+        pendingStoredAnchor &&
+        ctx?.sinceLastCommitKey === pendingStoredAnchor.key
+      ) {
+        windowTracker.loadAnchor(pendingStoredAnchor);
+      } else if (pendingStoredAnchor) {
+        void context.workspaceState.update(
+          SINCE_LAST_COMMIT_BASELINE_KEY,
+          undefined
+        );
+      }
+      pendingStoredAnchor = undefined;
+    }
+
+    const prevCommitKey = lastGitContext?.sinceLastCommitKey;
+    const prevBranchKey = lastGitContext?.thisBranchKey;
+    lastGitContext = ctx;
+
+    const commitNext = windowTracker.setAnchor(ctx?.sinceLastCommitKey);
+    const branchChanged = windowTracker.setThisBranchKey(ctx?.thisBranchKey);
+
+    if (commitNext === null) {
+      void context.workspaceState.update(
+        SINCE_LAST_COMMIT_BASELINE_KEY,
+        undefined
+      );
+    } else if (commitNext) {
+      void context.workspaceState.update(SINCE_LAST_COMMIT_BASELINE_KEY, commitNext);
+    }
+    if (branchChanged) {
+      const branches = windowTracker.takeBranchBaselinesIfNeedsPersist();
+      if (branches !== undefined) {
+        void context.workspaceState.update(
+          THIS_BRANCH_BASELINES_KEY,
+          branches === null ? undefined : branches
+        );
+      }
+    }
+
+    const commitKeySame =
+      prevCommitKey === (ctx?.sinceLastCommitKey ?? undefined);
+    const branchKeySame =
+      prevBranchKey === (ctx?.thisBranchKey ?? undefined);
+    const metadataOnly =
+      !firstEmit &&
+      commitNext === undefined &&
+      !branchChanged &&
+      commitKeySame &&
+      branchKeySame;
+
+    if (metadataOnly) {
+      if (lastSnapshot) {
+        const updated = stampGit(windowTracker.overlayWindows(lastSnapshot));
+        lastSnapshot = updated;
+        provider.showUsage(updated, { force: true });
+        updateStatusBar(statusBar, updated);
+      }
+      return;
+    }
+
+    if (
+      firstEmit &&
+      commitNext === undefined &&
+      !branchChanged &&
+      lastSnapshot
+    ) {
+      const updated = stampGit(windowTracker.overlayWindows(lastSnapshot));
+      lastSnapshot = updated;
+      provider.showUsage(updated, { force: true });
+      updateStatusBar(statusBar, updated);
+      // Still refresh if we activated a branch pending samples / need live baseline.
+      if (ctx?.thisBranchKey || ctx?.sinceLastCommitKey) {
+        requestRefresh('git', { silent: true, force: true });
+      }
+      return;
+    }
+
+    requestRefresh('git', { silent: true, force: true });
+  });
+
   context.subscriptions.push(
     vscode.window.registerWebviewViewProvider(UsageViewProvider.viewId, provider, {
       webviewOptions: { retainContextWhenHidden: true },
@@ -319,7 +479,8 @@ export function activate(context: vscode.ExtensionContext): void {
         }
       },
     },
-    activityWatcher
+    activityWatcher,
+    gitWatcher
   );
 
   void (async () => {
@@ -386,7 +547,24 @@ function fmtSinceClock(iso: string): string {
   if (Number.isNaN(d.getTime())) {
     return 'reset';
   }
-  return d.toLocaleString();
+  const clock = {
+    hour: '2-digit' as const,
+    minute: '2-digit' as const,
+    hour12: false as const,
+  };
+  const now = new Date();
+  const sameDay =
+    d.getFullYear() === now.getFullYear() &&
+    d.getMonth() === now.getMonth() &&
+    d.getDate() === now.getDate();
+  if (sameDay) {
+    return d.toLocaleTimeString(undefined, clock);
+  }
+  return d.toLocaleString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    ...clock,
+  });
 }
 
 function updateStatusBar(
@@ -399,6 +577,55 @@ function updateStatusBar(
   const cm = Math.round(snapshot.autoPercentUsed);
   const om = Math.round(snapshot.apiPercentUsed);
   const soFar = snapshot.usageSoFar;
+  const sinceCommit = snapshot.sinceLastCommit;
+  const thisBranch = snapshot.thisBranch;
+
+  if (mode === 'thisBranch' && thisBranch) {
+    const key = [
+      'thisBranch',
+      snapshot.planName,
+      thisBranch.autoPercentDelta,
+      thisBranch.apiPercentDelta,
+      thisBranch.since,
+      snapshot.git?.branch ?? '',
+    ].join('|');
+    if (key === lastStatusKey) {
+      return;
+    }
+    lastStatusKey = key;
+    item.text = `$(git-branch) CM +${thisBranch.autoPercentDelta}% · OM +${thisBranch.apiPercentDelta}%`;
+    item.tooltip = [
+      `Cursor Plan Usage — ${snapshot.planName}`,
+      `This branch${snapshot.git?.branch ? ` (${snapshot.git.branch})` : ''} since ${fmtSinceClock(thisBranch.since)}`,
+      `Cursor Models +${thisBranch.autoPercentDelta}%`,
+      `Other Models +${thisBranch.apiPercentDelta}%`,
+      `Cycle total — CM ${cm}% · OM ${om}%`,
+    ].join('\n');
+    return;
+  }
+
+  if (mode === 'sinceLastCommit' && sinceCommit) {
+    const key = [
+      'sinceCommit',
+      snapshot.planName,
+      sinceCommit.autoPercentDelta,
+      sinceCommit.apiPercentDelta,
+      sinceCommit.since,
+    ].join('|');
+    if (key === lastStatusKey) {
+      return;
+    }
+    lastStatusKey = key;
+    item.text = `$(git-commit) CM +${sinceCommit.autoPercentDelta}% · OM +${sinceCommit.apiPercentDelta}%`;
+    item.tooltip = [
+      `Cursor Plan Usage — ${snapshot.planName}`,
+      `Since last commit (since ${fmtSinceClock(sinceCommit.since)})`,
+      `Cursor Models +${sinceCommit.autoPercentDelta}%`,
+      `Other Models +${sinceCommit.apiPercentDelta}%`,
+      `Cycle total — CM ${cm}% · OM ${om}%`,
+    ].join('\n');
+    return;
+  }
 
   if (mode === 'usageSoFar' && soFar) {
     const key = [
diff --git a/src/git.ts b/src/git.ts
new file mode 100644
index 0000000..11515d6
--- /dev/null
+++ b/src/git.ts
@@ -0,0 +1,385 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+
+/** Minimal subset of the built-in vscode.git extension API. */
+interface GitExtension {
+  getAPI(version: 1): GitAPI;
+}
+
+interface GitAPI {
+  repositories: Repository[];
+  onDidOpenRepository: vscode.Event<Repository>;
+  onDidCloseRepository: vscode.Event<Repository>;
+}
+
+interface GitRef {
+  name?: string;
+  commit?: string;
+}
+
+interface Repository {
+  rootUri: vscode.Uri;
+  state: RepositoryState;
+  getRefs?(
+    query: { pattern?: string },
+    token?: vscode.CancellationToken
+  ): Promise<GitRef[]>;
+}
+
+interface RepositoryState {
+  HEAD: { name?: string; commit?: string } | undefined;
+  remotes: readonly { name: string }[];
+  workingTreeChanges: readonly unknown[];
+  indexChanges: readonly unknown[];
+  mergeChanges: readonly unknown[];
+  onDidChange: vscode.Event<void>;
+}
+
+/** Unified git snapshot for Since last commit + This branch. */
+export interface GitContext {
+  repoRoot: string;
+  repoName: string;
+  branchName?: string;
+  isDefaultBranch: boolean;
+  headCommit?: string;
+  dirtyFiles: number;
+  /** Present only when dirty — drives Since last commit. */
+  sinceLastCommitKey?: string;
+  /** Present only when named + !isDefaultBranch — drives This branch. */
+  thisBranchKey?: string;
+}
+
+/** @deprecated Use GitContext; kept for any external imports. */
+export type GitAnchor = {
+  key: string;
+  repoName: string;
+  branch?: string;
+  dirtyFiles: number;
+};
+
+const DEBOUNCE_MS = 500;
+const FALLBACK_DEFAULTS = ['main', 'master', 'develop'] as const;
+
+/** Cached default branch short name per repo root. */
+const defaultBranchCache = new Map<string, string | undefined>();
+
+function getGitApi(): GitAPI | undefined {
+  const ext = vscode.extensions.getExtension<GitExtension>('vscode.git');
+  if (!ext) {
+    return undefined;
+  }
+  try {
+    if (!ext.isActive) {
+      void ext.activate();
+      return undefined;
+    }
+    return ext.exports.getAPI(1);
+  } catch {
+    return undefined;
+  }
+}
+
+function repoContainsUri(repo: Repository, uri: vscode.Uri): boolean {
+  const root = repo.rootUri.fsPath.replace(/\\/g, '/').toLowerCase();
+  const file = uri.fsPath.replace(/\\/g, '/').toLowerCase();
+  return (
+    file === root || file.startsWith(root.endsWith('/') ? root : `${root}/`)
+  );
+}
+
+function pickRepo(api: GitAPI): Repository | undefined {
+  const repos = api.repositories;
+  if (!repos.length) {
+    return undefined;
+  }
+  const active = vscode.window.activeTextEditor?.document.uri;
+  if (active && active.scheme === 'file') {
+    const match = repos.find((r) => repoContainsUri(r, active));
+    if (match) {
+      return match;
+    }
+  }
+  return repos[0];
+}
+
+function shortBranchName(refName: string): string {
+  // refs/remotes/origin/HEAD → often reported as origin/HEAD; resolve target later
+  const parts = refName.replace(/^refs\//, '').split('/');
+  return parts[parts.length - 1] ?? refName;
+}
+
+/**
+ * Resolve the repo default branch short name.
+ * Prefer remote HEAD (origin/HEAD → main); else local main/master/develop.
+ */
+async function resolveDefaultBranch(repo: Repository): Promise<string | undefined> {
+  const root = repo.rootUri.fsPath;
+  if (defaultBranchCache.has(root)) {
+    return defaultBranchCache.get(root);
+  }
+
+  let resolved: string | undefined;
+
+  if (typeof repo.getRefs === 'function') {
+    try {
+      const heads = await repo.getRefs({ pattern: 'refs/remotes/*/HEAD' });
+      for (const ref of heads) {
+        const name = ref.name ?? '';
+        // Symbolic remote HEAD is often stored as the target name in some APIs;
+        // also try reading refs/remotes/origin/main style from commit match.
+        if (/\/HEAD$/i.test(name) || name.endsWith('HEAD')) {
+          // Some git APIs give name like "origin/HEAD" with commit of default tip.
+          // Look for a remote branch with the same commit.
+          if (ref.commit) {
+            const remotes = await repo.getRefs({ pattern: 'refs/remotes/*/*' });
+            const match = remotes.find(
+              (r) =>
+                r.commit === ref.commit &&
+                r.name &&
+                !/\/HEAD$/i.test(r.name)
+            );
+            if (match?.name) {
+              const segs = match.name.replace(/^refs\/remotes\//, '').split('/');
+              // origin/main → main
+              resolved = segs.slice(1).join('/') || segs[segs.length - 1];
+              break;
+            }
+          }
+        }
+      }
+
+      if (!resolved) {
+        for (const candidate of FALLBACK_DEFAULTS) {
+          const locals = await repo.getRefs({
+            pattern: `refs/heads/${candidate}`,
+          });
+          if (locals.some((r) => shortBranchName(r.name ?? '') === candidate)) {
+            resolved = candidate;
+            break;
+          }
+        }
+      }
+    } catch {
+      // fall through
+    }
+  }
+
+  if (!resolved) {
+    // Sync fallback when getRefs unavailable: HEAD name if classic default.
+    const head = repo.state.HEAD?.name;
+    if (head && (FALLBACK_DEFAULTS as readonly string[]).includes(head)) {
+      resolved = head;
+    } else {
+      resolved = 'main';
+    }
+  }
+
+  defaultBranchCache.set(root, resolved);
+  return resolved;
+}
+
+function isDefaultBranchName(
+  branchName: string | undefined,
+  defaultName: string | undefined
+): boolean {
+  if (!branchName) {
+    return true; // detached → treat as "not a feature branch"
+  }
+  if (defaultName && branchName === defaultName) {
+    return true;
+  }
+  // Last-resort: classic names when detection failed oddly
+  if (!defaultName && (branchName === 'main' || branchName === 'master')) {
+    return true;
+  }
+  return false;
+}
+
+async function computeContext(
+  api: GitAPI | undefined
+): Promise<GitContext | undefined> {
+  if (!api) {
+    return undefined;
+  }
+  const repo = pickRepo(api);
+  if (!repo) {
+    return undefined;
+  }
+  const s = repo.state;
+  const dirtyFiles =
+    s.workingTreeChanges.length +
+    s.indexChanges.length +
+    s.mergeChanges.length;
+  const root = repo.rootUri.fsPath;
+  const repoName = path.basename(root) || 'repo';
+  const branchName = s.HEAD?.name;
+  const headCommit = s.HEAD?.commit;
+  const defaultName = await resolveDefaultBranch(repo);
+  const isDefault = isDefaultBranchName(branchName, defaultName);
+
+  const ctx: GitContext = {
+    repoRoot: root,
+    repoName,
+    branchName,
+    isDefaultBranch: isDefault,
+    headCommit,
+    dirtyFiles,
+  };
+
+  if (dirtyFiles > 0) {
+    ctx.sinceLastCommitKey = `${root}@${headCommit ?? 'none'}`;
+  }
+  if (branchName && !isDefault) {
+    ctx.thisBranchKey = `${root}@${branchName}`;
+  }
+
+  return ctx;
+}
+
+/**
+ * Watch the active git repo. Emits a full GitContext when the API is usable,
+ * or undefined when there is no repo / git is unavailable.
+ * Callers hide git-derived windows until the first non-pending emit.
+ */
+export function watchGitContext(
+  onChange: (ctx: GitContext | undefined) => void
+): vscode.Disposable {
+  const disposables: vscode.Disposable[] = [];
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let lastSig = '';
+  let repoListeners: vscode.Disposable[] = [];
+  let computing = false;
+  let computeAgain = false;
+
+  const emit = (): void => {
+    if (computing) {
+      computeAgain = true;
+      return;
+    }
+    computing = true;
+    void (async () => {
+      try {
+        do {
+          computeAgain = false;
+          const ctx = await computeContext(getGitApi());
+          const sig = ctx
+            ? [
+                ctx.repoRoot,
+                ctx.branchName ?? '',
+                ctx.isDefaultBranch ? '1' : '0',
+                ctx.headCommit ?? '',
+                String(ctx.dirtyFiles),
+                ctx.sinceLastCommitKey ?? '',
+                ctx.thisBranchKey ?? '',
+              ].join('|')
+            : '';
+          if (sig === lastSig) {
+            continue;
+          }
+          lastSig = sig;
+          onChange(ctx);
+        } while (computeAgain);
+      } finally {
+        computing = false;
+      }
+    })();
+  };
+
+  const schedule = (): void => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = undefined;
+      emit();
+    }, DEBOUNCE_MS);
+  };
+
+  const bindRepos = (): void => {
+    for (const d of repoListeners) {
+      d.dispose();
+    }
+    repoListeners = [];
+    const api = getGitApi();
+    if (!api) {
+      return;
+    }
+    for (const repo of api.repositories) {
+      repoListeners.push(repo.state.onDidChange(schedule));
+    }
+  };
+
+  const api = getGitApi();
+  if (api) {
+    disposables.push(
+      api.onDidOpenRepository(() => {
+        defaultBranchCache.clear();
+        bindRepos();
+        schedule();
+      })
+    );
+    disposables.push(
+      api.onDidCloseRepository(() => {
+        defaultBranchCache.clear();
+        bindRepos();
+        schedule();
+      })
+    );
+    bindRepos();
+  }
+
+  disposables.push(
+    vscode.window.onDidChangeActiveTextEditor(() => {
+      bindRepos();
+      schedule();
+    }),
+    vscode.extensions.onDidChange(() => {
+      bindRepos();
+      schedule();
+    })
+  );
+
+  schedule();
+
+  const ext = vscode.extensions.getExtension('vscode.git');
+  if (ext && !ext.isActive) {
+    void ext.activate().then(() => {
+      bindRepos();
+      schedule();
+    });
+  }
+
+  return {
+    dispose: () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+      for (const d of repoListeners) {
+        d.dispose();
+      }
+      repoListeners = [];
+      for (const d of disposables) {
+        d.dispose();
+      }
+    },
+  };
+}
+
+/** @deprecated Prefer watchGitContext. */
+export function watchGitAnchor(
+  onChange: (anchor: GitAnchor | undefined) => void
+): vscode.Disposable {
+  return watchGitContext((ctx) => {
+    if (!ctx?.sinceLastCommitKey) {
+      onChange(undefined);
+      return;
+    }
+    onChange({
+      key: ctx.sinceLastCommitKey,
+      repoName: ctx.repoName,
+      branch: ctx.branchName,
+      dirtyFiles: ctx.dirtyFiles,
+    });
+  });
+}
diff --git a/src/media/view.js b/src/media/view.js
index c44ca80..361a7a8 100644
--- a/src/media/view.js
+++ b/src/media/view.js
@@ -48,6 +48,7 @@
       year: 'numeric',
       hour: '2-digit',
       minute: '2-digit',
+      hour12: false,
     });
   }
 
@@ -139,6 +140,7 @@
       const clock = {
         hour: '2-digit',
         minute: '2-digit',
+        hour12: false,
       };
 
       if (kind === 'hour') {
@@ -156,11 +158,7 @@
         return { text: 'rolling 1h' };
       }
 
-      if (kind === 'session') {
-        return { text: `since ${d.toLocaleTimeString(undefined, clock)}` };
-      }
-
-      if (kind === 'custom') {
+      if (kind === 'session' || kind === 'custom') {
         const now = new Date();
         const sameDay =
           d.getFullYear() === now.getFullYear() &&
@@ -225,6 +223,72 @@
     );
   }
 
+  function sinceLastCommitSubtitle(w, git) {
+    const tip =
+      'Plan usage since your working tree went dirty at this HEAD. Not attributed to specific files.';
+    if (git && (git.branch || git.dirtyFiles)) {
+      const parts = [];
+      if (git.branch) parts.push(String(git.branch));
+      if (git.dirtyFiles) {
+        const n = git.dirtyFiles;
+        parts.push(`${n} file${n === 1 ? '' : 's'}`);
+      }
+      return { text: parts.join(' · '), tip };
+    }
+    const since = sinceInfo(w, 'custom');
+    return since ? { text: since.text, tip } : { text: '', tip };
+  }
+
+  function renderSinceLastCommit(w, git) {
+    if (!w) return '';
+    const sub = sinceLastCommitSubtitle(w, git);
+    return (
+      `<hr class="divider" />` +
+      `<section class="section section-since-last-commit">` +
+      `<div class="section-head">` +
+      `<h2 class="section-title" title="${esc(sub.tip)}">Since last commit</h2>` +
+      `</div>` +
+      (sub.text
+        ? `<p class="subtitle usage-so-far-since" title="${esc(sub.tip)}">${esc(sub.text)}</p>`
+        : '') +
+      `<div class="window-stats window-stats-block">` +
+      `<span class="window-stat window-stat-cm">CM ${esc(fmtDeltaPct(w.autoPercentDelta))}</span>` +
+      `<span class="window-stat window-stat-om">OM ${esc(fmtDeltaPct(w.apiPercentDelta))}</span>` +
+      `</div>` +
+      `</section>`
+    );
+  }
+
+  function thisBranchSubtitle(w, git) {
+    const tip =
+      'Plan usage while this branch was checked out (since we first saw it). Not attributed to commits or files.';
+    const since = sinceInfo(w, 'custom');
+    const parts = [];
+    if (git && git.branch) parts.push(String(git.branch));
+    if (since && since.text) parts.push(since.text);
+    return { text: parts.join(' · '), tip };
+  }
+
+  function renderThisBranch(w, git) {
+    if (!w) return '';
+    const sub = thisBranchSubtitle(w, git);
+    return (
+      `<hr class="divider" />` +
+      `<section class="section section-this-branch">` +
+      `<div class="section-head">` +
+      `<h2 class="section-title" title="${esc(sub.tip)}">This branch</h2>` +
+      `</div>` +
+      (sub.text
+        ? `<p class="subtitle usage-so-far-since" title="${esc(sub.tip)}">${esc(sub.text)}</p>`
+        : '') +
+      `<div class="window-stats window-stats-block">` +
+      `<span class="window-stat window-stat-cm">CM ${esc(fmtDeltaPct(w.autoPercentDelta))}</span>` +
+      `<span class="window-stat window-stat-om">OM ${esc(fmtDeltaPct(w.apiPercentDelta))}</span>` +
+      `</div>` +
+      `</section>`
+    );
+  }
+
   function renderLoading() {
     app.innerHTML = '<div class="state state-loading">Loading plan usage…</div>';
   }
@@ -268,6 +332,11 @@
       : '';
 
     const usageSoFar = renderUsageSoFar(data.usageSoFar);
+    const sinceLastCommit = renderSinceLastCommit(
+      data.sinceLastCommit,
+      data.git
+    );
+    const thisBranch = renderThisBranch(data.thisBranch, data.git);
 
     const windows =
       data.lastHour || data.session
@@ -304,6 +373,8 @@
         cyclePct
       ) +
       usageSoFar +
+      sinceLastCommit +
+      thisBranch +
       windows +
       `<hr class="divider" />` +
       `<div class="footer">` +
diff --git a/src/types.ts b/src/types.ts
index c50d312..9d1b85b 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -17,6 +17,17 @@ export interface UsageSnapshot {
   session?: UsageWindow;
   /** User-resettable window; baseline persisted across reloads. */
   usageSoFar?: UsageWindow;
+  /** Usage since HEAD while the working tree is dirty. */
+  sinceLastCommit?: UsageWindow;
+  /** Usage while the current feature branch was checked out (active-time). */
+  thisBranch?: UsageWindow;
+  /** Active git repo metadata for git-derived windows. */
+  git?: {
+    repoName: string;
+    branch?: string;
+    dirtyFiles: number;
+    isDefaultBranch?: boolean;
+  };
 }
 
 /** Delta for a time window relative to a baseline sample. */
diff --git a/src/usageViewProvider.ts b/src/usageViewProvider.ts
index 8585fa2..a5116eb 100644
--- a/src/usageViewProvider.ts
+++ b/src/usageViewProvider.ts
@@ -186,7 +186,13 @@ function sameUsage(a: UsageSnapshot | undefined, b: UsageSnapshot): boolean {
     a.billingCycleEnd === b.billingCycleEnd &&
     sameWindow(a.lastHour, b.lastHour) &&
     sameWindow(a.session, b.session) &&
-    sameWindow(a.usageSoFar, b.usageSoFar)
+    sameWindow(a.usageSoFar, b.usageSoFar) &&
+    sameWindow(a.sinceLastCommit, b.sinceLastCommit) &&
+    sameWindow(a.thisBranch, b.thisBranch) &&
+    a.git?.dirtyFiles === b.git?.dirtyFiles &&
+    a.git?.branch === b.git?.branch &&
+    a.git?.repoName === b.git?.repoName &&
+    a.git?.isDefaultBranch === b.git?.isDefaultBranch
   );
 }
 
diff --git a/src/usageWindows.test.ts b/src/usageWindows.test.ts
index 2d3755e..4a48a40 100644
--- a/src/usageWindows.test.ts
+++ b/src/usageWindows.test.ts
@@ -3,7 +3,11 @@ import { describe, expect, it } from 'vitest';
 import type { UsageSnapshot } from './types';
 import {
   isUsageSample,
+  parseAnchoredBaseline,
+  parseBranchBaselinesState,
+  parseUsageSamples,
   parseUsageSoFarState,
+  THIS_BRANCH_MAP_CAP,
   UsageWindowTracker,
 } from './usageWindows';
 
@@ -53,6 +57,61 @@ describe('persisted usage state parsing', () => {
     expect(parseUsageSoFarState(sample)).toEqual({ baseline: sample });
     expect(parseUsageSoFarState({ baseline: {} })).toBeUndefined();
   });
+
+  it('parses a sample ring and skips garbage', () => {
+    expect(parseUsageSamples(null)).toEqual([]);
+    expect(parseUsageSamples({})).toEqual([]);
+    expect(
+      parseUsageSamples([sample, { at: 'bad' }, null, sample])
+    ).toEqual([sample, sample]);
+  });
+
+  it('parses keyed since-last-commit anchors', () => {
+    expect(
+      parseAnchoredBaseline({
+        key: '/repo@abc',
+        baseline: sample,
+        cycleKey: 'start:2026-07-01',
+      })
+    ).toEqual({
+      key: '/repo@abc',
+      baseline: sample,
+      cycleKey: 'start:2026-07-01',
+    });
+    expect(parseAnchoredBaseline({ key: '', baseline: sample })).toBeUndefined();
+    expect(parseAnchoredBaseline({ key: '/repo@abc', baseline: {} })).toBeUndefined();
+  });
+
+  it('parses branch baseline maps and rejects garbage', () => {
+    expect(parseBranchBaselinesState(null)).toBeUndefined();
+    expect(parseBranchBaselinesState({ entries: [] })).toBeUndefined();
+    expect(
+      parseBranchBaselinesState({
+        cycleKey: 'start:2026-07-01',
+        activeKey: '/repo@feat',
+        entries: {
+          '/repo@feat': {
+            accumulatedAuto: 1.5,
+            accumulatedApi: 2,
+            startedAt: BASE_TIME,
+            lastSeenAt: BASE_TIME + 1000,
+          },
+          bad: { accumulatedAuto: 'x' },
+        },
+      })
+    ).toEqual({
+      cycleKey: 'start:2026-07-01',
+      activeKey: '/repo@feat',
+      entries: {
+        '/repo@feat': {
+          accumulatedAuto: 1.5,
+          accumulatedApi: 2,
+          startedAt: BASE_TIME,
+          lastSeenAt: BASE_TIME + 1000,
+        },
+      },
+    });
+  });
 });
 
 describe('UsageWindowTracker', () => {
@@ -119,9 +178,57 @@ describe('UsageWindowTracker', () => {
     expect(tracker.takeCustomBaselineIfNeedsPersist()).toBeUndefined();
   });
 
+  it('round-trips the sample ring so last-hour survives a restart', () => {
+    const a = new UsageWindowTracker();
+    a.record(snapshot(10, 20), BASE_TIME);
+    a.record(snapshot(12, 24), BASE_TIME + 30 * MINUTE_MS);
+    a.record(snapshot(15, 29), BASE_TIME + 90 * MINUTE_MS);
+
+    const persisted = a.takeSamplesIfNeedsPersist();
+    expect(persisted).toBeDefined();
+    expect(a.takeSamplesIfNeedsPersist()).toBeUndefined();
+
+    const b = new UsageWindowTracker();
+    b.loadSamples(persisted!, BASE_TIME + 90 * MINUTE_MS);
+    expect(b.lastHour(BASE_TIME + 90 * MINUTE_MS)).toMatchObject({
+      autoPercentDelta: 3,
+      apiPercentDelta: 5,
+      since: new Date(BASE_TIME + 30 * MINUTE_MS).toISOString(),
+      partial: false,
+      outdated: false,
+    });
+  });
+
+  it('does not seed session from loaded samples', () => {
+    const a = new UsageWindowTracker();
+    a.record(snapshot(10, 20), BASE_TIME);
+    a.record(snapshot(14, 28), BASE_TIME + 45 * MINUTE_MS);
+    const persisted = a.takeSamplesIfNeedsPersist()!;
+
+    const b = new UsageWindowTracker();
+    b.loadSamples(persisted, BASE_TIME + 45 * MINUTE_MS);
+    const reopenAt = BASE_TIME + 50 * MINUTE_MS;
+    b.record(snapshot(15, 30), reopenAt);
+
+    expect(b.session()).toMatchObject({
+      autoPercentDelta: 0,
+      apiPercentDelta: 0,
+      since: new Date(reopenAt).toISOString(),
+      partial: false,
+    });
+    expect(b.lastHour(reopenAt)).toMatchObject({
+      autoPercentDelta: 5,
+      apiPercentDelta: 10,
+      since: new Date(BASE_TIME).toISOString(),
+      partial: true,
+    });
+  });
+
   it('resets all windows when the billing cycle changes', () => {
     const tracker = new UsageWindowTracker();
     tracker.record(snapshot(90, 80), BASE_TIME);
+    expect(tracker.takeSamplesIfNeedsPersist()?.length).toBe(1);
+
     tracker.record(
       snapshot(2, 3, {
         billingCycleStart: '2026-08-01',
@@ -142,6 +249,13 @@ describe('UsageWindowTracker', () => {
     expect(tracker.takeCustomBaselineIfNeedsPersist()?.cycleKey).toBe(
       'start:2026-08-01'
     );
+    expect(tracker.takeSamplesIfNeedsPersist()).toEqual([
+      {
+        at: BASE_TIME + MINUTE_MS,
+        autoPercentUsed: 2,
+        apiPercentUsed: 3,
+      },
+    ]);
   });
 
   it('also detects rollover when cumulative usage drops significantly', () => {
@@ -155,4 +269,197 @@ describe('UsageWindowTracker', () => {
       since: new Date(BASE_TIME + MINUTE_MS).toISOString(),
     });
   });
+
+  it('applies a pending since-last-commit anchor on the first sample', () => {
+    const tracker = new UsageWindowTracker();
+    expect(tracker.setAnchor('/repo@aaa')).toBeUndefined();
+    expect(tracker.sinceLastCommit()).toBeUndefined();
+
+    tracker.record(snapshot(10, 20), BASE_TIME);
+    expect(tracker.sinceLastCommit()).toMatchObject({
+      autoPercentDelta: 0,
+      apiPercentDelta: 0,
+      since: new Date(BASE_TIME).toISOString(),
+    });
+    expect(tracker.takeAnchorIfNeedsPersist()).toMatchObject({
+      key: '/repo@aaa',
+      baseline: {
+        at: BASE_TIME,
+        autoPercentUsed: 10,
+        apiPercentUsed: 20,
+      },
+    });
+  });
+
+  it('re-anchors on key change and no-ops on the same key', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(10, 20), BASE_TIME);
+    expect(tracker.setAnchor('/repo@aaa')).toMatchObject({ key: '/repo@aaa' });
+    tracker.record(snapshot(12, 25), BASE_TIME + MINUTE_MS);
+
+    expect(tracker.sinceLastCommit()).toMatchObject({
+      autoPercentDelta: 2,
+      apiPercentDelta: 5,
+    });
+    expect(tracker.setAnchor('/repo@aaa')).toBeUndefined();
+    expect(tracker.sinceLastCommit()).toMatchObject({
+      autoPercentDelta: 2,
+      apiPercentDelta: 5,
+    });
+
+    expect(tracker.setAnchor('/repo@bbb')).toMatchObject({
+      key: '/repo@bbb',
+      baseline: {
+        at: BASE_TIME + MINUTE_MS,
+        autoPercentUsed: 12,
+        apiPercentUsed: 25,
+      },
+    });
+    expect(tracker.sinceLastCommit()).toMatchObject({
+      autoPercentDelta: 0,
+      apiPercentDelta: 0,
+    });
+  });
+
+  it('clears since-last-commit when the anchor key is removed', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(10, 20), BASE_TIME);
+    tracker.setAnchor('/repo@aaa');
+    expect(tracker.sinceLastCommit()).toBeDefined();
+
+    expect(tracker.setAnchor(undefined)).toBeNull();
+    expect(tracker.sinceLastCommit()).toBeUndefined();
+    expect(tracker.setAnchor(undefined)).toBeUndefined();
+  });
+
+  it('drops the since-last-commit anchor on billing cycle rollover', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(90, 80), BASE_TIME);
+    tracker.setAnchor('/repo@aaa');
+    tracker.record(snapshot(92, 81), BASE_TIME + MINUTE_MS);
+    expect(tracker.sinceLastCommit()?.autoPercentDelta).toBe(2);
+
+    tracker.record(
+      snapshot(2, 3, {
+        billingCycleStart: '2026-08-01',
+        billingCycleEnd: '2026-09-01',
+      }),
+      BASE_TIME + 2 * MINUTE_MS
+    );
+
+    expect(tracker.sinceLastCommit()).toBeUndefined();
+    expect(tracker.takeAnchorIfNeedsPersist()).toBeNull();
+  });
+
+  it('tracks this-branch active-time with pause and resume', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(10, 20), BASE_TIME);
+    expect(tracker.setThisBranchKey('/repo@feat', BASE_TIME)).toBe(true);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 0,
+      apiPercentDelta: 0,
+      since: new Date(BASE_TIME).toISOString(),
+    });
+
+    tracker.record(snapshot(12, 23), BASE_TIME + MINUTE_MS);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 2,
+      apiPercentDelta: 3,
+    });
+
+    // Leave feature branch (e.g. checkout main) — freeze accumulated.
+    expect(tracker.setThisBranchKey(undefined, BASE_TIME + 2 * MINUTE_MS)).toBe(
+      true
+    );
+    expect(tracker.thisBranch()).toBeUndefined();
+
+    // Usage while away must not count.
+    tracker.record(snapshot(20, 40), BASE_TIME + 3 * MINUTE_MS);
+    expect(tracker.thisBranch()).toBeUndefined();
+
+    // Return — resume at frozen 2/3, then only new active spend adds.
+    expect(
+      tracker.setThisBranchKey('/repo@feat', BASE_TIME + 4 * MINUTE_MS)
+    ).toBe(true);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 2,
+      apiPercentDelta: 3,
+    });
+    tracker.record(snapshot(21, 41), BASE_TIME + 5 * MINUTE_MS);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 3,
+      apiPercentDelta: 4,
+    });
+  });
+
+  it('restores accumulated when switching between feature branches', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(10, 10), BASE_TIME);
+    tracker.setThisBranchKey('/repo@a', BASE_TIME);
+    tracker.record(snapshot(13, 12), BASE_TIME + MINUTE_MS);
+    expect(tracker.thisBranch()?.autoPercentDelta).toBe(3);
+
+    tracker.setThisBranchKey('/repo@b', BASE_TIME + 2 * MINUTE_MS);
+    tracker.record(snapshot(15, 14), BASE_TIME + 3 * MINUTE_MS);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 2,
+      apiPercentDelta: 2,
+    });
+
+    tracker.setThisBranchKey('/repo@a', BASE_TIME + 4 * MINUTE_MS);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 3,
+      apiPercentDelta: 2,
+    });
+  });
+
+  it('applies a pending this-branch key on the first sample', () => {
+    const tracker = new UsageWindowTracker();
+    expect(tracker.setThisBranchKey('/repo@feat', BASE_TIME)).toBe(false);
+    expect(tracker.thisBranch()).toBeUndefined();
+    tracker.record(snapshot(5, 5), BASE_TIME);
+    expect(tracker.thisBranch()).toMatchObject({
+      autoPercentDelta: 0,
+      apiPercentDelta: 0,
+    });
+  });
+
+  it('wipes this-branch map on billing cycle rollover', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(50, 50), BASE_TIME);
+    tracker.setThisBranchKey('/repo@feat', BASE_TIME);
+    tracker.record(snapshot(55, 55), BASE_TIME + MINUTE_MS);
+    expect(tracker.thisBranch()?.autoPercentDelta).toBe(5);
+
+    tracker.record(
+      snapshot(1, 1, {
+        billingCycleStart: '2026-08-01',
+        billingCycleEnd: '2026-09-01',
+      }),
+      BASE_TIME + 2 * MINUTE_MS
+    );
+    expect(tracker.thisBranch()).toBeUndefined();
+    expect(tracker.takeBranchBaselinesIfNeedsPersist()).toBeNull();
+  });
+
+  it('evicts the oldest paused branch when the map exceeds the cap', () => {
+    const tracker = new UsageWindowTracker();
+    tracker.record(snapshot(1, 1), BASE_TIME);
+
+    for (let i = 0; i < THIS_BRANCH_MAP_CAP; i++) {
+      const t = BASE_TIME + i * MINUTE_MS;
+      tracker.setThisBranchKey(`/repo@b${i}`, t);
+      tracker.record(snapshot(1 + i * 0.01, 1), t + 1);
+      tracker.setThisBranchKey(undefined, t + 2);
+    }
+
+    // Map is at cap with all paused. Entering a new branch evicts oldest.
+    const enterAt = BASE_TIME + THIS_BRANCH_MAP_CAP * MINUTE_MS;
+    tracker.setThisBranchKey('/repo@new', enterAt);
+    const persisted = tracker.takeBranchBaselinesIfNeedsPersist();
+    expect(persisted).toBeDefined();
+    expect(Object.keys(persisted!.entries).length).toBe(THIS_BRANCH_MAP_CAP);
+    expect(persisted!.entries['/repo@b0']).toBeUndefined();
+    expect(persisted!.entries['/repo@new']).toBeDefined();
+  });
 });
diff --git a/src/usageWindows.ts b/src/usageWindows.ts
index 8d989c0..fa60719 100644
--- a/src/usageWindows.ts
+++ b/src/usageWindows.ts
@@ -12,9 +12,52 @@ export interface UsageSoFarState {
   cycleKey?: string;
 }
 
+/**
+ * Keyed baseline for "Since last commit" — key is `{repoRoot}@{headCommit}`.
+ * Persisted in workspaceState (per-workspace).
+ */
+export interface AnchoredBaseline {
+  key: string;
+  baseline: UsageSample;
+  cycleKey?: string;
+}
+
 /** globalState key for the user-resettable "Usage so far" baseline. */
 export const USAGE_SO_FAR_BASELINE_KEY = 'cursorPlanUsage.usageSoFarBaseline';
 
+/** globalState key for the pruned last-hour sample ring. */
+export const USAGE_SAMPLES_KEY = 'cursorPlanUsage.usageSamples';
+
+/** workspaceState key for the "Since last commit" keyed baseline. */
+export const SINCE_LAST_COMMIT_BASELINE_KEY =
+  'cursorPlanUsage.sinceLastCommitBaseline';
+
+/** workspaceState key for per-branch active-time baselines. */
+export const THIS_BRANCH_BASELINES_KEY = 'cursorPlanUsage.thisBranchBaselines';
+
+/** Max remembered feature-branch entries (LRU by lastSeenAt). */
+export const THIS_BRANCH_MAP_CAP = 40;
+
+/**
+ * Per-branch active-time accounting. Usage while checked out elsewhere does
+ * not inflate the delta.
+ */
+export interface BranchEntry {
+  accumulatedAuto: number;
+  accumulatedApi: number;
+  /** Set only while this branch is currently checked out. */
+  liveBaseline?: UsageSample;
+  /** First observation time (ms). */
+  startedAt: number;
+  lastSeenAt: number;
+}
+
+export interface BranchBaselinesState {
+  cycleKey?: string;
+  activeKey?: string;
+  entries: Record<string, BranchEntry>;
+}
+
 const HOUR_MS = 60 * 60 * 1000;
 /** Keep slightly more than 1h so we always have a pre-window baseline. */
 const RETAIN_MS = HOUR_MS + 15 * 60 * 1000;
@@ -93,8 +136,114 @@ export function parseUsageSoFarState(
   return undefined;
 }
 
+/** Reads a persisted sample ring; skips malformed entries. */
+export function parseUsageSamples(value: unknown): UsageSample[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const out: UsageSample[] = [];
+  for (const item of value) {
+    if (isUsageSample(item)) {
+      out.push({
+        at: item.at,
+        autoPercentUsed: item.autoPercentUsed,
+        apiPercentUsed: item.apiPercentUsed,
+      });
+    }
+  }
+  return out;
+}
+
+/** Reads a persisted keyed anchor for "Since last commit". */
+export function parseAnchoredBaseline(
+  value: unknown
+): AnchoredBaseline | undefined {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const v = value as Record<string, unknown>;
+  if (typeof v.key !== 'string' || !v.key || !isUsageSample(v.baseline)) {
+    return undefined;
+  }
+  return {
+    key: v.key,
+    baseline: {
+      at: v.baseline.at,
+      autoPercentUsed: v.baseline.autoPercentUsed,
+      apiPercentUsed: v.baseline.apiPercentUsed,
+    },
+    cycleKey: typeof v.cycleKey === 'string' ? v.cycleKey : undefined,
+  };
+}
+
+function parseBranchEntry(value: unknown): BranchEntry | undefined {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const v = value as Record<string, unknown>;
+  if (
+    typeof v.accumulatedAuto !== 'number' ||
+    !Number.isFinite(v.accumulatedAuto) ||
+    typeof v.accumulatedApi !== 'number' ||
+    !Number.isFinite(v.accumulatedApi) ||
+    typeof v.startedAt !== 'number' ||
+    !Number.isFinite(v.startedAt) ||
+    typeof v.lastSeenAt !== 'number' ||
+    !Number.isFinite(v.lastSeenAt)
+  ) {
+    return undefined;
+  }
+  const entry: BranchEntry = {
+    accumulatedAuto: v.accumulatedAuto,
+    accumulatedApi: v.accumulatedApi,
+    startedAt: v.startedAt,
+    lastSeenAt: v.lastSeenAt,
+  };
+  if (v.liveBaseline !== undefined) {
+    if (!isUsageSample(v.liveBaseline)) {
+      return undefined;
+    }
+    entry.liveBaseline = {
+      at: v.liveBaseline.at,
+      autoPercentUsed: v.liveBaseline.autoPercentUsed,
+      apiPercentUsed: v.liveBaseline.apiPercentUsed,
+    };
+  }
+  return entry;
+}
+
+/** Reads persisted per-branch baselines; skips malformed entries. */
+export function parseBranchBaselinesState(
+  value: unknown
+): BranchBaselinesState | undefined {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const v = value as Record<string, unknown>;
+  if (!v.entries || typeof v.entries !== 'object' || Array.isArray(v.entries)) {
+    return undefined;
+  }
+  const entries: Record<string, BranchEntry> = {};
+  for (const [key, raw] of Object.entries(
+    v.entries as Record<string, unknown>
+  )) {
+    if (!key) {
+      continue;
+    }
+    const entry = parseBranchEntry(raw);
+    if (entry) {
+      entries[key] = entry;
+    }
+  }
+  return {
+    cycleKey: typeof v.cycleKey === 'string' ? v.cycleKey : undefined,
+    activeKey: typeof v.activeKey === 'string' ? v.activeKey : undefined,
+    entries,
+  };
+}
+
 /**
- * In-memory ring of period-usage samples for last-hour / IDE-session deltas.
+ * Sample ring for last-hour (persisted) and IDE-session (in-memory) deltas.
  * Absolute spend/% come from GetCurrentPeriodUsage; windows are local diffs.
  */
 export class UsageWindowTracker {
@@ -104,6 +253,20 @@ export class UsageWindowTracker {
   private cycleKey?: string;
   /** True when customBaseline was seeded/rolled over and not yet persisted. */
   private customBaselineNeedsPersist = false;
+  /** True when the sample ring changed and is not yet persisted. */
+  private samplesNeedPersist = false;
+  /** Keyed "Since last commit" anchor. */
+  private anchor?: AnchoredBaseline;
+  /** Anchor key requested before any sample existed; applied on next record(). */
+  private pendingAnchorKey?: string;
+  /** True when anchor was auto-applied and not yet persisted. */
+  private anchorNeedsPersist = false;
+  /** Per-branch active-time map. */
+  private branchEntries: Record<string, BranchEntry> = {};
+  private activeBranchKey?: string;
+  /** Branch key requested before any sample; applied on next record(). */
+  private pendingBranchKey?: string;
+  private branchNeedsPersist = false;
 
   loadCustomBaseline(state: UsageSoFarState): void {
     this.customBaseline = { ...state.baseline };
@@ -111,6 +274,49 @@ export class UsageWindowTracker {
     this.customBaselineNeedsPersist = false;
   }
 
+  loadAnchor(state: AnchoredBaseline): void {
+    this.anchor = {
+      key: state.key,
+      baseline: { ...state.baseline },
+      cycleKey: state.cycleKey,
+    };
+    this.pendingAnchorKey = undefined;
+    this.anchorNeedsPersist = false;
+  }
+
+  /**
+   * Restore paused/active branch map. Does not auto-activate a key — caller
+   * should setThisBranchKey after git is ready.
+   */
+  loadBranchBaselines(state: BranchBaselinesState): void {
+    this.branchEntries = {};
+    for (const [key, entry] of Object.entries(state.entries)) {
+      this.branchEntries[key] = {
+        accumulatedAuto: entry.accumulatedAuto,
+        accumulatedApi: entry.accumulatedApi,
+        startedAt: entry.startedAt,
+        lastSeenAt: entry.lastSeenAt,
+        // Never restore liveBaseline across reloads — re-enter via setThisBranchKey.
+      };
+    }
+    if (state.cycleKey) {
+      this.cycleKey = state.cycleKey;
+    }
+    this.activeBranchKey = undefined;
+    this.pendingBranchKey = undefined;
+    this.branchNeedsPersist = false;
+  }
+
+  /**
+   * Restore the last-hour sample ring. Does not seed sessionBaseline — that
+   * stays IDE-local and is set on the next live record().
+   */
+  loadSamples(samples: UsageSample[], at = Date.now()): void {
+    this.samples = samples.map((s) => ({ ...s }));
+    this.prune(at);
+    this.samplesNeedPersist = false;
+  }
+
   /**
    * If the custom baseline was auto-seeded and not yet written, return it and
    * clear the dirty flag. Callers should persist to globalState.
@@ -127,6 +333,46 @@ export class UsageWindowTracker {
     return state;
   }
 
+  /**
+   * If the sample ring changed and is not yet written, return a copy and clear
+   * the dirty flag. Callers should persist to globalState.
+   */
+  takeSamplesIfNeedsPersist(): UsageSample[] | undefined {
+    if (!this.samplesNeedPersist) {
+      return undefined;
+    }
+    this.samplesNeedPersist = false;
+    return this.samples.map((s) => ({ ...s }));
+  }
+
+  /**
+   * If the since-last-commit anchor changed and is not yet written, return it
+   * (or null when cleared) and clear the dirty flag.
+   */
+  takeAnchorIfNeedsPersist(): AnchoredBaseline | null | undefined {
+    if (!this.anchorNeedsPersist) {
+      return undefined;
+    }
+    this.anchorNeedsPersist = false;
+    return this.anchorState() ?? null;
+  }
+
+  /**
+   * If the branch map changed, return a copy to persist (or null when empty
+   * after clear) and clear the dirty flag.
+   */
+  takeBranchBaselinesIfNeedsPersist(): BranchBaselinesState | null | undefined {
+    if (!this.branchNeedsPersist) {
+      return undefined;
+    }
+    this.branchNeedsPersist = false;
+    const state = this.branchState();
+    if (!state || Object.keys(state.entries).length === 0) {
+      return null;
+    }
+    return state;
+  }
+
   /**
    * Reset "Usage so far" to the latest sample. Returns the new state, or
    * undefined if there are no samples yet.
@@ -141,6 +387,83 @@ export class UsageWindowTracker {
     return this.customState();
   }
 
+  /**
+   * Set or clear the "Since last commit" key. No-op when the key is unchanged
+   * and an anchor already exists. Returns the new state to persist, or null
+   * when cleared, or undefined when unchanged / pending.
+   */
+  setAnchor(key: string | undefined): AnchoredBaseline | null | undefined {
+    if (!key) {
+      const had =
+        this.anchor !== undefined || this.pendingAnchorKey !== undefined;
+      this.anchor = undefined;
+      this.pendingAnchorKey = undefined;
+      if (!had) {
+        return undefined;
+      }
+      this.anchorNeedsPersist = false;
+      return null;
+    }
+    if (this.anchor?.key === key || this.pendingAnchorKey === key) {
+      return undefined;
+    }
+    const current = this.latest();
+    if (!current) {
+      this.pendingAnchorKey = key;
+      this.anchor = undefined;
+      this.anchorNeedsPersist = false;
+      return undefined;
+    }
+    this.anchor = {
+      key,
+      baseline: { ...current },
+      cycleKey: this.cycleKey,
+    };
+    this.pendingAnchorKey = undefined;
+    this.anchorNeedsPersist = false;
+    return this.anchorState();
+  }
+
+  /**
+   * Activate or pause "This branch" tracking. Pausing freezes accumulated
+   * spend so usage on other branches does not inflate the delta.
+   * Returns true when the map changed and should be persisted.
+   */
+  setThisBranchKey(key: string | undefined, at = Date.now()): boolean {
+    if (key === this.activeBranchKey) {
+      if (key && this.branchEntries[key]) {
+        this.branchEntries[key].lastSeenAt = at;
+      }
+      return false;
+    }
+
+    // Same key already pending with no samples yet.
+    if (key && this.pendingBranchKey === key && !this.activeBranchKey) {
+      return false;
+    }
+
+    const current = this.latest();
+    this.pauseActiveBranch(current, at);
+
+    if (!key) {
+      this.pendingBranchKey = undefined;
+      this.activeBranchKey = undefined;
+      this.branchNeedsPersist = true;
+      return true;
+    }
+
+    if (!current) {
+      this.pendingBranchKey = key;
+      this.activeBranchKey = undefined;
+      return false;
+    }
+
+    this.enterBranch(key, current, at);
+    this.pendingBranchKey = undefined;
+    this.branchNeedsPersist = true;
+    return true;
+  }
+
   record(snapshot: UsageSnapshot, at = Date.now()): void {
     const sample: UsageSample = {
       at,
@@ -153,6 +476,16 @@ export class UsageWindowTracker {
       this.samples = [];
       this.sessionBaseline = undefined;
       this.customBaseline = undefined;
+      if (this.anchor) {
+        this.anchor = undefined;
+        this.anchorNeedsPersist = true;
+      }
+      if (Object.keys(this.branchEntries).length || this.activeBranchKey) {
+        this.branchEntries = {};
+        this.activeBranchKey = undefined;
+        this.branchNeedsPersist = true;
+      }
+      // Keep pendingAnchorKey / pendingBranchKey so dirty/feature re-seed after rollover.
     }
     if (cycleKey) {
       this.cycleKey = cycleKey;
@@ -162,8 +495,23 @@ export class UsageWindowTracker {
       this.customBaseline = sample;
       this.customBaselineNeedsPersist = true;
     }
+    if (this.pendingAnchorKey) {
+      this.anchor = {
+        key: this.pendingAnchorKey,
+        baseline: sample,
+        cycleKey: this.cycleKey,
+      };
+      this.pendingAnchorKey = undefined;
+      this.anchorNeedsPersist = true;
+    }
+    if (this.pendingBranchKey) {
+      this.enterBranch(this.pendingBranchKey, sample, at);
+      this.pendingBranchKey = undefined;
+      this.branchNeedsPersist = true;
+    }
     this.samples.push(sample);
     this.prune(at);
+    this.samplesNeedPersist = true;
   }
 
   attachWindows(snapshot: UsageSnapshot, at = Date.now()): UsageSnapshot {
@@ -178,6 +526,8 @@ export class UsageWindowTracker {
       lastHour: this.lastHour(at),
       session: this.session(at),
       usageSoFar: this.usageSoFar(at),
+      sinceLastCommit: this.sinceLastCommit(at),
+      thisBranch: this.thisBranch(at),
     };
   }
 
@@ -216,6 +566,41 @@ export class UsageWindowTracker {
     return { ...delta(baseline, current, baseline.at), partial: false };
   }
 
+  sinceLastCommit(_at = Date.now()): UsageWindow | undefined {
+    const current = this.latest();
+    const baseline = this.anchor?.baseline;
+    if (!current || !baseline) {
+      return undefined;
+    }
+    return { ...delta(baseline, current, baseline.at), partial: false };
+  }
+
+  thisBranch(_at = Date.now()): UsageWindow | undefined {
+    const key = this.activeBranchKey;
+    if (!key) {
+      return undefined;
+    }
+    const entry = this.branchEntries[key];
+    const current = this.latest();
+    if (!entry || !current || !entry.liveBaseline) {
+      return undefined;
+    }
+    const liveAuto = Math.max(
+      0,
+      current.autoPercentUsed - entry.liveBaseline.autoPercentUsed
+    );
+    const liveApi = Math.max(
+      0,
+      current.apiPercentUsed - entry.liveBaseline.apiPercentUsed
+    );
+    return {
+      autoPercentDelta: round1(entry.accumulatedAuto + liveAuto),
+      apiPercentDelta: round1(entry.accumulatedApi + liveApi),
+      since: new Date(entry.startedAt).toISOString(),
+      partial: false,
+    };
+  }
+
   /**
    * True when the new sample cannot belong to the same period as what we
    * already track: the cycle id changed, or cumulative usage went down.
@@ -244,6 +629,102 @@ export class UsageWindowTracker {
     return { baseline: { ...this.customBaseline }, cycleKey: this.cycleKey };
   }
 
+  private anchorState(): AnchoredBaseline | undefined {
+    if (!this.anchor) {
+      return undefined;
+    }
+    return {
+      key: this.anchor.key,
+      baseline: { ...this.anchor.baseline },
+      cycleKey: this.anchor.cycleKey ?? this.cycleKey,
+    };
+  }
+
+  private branchState(): BranchBaselinesState {
+    const entries: Record<string, BranchEntry> = {};
+    for (const [key, entry] of Object.entries(this.branchEntries)) {
+      entries[key] = {
+        accumulatedAuto: entry.accumulatedAuto,
+        accumulatedApi: entry.accumulatedApi,
+        startedAt: entry.startedAt,
+        lastSeenAt: entry.lastSeenAt,
+        // Persist without liveBaseline — resume sets a fresh one.
+      };
+    }
+    return {
+      cycleKey: this.cycleKey,
+      activeKey: this.activeBranchKey,
+      entries,
+    };
+  }
+
+  private pauseActiveBranch(
+    current: UsageSample | undefined,
+    at: number
+  ): void {
+    const key = this.activeBranchKey;
+    if (!key) {
+      return;
+    }
+    const entry = this.branchEntries[key];
+    if (!entry?.liveBaseline) {
+      this.activeBranchKey = undefined;
+      return;
+    }
+    if (current) {
+      entry.accumulatedAuto += Math.max(
+        0,
+        current.autoPercentUsed - entry.liveBaseline.autoPercentUsed
+      );
+      entry.accumulatedApi += Math.max(
+        0,
+        current.apiPercentUsed - entry.liveBaseline.apiPercentUsed
+      );
+    }
+    entry.liveBaseline = undefined;
+    entry.lastSeenAt = at;
+    this.activeBranchKey = undefined;
+  }
+
+  private enterBranch(key: string, current: UsageSample, at: number): void {
+    let entry = this.branchEntries[key];
+    if (!entry) {
+      this.evictOldestBranchesIfNeeded();
+      entry = {
+        accumulatedAuto: 0,
+        accumulatedApi: 0,
+        startedAt: at,
+        lastSeenAt: at,
+        liveBaseline: { ...current },
+      };
+      this.branchEntries[key] = entry;
+    } else {
+      entry.liveBaseline = { ...current };
+      entry.lastSeenAt = at;
+    }
+    this.activeBranchKey = key;
+  }
+
+  private evictOldestBranchesIfNeeded(): void {
+    const keys = Object.keys(this.branchEntries);
+    if (keys.length < THIS_BRANCH_MAP_CAP) {
+      return;
+    }
+    let oldestKey = keys[0];
+    let oldestAt = this.branchEntries[oldestKey].lastSeenAt;
+    for (const key of keys) {
+      const seen = this.branchEntries[key].lastSeenAt;
+      if (seen < oldestAt) {
+        oldestAt = seen;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey === this.activeBranchKey) {
+      return;
+    }
+    delete this.branchEntries[oldestKey];
+  }
+
   private latest(): UsageSample | undefined {
     return this.samples.at(-1);
   }