# Chrome-extension value evaluation — does an MV3 extension add concrete value beyond CDP?

**Phase:** 180.C.20.06
**Status:** Decision — **extension mode IS approved** for a *minimal* MV3
extension. Direct CDP remains the verified default for driving the browser; the
extension exists only to close three specific value gaps CDP cannot cleanly fill
(a tamper-resistant visible-automation indicator, a native-ish consent/approval
popup, and a per-origin profile-grant surface). The extension is implemented in
180.C.20.07 and adversarially tested in 180.C.20.08.
**Scope:** Whether a browser extension earns its place alongside the existing
direct-CDP host browser surface for **overlays, profile grants, page
annotations, and consent UI** — and, if so, with what trust posture.

This evaluation is anchored to what the Bellona remote-control surface already
ships: the deterministic CDP/Playwright host browser adapter
(`apps/bellona/remote-host/src/browser-adapter.ts`), the browser-agent provider
plane and 180.C.20.04 policy gate
(`libs/bellona/remote-protocol/src/browser-agent-provider.ts`), and the
profile-isolation policy (`browser-profile-isolation.md`). The question is not
"extension vs. CDP" as a backend (CDP wins that — see
`browser-use-vs-direct-cdp-evaluation.md`); it is "is there a UX/trust surface
only an extension can provide, on top of CDP."

