diff --git a/.github/workflows/mv3-compatibility.yml b/.github/workflows/mv3-compatibility.yml
index 13a9eec6c..f6b227c3a 100644
--- a/.github/workflows/mv3-compatibility.yml
+++ b/.github/workflows/mv3-compatibility.yml
@@ -6,10 +6,17 @@ on:
     paths:
       - ".github/workflows/mv3-compatibility.yml"
       - "crates/originweave-core/**"
+      - "crates/originweave-fingerprint/**"
+      - "extensions/originweave-privacy-guard/**"
       - "scripts/ci/run_mv3_compatibility.py"
+      - "scripts/ci/run_web_audio_privacy.py"
       - "tests/fixtures/mv3_basic/**"
+      - "tests/fixtures/web_audio_privacy/**"
       - "tests/test_mv3_compatibility_contract.py"
+      - "tests/test_web_audio_privacy_contract.py"
+      - "docs/adr/0114-default-deny-web-audio-fingerprinting.md"
       - "docs/doctoring/mv3-compatibility.md"
+      - "docs/doctoring/web-audio-privacy.md"
 
 permissions:
   contents: read
@@ -74,14 +81,16 @@ jobs:
           "$CHROME_BIN" --version
           "$CHROMEDRIVER_BIN" --version
           python3 scripts/ci/run_mv3_compatibility.py | tee mv3-compatibility.json
+          python3 scripts/ci/run_web_audio_privacy.py | tee web-audio-privacy.json
 
       - name: Upload bounded compatibility evidence
         if: always()
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: mv3-compatibility-${{ github.event.pull_request.head.sha || github.sha }}
           path: |
             mv3-download-sha256.txt
             mv3-compatibility.json
+            web-audio-privacy.json
           if-no-files-found: warn
           retention-days: 7
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bd5bb74df..8a5778e72 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,9 +8,10 @@ All notable changes to OriginWeave are documented in this file. The format follo
 - Refreshed the product-gap queue to 126 open pull requests (54 ready, 72 draft) after #190, #188, #185, #192, #182, #184, #115, #181, #116, #117, #118, #183, #114, #127, #112, #109, #186, #110, #108, #111, #174, and #113 were merged into their immediate stacked prerequisites. PRs #147, #146, #145, #144, #143, #142, #141, #139, #136, #132, #129, and #128 moved to ready after exact-head checks and thread review; these are queue-consolidation results, not protected-main shipment.
 
 ### Added
+- Added a default-deny Web Audio fingerprinting boundary for isolated Agent and Crawler profiles: exact-origin grants capped at 128 unique canonical origins, a deterministic Rust-rendered MAIN-world `document_start` guard, and a pinned-Chromium top-document/child-frame proof that blocks online, offline, prefixed, and AudioWorklet construction entry points (see ADR 0114).
 - Added cross-surface platform coherence to the fingerprint kernel: `PresentationPlatform::hints_platform` is the single source of truth mapping each presentation platform to its canonical UA Client Hints platform, and `require_hints_coherence` fails closed on any contradiction so the presentation-platform, UA-token, and UA-CH-platform triad cannot leak a mismatched identity (see ADR 0113).
 - Added bounded User-Agent Client Hints surfaces to the fingerprint kernel: ASCII brand/version validation with a 32-character name bound, enumerated architecture/bitness/platform tokens, a non-empty brand-list requirement, and the spec rule that a non-mobile user agent reports an empty model. Control-plane contract only, grounded in the User-Agent Client Hints draft (WICG, 2026); see ADR 0112.
-- Added bounded stealth-normalization surfaces to the fingerprint kernel: enumerated canvas-noise classes, canonicalized WebGL renderer tokens with a 256-byte pre-normalization input ceiling, standard-rate Web Audio normalization, bounded WebRTC interface policy, and a fail-closed Canvas/WebGL/WebAudio/WebRtc surface-admission contract. This is a privacy-preserving control-plane contract with no real-browser or anti-evasion claim (see ADR 0111).
+- Added bounded stealth-normalization surfaces to the fingerprint kernel: enumerated canvas-noise classes, canonicalized WebGL renderer tokens, standard-rate Web Audio normalization, bounded WebRTC interface policy, and a fail-closed Canvas/WebGL/WebAudio/WebRtc surface-admission contract. This is a privacy-preserving control-plane contract with no real-browser or anti-evasion claim (see ADR 0111).
 - Corrected the 2026-08-26 product-gap snapshot with current #229 presentation-identity evidence, stacked-only #205 integration evidence, current base/head pairs, the 126-PR queue count, explicit root-versus-child merge ordering, and the active GitHub counted-approval gate.
 - Refreshed the product and technical gap baseline onto the 2026-08-26 live inventory: 126 open pull requests (54 ready, 72 draft), protected-main promotion of #168/#194/#196/#216/#151, a verified maintenance-loop record (supersession closure of #153, conflict reconciliations on #37/#149/#152/#173/#175, issue #212 option-(b) authorization on #43, Strix vuln-0001 homoglyph remediation on #124), provider-rerun outcome evidence, an organization review-pipeline congestion record, and refreshed merge-order queue guidance. Documentation evidence contracts were aligned to the same snapshot so the baseline, its dated markers, and the pinned exact-head rows cannot silently diverge.
 
@@ -102,6 +103,7 @@ All notable changes to OriginWeave are documented in this file. The format follo
 - Corrected the baseline evidence collector to flatten every paginated input, apply current reviewer and last-push approval semantics, and discard verdicts when either the PR head or base moves.
 
 ### Security
+- Web Audio constructors now fail with a fixed `NotAllowedError` in the managed default profile unless a trusted policy grants the exact canonical origin; the guard has no storage, network, messaging, model, or secret authority and does not affect ordinary media-element playback.
 
 - Explicit proxy server identifiers require ASCII decimal port tokens before numeric range parsing, preventing Rust-specific leading-plus spellings from widening proxy authority.
 - Raw page content cannot become a trusted instruction.
