witan-code 0.24.0__tar.gz → 0.25.0__tar.gz

{witan_code-0.24.0 → witan_code-0.25.0}/.gitignore

@@ -26,7 +26,7 @@ build/
 *.egg-info/
 # omnigraph binary downloaded by hatch_build.py — not committed
 _bin/
-# omnigraph cluster state (populated by `omnigraph cluster import`)
+# omnigraph cluster state (populated by `omnigraph cluster apply`)
 __cluster/
 # The witan UI bundle, written by `npm run build` in mcp/servers/witan/ui/.
 # A build output, so not committed — hatch's `artifacts` setting in that

{witan_code-0.24.0 → witan_code-0.25.0}/CHANGELOG.md

@@ -8,6 +8,32 @@ a MINOR bump may include breaking changes).
 
 <!-- scriv-insert-here -->
 
+## [0.25.0] - 2026-10-15
+
+### Changed
+
+- `witan-code cleanup` no longer defaults to `--keep 10`. From omnigraph 0.12
+  `--keep` counts graph commits per live branch, not versions per table, so
+  that default would cut a store to its last ten writes. With neither bound
+  it now keeps the last 30 days, as the Stop hook does. The help text
+  describes both bounds in graph commits. `--older-than` on its own
+  no longer adds an implicit `--keep 10`.
+- The refusal for a shared cluster graph notes that from omnigraph 0.12
+  compaction is also refused while the server holds the cluster's `serve`
+  lock.
+
+- Requires witan-core 0.41 or later, the first release on omnigraph 0.13.
+  Every deployed omnigraph server is on 0.13 and refuses a client that does
+  not send `Omnigraph-Http-Api: 0.13`.
+
+### Fixed
+
+- `reap-views` ages a graph's views concurrently, `WITAN_CODE_VIEW_SURVEY_WORKERS` at a time (default 8; `1` is serial). Ageing a view is one `commit list --branch` that returns its whole reachable history, and serially production's 309-view bridge graph took 327s on its own, pushing the reaper CronJob past its 600s deadline; 8 workers take it to 50s. Each graph now also prints a `surveying views` line before its survey, so a job killed mid-sweep shows which graph it was on.
+
+- A cluster graph that is not served is recognised on omnigraph 0.13, whose
+  404 says `graph not found` without the quoted id. It was reported as an
+  unreachable cluster.
+
 ## [0.24.0] - 2026-10-02
 
 ### Added

{witan_code-0.24.0 → witan_code-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: witan-code
-Version: 0.24.0
+Version: 0.25.0
 Summary: witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)
 Project-URL: Homepage, https://github.com/mitodl/agent-kit/tree/main/mcp/servers/witan-code
 Project-URL: Repository, https://github.com/mitodl/agent-kit
@@ -26,7 +26,7 @@ Requires-Dist: tree-sitter-sql<0.4,>=0.3
 Requires-Dist: tree-sitter-typescript<0.24,>=0.23
 Requires-Dist: tree-sitter-yaml<0.8,>=0.7
 Requires-Dist: tree-sitter<0.26,>=0.25
-Requires-Dist: witan-core[cli,observability,remote,sentry]<1,>=0.40
+Requires-Dist: witan-core[cli,observability,remote,sentry]<1,>=0.41
 Provides-Extra: tasks
 Requires-Dist: fastmcp-tasks<5,>=4; extra == 'tasks'
 Description-Content-Type: text/markdown
@@ -584,7 +584,9 @@ graph):
   instead.
 - `cleanup [--store PATH] [--bridge] [--keep N] [--older-than DUR] --yes` —
   reclaim disk by GC'ing old Lance versions (**destructive**; requires
