Sync ctx c61de90 (part 2)

GitHub commit: c61de902e8fdd2a4b2cfa061c5337a2fef078d0a

scripts/audit_backup.py

@@ -10,6 +10,14 @@ from pathlib import Path
 
 CLAUDE_HOME = Path(os.path.expanduser("~/.claude"))
 BACKUPS = CLAUDE_HOME / "backups"
+USAGE = """usage: python scripts/audit_backup.py [SNAPSHOT]
+
+Summarize a backup snapshot and flag expected ~/.claude files missing from it.
+
+Arguments:
+  SNAPSHOT  Optional backup snapshot directory. Defaults to the latest
+            directory under ~/.claude/backups.
+"""
 
 
 def latest_snapshot() -> Path:
@@ -17,8 +25,15 @@ def latest_snapshot() -> Path:
     return snaps[-1]
 
 
+def _snapshot_arg(argv: list[str]) -> Path:
+    if len(argv) > 1 and argv[1] in {"-h", "--help"}:
+        print(USAGE)
+        raise SystemExit(0)
+    return Path(argv[1]) if len(argv) > 1 else latest_snapshot()
+
+
 def main() -> int:
-    snap = Path(sys.argv[1]) if len(sys.argv) > 1 else latest_snapshot()
+    snap = _snapshot_arg(sys.argv)
     manifest = json.loads((snap / "manifest.json").read_text(encoding="utf-8-sig"))
 
     print(f"snapshot:  {snap}")

scripts/ci_classifier.py

