feat(core): bind runtime adapter version before protocol use

CHANGELOG.md

@@ -10,6 +10,7 @@ All notable changes to OriginWeave are documented in this file. The format follo
 - Versioned browser-protocol adapter metadata that distinguishes WebDriver BiDi from pinned CDP, binds bounded adapter/browser revision tokens to an explicit duplicate-free capability set, normalizes capability-set identity independently of caller ordering, and exposes typed fail-closed capability requirements without granting browser, action, network, or secret authority by protocol kind alone.
 - Canonical OriginWeave protocol-version parsing for exact `originweave/<major>.<minor>` syntax, with typed fail-closed rejection of malformed, ambiguous, overflowed, or noncanonical serialized generations; parsing does not negotiate compatibility or grant adapter authority.
 - Atomic browser-protocol use validation that requires the exact OriginWeave protocol generation, caller-supplied runtime protocol family, exact pinned runtime protocol/browser revisions, and an explicitly declared capability in deterministic fail-closed order before producing non-cloneable validation evidence; this metadata proof does not authenticate the adapter or grant browser/Agent authority.
+- Runtime browser-adapter version binding at the atomic protocol-use boundary: the caller-supplied bounded adapter-version token must exactly match the reviewed descriptor version before runtime revision or capability checks can succeed, preventing adapter-build drift from silently reusing otherwise matching protocol/browser metadata without authenticating or attesting the adapter process.
 - Credential-safe browser-protocol validation evidence that copies only the already validated protocol family, OriginWeave generation, adapter version, pinned protocol/browser revisions, and exact capability into cloneable audit metadata without recreating the non-cloneable validation prerequisite or granting browser/Agent authority.
 - Canonical HTTPS and loopback-origin boundary with case-normalized schemes and hosts, default-port normalization, IPv4/IPv6 handling, browser-special numeric-host rejection, and explicit malformed-input errors.
 - Typed browser actions, capabilities, risk classes, execution modes, robots decisions, secret-delivery contracts, immutable canonical action-intent digests, and intent-bound approval scopes.

crates/originweave-core/src/browser_protocol.rs

@@ -294,7 +294,7 @@ impl BrowserProtocolAdapterDescriptor {
     ///
     /// Validation is intentionally ordered and fail closed: the exact
     /// OriginWeave Protocol generation is checked first, then the caller-supplied
-    /// runtime protocol family, then the supplied runtime protocol/browser
+    /// runtime protocol family, runtime adapter version, protocol/browser
     /// revisions, and finally the required adapter capability. Success returns
     /// a non-cloneable value that a later trusted transport can consume as proof
     /// that these metadata prerequisites were checked together. It is not
@@ -304,6 +304,7 @@ impl BrowserProtocolAdapterDescriptor {
         &self,
         required_originweave_protocol_version: OriginWeaveProtocolVersion,
         runtime_kind: BrowserProtocolKind,
+        runtime_adapter_version: &str,
         runtime_protocol_revision: &str,
         runtime_browser_revision: &str,
         required_capability: BrowserProtocolCapability,
@@ -316,6 +317,12 @@ impl BrowserProtocolAdapterDescriptor {
                 runtime_kind,
             });
         }
+        if !metadata_token_is_valid(runtime_adapter_version) {
+            return Err(BrowserProtocolUseValidationError::InvalidAdapterVersion);
+        }
+        if self.adapter_version != runtime_adapter_version {
+            return Err(BrowserProtocolUseValidationError::AdapterVersionMismatch);
+        }
         self.require_runtime_revisions(runtime_protocol_revision, runtime_browser_revision)
             .map_err(BrowserProtocolUseValidationError::RuntimeRevision)?;
         self.require_capability(required_capability)
@@ -499,6 +506,10 @@ pub enum BrowserProtocolUseValidationError {
         /// Browser protocol family reported by the runtime transport.
         runtime_kind: BrowserProtocolKind,
     },
+    /// The runtime adapter-version token was malformed.
+    InvalidAdapterVersion,
+    /// The runtime adapter version differs from the pinned descriptor version.
+    AdapterVersionMismatch,
     /// The supplied runtime protocol or browser revision is invalid or has drifted.
     RuntimeRevision(BrowserProtocolRuntimeRequirementError),
     /// The descriptor does not explicitly declare the required capability.
