@@ -233,8 +233,9 @@ def _capture_windows(*, consequence: str) -> dict[str, str] | None:
     upper-case names ``os.environ`` gives them on Windows, which is the spelling
     every reader of this capture asks for.
 
-    ``None`` when neither store can be read, which is the "capture failed"
-    signal the caller falls back on.
+    ``None`` when neither store can be read, or when a stored Path cannot be
+    expanded (a cyclic, too deeply nested or oversized reference): either is
+    the "capture failed" signal the caller falls back on.
     """
     import winreg
 
 
@@ -1176,12 +1176,13 @@ def _note_menu_re_measured(snapshot: Any, name: str) -> None:
 def capabilities_wanted(cfg: Any) -> bool:
     """Does this acp entry lack a fresh, complete capability record?
 
-    The same four cases the boot backfill re-measures: no snapshot, one whose
-    launch config has changed, one written before the model menu was recorded,
-    or one of raven's own whose menu came back empty -- that last one bounded as
-    ``_own_row_missing_its_menu`` bounds it. A row with a complete record keeps
-    it -- a connect must not spend a handshake re-measuring what is already
-    known.
+    Four cases: no snapshot, one whose launch config has changed, one written
+    before the model menu was recorded, or one of raven's own whose menu came
+    back empty -- that last one bounded as ``_own_row_missing_its_menu`` bounds
+    it. A recorded failure, a credential refusal included, is not one of them;
+    the boot backfill re-measures those as well as these four. A row with a
+    complete record keeps it -- a connect must not spend a handshake re-measuring
+    what is already known.
     """
     snapshot = acp_snapshot_for(cfg)
     if snapshot is None or snapshot.stale or not getattr(snapshot, "model_menu_measured", True):
@@ -1222,6 +1223,16 @@ def _test_record(snapshot: Any, previous: Any) -> Any:
     )
 
 
+def _measured_at(snapshot: Any) -> int | None:
+    """When the record's verdict was measured; ``None`` for no record.
+
+    Every measurement stamps its own time (``_test_record`` carries it over), and
+    a modes relearn keeps the stamp it found, so a changed stamp means a newer
+    verdict and nothing else does.
+    """
+    return None if snapshot is None else getattr(snapshot, "measured_at_ms", 0)
+
+
 _SCHEDULED = False
 """One auto-verify per process. Manual Test runs and probe=true listings are
 peer paths to this backfill, not causes to run it again."""
@@ -1336,7 +1347,9 @@ async def _verify_missing_snapshots(manager: Any, rows: list[Any], *, configured
     once at boot. After the run the table is refreshed so the rows rebuilt at
     startup pick up the snapshots this task just recorded -- the alternative is
     a roster that reports an agent stateful and dispatches it stateless until
-    the next restart or hot-apply.
+    the next restart or hot-apply. The newest measurement wins: a row measured
+    while its handshake was in flight -- a manual Test, a connect -- keeps that
+    verdict, whatever the handshake returned.
     """
     from raven.acp_client.capabilities import SnapshotStore, verify_agent
 