@@ -28,6 +28,7 @@ DOCS_PATTERNS = (
     "graph/README.md",
     "LICENSE",
     "mkdocs.yml",
+    "qa/feature_status.csv",
     "requirements-docs.txt",
 )
 GRAPH_ARTIFACT_PATTERNS = (
@@ -115,30 +116,23 @@ def _is_graph_artifact_path(path: str) -> bool:
 
 
 def classify_paths(paths: Iterable[str]) -> dict[str, bool]:
-    files = [
-        normalized
-        for path in paths
-        if (normalized := _normalize_path(path))
-    ]
+    files = [normalized for path in paths if (normalized := _normalize_path(path))]
     ci_changed = any(_matches(path, (".github/workflows/**",)) for path in files)
     docs_changed = any(_matches(path, DOCS_PATTERNS) for path in files)
     graph_artifact_changed = any(_is_graph_artifact_path(path) for path in files)
     graph_only = bool(files) and all(_matches(path, ("graph/**",)) for path in files)
     return {
-        "browser_changed": ci_changed
-        or any(_matches(path, BROWSER_PATTERNS) for path in files),
+        "browser_changed": ci_changed or any(_matches(path, BROWSER_PATTERNS) for path in files),
         "ci_changed": ci_changed,
         "docs_changed": docs_changed,
         "docs_only": bool(files) and all(_matches(path, DOCS_PATTERNS) for path in files),
         "graph_artifact_changed": graph_artifact_changed,
         "graph_changed": any(_matches(path, ("graph/**",)) for path in files),
         "graph_only": graph_only,
-        "package_changed": ci_changed
-        or any(_matches(path, PACKAGE_PATTERNS) for path in files),
+        "package_changed": ci_changed or any(_matches(path, PACKAGE_PATTERNS) for path in files),
         "similarity_changed": ci_changed
         or any(_matches(path, SIMILARITY_PATTERNS) for path in files),
-        "source_changed": ci_changed
-        or any(_matches(path, SOURCE_PATTERNS) for path in files),
+        "source_changed": ci_changed or any(_matches(path, SOURCE_PATTERNS) for path in files),
         "telemetry_changed": ci_changed
         or any(_matches(path, TELEMETRY_PATTERNS) for path in files),
     }

scripts/no_mistakes_codex_env.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# no-mistakes agents run in a stripped-down environment. Keep ctx validation fast
+# by exposing the verified project Python toolchain and Codex-bundled ripgrep.
+default_ctx_python_bin="/tmp/ctx-verify-venv/bin"
+ctx_python_bin="${CTX_NO_MISTAKES_PYTHON_BIN:-${default_ctx_python_bin}}"
+codex_resources="${CTX_NO_MISTAKES_CODEX_RESOURCES:-/Applications/Codex.app/Contents/Resources}"
+real_codex="${CTX_NO_MISTAKES_REAL_CODEX:-${codex_resources}/codex}"
+
+is_trusted_python_bin() {
+  local bin_dir="$1"
+  local venv_dir="${bin_dir%/bin}"
+
+  [[ -d "${bin_dir}" && -x "${bin_dir}/python" ]] || return 1
+  [[ -O "${venv_dir}" && -O "${bin_dir}" ]] || return 1
+  [[ -z "$(find "${venv_dir}" "${bin_dir}" -prune -perm -022 -print -quit)" ]]
+}
+
+trusted_ctx_python_bin=""
+if [[ -n "${CTX_NO_MISTAKES_PYTHON_BIN:-}" ]]; then
+  trusted_ctx_python_bin="${ctx_python_bin}"
+elif is_trusted_python_bin "${ctx_python_bin}"; then
+  trusted_ctx_python_bin="${ctx_python_bin}"
+fi
+
+if [[ -n "${trusted_ctx_python_bin}" ]]; then
+  export PATH="${trusted_ctx_python_bin}:${codex_resources}:${PATH}"
+  if [[ -x "${trusted_ctx_python_bin}/python" ]]; then
+    export VIRTUAL_ENV="${VIRTUAL_ENV:-${trusted_ctx_python_bin%/bin}}"
+  fi
+else
+  export PATH="${codex_resources}:${PATH}"
+fi
+export PYTHONDONTWRITEBYTECODE="${PYTHONDONTWRITEBYTECODE:-1}"
+export PIP_DISABLE_PIP_VERSION_CHECK="${PIP_DISABLE_PIP_VERSION_CHECK:-1}"
+
+exec "${real_codex}" "$@"

scripts/tune_similarity_thresholds.py

@@ -1,6 +1,6 @@
 """
 tune_similarity_thresholds.py -- Sweep thresholds against the fixture corpus
-and print the precision/recall surface so we can pick sensible defaults.
+and print the precision/recall/F1 surface so we can pick sensible defaults.
 
 Run once after editing fixtures or changing the embedder; not part of CI.
 """
@@ -22,6 +22,14 @@ from ctx_config import cfg  # noqa: E402
 from intake_gate import compose_corpus_text  # noqa: E402
 
 FIXTURE_DIR = SRC_DIR / "tests" / "fixtures" / "similarity"
+USAGE = """usage: python scripts/tune_similarity_thresholds.py
+
+Sweep similarity thresholds against the fixture corpus and print precision,
+recall, F1, and confusion counts for candidate defaults.
+
+Requires the configured embedding backend. Use --help to show this message
+without loading the embedding model.
+"""
 
 
 @dataclass(frozen=True)
@@ -66,9 +74,31 @@ def _score(pair: _Pair, embedder, root: Path) -> float:
     return float(top[0].score) if top else 0.0
 
 
-def main() -> None:
+def _precision_recall_f1(
+    near_scores: list[tuple[str, float]],
+    negative_scores: list[tuple[str, float]],
+    threshold: float,
+) -> tuple[float, float, float, int, int, int]:
+    tp = sum(1 for _, score in near_scores if score >= threshold)
+    fn = len(near_scores) - tp
+    fp = sum(1 for _, score in negative_scores if score >= threshold)
+    recall = tp / (tp + fn) if (tp + fn) else 0
+    precision = tp / (tp + fp) if (tp + fp) else 0
+    f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) else 0
+    return precision, recall, f1, tp, fn, fp
+
+
+def main(argv: list[str] | None = None) -> int:
     import tempfile
 
+    args = sys.argv[1:] if argv is None else argv
+    if any(arg in {"-h", "--help"} for arg in args):
+        print(USAGE)
+        return 0
+    if args:
+        print(USAGE, file=sys.stderr)
+        return 2
+
     embedder = cfg.build_intake_embedder()
     near = _load("near_duplicates.jsonl")
     distinct = _load("distinct_pairs.jsonl")
@@ -83,14 +113,18 @@ def main() -> None:
     print("\n=== Near-duplicate scores (should be HIGH) ===")
     for pid, s in sorted(near_scores, key=lambda x: x[1]):
         print(f"  {pid}: {s:.4f}")
