fix: stacked-review round — 1 Critical, 3 High, 3 confirmed handle-shape defects (nexus-dhs30, asaod, ingey, at2ff sweep)

Six reviewers over 2b2ecd0..a7ef414, run AFTER those eight commits shipped —
which is how the Critical below reached develop and sat there. Every fix here
is mutation-verified: the guard is removed, the test fails, the guard is
restored.

CRITICAL — CI has been RED on develop for hours and nobody looked (nexus-dhs30)
a797dbd added `fetch-tags: true` to release.yml but NOT to ci.yml's `test`
job, which runs the full suite on every push from a shallow, tagless checkout.
The non-vacuity test I had just written (test_newest_published_engine_reads_
real_tags) therefore failed on EVERY push from a797dbd onward — four commits
landed on red. Each of those commit messages says "Full unit suite: N passed,
0 failed", true from a local full clone, and the CI result was never read.
Exactly the rot class the day was spent mechanizing against, one layer down:
the mechanization's own test was never validated in the shape it runs in.
  - ci.yml `test` job gains fetch-tags: true.
  - The test is SPLIT: a new hermetic test builds its own repo with known tags,
    so the parse bug it exists to catch (parse_engine_version takes "0.1.56",
    not "engine-service-v0.1.56") is caught in ANY environment, tags or not.

HIGH — the asaod 409 guard was half-applied, and the missed half is the
heavier path. `op.startsWith("/import/")` does NOT match "/import_batch" (no
slash after "import"). importTopicsBatch does the identical
insertInto(TOPICS, TOPICS.ID, ...).onConflict(TOPICS.ID) against the same
global BIGSERIAL PK, so the bulk ETL route — the 190k-row dogfood leg — kept
returning the opaque 500 the fix was cut to remove. Extracted isImportOp();
added a Testcontainers regression test that fails against the original guard.
NOT LIVE: engine-service-v0.1.56 is deployed with the half-applied guard.

HIGH x2 — `nx doctor` crashed where it was supposed to degrade, in the very
commit that existed to stop doctor misreporting health (nexus-ingey/k0luu).
_report_aspect_queue_service caught only httpx.HTTPError, but store
CONSTRUCTION resolves the endpoint and raises ServiceEndpointUnresolvableError
— a RuntimeError, not an httpx error. _run_trim_telemetry's service branch had
NO handling at all. A missing supervisor lease or absent NX_SERVICE_TOKEN thus
produced a traceback. The console twin written in the SAME commit caught
(httpx.HTTPError, RuntimeError) correctly; the doctor sites did not. Trim now
exits 2 with UNKNOWN rather than reporting a partial trim as complete.

THREE MORE at2ff INSTANCES, found by an independent sweep beyond the four
fixed in a23b2aa:
  - db/migrations.py:2705 — an UPGRADE BLOCKER. t3_db._client made every
    collection print "SKIPPED (AttributeError)", then a raw taxonomy.conn read
    OUTSIDE the loop's except hard-failed, so `nx upgrade` reported "will retry
    on next nx upgrade" for a retry that could never succeed. Both halves
    fixed; the raw count is DELETED rather than guarded (it was a progress-line
    nicety, and guarding it would have grown a census that may only shrink).
  - db/t3_reidentify.py:145 — `nx t3 reidentify` errored on every collection.
  - mcp/plan_cache_registry.py:62 — the staleness tier is DEAD in production
    (HttpPlanLibrary has no .path, so mtime is always 0.0). DECLARED, not
    faked: a real fix needs a server-side ETag. The docstring had called the
    only production case an "edge case".

A THIRD TEST FOUND ENCODING A PHANTOM HANDLE SHAPE. tests/test_projection_
quality.py had its own `class _StubT3: self._client = client`, and
tests/mcp/test_remediate_tool.py stubbed a telemetry object with no
record_consent while calling it "the real service-mode shape" — but
HttpTelemetryStore has had record_consent since nexus-ng2sy. Three today
(cf. tests/test_catalog.py). Each made a permanently-dead branch look covered.

