@@ -6,8 +6,10 @@ vi.mock('electron', () => import('@/test/electron-mock'))
 import { Menu, WebContentsView } from 'electron'
 import {
   attachAgentContextMenu,
+  BASE_ZOOM_FACTOR,
   buildAgentContextMenuTemplate,
   steppedZoomFactor,
+  zoomPercentOf,
 } from '@/main/browser-agent/context-menu'
 
 const EDIT_FLAGS: ContextMenuParams['editFlags'] = {
@@ -30,7 +32,8 @@ function params(overrides: Partial<Params> = {}): Params {
 }
 
 function page(overrides: Partial<Page> = {}): Page {
-  return { canGoBack: true, canGoForward: true, zoomFactor: 1, ...overrides }
+  // A fresh tab sits at the panel's baseline, which the menu reports as 100%.
+  return { canGoBack: true, canGoForward: true, zoomFactor: BASE_ZOOM_FACTOR, ...overrides }
 }
 
 function handlers(): Handlers {
@@ -130,7 +133,10 @@ describe('buildAgentContextMenuTemplate', () => {
   })
 
   it('reports the current zoom and disables the ends of the ladder', () => {
-    const stepped = buildAgentContextMenuTemplate(params(), page({ zoomFactor: 1.21 }), handlers())
+    // Two rungs up from the baseline, reported against the baseline rather than
+    // against Chromium's native scale (where this factor would read 110%).
+    const twoUp = steppedZoomFactor(steppedZoomFactor(BASE_ZOOM_FACTOR, 1), 1)
+    const stepped = buildAgentContextMenuTemplate(params(), page({ zoomFactor: twoUp }), handlers())
     expect(item(stepped, 'Actual Size (121%)')?.enabled).toBe(true)
 
     const atMax = buildAgentContextMenuTemplate(params(), page({ zoomFactor: 3 }), handlers())
@@ -147,17 +153,16 @@ describe('buildAgentContextMenuTemplate', () => {
     ).toBe(false)
   })
 
-  it('resets to exactly 100%, undoing accumulated drift', () => {
+  it('resets to exactly the baseline, undoing accumulated drift', () => {
     const handled = handlers()
-    const template = buildAgentContextMenuTemplate(
-      params(),
-      page({ zoomFactor: 1.3310000000000004 }),
-      handled
-    )
+    // Three rungs of float multiplication up, so the factor no longer sits on a
+    // clean value — reset has to restore the baseline exactly, not step back.
+    const drifted = [1, 1, 1].reduce((factor) => steppedZoomFactor(factor, 1), BASE_ZOOM_FACTOR)
+    const template = buildAgentContextMenuTemplate(params(), page({ zoomFactor: drifted }), handled)
 
     item(template, 'Actual Size (133%)')?.click?.({} as never, undefined as never, {} as never)
 
-    expect(handled.setZoomFactor).toHaveBeenCalledWith(1)
+    expect(handled.setZoomFactor).toHaveBeenCalledWith(BASE_ZOOM_FACTOR)
   })
 
   it('never leaves a separator with nothing above it', () => {
@@ -215,8 +220,41 @@ describe('steppedZoomFactor', () => {
     expect(steppedZoomFactor(0.5, -1)).toBe(0.5)
   })
 
-  it('treats a nonsense factor as 100%', () => {
-    expect(steppedZoomFactor(Number.NaN, 1)).toBe(1.1)
-    expect(steppedZoomFactor(0, 1)).toBe(1.1)
+  it('treats a nonsense factor as the baseline', () => {
+    // One rung up from the baseline is Chromium's native 1.0.
+    expect(steppedZoomFactor(Number.NaN, 1)).toBe(1)
+    expect(steppedZoomFactor(0, 1)).toBe(1)
+  })
+})
+
+describe('BASE_ZOOM_FACTOR', () => {
+  it('renders a rung below native but reads as 100%', () => {
+    expect(BASE_ZOOM_FACTOR).toBeCloseTo(0.909, 3)
+    expect(zoomPercentOf(BASE_ZOOM_FACTOR)).toBe(100)
+  })
+
+  it('keeps the ladder landing exactly on Chromium native one step up', () => {
+    expect(steppedZoomFactor(BASE_ZOOM_FACTOR, 1)).toBe(1)
+    expect(zoomPercentOf(1)).toBe(110)
+  })
+
+  it('stays inside the ladder, so the page menu can still step both ways', () => {
+    expect(steppedZoomFactor(BASE_ZOOM_FACTOR, 1)).not.toBe(BASE_ZOOM_FACTOR)
+    expect(steppedZoomFactor(BASE_ZOOM_FACTOR, -1)).not.toBe(BASE_ZOOM_FACTOR)
+  })
+})
+
+describe('zoomPercentOf', () => {
+  it('reports every rung relative to the panel baseline, not to native', () => {
+    expect(zoomPercentOf(steppedZoomFactor(BASE_ZOOM_FACTOR, -1))).toBe(91)
+    expect(zoomPercentOf(BASE_ZOOM_FACTOR)).toBe(100)
+    expect(zoomPercentOf(steppedZoomFactor(BASE_ZOOM_FACTOR, 1))).toBe(110)
+  })
+
+  it('still reads 100% after a round trip up and back down', () => {
+    // The ladder is float arithmetic, so the reset item's `!== 100` guard has to
+    // survive a step that does not return bit-identically to the baseline.
+    const roundTripped = steppedZoomFactor(steppedZoomFactor(BASE_ZOOM_FACTOR, 1), -1)
+    expect(zoomPercentOf(roundTripped)).toBe(100)
   })
 })
@@ -17,20 +17,50 @@ import type { ContextMenuParams, MenuItemConstructorOptions, WebContents } from
 import { clipboard, Menu } from 'electron'
 
 /**
- * Page-zoom ladder for the embedded browser, in factors (1 = 100%) because that
- * is what the menu displays.
+ * Page-zoom ladder for the embedded browser, in Chromium's absolute zoom
+ * factors. The ends are the platform's own limits, not a product choice —
+ * Chromium refuses to scale past them, and a rung outside the range would come
+ * back clamped and leave the menu offering a step that never lands.
  */
 const ZOOM_STEP_RATIO = 1.1
 const MIN_ZOOM_FACTOR = 0.5
 const MAX_ZOOM_FACTOR = 3
 
+/**
+ * What the panel calls 100%.
+ *
+ * The browser lives in a panel that is only ever a fraction of the window, so
+ * it renders a rung below Chromium's native scale and treats THAT as its
+ * baseline: the menu reads 100% there, and every other rung is reported
+ * relative to it. Users get a zoom control that behaves the way one should —
+ * starts at 100%, resets to 100% — over a page that is genuinely rendering at
+ * ~91% of native.
+ *
+ * Defined as one rung below native rather than as a round number so the ladder
+ * still lands exactly on Chromium's 1.0 (the crispest rasterization, one step
+ * up from the baseline) instead of straddling it.
+ */
+export const BASE_ZOOM_FACTOR = 1 / ZOOM_STEP_RATIO
+
+/**
+ * A Chromium zoom factor as a percentage of {@link BASE_ZOOM_FACTOR} — what the
+ * menu shows and what "100%" means everywhere in the browser panel's UI.
+ *
+ * Only display and the reset target convert; the ladder itself stays in
+ * absolute factors, so stepping never round-trips through this and cannot
+ * accumulate float drift away from the rungs.
+ */
+export function zoomPercentOf(factor: number): number {
+  return Math.round((factor / BASE_ZOOM_FACTOR) * 100)
+}
+
 /**
  * One step along the zoom ladder, clamped to its ends. Returning the current
  * factor unchanged is how the menu knows an end is reached, so it can disable
  * the item rather than offer a step that does nothing.
  */
 export function steppedZoomFactor(current: number, direction: 1 | -1): number {
-  const base = Number.isFinite(current) && current > 0 ? current : 1
+  const base = Number.isFinite(current) && current > 0 ? current : BASE_ZOOM_FACTOR
   const next = direction === 1 ? base * ZOOM_STEP_RATIO : base / ZOOM_STEP_RATIO
   return Math.min(MAX_ZOOM_FACTOR, Math.max(MIN_ZOOM_FACTOR, next))
 }
@@ -107,7 +137,7 @@ export function buildAgentContextMenuTemplate(
 
   const zoomIn = steppedZoomFactor(page.zoomFactor, 1)
   const zoomOut = steppedZoomFactor(page.zoomFactor, -1)
-  const zoomPercent = Math.round(page.zoomFactor * 100)
+  const zoomPercent = zoomPercentOf(page.zoomFactor)
   template.push(
     {
       label: 'Zoom In',
@@ -122,7 +152,7 @@ export function buildAgentContextMenuTemplate(
     {
       label: `Actual Size (${zoomPercent}%)`,
       enabled: zoomPercent !== 100,
-      click: () => handlers.setZoomFactor(1),
+      click: () => handlers.setZoomFactor(BASE_ZOOM_FACTOR),
     }
   )
 
 
@@ -11,7 +11,7 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import type { BrowserWindow, CookiesSetDetails, Input, Session, WebContents } from 'electron'
 import { session as electronSession, nativeTheme, WebContentsView } from 'electron'
-import { attachAgentContextMenu } from '@/main/browser-agent/context-menu'
+import { attachAgentContextMenu, BASE_ZOOM_FACTOR } from '@/main/browser-agent/context-menu'
 import type { BrowserCookieSignal } from '@/main/browser-agent/known-sessions'
 import {
   detachAttachedView,
@@ -340,6 +340,9 @@ function createTabView(): WebContentsView {
       // applyActiveTabThrottling — never blanket across every tab.
       backgroundThrottling: true,
       spellcheck: false,
+      // The default every origin this tab visits starts at; a per-origin zoom
+      // the user sets from the page menu still wins and still persists.
+      zoomFactor: BASE_ZOOM_FACTOR,
     },
   })
   view.setBackgroundColor(browserBackgroundColor())
 
@@ -2,6 +2,7 @@ import { createCipheriv, createHash } from 'node:crypto'
 import { mkdtemp, readdir, rm, stat, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { sleep } from '@sim/utils/helpers'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { readBrowserCookies } from '@/main/browser-import/chromium-cookies'
 import { deriveEncryptionKey } from '@/main/browser-import/chromium-crypto'
@@ -19,6 +20,29 @@ const sqliteAvailable = await import('node:sqlite').then(
 const KEY = deriveEncryptionKey('test-safe-storage-password')
 const NOW_SECONDS = 1_800_000_000
 
+async function stagingDirectories(): Promise<Set<string>> {
+  const entries = await readdir(tmpdir())
+  return new Set(entries.filter((entry) => entry.startsWith('sim-chrome-import-')))
+}
+
+/**
+ * Staging copies still present that were not there at `before`.
+ *
+ * Every reader in this folder stages through the shared `os.tmpdir()` under one
+ * prefix, and Vitest runs their suites in parallel workers, so a single snapshot
+ * can catch a sibling's copy mid-read and read as a leak. A leak of our own
+ * never clears, so this settles instead of sampling once.
+ */
+async function stagingLeftBehindSince(before: ReadonlySet<string>): Promise<string[]> {
+  let leftover: string[] = []
+  for (let attempt = 0; attempt < 20; attempt++) {
+    leftover = [...(await stagingDirectories())].filter((entry) => !before.has(entry))
+    if (leftover.length === 0) return leftover
+    await sleep(25)
+  }
+  return leftover
+}
+
 function chromeTime(unixSeconds: number): bigint {
   return BigInt(unixSeconds + 11_644_473_600) * 1_000_000n
 }
@@ -204,32 +228,22 @@ describe.skipIf(!sqliteAvailable)('readBrowserCookies', () => {
   })
 
   it('deletes its decrypted working copy', async () => {
-    const stagingBefore = (await readdir(tmpdir())).filter((entry) =>
-      entry.startsWith('sim-chrome-import-')
-    ).length
+    const before = await stagingDirectories()
     const path = await writeCookieDatabase([
       { hostKey: 'example.com', name: 'a', encryptedValue: encryptV10(Buffer.from('v')) },
     ])
 
     await readBrowserCookies(path, KEY, NOW_SECONDS)
 
-    const stagingAfter = (await readdir(tmpdir())).filter((entry) =>
-      entry.startsWith('sim-chrome-import-')
-    ).length
-    expect(stagingAfter).toBe(stagingBefore)
+    expect(await stagingLeftBehindSince(before)).toEqual([])
   })
 
   it('cleans up even when the read fails', async () => {
-    const stagingBefore = (await readdir(tmpdir())).filter((entry) =>
-      entry.startsWith('sim-chrome-import-')
-    ).length
+    const before = await stagingDirectories()
     await writeFile(join(directory, 'Cookies'), 'not a database')
 
     await expect(readBrowserCookies(join(directory, 'Cookies'), KEY, NOW_SECONDS)).rejects.toThrow()
 
-    const stagingAfter = (await readdir(tmpdir())).filter((entry) =>
-      entry.startsWith('sim-chrome-import-')
-    ).length
-    expect(stagingAfter).toBe(stagingBefore)
+    expect(await stagingLeftBehindSince(before)).toEqual([])
   })
 })