@@ -511,6 +522,12 @@ impl fmt::Display for BrowserProtocolUseValidationError {
             Self::ProtocolVersion(error) => error.fmt(formatter),
             Self::ProtocolKindMismatch { .. } => formatter
                 .write_str("runtime browser protocol kind does not match the pinned adapter kind"),
+            Self::InvalidAdapterVersion => formatter.write_str(
+                "runtime browser adapter version must be a bounded ASCII metadata token",
+            ),
+            Self::AdapterVersionMismatch => formatter.write_str(
+                "runtime browser adapter version does not match the pinned adapter version",
+            ),
             Self::RuntimeRevision(error) => error.fmt(formatter),
             Self::Capability(error) => error.fmt(formatter),
         }
@@ -521,7 +538,9 @@ impl std::error::Error for BrowserProtocolUseValidationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
             Self::ProtocolVersion(error) => Some(error),
-            Self::ProtocolKindMismatch { .. } => None,
+            Self::ProtocolKindMismatch { .. }
+            | Self::InvalidAdapterVersion
+            | Self::AdapterVersionMismatch => None,
             Self::RuntimeRevision(error) => Some(error),
             Self::Capability(error) => Some(error),
         }

crates/originweave-core/tests/browser_protocol_runtime_adapter_version.rs

@@ -0,0 +1,94 @@
+use std::error::Error;
+
+use originweave_core::{
+    BrowserProtocolAdapterDescriptor, BrowserProtocolCapability, BrowserProtocolKind,
+    BrowserProtocolUseValidationError, OriginWeaveProtocolVersion,
+};
+
+const ORIGINWEAVE_PROTOCOL_VERSION: OriginWeaveProtocolVersion =
+    OriginWeaveProtocolVersion::new(0, 1);
+const ADAPTER_VERSION: &str = "originweave-bidi-v1";
+const PROTOCOL_REVISION: &str = "webdriver-bidi-wd-2026-06-01";
+const BROWSER_REVISION: &str = "chromium-r1639810";
+
+fn descriptor() -> Result<BrowserProtocolAdapterDescriptor, Box<dyn Error>> {
+    Ok(BrowserProtocolAdapterDescriptor::new(
+        BrowserProtocolKind::WebDriverBiDi,
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        ADAPTER_VERSION,
+        PROTOCOL_REVISION,
+        BROWSER_REVISION,
+        &[BrowserProtocolCapability::Navigation],
+    )?)
+}
+
+#[test]
+fn runtime_adapter_version_is_bound_into_atomic_use_validation() -> Result<(), Box<dyn Error>> {
+    let descriptor = descriptor()?;
+
+    let validated = descriptor.validate_use(
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        BrowserProtocolKind::WebDriverBiDi,
+        ADAPTER_VERSION,
+        PROTOCOL_REVISION,
+        BROWSER_REVISION,
+        BrowserProtocolCapability::Navigation,
+    )?;
+
+    assert_eq!(validated.adapter_version(), ADAPTER_VERSION);
+    Ok(())
+}
+
+#[test]
+fn runtime_adapter_version_mismatch_precedes_revision_and_capability_checks()
+-> Result<(), Box<dyn Error>> {
+    let descriptor = descriptor()?;
+
+    let error = descriptor.validate_use(
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        BrowserProtocolKind::WebDriverBiDi,
+        "originweave-bidi-v2",
+        "runtime revision with spaces",
+        "browser/revision",
+        BrowserProtocolCapability::NetworkObservation,
+    );
+
+    assert_eq!(
+        error,
+        Err(BrowserProtocolUseValidationError::AdapterVersionMismatch)
+    );
+    let error = error.err().ok_or("expected adapter version mismatch")?;
+    assert_eq!(
+        error.to_string(),
+        "runtime browser adapter version does not match the pinned adapter version"
+    );
+    assert!(error.source().is_none());
+    Ok(())
+}
+
+#[test]
+fn malformed_runtime_adapter_version_fails_closed_before_revision_checks()
+-> Result<(), Box<dyn Error>> {
+    let descriptor = descriptor()?;
+
+    let error = descriptor.validate_use(
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        BrowserProtocolKind::WebDriverBiDi,
+        "runtime adapter/version",
+        "runtime revision with spaces",
+        "browser/revision",
+        BrowserProtocolCapability::NetworkObservation,
+    );
+
+    assert_eq!(
+        error,
+        Err(BrowserProtocolUseValidationError::InvalidAdapterVersion)
+    );
+    let error = error.err().ok_or("expected invalid adapter version")?;
+    assert_eq!(
+        error.to_string(),
+        "runtime browser adapter version must be a bounded ASCII metadata token"
+    );
+    assert!(error.source().is_none());
+    Ok(())
+}