ALSO FIXED:
  - nexus-xj744: HttpCatalogClient._db raised RuntimeError, violating the
    guard contract that hasattr()/has_raw_access() depend on. Now
    AttributeError, plus a NEW contract suite pinning all nine service-backed
    stores so the next one cannot reintroduce it.
  - nexus-huaef: the remediate version-skew branch could never fire. The
    fail-closed contract itself was never at risk (record_consent raises via
    _raise_for_status, and the generic except refuses), but the actionable
    "upgrade the engine" diagnosis was dead. Now keyed on 404/405, with a 500
    deliberately NOT misdiagnosed as skew.
  - nexus-d4ac1: embed_migrate's two at2ff sites, fixed while still dead code.
  - The ManagedServiceError branch of check_floor had ZERO coverage —
    replacing it with `return 0` left all 14 tests green. Covered.
  - NEXUS_PREV_RELEASE/NEXUS_PREV_ENGINE_TAG rotated to 6.18.0/v0.1.52. This
    was a MISSED SCHEDULED TRIGGER, not new debt: the 6.18.0 record said
    "rotate on next floor bump" and that bump was bfd3c25.
  - M1 accepted risk recorded in code: the 409-vs-200 status is a cross-tenant
    id-EXISTENCE oracle (global BIGSERIAL PK). Body and logs leak nothing
    further. Enumeration surface left open — nexus-4fpbl (P3).
  - Locale coupling on the RLS message match noted (non-English lc_messages
    silently degrades every 409 back to 500).

The suite-runtime anomaly (1:03:13 vs ~13min) was diagnosed as machine
contention, NOT code — the routing tests run 43 tests in 2.1s and the tree
runs at normal throughput today. --durations=15 added to the invocation so the
next anomaly localizes itself instead of needing forensics.

Full unit suite: 13,432 passed, 0 failed (fresh service JAR).

Author: Hellblazer

.github/workflows/ci.yml

@@ -85,6 +85,16 @@ jobs:
 
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd  # v5
+        with:
+          # nexus-dhs30: the suite includes a NON-VACUITY test that reads
+          # `git tag -l engine-service-v*` (tests/scripts/
+          # test_check_engine_release_floor.py::test_newest_published_engine_reads_real_tags).
+          # Default checkout is shallow and fetches NO tags, so that test saw an
+          # empty tag list and failed on every push from a797dbd4 onward — four
+          # commits landed on red CI because the local full-clone run was green
+          # and nobody read the CI result. release.yml got `fetch-tags: true` in
+          # the same commit; this job did not.
+          fetch-tags: true
 
       - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78  # v7
         with:

service/src/main/java/dev/nexus/service/http/HttpUtil.java