diff --git a/Cargo.lock b/Cargo.lock
index ca7a3ef12..f7c65dab3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -292,6 +292,7 @@ dependencies = [
 name = "originweave-fingerprint"
 version = "0.1.0"
 dependencies = [
+ "originweave-core",
  "sha2",
 ]
 
diff --git a/crates/originweave-fingerprint/Cargo.toml b/crates/originweave-fingerprint/Cargo.toml
index 595282d48..608ac4977 100644
--- a/crates/originweave-fingerprint/Cargo.toml
+++ b/crates/originweave-fingerprint/Cargo.toml
@@ -11,6 +11,7 @@ homepage.workspace = true
 publish = false
 
 [dependencies]
+originweave-core = { path = "../originweave-core" }
 sha2 = "=0.10.9"
 
 [lints]
diff --git a/crates/originweave-fingerprint/src/lib.rs b/crates/originweave-fingerprint/src/lib.rs
index 7c73b0f5a..d793df095 100644
--- a/crates/originweave-fingerprint/src/lib.rs
+++ b/crates/originweave-fingerprint/src/lib.rs
@@ -24,6 +24,7 @@
 mod coherence;
 mod stealth;
 mod ua_hints;
+mod web_audio_guard;
 
 pub use coherence::{CoherenceError, require_hints_coherence};
 pub use stealth::{
@@ -33,6 +34,7 @@ pub use stealth::{
 pub use ua_hints::{
     ClientHintsError, HintsArchitecture, HintsBitness, HintsPlatform, UaBrand, UaClientHints,
 };
+pub use web_audio_guard::{WebAudioDecision, WebAudioFingerprintPolicy, WebAudioPolicyError};
 
 use sha2::{Digest, Sha256};
 use std::error::Error;
diff --git a/crates/originweave-fingerprint/src/web_audio_guard.rs b/crates/originweave-fingerprint/src/web_audio_guard.rs
new file mode 100644
index 000000000..98d29ad52
--- /dev/null
+++ b/crates/originweave-fingerprint/src/web_audio_guard.rs
@@ -0,0 +1,119 @@
+//! Default-deny Web Audio fingerprinting policy and deterministic guard asset.
+//!
+//! Web Audio exposes implementation-specific timing and digital-signal-
+//! processing behavior that a page can combine into a device fingerprint. This
+//! module binds exact-origin exceptions to a reviewed pre-document guard rather
+//! than copying host audio characteristics or injecting random noise.
+
+use originweave_core::Origin;
+use std::collections::BTreeSet;
+use std::error::Error;
+use std::fmt;
+
+const MAX_ALLOWED_ORIGINS: usize = 128;
+const ALLOWLIST_MARKER: &str = "/* ORIGINWEAVE_ALLOWED_WEB_AUDIO_ORIGINS */";
+const GUARD_SCRIPT_TEMPLATE: &str =
+    include_str!("../../../extensions/originweave-privacy-guard/web_audio_guard.js");
+
+/// The result of evaluating one page origin against the Web Audio policy.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WebAudioDecision {
+    /// Web Audio construction must be blocked because no exact grant exists.
+    BlockFingerprinting,
+    /// A trusted profile explicitly granted the exact canonical origin.
+    AllowExplicitOrigin,
+}
+
+impl WebAudioDecision {
+    /// Return whether the privacy guard must block Web Audio constructors.
+    #[must_use]
+    pub const fn blocks_fingerprinting(self) -> bool {
+        matches!(self, Self::BlockFingerprinting)
+    }
+
+    /// Return the stable credential-free denial reason for audit evidence.
+    #[must_use]
+    pub const fn reason_code(self) -> Option<&'static str> {
+        match self {
+            Self::BlockFingerprinting => Some("web_audio_fingerprinting_no_explicit_origin_grant"),
+            Self::AllowExplicitOrigin => None,
+        }
+    }
+}
+
+/// A bounded Web Audio privacy-policy configuration failure.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WebAudioPolicyError {
+    /// The canonical allowlist exceeded its reviewed unique-origin ceiling.
+    TooManyAllowedOrigins {
+        /// Maximum number of unique canonical origins permitted by the policy.
+        maximum: usize,
+        /// Actual number of unique canonical origins supplied by the caller.
+        actual: usize,
+    },
+}
+
+impl fmt::Display for WebAudioPolicyError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::TooManyAllowedOrigins { maximum, actual } => write!(
+                formatter,
+                "web audio allowlist contains {actual} unique origins; maximum is {maximum}"
+            ),
+        }
+    }
+}
+
+impl Error for WebAudioPolicyError {}
+
+/// An immutable exact-origin policy for the reviewed Web Audio guard.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct WebAudioFingerprintPolicy {
+    allowed_origins: BTreeSet<Origin>,
+}
+
+impl WebAudioFingerprintPolicy {
+    /// Build a policy from canonical origins, deduplicating before bounding it.
+    pub fn new(allowed_origins: Vec<Origin>) -> Result<Self, WebAudioPolicyError> {
+        let allowed_origins = allowed_origins.into_iter().collect::<BTreeSet<_>>();
+        if allowed_origins.len() > MAX_ALLOWED_ORIGINS {
+            return Err(WebAudioPolicyError::TooManyAllowedOrigins {
+                maximum: MAX_ALLOWED_ORIGINS,
+                actual: allowed_origins.len(),
+            });
+        }
+        Ok(Self { allowed_origins })
+    }
+
+    /// Evaluate one exact canonical origin without subdomain or port widening.
+    #[must_use]
+    pub fn decision(&self, origin: &Origin) -> WebAudioDecision {
+        if self.allowed_origins.contains(origin) {
+            WebAudioDecision::AllowExplicitOrigin
+        } else {
+            WebAudioDecision::BlockFingerprinting
+        }
+    }
+
+    /// Return the number of unique exact-origin grants in this policy.
+    #[must_use]
+    pub fn allowed_origin_count(&self) -> usize {
+        self.allowed_origins.len()
+    }
+
+    /// Render the reviewed MAIN-world `document_start` guard deterministically.
+    ///
+    /// [`Origin`] admits only canonical scheme/authority strings, so each value
+    /// is safe to place inside the generated JSON string literal without path,
+    /// quote, backslash, control-character, or user-information ambiguity.
+    #[must_use]
+    pub fn render_guard_script(&self) -> String {
+        let rendered_origins = self
+            .allowed_origins
+            .iter()
+            .map(|origin| format!("    \"{}\"", origin.as_str()))
+            .collect::<Vec<_>>()
+            .join(",\n");
+        GUARD_SCRIPT_TEMPLATE.replacen(ALLOWLIST_MARKER, &rendered_origins, 1)
+    }
+}
diff --git a/crates/originweave-fingerprint/tests/web_audio_fingerprint_guard.rs b/crates/originweave-fingerprint/tests/web_audio_fingerprint_guard.rs
new file mode 100644
index 000000000..c852867da
--- /dev/null
+++ b/crates/originweave-fingerprint/tests/web_audio_fingerprint_guard.rs
@@ -0,0 +1,128 @@
+//! Web Audio fingerprint-blocking contracts for OriginWeave privacy profiles.
+//!
+//! These tests are intentionally added before production code. They define a
+//! default-deny policy, exact-origin exceptions, bounded configuration, and a
+//! deterministic pre-document guard script that blocks Web Audio constructors
+//! before page JavaScript can create a silent fingerprint graph.
+#![allow(clippy::expect_used)]
+
+use originweave_core::Origin;
+use originweave_fingerprint::{WebAudioDecision, WebAudioFingerprintPolicy, WebAudioPolicyError};
+
+fn origin(value: &str) -> Origin {
+    Origin::parse(value).expect("test origin must satisfy the shared origin contract")
+}
+
+#[test]
+fn default_policy_blocks_web_audio_fingerprinting_with_audit_reason() {
+    let policy = WebAudioFingerprintPolicy::default();
+    let decision = policy.decision(&origin("https://shop.example"));
+
+    assert_eq!(decision, WebAudioDecision::BlockFingerprinting);
+    assert!(decision.blocks_fingerprinting());
+    assert_eq!(
+        decision.reason_code(),
+        Some("web_audio_fingerprinting_no_explicit_origin_grant")
+    );
+    assert_eq!(policy.allowed_origin_count(), 0);
+}
+
+#[test]
+fn explicit_grant_is_exact_origin_scoped() {
+    let policy = WebAudioFingerprintPolicy::new(vec![origin("https://shop.example")])
+        .expect("one valid grant must fit the bounded policy");
+
+    let allowed = policy.decision(&origin("https://shop.example:443"));
+    assert_eq!(allowed, WebAudioDecision::AllowExplicitOrigin);
+    assert!(!allowed.blocks_fingerprinting());
+    assert_eq!(allowed.reason_code(), None);
+
+    assert_eq!(
+        policy.decision(&origin("https://cdn.shop.example")),
+        WebAudioDecision::BlockFingerprinting
+    );
+    assert_eq!(
+        policy.decision(&origin("https://shop.example:8443")),
+        WebAudioDecision::BlockFingerprinting
+    );
+}
+
+#[test]
+fn duplicate_grants_collapse_to_one_canonical_origin() {
+    let policy = WebAudioFingerprintPolicy::new(vec![
+        origin("https://shop.example"),
+        origin("https://shop.example:443"),
+    ])
+    .expect("canonical duplicate grants must remain bounded");
+
+    assert_eq!(policy.allowed_origin_count(), 1);
+}
+
+#[test]
+fn allowlist_rejects_more_than_the_bounded_unique_origin_count() {
+    let grants = (0..129)
+        .map(|index| origin(&format!("https://site-{index}.example")))
+        .collect::<Vec<_>>();
+
+    assert_eq!(
+        WebAudioFingerprintPolicy::new(grants),
+        Err(WebAudioPolicyError::TooManyAllowedOrigins {
+            maximum: 128,
+            actual: 129,
+        })
+    );
+}
+
+#[test]
+fn rendered_guard_is_deterministic_and_contains_only_canonical_grants() {
+    let policy = WebAudioFingerprintPolicy::new(vec![
+        origin("https://z.example"),
+        origin("https://a.example:443"),
+    ])
+    .expect("two exact grants must fit the bounded policy");
+
+    let first = policy.render_guard_script();
+    let second = policy.render_guard_script();
+    assert_eq!(first, second);
+    assert!(!first.contains("ORIGINWEAVE_ALLOWED_WEB_AUDIO_ORIGINS"));
+    assert!(first.contains("\"https://a.example\""));
+    assert!(first.contains("\"https://z.example\""));
+    assert!(
+        first
+            .find("https://a.example")
+            .expect("first origin must be rendered")
+            < first
+                .find("https://z.example")
+                .expect("second origin must be rendered")
+    );
+}
+
+#[test]
+fn rendered_guard_blocks_every_web_audio_construction_entrypoint() {
+    let script = WebAudioFingerprintPolicy::default().render_guard_script();
+
+    for constructor in [
+        "AudioContext",
+        "webkitAudioContext",
+        "OfflineAudioContext",
+        "webkitOfflineAudioContext",
+        "AudioWorkletNode",
+    ] {
+        assert!(script.contains(constructor), "missing {constructor}");
+    }
+    assert!(script.contains("NotAllowedError"));
+    assert!(script.contains("document_start"));
+}
+
+#[test]
+fn policy_error_formats_a_stable_operator_message() {
+    let error = WebAudioPolicyError::TooManyAllowedOrigins {
+        maximum: 128,
+        actual: 129,
+    };
+
+    assert_eq!(
+        error.to_string(),
+        "web audio allowlist contains 129 unique origins; maximum is 128"
+    );
+}
diff --git a/docs/README.md b/docs/README.md
index f9529978a..55ff1fbfa 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -88,6 +88,7 @@ Proposed ADRs are reviewable architecture memory, not shipped behavior and not a
 - [ADR 0111: Bounded stealth-normalization surfaces](adr/0111-bounded-stealth-normalization-surfaces.md)
 - [ADR 0112: Bounded User-Agent Client Hints](adr/0112-bounded-user-agent-client-hints.md)
 - [ADR 0113: Cross-surface platform coherence](adr/0113-cross-surface-platform-coherence.md)
+- [ADR 0114: Default-deny Web Audio fingerprinting](adr/0114-default-deny-web-audio-fingerprinting.md)
 
 The second group exists only on this documentation branch until the branch integrates. After integration, the heading remains useful historical provenance; it does not promote either ADR from Proposed to Accepted and it does not claim that the described runtime capability is implemented.
 