crates/originweave-core/tests/browser_protocol_use_validation.rs

@@ -33,6 +33,7 @@ fn validated_use_binds_all_required_adapter_metadata() -> Result<(), Box<dyn Err
     let validated = descriptor.validate_use(
         ORIGINWEAVE_PROTOCOL_VERSION,
         BrowserProtocolKind::WebDriverBiDi,
+        ADAPTER_VERSION,
         PROTOCOL_REVISION,
         BROWSER_REVISION,
         BrowserProtocolCapability::Navigation,
@@ -63,6 +64,7 @@ fn protocol_generation_mismatch_precedes_runtime_and_capability_checks()
         descriptor.validate_use(
             wrong_generation,
             BrowserProtocolKind::ChromeDevToolsProtocol,
+            "runtime adapter/version",
             "runtime revision with spaces",
             "browser/revision",
             BrowserProtocolCapability::NetworkObservation,
@@ -78,13 +80,14 @@ fn protocol_generation_mismatch_precedes_runtime_and_capability_checks()
 }
 
 #[test]
-fn runtime_protocol_kind_mismatch_precedes_revision_and_capability_checks()
+fn runtime_protocol_kind_mismatch_precedes_adapter_revision_and_capability_checks()
 -> Result<(), Box<dyn Error>> {
     let descriptor = descriptor()?;
 
     let error = descriptor.validate_use(
         ORIGINWEAVE_PROTOCOL_VERSION,
         BrowserProtocolKind::ChromeDevToolsProtocol,
+        "runtime adapter/version",
         "runtime revision with spaces",
         "browser/revision",
         BrowserProtocolCapability::NetworkObservation,
@@ -114,6 +117,7 @@ fn runtime_revision_validation_precedes_capability_check() -> Result<(), Box<dyn
         descriptor.validate_use(
             ORIGINWEAVE_PROTOCOL_VERSION,
             BrowserProtocolKind::WebDriverBiDi,
+            ADAPTER_VERSION,
             "webdriver-bidi-wd-2026-07-01",
             BROWSER_REVISION,
             BrowserProtocolCapability::NetworkObservation,
@@ -133,6 +137,7 @@ fn undeclared_capability_cannot_produce_validated_use() -> Result<(), Box<dyn Er
         descriptor.validate_use(
             ORIGINWEAVE_PROTOCOL_VERSION,
             BrowserProtocolKind::WebDriverBiDi,
+            ADAPTER_VERSION,
             PROTOCOL_REVISION,
             BROWSER_REVISION,
             BrowserProtocolCapability::NetworkObservation,

crates/originweave-evidence/tests/browser_protocol_validation_evidence.rs

@@ -25,6 +25,7 @@ fn records_exact_metadata_from_one_validated_browser_protocol_use() -> Result<()
     let validated = descriptor.validate_use(
         ORIGINWEAVE_PROTOCOL_VERSION,
         BrowserProtocolKind::WebDriverBiDi,
+        ADAPTER_VERSION,
         PROTOCOL_REVISION,
         BROWSER_REVISION,
         BrowserProtocolCapability::SemanticObservation,
@@ -50,18 +51,21 @@ fn records_exact_metadata_from_one_validated_browser_protocol_use() -> Result<()
 #[test]
 fn evidence_is_owned_audit_metadata_not_reusable_validation_authority() -> Result<(), Box<dyn Error>>
 {
+    let cdp_adapter_version = "originweave-cdp-v1";
+    let cdp_protocol_revision = "cdp-1-3-r1639810";
     let descriptor = BrowserProtocolAdapterDescriptor::new(
         BrowserProtocolKind::ChromeDevToolsProtocol,
         ORIGINWEAVE_PROTOCOL_VERSION,
-        "originweave-cdp-v1",
-        "cdp-1-3-r1639810",
+        cdp_adapter_version,
+        cdp_protocol_revision,
         BROWSER_REVISION,
         &[BrowserProtocolCapability::NetworkObservation],
     )?;
     let validated = descriptor.validate_use(
         ORIGINWEAVE_PROTOCOL_VERSION,
         BrowserProtocolKind::ChromeDevToolsProtocol,
-        "cdp-1-3-r1639810",
+        cdp_adapter_version,
+        cdp_protocol_revision,
         BROWSER_REVISION,
         BrowserProtocolCapability::NetworkObservation,
     )?;