-    print(f"  min={min(s for _, s in near_scores):.4f} "
-          f"median={sorted(s for _, s in near_scores)[len(near_scores)//2]:.4f}")
+    print(
+        f"  min={min(s for _, s in near_scores):.4f} "
+        f"median={sorted(s for _, s in near_scores)[len(near_scores) // 2]:.4f}"
+    )
 
     print("\n=== Distinct scores (should be LOW) ===")
     for pid, s in sorted(distinct_scores, key=lambda x: -x[1])[:10]:
         print(f"  {pid}: {s:.4f}")
-    print(f"  max={max(s for _, s in distinct_scores):.4f} "
-          f"median={sorted(s for _, s in distinct_scores)[len(distinct_scores)//2]:.4f}")
+    print(
+        f"  max={max(s for _, s in distinct_scores):.4f} "
+        f"median={sorted(s for _, s in distinct_scores)[len(distinct_scores) // 2]:.4f}"
+    )
 
     print("\n=== Adversarial scores (should be LOW — precision traps) ===")
     for pid, s in sorted(adv_scores, key=lambda x: -x[1]):
@@ -100,15 +134,19 @@ def main() -> None:
     # Sweep: at each candidate near_dup threshold, compute P/R assuming a pair
     # is flagged iff top_score >= threshold.
     print("\n=== Threshold sweep (flag if score >= t) ===")
-    print(f"{'threshold':>10} {'recall':>8} {'precision':>10} {'TP':>4} {'FN':>4} {'FP':>4}")
+    print(
+        f"{'threshold':>10} {'recall':>8} {'precision':>10} {'f1':>8} {'TP':>4} {'FN':>4} {'FP':>4}"
+    )
     for t in [0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.82, 0.85, 0.88, 0.90, 0.93]:
-        tp = sum(1 for _, s in near_scores if s >= t)
-        fn = len(near_scores) - tp
-        fp = sum(1 for _, s in distinct_scores + adv_scores if s >= t)
-        recall = tp / (tp + fn) if (tp + fn) else 0
-        precision = tp / (tp + fp) if (tp + fp) else 0
-        print(f"{t:>10.2f} {recall:>8.3f} {precision:>10.3f} {tp:>4} {fn:>4} {fp:>4}")
+        precision, recall, f1, tp, fn, fp = _precision_recall_f1(
+            near_scores,
+            distinct_scores + adv_scores,
+            t,
+        )
+        print(f"{t:>10.2f} {recall:>8.3f} {precision:>10.3f} {f1:>8.3f} {tp:>4} {fn:>4} {fp:>4}")
+
+    return 0
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

src/ctx/__init__.py

@@ -10,6 +10,7 @@ Four delivery surfaces (pick what fits your integration):
   2. **Generic harness CLI** — drive any LLM against a task:
          ctx run --model openrouter/anthropic/claude-opus-4.7 \\
                  --task "fix the failing tests"
+     The same CLI is available through ``python -m ctx``.
 
   3. **Python library** — use from your own harness / tool:
          from ctx import recommend_bundle, graph_query, wiki_search

src/ctx/__main__.py

@@ -0,0 +1,7 @@
+"""Run the model-agnostic harness via ``python -m ctx``."""
+
+from ctx.cli.run import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/ctx/api.py

@@ -20,7 +20,8 @@ Four delivery paths, in increasing order of coupling to ctx:
 
 3. **Use ``ctx run`` directly.** The full harness-over-LiteLLM
    experience, no host-side code required. Good if you don't already
-   have a loop.
+   have a loop. ``python -m ctx run`` reaches the same CLI when the
+   console script is unavailable.
 
 4. **Use the LoopFlow adapter.** If another runner already owns
    plan/act/observe, call ``python -m ctx.adapters.loopflow`` or

src/ctx/cli/__init__.py

@@ -15,4 +15,6 @@ New CLIs (harness-facing, added H7):
   ctx run        - drive any model autonomously against a task
   ctx resume     - continue a previous session
   ctx sessions   - list / inspect sessions
