diff --git a/.claude/retiring.txt b/.claude/retiring.txt
index 22ed0c70..a274bc63 100644
--- a/.claude/retiring.txt
+++ b/.claude/retiring.txt
@@ -21,9 +21,6 @@ allow PEEK_PAGEHOST_HYBRID_PROBE  # distinct, still-live debug env var (main/pag
 # main/hybrid-page-host-registry.ts, main/entry.ts, main/hybrid-overlay.ts,
 # renderer/page/overlay.js); the remaining 22 test-comment refs across 15
 # tests/desktop/*.spec.ts files were fixed in the follow-up scrub pass.
-# Note: flag SHORTHAND without the literal string ("hybrid flag off" skip
-# reasons, "under the hybrid flag" comments, ~90+ lines across ~20 spec files)
-# still exists — it doesn't match this symbol and is a separate cleanup.
 
 isCanvasPage
 # clean — zero refs
diff --git a/apps/desktop/tests/desktop/boot-window-inventory.spec.ts b/apps/desktop/tests/desktop/boot-window-inventory.spec.ts
index f499f11e..8ef0ec09 100644
--- a/apps/desktop/tests/desktop/boot-window-inventory.spec.ts
+++ b/apps/desktop/tests/desktop/boot-window-inventory.spec.ts
@@ -145,20 +145,21 @@ test.describe('Boot Window Inventory @desktop', () => {
     // (the canvas shell) PLUS exactly one embedded `<webview>` webContents
     // (expectations at the bottom: pageHostWindows===K, pageHostWebviews===K,
     // and the deterministic wait that polls for K `peek://app/page/` windows +
-    // K `getType()==='webview'` WCs). Under the hybrid flag a page-host is an
-    // OPAQUE WebContentsView inside a BaseWindow: the host window's URL is the
-    // real http(s) content URL (no `peek://app/page/` shell) and there is NO
-    // `<webview>` (the content WC type is 'browserView'). So the page-host poll
-    // never satisfies (60s timeout) and the per-page structural counts can't
-    // hold — this is a fundamental measurement-shape difference, NOT a product
-    // bug. Hybrid page-host enumeration/structure is covered by
-    // hybrid-windows-feature.spec.ts and hybrid-overlay.spec.ts; a hybrid
-    // boot-inventory measurement (1 BaseWindow + 1 WebContentsView per page,
-    // no shell/webview) is a separate rewrite. TODO(pagehost-hybrid): port the
-    // per-page-host cost measurement to the hybrid shape. Tracked for Batch D.
-    // (The FIXED boot-count regression guard still passes flag-on — observed
-    // FIXED windows=3 — but it's interleaved with the canvas per-page asserts,
-    // so the whole test is skipped rather than partially masked.)
+    // K `getType()==='webview'` WCs). In the current (hybrid-only) architecture
+    // a page-host is an OPAQUE WebContentsView inside a BaseWindow: the host
+    // window's URL is the real http(s) content URL (no `peek://app/page/`
+    // shell) and there is NO `<webview>` (the content WC type is
+    // 'browserView'). So the page-host poll never satisfies (60s timeout) and
+    // the per-page structural counts can't hold — this is a fundamental
+    // measurement-shape difference, NOT a product bug. Hybrid page-host
+    // enumeration/structure is covered by hybrid-windows-feature.spec.ts and
+    // hybrid-overlay.spec.ts; a hybrid boot-inventory measurement (1 BaseWindow
+    // + 1 WebContentsView per page, no shell/webview) is a separate rewrite.
+    // TODO(pagehost-hybrid): port the per-page-host cost measurement to the
+    // hybrid shape. Tracked for Batch D.
+    // (The FIXED boot-count regression guard still passes — observed FIXED
+    // windows=3 — but it's interleaved with the canvas per-page asserts, so
+    // the whole test is skipped rather than partially masked.)
     test.skip(
       await hybridBridgePresent(app),
       'canvas-only page-host structural measurement (peek://app/page/ shell + embedded <webview>); hybrid page-hosts have neither (TODO Batch D rewrite)',
diff --git a/apps/desktop/tests/desktop/download.spec.ts b/apps/desktop/tests/desktop/download.spec.ts
index 5218db6a..6311a471 100644
--- a/apps/desktop/tests/desktop/download.spec.ts
+++ b/apps/desktop/tests/desktop/download.spec.ts
@@ -120,9 +120,9 @@ async function getWebviewUrl(pageWindow: Page): Promise<string | null> {
 test.describe('Download Navigation @desktop', () => {
   // ── Hybrid page-host caveat ───────────────────────────────────────────────
   // These tests assert against the canvas `<webview>` page host (`#content`
-  // webview, `.loaded` class, `webview.getURL()/executeJavaScript`). Under the
-  // hybrid flag the page content is an OPAQUE WebContentsView in a BaseWindow,
-  // so there is no in-window webview to drive.
+  // webview, `.loaded` class, `webview.getURL()/executeJavaScript`). In the
+  // current (hybrid-only) architecture the page content is an OPAQUE
+  // WebContentsView in a BaseWindow, so there is no in-window webview to drive.
   //
   // The product cleanup gap is now FIXED: the will-download handler in
   // main/session-partition.ts no longer dead-ends on a hybrid content WC. After
@@ -134,15 +134,14 @@ test.describe('Download Navigation @desktop', () => {
   // that host orphaned. That reverse lookup is covered by a focused unit test in
   // main/hybrid-page-host-registry.test.ts.
   //
-  // The describe nonetheless stays SKIPPED under the hybrid flag for a NARROWER,
-  // harness-only reason: the shared hybrid test bridge (`makeFakeHybridWindow` /
-  // `makeWiredHybrid`) builds its content WebContentsView on the DEFAULT session
-  // (no `session: profileSession`), so `will-download` — which is registered on
-  // profileSession at init — never fires for bridge-driven windows. Driving a
-  // real hybrid download e2e (and asserting the host actually closes) needs a
-  // partitioned-session test bridge; that's tracked as a separate follow-up.
-  //
-  // The tests remain fully valid on the canvas path (flag off).
+  // The describe nonetheless stays SKIPPED for a NARROWER, harness-only reason:
+  // the shared hybrid test bridge (`makeFakeHybridWindow` / `makeWiredHybrid`)
+  // builds its content WebContentsView on the DEFAULT session (no `session:
+  // profileSession`), so `will-download` — which is registered on profileSession
+  // at init — never fires for bridge-driven windows. Driving a real hybrid
+  // download e2e (and asserting the host actually closes) needs a
+  // partitioned-session test bridge; that's tracked as a separate follow-up
+  // (peek item 5d14237a).
   test.beforeEach(async () => {
     test.skip(
       await hybridBridgePresent(sharedApp),
diff --git a/apps/desktop/tests/desktop/hybrid-activation-policy.spec.ts b/apps/desktop/tests/desktop/hybrid-activation-policy.spec.ts
index 8b49b7b7..e85b95b5 100644
--- a/apps/desktop/tests/desktop/hybrid-activation-policy.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-activation-policy.spec.ts
@@ -33,7 +33,7 @@ test.describe('Activation policy guard (R7) @desktop', () => {
     app.evaluateMain!(() => Boolean((globalThis as any).__peekHybridOverlayTest));
 
   test('non-headless leaves default (regular); never accessory/prohibited', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const { real, headless } = await app.evaluateMain!(() => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-close-leak.spec.ts b/apps/desktop/tests/desktop/hybrid-close-leak.spec.ts
index 71473cf6..49f6fe33 100644
--- a/apps/desktop/tests/desktop/hybrid-close-leak.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-close-leak.spec.ts
@@ -80,7 +80,7 @@ test.describe('Hybrid Close Leak @desktop', () => {
     const slug = 'leak-roundtrip';
     const url = `http://127.0.0.1:${serverPort}/${slug}`;
 
-    // Open the page. Under the hybrid flag this is a BaseWindow page-host.
+    // Open the page. This is a BaseWindow page-host.
     const result = await bgWindow.evaluate(async (u: string) => {
       return await (window as any).app.window.open(u, { width: 800, height: 600 });
     }, url);
@@ -93,7 +93,7 @@ test.describe('Hybrid Close Leak @desktop', () => {
     // Hybrid-only outcome — skip on the canvas path.
     const isHybrid = await app.evaluateMain!(((_e: unknown, id: number) =>
       (globalThis as any).__peek_test.isHybridWindowForTest(id)) as any, windowId) as boolean;
-    test.skip(!isHybrid, 'hybrid flag off — leak is hybrid-path only');
+    test.skip(!isHybrid, 'not a hybrid page-host — leak is hybrid-path only');
 
     // Capture the content wc id while the window is still open and registered.
     const contentWcId = await app.evaluateMain!(((_e: unknown, id: number) =>
@@ -144,7 +144,7 @@ test.describe('Hybrid Close Leak @desktop', () => {
       if (i === 0) {
         const isHybrid = await app.evaluateMain!(((_e: unknown, id: number) =>
           (globalThis as any).__peek_test.isHybridWindowForTest(id)) as any, windowId) as boolean;
-        test.skip(!isHybrid, 'hybrid flag off — leak is hybrid-path only');
+        test.skip(!isHybrid, 'not a hybrid page-host — leak is hybrid-path only');
       }
 
       const contentWcId = await app.evaluateMain!(((_e: unknown, id: number) =>
diff --git a/apps/desktop/tests/desktop/hybrid-close-shortcut.spec.ts b/apps/desktop/tests/desktop/hybrid-close-shortcut.spec.ts
index d5ff2bef..9685b13e 100644
--- a/apps/desktop/tests/desktop/hybrid-close-shortcut.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-close-shortcut.spec.ts
@@ -41,7 +41,7 @@ test.describe('Hybrid page-host cmd+W close (R1) @desktop', () => {
   // getFocusedWindow() reports null (it can't see BaseWindows). This is what
   // broke the old getFocusedWindow()-based close handler.
   test('getFocusedWindow() is null while a hybrid host is the active window', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const probe = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -64,7 +64,7 @@ test.describe('Hybrid page-host cmd+W close (R1) @desktop', () => {
   // cmd+W's resolve-and-close path closes the focused hybrid host even though
   // getFocusedWindow() returns null for it.
   test('closeFocusedWindow() closes the active hybrid host (cmd+W path)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -97,7 +97,7 @@ test.describe('Hybrid page-host cmd+W close (R1) @desktop', () => {
   // initHybridOverlay registered the overlay-id provider against the real
   // singleton, so the resolver can tell the overlay apart from a page-host.
   test('the registry recognises the live overlay window (cmd+W redirect wiring)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const probe = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-escape-close.spec.ts b/apps/desktop/tests/desktop/hybrid-escape-close.spec.ts
index b810a01c..e2c2ad25 100644
--- a/apps/desktop/tests/desktop/hybrid-escape-close.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-escape-close.spec.ts
@@ -51,7 +51,7 @@ test.describe('Hybrid page-host ESC close @desktop', () => {
   // dispatchContentKey (proving ESC is intercepted + preventDefault'd there) and
   // awaits the async close deterministically (waitHybridGone).
   test('ESC on a focused hybrid quick-view host closes it (real before-input path)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -85,7 +85,7 @@ test.describe('Hybrid page-host ESC close @desktop', () => {
   // isolation: handleHybridEscape → escPolicy('…','quick-view')==='close' →
   // closeOrHideWindow closes the hybrid BaseWindow.
   test('handleHybridEscape closes a quick-view hybrid host (policy path)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -109,7 +109,7 @@ test.describe('Hybrid page-host ESC close @desktop', () => {
   // hybrid host (preserved identically to the canvas path). This proves the
   // hybrid path reuses the policy gate, not a "hybrid always closes" shortcut.
   test('escapeMode:"ignore" hybrid host is NOT closed by ESC', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -143,7 +143,7 @@ test.describe('Hybrid page-host ESC close @desktop', () => {
   // against, driven by the active-hybrid id), not just escPolicy(state, role) —
   // so it covers the live path a green headless escPolicy spec missed.
   test('ESC on the wrong (content) host closes the ACTIVE quick-view, not the switcher', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -184,7 +184,7 @@ test.describe('Hybrid page-host ESC close @desktop', () => {
   // toward it — it resolves against the host it landed on, preserving the
   // deferred ESC→switcher routing for real content pages (peek e8081cce).
   test('ESC does NOT redirect toward a content active window (no force-close)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-keeplive-close.spec.ts b/apps/desktop/tests/desktop/hybrid-keeplive-close.spec.ts
index dd528f23..924d8575 100644
--- a/apps/desktop/tests/desktop/hybrid-keeplive-close.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-keeplive-close.spec.ts
@@ -43,7 +43,7 @@ test.describe('Hybrid page-host keepLive on close path @desktop', () => {
   // BaseWindow stays alive, just not visible) when run through closeOrHideWindow,
   // so its content WebContentsView keeps running in the background.
   test('keepLive:true hybrid host is HIDDEN (not destroyed) on the close path', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -82,7 +82,7 @@ test.describe('Hybrid page-host keepLive on close path @desktop', () => {
   // The non-keepLive case must be UNCHANGED: a transient quick-view (no
   // keepLive) is destroyed on the close path so it gets cleanly recreated.
   test('keepLive:false hybrid host is CLOSED (destroyed) on the close path', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-load-start-show.spec.ts b/apps/desktop/tests/desktop/hybrid-load-start-show.spec.ts
index b4046aa3..a5f868f6 100644
--- a/apps/desktop/tests/desktop/hybrid-load-start-show.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-load-start-show.spec.ts
@@ -107,7 +107,7 @@ test.describe('Hybrid Load-Start Show @desktop', () => {
     app.evaluateMain!(() => Boolean((globalThis as any).__peekHybridOverlayTest));
 
   test('the host window is visible (loading frame) while content is still loading', async () => {
-    test.skip(!(await hybridBridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent()), 'no overlay bridge in this configuration');
 
     const slowUrl = `http://127.0.0.1:${serverPort}/slow/load-start`;
 
diff --git a/apps/desktop/tests/desktop/hybrid-overlay.spec.ts b/apps/desktop/tests/desktop/hybrid-overlay.spec.ts
index e7cab1d6..2a324677 100644
--- a/apps/desktop/tests/desktop/hybrid-overlay.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-overlay.spec.ts
@@ -30,7 +30,7 @@ test.describe('Hybrid Chrome Overlay (P1.4b-1) @desktop', () => {
     app.evaluateMain!(() => Boolean((globalThis as any).__peekHybridOverlayTest));
 
   test('retarget is focus-free: overlay frames A, then B, then hides on null', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const boundsA = { x: 100, y: 120, width: 640, height: 480 };
     const boundsB = { x: 800, y: 200, width: 500, height: 700 };
@@ -93,7 +93,7 @@ test.describe('Hybrid Chrome Overlay (P1.4b-1) @desktop', () => {
   });
 
   test('follows the active host window move/resize (focus-free)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 50, y: 60, width: 400, height: 300 };
     const moved = { x: 333, y: 222, width: 555, height: 666 };
@@ -118,7 +118,7 @@ test.describe('Hybrid Chrome Overlay (P1.4b-1) @desktop', () => {
   });
 
   test('singleton: exactly one overlay window across many active-changes', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(() => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -186,7 +186,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   };
 
   test('active handoff paints navbar for A, swaps to B, clears on null', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Two real (headless) hybrid windows; load distinct content so url() differs.
     const ids = await app.evaluateMain!(async () => {
@@ -249,7 +249,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('navbar intents drive the active content WebContents (navigate/back/reload)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -327,7 +327,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('content events repaint the active window navbar (nav-state, title)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -380,7 +380,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('overlay is focusable but not focused after a retarget (P1.4b-3)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Make + activate a hybrid window → overlay retargets onto it.
     await app.evaluateMain!(async () => {
@@ -403,7 +403,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('resize intent resizes the content window + overlay reframes (P1.4b-3)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 100, y: 120, width: 500, height: 400 };
     const resized = { x: 100, y: 120, width: 760, height: 560 };
@@ -429,7 +429,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('move intent moves the content window + overlay follows (P1.4b-3)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 200, y: 200, width: 480, height: 360 };
     const moved = { x: 640, y: 330, width: 480, height: 360 };
@@ -451,7 +451,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('maximize snaps to work area; restore returns to prior bounds (P1.4b-3)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 150, y: 160, width: 520, height: 380 };
 
@@ -477,7 +477,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('geometry intents for a non-hybrid windowId are a no-op (P1.4b-3)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // A windowId that is not a registered hybrid window must not throw and must
     // leave any real hybrid window untouched.
@@ -497,7 +497,7 @@ test.describe('Hybrid Chrome Overlay working navbar (P1.4b-2) @desktop', () => {
   });
 
   test('click-capture toggles overlay window between capture and click-through', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Ensure an overlay exists.
     await app.evaluateMain!(async () => {
@@ -558,7 +558,7 @@ test.describe('Hybrid Chrome Overlay find + title/favicon (P1.4b-4) @desktop', (
   };
 
   test('page:find-exec routes to the active content WC and finds a match; next advances; stop clears', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // A page with the term "needle" appearing 3 times.
     const id = await app.evaluateMain!(async () => {
@@ -601,7 +601,7 @@ test.describe('Hybrid Chrome Overlay find + title/favicon (P1.4b-4) @desktop', (
   });
 
   test('Cmd+F forward (page:find) opens the overlay find bar for the active window', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -642,7 +642,7 @@ test.describe('Hybrid Chrome Overlay find + title/favicon (P1.4b-4) @desktop', (
   });
 
   test('page:title-updated + page:favicon surface in the navbar (foreign windowId ignored)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -757,7 +757,7 @@ test.describe('Hybrid Chrome Overlay side panels (P1.4b-5) @desktop', () => {
   };
 
   test('page-info renders the active window data, swaps on retarget, clears on null', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveWithUrl('https://alpha.example.com/page');
     await waitOverlayReady();
@@ -860,7 +860,7 @@ test.describe('Hybrid Chrome Overlay side panels (P1.4b-5) @desktop', () => {
   });
 
   test('entities panel renders active-URL entities and swaps on retarget', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveWithUrl('https://ent-a.example.com/x');
     await waitOverlayReady();
@@ -914,7 +914,7 @@ test.describe('Hybrid Chrome Overlay side panels (P1.4b-5) @desktop', () => {
   });
 
   test('tags + extensions panels gain has-data for an active http window, clear on null', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     await makeActiveWithUrl('https://tagsite.example.com/p');
     await waitOverlayReady();
@@ -949,7 +949,7 @@ test.describe('Hybrid Chrome Overlay side panels (P1.4b-5) @desktop', () => {
   });
 
   test('panels become visible with the chrome and are in the click-capture set', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveWithUrl('https://vis.example.com/p');
     await waitOverlayReady();
@@ -1037,7 +1037,7 @@ test.describe('Hybrid Chrome Overlay notes + widgets (P1.4b-6) @desktop', () =>
   };
 
   test('notes pane loads for the active URL, swaps on retarget, clears on null', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Seed a note in the datastore anchored to alpha, via the overlay's own
     // api.datastore (the same path PageNotesPane reads). The note is a 'text' item
@@ -1118,7 +1118,7 @@ test.describe('Hybrid Chrome Overlay notes + widgets (P1.4b-6) @desktop', () =>
   });
 
   test('OpenSearch widget appears for active windowId, foreign ignored, clears on retarget', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveWithUrl('https://search.example.com/home');
     await waitOverlayReady();
@@ -1188,7 +1188,7 @@ test.describe('Hybrid Chrome Overlay notes + widgets (P1.4b-6) @desktop', () =>
   });
 
   test('gutter fix: widgets render in the right gutter (outside content) and STACK', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveWithUrl('https://gutter.example.com/p');
     await waitOverlayReady();
@@ -1273,7 +1273,7 @@ test.describe('Hybrid Chrome Overlay focus-group @desktop', () => {
   };
 
   test('clicking the chrome (overlay focus on content blur) does NOT deactivate', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Content A focused → active = A, overlay shown over A.
     const setup = await app.evaluateMain!(async () => {
@@ -1326,7 +1326,7 @@ test.describe('Hybrid Chrome Overlay focus-group @desktop', () => {
   });
 
   test('real switch between two hybrid windows still retargets (A → B)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -1361,7 +1361,7 @@ test.describe('Hybrid Chrome Overlay focus-group @desktop', () => {
   });
 
   test('back/forward unblocked: nav drives the active content WC held through an overlay interaction', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -1507,7 +1507,7 @@ test.describe('Hybrid Chrome Overlay navbar reveal @desktop', () => {
   };
 
   test('Cmd+L (page:show-navbar) reveals the navbar AND focuses the URL field; foreign windowId ignored', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActive('data:text/html,<body>cmd-l target</body>');
 
@@ -1544,7 +1544,7 @@ test.describe('Hybrid Chrome Overlay navbar reveal @desktop', () => {
   });
 
   test('trigger-zone hover reliably reveals the navbar via the forwarded mousemove path', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     await makeActive('data:text/html,<body>hover target</body>');
 
@@ -1566,7 +1566,7 @@ test.describe('Hybrid Chrome Overlay navbar reveal @desktop', () => {
   });
 
   test('trigger-zone → navbar move keeps the chrome open (no flicker); move off schedules hide', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     await makeActive('data:text/html,<body>flicker target</body>');
 
@@ -1691,7 +1691,7 @@ test.describe('Hybrid Chrome Overlay top-border gesture reveal (363e7cff) @deskt
   };
 
   test('idle top-border hover over the content WC reveals the navbar (no-gutter/maximized)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveMaximized();
     await resetHidden();
@@ -1710,7 +1710,7 @@ test.describe('Hybrid Chrome Overlay top-border gesture reveal (363e7cff) @deskt
   });
 
   test('idle move BELOW the reveal band does not reveal; entering it does', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveMaximized();
     await resetHidden();
@@ -1733,7 +1733,7 @@ test.describe('Hybrid Chrome Overlay top-border gesture reveal (363e7cff) @deskt
   });
 
   test('top-border reveal also works in the GUTTERED (non-maximized) case', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -1753,7 +1753,7 @@ test.describe('Hybrid Chrome Overlay top-border gesture reveal (363e7cff) @deskt
   });
 
   test('idle move within the navbar band but past the 8px trigger strip does NOT reveal', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveMaximized();
     await resetHidden();
@@ -1768,7 +1768,7 @@ test.describe('Hybrid Chrome Overlay top-border gesture reveal (363e7cff) @deskt
   });
 
   test('boundary: a move at the trigger strip edge (<=8px) reveals', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveMaximized();
     await resetHidden();
@@ -1782,7 +1782,7 @@ test.describe('Hybrid Chrome Overlay top-border gesture reveal (363e7cff) @deskt
   });
 
   test('hysteresis: once revealed, moving within the navbar band keeps it revealed, then clears past 44px', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActiveMaximized();
     await resetHidden();
@@ -1871,7 +1871,7 @@ test.describe('Hybrid Chrome Overlay regressions R1/R2/R3 @desktop', () => {
   };
 
   test('R1: app resign-active forces click-through + drops floating; become-active restores', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     await makeActive('data:text/html,<body>r1 target</body>');
 
@@ -1931,7 +1931,7 @@ test.describe('Hybrid Chrome Overlay regressions R1/R2/R3 @desktop', () => {
   });
 
   test('hold-to-drag FSM: hold-then-move drags; pre-threshold move cancels (pure, manual clock)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Ensure the overlay renderer exists + is ready (the FSM factory lives there).
     await app.evaluateMain!(async () => {
@@ -1966,7 +1966,7 @@ test.describe('Hybrid Chrome Overlay regressions R1/R2/R3 @desktop', () => {
   });
 
   test('hold-to-drag: navbar background HOLD then move publishes page:set-bounds and moves the host', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 200, y: 220, width: 520, height: 400 };
     const id = await app.evaluateMain!(async (_e, arg) => {
@@ -2009,7 +2009,7 @@ test.describe('Hybrid Chrome Overlay regressions R1/R2/R3 @desktop', () => {
   });
 
   test('hold-to-drag: a stray buttons=0 mousemove during the hold does NOT cancel the press (flake regression 73681521/7064b15c)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 240, y: 240, width: 520, height: 400 };
     const id = await app.evaluateMain!(async (_e, arg) => {
@@ -2052,7 +2052,7 @@ test.describe('Hybrid Chrome Overlay regressions R1/R2/R3 @desktop', () => {
   });
 
   test('hold-to-drag: pre-threshold movement CANCELS candidacy (dnd / selection / click preserved) and does NOT move the host', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const start = { x: 260, y: 280, width: 500, height: 380 };
     const id = await app.evaluateMain!(async (_e, arg) => {
@@ -2090,7 +2090,7 @@ test.describe('Hybrid Chrome Overlay regressions R1/R2/R3 @desktop', () => {
   });
 
   test('R3: Cmd+L focuses the overlay window for the active window only, never when backgrounded', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const id = await makeActive('data:text/html,<body>cmd-l focus target</body>');
 
diff --git a/apps/desktop/tests/desktop/hybrid-popups.spec.ts b/apps/desktop/tests/desktop/hybrid-popups.spec.ts
index db5b1f6d..3622a6c1 100644
--- a/apps/desktop/tests/desktop/hybrid-popups.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-popups.spec.ts
@@ -10,8 +10,8 @@ import { createPerDescribeApp } from '../helpers/test-app';
  * installs an explicit `setWindowOpenHandler` on it that mirrors the canvas
  * <webview> guest policy: http(s) `window.open` / `target=_blank` are DENIED
  * the default raw popup and re-routed through the canonical window-open IPC
- * handler (`invokeWindowOpen`). With the hybrid flag on, that re-entry takes the
- * hybrid EARLY BRANCH → a NEW opaque BaseWindow + WebContentsView page-host.
+ * handler (`invokeWindowOpen`). That re-entry takes the hybrid EARLY BRANCH →
+ * a NEW opaque BaseWindow + WebContentsView page-host.
  *
  * The test bridge's `makeWiredHybrid(dataUrl)` builds a hybrid window and calls
  * the SAME `wireHybridContentEvents` the real branch calls, so the handler under
@@ -19,7 +19,7 @@ import { createPerDescribeApp } from '../helpers/test-app';
  * window-registry `address` of any NEW hybrid host (network-free).
  *
  * Everything is focus-free: hybrid windows are headless (opacity 0, never
- * shown). Skips itself if the hybrid bridge isn't present (flag off).
+ * shown). Skips itself if the hybrid bridge isn't present.
  */
 test.describe('Hybrid page-host popups (P1.5) @desktop', () => {
   let app: DesktopApp;
@@ -36,7 +36,7 @@ test.describe('Hybrid page-host popups (P1.5) @desktop', () => {
     app.evaluateMain!(() => Boolean((globalThis as any).__peekHybridOverlayTest));
 
   test('window.open(https) routes to a NEW hybrid page-host (not a raw popup)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no hybrid bridge');
+    test.skip(!(await bridgePresent()), 'no hybrid bridge in this configuration');
 
     // A hybrid page-host whose content WC has the real popup handler installed.
     const opener = await app.evaluateMain!(async () => {
@@ -74,7 +74,7 @@ test.describe('Hybrid page-host popups (P1.5) @desktop', () => {
   });
 
   test('target=_blank click (https) also routes to a NEW hybrid page-host', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no hybrid bridge');
+    test.skip(!(await bridgePresent()), 'no hybrid bridge in this configuration');
 
     const opener = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -101,7 +101,7 @@ test.describe('Hybrid page-host popups (P1.5) @desktop', () => {
   });
 
   test('non-http(s) window.open (about:blank) is NOT routed to a hybrid host (canvas policy)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no hybrid bridge');
+    test.skip(!(await bridgePresent()), 'no hybrid bridge in this configuration');
 
     const opener = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-reuse.spec.ts b/apps/desktop/tests/desktop/hybrid-reuse.spec.ts
index 1e58a130..fec76f3a 100644
--- a/apps/desktop/tests/desktop/hybrid-reuse.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-reuse.spec.ts
@@ -19,7 +19,7 @@ import { createPerDescribeApp } from '../helpers/test-app';
  * Network-free: dedup (and `waitHybridForUrl`) match the REQUESTED address the
  * registry stores at open time, independent of whether the content load
  * resolves. Focus-free: hybrid windows are headless (opacity 0, never shown).
- * Skips itself if the hybrid bridge isn't present (flag off).
+ * Skips itself if the hybrid bridge isn't present.
  */
 test.describe('Hybrid page-host window-reuse dedup (P1.4a) @desktop', () => {
   let app: DesktopApp;
@@ -36,7 +36,7 @@ test.describe('Hybrid page-host window-reuse dedup (P1.4a) @desktop', () => {
     app.evaluateMain!(() => Boolean((globalThis as any).__peekHybridOverlayTest));
 
   test('a repeat open of the same URL reuses the existing hybrid window (no duplicate)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no hybrid bridge');
+    test.skip(!(await bridgePresent()), 'no hybrid bridge in this configuration');
     const url = 'https://reuse.example/';
 
     const opener = await app.evaluateMain!(async () => {
diff --git a/apps/desktop/tests/desktop/hybrid-shortcut-routing.spec.ts b/apps/desktop/tests/desktop/hybrid-shortcut-routing.spec.ts
index f9cda4e8..eec04a45 100644
--- a/apps/desktop/tests/desktop/hybrid-shortcut-routing.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-shortcut-routing.spec.ts
@@ -49,7 +49,7 @@ test.describe('Hybrid page-host shortcut routing (R2/R3) @desktop', () => {
   // carries the real cmd+N → openNewPageWindow binding). The event is also
   // preventDefault()-ed (consumed), matching the canvas/core dispatch contract.
   test('cmd+N over a hybrid host reaches the local-shortcut dispatcher (R3)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -78,7 +78,7 @@ test.describe('Hybrid page-host shortcut routing (R2/R3) @desktop', () => {
   // Before the fix, only the page-specific accelerators reached the handler, so
   // these were dead with a hybrid host focused.
   test('a generic local shortcut fires through the hybrid content WC path (R2)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -99,7 +99,7 @@ test.describe('Hybrid page-host shortcut routing (R2/R3) @desktop', () => {
   // INLINE by the hybrid handler and must NOT also be routed to a same-key local
   // shortcut — i.e. the inline page set takes precedence (no double-dispatch).
   test('page-specific accelerators stay inline, not double-dispatched (guard)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-show-activate.spec.ts b/apps/desktop/tests/desktop/hybrid-show-activate.spec.ts
index ac506661..e6ba6778 100644
--- a/apps/desktop/tests/desktop/hybrid-show-activate.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-show-activate.spec.ts
@@ -52,7 +52,7 @@ test.describe('Hybrid page-host show/activate (R4/R5/R7) @desktop', () => {
   // (peek task 2b55f3af). We assert BOTH branches deterministically via the pure
   // decision — focus-free, independent of the run's actual headless mode.
   test('show DECISION: non-headless activates+focuses content; headless stays inactive', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const { real, headless } = await app.evaluateMain!(() => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -79,7 +79,7 @@ test.describe('Hybrid page-host show/activate (R4/R5/R7) @desktop', () => {
   // The applied show path matches the decision for THIS run (headless here): it
   // must take the inactive, focus-free branch — never activate, never focus.
   test('applied show path is focus-free under headless', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const probe = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -101,7 +101,7 @@ test.describe('Hybrid page-host show/activate (R4/R5/R7) @desktop', () => {
   // overlay retarget + reveal over the content. If the content WC focus is never
   // delivered to the registry, active stays null and the overlay never reveals.
   test('content-WC focus drives active-hybrid id → overlay can reveal (R5)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const result = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
@@ -132,7 +132,7 @@ test.describe('Hybrid page-host show/activate (R4/R5/R7) @desktop', () => {
   // it left the overlay VISIBLE. On resign it must hide; on become-active (with an
   // active hybrid window) it re-frames + shows.
   test('overlay hides when the app resigns active, re-shows on become-active (R6)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     const visibleWhileActive = await app.evaluateMain!(async () => {
       const b = (globalThis as any).__peekHybridOverlayTest;
diff --git a/apps/desktop/tests/desktop/hybrid-windows-feature.spec.ts b/apps/desktop/tests/desktop/hybrid-windows-feature.spec.ts
index 6d4aea30..7a1cbf5a 100644
--- a/apps/desktop/tests/desktop/hybrid-windows-feature.spec.ts
+++ b/apps/desktop/tests/desktop/hybrid-windows-feature.spec.ts
@@ -34,7 +34,7 @@ test.describe('Windows feature: hybrid page-host enumeration @desktop', () => {
     app.evaluateMain!(() => Boolean((globalThis as any).__peekHybridOverlayTest));
 
   test('both hybrid windows appear in the windows-feature list with correct url/title', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Two real (headless) hybrid windows with distinct content, so url()/title()
     // differ between them.
@@ -77,7 +77,7 @@ test.describe('Windows feature: hybrid page-host enumeration @desktop', () => {
   });
 
   test('focusing a hybrid entry routes to its host BaseWindow (focus action)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // The windows feature focuses a selected window by id (setOverlayFocusTarget
     // → main routes getLiveWindow OR, for a hybrid, getHybridWindow().baseWin).
@@ -107,7 +107,7 @@ test.describe('Windows feature: hybrid page-host enumeration @desktop', () => {
   });
 
   test('additive: list is empty of hybrids until any are registered (flag-off shape)', async () => {
-    test.skip(!(await bridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await bridgePresent()), 'no overlay bridge in this configuration');
 
     // Close every hybrid window registered by the prior tests, then assert the
     // windows-feature hybrid loop yields ZERO entries — i.e. the addition is
diff --git a/apps/desktop/tests/desktop/izui-behavior.spec.ts b/apps/desktop/tests/desktop/izui-behavior.spec.ts
index 1bec95d2..1a2ce66d 100644
--- a/apps/desktop/tests/desktop/izui-behavior.spec.ts
+++ b/apps/desktop/tests/desktop/izui-behavior.spec.ts
@@ -68,9 +68,9 @@ test.describe('IZUI Behavior @desktop', () => {
 
     // Step 2: Open a child window FROM the groups content window.
     // Since groups/home.html is a real content window (not the background renderer),
-    // the child should get parentWindowId set to the groups window's ID. Under the
-    // hybrid flag the child is an opaque BaseWindow page-host, but parent
-    // propagation flows through the same window-registry params either way.
+    // the child should get parentWindowId set to the groups window's ID. The
+    // child is an opaque BaseWindow page-host, but parent propagation flows
+    // through the same window-registry params either way.
     const childUrl = `http://127.0.0.1:${serverPort}/`;
     const childResult = await groupsWindow.evaluate(async (u: string) => {
       return await (window as any).app.window.open(u, {
diff --git a/apps/desktop/tests/desktop/page-navbar.spec.ts b/apps/desktop/tests/desktop/page-navbar.spec.ts
index 2069d6cb..8691cbf1 100644
--- a/apps/desktop/tests/desktop/page-navbar.spec.ts
+++ b/apps/desktop/tests/desktop/page-navbar.spec.ts
@@ -53,7 +53,7 @@ const PAGE_HTML = 'data:text/html,<title>Example</title><body>hello page-navbar<
 
 test.describe('Page Navbar @desktop', () => {
   test('navbar reflects the content loading lifecycle and stays hidden by default', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -81,7 +81,7 @@ test.describe('Page Navbar @desktop', () => {
   });
 
   test('Cmd+L reveals the navbar and focuses its URL field', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -108,7 +108,7 @@ test.describe('Page Navbar @desktop', () => {
   });
 
   test('revealed navbar schedules auto-hide when the pointer moves off the chrome', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -128,7 +128,7 @@ test.describe('Page Navbar @desktop', () => {
   });
 
   test('trigger-zone hover reveals the navbar', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
diff --git a/apps/desktop/tests/desktop/page-redirect.spec.ts b/apps/desktop/tests/desktop/page-redirect.spec.ts
index 55ce7b90..7cfc41e0 100644
--- a/apps/desktop/tests/desktop/page-redirect.spec.ts
+++ b/apps/desktop/tests/desktop/page-redirect.spec.ts
@@ -111,7 +111,7 @@ async function contentElementText(
 
 test.describe('Page Host Redirect Navigation @desktop', () => {
   test('HTTP 301 redirect: content loads the redirect target, not blank', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const redirectUrl = `http://127.0.0.1:${serverPort}/redirect-301`;
     // openHybridPage runs contentWC.loadURL to completion, following redirects.
@@ -127,7 +127,7 @@ test.describe('Page Host Redirect Navigation @desktop', () => {
   });
 
   test('HTTP 302 redirect: content loads the redirect target', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const redirectUrl = `http://127.0.0.1:${serverPort}/redirect-302`;
     const h = await openHybridPage(app, redirectUrl);
@@ -138,7 +138,7 @@ test.describe('Page Host Redirect Navigation @desktop', () => {
   });
 
   test('Redirect chain (301→302): content loads the final target', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const redirectUrl = `http://127.0.0.1:${serverPort}/redirect-chain`;
     const h = await openHybridPage(app, redirectUrl);
@@ -150,7 +150,7 @@ test.describe('Page Host Redirect Navigation @desktop', () => {
   });
 
   test('Redirect: content reaches the target without stalling blank', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     // The canvas version polled webview CSS classes to detect a blank
     // (opacity-0, no loading/loaded class) frame. In the hybrid model the
diff --git a/apps/desktop/tests/desktop/page-widgets.spec.ts b/apps/desktop/tests/desktop/page-widgets.spec.ts
index a786f982..9c06b5fe 100644
--- a/apps/desktop/tests/desktop/page-widgets.spec.ts
+++ b/apps/desktop/tests/desktop/page-widgets.spec.ts
@@ -55,7 +55,7 @@ const PAGE_HTML = 'data:text/html,<title>Example</title><body>hello page-widgets
 
 test.describe('Page Widgets @desktop', () => {
   test('widget host is initialized for the active hybrid page', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -67,7 +67,7 @@ test.describe('Page Widgets @desktop', () => {
   });
 
   test('widget:register creates a widget registration', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -86,7 +86,7 @@ test.describe('Page Widgets @desktop', () => {
   });
 
   test('widget:render displays a widget in the overlay container', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -115,7 +115,7 @@ test.describe('Page Widgets @desktop', () => {
   });
 
   test('widget:update modifies existing widget content', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -151,7 +151,7 @@ test.describe('Page Widgets @desktop', () => {
   });
 
   test('widget:close removes widget from the overlay container', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
 
@@ -185,7 +185,7 @@ test.describe('Page Widgets @desktop', () => {
 
   // ── page:execute-script — runs in MAIN against the hybrid content WC ───────
   test('page:execute-script runs code in webview and returns result', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
     const res = await app.evaluateMain!((_e, arg) => {
@@ -200,7 +200,7 @@ test.describe('Page Widgets @desktop', () => {
   });
 
   test('page:execute-script returns error for invalid script', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     const h = await openHybridPage(app, PAGE_HTML);
     const res = await app.evaluateMain!((_e, arg) => {
diff --git a/apps/desktop/tests/desktop/runtime-external-polyfill.spec.ts b/apps/desktop/tests/desktop/runtime-external-polyfill.spec.ts
index c27db869..f34c7f1b 100644
--- a/apps/desktop/tests/desktop/runtime-external-polyfill.spec.ts
+++ b/apps/desktop/tests/desktop/runtime-external-polyfill.spec.ts
@@ -63,7 +63,7 @@ test.describe('runtime-external polyfill @desktop', () => {
   });
 
   test('preload + page polyfill are NOT injected when URL does not match externally_connectable', async () => {
-    test.skip(!(await hybridBridgePresent(app)), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent(app)), 'no overlay bridge in this configuration');
 
     // Deliberately a NON-matching URL (127.0.0.1) to confirm the negative case:
     // no runtime-external preload should be selected, so chrome.runtime should
diff --git a/apps/desktop/tests/desktop/session-restore-deferred-load.spec.ts b/apps/desktop/tests/desktop/session-restore-deferred-load.spec.ts
index 98c13e1c..a4bb2aa8 100644
--- a/apps/desktop/tests/desktop/session-restore-deferred-load.spec.ts
+++ b/apps/desktop/tests/desktop/session-restore-deferred-load.spec.ts
@@ -131,7 +131,7 @@ test.describe('Session Restore Deferred Load @desktop', () => {
     // Hybrid-only: the deferred-load mechanism lives in the hybrid registry.
     const isHybrid = await app.evaluateMain!(((_e: unknown, id: number) =>
       (globalThis as any).__peek_test.isHybridWindowForTest(id)) as never, openedIds[0]) as boolean;
-    test.skip(!isHybrid, 'hybrid flag off — deferred restore is hybrid-only');
+    test.skip(!isHybrid, 'not a hybrid page-host — deferred restore is hybrid-only');
 
     // Save, close everything, restore.
     await app.evaluateMain!((() =>
diff --git a/apps/desktop/tests/desktop/session-restore-hybrid-focus.spec.ts b/apps/desktop/tests/desktop/session-restore-hybrid-focus.spec.ts
index 50269e3c..1f7c01fd 100644
--- a/apps/desktop/tests/desktop/session-restore-hybrid-focus.spec.ts
+++ b/apps/desktop/tests/desktop/session-restore-hybrid-focus.spec.ts
@@ -121,7 +121,7 @@ test.describe('Session Restore Hybrid Focus @desktop', () => {
   // focused is not the one raised. Pre-fix `hybridShowIntent(false)` is
   // unconditionally activating (no inactive concept), so this assertion fails.
   test('restore (show:false) hybrid show DECISION is non-activating in non-headless', async () => {
-    test.skip(!(await hybridBridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent()), 'no overlay bridge in this configuration');
 
     const { freshNonHeadless, restoreNonHeadless, restoreHeadless } =
       await app.evaluateMain!(() => {
@@ -157,7 +157,7 @@ test.describe('Session Restore Hybrid Focus @desktop', () => {
   // EXACTLY ONE hybrid window (not both). The drift counters expose the
   // restore loop's decision focus-free.
   test('two hybrid pages: the page focused at save is the one restore raises (not the other)', async () => {
-    test.skip(!(await hybridBridgePresent()), 'hybrid flag off — no overlay bridge');
+    test.skip(!(await hybridBridgePresent()), 'no overlay bridge in this configuration');
 
     const slugA = 'hybrid-focus-A';
     const slugB = 'hybrid-focus-B';
@@ -172,7 +172,7 @@ test.describe('Session Restore Hybrid Focus @desktop', () => {
 
     const aIsHybrid = await app.evaluateMain!(((_e: unknown, id: number) =>
       (globalThis as any).__peek_test.isHybridWindowForTest(id)) as any, a.windowId) as boolean;
-    test.skip(!aIsHybrid, 'hybrid flag off — identity bug is hybrid-only');
+    test.skip(!aIsHybrid, 'not a hybrid page-host — identity bug is hybrid-only');
 
     // The user clicks BACK into page A → A is the page focused at quit. Drive
     // the REAL host BaseWindow 'focus' event (the exact event Electron fires).
diff --git a/apps/desktop/tests/desktop/session-restore-page-host.spec.ts b/apps/desktop/tests/desktop/session-restore-page-host.spec.ts
index 1536acc2..2bd2eb01 100644
--- a/apps/desktop/tests/desktop/session-restore-page-host.spec.ts
+++ b/apps/desktop/tests/desktop/session-restore-page-host.spec.ts
@@ -581,9 +581,9 @@ test.describe('Session Restore Page Host @desktop', () => {
     const settingsWindow = await app.getWindow('settings/settings.html', 15000);
     await settingsWindow.waitForLoadState('domcontentloaded');
 
-    // Open the web page. Under the hybrid flag this is a BaseWindow page-host;
-    // its content webContents loads the bare http URL (no canvas ?width/height
-    // wrapper), so we just wait for the page to load.
+    // Open the web page. This is a BaseWindow page-host; its content
+    // webContents loads the bare http URL (no canvas ?width/height wrapper),
+    // so we just wait for the page to load.
     const { pageWindow, windowId: webWindowId } = await openPageHost(url);
     await pageWindow.waitForLoadState('domcontentloaded');
 
@@ -591,7 +591,7 @@ test.describe('Session Restore Page Host @desktop', () => {
     // page-host, the same way the hybrid-overlay suite does.
     const isHybrid = await app.evaluateMain!(((_e: unknown, id: number) =>
       (globalThis as any).__peek_test.isHybridWindowForTest(id)) as any, webWindowId) as boolean;
-    test.skip(!isHybrid, 'hybrid flag off — focus-order bug is hybrid-only');
+    test.skip(!isHybrid, 'not a hybrid page-host — focus-order bug is hybrid-only');
 
     // The user clicks into the web page → it becomes frontmost/focused. Drive
     // the REAL host-BaseWindow 'focus' event (Electron's own event on OS focus).
@@ -713,7 +713,7 @@ test.describe('Session Restore Page Host @desktop', () => {
 
     const isHybrid = await app.evaluateMain!(((_e: unknown, id: number) =>
       (globalThis as any).__peek_test.isHybridWindowForTest(id)) as any, windowId) as boolean;
-    test.skip(!isHybrid, 'hybrid flag off — this test exercises the hybrid maximize registry');
+    test.skip(!isHybrid, 'not a hybrid page-host — this test exercises the hybrid maximize registry');
 
     async function findEntry(id: number) {
       return bgWindow.evaluate(async (targetId: number) => {