diff --git a/docs/adr/0114-default-deny-web-audio-fingerprinting.md b/docs/adr/0114-default-deny-web-audio-fingerprinting.md
new file mode 100644
index 000000000..efc792e3a
--- /dev/null
+++ b/docs/adr/0114-default-deny-web-audio-fingerprinting.md
@@ -0,0 +1,147 @@
+# ADR 0114: Default-deny Web Audio fingerprinting
+
+- Status: Proposed
+- Date: 2026-08-27
+- Supersedes: None
+- Superseded by: None
+
+## Context
+
+A page does not need audible playback to use the Web Audio API as a fingerprinting surface. It can create an oscillator or other deterministic graph, inspect analyser or processor output, render an `OfflineAudioContext`, and combine implementation-specific numerical differences with other browser signals. Setting the final gain to zero only prevents sound from reaching the user; it does not prevent the browser from performing the measurements.
+
+ADR 0111 standardizes a reported Web Audio sample rate as part of a bounded presentation identity. That reduces one ambient signal but does not prevent a page from constructing analyser, processor, compressor, oscillator, offline-rendering, or worklet graphs. A privacy profile therefore requires an explicit authority decision before any page script captures the native Web Audio constructors.
+
+## Decision drivers
+
+- Prevent silent Web Audio computation from becoming an ambient re-identification channel.
+- Apply the decision before page JavaScript, including in child frames.
+- Preserve ordinary `<audio>` and `<video>` playback.
+- Support a bounded exact-origin exception for trusted applications that legitimately require Web Audio.
+- Avoid random output perturbation that could become a new stable distinguisher.
+- Produce deterministic, credential-free policy and browser evidence.
+- Keep privacy enforcement separate from CAPTCHA, consent, bot-management, or access-control evasion.
+
+## Assumptions and authority boundaries
+
+- OriginWeave Agent and Crawler profiles are isolated managed profiles; the user's unrestricted Human profile is not silently rewritten by this policy.
+- `originweave_core::Origin` is the sole parser and canonicalizer for an allowed origin.
+- Exact origin means scheme, canonical host, and effective port. A grant does not include sibling subdomains or non-default ports.
+- The checked-in Manifest V3 extension is a reviewed enforcement asset. The Rust policy renders a deterministic copy by replacing one fixed allowlist marker.
+- Page content cannot add an origin grant or weaken the guard.
+- This ADR governs Web Audio construction authority, not microphone permission, media-element playback, or operating-system audio routing.
+
+## Options considered
+
+### Normalize only the sample rate
+
+Rejected as insufficient. It leaves timing, analyser, processor, compressor, oscillator, offline-rendering, and worklet behavior available to page scripts.
+
+### Inject random noise into Web Audio output
+
+Rejected. Independent or session-specific noise can create another distinguisher, makes scientific reproducibility difficult, and still permits resource consumption by hidden graphs.
+
+### Block all media playback
+
+Rejected as overbroad. Standard media elements are needed for ordinary audio and video playback and do not require exposing the Web Audio graph API.
+
+### Default-deny Web Audio constructors with exact-origin grants
+
+Selected. It removes the high-entropy computation surface from managed privacy profiles, preserves media elements, and makes compatibility exceptions explicit and auditable.
+
+## Decision
+
+OriginWeave Agent and Crawler privacy profiles must apply a Manifest V3 content script with all of the following properties:
+
+```text
+run_at: document_start
+world: MAIN
+all_frames: true
+match_about_blank: true
+match_origin_as_fallback: true
+```
+
+Unless the current canonical origin appears in the trusted profile's bounded allowlist, the script replaces these global construction entry points before page scripts execute:
+
+```text
+AudioContext
+webkitAudioContext
+OfflineAudioContext
+webkitOfflineAudioContext
+AudioWorkletNode
+```
+
+Each blocked constructor throws a `DOMException` named `NotAllowedError` with a fixed non-secret message. The replacement properties are non-writable and non-configurable for the lifetime of that document.
+
+The control-plane policy:
+
+- defaults to an empty allowlist;
+- deduplicates canonical origins;
+- permits no more than 128 unique exact origins;
+- evaluates membership without wildcard or subdomain expansion;
+- sorts origins deterministically through `BTreeSet`;
+- renders the reviewed guard by replacing exactly one source marker; and
+- emits the stable denial reason `web_audio_fingerprinting_no_explicit_origin_grant`.
+
+The checked-in extension uses the empty allowlist and is therefore default-deny. A future trusted profile builder may materialize a policy-specific extension artifact from the Rust-rendered script, bind its digest to session evidence, and load only that artifact.
+
+## Consequences
+
+### Benefits
+
+- Silent oscillator/analyser and offline-rendering fingerprints cannot start in the managed default profile.
+- Top-level documents and child frames share the same default-deny boundary.
+- Legitimate Web Audio applications have a narrow, reviewable compatibility path.
+- Ordinary media elements remain available.
+- The same source asset is used by the Rust renderer and the real-browser test.
+
+### Costs
+
+- Web games, conferencing tools, music applications, visualizers, and accessibility tools that require Web Audio will fail until their exact origin is granted.
+- A content-script guard is a distribution-layer enforcement mechanism; a future Chromium policy integration may provide a stronger engine-native boundary.
+- The broad match patterns are intentional for an isolated privacy profile and must not be copied into an unrelated extension distribution.
+
+## Failure and degraded behavior
+
+- Missing or malformed policy material fails to the checked-in empty allowlist.
+- Too many unique grants fail closed before a browser artifact is created.
+- A non-matching scheme, subdomain, or port remains blocked.
+- If the real-browser lane cannot prove first-script and child-frame enforcement on the pinned Chromium build, the feature remains draft and cannot be claimed as released.
+- A site broken by the guard requires an explicit exact-origin grant; disabling privacy globally is not the fallback.
+
+## Security / privacy / governance impact
+
+- The guard performs no network request, storage access, model call, secret read, or host fingerprint read.
+- Page text, scripts, and WebMCP output are untrusted observations and cannot grant Web Audio.
+- The policy does not evade access control or impersonate another device.
+- Audit evidence records the origin, policy revision/digest, decision, and reason code, never page audio samples or user secrets.
+- Enterprise administrators must use maker-checker governance for organization-wide grants once that administration plane ships.
+
+## Tests and acceptance evidence
+
+- Rust integration tests prove default denial, exact-origin behavior, canonical duplicate collapse, the 128-origin bound, deterministic ordering, complete constructor coverage, and stable errors.
+- Python repository contracts prove the Manifest V3 timing/world/frame properties, source binding, no ambient extension permissions, pinned runner, and workflow artifact.
+- A pinned Chrome for Testing 150.0.7871.129 lane runs three isolated trials and requires the first top-document script and first child-frame script to observe `NotAllowedError` from every available construction entry point.
+- Existing repository gates continue to require exact production function, line, region, and branch coverage plus public documentation.
+
+## Migration and rollback
+
+The change is additive and stacked on ADRs 0110–0113. Rollback removes the privacy extension, policy module, and exact-origin grants together. Retaining grants while removing enforcement is prohibited because it would leave misleading policy evidence. A rollback must restore the prior claim that Web Audio is only normalized, not blocked, and must update the product-gap baseline.
+
+## Open follow-ups
+
+- Bind a rendered guard digest to the isolated browser-profile launch record.
+- Add user and enterprise administration surfaces for temporary and durable exact-origin grants.
+- Add expiry, reviewer, purpose, and application identity to durable organization grants.
+- Prove behavior for cross-origin iframes and opaque-origin frames in the complete browser distribution.
+- Evaluate engine-native Chromium permission/policy integration as a future replacement for the distribution extension.
+- Add resource-budget evidence showing that blocked graphs do not consume hidden audio-processing capacity.
+
+## Supersession / reversal conditions
+
+Revisit this decision when Chromium provides a stable engine-native Web Audio permission or anti-fingerprinting control that can be policy-managed before page script with equal or stronger all-frame guarantees. Any replacement must preserve default denial, exact-origin exceptions, deterministic evidence, ordinary media playback, and compatibility rollback.
+
+## References
+
+Google Chrome Developers. (2023). *Content scripts*. https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts
+
+World Wide Web Consortium. (2024). *Web Audio API 1.1*. https://www.w3.org/TR/webaudio-1.1/
diff --git a/docs/adr/README.md b/docs/adr/README.md
index c4f189ee3..c19b3583e 100644
--- a/docs/adr/README.md
+++ b/docs/adr/README.md
@@ -58,8 +58,9 @@ Proposed ADR files are reviewable target architecture without becoming Accepted
 | [0111](0111-bounded-stealth-normalization-surfaces.md) | Bounded stealth-normalization surfaces | Proposed | canvas/WebGL/WebAudio/WebRTC bounded enumerated classes and surface admission |
 | [0112](0112-bounded-user-agent-client-hints.md) | Bounded User-Agent Client Hints | Proposed | UA-CH bounded enumerated tokens, brand grammar, and cross-field coherence |
 | [0113](0113-cross-surface-platform-coherence.md) | Cross-surface platform coherence | Proposed | presentation-platform, UA-token, and UA-CH-platform triad agreement |
