security-knowledge-os 0.2.0__tar.gz → 0.3.0__tar.gz

{security_knowledge_os-0.2.0 → security_knowledge_os-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: security-knowledge-os
-Version: 0.2.0
+Version: 0.3.0
 Summary: Deterministic security assessment engine + knowledge retrieval + optional LLM assistance
 License-Expression: Apache-2.0
 License-File: LICENSE

{security_knowledge_os-0.2.0 → security_knowledge_os-0.3.0}/PUBLICATION_MANIFEST.md

@@ -1,16 +1,16 @@
-# Publication Manifest — Security Knowledge OS v0.2.0
+# Publication Manifest — Security Knowledge OS v0.3.0
 
 Snapshot of what the first public push contains. Generated for the pre-publication
 review; regenerate with `git ls-files` after any change.
 
-- Commit: `316e8c6` (v0.2.0: Update Packs + `skos scan mcp`; PyPI 0.1.0 was `a7f463d`)
+- Commit: `2627b44` (v0.3.0: whole-agent capability labels for the `capgraph` pack; 0.2.0 was `316e8c6`, 0.1.0 `a7f463d`)
 - History: rewritten once on 2026-09-20, before first publication, to normalise author/committer identity to the
   GitHub no-reply address (one commit message also scrubbed of a local account name). Every commit's tree is
   identical before and after, so the reviewed content is the published content; commit hashes cited in the
   review records below are the **pre-rewrite** ones - see `docs/history-rewrite-map.md` for old -> new.
 - Licence: **Apache-2.0** (`LICENSE`, `NOTICE`, `pyproject.toml`)
-- Tracked files: **242**
-- Tests: **943** items (942 pass, 1 skip = JA-R02)
+- Tracked files: **244**
+- Tests: **978** items (977 pass, 1 skip = JA-R02)
 - `scripts/preflight.py`: **PASS** (now also verifies the documented
   quickstart `pip install -e` command installs every declared extra,
   pins `constraints.txt`, AND passes `--build-constraint constraints.txt`
@@ -798,6 +798,21 @@ review; regenerate with `git ls-files` after any change.
   empty value in a URL, or a flag with no value, is reported as a literal
   secret - a false positive).
 
+  **v0.3.0 capability-label review** (2026-09-29, scoped to `master..2627b44`:
+  `app/adapters/capgraph.py`, the `skos scan mcp --client` / `_agent.yaml` /
+  `capability-labels.json` changes in `app/adapters/mcp_config.py` and
+  `app/cli.py`, plus the separate data-only `capgraph` pack source). Codex,
+  three rounds, each CHANGES-REQUIRED and fixed: round 1 (`5b6a115`) 10
+  findings (4 HIGH: package impersonation via launcher path or environment,
+  server identity bound to file names, browser and memory profiles claiming
+  absent capabilities); round 2 (`75f146f`) residuals plus 2 new (HIGH: a pack
+  failing verification treated as not installed); round 3 (`2cc494b`) one
+  residual HIGH (`pnpm exec`/`yarn exec` run a local command) and one LOW
+  (npx server arguments). Fixed in `970a1b1`, reviewed by Antigravity:
+  **PASS-with-nits**; the test nit was added in `2627b44`. The medium-rule
+  suppression Codex flagged as G10 is documented in the pack README (engine
+  policy), not changed.
+
 ## Tracked files by area
 
 Per-area counts below were last verified at round 2 (commit `bcd9519`) and
@@ -807,8 +822,8 @@ check enforces (total tracked files, total tests) are kept current above.
 
 | area | files | notes |
 | --- | --- | --- |
-| `app/` | 76 (.py) | engine, models, policy, retrieval, reviewer, llm, storage, eval, cli, main, packs (Update Pack manager), adapters (MCP config scan) |
-| `tests/` | 86 | 55 test modules + fixtures |
+| `app/` | 77 (.py) | engine, models, policy, retrieval, reviewer, llm, storage, eval, cli, main, packs (Update Pack manager), adapters (MCP config scan, capability labels) |
+| `tests/` | 87 | 56 test modules + fixtures |
 | `knowledge/` | 24 | 14 public KUs + `private/` skeleton (README + 2 `.gitkeep`) + category `.gitkeep`s |
 | `rules/` | 13 | 7 rule YAMLs + category `.gitkeep`s |
 | `safe_tests/` | 4 | 4 vetted templates |

{security_knowledge_os-0.2.0 → security_knowledge_os-0.3.0}/app/__init__.py

@@ -1,3 +1,3 @@
 """Security Knowledge OS - deterministic security assessment engine."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

security_knowledge_os-0.3.0/app/adapters/capgraph.py

@@ -0,0 +1,219 @@
+"""Capability labels for one agent, derived from its MCP client config.
+
+Each server gets six labels - ``untrusted_input``, ``sensitive_read``,
+``egress``, ``exec``, ``write``, ``persistence`` - valued ``True`` /
+``False`` / ``None`` (unknown). A label is ``True`` only when the config
+(package identity, launch options) establishes it, and ``False`` only when
+the absence is established the same way; a server the scanner does not know
+keeps every label ``None``. Tool descriptions are never used: they can lie.
+
+The agent is the union of its servers and the client's own built-in tools,
+combined with a three-valued OR (any ``True`` -> ``True``; all ``False`` ->
+``False``; otherwise ``None``). When the client is not declared, nothing is
+known about its built-in tools, so an aggregate ``False`` becomes ``None``.
+
+The result feeds the ``capgraph`` Update Pack (``extensions.capgraph``) and
+is also written as ``capability-labels.json`` for runtime enforcement (for
+example a gateway that decides trust from the same labels). Only server
+names from the config appear in either output (project paths are replaced by
+opaque ids), never configuration values.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+
+from app.adapters.mcp_config import ServerScan
+
+LABELS = ("untrusted_input", "sensitive_read", "egress", "exec", "write", "persistence")
+# Written to extensions.capgraph; every key becomes a ``capgraph_<key>`` fact.
+FACT_KEYS = (*LABELS, "flow_gated", "egress_gated")
+SCHEMA = "capgraph/v0"
+AGENT_FILE_STEM = "_agent"  # reserved: no server may be written under this name
+CLIENTS = ("claude-code", "none")
+
+Label = bool | None
+
+
+@dataclass(frozen=True)
+class _Caps:
+    """What a known package can do beyond the MCP scanner's own facts."""
+
+    sensitive_read: Label = None
+    persistence: Label = None
+    write_scope: str | None = None  # "fs" = the scanner's fs_scope
+    # the scanner's "no shell" does not mean "no code": a browser runs
+    # JavaScript on the pages it drives
+    exec_unknown: bool = False
+
+
+# By exact (ecosystem, package) identity, like the scanner's own profiles.
+_KNOWN: dict[tuple[str, str], _Caps] = {
+    # scope-dependent: see _labels()
+    ("npm", "@modelcontextprotocol/server-filesystem"): _Caps(None, True, "fs"),
+    # private repositories/messages behind the token; pushes can change CI
+    ("npm", "@modelcontextprotocol/server-github"): _Caps(True, True, "remote"),
+    ("npm", "@modelcontextprotocol/server-gitlab"): _Caps(True, True, "remote"),
+    ("npm", "@modelcontextprotocol/server-slack"): _Caps(True, None, "remote"),
+    # a browser reaches intranet pages and the host's services, submits forms
+    # and can store content that is loaded again later (Codex capgraph G03)
+    ("npm", "@modelcontextprotocol/server-puppeteer"): _Caps(None, None, "remote", True),
+    ("npm", "@playwright/mcp"): _Caps(None, None, "remote", True),
+    ("npm", "@modelcontextprotocol/server-brave-search"): _Caps(False, False, "none"),
+    # what it stores is loaded into later sessions; what it holds - and where
+    # the file is - is not visible (Codex capgraph G04)
+    ("npm", "@modelcontextprotocol/server-memory"): _Caps(None, True, None),
+    ("npm", "@wonderwhy-er/desktop-commander"): _Caps(True, True, "root"),
+    # fetch can reach localhost and intranet URLs
+    ("pypi", "mcp-server-fetch"): _Caps(None, False, "none"),
+    ("pypi", "mcp-server-git"): _Caps(None, None, "project"),
+    ("pypi", "mcp-server-time"): _Caps(False, False, "none"),
+}
+
+# Built-in tools of an agent client, by --client name. "none" declares a
+# client without built-in tools (e.g. a custom agent that only uses MCP).
+_CLIENTS: dict[str, dict[str, Label]] = {
+    # Bash, Read/Edit/Write, WebFetch/WebSearch
+    "claude-code": {
+        "untrusted_input": True, "sensitive_read": True, "egress": True,
+        "exec": True, "write": True, "persistence": True,
+    },
+}
+
+
+@dataclass
+class ServerLabels:
+    name: str  # the scan's file stem (used in notes and file names)
+    server: str  # exact server name in the config
+    scope: str  # "global" or "project-<id>"
+    labels: dict[str, Label]
+    write_scope: str | None
+
+
+@dataclass
+class AgentLabels:
+    client: str | None
+    servers: list[ServerLabels]
+    labels: dict[str, Label] = field(default_factory=dict)
+    contributors: dict[str, list[str]] = field(default_factory=dict)
+
+    def facts(self) -> dict[str, Label]:
+        """The ``extensions.capgraph`` block. The gates (``flow_gated``,
+        ``egress_gated``) are not visible in a config: they are left for the
+        operator and asked when a combination they guard applies."""
+        return {**self.labels, "flow_gated": None, "egress_gated": None}
+
+    def notes(self) -> list[str]:
+        out = []
+        if self.client is None:
+            out.append(
+                "client not declared (--client): its built-in tools are unknown, so no label "
+                "is claimed absent"
+            )
+        for label in LABELS:
+            if self.contributors.get(label):
+                out.append(f"{label} <- {', '.join(self.contributors[label])}")
+        return out
+
+
+def _labels(scan: ServerScan) -> ServerLabels:
+    f = scan.facts
+    labels: dict[str, Label] = {
+        "untrusted_input": f.get("ingests_untrusted_content"),
+        "sensitive_read": None,
+        "egress": f.get("can_send"),
+        "exec": f.get("shell_exec"),
+        "write": f.get("can_write"),
+        "persistence": None,
+    }
+    write_scope: str | None = None
+    caps = None
+    if scan.package is not None and scan.ecosystem is not None:
+        caps = _KNOWN.get((scan.ecosystem, scan.package))
+    if caps is not None:
+        labels["sensitive_read"] = caps.sensitive_read
+        labels["persistence"] = caps.persistence
+        write_scope = caps.write_scope
+        if caps.exec_unknown:
+            labels["exec"] = None
+        if caps.write_scope == "fs":
+            scope = f.get("fs_scope")
+            write_scope = scope if scope in ("project", "home", "root") else None
+            # the whole home directory or / holds credentials and private files;
+            # a project directory may (.env) but that is not visible here
+            labels["sensitive_read"] = True if scope in ("home", "root") else None
+    if labels["exec"] is True and f.get("sandboxed") is not True:
+        # an unsandboxed shell reads and writes anything the user can
+        labels["sensitive_read"] = labels["write"] = labels["persistence"] = True
+        write_scope = write_scope or "root"
+    if labels["write"] is False and labels["exec"] is False and labels["persistence"] is None:
+        labels["persistence"] = False
+    return ServerLabels(scan.name, scan.server, scan.scope, labels, write_scope)
+
+
+def _or(values: list[Label]) -> Label:
+    if any(v is True for v in values):
+        return True
+    if values and all(v is False for v in values):
+        return False
+    return None
+
+
+def agent_labels(scans: list[ServerScan], client: str | None) -> AgentLabels:
+    if client is not None and client not in CLIENTS:
+        raise ValueError(f"unknown client {client!r} (known: {', '.join(CLIENTS)})")
+    servers = [_labels(s) for s in scans]
+    builtin = _CLIENTS.get(client) if client else None
+    agent = AgentLabels(client, servers)
+    for label in LABELS:
+        values = [s.labels[label] for s in servers]
+        sources = [s.name for s in servers if s.labels[label] is True]
+        if builtin is not None:
+            values.append(builtin[label])
+            if builtin[label] is True:
+                sources.insert(0, f"client:{client}")
+        value = _or(values)
+        if value is False and client is None:
+            value = None
+        agent.labels[label] = value
+        agent.contributors[label] = sources
+    return agent
+
+
+def labels_json(agent: AgentLabels, source_name: str) -> str:
+    doc = {
+        "schema": SCHEMA,
+        "source": source_name,
+        "client": agent.client,
+        "agent": agent.labels,
+        "contributors": agent.contributors,
+        # identify a server by (scope, exact name) - the file stem is only a
+        # file name and may be renamed to stay unique (Codex capgraph G02)
+        "servers": [
+            {
+                "server": s.server, "scope": s.scope, "file": s.name,
+                "labels": s.labels, "write_scope": s.write_scope,
+            }
+            for s in agent.servers
+        ],
+    }
+    return json.dumps(doc, indent=2, ensure_ascii=False) + "\n"
+
+
+def agent_yaml(agent: AgentLabels, source_name: str) -> str:
+    import yaml
+
+    body = yaml.safe_dump(
+        {"name": f"agent:{source_name}", "extensions": {"capgraph": agent.facts()}},
+        sort_keys=False,
+        allow_unicode=True,
+    )
+    header = [
+        f"# generated by `skos scan mcp` from {source_name} (the whole agent: every server"
+        + (f" + client {agent.client}" if agent.client else "") + ")",
+        "# null = not established by the config. Answer what you can, then `skos assess` this"
+        " file.",
+    ]
+    header += [f"# note: {n}" for n in agent.notes()]
+    return "\n".join(header) + "\n" + body

{security_knowledge_os-0.2.0 → security_knowledge_os-0.3.0}/app/adapters/mcp_config.py

@@ -19,6 +19,7 @@ names - is ever written, printed, or placed in an error message.
 
 from __future__ import annotations
 
+import hashlib
 import ipaddress
 import json
 import posixpath
@@ -86,10 +87,12 @@ _KNOWN: dict[tuple[str, str], _Profile] = {
     ("npm", "@modelcontextprotocol/server-github"): _Profile(False, True, True, True),
     ("npm", "@modelcontextprotocol/server-gitlab"): _Profile(False, True, True, True),
     ("npm", "@modelcontextprotocol/server-slack"): _Profile(False, True, True, True),
-    ("npm", "@modelcontextprotocol/server-puppeteer"): _Profile(False, False, True, True),
+    # a browser can submit forms and change state on the sites it visits
+    ("npm", "@modelcontextprotocol/server-puppeteer"): _Profile(False, True, True, True),
     ("npm", "@modelcontextprotocol/server-brave-search"): _Profile(False, False, True, True),
-    ("npm", "@modelcontextprotocol/server-memory"): _Profile(False, True, False, False),
-    ("npm", "@playwright/mcp"): _Profile(False, False, True, True),
+    # what is stored may itself have come from outside content
+    ("npm", "@modelcontextprotocol/server-memory"): _Profile(False, True, False, None),
+    ("npm", "@playwright/mcp"): _Profile(False, True, True, True),
     ("npm", "@wonderwhy-er/desktop-commander"): _Profile(True, True, True, None, True),
     ("pypi", "mcp-server-fetch"): _Profile(False, False, True, True),
     ("pypi", "mcp-server-git"): _Profile(False, True, False, None, True),
@@ -129,10 +132,13 @@ class ConfigError(ValueError):
 
 @dataclass
 class ServerScan:
-    name: str
+    name: str  # file-safe, unique stem for this scan's outputs
     package: str | None
     facts: dict[str, Any] = field(default_factory=dict)
     notes: list[str] = field(default_factory=list)
+    ecosystem: str | None = None  # "npm" / "pypi" when the package is identified
+    server: str = ""  # the server's exact name in the config
+    scope: str = "global"  # "global" or "project-<id>" (an opaque id, never the path)
 
     def unknown(self) -> list[str]:
         return [k for k in FACT_KEYS if self.facts.get(k) is None]
@@ -226,7 +232,18 @@ def _launcher(command: str, args: list[str]) -> tuple[str, str | None, list[str]
     ecosystem: "npm" / "pypi" / "container" / "" (a plain command)."""
     base = PurePosixPath(command).name
     rest = list(args)
-    if base in ("pnpm", "yarn", "npm") and rest[:1] in (["dlx"], ["exec"]):
+    # `pnpm exec` / `yarn exec` run a LOCAL command: the name says nothing
+    # about a registry package (Codex capgraph review G01). `dlx` fetches one.
+    if base in ("pnpm", "yarn") and rest[:1] == ["dlx"]:
+        base, rest = "npx", rest[1:]
+    elif base in ("pnpm", "yarn") and rest[:1] == ["exec"]:
+        return "npm", None, []
+    # npm itself keeps parsing its options after the package unless they
+    # follow `--` (a trailing --registry=... replaces what runs); npx inserts
+    # that `--` before the first positional argument, so for npx the
+    # arguments after the package belong to the server (Codex G01/G13).
+    npm_exec = base == "npm" and rest[:1] == ["exec"]
+    if npm_exec:
         base, rest = "npx", rest[1:]
     # Only the launcher options below are understood. Anything else - a
     # registry/index override, `-p/--from` naming a different package than
@@ -238,7 +255,13 @@ def _launcher(command: str, args: list[str]) -> tuple[str, str | None, list[str]
                 continue
             if arg.startswith("-"):
                 return "npm", None, []
-            return "npm", arg, rest[i + 1 :]
+            after = rest[i + 1 :]
+            if not npm_exec:
+                return "npm", arg, after
+            sep = after.index("--") if "--" in after else len(after)
+            if any(a.startswith("-") for a in after[:sep]):
+                return "npm", None, []
+            return "npm", arg, after[:sep] + after[sep + 1 :]
         return "npm", None, []
     if base in ("uvx", "pipx"):
         if base == "pipx":
@@ -384,13 +407,33 @@ def _fs_scope(paths: list[str]) -> str | None:
     return None  # pragma: no cover
 
 
-def scan_server(label: str, cfg: object, taken: set[str]) -> ServerScan:
+def _launch_uncertain(command: str, env: dict[str, Any]) -> str | None:
+    """Why the configured launcher may not run the package it names, or None.
+
+    A launcher given by path is whatever that file is, and environment
+    variables other than credentials (NODE_OPTIONS, npm_config_registry,
+    PYTHONPATH, LD_PRELOAD, ...) can change what actually runs, so the
+    package is then not identified and no capability is inferred from it
+    (Codex capgraph review G01)."""
+    if command != PurePosixPath(command).name or "\\" in command:
+        return "the launcher is given by path; the package is not identified"
+    if any(re.search(_SECRET_NAME, k) is None for k in env):
+        return (
+            "environment variables other than credentials can change what runs; "
+            "the package is not identified"
+        )
+    return None
+
+
+def scan_server(label: str, cfg: object, taken: set[str], *, server: str | None = None,
+                scope: str = "global") -> ServerScan:
     name = _safe_name(label, taken)
     if not isinstance(cfg, dict):
         raise ConfigError(f"server {name!r}: entry must be an object")
     facts: dict[str, Any] = {k: None for k in FACT_KEYS}
     notes: list[str] = []
     package: str | None = None
+    identified: str | None = None
     secret_seen = False
     token_seen = False
     url = cfg.get("url")
@@ -408,11 +451,11 @@ def scan_server(label: str, cfg: object, taken: set[str]) -> ServerScan:
         except ValueError:
             # The exception text can quote the URL (and credentials in it).
             raise ConfigError(f"server {name!r}: 'url' is not a valid URL") from None
-        scope = _host_scope(host)
-        if scope == "loopback":
+        reach = _host_scope(host)
+        if reach == "loopback":
             notes.append("reached via loopback; the server's own listen address is not visible")
         else:
-            facts["bind_scope"] = scope  # reachable at least from there
+            facts["bind_scope"] = reach  # reachable at least from there
         if has_userinfo:
             secret_seen = token_seen = True
         if any(re.search(_SECRET_NAME, k) for k in query_keys):
@@ -427,18 +470,26 @@ def scan_server(label: str, cfg: object, taken: set[str]) -> ServerScan:
             notes.append(
                 "the client sends credentials; whether the server REQUIRES them is not visible"
             )
-        if url.startswith("http://") and scope not in (None, "loopback"):
+        if url.startswith("http://") and reach not in (None, "loopback"):
             notes.append("remote server over plain http (no TLS)")
     elif isinstance(cfg.get("command"), str):
         facts["transport"] = "stdio"
         args = _str_list(cfg.get("args"), f"server {name!r}: 'args'")
-        ecosystem, spec, rest = _launcher(cfg["command"], args)
+        uncertain = _launch_uncertain(
+            cfg["command"], _str_dict(cfg.get("env"), f"server {name!r}: 'env'")
+        )
+        if uncertain is None:
+            ecosystem, spec, rest = _launcher(cfg["command"], args)
+        else:
+            notes.append(uncertain)
+            ecosystem, spec, rest = "", None, args
         if ecosystem == "container":
             facts["sandboxed"], facts["version_pinned"], extra = _container(rest)
             notes += extra
         elif spec is not None:
             package, pinned = _identity(ecosystem, spec)
             if package is not None:
+                identified = ecosystem
                 facts["version_pinned"] = pinned
                 facts["third_party"] = not (
                     (ecosystem == "npm" and package.startswith(_FIRST_PARTY_NPM_SCOPE))
@@ -471,13 +522,25 @@ def scan_server(label: str, cfg: object, taken: set[str]) -> ServerScan:
     facts["token_scope"] = None
     if not token_seen:
         notes.append("no credential recognised in the config (this does not prove there is none)")
-    return ServerScan(name, package, facts, notes)
+    return ServerScan(
+        name, package, facts, notes, identified, label if server is None else server, scope
+    )
+
+
+def project_id(project: str) -> str:
+    """An opaque, stable id for a ``projects.<path>`` entry: outputs must not
+    carry the project path (Codex capgraph review G05). Whoever knows the path
+    can recompute it."""
+    # 128 bits: two project paths must never share an id (Codex capgraph G02)
+    return "project-" + hashlib.sha256(project.encode("utf-8")).hexdigest()[:32]
 
 
-def load_config(path: Path) -> list[tuple[str, object]]:
-    """``[(label, server config)]`` from the top-level ``mcpServers`` and, for
-    ``~/.claude.json``, every ``projects.<path>.mcpServers``. Labels may
-    repeat; scan_config() makes them unique, so no server is ever dropped."""
+def load_config(path: Path) -> list[tuple[str, str, object]]:
+    """``[(scope, server name, server config)]`` from the top-level
+    ``mcpServers`` (scope ``global``) and, for ``~/.claude.json``, every
+    ``projects.<path>.mcpServers`` (scope ``project-<id>``). Names may repeat
+    across scopes; scan_config() gives each a unique file stem, so no server
+    is ever dropped."""
     try:
         with path.open("rb") as fh:
             raw = fh.read(MAX_CONFIG_BYTES + 1)
@@ -491,25 +554,39 @@ def load_config(path: Path) -> list[tuple[str, object]]:
         raise ConfigError("config is not valid UTF-8 JSON") from None
     if not isinstance(data, dict):
         raise ConfigError("config must be a JSON object")
-    servers: list[tuple[str, object]] = []
+    servers: list[tuple[str, str, object]] = []
     top = data.get("mcpServers")
     if isinstance(top, dict):
-        servers += [(str(k), v) for k, v in top.items()]
+        servers += [("global", str(k), v) for k, v in top.items()]
     projects = data.get("projects")
     if isinstance(projects, dict):
         for project, pdata in projects.items():
             inner = pdata.get("mcpServers") if isinstance(pdata, dict) else None
             if isinstance(inner, dict):
-                label = PurePosixPath(str(project)).name or "project"
-                servers += [(f"{label}.{k}", v) for k, v in inner.items()]
+                pid = project_id(str(project))
+                servers += [(pid, str(k), v) for k, v in inner.items()]
     if not servers:
         raise ConfigError("no MCP servers found (expected 'mcpServers')")
+    identities = [(scope, name) for scope, name, _ in servers]
+    if len(set(identities)) != len(identities):
+        # (scope, name) is how outputs identify a server; never let two share it
+        raise ConfigError("two servers share the same scope and name")
     return servers
 
 
+# File stems the CLI writes next to the per-server inputs.
+RESERVED_NAMES = frozenset({"_agent"})
+
+
 def scan_config(path: Path) -> list[ServerScan]:
-    taken: set[str] = set()
-    return [scan_server(label, cfg, taken) for label, cfg in load_config(path)]
+    taken: set[str] = set(RESERVED_NAMES)
+    return [
+        scan_server(
+            name if scope == "global" else f"{scope}.{name}", cfg, taken,
+            server=name, scope=scope,
+        )
+        for scope, name, cfg in load_config(path)
+    ]
 
 
 def assessment_yaml(scan: ServerScan, source_name: str) -> str: