witan-code 0.17.0__tar.gz → 0.18.0__tar.gz

{witan_code-0.17.0 → witan_code-0.18.0}/CHANGELOG.md

@@ -6,6 +6,52 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/) (pre-1.0:
 a MINOR bump may include breaking changes).
 
+## [0.18.0] - 2026-09-02
+
+### Added
+
+- **`witan --target <name> code index` reaches this package.** witan-council's
+  launcher gained an app-level `--target`, and `witan code …` mounts this
+  package's cyclopts App but *not* its meta launcher, so the value is forwarded
+  into `witan_code.selected_target` and read by `_srv()`. Before this the flag
+  was bound but never routed: `cli._srv()` called `load_remote_config()` with no
+  argument, so `witan --target ci code repos` answered from the ambient target
+  while appearing to work. Standalone `witan-code --target <name> …` works too.
+
+- **`witan code index` prints the store it wrote to, unconditionally.** The one
+  command whose entire output is about where symbols went was silent about which
+  graph received them — and memory and code graphs are routed by separate
+  settings, so a target whose memory is deployed can still index onto the
+  laptop. Printed for local and shared alike: a line that appears only in the
+  bad case is one nobody has learned to look for. Carried on `IndexStats` rather
+  than recomputed by the printer, so a *failed* run reports the same
+  destination — the run where "which graph was this?" is actually open.
+
+### Fixed
+
+- **`witan-code doctor` could not say which graph was broken under
+  `code_transport = "mcp"`.** The identifying column took `os.path.basename` of
+  the store address, which is right for a local path and wrong for an
+  MCP-routed one — those end in the endpoint URL, so all of production's
+  per-repo cluster graphs rendered as the identical string `mcp)`. `StoreRef`
+  gained a `label` that answers "which graph is this row" for all three address
+  forms, and `code_store_health` returns it alongside the full `store`.
+
+- **A failed index did not always name its destination.** `IndexStats` was built
+  *after* `ensure_branch()` and the existing-hash read, both of which are remote
+  calls, so an unreachable endpoint or a rejected token raised before the stats
+  existed and the summary had nothing to print. Stats are now built straight
+  after the store resolves, and those two setup calls are wrapped so a failure
+  arrives as `IndexFailed` carrying the destination. `check_writable` is
+  deliberately left outside: it raises `SharedGraphWriteRefused`, a clean
+  self-explanatory refusal that callers assert on by type, not the unattributed
+  failure the phases exist to annotate.
+
+- **`code_transport` is parsed off a target block.** A target registered with
+  `--remote-url` now carries `code_transport = "mcp"`, so branches indexed from
+  a checkout land on the cluster where another session — and another developer —
+  can see them, instead of in a directory on one laptop.
+
 ## [0.17.0] - 2026-09-01
 
 ### Fixed