+
+The package entrypoint ``python -m ctx`` delegates to the same harness CLI.
 """

src/ctx/telemetry/__init__.py

@@ -38,9 +38,7 @@ RETENTION_STATUS_SCHEMA_VERSION = "ctx.telemetry.retention_status.v1"
 DEFAULT_TELEMETRY_PATH = Path(os.path.expanduser("~/.ctx/telemetry/events.jsonl"))
 DEFAULT_EXPORT_PATH = Path(os.path.expanduser("~/.ctx/telemetry/exported-events.jsonl"))
 DEFAULT_METRICS_PATH = Path(os.path.expanduser("~/.ctx/telemetry/metrics.jsonl"))
-DEFAULT_METRICS_EXPORT_PATH = Path(
-    os.path.expanduser("~/.ctx/telemetry/exported-metrics.jsonl")
-)
+DEFAULT_METRICS_EXPORT_PATH = Path(os.path.expanduser("~/.ctx/telemetry/exported-metrics.jsonl"))
 DEFAULT_OTLP_LOGS_ENDPOINT = "http://localhost:4318/v1/logs"
 DEFAULT_OTLP_METRICS_ENDPOINT = "http://localhost:4318/v1/metrics"
 DEFAULT_PRIVACY_MODE = "local_redacted"
@@ -71,31 +69,38 @@ _DEFAULT_HISTOGRAM_BOUNDS = (
 )
 _PRIVATE_DIR_MODE = 0o700
 _PRIVATE_FILE_MODE = 0o600
-_RAW_VALUE_KEYS = frozenset({
-    "command",
-    "command_output",
-    "cwd",
-    "goal",
-    "input",
-    "model_response",
-    "output",
-    "path",
-    "prompt",
-    "query",
-    "raw_input",
-    "raw_prompt",
-    "repo",
-    "response",
-    "stderr",
-    "stdout",
-    "task",
-    "tool_args",
-    "tool_input",
-    "tool_output",
-})
+_RAW_VALUE_KEYS = frozenset(
+    {
+        "command",
+        "command_output",
+        "cwd",
+        "goal",
+        "input",
+        "model_response",
+        "output",
+        "path",
+        "paths",
+        "prompt",
+        "query",
+        "raw_input",
+        "raw_prompt",
+        "repo",
+        "response",
+        "stderr",
+        "stdout",
+        "task",
+        "tool_args",
+        "tool_input",
+        "tool_output",
+    }
+)
 _SCALAR_TYPES = (str, int, float, bool, type(None))
 
 
+def _raw_value_key_like(normalized_key: str) -> bool:
+    return normalized_key in _RAW_VALUE_KEYS or normalized_key.endswith(("_path", "_paths"))
+
+
 @dataclass(frozen=True)
 class TelemetryEvent:
     """One canonical ctx telemetry event."""
@@ -781,7 +786,9 @@ def _record_metric(
         print(f"ctx telemetry: failed to write metric ({type(exc).__name__})", file=sys.stderr)
         return None
     if settings["metric_export_enabled"]:
-        _export_recorded_metric(metric, settings=settings, source_path=target, trusted_root=trusted_root)
+        _export_recorded_metric(
+            metric, settings=settings, source_path=target, trusted_root=trusted_root
+        )
     return metric
 
 
@@ -1012,9 +1019,7 @@ def export_metrics(
             trusted_root=trusted_root,
         )
         checkpoint_after_metric_id = last_metric.metric_id
-        checkpoint_advanced = (
-            checkpoint_after_metric_id != pending.checkpoint_before_metric_id
-        )
+        checkpoint_advanced = checkpoint_after_metric_id != pending.checkpoint_before_metric_id
     status_path = _metric_export_status_path(
         settings,
         source_path=source_path,
@@ -1080,9 +1085,7 @@ def preview_metrics_export(
         include_exported=include_exported,
     )
     last_metric_id = (
-        pending.metrics[-1].metric_id
-        if pending.metrics
-        else pending.checkpoint_before_metric_id
+        pending.metrics[-1].metric_id if pending.metrics else pending.checkpoint_before_metric_id
     )
     status_path = _metric_export_status_path(
         settings,
@@ -1142,7 +1145,9 @@ def preview_export(
         trusted_root=trusted_root,
         include_exported=include_exported,
     )
-    last_event_id = pending.events[-1].event_id if pending.events else pending.checkpoint_before_event_id
+    last_event_id = (
+        pending.events[-1].event_id if pending.events else pending.checkpoint_before_event_id
+    )
     status_path = _export_status_path(
         settings,
         source_path=source_path,
@@ -1229,7 +1234,11 @@ def _ctx_version() -> str | None:
     try:
         return package_version("claude-ctx")
     except PackageNotFoundError:
-        return None
+        try:
+            from ctx import __version__
+        except (ImportError, AttributeError):
+            return None
+        return __version__ or None
 
 
 def _resolve_path(path: Path, *, trusted_root: Path | None = None) -> Path:
@@ -1288,9 +1297,7 @@ def _settings(config: Mapping[str, Any] | None) -> dict[str, Any]:
         "otlp_timeout_seconds": float(_mapping_get(otlp, "timeout_seconds", 5.0)),
         "otlp_service_name": str(_mapping_get(otlp, "service_name", "ctx")),
         "otlp_service_namespace": str(_mapping_get(otlp, "service_namespace", "ctx")),
-        "otlp_deployment_environment": str(
-            _mapping_get(otlp, "deployment_environment", "local")
-        ),
+        "otlp_deployment_environment": str(_mapping_get(otlp, "deployment_environment", "local")),
         "max_payload_keys": int(
             _mapping_get(limits, "max_payload_keys", _MAX_PAYLOAD_KEYS),
         ),
@@ -1342,9 +1349,7 @@ def _metric_settings(config: Mapping[str, Any] | None) -> dict[str, Any]:
         "otlp_timeout_seconds": float(_mapping_get(otlp, "timeout_seconds", 5.0)),
         "otlp_service_name": str(_mapping_get(otlp, "service_name", "ctx")),
         "otlp_service_namespace": str(_mapping_get(otlp, "service_namespace", "ctx")),
-        "otlp_deployment_environment": str(
-            _mapping_get(otlp, "deployment_environment", "local")
-        ),
+        "otlp_deployment_environment": str(_mapping_get(otlp, "deployment_environment", "local")),
         "histogram_bounds": _histogram_bounds(metrics),
         "max_payload_keys": int(
             _mapping_get(limits, "max_payload_keys", _MAX_PAYLOAD_KEYS),
@@ -1358,9 +1363,7 @@ def _metric_settings(config: Mapping[str, Any] | None) -> dict[str, Any]:
 def _retention_settings(config: Mapping[str, Any] | None) -> dict[str, Any]:
     raw = dict(config or _config_get("telemetry", {}) or {})
     raw_retention = raw.get("retention")
-    retention: Mapping[str, Any] = (
-        raw_retention if isinstance(raw_retention, Mapping) else {}
-    )
+    retention: Mapping[str, Any] = raw_retention if isinstance(raw_retention, Mapping) else {}
     events = retention.get("events")
     metrics = retention.get("metrics")
     return {
@@ -1387,16 +1390,8 @@ def _retention_policy(
     policy: Mapping[str, Any] = signal_policy if isinstance(signal_policy, Mapping) else {}
     raw_max_age_days = _mapping_get(policy, "max_age_days", None)
     raw_max_records = _mapping_get(policy, "max_records", None)
-    max_age_days = (
-        max(0, int(raw_max_age_days))
-        if raw_max_age_days not in (None, "")
-        else None
-    )
-    max_records = (
-        max(0, int(raw_max_records))
-        if raw_max_records not in (None, "")
-        else None
-    )
+    max_age_days = max(0, int(raw_max_age_days)) if raw_max_age_days not in (None, "") else None
+    max_records = max(0, int(raw_max_records)) if raw_max_records not in (None, "") else None
     return max_age_days, max_records
 
 
@@ -1590,9 +1585,7 @@ def _apply_retention_policy(
         else:
             kept.append(record)
     effective_max_records = (
-        max(max_records, min_keep_records)
-        if max_records is not None and max_records > 0
-        else None
+        max(max_records, min_keep_records) if max_records is not None and max_records > 0 else None
     )
     if effective_max_records is not None and len(kept) > effective_max_records:
         overflow = len(kept) - effective_max_records
@@ -1610,9 +1603,7 @@ def _rewrite_retention_file(
     drop_malformed: bool,
 ) -> None:
     lines: list[tuple[int, str]] = [
-        (record.index, record.raw_line)
-        for record in records
-        if record.index in kept_by_index
+        (record.index, record.raw_line) for record in records if record.index in kept_by_index
     ]
     if not drop_malformed:
         lines.extend(malformed_lines)
@@ -2469,7 +2460,9 @@ def _otlp_logs_payload(events: list[TelemetryEvent], settings: Mapping[str, Any]
                 "scopeLogs": [
                     {
                         "scope": {"name": "ctx.telemetry", "version": SCHEMA_VERSION},
-                        "logRecords": [_otlp_log_record(event, settings=settings) for event in events],
+                        "logRecords": [
+                            _otlp_log_record(event, settings=settings) for event in events
+                        ],
                     }
                 ],
             }
@@ -2494,8 +2487,7 @@ def _otlp_metrics_payload(
                     {
                         "scope": {"name": "ctx.telemetry", "version": METRIC_SCHEMA_VERSION},
                         "metrics": [
-                            _otlp_metric_record(metric, settings=settings)
-                            for metric in metrics
+                            _otlp_metric_record(metric, settings=settings) for metric in metrics
                         ],
                     }
                 ],
@@ -2639,10 +2631,7 @@ def _iso_to_unix_nanos(value: str) -> int:
 
 
 def _otlp_attributes(attributes: Mapping[str, Any]) -> list[dict[str, Any]]:
-    return [
-        {"key": key, "value": _otlp_value(value)}
-        for key, value in sorted(attributes.items())
-    ]
+    return [{"key": key, "value": _otlp_value(value)} for key, value in sorted(attributes.items())]
 
 
 def _otlp_value(value: Any) -> dict[str, Any]:
@@ -2679,8 +2668,8 @@ def _sanitize_payload(
         if secret_key_like(key):
             sanitized[key] = "[redacted]"
             continue
-        normalized = key.lower().replace("-", "_")
-        if privacy_mode == DEFAULT_PRIVACY_MODE and normalized in _RAW_VALUE_KEYS:
+        normalized = key.lower().replace("-", "_").replace(".", "_")
+        if privacy_mode == DEFAULT_PRIVACY_MODE and _raw_value_key_like(normalized):
             if value is not None:
                 sanitized[f"{key}_hash"] = hash_identifier(str(value), salt=hash_salt)
             continue

src/embedding_backend.py

@@ -14,7 +14,10 @@ backend-agnostic. Both implementations return L2-normalised float32 vectors
 so downstream cosine similarity is a single dot product.
 
 Backend selection is centralised in ``get_embedder(name)``; callers pass the
-string from ``ctx_config.intake.embedding.backend``. Heavy imports
+string from ``ctx_config.intake.embedding.backend``. For the Ollama backend,
+``intake.embedding.base_url`` wins first, then ``OLLAMA_URL`` when set, then
+``http://localhost:11434``. An empty or malformed ``OLLAMA_URL`` is treated as
+configuration and rejected instead of silently falling back. Heavy imports
 (``sentence_transformers``, ``requests``) happen lazily inside the concrete
 class to keep the module cheap to import.
 
@@ -150,9 +153,7 @@ class OllamaEmbedder:
     def __post_init__(self) -> None:
         parsed = urlparse(self.base_url)
         if parsed.scheme not in ("http", "https"):
-            raise ValueError(
-                f"base_url scheme must be http or https: {self.base_url!r}"
-            )
+            raise ValueError(f"base_url scheme must be http or https: {self.base_url!r}")
         host = (parsed.hostname or "").lower()
         if not host:
             raise ValueError(f"base_url has no host: {self.base_url!r}")
@@ -197,9 +198,7 @@ class OllamaEmbedder:
             except Exception as exc:
                 raise OllamaEmbedderError(idx, str(exc)) from exc
             if "embedding" not in payload:
-                raise OllamaEmbedderError(
-                    idx, f"response missing 'embedding' key: {payload!r}"
-                )
+                raise OllamaEmbedderError(idx, f"response missing 'embedding' key: {payload!r}")
             rows.append(payload["embedding"])
         return _l2_normalize(np.asarray(rows, dtype=np.float32))
 
@@ -222,12 +221,14 @@ def get_embedder(
     if key in ("", "sentence-transformers", "st", "sbert"):
         return SentenceTransformerEmbedder(model_name=model or DEFAULT_ST_MODEL)
     if key in ("ollama", "ol"):
+        configured_base_url = (
+            os.environ["OLLAMA_URL"] if "OLLAMA_URL" in os.environ else DEFAULT_OLLAMA_URL
+        )
         return OllamaEmbedder(
             model_name=model or DEFAULT_OLLAMA_MODEL,
-            base_url=base_url or os.environ.get("OLLAMA_URL", DEFAULT_OLLAMA_URL),
+            base_url=base_url or configured_base_url,
             allow_remote=allow_remote,
         )
     raise ValueError(
-        f"unknown embedding backend {backend!r}; expected "
-        f"'sentence-transformers' or 'ollama'"
+        f"unknown embedding backend {backend!r}; expected 'sentence-transformers' or 'ollama'"
     )