diff --git a/crates/didbot-onboarding/src/env.rs b/crates/didbot-onboarding/src/env.rs
index 10c6e1ba..4719e8be 100644
--- a/crates/didbot-onboarding/src/env.rs
+++ b/crates/didbot-onboarding/src/env.rs
@@ -226,37 +226,3 @@ pub(crate) fn first_missing<E: Environment + ?Sized>(
         .iter()
         .find_map(|capability| env.missing(*capability).map(|why| (*capability, why)))
 }
-
-/// Reads a record out of the operator's own repository.
-///
-/// The one authenticated seam in this crate, and the seam a signed-in front
-/// end fills. It is handed a collection and a record key, never a hostname,
-/// because the repository it reads is the **operator's own** — on the
-/// operator's own PDS — and never the server being checked.
-// `async fn` in a public trait forgoes an auto `Send` bound on its future;
-// see [`Environment`]'s own note.
-#[allow(async_fn_in_trait)]
-pub trait OperatorRepository {
-    /// The record at `collection`/`rkey`, or `None` when the repository
-    /// holds none.
-    async fn record(
-        &self,
-        collection: &str,
-        rkey: &str,
-    ) -> Result<Option<serde_json::Value>, String>;
-}
-
-/// The absence of a signed-in operator, and what an environment is built
-/// with until one arrives.
-#[derive(Debug, Default, Clone, Copy)]
-pub struct NoOperator;
-
-impl OperatorRepository for NoOperator {
-    async fn record(
-        &self,
-        _collection: &str,
-        _rkey: &str,
-    ) -> Result<Option<serde_json::Value>, String> {
-        Err("nobody is signed in".to_owned())
-    }
-}
diff --git a/crates/didbot-onboarding/src/lib.rs b/crates/didbot-onboarding/src/lib.rs
index e833f4d4..2953827c 100644
--- a/crates/didbot-onboarding/src/lib.rs
+++ b/crates/didbot-onboarding/src/lib.rs
@@ -43,10 +43,7 @@ pub mod verdict;
 #[cfg(not(target_arch = "wasm32"))]
 pub mod native;
 
-pub use env::{
-    Capability, Certificate, Environment, Fetched, NoOperator, OperatorRepository, RecordKind,
-    Unavailable,
-};
+pub use env::{Capability, Certificate, Environment, Fetched, RecordKind, Unavailable};
 pub use run::{run_steps, Target};
 pub use step::{Check, Step};
 pub use verdict::{CheckOutcome, Run, StepOutcome, StepState, Verdict};
diff --git a/crates/didbot-onboarding/src/native.rs b/crates/didbot-onboarding/src/native.rs
index eb43479c..679e27de 100644
--- a/crates/didbot-onboarding/src/native.rs
+++ b/crates/didbot-onboarding/src/native.rs
@@ -1,15 +1,11 @@
 //! The environment an operator's own machine offers.
 //!
-//! Everything: HTTPS with no same-origin rule, the machine's own stub
-//! resolver, DoH for the record types a stub resolver has no API for, and
-//! the certificate the connection actually rests on. A signed-in operator is
-//! the one thing a caller supplies.
+//! Everything but a signed-in operator: HTTPS with no same-origin rule, the
+//! machine's own stub resolver, DoH for the record types a stub resolver has
+//! no API for, and the certificate the connection actually rests on.
 
 use crate::doh;
-use crate::env::{
-    Capability, Certificate, Environment, Fetched, NoOperator, OperatorRepository, RecordKind,
-    Unavailable,
-};
+use crate::env::{Capability, Certificate, Environment, Fetched, RecordKind, Unavailable};
 
 /// How long any one call waits before calling it a failure.
 ///
@@ -21,38 +17,35 @@ use crate::env::{
 pub const CHECK_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
 /// The full environment: everything a command run by an operator can do.
-pub struct NativeEnvironment<R = NoOperator> {
+pub struct NativeEnvironment {
     client: reqwest::Client,
     resolver: String,
-    operator: Option<R>,
 }
 
-impl NativeEnvironment<NoOperator> {
-    /// An environment with nobody signed in, resolving through
-    /// [`doh::CLOUDFLARE`].
+impl NativeEnvironment {
+    /// An environment resolving through [`doh::CLOUDFLARE`].
     #[must_use]
     pub fn new() -> Self {
         Self::with_resolver(doh::CLOUDFLARE)
     }
 
-    /// An environment with nobody signed in, resolving through `resolver`.
+    /// An environment resolving through `resolver`.
     #[must_use]
     pub fn with_resolver(resolver: impl Into<String>) -> Self {
         Self {
             client: didbot_http::client(),
             resolver: resolver.into(),
-            operator: None,
         }
     }
 }
 
-impl Default for NativeEnvironment<NoOperator> {
+impl Default for NativeEnvironment {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<R: OperatorRepository> NativeEnvironment<R> {
+impl NativeEnvironment {
     /// One DoH query. The resolver is this machine's own choice, so it may
     /// be on a private address.
     async fn doh(&self, name: &str, record_type: (u16, &str)) -> Result<Vec<String>, String> {
@@ -85,14 +78,13 @@ impl<R: OperatorRepository> NativeEnvironment<R> {
     }
 }
 
-impl<R: OperatorRepository> Environment for NativeEnvironment<R> {
+impl Environment for NativeEnvironment {
     fn missing(&self, capability: Capability) -> Option<String> {
         match capability {
             Capability::Fetch | Capability::Dns | Capability::Certificate => None,
-            Capability::OperatorSession => self
-                .operator
-                .is_none()
-                .then(|| "no operator account is signed in to this command".to_owned()),
+            Capability::OperatorSession => {
+                Some("no operator account is signed in to this command".to_owned())
+            }
         }
     }
 
@@ -131,23 +123,6 @@ impl<R: OperatorRepository> Environment for NativeEnvironment<R> {
     async fn certificate(&self, hostname: &str) -> Result<Certificate, Unavailable> {
         handshake(hostname).await.map_err(Unavailable::failed)
     }
-
-    async fn operator_record(
-        &self,
-        collection: &str,
-        rkey: &str,
-    ) -> Result<Option<serde_json::Value>, Unavailable> {
-        match &self.operator {
-            Some(operator) => operator
-                .record(collection, rkey)
-                .await
-                .map_err(Unavailable::failed),
-            None => Err(Unavailable::not_here(
-                Capability::OperatorSession,
-                "no operator account is signed in to this command",
-            )),
-        }
-    }
 }
 
 /// Opens a TLS connection to `hostname` and reads the certificate it