+| [0114](0114-default-deny-web-audio-fingerprinting.md) | Default-deny Web Audio fingerprinting | Proposed | exact-origin Web Audio construction authority and pre-document privacy guard |
 
-ADR 0013, ADR 0014, ADR 0110, ADR 0111, and ADR 0112 exist only on this documentation branch until it integrates. After integration, this subsection remains historical provenance rather than an active-PR claim; all five decisions remain Proposed until a later policy-compliant change explicitly changes their lifecycle.
+ADR 0013, ADR 0014, ADR 0110, and ADR 0111 exist only on this documentation branch until it integrates. After integration, this subsection remains historical provenance rather than an active-PR claim; all four decisions remain Proposed until a later policy-compliant change explicitly changes their lifecycle.
 
 ### Proposed decisions introduced by active feature work
 
diff --git a/docs/doctoring/web-audio-privacy.md b/docs/doctoring/web-audio-privacy.md
new file mode 100644
index 000000000..74a69c163
--- /dev/null
+++ b/docs/doctoring/web-audio-privacy.md
@@ -0,0 +1,70 @@
+# Web Audio fingerprinting privacy basis
+
+## Claim boundary
+
+This record supports one bounded claim:
+
+> In an isolated OriginWeave privacy profile, the reviewed Manifest V3 guard is injected in the page's MAIN world at `document_start` and blocks Web Audio construction by default unless the exact canonical origin is present in the rendered trusted-policy allowlist.
+
+It does **not** claim that:
+
+- Web Audio is the only browser fingerprinting surface;
+- a content script is stronger than a future engine-native Chromium policy;
+- the guard defeats bot management, CAPTCHA, consent, or access control;
+- all Chrome extensions or all websites remain compatible;
+- ordinary media-element playback is blocked; or
+- the feature is shipped before its stack reaches protected `main` and a signed release.
+
+## Primary-source findings
+
+The Web Audio API privacy section identifies multiple observable sources of fingerprint entropy. It notes exposure of supported sample rates and output channel counts; timing through `AnalyserNode` or `ScriptProcessorNode`; and implementation differences in `DynamicsCompressorNode`, `OscillatorNode`, and other signal-processing behavior. This supports blocking construction rather than only muting the destination or standardizing one sample-rate field.
+
+Chrome's Manifest V3 content-script contract provides the enforcement placement used by the fixture:
+
+- `run_at: document_start` injects before other page scripts;
+- `world: MAIN` shares the page's JavaScript environment so the page-visible constructors can be replaced;
+- `all_frames`, `match_about_blank`, and `match_origin_as_fallback` extend the rule to relevant descendant frames; and
+- static `matches` patterns declare the isolated profile's injection scope.
+
+The MAIN world is intentionally powerful and therefore the guard is constant, reviewed code. It consumes no page-provided instruction, network response, extension message, storage value, or model output.
+
+## Claim-to-implementation traceability
+
+| Claim | Implementation | Executable evidence |
+|---|---|---|
+| Default denial | `WebAudioFingerprintPolicy::default` has no grants | Rust default-policy test |
+| Exact-origin exception | `BTreeSet<originweave_core::Origin>` membership | scheme/subdomain/port test |
+| Bounded policy | 128 unique canonical origins | boundary test with 129 origins |
+| Deterministic artifact | ordered origins replace one reviewed marker | repeated rendering/order test |
+| First-script enforcement | MV3 `document_start` + MAIN world | pinned-Chromium top-document probe |
+| Child-frame enforcement | `all_frames` and origin-fallback settings | pinned-Chromium iframe probe |
+| Complete construction boundary | online/offline/prefixed/worklet constructor list | Rust, Python, and browser probes |
+| Credential-free failure | fixed `NotAllowedError` and stable reason code | Rust error/reason tests |
+| No ambient authority | no extension permissions, storage, network, or runtime messaging | manifest/source repository contract |
+
+## Validation environment
+
+The real-browser lane pins:
+
+```text
+Chrome for Testing: 150.0.7871.129
+Chromium revision: r1639810
+Trials: 3 isolated browser profiles
+Transport: loopback-only ChromeDriver HTTP
+Fixture: loopback static HTML
+```
+
+A missing required probe, an unexpected exception, a leaked constructor, a browser-version mismatch, or fewer than three successful trials fails the workflow. Unsupported or skipped probes are not counted as passing.
+
+## Known limitations
+
+- The branch provides a policy kernel, reviewed extension asset, and pinned-browser fixture. Full OriginWeave browser-profile materialization and signed distribution remain separate integration work.
+- The current exception model is exact origin without expiry or maker-checker metadata. Durable enterprise grants require the administration plane.
+- The test covers a same-origin child frame; complete cross-origin and opaque-origin coverage remains a release-program requirement.
+- Other surfaces such as Canvas, WebGL, WebRTC, fonts, storage, and behavioral signals require their own controls.
+
+## References — APA 7th
+
+Google Chrome Developers. (2023). *Content scripts*. https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts
+
+World Wide Web Consortium. (2024). *Web Audio API 1.1*. https://www.w3.org/TR/webaudio-1.1/
diff --git a/docs/product-technical-gap-baseline.md b/docs/product-technical-gap-baseline.md
index 34dd561cf..3b549d83d 100644
--- a/docs/product-technical-gap-baseline.md
+++ b/docs/product-technical-gap-baseline.md
@@ -45,6 +45,7 @@ Representative active workstreams at this snapshot were:
 | Stealth surface normalization | stacked `feat/stealth-normalize-surfaces` on #229 | Proposed ADR 0111 adds bounded canvas-noise classes, canonicalized WebGL renderer tokens, standard-rate Web Audio normalization, bounded WebRTC interface policy, and fail-closed Canvas/WebGL/WebAudio/WebRtc surface admission; control-plane contract only, no real-browser or anti-evasion claim |
 | UA Client Hints surface | stacked `feat/ua-client-hints-surface` on #233 | Proposed ADR 0112 bounds the `navigator.userAgentData` / `Sec-CH-UA*` surface: ASCII brand grammar with 32-char name bound, enumerated architecture/bitness/platform tokens, non-empty brand list, and the draft rule that non-mobile user agents report an empty model; control-plane contract only, no browser claim |
 | Cross-surface platform coherence | stacked `feat/stealth-profile-coherence` on #234 | Proposed ADR 0113 binds the presentation-platform, UA-token, and UA-CH-platform triad through `PresentationPlatform::hints_platform` and `require_hints_coherence`; control-plane contract only, no browser claim |
+| Web Audio privacy guard | draft #236 stacked on #235 | Proposed ADR 0114 adds a default-deny exact-origin Web Audio policy, reviewed MV3 MAIN-world `document_start` guard, and pinned-Chromium top-document/child-frame evidence; it remains active-PR evidence until prerequisites, exact-head checks, independent review, protected-main integration, profile-builder binding, and signed release are complete |
 | Enterprise approval authority | #220 | Ready/non-draft bounded maker-checker approval lifecycle on the exact `ApprovalScope`; all current-head checks green at snapshot, awaiting current-head review evidence |
 | Release artifact identity | #218 and #219 | Ready/non-draft fail-closed benchmark release decision and canonical release manifest binding; Strix provider-failure reruns completed green on both heads |
 | Schema-bound extraction and BAP lifecycle | #209 and #208 | Ready/non-draft schema-bound extraction contract and resumable task-lifecycle kernel; #209 Strix rerun green, #208 rerun re-dispatched after a further provider failure |