@@ -1380,11 +1393,22 @@ async def _verify_missing_snapshots(manager: Any, rows: list[Any], *, configured
                 continue
             result = await verify_agent(cfg, **_launch_kw(cfg))
             _note_menu_re_measured(result, name)
+            # Read again with nothing awaited between here and the write: the
+            # handshake held the row for up to the ready timeout. A measurement
+            # recorded meanwhile -- a manual Test, a connect -- is newer evidence
+            # than this one and stands. A dispatch relearning the agent's modes
+            # measures nothing and keeps the stamp, so it does not stop this
+            # write, and a failure below is kept over the re-read record, modes
+            # included.
+            current = acp_snapshot_for(cfg)
+            if _measured_at(current) != _measured_at(snapshot):
+                logger.info("acp agent {!r}: auto-verify {} superseded by a newer measurement", name, result.status)
+                continue
             # Replace an old failure with what this attempt actually measured.
             # Failed rows are retried next boot, so a timeout is not a permanent
             # verdict. A formerly working row still keeps its old capabilities.
             if result.status == "ready" or getattr(result, "needs_auth", False) or failed_before:
-                record = _test_record(result, snapshot) if snapshot is not None and result.status != "ready" else result
+                record = _test_record(result, current) if current is not None and result.status != "ready" else result
                 store.record(record)
                 recorded = True
             logger.info("acp agent {!r}: auto-verify {}", name, result.status)
 
@@ -1,20 +1,45 @@
-"""Choose existing config key spellings without letting null aliases hide values."""
+"""Choose the config key spelling the loaders read, so a write updates it in place."""
 
 from collections.abc import Mapping
 from typing import Any
 
 from pydantic.alias_generators import to_camel, to_snake
 
 
-def key_as_written(node: Mapping[str, Any], name: str) -> str:
-    """Prefer a non-null spelling, then a present null spelling, then ``name``.
+def key_as_written(node: Mapping[str, Any], name: str, *, top_level: bool = False, exact: bool = False) -> str:
+    """The spelling of ``name`` already in ``node`` that the loader reads, else ``name``.
 
-    Extension loading skips null blocks, so a null alias must not hide the
-    block it reads. False, zero and other non-null values still reach the
-    caller's validation rather than being replaced as if they were absent.
+    The config models accept every key as camelCase or snake_case, so a write
+    has to land on the spelling being read or it grows a second key beside it.
+    Which spelling is read depends on where the key sits:
+
+    - Below the top level pydantic reads every key. It takes the camelCase
+      alias whenever it is present, null or not, and the snake_case name only
+      when the alias is absent, so the first spelling present is the one read.
+      ``name`` is tried first, so a key present exactly as written wins; a
+      schema field is passed as its alias, the spelling pydantic tries first.
+    - At the top level ``load_raven_config`` drops a null extension block
+      before pydantic sees it, so a non-null spelling is the one read there and
+      a null one only when nothing else is present. False, zero and other
+      non-null values still count, so they reach the caller's validation.
+    - ``exact`` is for a segment that is not a field at all: the caller names a
+      *map entry* (a provider, a channel, an MCP server), and the map is read by
+      the key itself. Folding there would reach a different entry that happens
+      to be a spelling of the same word -- ``foo_bar`` and ``fooBar`` are two
+      MCP servers, and a write aimed at one disabling the other.
+      ``providers`` is the exception the caller keeps tolerant: its runtime
+      reader folds spellings through ``names_same_provider``, so exactness
+      there would update a section nothing reads.
+
+    ``exact`` is only consulted for a name the node does not carry as written:
+    a caller spelling an entry the way the file already files it lands on that
+    key either way.
     """
+    if exact:
+        return name
     spellings = (name, to_camel(name), to_snake(name))
-    for spelling in spellings:
-        if spelling in node and node[spelling] is not None:
-            return spelling
+    if top_level:
+        for spelling in spellings:
+            if node.get(spelling) is not None:
+                return spelling
     return next((spelling for spelling in spellings if spelling in node), name)
@@ -35,6 +35,7 @@
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from enum import StrEnum
+from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
@@ -783,6 +784,47 @@ def find(path: str) -> tuple[Setting, list[str]] | None:
     return None
 
 
+@lru_cache(maxsize=1024)
+def _wildcard_indexes(path: str) -> frozenset[int]:
+    """The positions in ``path`` that stand for a map entry rather than a field.
+
+    Asked of the longest catalog entry whose path is a *prefix* of this one, not
+    of a full match: the catalog carries ``tools.mcpServers.*.enabled`` and the
+    tool may not write ``tools.mcpServers.fooBar.command``, but a map entry is
+    named the same way however deep inside it a path reaches. The binding is a
+    property of the segment, so it is read before the rest of the path is known.
+
+    A path with no catalog entry anywhere along it (an extension section, a
+    second-level sub-agent field) has no wildcard to find, and the tolerant rule
+    that was there before is what reads it. The catalog is the only thing that
+    knows a segment was named by the caller, so it is asked rather than guessed
+    from the shape of the name.
+
+    Cached on the path: the catalog is a module constant, so the answer cannot
+    change while the process runs, and ``lookup`` is called once per leaf on
+    every settings read. Uncached, this walked the 95 catalog entries once per
+    prefix -- 48us a call against the 22us the walk itself costs, on a path a
+    page reload repeats for every row it draws.
+    """
+    parts = path.split(".")
+    wildcards: frozenset[int] = frozenset()
+    for end in range(1, len(parts) + 1):
+        found = find(".".join(parts[:end]))
+        if found is not None:
+            pattern = found[0].path.split(".")
+            wildcards = frozenset(index for index, part in enumerate(pattern) if part == "*")
+    return wildcards
+
+
+def _provider_bound(path: str) -> bool:
+    """Whether a wildcard in ``path`` binds a provider name.
+
+    ``providers`` is the one map whose reader folds spellings, so it is the one
+    map where a segment naming an entry keeps the tolerant rule.
+    """
+    return path.split(".", 1)[0] == "providers"
+
+
 def section_of(path: str) -> Section | None:
     for section in SECTIONS:
         if section.name == path:
@@ -1424,11 +1466,12 @@ def read_raw(config_path: Path | None = None) -> dict[str, Any]:
 
 def lookup(data: dict[str, Any], path: str) -> tuple[bool, Any]:
     """``(present, value)`` for ``path`` in a raw config dict, either spelling."""
+    wildcards = _wildcard_indexes(path) if not _provider_bound(path) else frozenset()
     node: Any = data
-    for part in path.split("."):
+    for index, part in enumerate(path.split(".")):
         if not isinstance(node, dict):
             return False, None
-        key = _spelled(node, part)
+        key = _spelled(node, part, top_level=node is data, exact=index in wildcards)
         if key not in node:
             return False, None
         node = node[key]
@@ -1559,13 +1602,17 @@ def remove_value(path: str, *, config_path: Path | None = None) -> Any:
 def _mutate(path: str, value: Any, *, remove: bool, config_path: Path | None) -> Any:
     target = config_path or get_config_path()
     parts = path.split(".")
+    # The segments standing for a map entry, which the file's own key names:
+    # see ``_wildcard_indexes``. Read once, outside the retry, since the
+    # catalog does not depend on the file's contents.
+    wildcards = _wildcard_indexes(path) if not _provider_bound(path) else frozenset()
 
     def _apply(_text: str | None) -> tuple[str | None, Any]:
         data = read_raw_or_raise(target) if target.exists() else {}
         before = copy.deepcopy(data)
         node = data
-        for part in parts[:-1]:
-            key = _spelled(node, part)
+        for index, part in enumerate(parts[:-1]):
+            key = _spelled(node, part, top_level=node is data, exact=index in wildcards)
             child = node.get(key)
             if child is None:
                 if remove:
@@ -1574,7 +1621,7 @@ def _apply(_text: str | None) -> tuple[str | None, Any]:
             if not isinstance(child, dict):
                 raise ValueError(f"{path}: {key} is not an object in config.json")
             node = child
-        leaf = _spelled(node, parts[-1])
+        leaf = _spelled(node, parts[-1], top_level=node is data, exact=len(parts) - 1 in wildcards)
         previous = node.get(leaf)
         if remove:
             if leaf not in node:
 
@@ -243,7 +243,7 @@ def set_skill_blocked(
 
     def _apply(_text: str | None) -> tuple[str | None, tuple[list[str], bool]]:
         data = read_raw_or_raise(path)
-        sf_key = key_as_written(data, "skillForge")
+        sf_key = key_as_written(data, "skillForge", top_level=True)
         section = data.get(sf_key)
         if section is None:
             section = data[sf_key] = {}