> **Honesty note (what is and isn't built).** The MV3 extension authored in
> 180.C.20.07 cannot be *loaded* in this CI environment — there is no Chrome
> profile or extension-host harness on the box. So the extension's security
> DECISIONS are implemented as pure, unit-tested functions
> (`apps/bellona/remote-extension/src/`), and the Chrome-runtime wiring
> (`background.ts`, `content-script.ts`) is a thin shell over them. Where this
> doc says "the extension does X," the *logic* of X is the cited pure function
> with a test; the Chrome glue is not asserted by an automated browser load.
> This is the same dependency-boundary discipline the Browser Use seam uses (we
> don't fabricate a runtime we can't exercise).

---

## 1. The four candidate value areas, judged against CDP

For each area: what CDP can do today, what an extension adds, and whether the
delta is *concrete* (a capability CDP genuinely lacks) or *cosmetic* (CDP can do
it, the extension is just nicer).

### 1.1 Overlays / page annotations

| | Direct CDP | MV3 extension |
| --- | --- | --- |
| Inject a banner/annotation | Yes — `Runtime.evaluate` / Playwright `addScriptTag` can inject DOM | Yes — content script injects DOM |
| **Page can remove it** | **Yes** — the injected node lives in the page's own DOM; page JS can `node.remove()`, restyle it, or a SPA re-render can wipe it, and CDP has no reliable "keep it there" primitive | **No (resistant)** — the content script runs in an ISOLATED world, mounts the banner in a **closed Shadow DOM** (page CSS/JS cannot read or restyle it), and a `MutationObserver` **re-mounts it the instant the page removes or hides it**; a look-alike node planted under the same id fails the integrity stamp |
| Survives navigation | Re-inject after every navigation (host bookkeeping) | Content script auto-runs at `document_start` on every allow-listed navigation |

**Verdict: CONCRETE for the *visible-automation indicator*; cosmetic for generic
annotations.** A decorative annotation is fine over CDP. But a banner whose
*entire purpose* is to truthfully tell a human "automation is driving this tab
right now" is a **safety control**, and a safety control the page can silently
delete is not a control. CDP cannot make the indicator tamper-resistant; an
isolated-world content script with a re-mounting `MutationObserver` can. This is
gap #1.

### 1.2 Consent UI / approval popup

| | Direct CDP | MV3 extension |
| --- | --- | --- |
| Where consent is collected today | In the **Control Room** (a first-party web app) — the operator approves an in-app dialog; the approval is a plan-bound token the 180.C.20.04 gate checks | Same Control Room path still works |
| In-page / browser-chrome consent | CDP can only draw *into the page* (spoofable: a page can mimic the dialog); it cannot put UI in the browser chrome | The **extension action popup** is browser-chrome UI the page cannot draw over or spoof; an `externally_connectable`-scoped channel lets the gateway drive an approval prompt that is visibly *not* page content |
| Trust origin of the prompt | The page (or an injected overlay) — weak | The extension (browser chrome) — strong |

**Verdict: CONCRETE but NARROW.** The Control Room already collects consent and
the 180.C.20.04 gate already enforces it, so the extension does **not** replace
the approval *system*. What it adds is a consent/approval surface that lives in
**browser chrome**, which a hostile page cannot spoof or obscure — useful
specifically when the operator is watching the target tab rather than the
Control Room. This is gap #2 (a refinement, not a new authority).

### 1.3 Profile grants (per-origin)

| | Direct CDP | MV3 extension |
| --- | --- | --- |
| Profile model today | Bellona-managed **isolated** profiles only; personal-profile access is a privileged, human-consented, restricted-origin, visible-stream session (`browser-profile-isolation.md`) | Same model; extension does not touch the personal profile wholesale |
| Per-origin scoping | CDP grants are **per-session/per-launch**; the *origin* allow-list is enforced by the host, not surfaced to the human as a standing per-origin grant | The extension's `host_permissions` ARE an explicit **per-origin allow-list** the human sees at install/grant time, and the per-session capability grant binds clipboard/upload/form to **specific origins** |
| Visibility of "what is granted where" | Buried in host config | A first-class, per-origin surface (the manifest + the grant view) |

**Verdict: CONCRETE for *surfacing/scoping* grants per origin.** CDP can confine
a session to origins, but it has no native notion of "the human granted
automation permission on **these specific origins** and nothing else, and can
see and revoke that." An extension's `host_permissions` model is exactly a
per-origin grant surface. This is gap #3.

### 1.4 Net: three concrete gaps, all UX/trust (not capability)

None of the gaps is "the extension can drive the browser better" — CDP drives
better (deterministic, on-box, auditable). All three are **trust-surface** gaps:
a tamper-resistant *indicator*, a spoof-proof *consent* surface, and a
per-origin *grant* surface. That is precisely the value an extension adds that
CDP structurally cannot.

---

## 2. The cost / risk side (why "minimal" and why policy-gated)

An extension is not free. The same isolated-world power that makes the indicator
tamper-resistant also means the content script **sees and can act on page
content** — it is, like Browser Use, a third-party-ish surface from the trust
model's point of view. The risks, and how the 180.C.20.07 design contains them:

| Risk | Containment (180.C.20.07) |
| --- | --- |
| Over-broad host access (`<all_urls>`) | **Forbidden by construction.** `host_permissions` and `content_scripts.matches` are an explicit operator allow-list; `compileExtensionOriginAllowList` / `assertManifestDomainScoped` reject `<all_urls>`, `*://*/*`, `http(s)://*/*` fail-loud. |
| A malicious iframe forging commands | `verifyExtensionMessageOrigin` rejects any sender whose origin is not the trusted host (and any sub-frame under `requireTopFrame`) **before** the payload is read; page-world traffic is additionally bound to a per-session token. |
| A page baiting clipboard/upload/form | `evaluateClipboardAccess` / `evaluateFileUpload` / `evaluateFormSubmission` are closed-by-default: refused unless the capability was explicitly granted **and** a single-use approval token + allow-listed origin match — the same discipline as the 180.C.20.04 gate and the 180.C.19.04/.06 upload/credential guards. |
| Extension impersonation / foreign extension | `verifyExtensionMessageSender` trusts only THIS extension id or an allow-listed external host origin; `externally_connectable` names one gateway origin, never a wildcard. |
| Stale authority after disable/uninstall | `runExtensionTeardown` revokes the session token, drops every capability grant, and tears down the indicator; post-teardown `authorize()` returns null so no message authenticates. |
| Excess permissions | `permissions` is the justified minimal set (`scripting`, `activeTab`, `storage`); `clipboardRead/Write` are **optional** (runtime-requested, gated), never install-time. |

**Why "minimal":** every capability beyond the three gaps is attack surface
without a justifying value gap. So the approved extension does the three things
and nothing else — it is not a general automation backend (that is CDP) and not
an agent (that is Browser Use).

---

## 3. Decision

1. **Approve a minimal MV3 extension** as an *optional* trust-surface layer on
   top of direct CDP. It is justified by three concrete gaps CDP cannot cleanly
   fill:
   - **a tamper-resistant, page-visible automation indicator** (the page cannot
     remove or spoof it — isolated-world + closed Shadow DOM + re-mounting
     observer + integrity stamp),
   - **a native-ish consent/approval popup** in browser chrome (spoof-proof,
     unlike an in-page overlay), refining — not replacing — the Control Room +
     180.C.20.04 approval system, and
   - **a per-origin profile-grant surface** (`host_permissions` as an explicit,
     human-visible, revocable per-origin allow-list).

2. **Direct CDP stays the default and the only automation backend.** The
   extension does not drive tasks, does not receive credentials, and is **never
   required** for the deterministic browser MVP (180.C.20.10). It is purely
   additive UX/trust.

3. **The extension is a third-party-ish surface and is policy-gated like one.**
   Domain-scoped (`<all_urls>` forbidden), extension-origin authenticated
   (handshake + per-session token, malicious-iframe-rejecting), and its
   sensitive actions (clipboard/upload/form) are closed-by-default behind the
   same explicit-approval discipline as the rest of Bellona. Disable/uninstall
   revokes everything.

4. **No fabricated runtime.** The extension cannot be loaded in CI, so its
   security logic is implemented and tested as pure functions; the Chrome glue
   is a thin shell. We assert the logic, not a browser load we cannot perform.

### What this unblocks / requires

- 180.C.20.07 (implement the minimal manifest, domain-scoped permissions,
  extension-origin authentication, visible automation indicator) — **required**
  by this approval.
- 180.C.20.08 (adversarial extension tests) — **required**.
- 180.C.20.09 (when each of CDP / Browser Use / extension / desktop is allowed)
  — the decision matrix that places this surface relative to the others.

---

## 4. Evidence pointers

- Extension security primitives (pure, unit-tested) and Chrome wiring:
  `apps/bellona/remote-extension/src/`
  (`origin-policy.ts`, `extension-auth.ts`, `action-guards.ts`,
  `automation-indicator.ts`, `session-lifecycle.ts`, `manifest-policy.ts`,
  `background.ts`, `content-script.ts`, `manifest.json`).
- The MV3 manifest proving domain-scoping (NOT `<all_urls>`):
  `apps/bellona/remote-extension/src/manifest.json` (validated by
  `manifest-policy.test.ts`).
- The trust model this extension mirrors (third-party → policy-gated,
  origin-authenticated, no credentials without approval):
  `libs/bellona/remote-protocol/src/browser-agent-provider.ts` and
  `browser-use-vs-direct-cdp-evaluation.md` §6.
- The profile-isolation policy the per-origin grant surface extends:
  `browser-profile-isolation.md`.
- Where each surface is allowed: `remote-control-mode-allowance-matrix.md`
  (180.C.20.09).
