@@ -40,7 +40,8 @@ deleted). For callers:
 
 - `2xx`: the namespace is complete;
 - any other outcome, including a lost connection: retry the same request; a
-  `400 Namespace already exists` on the retry means the earlier attempt did complete.
+  `400 Namespace already exists` on the retry means the earlier attempt did complete. (Once
+  the configuration is persisted, the creation finishes even if the client has gone away.)
 
 In single-namespace mode (`--disable-namespaces`) creating the default namespace is a
 configuration upsert and always succeeds, except with a `dump_url`: a dump can only be imported
 
@@ -263,7 +263,7 @@ The reservation is the cache entry's lock, but moka knows nothing about that loc
 
 Fix, in three parts:
 
-- **Pin.** `NamespaceStoreInner::in_flight: Mutex<HashMap<NamespaceName, NamespaceEntry>>`. `Reservation::acquire` (create, fork) and `reset` pin the locked entry; `load_namespace` consults the map *before* `try_get_with` and waits on the pinned entry instead of loading. If the entry ends up empty — the operation failed, or published elsewhere — the lookup falls through: `NamespaceDoesntExist` if the metastore no longer knows the name, otherwise the regular cache path. Unpin happens after the config removal (abort) or after the namespace is visible (publish), so no lookup can slip into a lazy load in between. `destroy` consults the map too.
+- **Pin.** `NamespaceStoreInner::in_flight: Mutex<HashMap<NamespaceName, NamespaceEntry>>`. `Reservation::acquire` (create, fork) and `reset` pin the locked entry; `load_namespace` consults the map *before* `try_get_with` and waits on the pinned entry instead of loading. If the entry ends up empty — the operation failed, or published elsewhere — the lookup falls through: `NamespaceDoesntExist` if the metastore no longer knows the name, otherwise the regular cache path. Unpin happens after the config removal (abort) or after the namespace is visible (publish), so no lookup can slip into a lazy load in between. `destroy` consults the map too. The pin is claimed **before** the entry is locked (`NamespaceStore::claim`, under the `in_flight` mutex), so the name is pinned at every moment its entry is locked: the listener never waits on the lock inline, and a second operation finds the pin and waits for the holder instead of reserving a fresh entry for the same name. An attempt dropped before it got the lock releases its claim (`PinClaim`). `create` consults the metastore before claiming anything, so an existing namespace is rejected without its readers ever seeing a pending writer.
 - **Non-blocking eviction listener.** The listener spawns the shutdown on its own task and returns immediately, so maintenance never waits for an operation in progress.
 - **Publish into a fresh entry when evicted.** `NamespaceStore::install` checks (by `Arc::ptr_eq`) that the locked entry is still the cache's entry for the name; if not, the namespace goes into a fresh entry and the orphaned one stays empty, so the spawned listener finds nothing to shut down and waiters fall through to the cache. Used by `create`, `fork` and `reset`.
 
@@ -297,6 +297,20 @@ Reviewers (correctness, architecture, testing, operations) plus a manual pass fo
 
 LOW items closed in the follow-up commit: `publish` keeps the guard inside the reservation across `install`'s awaits, so a cancellation there undoes the creation instead of leaking the pin; `remove_incomplete_marker` stats before taking the blocking-pool hop (every cold load passes through it); a failure to remove the marker after publish is logged at `error`; `FreshDir`'s log is `info` (every failed create, including client errors, passes through it); `acquire` logs when it has to wait; store-level `aborted_creation_is_undone` test (`JoinHandle::abort` mid-import); the restart test drops the first server before starting the second; the unmarked-directory test asserts the outcome.
 
+### Second review (2026-10-22, after the rebase onto #56 and the restack on the release branch)
+
+| Severity | Finding | Fix |
+|---|---|---|
+| MED | A request dropped inside `publish` (moka's `insert` awaits after putting the entry in the map) left the namespace installed while `Reservation::drop` discarded its row and directory: `create` ⇒ 400, everything else ⇒ 404, until eviction. | `publish` runs in its own task: past the commit point the creation completes without the request. |
+| MED | The pin was claimed after the lock. In the locked-but-unpinned window the eviction listener waited on the lock inline, under moka's key lock, which `install`'s `insert` needs ⇒ deadlock for that name. After an abort, a third `create` could reserve a fresh entry for the same name ⇒ two creations on one directory. | `claim` pins before locking, waits for a holder, releases the claim on cancellation; `reset` uses it too. |
+| LOW–MED | `create` of an existing namespace write-locked its entry before "already exists"; async-lock prefers writers, so new readers waited (for the whole fork when the namespace was a fork source). | Metastore check before touching the entry. |
+| LOW | A creation (or reset) past its last shutdown check could install after `shutdown` had collected the entries. | `shut_down_if_stopped` after publish and after `reset`'s install. |
+| LOW | `destroy` took the pinned *or* the cached entry; a namespace just installed into a fresh entry was left to the eviction listener. | Both entries are taken; `install` drops a fresh entry whose record a `destroy` removed between its check and its insert. |
+| LOW | A panic in the spawned publish task was only logged; the caller returned 200 for a namespace the task's `Drop` had undone. | `publish` returns the error. |
+| LOW | `sweep` stopped at a regular file in `dbs/` (`<file>/.incomplete` ⇒ ENOTDIR). | Files skipped. |
+
+Accepted: the eviction listener reads the pin once, when moka creates it; a claim that starts and finishes between that read and the listener's first poll (nanoseconds) still waits inline. Noted, out of scope: `connection/program.rs` calls `MetaStore::handle` for `ATTACH`, which registers a config for a nonexistent name (pre-existing).
+
 Also closed: the marker and its directory entry are fsynced on creation (`mark_incomplete`), so the marker is durable before anything else in the directory can be; `checkpoint` no longer mints an empty cache entry for an unloaded namespace (the pre-existing source of the same wedge); `ForkTask::fork` only removes a failed fork's destination if it carries the marker.
 
 Not changed: after an *abort* the (empty) cache entry stays until a lookup heals it or the cache evicts it — it counts toward capacity but is never served; a metastore rebuilt from the filesystem (`destroy_on_error` + `allow_recover_from_fs`) in the milliseconds between a namespace's flush and its unmark would skip that namespace. Bottomless is not used in our deployment and this change is untested with it.
 
@@ -133,6 +133,11 @@ pub(crate) async fn sweep(base: &Path, meta_store: &MetaStore) -> std::io::Resul
         return Ok(());
     };
     for entry in entries.flatten() {
+        // Only directories can be namespaces; `<file>/.incomplete` would fail with ENOTDIR
+        // and end the sweep.
+        if !entry.file_type()?.is_dir() {
+            continue;
+        }
         if !entry.path().join(INCOMPLETE_MARKER).try_exists()? {
             continue;
         }
@@ -223,9 +228,15 @@ mod test {
         create_marked_dir(&known).unwrap();
         let unmarked = base.join("dbs").join("unmarked");
         std::fs::create_dir_all(&unmarked).unwrap();
+        // A stray file is skipped, not an error that ends the sweep (`<file>/.incomplete`
+        // would fail with ENOTDIR). Named to sort before the directories.
+        let stray = base.join("dbs").join("a-stray-file");
+        std::fs::write(&stray, b"junk").unwrap();
 
         sweep(base, &store).await.unwrap();
 
+        assert!(stray.exists());
+
         assert!(!crashed.exists());
         assert!(
             known.join(INCOMPLETE_MARKER).exists(),