diff --git a/extensions/originweave-privacy-guard/manifest.json b/extensions/originweave-privacy-guard/manifest.json
new file mode 100644
index 000000000..ce1f7d0f0
--- /dev/null
+++ b/extensions/originweave-privacy-guard/manifest.json
@@ -0,0 +1,17 @@
+{
+  "manifest_version": 3,
+  "name": "OriginWeave Web Audio Privacy Guard",
+  "version": "0.1.0",
+  "description": "Blocks Web Audio fingerprinting in isolated OriginWeave Agent and Crawler profiles.",
+  "content_scripts": [
+    {
+      "matches": ["http://*/*", "https://*/*"],
+      "js": ["web_audio_guard.js"],
+      "run_at": "document_start",
+      "world": "MAIN",
+      "all_frames": true,
+      "match_about_blank": true,
+      "match_origin_as_fallback": true
+    }
+  ]
+}
diff --git a/extensions/originweave-privacy-guard/web_audio_guard.js b/extensions/originweave-privacy-guard/web_audio_guard.js
new file mode 100644
index 000000000..13034bfdd
--- /dev/null
+++ b/extensions/originweave-privacy-guard/web_audio_guard.js
@@ -0,0 +1,45 @@
+"use strict";
+
+// Injected by Manifest V3 at document_start in the MAIN world so page scripts
+// cannot capture the native constructors before the privacy policy applies.
+(() => {
+  const allowedOrigins = [
+    /* ORIGINWEAVE_ALLOWED_WEB_AUDIO_ORIGINS */
+  ];
+  const currentOrigin = globalThis.location.origin;
+  for (let index = 0; index < allowedOrigins.length; index += 1) {
+    if (allowedOrigins[index] === currentOrigin) {
+      return;
+    }
+  }
+
+  const blockedConstructorNames = Object.freeze([
+    "AudioContext",
+    "webkitAudioContext",
+    "OfflineAudioContext",
+    "webkitOfflineAudioContext",
+    "AudioWorkletNode"
+  ]);
+  const blockedMessage = "Web Audio disabled by OriginWeave privacy policy";
+
+  const createBlockedConstructor = () => {
+    const blockedConstructor = function originweaveBlockedWebAudioConstructor() {
+      throw new DOMException(blockedMessage, "NotAllowedError");
+    };
+    Object.freeze(blockedConstructor.prototype);
+    return Object.freeze(blockedConstructor);
+  };
+
+  for (const constructorName of blockedConstructorNames) {
+    if (!(constructorName in globalThis)) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, constructorName);
+    Object.defineProperty(globalThis, constructorName, {
+      value: createBlockedConstructor(),
+      enumerable: descriptor?.enumerable ?? false,
+      configurable: false,
+      writable: false
+    });
+  }
+})();
diff --git a/scripts/ci/run_web_audio_privacy.py b/scripts/ci/run_web_audio_privacy.py
new file mode 100755
index 000000000..198ea490f
--- /dev/null
+++ b/scripts/ci/run_web_audio_privacy.py
@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+"""Prove the Web Audio privacy guard in a pinned real Chromium build.
+
+The runner serves a controlled loopback fixture, loads only the reviewed
+OriginWeave privacy extension, and verifies that the first page scripts in both
+the top document and a child frame receive `NotAllowedError` from every exposed
+Web Audio construction entry point. It emits bounded credential-free evidence.
+"""
+
+from __future__ import annotations
+
+import http.client
+import http.server
+import json
+import os
+import pathlib
+import socket
+import string
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from typing import Any
+
+ROOT = pathlib.Path(__file__).resolve().parents[2]
+EXTENSION = ROOT / "extensions" / "originweave-privacy-guard"
+FIXTURE = ROOT / "tests" / "fixtures" / "web_audio_privacy"
+PINNED_CHROME_VERSION = "150.0.7871.129"
+PINNED_CHROME_REVISION = "r1639810"
+REPEATABILITY_TRIALS = 3
+REQUEST_TIMEOUT_SECONDS = 5.0
+STARTUP_TIMEOUT_SECONDS = 20.0
+FIXTURE_TIMEOUT_SECONDS = 20.0
+MAX_WEBDRIVER_RESPONSE_BYTES = 1_048_576
+PATH_TOKEN_CHARACTERS = frozenset(string.ascii_letters + string.digits + "-_.")
+REQUIRED_BLOCKED_SURFACES = frozenset(
+    {
+        "audioContext",
+        "offlineAudioContext",
+        "audioWorkletNode",
+        "childAudioContext",
+        "childOfflineAudioContext",
+    }
+)
+OPTIONAL_PREFIXED_SURFACES = frozenset(
+    {"webkitAudioContext", "webkitOfflineAudioContext"}
+)
+EXPECTED_SURFACES = REQUIRED_BLOCKED_SURFACES | OPTIONAL_PREFIXED_SURFACES
+
+
+class QuietFixtureHandler(http.server.SimpleHTTPRequestHandler):
+    """Serve only the controlled local fixture without request logging."""
+
+    def log_message(self, _format: str, *args: object) -> None:
+        """Suppress fixture request logs that contain no test evidence."""
+
+
+class PrivacyProbeError(RuntimeError):
+    """A controlled fixture failed to reach its required privacy state."""
+
+    def __init__(self, surfaces: dict[str, str]) -> None:
+        """Preserve only bounded fixture surface states for diagnosis."""
+
+        self.surfaces = dict(surfaces)
+        super().__init__("Web Audio privacy fixture did not converge")
+
+
+class BrowserSessionCleanupError(RuntimeError):
+    """A bounded WebDriver session cleanup failed."""
+
+    def __init__(self, cleanup_error: BaseException) -> None:
+        """Retain only the cleanup error class while chaining the causal error."""
+
+        self.cleanup_error_type = type(cleanup_error).__name__
+        super().__init__("WebDriver session cleanup failed; see the chained causal browser failure")
+
+
+def _privacy_evidence_satisfies(surfaces: dict[str, str]) -> bool:
+    """Accept blocked core surfaces and absent-or-blocked vendor aliases."""
+
+    if set(surfaces) != EXPECTED_SURFACES:
+        return False
+    if any(surfaces[name] != "blocked" for name in REQUIRED_BLOCKED_SURFACES):
+        return False
+    return all(
+        surfaces[name] in {"blocked", "unavailable"}
+        for name in OPTIONAL_PREFIXED_SURFACES
+    )
+
+
+def _free_loopback_port() -> int:
+    """Reserve and release one loopback port for a short-lived local service."""
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def _path_token(value: str, label: str) -> str:
+    """Validate a ChromeDriver-issued token before using it in a request path."""
+
+    if (
+        not value
+        or len(value) > 256
+        or value in {".", ".."}
+        or any(character not in PATH_TOKEN_CHARACTERS for character in value)
+    ):
+        raise RuntimeError(f"invalid WebDriver {label}")
+    return value
+
+
+def _webdriver_path(session_id: str, suffix: str) -> str:
+    """Build one bounded ChromeDriver path from a validated session token."""
+
+    safe_session = _path_token(session_id, "session identifier")
+    if suffix and not suffix.startswith("/"):
+        raise RuntimeError("invalid WebDriver path suffix")
+    if "://" in suffix or any(character in suffix for character in "\r\n"):
+        raise RuntimeError("invalid WebDriver path suffix")
+    return f"/session/{safe_session}{suffix}"
+
+
+def _json_request(
+    driver_port: int,
+    method: str,
+    path: str,
+    payload: dict[str, Any] | None = None,
+    *,
+    timeout: float = REQUEST_TIMEOUT_SECONDS,
+) -> dict[str, Any]:
+    """Issue one bounded JSON request to the fixed loopback ChromeDriver."""
+
+    if not 1 <= driver_port <= 65_535:
+        raise ValueError("invalid ChromeDriver port")
+    if method not in {"GET", "POST", "DELETE"}:
+        raise ValueError("unsupported ChromeDriver method")
+    if not path.startswith("/") or "://" in path or any(
+        character in path for character in "\r\n"
+    ):
+        raise ValueError("invalid WebDriver path")
+
+    body = None if payload is None else json.dumps(payload).encode("utf-8")
+    connection = http.client.HTTPConnection("127.0.0.1", driver_port, timeout=timeout)
+    try:
+        connection.request(
+            method,
+            path,
+            body=body,
+            headers={"Content-Type": "application/json"},
+        )
+        response = connection.getresponse()
+        raw = response.read(MAX_WEBDRIVER_RESPONSE_BYTES + 1)
+        if len(raw) > MAX_WEBDRIVER_RESPONSE_BYTES:
+            raise RuntimeError("WebDriver response exceeded the bounded JSON limit")
+        if response.status >= 400:
+            raise RuntimeError(f"WebDriver HTTP {response.status}")
+    finally:
+        connection.close()
+
+    decoded = json.loads(raw.decode("utf-8"))
+    if not isinstance(decoded, dict):
+        raise RuntimeError("WebDriver returned a non-object JSON payload")
+    value = decoded.get("value")
+    if isinstance(value, dict) and value.get("error"):
+        raise RuntimeError("WebDriver returned an error response")
+    return decoded
+
+
+def _cleanup_browser_session(driver_port: int, session_id: str) -> None:
+    """Delete one validated loopback WebDriver session."""
+
+    _json_request(driver_port, "DELETE", _webdriver_path(session_id, ""), {})
+
+
+def _cleanup_browser_session_preserving_primary(
+    driver_port: int,
+    session_id: str,
+    primary_error: BaseException | None,
+) -> None:
+    """Fail closed on bounded cleanup errors without losing a primary failure."""
+
+    try:
+        _cleanup_browser_session(driver_port, session_id)
+    except (
+        OSError,
+        ValueError,
+        RuntimeError,
+        http.client.HTTPException,
+        json.JSONDecodeError,
+    ) as cleanup_error:
+        bounded_error = BrowserSessionCleanupError(cleanup_error)
+        if primary_error is None:
+            raise bounded_error from cleanup_error
+        add_note = getattr(primary_error, "add_note", None)
+        if callable(add_note):
+            add_note(
+                f"WebDriver session cleanup also failed with {bounded_error.cleanup_error_type}"
+            )
+        raise primary_error
+
+
+def _wait_for_driver(driver_port: int) -> None:
+    """Wait for the exact local ChromeDriver process to become ready."""
+
+    deadline = time.monotonic() + STARTUP_TIMEOUT_SECONDS
+    last_error: Exception | None = None
+    while time.monotonic() < deadline:
+        try:
+            status = _json_request(driver_port, "GET", "/status", timeout=1.0)
+            if status.get("value", {}).get("ready") is True:
+                return
+        except (
+            OSError,
+            ValueError,
+            RuntimeError,
+            http.client.HTTPException,
+            json.JSONDecodeError,
+        ) as exc:
+            last_error = exc
+        time.sleep(0.1)
+    raise RuntimeError(f"ChromeDriver did not become ready: {last_error}")
+
+
+def _execute(driver_port: int, session_id: str, script: str) -> Any:
+    """Execute fixture-only JavaScript in the controlled WebDriver session."""
+
+    response = _json_request(
+        driver_port,
+        "POST",
+        _webdriver_path(session_id, "/execute/sync"),
+        {"script": script, "args": []},
+    )
+    return response.get("value")
+
+
+def _wait_for_privacy_evidence(driver_port: int, session_id: str) -> dict[str, str]:
+    """Wait until top-document and child-frame privacy probes are complete."""
+
+    script = """
+const root = document.documentElement.dataset;
+const frame = document.querySelector("#privacy-frame");
+const child = frame?.contentDocument?.documentElement?.dataset;
+return {
+  audioContext: root.originweaveAudioContext || "missing",
+  webkitAudioContext: root.originweaveWebkitAudioContext || "missing",
+  offlineAudioContext: root.originweaveOfflineAudioContext || "missing",
+  webkitOfflineAudioContext: root.originweaveWebkitOfflineAudioContext || "missing",
+  audioWorkletNode: root.originweaveAudioWorkletNode || "missing",
+  childAudioContext: child?.originweaveAudioContext || "missing",
+  childOfflineAudioContext: child?.originweaveOfflineAudioContext || "missing"
+};
+"""
+    deadline = time.monotonic() + FIXTURE_TIMEOUT_SECONDS
+    latest: dict[str, str] = {}
+    while time.monotonic() < deadline:
+        value = _execute(driver_port, session_id, script)
+        if isinstance(value, dict):
+            latest = {str(key): str(item) for key, item in value.items()}
+            if _privacy_evidence_satisfies(latest):
+                return latest
+        time.sleep(0.1)
+    raise PrivacyProbeError(latest)
+
+
+def _run_trial(
+    chrome_bin: pathlib.Path,
+    chromedriver_bin: pathlib.Path,
+    fixture_url: str,
+    trial_number: int,
+) -> dict[str, Any]:
+    """Run one independent browser process and return credential-free evidence."""
+
+    driver_port = _free_loopback_port()
+    session_id: str | None = None
+    started = time.monotonic()
+    with tempfile.TemporaryDirectory(
+        prefix=f"originweave-web-audio-{trial_number}-"
+    ) as profile_dir:
+        driver = subprocess.Popen(
+            [str(chromedriver_bin), f"--port={driver_port}", "--allowed-ips=127.0.0.1"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        try:
+            _wait_for_driver(driver_port)
+            session = _json_request(
+                driver_port,
+                "POST",
+                "/session",
+                {
+                    "capabilities": {
+                        "alwaysMatch": {
+                            "browserName": "chrome",
+                            "goog:chromeOptions": {
+                                "binary": str(chrome_bin),
+                                "args": [
+                                    "--headless=new",
+                                    "--no-first-run",
+                                    "--disable-default-apps",
+                                    "--disable-component-update",
+                                    "--disable-sync",
+                                    "--disable-dev-shm-usage",
+                                    "--no-sandbox",
+                                    f"--user-data-dir={profile_dir}",
+                                    f"--disable-extensions-except={EXTENSION}",
+                                    f"--load-extension={EXTENSION}",
+                                ],
+                            },
+                        }
+                    }
+                },
+            ).get("value", {})
+            if not isinstance(session, dict):
+                raise RuntimeError("ChromeDriver session response is malformed")
+            raw_session_id = session.get("sessionId")
+            capabilities = session.get("capabilities", {})
+            if not isinstance(raw_session_id, str):
+                raise RuntimeError("ChromeDriver did not return a session id")
+            session_id = _path_token(raw_session_id, "session identifier")
+            browser_version = (
+                capabilities.get("browserVersion")
+                if isinstance(capabilities, dict)
+                else None
+            )
+            if browser_version != PINNED_CHROME_VERSION:
+                raise RuntimeError(
+                    f"unexpected Chrome version: expected {PINNED_CHROME_VERSION}, "
+                    f"got {browser_version!r}"
+                )
+
+            _json_request(
+                driver_port,
+                "POST",
+                _webdriver_path(session_id, "/url"),
+                {"url": fixture_url},
+            )
+            surfaces = _wait_for_privacy_evidence(driver_port, session_id)
+            return {
+                "trial_number": trial_number,
+                "passed": True,
+                "browser_version": browser_version,
+                "surfaces": surfaces,
+                "duration_ms": round((time.monotonic() - started) * 1000),
+            }
+        finally:
+            primary_error = sys.exc_info()[1]
+            try:
+                if session_id is not None:
+                    _cleanup_browser_session_preserving_primary(
+                        driver_port,
+                        session_id,
+                        primary_error,
+                    )
+            finally:
+                driver.terminate()
+                try:
+                    driver.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    driver.kill()
+                    driver.wait(timeout=5)
+
+
+def _run_trial_with_evidence(
+    chrome_bin: pathlib.Path,
+    chromedriver_bin: pathlib.Path,
+    fixture_url: str,
+    trial_number: int,
+) -> dict[str, Any]:
+    """Convert one bounded recoverable browser failure into failed-trial evidence."""
+
+    try:
+        return _run_trial(chrome_bin, chromedriver_bin, fixture_url, trial_number)
+    except PrivacyProbeError as exc:
+        return {
+            "trial_number": trial_number,
+            "passed": False,
+            "error_type": type(exc).__name__,
+            "surfaces": exc.surfaces,
+        }
+    except (
+        OSError,
+        ValueError,
+        RuntimeError,
+        http.client.HTTPException,
+        json.JSONDecodeError,
+    ) as exc:
+        return {
+            "trial_number": trial_number,
+            "passed": False,
+            "error_type": type(exc).__name__,
+        }
+
+
+def main() -> int:
+    """Run three isolated trials and emit bounded repeatability evidence."""
+
+    chrome_bin = pathlib.Path(os.environ.get("CHROME_BIN", ""))
+    chromedriver_bin = pathlib.Path(os.environ.get("CHROMEDRIVER_BIN", ""))
+    if not chrome_bin.is_file():
+        raise SystemExit("CHROME_BIN must point to the pinned Chrome executable")
+    if not chromedriver_bin.is_file():
+        raise SystemExit("CHROMEDRIVER_BIN must point to the matching ChromeDriver")
+    for required in (
+        EXTENSION / "manifest.json",
+        EXTENSION / "web_audio_guard.js",
+        FIXTURE / "page.html",
+        FIXTURE / "frame.html",
+    ):
+        if not required.is_file():
+            raise SystemExit(f"required privacy fixture file is missing: {required.name}")
+
+    fixture_server = http.server.ThreadingHTTPServer(
+        ("127.0.0.1", 0),
+        lambda *args, **kwargs: QuietFixtureHandler(
+            *args, directory=str(FIXTURE), **kwargs
+        ),
+    )
+    fixture_thread = threading.Thread(target=fixture_server.serve_forever, daemon=True)
+    fixture_thread.start()
+    started = time.monotonic()
+    try:
+        fixture_url = f"http://127.0.0.1:{fixture_server.server_port}/page.html"
+        trials = [
+            _run_trial_with_evidence(
+                chrome_bin,
+                chromedriver_bin,
+                fixture_url,
+                trial_number,
+            )
+            for trial_number in range(1, REPEATABILITY_TRIALS + 1)
+        ]
+
+        successful_trials = sum(trial.get("passed") is True for trial in trials)
+        evidence = {
+            "chrome_version": PINNED_CHROME_VERSION,
+            "chrome_revision": PINNED_CHROME_REVISION,
+            "repeatability_trials": REPEATABILITY_TRIALS,
+            "successful_trials": successful_trials,
+            "trial_pass_rate": successful_trials / REPEATABILITY_TRIALS,
+            "guard_profile": "default_deny_exact_origin_grants",
+            "top_document_and_child_frame": True,
+            "trial_results": trials,
+            "duration_ms": round((time.monotonic() - started) * 1000),
+        }
+        print(json.dumps(evidence, sort_keys=True))
+        if successful_trials != REPEATABILITY_TRIALS:
+            raise RuntimeError(
+                "Web Audio privacy gate failed: "
+                f"{successful_trials}/{REPEATABILITY_TRIALS} trials passed"
+            )
+        return 0
+    finally:
+        fixture_server.shutdown()
+        fixture_server.server_close()
+        fixture_thread.join(timeout=5)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tests/fixtures/web_audio_privacy/frame.html b/tests/fixtures/web_audio_privacy/frame.html
new file mode 100644
index 000000000..7e6a7bc79
--- /dev/null
+++ b/tests/fixtures/web_audio_privacy/frame.html
@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>OriginWeave child-frame Web Audio probe</title>
+  <script>
+    "use strict";
+    const originweaveProbeConstructor = (constructorName) => {
+      try {
+        const Constructor = globalThis[constructorName];
+        if (typeof Constructor !== "function") {
+          return "unavailable";
+        }
+        new Constructor();
+        return "leaked";
+      } catch (error) {
+        return error?.name === "NotAllowedError" ? "blocked" : `unexpected:${error?.name ?? "Error"}`;
+      }
+    };
+    document.documentElement.dataset.originweaveAudioContext =
+      originweaveProbeConstructor("AudioContext");
+    document.documentElement.dataset.originweaveOfflineAudioContext =
+      originweaveProbeConstructor("OfflineAudioContext");
+  </script>
+</head>
+<body>
+  <p>Child-frame privacy probe.</p>
+</body>
+</html>
diff --git a/tests/fixtures/web_audio_privacy/page.html b/tests/fixtures/web_audio_privacy/page.html
new file mode 100644
index 000000000..621a0f14e
--- /dev/null
+++ b/tests/fixtures/web_audio_privacy/page.html
@@ -0,0 +1,38 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>OriginWeave Web Audio privacy fixture</title>
+  <script>
+    "use strict";
+    const originweaveProbeConstructor = (constructorName) => {
+      try {
+        const Constructor = globalThis[constructorName];
+        if (typeof Constructor !== "function") {
+          return "unavailable";
+        }
+        new Constructor();
+        return "leaked";
+      } catch (error) {
+        return error?.name === "NotAllowedError" ? "blocked" : `unexpected:${error?.name ?? "Error"}`;
+      }
+    };
+    document.documentElement.dataset.originweaveAudioContext =
+      originweaveProbeConstructor("AudioContext");
+    document.documentElement.dataset.originweaveWebkitAudioContext =
+      originweaveProbeConstructor("webkitAudioContext");
+    document.documentElement.dataset.originweaveOfflineAudioContext =
+      originweaveProbeConstructor("OfflineAudioContext");
+    document.documentElement.dataset.originweaveWebkitOfflineAudioContext =
+      originweaveProbeConstructor("webkitOfflineAudioContext");
+    document.documentElement.dataset.originweaveAudioWorkletNode =
+      originweaveProbeConstructor("AudioWorkletNode");
+  </script>
+</head>
+<body>
+  <main>
+    <h1>OriginWeave Web Audio privacy fixture</h1>
+    <iframe id="privacy-frame" title="Child-frame privacy probe" src="frame.html"></iframe>
+  </main>
+</body>
+</html>
diff --git a/tests/test_web_audio_privacy_contract.py b/tests/test_web_audio_privacy_contract.py
new file mode 100644
index 000000000..3a5864e51
--- /dev/null
+++ b/tests/test_web_audio_privacy_contract.py
@@ -0,0 +1,253 @@
+"""Repository contract for the executable Web Audio privacy boundary."""
+
+from __future__ import annotations
+
+import http.server
+import json
+import pathlib
+import runpy
+import threading
+import unittest
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+EXTENSION = ROOT / "extensions" / "originweave-privacy-guard"
+FIXTURE = ROOT / "tests" / "fixtures" / "web_audio_privacy"
+RUNNER = ROOT / "scripts" / "ci" / "run_web_audio_privacy.py"
+WORKFLOW = ROOT / ".github" / "workflows" / "mv3-compatibility.yml"
+RUST_POLICY = (
+    ROOT
+    / "crates"
+    / "originweave-fingerprint"
+    / "src"
+    / "web_audio_guard.rs"
+)
+SECRET_MARKER = "buyer-secret-marker-must-not-reach-ci"
+
+
+class _ErrorResponseHandler(http.server.BaseHTTPRequestHandler):
+    """Serve deterministic hostile ChromeDriver-shaped error responses."""
+
+    response_status = 403
+    response_body = (
+        b'{"value":{"error":"unknown error","message":"'
+        + SECRET_MARKER.encode("ascii")
+        + b'"}}'
+    )
+
+    def do_GET(self) -> None:  # noqa: N802 - stdlib handler contract.
+        self.send_response(self.response_status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(self.response_body)))
+        self.end_headers()
+        self.wfile.write(self.response_body)
+
+    def log_message(self, _format: str, *args: object) -> None:
+        """Keep the hostile marker out of test-server logging."""
+
+
+class WebAudioPrivacyContractTests(unittest.TestCase):
+    """Keep the default-deny browser guard explicit and reproducible."""
+
+    def test_manifest_runs_before_page_scripts_in_main_world_and_all_frames(self) -> None:
+        """The guard must reach the page's own constructors before any page script."""
+
+        manifest = json.loads((EXTENSION / "manifest.json").read_text(encoding="utf-8"))
+        self.assertEqual(manifest["manifest_version"], 3)
+        self.assertNotIn("permissions", manifest)
+        self.assertNotIn("host_permissions", manifest)
+        scripts = manifest["content_scripts"]
+        self.assertEqual(len(scripts), 1)
+        script = scripts[0]
+        self.assertEqual(script["matches"], ["http://*/*", "https://*/*"])
+        self.assertEqual(script["js"], ["web_audio_guard.js"])
+        self.assertEqual(script["run_at"], "document_start")
+        self.assertEqual(script["world"], "MAIN")
+        self.assertIs(script["all_frames"], True)
+        self.assertIs(script["match_about_blank"], True)
+        self.assertIs(script["match_origin_as_fallback"], True)
+
+    def test_checked_in_guard_blocks_every_web_audio_entrypoint(self) -> None:
+        """The reviewed guard must block online, offline, prefixed, and worklet APIs."""
+
+        guard = (EXTENSION / "web_audio_guard.js").read_text(encoding="utf-8")
+        self.assertEqual(guard.count("ORIGINWEAVE_ALLOWED_WEB_AUDIO_ORIGINS"), 1)
+        for constructor in (
+            "AudioContext",
+            "webkitAudioContext",
+            "OfflineAudioContext",
+            "webkitOfflineAudioContext",
+            "AudioWorkletNode",
+        ):
+            with self.subTest(constructor=constructor):
+                self.assertIn(f'"{constructor}"', guard)
+        self.assertIn('"NotAllowedError"', guard)
+        self.assertIn("document_start", guard)
+        for forbidden in ("eval(", "new Function", "fetch(", "XMLHttpRequest", "chrome."):
+            with self.subTest(forbidden=forbidden):
+                self.assertNotIn(forbidden, guard)
+
+    def test_rust_policy_includes_the_reviewed_guard_and_bounds_exact_grants(self) -> None:
+        """Policy rendering must be source-bound, deterministic, and bounded."""
+
+        policy = RUST_POLICY.read_text(encoding="utf-8")
+        for expected in (
+            "include_str!",
+            "originweave-privacy-guard/web_audio_guard.js",
+            "BTreeSet<Origin>",
+            "MAX_ALLOWED_ORIGINS: usize = 128",
+            "web_audio_fingerprinting_no_explicit_origin_grant",
+            "replacen(ALLOWLIST_MARKER",
+        ):
+            with self.subTest(expected=expected):
+                self.assertIn(expected, policy)
+
+    def test_fixture_probes_top_document_and_child_frame_before_dom_ready(self) -> None:
+        """The browser fixture must test first-script and all-frame enforcement."""
+
+        page = (FIXTURE / "page.html").read_text(encoding="utf-8")
+        frame = (FIXTURE / "frame.html").read_text(encoding="utf-8")
+        self.assertIn("originweaveAudioContext", page)
+        self.assertIn("originweaveAudioWorkletNode", page)
+        self.assertIn('src="frame.html"', page)
+        self.assertIn("originweaveOfflineAudioContext", frame)
+        self.assertNotIn("DOMContentLoaded", page)
+        self.assertNotIn("DOMContentLoaded", frame)
+
+    def test_runner_is_pinned_loopback_only_and_repeated(self) -> None:
+        """Privacy evidence must use one pinned browser and three isolated trials."""
+
+        runner = RUNNER.read_text(encoding="utf-8")
+        for expected in (
+            'PINNED_CHROME_VERSION = "150.0.7871.129"',
+            'PINNED_CHROME_REVISION = "r1639810"',
+            "REPEATABILITY_TRIALS = 3",
+            "http.client.HTTPConnection",
+            '"127.0.0.1"',
+            "originweave-privacy-guard",
+            "top_document_and_child_frame",
+            "trial_pass_rate",
+        ):
+            with self.subTest(expected=expected):
+                self.assertIn(expected, runner)
+        self.assertNotIn("urllib.request", runner)
+        self.assertNotIn("NVIDIA_NIM_API_KEY", runner)
+
+        namespace = runpy.run_path(str(RUNNER), run_name="web_audio_contract")
+        validate = namespace["_path_token"]
+        token = "f.3A0B2C.d.9D8E7F.e.2"
+        self.assertEqual(validate(token, "session identifier"), token)
+        for invalid in (".", "..", "f/escape", "f%2Fescape", "f?query"):
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(RuntimeError):
+                    validate(invalid, "session identifier")
+
+        satisfies = namespace["_privacy_evidence_satisfies"]
+        protected = {
+            "audioContext": "blocked",
+            "webkitAudioContext": "unavailable",
+            "offlineAudioContext": "blocked",
+            "webkitOfflineAudioContext": "unavailable",
+            "audioWorkletNode": "blocked",
+            "childAudioContext": "blocked",
+            "childOfflineAudioContext": "blocked",
+        }
+        self.assertIs(satisfies(protected), True)
+        prefixed_blocked = dict(protected)
+        prefixed_blocked["webkitAudioContext"] = "blocked"
+        prefixed_blocked["webkitOfflineAudioContext"] = "blocked"
+        self.assertIs(satisfies(prefixed_blocked), True)
+        leaked = dict(protected)
+        leaked["audioContext"] = "leaked"
+        self.assertIs(satisfies(leaked), False)
+        missing = dict(protected)
+        del missing["childAudioContext"]
+        self.assertIs(satisfies(missing), False)
+
+    def _webdriver_error_against(self, *, status: int) -> RuntimeError:
+        """Return one runner error produced by a hostile local ChromeDriver response."""
+
+        namespace = runpy.run_path(
+            str(RUNNER), run_name="web_audio_chromedriver_diagnostic_contract"
+        )
+        json_request = namespace["_json_request"]
+
+        class Handler(_ErrorResponseHandler):
+            response_status = status
+
+        server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            with self.assertRaises(RuntimeError) as captured:
+                json_request(int(server.server_port), "GET", "/status")
+            return captured.exception
+        finally:
+            server.shutdown()
+            server.server_close()
+            thread.join(timeout=2.0)
+
+    def test_webdriver_http_error_does_not_reflect_response_body(self) -> None:
+        """HTTP status may remain diagnostic evidence; response bytes may not."""
+
+        error = self._webdriver_error_against(status=403)
+        self.assertIn("403", str(error))
+        self.assertNotIn(SECRET_MARKER, str(error))
+
+    def test_webdriver_error_object_does_not_reflect_response_message(self) -> None:
+        """A 2xx WebDriver error object must fail closed without its raw message."""
+
+        error = self._webdriver_error_against(status=200)
+        self.assertIn("WebDriver", str(error))
+        self.assertNotIn(SECRET_MARKER, str(error))
+
+    def test_webdriver_session_cleanup_is_typed_and_fail_closed(self) -> None:
+        """Cleanup failure must never be silently converted into a passing browser trial."""
+
+        runner = RUNNER.read_text(encoding="utf-8")
+        self.assertNotIn("contextlib.suppress(Exception)", runner)
+
+        namespace = runpy.run_path(str(RUNNER), run_name="web_audio_cleanup_contract")
+        cleanup = namespace["_cleanup_browser_session_preserving_primary"]
+        cleanup_error_type = namespace["BrowserSessionCleanupError"]
+        globals_dict = cleanup.__globals__
+        original_cleanup = globals_dict["_cleanup_browser_session"]
+
+        def fail_cleanup(_driver_port: int, _session_id: str) -> None:
+            raise OSError("simulated bounded cleanup failure")
+
+        globals_dict["_cleanup_browser_session"] = fail_cleanup
+        try:
+            with self.assertRaises(cleanup_error_type) as no_primary:
+                cleanup(9515, "safe-session", None)
+            self.assertEqual(no_primary.exception.cleanup_error_type, "OSError")
+            self.assertIsInstance(no_primary.exception.__cause__, OSError)
+
+            primary = RuntimeError("primary browser failure")
+            with self.assertRaises(RuntimeError) as with_primary:
+                cleanup(9515, "safe-session", primary)
+            self.assertIs(with_primary.exception, primary)
+            self.assertIsInstance(with_primary.exception.__context__, OSError)
+            self.assertIn(
+                "WebDriver session cleanup also failed with OSError",
+                getattr(with_primary.exception, "__notes__", []),
+            )
+        finally:
+            globals_dict["_cleanup_browser_session"] = original_cleanup
+
+    def test_workflow_executes_and_publishes_the_real_browser_privacy_gate(self) -> None:
+        """The pinned Chromium workflow must execute and retain privacy evidence."""
+
+        workflow = WORKFLOW.read_text(encoding="utf-8")
+        for expected in (
+            "run_web_audio_privacy.py",
+            "web-audio-privacy.json",
+            "extensions/originweave-privacy-guard/**",
+            "tests/fixtures/web_audio_privacy/**",
+        ):
+            with self.subTest(expected=expected):
+                self.assertIn(expected, workflow)
+        self.assertNotIn("contents: write", workflow)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_web_audio_privacy_python310_cleanup_contract.py b/tests/test_web_audio_privacy_python310_cleanup_contract.py
new file mode 100644
index 000000000..599d8a745
--- /dev/null
+++ b/tests/test_web_audio_privacy_python310_cleanup_contract.py
@@ -0,0 +1,143 @@
+"""Regression contracts for bounded Web Audio runner recovery."""
+
+from __future__ import annotations
+
+import http.client
+import pathlib
+import runpy
+import unittest
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+RUNNER = ROOT / "scripts" / "ci" / "run_web_audio_privacy.py"
+
+
+class WebAudioPrivacyRecoveryContractTests(unittest.TestCase):
+    """Preserve causal failures and retry only bounded local readiness faults."""
+
+    def _namespace(self) -> dict[str, object]:
+        return runpy.run_path(str(RUNNER), run_name="web_audio_recovery_contract")
+
+    def test_cleanup_failure_does_not_require_exception_add_note(self) -> None:
+        """Cleanup recovery must remain correct on Python 3.10."""
+
+        namespace = self._namespace()
+        cleanup = namespace["_cleanup_browser_session_preserving_primary"]
+        globals_dict = cleanup.__globals__
+        original_cleanup = globals_dict["_cleanup_browser_session"]
+
+        class Python310StylePrimaryError(RuntimeError):
+            """Model a BaseException implementation without Python 3.11 add_note."""
+
+            add_note = None
+
+        def fail_cleanup(_driver_port: int, _session_id: str) -> None:
+            raise OSError("simulated bounded cleanup failure")
+
+        globals_dict["_cleanup_browser_session"] = fail_cleanup
+        try:
+            primary = Python310StylePrimaryError("primary browser failure")
+            with self.assertRaises(Python310StylePrimaryError) as raised:
+                cleanup(9515, "safe-session", primary)
+            self.assertIs(raised.exception, primary)
+            self.assertIsInstance(raised.exception.__context__, OSError)
+        finally:
+            globals_dict["_cleanup_browser_session"] = original_cleanup
+
+    def test_driver_readiness_retries_transient_http_disconnect(self) -> None:
+        """A recoverable loopback protocol disconnect must use the bounded startup retry."""
+
+        namespace = self._namespace()
+        wait_for_driver = namespace["_wait_for_driver"]
+        globals_dict = wait_for_driver.__globals__
+        original_request = globals_dict["_json_request"]
+        attempts = 0
+
+        def transient_request(
+            _driver_port: int,
+            _method: str,
+            _path: str,
+            _payload: dict[str, object] | None = None,
+            *,
+            timeout: float,
+        ) -> dict[str, object]:
+            nonlocal attempts
+            attempts += 1
+            if attempts == 1:
+                raise http.client.RemoteDisconnected("simulated startup disconnect")
+            return {"value": {"ready": True}}
+
+        globals_dict["_json_request"] = transient_request
+        try:
+            wait_for_driver(9515)
+            self.assertEqual(attempts, 2)
+        finally:
+            globals_dict["_json_request"] = original_request
+
+    def test_driver_readiness_retries_transient_bad_status_line(self) -> None:
+        """A malformed startup response must use the same bounded readiness retry."""
+
+        namespace = self._namespace()
+        wait_for_driver = namespace["_wait_for_driver"]
+        globals_dict = wait_for_driver.__globals__
+        original_request = globals_dict["_json_request"]
+        attempts = 0
+
+        def transient_request(
+            _driver_port: int,
+            _method: str,
+            _path: str,
+            _payload: dict[str, object] | None = None,
+            *,
+            timeout: float,
+        ) -> dict[str, object]:
+            nonlocal attempts
+            attempts += 1
+            if attempts == 1:
+                raise http.client.BadStatusLine("simulated startup protocol noise")
+            return {"value": {"ready": True}}
+
+        globals_dict["_json_request"] = transient_request
+        try:
+            wait_for_driver(9515)
+            self.assertEqual(attempts, 2)
+        finally:
+            globals_dict["_json_request"] = original_request
+
+    def test_trial_protocol_failure_becomes_bounded_failed_evidence(self) -> None:
+        """A malformed in-trial response must not abort the repeatability portfolio."""
+
+        namespace = self._namespace()
+        run_trial_with_evidence = namespace["_run_trial_with_evidence"]
+        globals_dict = run_trial_with_evidence.__globals__
+        original_run_trial = globals_dict["_run_trial"]
+
+        def fail_trial(
+            _chrome_bin: pathlib.Path,
+            _chromedriver_bin: pathlib.Path,
+            _fixture_url: str,
+            _trial_number: int,
+        ) -> dict[str, object]:
+            raise http.client.BadStatusLine("simulated in-trial protocol noise")
+
+        globals_dict["_run_trial"] = fail_trial
+        try:
+            evidence = run_trial_with_evidence(
+                pathlib.Path("/reviewed/chrome"),
+                pathlib.Path("/reviewed/chromedriver"),
+                "http://127.0.0.1:9515/page.html",
+                2,
+            )
+            self.assertEqual(
+                evidence,
+                {
+                    "trial_number": 2,
+                    "passed": False,
+                    "error_type": "BadStatusLine",
+                },
+            )
+        finally:
+            globals_dict["_run_trial"] = original_run_trial
+
+
+if __name__ == "__main__":
+    unittest.main()