@@ -188,6 +188,14 @@ public static boolean sendTypedDbError(HttpExchange exchange, Throwable e,
      * the previous 500 — wrong status, never a wrong success. The paired
      * ``rejectsCrossTenantIdWith409`` test pins the live wording so the coupling
      * cannot rot silently.
+     *
+     * <p>LOCALE COUPLING (review, 2026-07-25): the message match assumes the PG
+     * server reports in English. A server with a non-English {@code lc_messages}
+     * localises "row-level security policy", the match silently fails, and every
+     * RLS refusal degrades back to an opaque 500 — the exact defect this exists to
+     * remove, reappearing as a config-dependent regression rather than a crash.
+     * Acceptable for a controlled hosted instance; state it rather than rediscover
+     * it. Same fragility class as a future PG rewording.
      */
     public static boolean isRlsRowRejection(Throwable t) {
         Throwable c = t;

service/src/main/java/dev/nexus/service/http/TaxonomyHandler.java

@@ -209,7 +209,29 @@ public void handle(HttpExchange exchange) throws IOException {
             // would be cross-tenant information disclosure. "not available" is all the
             // caller is entitled to, and all it needs (pick another id / re-key the
             // import).
-            if (op != null && op.startsWith("/import/") && HttpUtil.isRlsRowRejection(e)) {
+            //
+            // ACCEPTED RISK, stated so it is not re-derived (review 2026-07-25, Hal
+            // decision): the 409-vs-200 STATUS ITSELF is a weaker signal of the same
+            // fact. nexus.topics has a GLOBAL BIGSERIAL primary key — RLS scopes rows,
+            // not the id space — so an authenticated tenant can probe whether an
+            // arbitrary id is claimed SOMEWHERE in the system without any read access
+            // to the holder's data. What leaks is existence only: not the holding
+            // tenant, not the label, not any row content (the body and the log line
+            // above are both id-free and tenant-B-free). Probed at scale it reveals
+            // roughly how densely the global id space is populated.
+            //
+            // Accepted because: the route requires Bearer auth + tenant, it is a
+            // fidelity-ETL/migration path rather than a hot API, and ids are normally
+            // each tenant's own prior sequential rowids — collisions happen by accident
+            // rather than by choosing. The enumeration surface is NOT closed: there is
+            // no rate limiting on this route (AuthFilter has none). Tracked separately.
+            //
+            // Removing the oracle at source would mean a composite (tenant_id, id) key
+            // so ids cannot collide across tenants — which deletes this whole class.
+            // That was already considered and REJECTED: topics_parent_fk is
+            // self-referential, so a composite key forces every parent_id to carry a
+            // tenant too. The global BIGSERIAL is deliberate, not an oversight.
+            if (isImportOp(op) && HttpUtil.isRlsRowRejection(e)) {
                 log.warn("event=taxonomy_import_id_unavailable tenant={} op={}", tenant, op);
                 HttpUtil.send(exchange, 409, json(Map.of(
                     "error", "supplied id is not available in this tenant")));
@@ -220,6 +242,32 @@ public void handle(HttpExchange exchange) throws IOException {
         }
     }
 
+    /**
+     * True for the fidelity-ETL routes that preserve CLIENT-SUPPLIED ids.
+     *
+     * <p>Both the per-kind routes ({@code /import/topic}, {@code /import/assignment},
+     * {@code /import/link}, {@code /import/meta}) and the BULK route
+     * ({@code /import_batch}) insert caller-chosen primary keys, so both can be
+     * refused by RLS with SQLSTATE 42501 when a second tenant contests an id that
+     * {@code nexus.topics}' global BIGSERIAL PK already holds.
+     *
+     * <p>Extracted because the original guard was {@code op.startsWith("/import/")},
+     * which silently EXCLUDED {@code /import_batch} — there is no slash after
+     * "import" in that route, so the bulk path kept returning the opaque 500 the fix
+     * was cut to remove. That is the heavier real-world path: {@code importTopicsBatch}
+     * is the 190k-row dogfood leg, and it shares the identical
+     * {@code insertInto(TOPICS, TOPICS.ID, ...).onConflict(TOPICS.ID)} shape as the
+     * single-row importer. Found in review, 2026-07-25.
+     *
+     * <p>Not qualified by {@code kind}: the assignment/link/meta batch importers key
+     * on tenant-scoped composite conflict targets, so a cross-tenant RLS refusal is
+     * structurally impossible for them and {@link HttpUtil#isRlsRowRejection} simply
+     * never fires.
+     */
+    private static boolean isImportOp(String op) {
+        return op != null && (op.startsWith("/import/") || op.equals("/import_batch"));
+    }
+
     // ── Topics handlers ────────────────────────────────────────────────────────
 
     private void handleGetTopics(HttpExchange ex, String tenant, String method) throws IOException {

service/src/test/java/dev/nexus/service/http/TaxonomyHandlerImportRlsTest.java

@@ -160,6 +160,32 @@ void importTopic_secondTenantClaimingSameId_returns409_not500() throws Exception
         assertThat(ex.bodyString()).contains("not available");
     }
 
+    @Test
+    void importBatch_secondTenantClaimingSameId_returns409_not500() throws Exception {
+        // nexus-asaod review H1: the fix guarded op.startsWith("/import/"), which
+        // EXCLUDES "/import_batch" — no slash after "import". The bulk route reaches
+        // importTopicsBatch, which does the identical
+        // insertInto(TOPICS, TOPICS.ID, ...).onConflict(TOPICS.ID) against the same
+        // global BIGSERIAL PK, so it raised the same 42501 and returned the same
+        // opaque 500 the fix was cut to remove. It is also the HEAVIER real path (the
+        // 190k-row dogfood leg), so the fix was half-applied to the less-used route.
+        long id = CONTESTED_ID + 1;
+        CapturingExchange seed = importTopicBatch(id, "batch-a");
+        handleAs(TENANT_A, seed);
+        assertThat(seed.status).as("precondition: tenant A holds the id").isIn(200, 409);
+
+        CapturingExchange ex = importTopicBatch(id, "batch-b");
+        handleAs(TENANT_B, ex);
+
+        assertThat(ex.status)
+            .as("bulk import must classify an RLS row refusal the same as the single-row route")
+            .isEqualTo(409);
+        assertThat(ex.bodyString()).contains("not available");
+        assertThat(ex.bodyString())
+            .as("must not leak that the id belongs to another tenant")
+            .doesNotContain(TENANT_A);
+    }
+
     @Test
     void importTopic_conflictBodyDoesNotLeakTheOtherTenant() throws Exception {
         CapturingExchange seed = importTopic(CONTESTED_ID + 1, "leak-probe-a");
@@ -230,6 +256,22 @@ private void handleAs(String tenant, CapturingExchange ex) throws Exception {
         }
     }
 
+    /**
+     * The BULK route (nexus-asaod review, H1). Same client-supplied id, same global
+     * BIGSERIAL PK, same {@code onConflict(TOPICS.ID)} in importTopicsBatch — but a
+     * different op string, which the original {@code startsWith("/import/")} guard
+     * did not match.
+     */
+    private static CapturingExchange importTopicBatch(long id, String label) {
+        String row = "{\"id\":" + id + ",\"label\":\"" + label + "\","
+            + "\"parent_id\":null,\"collection\":\"knowledge__rls\","
+            + "\"centroid_hash\":null,\"doc_count\":1,"
+            + "\"created_at\":\"2026-07-25T00:00:00Z\","
+            + "\"review_status\":\"pending\",\"terms\":\"[]\"}";
+        String body = "{\"kind\":\"topic\",\"rows\":[" + row + "]}";
+        return new CapturingExchange("POST", URI.create("/v1/taxonomy/import_batch"), body);
+    }
+
     private static CapturingExchange importTopic(long id, String label) {
         String body = "{\"id\":" + id + ",\"label\":\"" + label + "\","
             + "\"parent_id\":null,\"collection\":\"knowledge__rls\","

src/nexus/catalog/http_catalog_client.py

@@ -261,8 +261,17 @@ def _db(self) -> None:  # type: ignore[return]
 
         Bead nexus-xnz0o is a HARD BLOCKER of Phase-4 catalog deletion
         (nexus-gmiaf.24).
+
+        RAISES AttributeError, NEVER RuntimeError (nexus-xj744). ``hasattr()``
+        only swallows ``AttributeError``; anything else propagates. A
+        ``RuntimeError`` here means a caller writing the sanctioned
+        ``hasattr(cat, "_db")`` / ``has_raw_access(cat)`` probe would CRASH in
+        service mode instead of getting ``False`` and taking the service branch
+        — the guard idiom that exists to make such checks safe would become the
+        thing that breaks them. ``db/t2/_raw_handle_guard.py`` states this
+        contract explicitly; this property was the one place violating it.
         """
-        raise RuntimeError(
+        raise AttributeError(
             "catalog._db is unavailable in service mode "
             "(NX_STORAGE_BACKEND_CATALOG=service).  "
             "This command path is not yet ported to the public catalog API — "

src/nexus/commands/doctor.py

@@ -593,11 +593,31 @@ def _run_trim_telemetry(days: int) -> None:
     # .trimSearchTelemetry / .trimHookFailures); only this call site never
     # routed to it. Same branch shape already used by _run_tier_writes below.
     if storage_backend_for("telemetry") == StorageBackend.SERVICE:
+        import httpx  # noqa: PLC0415 — deferred local import — avoids import-time cost / circular deps
+
         from nexus.db.t2.http_telemetry_store import HttpTelemetryStore  # noqa: PLC0415 — deferred local import — avoids import-time cost / circular deps
 
-        store = HttpTelemetryStore()
-        deleted_search = store.trim_search_telemetry(days=days)
-        deleted_hooks = store.trim_hook_failures(days=days)
+        try:
+            store = HttpTelemetryStore()
+            deleted_search = store.trim_search_telemetry(days=days)
+            deleted_hooks = store.trim_hook_failures(days=days)
+        except (httpx.HTTPError, RuntimeError) as exc:
+            # Same class as _report_aspect_queue_service above (review
+            # 2026-07-25): store CONSTRUCTION resolves the endpoint and raises
+            # ServiceEndpointUnresolvableError (a RuntimeError, not an
+            # httpx error) when it cannot. This branch originally had NO
+            # handling at all, so an unresolvable endpoint or a transport blip
+            # crashed `nx doctor --trim` outright.
+            #
+            # Reporting nothing trimmed would be the false-clean this whole
+            # commit exists to remove — say UNKNOWN and exit non-zero so a
+            # scripted caller cannot mistake a failed trim for a completed one.
+            click.echo(
+                f"Error: telemetry trim unavailable ({exc}). Nothing was "
+                "trimmed and the live retention state is UNKNOWN.",
+                err=True,
+            )
+            raise click.exceptions.Exit(2)
     else:
         from nexus.db.t2.telemetry import Telemetry  # noqa: PLC0415 — deferred local import — avoids import-time cost / circular deps
 
@@ -644,7 +664,17 @@ def _report_aspect_queue_service() -> None:
         q = HttpAspectQueue()
         pending = q.pending_count()
         failed = q.list_failed()
-    except httpx.HTTPError as exc:
+    except (httpx.HTTPError, RuntimeError) as exc:
+        # RuntimeError is NOT redundant with httpx.HTTPError: constructing the
+        # store resolves the endpoint, and an unresolvable one raises
+        # ServiceEndpointUnresolvableError, which subclasses RuntimeError and
+        # NOT httpx.HTTPError (review 2026-07-25). Catching only the transport
+        # error let a missing supervisor lease / absent NX_SERVICE_TOKEN escape
+        # as a traceback out of `nx doctor` — turning a health check into a
+        # crash, in the very commit whose purpose was to stop doctor from
+        # misreporting health. The console twin
+        # (console/routes/health.py::_collect_aspect_queue_data_service) had
+        # this right; this call site did not.
         click.echo(
             f"aspect_extraction_queue: service backend unreachable ({exc}). "
             "Queue depth UNKNOWN — not reporting a count.",

src/nexus/db/embed_migrate.py

@@ -124,7 +124,13 @@ def detect_stale_local_collections(
         if not count:
             continue
         try:
-            col = db._client_for(name).get_collection(name)
+            # nexus-d4ac1 / nexus-at2ff: was ``db._client_for(name)``, which only
+            # the T3Database facade has — a production HttpVectorClient handle
+            # would AttributeError here, get swallowed by the except below, and
+            # report ZERO stale collections. A false-clean, not a crash. Fixed
+            # while the module is still dead code (no src/ caller today) because
+            # the trap arms itself the moment anyone wires it up.
+            col = db.get_collection(name)
         except Exception:  # noqa: BLE001 — best-effort probe; skip collection on any failure
             continue
         try:
@@ -173,10 +179,12 @@ def collection_source_paths(
     or — post RDR-108 Phase 3 — only ``chunk_text_hash``, resolved via the
     catalog chash->doc_id manifest. Returns ``(source_paths, sourceless_ids)``.
     """
-    # Raw client handle: we only read metadata via ``.get()``, so we must
-    # not attach the active EF (it would conflict with the collection's
-    # persisted EF config for cross-embedder names — the whole point here).
-    col = db._client_for(name).get_collection(name)
+    # Read metadata via ``.get()`` only — no active EF attached (it would
+    # conflict with the collection's persisted EF config for cross-embedder
+    # names, which is the whole point here).
+    # nexus-d4ac1 / nexus-at2ff: was ``db._client_for(name)`` (test-facade-only
+    # attribute); the handle exposes get_collection directly on both backends.
+    col = db.get_collection(name)
     source_paths: set[str] = set()
     sourceless: list[str] = []
     offset = 0

src/nexus/db/migrations.py

@@ -2701,8 +2701,16 @@ def backfill_projection(t3_db: Any, taxonomy: Any) -> None:
             continue
         t0 = time.monotonic()
         try:
+            # nexus-at2ff (review sweep 2026-07-25): was ``t3_db._client``.
+            # `nx upgrade` builds t3_db via make_t3() -> HttpVectorClient, which
+            # has no ``_client``; only the T3Database test facade does. The
+            # AttributeError was caught by the per-collection `except Exception`
+            # below and printed "SKIPPED (AttributeError)" for EVERY collection,
+            # so this backfill silently did nothing on any service-mode install.
+            # HttpTaxonomyStore.project_against takes the handle as its
+            # ``chroma_client`` argument (its own docstring says so, nexus-9pqoj).
             result = taxonomy.project_against(
-                src, targets, t3_db._client, threshold=0.85,
+                src, targets, t3_db, threshold=0.85,
             )
             assignments = result.get("chunk_assignments", [])
             # RDR-077 RF-3: 3-tuple (doc_id, topic_id, raw_cosine_similarity).
@@ -2743,13 +2751,34 @@ def backfill_projection(t3_db: Any, taxonomy: Any) -> None:
     # 'attempted' counts may exceed actual writes). Lock taken per storage
     # review I-1 — this runs in a long upgrade context where concurrent
     # writes on the same connection are plausible.
-    with taxonomy._lock:
-        actual_written = taxonomy.conn.execute(
-            "SELECT COUNT(*) FROM topic_assignments WHERE assigned_by = 'projection'"
-        ).fetchone()[0]
+    # nexus-at2ff: this raw read is the SECOND half of the same breakage, and
+    # fixing only the first leaves the step still unable to pass. On a
+    # service-backed taxonomy store RawHandleGuardMixin raises AttributeError
+    # here, OUTSIDE the per-collection except above, so the whole upgrade step
+    # failed — and upgrade.py then printed "will retry on next `nx upgrade`"
+    # for a retry that could never succeed.
+    #
+    # The count is a progress/audit figure, not a correctness input: it exists
+    # only because INSERT OR IGNORE dedupes, so `attempted` can overstate
+    # `written`. In service mode we report the attempted count and SAY it is
+    # attempted rather than inventing a precise number we cannot obtain — a
+    # silently-wrong "actual" would be the false-clean class.
+    # The raw ``taxonomy._lock`` / ``taxonomy.conn`` count that used to live here
+    # is DELETED rather than guarded. It re-read the table to turn "attempted"
+    # into "actually stored" (INSERT OR IGNORE dedupes, so attempted can
+    # overstate) — a progress-line nicety, never a correctness input.
+    #
+    # Guarding it with has_raw_access would have worked but required two new
+    # self-service raw-access overrides, GROWING a census that may only shrink,
+    # and adding two more raw-SQLite sites for RDR-158 P4 to delete later.
+    # Removing it costs one decimal place in a stderr line and takes the site
+    # off the retirement backlog instead of adding to it.
+    # (Comment deliberately avoids the literal override token: the NO-SQLITE
+    # scanner is a dumb regex by design, so even PROSE naming it counts.)
     print(  # noqa: T201 — long-running upgrade progress to stderr; structured event emitted via log.info below
-        f"  Backfill complete: {actual_written} projection assignments stored "
-        f"({total_assigned} attempted) in {total_elapsed:.1f}s across {n} collections.",
+        f"  Backfill complete: {total_assigned} projection assignments attempted "
+        f"in {total_elapsed:.1f}s across {n} collections. (Attempted, not stored: "
+        f"INSERT OR IGNORE dedupes, so the stored count may be lower.)",
         file=sys.stderr,
     )
     log.info("backfill_projection_complete",

src/nexus/db/t3_reidentify.py

@@ -142,7 +142,21 @@ def reidentify_collection(
         return result
 
     try:
-        col = t3._client_for(collection_name).get_collection(collection_name)
+        # nexus-at2ff sweep (2026-07-25): was ``t3._client_for(collection_name)
+        # .get_collection(...)``. `nx t3 reidentify` builds its handle via
+        # _make_t3_for_backfill() -> make_t3() -> HttpVectorClient, which has no
+        # ``_client_for`` — only the T3Database facade does, and that helper's
+        # own docstring says it is "patched in tests for isolation". So every
+        # collection errored with "'HttpVectorClient' object has no attribute
+        # '_client_for'" and the verb did nothing. Both handles expose
+        # get_collection directly.
+        #
+        # NOTE the structural blind spot this sat in: storage_boundary_lint's
+        # CLIENT_FOR_ALLOWLIST_PREFIXES allowlists ``._client_for`` by the FILE
+        # it appears in (src/nexus/db/), not by which handle arrives. A db/
+        # helper called from commands/ with a make_t3() handle is invisible to
+        # that lint by construction.
+        col = t3.get_collection(collection_name)
     except collection_not_found_errors():
         _log.info(
             "reidentify_collection_absent",