{witan_code-0.17.0 → witan_code-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: witan-code
-Version: 0.17.0
+Version: 0.18.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

{witan_code-0.17.0 → witan_code-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "witan-code"
-version = "0.17.0"
+version = "0.18.0"
 description = "witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -204,7 +204,7 @@ testpaths = ["tests"]
 packages = ["witan_code"]
 
 [tool.bumpversion]
-current_version = "0.17.0"
+current_version = "0.18.0"
 allow_dirty = true
 
 [[tool.bumpversion.files]]

witan_code-0.18.0/tests/test_cli_selected_target.py

@@ -0,0 +1,86 @@
+"""``witan code …`` dispatches to the target witan's launcher bound.
+
+This package's App is mounted by witan's CLI but its meta launcher is not, so
+witan's launcher forwards the ``--target`` it bound into
+:mod:`witan_code.selected_target` (the same forwarding ``--output-format``
+already gets, for the same reason). What is asserted here is the other end of
+that wire: that the dispatch path actually consults it.
+
+Resolving the ambient target here instead is not a cosmetic gap. ``witan code
+index`` WRITES a code graph, so it would have written to whichever deployment
+the checkout happened to match while the flag on the command line said
+otherwise — and said nothing about it.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from witan_code import cli as code_cli
+from witan_code import config as code_cfg
+from witan_code.selected_target import selected_target, set_selected_target
+
+
+@pytest.fixture(autouse=True)
+def _clean_selection():
+    """Module-level state, so a leaked value would silently steer a later test."""
+    set_selected_target(None)
+    yield
+    set_selected_target(None)
+
+
+def test_dispatch_reads_the_forwarded_target(monkeypatch):
+    seen = {}
+
+    def _record(target=None):
+        seen["target"] = target
+        return None  # in-process branch; a stub RemoteConfig is not the point
+
+    monkeypatch.setattr(code_cli, "_server", None)
+    monkeypatch.setattr(code_cfg, "load_remote_config", _record)
+    set_selected_target("qa")
+
+    code_cli._srv()
+
+    assert seen["target"] == "qa"
+
+
+def test_no_forwarded_target_leaves_resolution_where_it_was(monkeypatch):
+    """``None`` is not "no target": the standalone ``witan-code`` launcher
+    declares no ``--target``, and resolution falls through to ``WITAN_TARGET``
+    and the checkout's ``match_*`` rules exactly as it always did."""
+    seen = {}
+
+    def _record(target=None):
+        seen["target"] = target
+        return None
+
+    monkeypatch.setattr(code_cli, "_server", None)
+    monkeypatch.setattr(code_cfg, "load_remote_config", _record)
+
+    code_cli._srv()
+
+    assert seen["target"] is None
+
+
+def test_the_auth_path_reads_it_too(monkeypatch):
+    """``witan code login`` has to reach the same deployment the read commands
+    do, or it mints a token against one target and spends it on another."""
+    seen = {}
+
+    def _record(target=None):
+        seen["target"] = target
+        return None
+
+    monkeypatch.setattr(code_cfg, "load_remote_config", _record)
+    set_selected_target("ci")
+
+    with pytest.raises(SystemExit):
+        code_cli._remote_or_exit()  # no remote configured -> clean exit
+
+    assert seen["target"] == "ci"
+
+
+def test_accessor_round_trips():
+    set_selected_target("production")
+    assert selected_target() == "production"

{witan_code-0.17.0 → witan_code-0.18.0}/tests/test_config_targets.py

@@ -377,3 +377,78 @@ def test_unknown_index_role_is_rejected(monkeypatch, toml_file):
 
     with pytest.raises(ValueError, match="Unknown index_role"):
         load()
+
+
+# ── The seam with `witan target add` ─────────────────────────────────────────
+
+
+def test_the_block_witan_target_add_writes_routes_code_graphs_to_the_cluster(
+    monkeypatch, toml_file
+):
+    """The exact block `witan target add --remote-url …` emits, read back here.
+
+    These are two packages agreeing by convention, not by a shared type: witan
+    (witan-council) renders the TOML, witan-code parses it, and nothing fails
+    loudly if they drift. Before `target add` learned `--code-transport`, a
+    deployed target had no `code_transport` key at all and fell through to the
+    `direct` default, leaving code graphs on the developer's own machine while
+    memory went to the deployment — silently, since a local store is a working
+    store. Keep this literal in step with `witan.cli.targets._FIELD_ORDER`.
+    """
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.ol]
+            remote_url = "https://witan.ci.ol.mit.edu/mcp"
+            oidc_issuer = "https://sso-ci.ol.mit.edu/realms/ol-platform-engineering"
+            oidc_audience = "witan"
+            code_transport = "mcp"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_TRANSPORT", raising=False)
+    monkeypatch.delenv("WITAN_CODE_SERVER", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "ol"
+    assert cfg.code_transport == "mcp"
+    # `mcp` alone makes it a cluster graph — code_server stays unset, because
+    # the deployment holds the address and resolves the actor from the JWT.
+    assert cfg.code_server is None
+    assert cfg.is_cluster
+
+
+def test_a_deployed_target_without_code_transport_still_falls_back_to_local(
+    monkeypatch, toml_file
+):
+    """The pre-fix shape, pinned so the regression is legible rather than silent.
+
+    This is what every target registered before 2026-09-01 looks like. It is
+    not an error and never was — which is the whole problem, and why the
+    onboarding doc now tells people to re-run `target add --force`.
+    """
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.ol]
+            remote_url = "https://witan.ci.ol.mit.edu/mcp"
+            oidc_issuer = "https://sso-ci.ol.mit.edu/realms/ol-platform-engineering"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_TRANSPORT", raising=False)
+    monkeypatch.delenv("WITAN_CODE_SERVER", raising=False)
+
+    cfg = load()
+    assert cfg.code_transport == "direct"
+    assert not cfg.is_cluster
+    # Memory is deployed while code graphs are not — the split this task fixed.
+    assert load_remote_config() is not None

witan_code-0.18.0/tests/test_index_reports_its_store.py

@@ -0,0 +1,122 @@
+"""`witan code index` has to say which graph it wrote.
+
+Memory and code graphs are routed by SEPARATE settings, so a target whose
+memory is deployed can still index onto the laptop — three non-maintainers were
+in exactly that state on production. The one command whose entire output is
+about where symbols went was silent about which store received them.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from witan_code import cli as cli_module
+from witan_code import indexer
+
+
+def test_a_successful_index_names_the_store(monkeypatch, capsys):
+    stats = indexer.IndexStats(
+        scanned=12,
+        indexed=12,
+        symbols=88,
+        store="/home/dev/.local/share/witan-code/x.omni",
+    )
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "/home/dev/.local/share/witan-code/x.omni" in capsys.readouterr().out
+
+
+def test_a_shared_store_is_reported_the_same_way(monkeypatch, capsys):
+    """Printed for local and shared alike. A line that appears only in the bad
+    case is a line nobody has learned to look for — and reading it is how "where
+    did this go" gets answered without knowing the setting exists."""
+    stats = indexer.IndexStats(
+        scanned=12, store="github.com/mitodl/agent-kit (via https://witan.example/mcp)"
+    )
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "https://witan.example/mcp" in capsys.readouterr().out
+
+
+def test_the_branch_view_is_named_when_there_is_one(monkeypatch, capsys):
+    """On a shared graph the view is per writer per git branch, so the store
+    alone does not identify what a reader has to look at."""
+    stats = indexer.IndexStats(store="s", branch="act-0eb-feature-x")
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "branch=act-0eb-feature-x" in capsys.readouterr().out
+
+
+def test_the_default_branch_prints_no_branch_field(monkeypatch, capsys):
+    stats = indexer.IndexStats(store="s")
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "branch=" not in capsys.readouterr().out
+
+
+def test_a_failed_index_still_names_the_store(monkeypatch, capsys):
+    """The failing run is the one where "which graph was this?" is the open
+    question, so the destination is carried on the stats rather than recomputed
+    by the printer."""
+    stats = indexer.IndexStats(scanned=657, store="https://witan.example/mcp")
+
+    def failing_index(path, *, force=False, **kwargs):
+        raise indexer.IndexFailed(
+            "load of nodes and edges",
+            RuntimeError("timed out"),
+            stats=stats,
+            elapsed=181.0,
+            detail={"records": 9000},
+        )
+
+    monkeypatch.setattr(indexer, "index_path", failing_index)
+
+    with pytest.raises(indexer.IndexFailed):
+        cli_module.index(Path("."))
+
+    assert "https://witan.example/mcp" in capsys.readouterr().out
+
+
+def test_a_setup_failure_names_the_store_it_was_reaching(tmp_path, monkeypatch):
+    """Regression, PR #316 review: the guarantee has to cover setup, not just
+    the load.
+
+    `ensure_branch` and the existing-hash read are REMOTE calls, and `IndexStats`
+    used to be built after both. So an unreachable endpoint or a rejected token
+    raised before the stats object existed, `_index` had nothing to print, and
+    the run that most needed a destination reported none — the exact gap the
+    "a failed run still identifies its graph" guarantee was added to close.
+    """
+    import subprocess
+
+    from witan_code import config as cfg_module
+    from witan_code.graph import OmnigraphClient
+
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/test/cg")
+    monkeypatch.setenv("WITAN_CODE_DIR", str(tmp_path / "code"))
+    src = tmp_path / "repo"
+    src.mkdir()
+    subprocess.run(["git", "init", "-q", "-b", "main"], cwd=src, check=True)
+    (src / "a.py").write_text("def a():\n    return 1\n")
+
+    def _unreachable(self, *a, **k):
+        raise RuntimeError("connection refused")
+
+    monkeypatch.setattr(OmnigraphClient, "ensure_branch", _unreachable)
+
+    with pytest.raises(indexer.IndexFailed) as excinfo:
+        indexer.index_path(src, config=cfg_module.load())
+
+    assert excinfo.value.phase == "branch setup"
+    assert excinfo.value.stats.store  # the destination, not an empty string
+    assert "cg" in excinfo.value.stats.store

{witan_code-0.17.0 → witan_code-0.18.0}/tests/test_indexer.py

@@ -21,6 +21,9 @@ def test_index_extracts_symbols_and_edges(sample_repo):
 
     slug = repo_mod.detect()
     store = store_mod.store_for_repo(slug, cfg)
+    # The destination the summary reports comes off the run itself, so this is
+    # what stops that line drifting from where the rows actually landed.
+    assert stats.store == str(store)
     client = OmnigraphClient(str(store), cfg.queries_dir)
 
     runs = client.read("code_read.gq", "find_by_name", {"name": "run"})

{witan_code-0.17.0 → witan_code-0.18.0}/tests/test_remote_store.py

@@ -184,6 +184,43 @@ def test_the_transport_decides_the_address(monkeypatch, tmp_path):
     assert bridge.via_mcp == cfg_module.BRIDGE_GRAPH_ID
 
 
+def test_label_names_the_graph_a_row_is(monkeypatch, tmp_path):
+    """Every MCP-routed address ends in the same endpoint.
+
+    Taking a basename of the full address — what `witan-code doctor` did —
+    therefore rendered all 14 of production's cluster graphs as `mcp)`, so the
+    table could not say which one was broken in exactly the configuration a
+    deployed target uses.
+    """
+    monkeypatch.setenv("WITAN_CODE_DIR", str(tmp_path / "code"))
+    monkeypatch.setenv("WITAN_CODE_TRANSPORT", cfg_module.CODE_TRANSPORT_MCP)
+    monkeypatch.setenv("WITAN_REMOTE_URL", "https://witan.example.org/mcp")
+    monkeypatch.setenv("WITAN_OIDC_ISSUER", "https://sso.example.org/realms/ol")
+
+    ref = store_module.store_for_repo(REPO, cfg_module.load())
+    assert ref.label == "test/cg"
+    assert str(ref).endswith("(via https://witan.example.org/mcp)")
+    assert store_module.bridge_store(cfg_module.load()).label == (
+        cfg_module.BRIDGE_GRAPH_ID
+    )
+
+
+def test_label_falls_back_to_the_store_name_off_the_mcp_path(monkeypatch, tmp_path):
+    """A local store and a directly-addressed cluster graph keep their own names."""
+    monkeypatch.setenv("WITAN_CODE_DIR", str(tmp_path / "code"))
+    monkeypatch.delenv("WITAN_CODE_TRANSPORT", raising=False)
+    monkeypatch.delenv("WITAN_CODE_SERVER", raising=False)
+    monkeypatch.delenv("WITAN_REMOTE_URL", raising=False)
+
+    local = store_module.store_for_repo(REPO, cfg_module.load())
+    assert local.label.endswith(".omni")
+    assert "/" not in local.label
+
+    monkeypatch.setenv("WITAN_CODE_SERVER", "http://omnigraph:8080")
+    direct = store_module.store_for_repo(REPO, cfg_module.load())
+    assert direct.label == direct.graph_id
+
+
 def test_the_endpoint_comes_from_the_config_that_asked_for_it(monkeypatch, tmp_path):
     """A `Config` from an explicit `load(target=…)` must resolve *that*
     target's endpoint. Re-running target selection would fall back to

{witan_code-0.17.0 → witan_code-0.18.0}/witan_code/cli.py

@@ -15,7 +15,6 @@ unconditionally.
 
 import asyncio
 import inspect
-import os
 import sys
 from pathlib import Path
 from typing import Annotated, Literal
@@ -50,16 +49,23 @@ def _srv():
     ``RemoteServerProxy`` when ``WITAN_REMOTE_URL`` (or a matched target's
     ``remote_url``) is set. The proxy mirrors the server module's tool surface,
     so every call site is identical either way.
+
+    Under ``witan code …`` the target comes from witan's launcher, which mounts
+    this App without this package's launcher and forwards what it bound into
+    :mod:`witan_code.selected_target`. ``witan code index`` writing a code graph
+    to whichever deployment the checkout happened to match, while the flag said
+    otherwise, is the failure this reaches back to prevent.
     """
     global _server
     if _server is None:
         from . import config as cfg_module
+        from .selected_target import selected_target
 
         # A misconfigured remote (e.g. WITAN_REMOTE_URL without
         # WITAN_OIDC_ISSUER) raises ValueError here; surface it as a clean CLI
         # error rather than letting a traceback escape every read command.
         try:
-            remote = cfg_module.load_remote_config()
+            remote = cfg_module.load_remote_config(selected_target())
         except ValueError as exc:
             print(exc)
             raise SystemExit(1) from None
@@ -272,12 +278,15 @@ def doctor() -> None:
     report = _fn(server_module.code_store_health)()
     rows = [
         {
-            # Basename only: a local store path is `<code_dir>/<sanitized
-            # repo>.omni` and the shared prefix is the same on every row, so
-            # printing it in full wraps every store onto three lines and buries
-            # the status column this table exists for. A cluster graph's `store`
-            # is not a path and has no basename to take.
-            "store": os.path.basename(s["store"]),
+            # The short form, not the address: a local store path is
+            # `<code_dir>/<sanitized repo>.omni` and a cluster graph's address
+            # ends in the endpoint, so in both cases the shared part is
+            # identical on every row — printed in full it wraps each store onto
+            # three lines and buries the status column this table exists for.
+            # Computed by StoreRef.label rather than here, because the three
+            # address forms are that type's business and taking a basename of
+            # the MCP one silently collapsed all 14 rows to `mcp)`.
+            "store": s["label"],
             "kind": s["kind"],
             "status": "ok"
             if s["ok"]
@@ -927,6 +936,17 @@ def setup(
 
 
 def _print_summary(action: str, path: Path, stats: indexer.IndexStats) -> None:
+    # ★ WHERE THE SYMBOLS WENT, UNCONDITIONALLY. Memory and code graphs are
+    # routed by separate settings, so a target whose memory is deployed can
+    # still index onto this laptop — and this command, whose entire output is
+    # about where symbols went, used to be silent about which graph it wrote.
+    # Printed for local and shared alike: a line that appears only in the bad
+    # case is a line nobody has learned to look for.
+    if stats.store:
+        print(
+            f"store: {stats.store}"
+            + (f" branch={stats.branch}" if stats.branch else "")
+        )
     print(
         f"{action} {path}: "
         f"scanned={stats.scanned} indexed={stats.indexed} "
@@ -1078,9 +1098,10 @@ def repos() -> None:
 
 def _remote_or_exit():
     from . import config as cfg_module
+    from .selected_target import selected_target
 
     try:
-        remote = cfg_module.load_remote_config()
+        remote = cfg_module.load_remote_config(selected_target())
     except ValueError as exc:
         print(exc)
         raise SystemExit(1) from None

{witan_code-0.17.0 → witan_code-0.18.0}/witan_code/indexer.py

@@ -303,6 +303,20 @@ class IndexStats:
     directory). Full-repo runs only; reported so a mass cleanup is visible
     rather than silent."""
 
+    store: str = ""
+    """Where the run wrote — a local directory, or the shared graph's address.
+
+    ``witan code index`` is the command whose whole output is about where
+    symbols went, and it happily wrote to a laptop under a deployed target
+    without comment. Carried on the stats rather than recomputed by the
+    printer so a FAILED run reports the same destination a successful one
+    does — that is precisely the run where "which graph was this?" is the
+    open question.
+    """
+
+    branch: str = ""
+    """The branch view written, or empty on the repo's default branch."""
+
 
 class IndexFailed(RuntimeError):
     """A write phase of :func:`index_path` failed, carrying what it knows.
@@ -397,22 +411,36 @@ def index_path(
     branch = views.repo_view(git_branch, actor=actor) if git_branch else None
 
     store = ensure_store(slug, cfg)
+    # Built HERE, before the first remote call, not after the setup reads
+    # below. The guarantee is that a failed run still says which graph it was
+    # writing to, and the setup calls are remote — an unreachable endpoint or a
+    # rejected token raised before `stats` existed, so `_index` had nothing to
+    # print and the run that most needed a destination reported none.
+    stats = IndexStats(store=str(store), branch=branch or "")
+
     client = store.client(cfg, branch=branch)
+    # Deliberately OUTSIDE the phases below. This raises
+    # SharedGraphWriteRefused, which is a clean, self-explanatory refusal with
+    # its own message — not the unattributed failure the phases exist to
+    # annotate — and callers assert on that type directly
+    # (tests/test_indexer_scope.py). Wrapping it would rename the exception for
+    # no diagnostic gain.
     check_writable(
         is_remote=client.is_remote, branch=branch, cfg=cfg, slug=slug, actor=actor
     )
     # The hash read below never forks; create the branch before reading.
-    client.ensure_branch()
+    with _write_phase("branch setup", stats, branch=branch or ""):
+        client.ensure_branch()
 
     # One query for all existing file hashes → the incremental skip check is
     # in-memory, not a query per file. Read even under `force` (where the
     # hashes go unused): a full-repo run also needs the stored file set to
     # find rows for files that are no longer part of the repo.
     existing: dict[str, str] = {}
-    for row in client.read("code_read.gq", "all_file_hashes", {}):
-        existing[row["slug"]] = row.get("content_hash")
+    with _write_phase("existing-hash read", stats):
+        for row in client.read("code_read.gq", "all_file_hashes", {}):
+            existing[row["slug"]] = row.get("content_hash")
 
-    stats = IndexStats()
     records: list[dict] = []
     reindexed_file_ids: list[str] = []
     bindings: list[ParsedBinding] = []

witan_code-0.18.0/witan_code/selected_target.py

@@ -0,0 +1,28 @@
+"""The ``--target`` in effect for this process.
+
+The twin of :mod:`witan.cli.selected_target`, and duplicated for the same
+reason :mod:`witan_code.output` is: ``witan code …`` mounts this package's
+cyclopts App but **not** its meta launcher, so witan's launcher is the one that
+runs and it forwards what it bound into here. Two modules rather than one
+because witan depends on witan-code, not the other way round.
+
+Left ``None`` when this package's own binary is driven directly
+(``witan-code index``): that launcher declares no ``--target``, so resolution
+falls through to ``WITAN_TARGET`` and the checkout's ``match_*`` rules exactly
+as it did before. Adding the option there is a separate change.
+"""
+
+from __future__ import annotations
+
+_selected: str | None = None
+
+
+def set_selected_target(name: str | None) -> None:
+    """Record the ``--target`` the calling launcher bound, if any."""
+    global _selected
+    _selected = name
+
+
+def selected_target() -> str | None:
+    """The ``--target`` given on this command line, else ``None``."""
+    return _selected

{witan_code-0.17.0 → witan_code-0.18.0}/witan_code/server.py

@@ -1059,8 +1059,11 @@ def code_store_health() -> dict:
     fail while every per-repo listing still looks healthy — which is how it
     stayed broken for six weeks.
 
-    Returns ``{"stores": [{store, kind, ok, files, error, stale_schema}],
-    "ok": bool, "stale_schema": [store, ...]}``. ``stale_schema`` names the
+    Returns ``{"stores": [{store, label, kind, ok, files, error,
+    stale_schema}], "ok": bool, "stale_schema": [store, ...]}``. ``store`` is
+    the full address; ``label`` is the short form that identifies WHICH graph a
+    row is, which for a cluster graph the address does not (it ends in the
+    endpoint, identical on every row). ``stale_schema`` names the
     stores written by an omnigraph whose on-disk format the installed binary
     no longer reads — the one failure with a known remedy, since a code graph
     is derived from its checkout and is rebuilt by reindexing
@@ -1071,6 +1074,10 @@ def code_store_health() -> dict:
         "stores": [
             {
                 "store": str(h.ref),
+                # The full `store` address is the same endpoint on every row
+                # under a deployed target, so it cannot be used as the column
+                # that tells the rows apart. See StoreRef.label.
+                "label": h.ref.label,
                 "kind": "bridge" if h.is_bridge else "repo",
                 "ok": h.ok,
                 "files": h.files,

{witan_code-0.17.0 → witan_code-0.18.0}/witan_code/store.py

@@ -41,6 +41,7 @@ from witan_core.omnigraph import (
 
 from . import config as cfg_module
 from .graph import OmnigraphClient, is_stale_schema
+from .visualize import short_repo
 
 # Graph registration changes only when provisioning does (a Pulumi deploy), but
 # `_client_for_repo` asks "does this store exist" on every MCP tool call. One
@@ -143,6 +144,27 @@ class StoreRef:
             return f"{self.uri} (graph {self.graph_id})"
         return self.uri
 
+    @property
+    def label(self) -> str:
+        """Short identifier for a table column — which graph, not where it is.
+
+        :meth:`__str__` is the full address and is what a refusal should print.
+        This is the version that fits in a column: the part that DIFFERS
+        between rows, with the endpoint or directory prefix that is identical
+        on every row dropped.
+
+        Taking ``os.path.basename`` of the full address instead is right only
+        for a local store. An MCP-routed address ends in the endpoint URL, so
+        every cluster graph in a listing came out as the same ``mcp)`` — which
+        made ``witan-code doctor`` unable to name which graph was broken in
+        exactly the configuration a deployed target now uses.
+        """
+        if self.via_mcp:
+            return short_repo(self.via_mcp)
+        if self.is_remote:
+            return self.graph_id or self.uri
+        return Path(self.uri).name
+
     def client(
         self,
         config: cfg_module.Config | None = None,