-  `--yes`).
+  `--yes`). `--keep N` retains the newest N graph commits of every live
+  branch (omnigraph 0.12+; versions per table on 0.11); with neither bound it
+  keeps the last 30 days.
 - `checkpoint` — opportunistically compact the current repo's store and the
   bridge store if due (see [Hooks](#hooks)); registered as the `Stop` hook,
   not usually run by hand.

{witan_code-0.24.0 → witan_code-0.25.0}/README.md

@@ -551,7 +551,9 @@ graph):
   instead.
 - `cleanup [--store PATH] [--bridge] [--keep N] [--older-than DUR] --yes` —
   reclaim disk by GC'ing old Lance versions (**destructive**; requires
-  `--yes`).
+  `--yes`). `--keep N` retains the newest N graph commits of every live
+  branch (omnigraph 0.12+; versions per table on 0.11); with neither bound it
+  keeps the last 30 days.
 - `checkpoint` — opportunistically compact the current repo's store and the
   bridge store if due (see [Hooks](#hooks)); registered as the `Stop` hook,
   not usually run by hand.

{witan_code-0.24.0 → witan_code-0.25.0}/docs/BRANCH_INDEXING.md

@@ -222,6 +222,8 @@ date, owner, or size. Two rules follow:
   ago — reaping it would race the indexer that just created it.
 
 The window is `WITAN_CODE_VIEW_MAX_IDLE_DAYS` (default 14; `0` disables).
+Ageing a view is one `commit list` per view, so the sweep ages
+`WITAN_CODE_VIEW_SURVEY_WORKERS` views at once (default 8; `1` is serial).
 Idleness is not abandonment: a branch parked past the window and picked back up
 loses its view, not its work, and the next index rebuilds it. Reporting is the
 default and `--apply` deletes, because the window is the one input nothing

{witan_code-0.24.0 → witan_code-0.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "witan-code"
-version = "0.24.0"
+version = "0.25.0"
 description = "witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -170,7 +170,13 @@ dependencies = [
     # `witan_core.cli.report_install` only prints `InstallResult.prerequisites`
     # from 0.40.0. It reads the field with getattr, so 0.39 imports and runs —
     # and silently drops the warning.
-    "witan-core[cli,remote,observability,sentry]>=0.40,<1",
+    #
+    # ★ >=0.41 IS A COMPATIBILITY FLOOR: 0.41.0 pins omnigraph 0.13 (storage
+    # format 14) and sends `Omnigraph-Http-Api: 0.13`. Every deployed server
+    # is on 0.13, which answers a request without that header with `400
+    # api_contract_mismatch`, so 0.40 imports and runs, then fails on the
+    # first read of a shared code graph.
+    "witan-core[cli,remote,observability,sentry]>=0.41,<1",
     "fastmcp>=4,<5",
     "cyclopts>=4,<6",
     # [targets.<name>] override models (config.py) — also transitively pulled
@@ -253,7 +259,7 @@ testpaths = ["tests"]
 packages = ["witan_code"]
 
 [tool.bumpversion]
-current_version = "0.24.0"
+current_version = "0.25.0"
 allow_dirty = true
 
 [[tool.bumpversion.files]]

{witan_code-0.24.0 → witan_code-0.25.0}/tests/test_maintenance.py

@@ -231,6 +231,37 @@ def test_cli_optimize_and_cleanup(tmp_path, capsys):
     assert "Cleaned up" in capsys.readouterr().out
 
 
+def test_cli_cleanup_with_no_bound_keeps_the_hooks_window(
+    tmp_path, capsys, monkeypatch
+):
+    """From omnigraph 0.12 `--keep` counts graph commits, so a default of
+    `--keep 10` would cut a store to its last ten writes. No bound means the
+    age window the Stop hook already uses."""
+    from witan_code import cli as cli_module
+    from witan_code import maintenance
+
+    store = tmp_path / "s.omni"
+    store.mkdir()
+    calls = []
+
+    class _Client:
+        def cleanup(self, **kwargs):
+            calls.append(kwargs)
+
+    monkeypatch.setattr(cli_module, "_maintenance_client", lambda _ref: _Client())
+
+    cli_module.cleanup(store=str(store))
+    assert f"newer than {maintenance.CLEANUP_OLDER_THAN}" in capsys.readouterr().out
+    assert calls == []
+
+    cli_module.cleanup(store=str(store), yes=True)
+    cli_module.cleanup(store=str(store), keep=3, yes=True)
+    assert calls == [
+        {"keep": None, "older_than": maintenance.CLEANUP_OLDER_THAN},
+        {"keep": 3, "older_than": None},
+    ]
+
+
 @requires_omnigraph
 def test_cli_optimize_then_cleanup(tmp_path, capsys):
     from witan_code import cli as cli_module

{witan_code-0.24.0 → witan_code-0.25.0}/tests/test_reaper.py

@@ -10,6 +10,8 @@ branch's own last write is recoverable from `commit list --branch` via
 identically, so it is asserted rather than mocked.
 """
 
+import threading
+import time
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -110,6 +112,27 @@ def test_a_malformed_window_is_an_error_not_a_default(monkeypatch):
         reaper_module.max_idle_days()
 
 
+def test_survey_workers_defaults_when_unset(monkeypatch):
+    monkeypatch.delenv(reaper_module.SURVEY_WORKERS_ENV_VAR, raising=False)
+    assert reaper_module.survey_workers() == reaper_module.DEFAULT_SURVEY_WORKERS
+
+
+def test_survey_workers_reads_the_env_var(monkeypatch):
+    monkeypatch.setenv(reaper_module.SURVEY_WORKERS_ENV_VAR, "3")
+    assert reaper_module.survey_workers() == 3
+
+
+def test_survey_workers_below_one_means_one(monkeypatch):
+    monkeypatch.setenv(reaper_module.SURVEY_WORKERS_ENV_VAR, "0")
+    assert reaper_module.survey_workers() == 1
+
+
+def test_malformed_survey_workers_is_an_error_not_a_default(monkeypatch):
+    monkeypatch.setenv(reaper_module.SURVEY_WORKERS_ENV_VAR, "lots")
+    with pytest.raises(ValueError, match="not a whole number of workers"):
+        reaper_module.survey_workers()
+
+
 # ── Authority ────────────────────────────────────────────────────────────────
 
 
@@ -439,3 +462,58 @@ def test_survey_skips_protected_views_entirely():
     )
     reaper_module.survey(client, now=NOW, max_idle=14)
     assert asked == ["act-alice/x"]
+
+
+def test_survey_ages_views_concurrently():
+    """One `commit list` per view, serially, is what outgrew the CronJob's
+    600s deadline on production's 309-view bridge graph. Each call waits at a
+    barrier that opens only once `workers` calls are in flight together, so a
+    serial survey breaks the barrier instead of passing."""
+    workers = 4
+    barrier = threading.Barrier(workers)
+
+    def last_write(name):
+        barrier.wait(timeout=5)
+        return NOW
+
+    client = SimpleNamespace(
+        list_branches=lambda: [f"act-alice/v{i}" for i in range(workers)],
+        branch_last_write=last_write,
+    )
+    ages, _ = reaper_module.survey(client, now=NOW, max_idle=14, workers=workers)
+    assert len(ages) == workers
+
+
+def test_a_concurrent_survey_pairs_each_view_with_its_own_last_write():
+    """Completion order must not leak into the result: a view aged against
+    its neighbour's timestamp is reaped, or kept, on someone else's evidence.
+    Earlier views finish last here, so an order-of-completion bug shows."""
+    names = [f"act-alice/v{i}" for i in range(6)]
+    idle_days = {name: 30.0 - i for i, name in enumerate(names)}
+
+    def last_write(name):
+        time.sleep(0.01 * (len(names) - names.index(name)))
+        return NOW - idle_days[name] * DAY
+
+    client = SimpleNamespace(list_branches=lambda: names, branch_last_write=last_write)
+    ages, _ = reaper_module.survey(client, now=NOW, max_idle=14, workers=3)
+
+    assert [a.view for a in ages] == names
+    assert {a.view: a.idle_days(NOW) for a in ages} == pytest.approx(idle_days)
+
+
+def test_a_concurrent_survey_still_raises_on_a_failed_read():
+    """The CLI turns a RuntimeError from the survey into `FAILED to survey`
+    and a non-zero exit. Running the reads on a pool must not swallow it."""
+
+    def last_write(name):
+        if name == "act-alice/bad":
+            raise RuntimeError("omnigraph commit list failed")
+        return NOW
+
+    client = SimpleNamespace(
+        list_branches=lambda: ["act-alice/ok", "act-alice/bad", "act-bob/ok"],
+        branch_last_write=last_write,
+    )
+    with pytest.raises(RuntimeError, match="commit list failed"):
+        reaper_module.survey(client, now=NOW, max_idle=14, workers=3)

{witan_code-0.24.0 → witan_code-0.25.0}/tests/test_store.py

@@ -632,15 +632,21 @@ class _NotFoundConnection:
     def request(self, method, path, body=None, headers=None):
         pass
 
+    #: 0.13.0 dropped the quoted id: `{"error": "graph not found", "code":
+    #: "not_found"}`, measured the same way on 2026-10-08.
+    error = "graph 'nosuch' not found"
+
     def getresponse(self):
+        _error = self.error
+
         class _Response:
             status = 404
             will_close = False
+            # Unstamped, as a 0.11.0 server's responses are.
+            headers = http_module.http.client.HTTPMessage()
 
             def read(self):
-                return json.dumps(
-                    {"error": "graph 'nosuch' not found", "code": "not_found"}
-                ).encode()
+                return json.dumps({"error": _error, "code": "not_found"}).encode()
 
             def getheader(self, _name, default=None):
                 return default
@@ -651,18 +657,20 @@ class _NotFoundConnection:
         pass
 
 
-def test_a_missing_cluster_graph_is_still_recognised_over_http(monkeypatch):
+@pytest.mark.parametrize("error", ["graph 'nosuch' not found", "graph not found"])
+def test_a_missing_cluster_graph_is_still_recognised_over_http(monkeypatch, error):
     """★ THE WORDING `_NOT_FOUND_RE` KEYS ON NOW ARRIVES FROM THE SERVER.
 
     `list_branches` was unconditionally a subprocess, so `_NOT_FOUND_RE` was
     tuned against what the CLI printed (see the comment above it). It is a
     `branch list` statement now, so a remote client takes the pooled transport
     and this discrimination runs on the HTTP body instead. If the server ever
-    stops quoting the id, every missing graph files as `ClusterUnreachable`
-    rather than `ClusterGraphMissing`, which is the exact confusion those two
-    types exist to prevent — and nothing else in the suite would notice,
+    stops quoting the id (0.13.0 did), every missing graph files as
+    `ClusterUnreachable` rather than `ClusterGraphMissing`, which is the exact
+    confusion those two types exist to prevent — and nothing else in the suite would notice,
     because every other probe test fakes the client.
     """
+    monkeypatch.setattr(_NotFoundConnection, "error", error)
     monkeypatch.setattr(http_module.http.client, "HTTPSConnection", _NotFoundConnection)
     monkeypatch.setattr(http_module.http.client, "HTTPConnection", _NotFoundConnection)
     monkeypatch.setenv("WITAN_CODE_SERVER", "https://omnigraph.test")

{witan_code-0.24.0 → witan_code-0.25.0}/witan_code/cli.py

@@ -680,7 +680,10 @@ def _resolve_store(store: str | None, *, bridge: bool = False):
     if ref.is_remote:
         print(
             f"{ref} is a shared cluster graph — compaction runs server-side "
-            "against the storage root, not from a client. Nothing to do here."
+            "against the storage root, not from a client. From omnigraph 0.12 "
+            "it is also refused while the server holds the cluster's `serve` "
+            "lock, so the data tier's maintenance job runs it in a stop "
+            "window. Nothing to do here."
         )
         return None
     if not ref.exists():
@@ -744,18 +747,21 @@ def cleanup(
     *,
     store: str | None = None,
     bridge: bool = False,
-    keep: int = 10,
+    keep: int | None = None,
     older_than: str | None = None,
     yes: bool = False,
 ) -> None:
     """Remove old Lance versions from a code-graph store (**destructive**).
 
     ``optimize`` compacts fragments but leaves old versions behind; this GCs
-    them, keeping the most recent ``keep`` versions per table (and/or those
-    newer than ``older_than``). From omnigraph 0.11 it is also the only thing
-    that reclaims the storage of deleted branches (``branches --prune``,
+    the ones no retained graph commit pins. A commit is retained when either
+    bound keeps it. From omnigraph 0.11 it is also the only thing that
+    reclaims the storage of deleted branches (``branches --prune``,
     ``reap-views --apply``). Irreversible, so it requires ``--yes``.
 
+    With neither bound given it keeps the last 30 days, the same policy the
+    Stop hook and the deployed maintenance job use.
+
     Parameters
     ----------
     store
@@ -763,24 +769,36 @@ def cleanup(
     bridge
         Clean the shared cross-repo bridge store instead.
     keep
-        Number of recent versions to keep per table.
+        Keep the newest N graph commits of every live branch, whatever
+        their age. (omnigraph 0.11 counted versions per table instead.)
     older_than
-        Also keep versions newer than this Go-style duration (e.g. 7d).
+        Keep every graph commit newer than this Go-style duration (e.g. 7d).
     yes
         Confirm the destructive operation (required to actually run).
     """
+    from . import maintenance
+
     ref = _resolve_store(store, bridge=bridge)
     if ref is None:
         return
+    if keep is None and older_than is None:
+        older_than = maintenance.CLEANUP_OLDER_THAN
+    kept = []
+    if keep is not None:
+        kept.append(
+            f"the {keep} newest graph commit(s) of every live branch "
+            "(version(s) per table on omnigraph 0.11)"
+        )
+    if older_than is not None:
+        kept.append(f"every graph commit newer than {older_than}")
+    policy = " and ".join(kept)
     if not yes:
         print(
-            f"cleanup is destructive — would keep the {keep} most recent "
-            f"version(s) per table"
-            + (f" and anything newer than {older_than}" if older_than else "")
-            + f" in {ref}.\nRe-run with --yes to proceed."
+            f"cleanup is destructive — would keep {policy} in {ref}.\n"
+            "Re-run with --yes to proceed."
         )
         return
-    print(f"Cleaning up {ref} (keep={keep}) …")
+    print(f"Cleaning up {ref} (keeping {policy}) …")
     _maintenance_client(ref).cleanup(keep=keep, older_than=older_than)
     print("Cleaned up.")
 
@@ -841,6 +859,7 @@ def reap_views(
         return
     try:
         idle = reaper_module.max_idle_days() if max_idle_days is None else max_idle_days
+        workers = reaper_module.survey_workers()
     except ValueError as exc:
         print(exc)
         raise SystemExit(1) from None
@@ -865,9 +884,18 @@ def reap_views(
 
     failed_graphs = 0
     for name, client in targets:
+        # Before the survey, not after: the report only prints once a graph is
+        # done, so a job killed mid-survey otherwise leaves no trace of which
+        # graph it was on.
+        print(f"{name}: surveying views", flush=True)
         try:
             report = reaper_module.reap(
-                client, graph=name, max_idle=idle, apply=apply, cfg=cfg
+                client,
+                graph=name,
+                max_idle=idle,
+                apply=apply,
+                cfg=cfg,
+                workers=workers,
             )
         except PermissionError as exc:
             print(exc)

{witan_code-0.24.0 → witan_code-0.25.0}/witan_code/reaper.py

@@ -45,6 +45,7 @@ from __future__ import annotations
 import os
 import time
 from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 
 from . import config as cfg_module
@@ -52,13 +53,16 @@ from . import views
 
 __all__ = [
     "DEFAULT_MAX_IDLE_DAYS",
+    "DEFAULT_SURVEY_WORKERS",
     "MAX_IDLE_ENV_VAR",
     "PROTECTED_VIEWS",
+    "SURVEY_WORKERS_ENV_VAR",
     "ReapReport",
     "ViewAge",
     "max_idle_days",
     "reap",
     "select_stale",
+    "survey_workers",
 ]
 
 MAX_IDLE_ENV_VAR = "WITAN_CODE_VIEW_MAX_IDLE_DAYS"
@@ -67,6 +71,16 @@ MAX_IDLE_ENV_VAR = "WITAN_CODE_VIEW_MAX_IDLE_DAYS"
 DEFAULT_MAX_IDLE_DAYS = 14.0
 """Long enough to cover a two-week vacation, short enough to bound sprawl."""
 
+SURVEY_WORKERS_ENV_VAR = "WITAN_CODE_VIEW_SURVEY_WORKERS"
+"""How many views to age at once. ``1`` ages them one after another."""
+
+DEFAULT_SURVEY_WORKERS = 8
+"""Measured against production's bridge graph (309 views, omnigraph 0.11):
+one at a time took 327s, 4 workers 85s, 8 workers 50s, and right after the
+8-worker run ``kubectl top`` read the 1-CPU omnigraph-server at 780m. Kept
+there rather than higher so the sweep leaves that server room for its other
+readers."""
+
 PROTECTED_VIEWS = frozenset({"main"})
 """Never reaped, whatever its age.
 
@@ -89,6 +103,20 @@ def max_idle_days() -> float:
     return max(value, 0.0)
 
 
+def survey_workers() -> int:
+    """The configured survey concurrency; anything below ``1`` means ``1``."""
+    raw = os.environ.get(SURVEY_WORKERS_ENV_VAR)
+    if raw is None or not raw.strip():
+        return DEFAULT_SURVEY_WORKERS
+    try:
+        value = int(raw)
+    except ValueError as exc:
+        raise ValueError(
+            f"{SURVEY_WORKERS_ENV_VAR}={raw!r} is not a whole number of workers"
+        ) from exc
+    return max(value, 1)
+
+
 @dataclass(frozen=True)
 class ViewAge:
     """One branch view and when it was last written."""
@@ -152,21 +180,46 @@ class ReapReport:
 
 
 def survey(
-    client, *, now: float, max_idle: float
+    client, *, now: float, max_idle: float, workers: int | None = None
 ) -> tuple[list[ViewAge], list[ViewAge]]:
     """Age every view on ``client``'s graph; return ``(all, stale)``.
 
     Read-only — the dry-run half of :func:`reap`, and what the CLI prints when
     it has not been told to delete anything.
     """
+    names = [name for name in client.list_branches() if name not in PROTECTED_VIEWS]
+    workers = survey_workers() if workers is None else workers
+    last_writes = _last_writes(client, names, workers=workers)
     ages = [
-        ViewAge(view=name, last_write=client.branch_last_write(name))
-        for name in client.list_branches()
-        if name not in PROTECTED_VIEWS
+        ViewAge(view=name, last_write=last_write)
+        for name, last_write in zip(names, last_writes, strict=True)
     ]
     return ages, select_stale(ages, now=now, max_idle=max_idle)
 
 
+def _last_writes(client, names: list[str], *, workers: int) -> list[float | None]:
+    """``client.branch_last_write`` for each of ``names``, in order.
+
+    Concurrent because the survey is one ``commit list --branch`` per view and
+    each returns the view's whole reachable history, ``main``'s included — so
+    the sweep costs views x commit-log length and both only grow. On omnigraph
+    0.11 ``commit list`` without ``--branch`` returns ``main``'s commits alone
+    and ``changes`` is per-branch too, so the calls can be overlapped but not
+    merged. Serially, production's bridge graph alone outgrew the reaper
+    CronJob's 600s deadline.
+
+    The first failure propagates, as it did serially, and views not yet
+    started are cancelled rather than aged for a survey that is already lost.
+    """
+    if workers <= 1 or len(names) <= 1:
+        return [client.branch_last_write(name) for name in names]
+    pool = ThreadPoolExecutor(max_workers=min(workers, len(names)))
+    try:
+        return list(pool.map(client.branch_last_write, names))
+    finally:
+        pool.shutdown(cancel_futures=True)
+
+
 def reap(
     client,
     *,
@@ -175,6 +228,7 @@ def reap(
     max_idle: float | None = None,
     apply: bool = False,
     cfg: cfg_module.Config | None = None,
+    workers: int | None = None,
 ) -> ReapReport:
     """Sweep one graph's stale branch views.
 
@@ -208,7 +262,7 @@ def reap(
     if max_idle <= 0:
         return ReapReport(graph=graph, now=now)
 
-    ages, stale = survey(client, now=now, max_idle=max_idle)
+    ages, stale = survey(client, now=now, max_idle=max_idle, workers=workers)
     report = ReapReport(graph=graph, now=now, scanned=len(ages), stale=stale)
     if not apply:
         return report

{witan_code-0.24.0 → witan_code-0.25.0}/witan_code/store.py

@@ -554,7 +554,7 @@ def discard_store(ref: StoreRef) -> int:
 # these two exception types exist to prevent.
 _NOT_SERVED = "is not served by the omnigraph-server"
 _NOT_FOUND_RE = re.compile(
-    rf"graph '[^']*' not found|{re.escape(_NOT_SERVED)}", re.IGNORECASE
+    rf"graph (?:'[^']*' )?not found|{re.escape(_NOT_SERVED)}", re.IGNORECASE
 )