diff --git a/.github/workflows/autonomousqa.yml b/.github/workflows/autonomousqa.yml
index c8c13a6..d52ee29 100644
--- a/.github/workflows/autonomousqa.yml
+++ b/.github/workflows/autonomousqa.yml
@@ -96,4 +96,4 @@ jobs:
           pip install -e .
           bash ../.github/scripts/install-asdecided.sh 0.23.1
       - name: Smoke — drive, compile, fidelity-gate, meter, re-score
-        run: RAC_BIN=decided python -m runner.cli smoke
+        run: DECIDED_BIN=decided python -m runner.cli smoke
diff --git a/.github/workflows/decisiongrounding-ci.yml b/.github/workflows/decisiongrounding-ci.yml
index 5bdc771..3acb1f2 100644
--- a/.github/workflows/decisiongrounding-ci.yml
+++ b/.github/workflows/decisiongrounding-ci.yml
@@ -3,7 +3,7 @@ name: decisiongrounding CI
 # The decisiongrounding benchmark arrived from its standalone repository with
 # its workflow at decisiongrounding/.github/workflows/ci.yml — a path GitHub
 # does not read in a subdirectory. This root workflow re-homes those same jobs
-# (test matrix, offline demo smoke, rac corpus gate) unchanged in substance,
+# (test matrix, offline demo smoke, live AsDecided arm smoke, corpus gate)
 # scoped to the subdirectory.
 
 on:
@@ -48,10 +48,10 @@ jobs:
       - name: Smoke the offline demo
         run: python -m runner.cli demo
 
-  corpus:
-    # Dogfood RAC: enforce the benchmark's own knowledge corpus the same way
-    # the benchmark studies — validation, relationships, and review must pass.
-    name: rac corpus gate
+  asdecided-core:
+    # Exercise the actual Rust system-under-test boundary and enforce the
+    # benchmark's own knowledge corpus.
+    name: AsDecided Core integration
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
@@ -65,5 +65,14 @@ jobs:
       - name: Install AsDecided
         run: bash ../.github/scripts/install-asdecided.sh 0.23.1
 
+      - name: Install benchmark
+        run: pip install -e ".[dev,schema]"
+
+      - name: Smoke the AsDecided whole-artifact arm
+        run: python -m runner.cli run --arm rac --scenarios scenarios --out /tmp/dg-core-smoke
+
+      - name: Smoke the AsDecided snippet arm
+        run: python -m runner.cli run --arm rac_snippets --scenarios scenarios --out /tmp/dg-core-snippets-smoke
+
       - name: Gate the RAC corpus (validate + relationships + review)
         run: decided gate rac
diff --git a/decisiongrounding/README.md b/decisiongrounding/README.md
index 8689c4d..9fca0b3 100644
--- a/decisiongrounding/README.md
+++ b/decisiongrounding/README.md
@@ -136,7 +136,8 @@ pip install -e ".[real,schema,chart]"
 export ANTHROPIC_API_KEY=...        # pinned answering model: claude-opus-4-8
 export VOYAGE_API_KEY=...           # real embeddings for naive_rag
 
-# rac arm additionally needs the `rac` CLI on PATH (or set RAC_BIN)
+# stable rac arm additionally needs AsDecided Core's `decided` CLI on PATH
+# (or set DECIDED_BIN)
 python -m runner.cli compare \
   --arms context_dump,naive_rag,rac \
   --answering claude \
@@ -154,7 +155,7 @@ so a run says exactly what produced it.
 
 For repeat or large runs, `python -m runner.cli batch …` runs the same
 comparison through the **Message Batches API at ~50% of standard token price**.
-It assembles every arm's grounding locally (rac CLI, embeddings) up front, then
+It assembles every arm's grounding locally (AsDecided Core, embeddings) up front, then
 submits all answering calls as one batch and polls to completion (asynchronous —
 usually under an hour). The trade vs `compare` is the live, abortable per-cell
 feedback; for the first exploratory run prefer `compare`, for bulk runs prefer
@@ -162,7 +163,7 @@ feedback; for the first exploratory run prefer `compare`, for bulk runs prefer
 
 A real run is expensive, so the runner protects your spend two ways. It
 **preflights** the configuration before doing any work — a missing
-`ANTHROPIC_API_KEY`, `VOYAGE_API_KEY`, backend package, or `rac` CLI fails fast
+`ANTHROPIC_API_KEY`, `VOYAGE_API_KEY`, backend package, or Core CLI fails fast
 with an actionable message instead of part-way through a paid sweep. And it
 **streams every completed run** to a durable `results/run-<stamp>-<label>.partial.jsonl`
 sidecar as it lands; a transient API error on one (arm, scenario) cell is
@@ -315,14 +316,14 @@ python -m runner.cli compare \
 The `rac` arm is the grounding layer under test: it follows the typed
 `supersedes` edge and supplies the live PEP 440, where `naive_rag` can surface
 PEP 386's appealing `verlib` section without the header that marks it superseded.
-It needs the `rac` CLI on PATH (`pip install -e .` from the repo root, or set
-`RAC_BIN`); drop `,rac` to run the baselines alone.
+It needs AsDecided Core's `decided` CLI on PATH (install `asdecided-core`, or
+set `DECIDED_BIN`); drop `,rac` to run the baselines alone.
 
 This produces the first genuine decision-adherence result (win, tie, or loss)
 on a real corpus; like every run it is appended to `results/`. The build
 environment for this pilot had no API keys, so the scenario is offline-validated
 (loads, schema-validates, scores, and the `rac` arm's supersedes-following is
-verified against the real `rac` CLI) and the real numbers are produced by whoever
+verified against the real AsDecided Core CLI) and the real numbers are produced by whoever
 holds the keys.
 
 ### Real adherence-vs-N curve (real distractors, not synthetic filler)
diff --git a/decisiongrounding/docs/AGENTIC_BENCHMARK_RUN_HANDOFF.md b/decisiongrounding/docs/AGENTIC_BENCHMARK_RUN_HANDOFF.md
index 40af537..1270fac 100644
--- a/decisiongrounding/docs/AGENTIC_BENCHMARK_RUN_HANDOFF.md
+++ b/decisiongrounding/docs/AGENTIC_BENCHMARK_RUN_HANDOFF.md
@@ -77,7 +77,7 @@ Either way:
   Never push to main.
 - Install: `pip install -e ".[real,schema,chart]"`. The `rac` arm needs the `rac`
   CLI on PATH (`brew install asdecided/tap/asdecided-core`, then
-  `export RAC_BIN=decided`). Alternatively `./scripts/from_source.sh` does venv + install + loads
+  `export DECIDED_BIN=decided`). Alternatively `./scripts/from_source.sh` does venv + install + loads
   keys from .env + probe + run in one go; the granular steps below are recommended
   for the first real run so you can inspect each stage.
 
diff --git a/decisiongrounding/providers/__init__.py b/decisiongrounding/providers/__init__.py
index 4afae6e..2e44427 100644
--- a/decisiongrounding/providers/__init__.py
+++ b/decisiongrounding/providers/__init__.py
@@ -42,7 +42,9 @@
 from .rac_snippets import RacSnippetsProvider
 
 # Real, runnable arms this pass: context_dump, naive_rag, no_grounding,
-# naive_rag_full (offline); rac, rac_snippets (need the external rac CLI).
+# naive_rag_full (offline); rac, rac_snippets (need AsDecided Core's external
+# `decided` CLI). The rac identifiers are stable experimental arm IDs, not
+# executable or product names.
 # naive_rag_full and rac_snippets are the token-budget parity variants that
 # complete the 2x2 (retrieval method x grounding granularity).
 # memory_provider is a typed stub.
diff --git a/decisiongrounding/providers/rac.py b/decisiongrounding/providers/rac.py
index 69730b0..ae49109 100644
--- a/decisiongrounding/providers/rac.py
+++ b/decisiongrounding/providers/rac.py
@@ -1,18 +1,19 @@
-"""`rac` arm — deterministic typed retrieval via the system under test.
+"""`rac` arm — deterministic typed retrieval via AsDecided Core.
 
-This arm assembles grounding by calling RAC's deterministic, typed retrieval
+This arm assembles grounding by calling AsDecided Core's deterministic, typed retrieval
 surface rather than embedding similarity. It is the layer whose value the whole
 benchmark exists to test, so it gets NO special treatment: same answering model,
 same scaffold, one symmetric grounding opportunity.
 
-RAC is treated as an EXTERNAL TOOL, never a Python import (ADR-0001): the arm
-shells out to the pinned `rac` CLI (`rac find … --json`, `rac relationships …
+AsDecided Core is treated as an EXTERNAL TOOL, never a Python import (ADR-0001):
+the arm shells out to the pinned `decided` CLI (`decided find … --json`,
+`decided relationships …
 --json`). The thesis is that typed retrieval + relationship traversal preserves
 exactly what naive_rag severs — notably supersession — by FOLLOWING `supersedes`
 edges instead of hoping the superseding artifact lands in top-k.
 
-Requires the `rac` CLI on PATH (or set RAC_BIN). It does not run in the offline
-demo; install `rac` to include this arm in a comparison.
+Requires the `decided` CLI on PATH (or set DECIDED_BIN). It does not run in the
+offline demo; install AsDecided Core to include this arm in a comparison.
 """
 
 from __future__ import annotations
@@ -28,26 +29,26 @@
 from pathlib import Path
 
 
-def rac_version() -> str | None:
-    """Best-effort version of the `rac` CLI — the system under test.
+def core_version() -> str | None:
+    """Best-effort version of AsDecided Core — the system under test.
 
-    The benchmark pins rac only by convention, so without this two runs
-    against different rac builds produce indistinguishable reports. Returns
-    the stripped `rac --version` output, or None when the binary is absent
+    Without this, two runs against different Core builds produce
+    indistinguishable reports. Returns the stripped `decided --version` output,
+    or None when the binary is absent
     or the call fails: provenance must never break a run.
     """
-    return _rac_version(os.environ.get("RAC_BIN", "rac"))
+    return _core_version(os.environ.get("DECIDED_BIN", "decided"))
 
 
 @lru_cache(maxsize=8)
-def _rac_version(rac_bin: str) -> str | None:
+def _core_version(decided_bin: str) -> str | None:
     """One subprocess per resolved binary per process (see the lru_cache);
-    tests vary RAC_BIN and call `_rac_version.cache_clear()`."""
-    if shutil.which(rac_bin) is None:
+    tests vary DECIDED_BIN and call `_core_version.cache_clear()`."""
+    if shutil.which(decided_bin) is None:
         return None
     try:
         proc = subprocess.run(
-            [rac_bin, "--version"], capture_output=True, text=True, timeout=10
+            [decided_bin, "--version"], capture_output=True, text=True, timeout=10
         )
     except Exception:  # noqa: BLE001 - absence/misbehaviour is expected, not fatal
         return None
@@ -66,7 +67,7 @@ def _rac_version(rac_bin: str) -> str | None:
 
 
 def _query_tokens(text: str) -> list[str]:
-    """Salient single terms for `rac find`, which substring-matches ID/title and
+    """Salient single terms for `decided find`, which matches ID/title and
     narrows on multi-word queries. Querying one term at a time and unioning the
     hits is the deterministic way to retrieve by topic over that surface."""
     seen: list[str] = []
@@ -130,26 +131,29 @@ def __init__(self, answering_model, top_k: int = 4):
 
     @staticmethod
     def _bin() -> str:
-        return os.environ.get("RAC_BIN", "rac")
+        return os.environ.get("DECIDED_BIN", "decided")
 
     def _run(self, *args: str) -> dict:
-        rac = self._bin()
-        if shutil.which(rac) is None:
+        decided = self._bin()
+        if shutil.which(decided) is None:
             raise RuntimeError(
-                f"rac CLI not found ({rac!r}). Install `rac` or set RAC_BIN to "
-                "include the rac arm. It does not run in the offline demo."
+                f"AsDecided Core CLI not found ({decided!r}). Install "
+                "`asdecided-core` or set DECIDED_BIN to include the rac arm. "
+                "It does not run in the offline demo."
             )
-        proc = subprocess.run([rac, *args], capture_output=True, text=True)
+        proc = subprocess.run([decided, *args], capture_output=True, text=True)
         if proc.returncode != 0:
             raise RuntimeError(
-                f"rac CLI failed ({rac} {' '.join(args)}): exit {proc.returncode}\n"
+                f"AsDecided Core CLI failed "
+                f"({decided} {' '.join(args)}): exit {proc.returncode}\n"
                 f"{proc.stderr.strip()}"
             )
         try:
             return json.loads(proc.stdout)
         except json.JSONDecodeError as exc:
             raise RuntimeError(
-                f"rac CLI returned non-JSON for ({rac} {' '.join(args)}): {exc}"
+                f"AsDecided Core CLI returned non-JSON for "
+                f"({decided} {' '.join(args)}): {exc}"
             ) from exc
 
     def _find_candidates(self, task: Task) -> list[str]:
@@ -170,15 +174,15 @@ def _find_candidates(self, task: Task) -> list[str]:
         return sorted(order, key=lambda i: (-hits[i], order.index(i)))
 
     def prepare(self, corpus: list[CorpusArtifact]) -> None:
-        # Write the corpus to a temp dir so the external `rac` CLI can index it.
+        # Write the corpus to a temp dir so the external Core CLI can index it.
         self._by_id = {a.id: a for a in corpus}
-        tmp = Path(tempfile.mkdtemp(prefix="dg-rac-"))
+        tmp = Path(tempfile.mkdtemp(prefix="dg-asdecided-"))
         for a in corpus:
             (tmp / f"{a.id}.md").write_text(a.text, encoding="utf-8")
         self._dir = tmp
         # The corpus is written fresh every prepare(); clean up the previous temp
         # dir and ensure this one is removed when the provider is collected, so a
-        # long sweep does not leak a dg-rac-* directory per run.
+        # long sweep does not leak a dg-asdecided-* directory per run.
         self._cleanup()
         self._finalizer = weakref.finalize(self, shutil.rmtree, tmp, ignore_errors=True)
         self._grounding = GroundingContext(text="", artifacts_supplied=(), token_estimate=0)
@@ -195,10 +199,10 @@ def _resolve(self, task: Task) -> list[str]:
         differ only in grounding granularity, never in retrieval."""
         if self._dir is None:
             raise RuntimeError("rac arm: prepare() must run before assemble()")
-        # 1. Typed candidate decisions. `rac find` substring-matches ID/title and
+        # 1. Typed candidate decisions. `decided find` matches ID/title and
         # ANDs multi-word queries, so we query one salient task term at a time and
         # union the hits, ranking by how many terms hit each decision (then by
-        # first appearance) — a deterministic topic search over rac's surface.
+        # first appearance) — a deterministic topic search over Core's surface.
         matched = self._find_candidates(task)
 
         # 2. Relationship graph → supersedes edges (source supersedes target).
@@ -226,12 +230,12 @@ def assemble(self, task: Task) -> GroundingContext:
 
 
 def _extract_supersedes_edges(rels_json: dict) -> list[tuple[str, str]]:
-    """Pull (source, target) supersedes pairs from `rac relationships --json`.
+    """Pull (source, target) pairs from `decided relationships --json`.
 
-    Defensive against shape drift across rac versions: handles both a flat
+    Defensive against shape drift across Core versions: handles both a flat
     relationships list (entries with relationship == "supersedes") and an
     artifacts[] report carrying a per-artifact `relationships.supersedes` list.
-    TODO(rac-arm): pin and verify against the installed rac version's JSON.
+    TODO(rac-arm): pin and verify against the installed Core version's JSON.
     """
     edges: list[tuple[str, str]] = []
 
@@ -242,8 +246,8 @@ def _extract_supersedes_edges(rels_json: dict) -> list[tuple[str, str]]:
                 edges.append((src, tgt))
 
     for art in rels_json.get("artifacts", []) or []:
-        # `rac relationships --json` identifies each artifact by `path`, not `id`
-        # (this rac build emits no `id` here). The arm writes the corpus as
+        # `decided relationships --json` identifies each artifact by `path`, not
+        # `id` (this Core build emits no `id` here). The arm writes the corpus as
         # `<id>.md`, so the file stem is the artifact id; prefer an explicit `id`
         # if a future rac version adds one.
         src = art.get("id") or Path(art.get("path", "")).stem or None
diff --git a/decisiongrounding/providers/rac_snippets.py b/decisiongrounding/providers/rac_snippets.py
index c08f5b1..01d3a45 100644
--- a/decisiongrounding/providers/rac_snippets.py
+++ b/decisiongrounding/providers/rac_snippets.py
@@ -7,15 +7,16 @@
 naive_rag comparison: does typed, supersession-aware retrieval help, and
 does dumping whole artifacts help or hurt?
 
-This arm isolates the first. It runs rac's exact typed retrieval
+This arm isolates the first. It runs AsDecided Core's exact typed retrieval
 (`RacProvider._resolve` — same candidates, same supersedes traversal, same
 top_k), then presents the resolved artifacts as SECTION SNIPPETS under a
 token budget matched to naive_rag's typical grounding size — so `rac_snippets`
 vs `naive_rag` compares retrieval method at an equal budget, and `rac_snippets`
 vs `rac` compares snippet vs whole-artifact granularity at equal retrieval.
 
-Requires the `rac` CLI (inherits `RacProvider`); does not run in the offline
-demo. See the 2×2 with `naive_rag_full` (cosine retrieval, whole artifacts).
+Requires the `decided` CLI (inherits `RacProvider`); does not run in the
+offline demo. See the 2×2 with `naive_rag_full` (cosine retrieval, whole
+artifacts).
 """
 
 from __future__ import annotations
diff --git a/decisiongrounding/pyproject.toml b/decisiongrounding/pyproject.toml
index 02f216e..d67cded 100644
--- a/decisiongrounding/pyproject.toml
+++ b/decisiongrounding/pyproject.toml
@@ -30,8 +30,9 @@ local-embeddings = ["sentence-transformers>=2.2"]
 # Local web UI (`decisiongrounding ui`). Optional and lazily imported so the
 # core stays dependency-free; the page needs no frontend build step.
 ui = ["fastapi>=0.110", "uvicorn>=0.27"]
-# The rac arm additionally needs the `rac` CLI on PATH (or RAC_BIN) — it is an
-# external tool, not a Python dependency (ADR-0001), so it is not listed here.
+# The stable rac arm additionally needs AsDecided Core's `decided` CLI on PATH
+# (or DECIDED_BIN). It is the external system under test, not a Python
+# dependency (ADR-0001), so it is not listed here.
 # Test runner.
 dev = ["pytest>=7"]
 
diff --git a/decisiongrounding/runner/cli.py b/decisiongrounding/runner/cli.py
index 8a8b942..3421f4c 100644
--- a/decisiongrounding/runner/cli.py
+++ b/decisiongrounding/runner/cli.py
@@ -43,7 +43,7 @@
     check_context_window,
 )
 from providers.answering import error_kind  # noqa: E402
-from providers.rac import rac_version  # noqa: E402
+from providers.rac import core_version  # noqa: E402
 from scenarios.loader import Scenario, load_pool, load_scenarios  # noqa: E402
 from scoring import aggregate, score  # noqa: E402
 from scoring.crossover import (  # noqa: E402
@@ -161,11 +161,11 @@ def _preflight(arms: tuple[str, ...], answering: str, embedder: str) -> None:
                 )
 
     if {"rac", "rac_snippets"} & set(arms) and shutil.which(
-        os.environ.get("RAC_BIN", "rac")
+        os.environ.get("DECIDED_BIN", "decided")
     ) is None:
         problems.append(
-            "the rac/rac_snippets arms need the `rac` CLI on PATH (pip install -e "
-            "the rac repo, or set RAC_BIN)"
+            "the rac/rac_snippets arms need AsDecided Core's `decided` CLI on "
+            "PATH (install `asdecided-core`, or set DECIDED_BIN)"
         )
 
     if problems:
@@ -257,12 +257,12 @@ def _backend_versions() -> dict:
             out[pkg] = md.version(pkg)
         except Exception:  # noqa: BLE001 - absence is expected offline
             pass
-    # The system under test: without this, two runs against different rac
+    # The system under test: without this, two runs against different Core
     # builds produce indistinguishable reports. Same omit-when-absent
     # convention as the pip packages.
-    v = rac_version()
+    v = core_version()
     if v is not None:
-        out["rac"] = v
+        out["asdecided_core"] = v
     return out
 
 
@@ -456,7 +456,7 @@ def cmd_compare(args) -> int:
 
 def cmd_batch(args) -> int:
     """Same comparison as `compare`, but the answering calls go through the
-    Message Batches API at 50% of standard price. Grounding assembly (rac CLI,
+    Message Batches API at 50% of standard price. Grounding assembly (AsDecided Core,
     embeddings) still runs locally up front; only the held-constant answering
     model is batched. Asynchronous: submit one batch, poll, then score."""
     arms = tuple(a.strip() for a in args.arms.split(",") if a.strip())
@@ -472,7 +472,7 @@ def cmd_batch(args) -> int:
     stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
     label = "batch-" + "-".join(arms)
 
-    # 1. Assemble every cell's grounding + request locally (rac CLI / embeddings
+    # 1. Assemble every cell's grounding + request locally (Core CLI / embeddings
     #    happen here). The answering calls are submitted together below. A cell
     #    that would exceed the answering model's context window is skipped
     #    here — the same symmetric preflight as Provider.respond() and
diff --git a/decisiongrounding/runner/dashboard.py b/decisiongrounding/runner/dashboard.py
index dca26f8..6e509f1 100644
--- a/decisiongrounding/runner/dashboard.py
+++ b/decisiongrounding/runner/dashboard.py
@@ -60,7 +60,7 @@ def curve_from_dataset(dataset) -> dict | None:
     "naive_rag": "embeds the corpus, retrieves top-k chunks (classic RAG)",
     "naive_rag_full": "cosine retrieval, whole artifact per top hit (whole-artifact granularity)",
     "no_grounding": "supplies nothing — parametric memory only (control)",
-    "rac": "typed, supersession-aware grounding assembled by the rac CLI",
+    "rac": "typed, supersession-aware grounding assembled by AsDecided Core",
     "rac_snippets": "rac's typed retrieval, snippets under naive_rag's token budget (equal budget)",
     "memory_provider": "pluggable external memory provider (stub)",
 }
diff --git a/decisiongrounding/scoring/crossover.py b/decisiongrounding/scoring/crossover.py
index 452a2c0..b674c80 100644
--- a/decisiongrounding/scoring/crossover.py
+++ b/decisiongrounding/scoring/crossover.py
@@ -27,7 +27,7 @@
 
 from providers import build_provider, make_answering_model
 from providers.answering import error_kind, usage_dict
-from providers.rac import rac_version
+from providers.rac import core_version
 from providers.base import SCAFFOLD, ContextWindowExceededError, CorpusArtifact, check_context_window
 from scenarios.loader import Scenario
 from scoring.metrics import summarize
@@ -208,10 +208,14 @@ def _envelope(discriminating, use_real, pool, seed, ns, model_version, embedder_
         "ns": list(ns),
         "answering_model": model_version,
         "embedder": embedder_spec,
-        # Version of the system under test. None when no rac-based arm is in
-        # this curve — a rac version on a curve that never ran rac would be
-        # noise, and None states explicitly that rac was not in play.
-        "rac_version": rac_version() if {"rac", "rac_snippets"} & set(arms) else None,
+        # Structured system-under-test provenance. None when no AsDecided arm is
+        # in this curve; product and binary names remain independent of stable
+        # historical arm IDs as this suite evolves toward SWE-DecisionGrounding.
+        "system_under_test": {
+            "product": "AsDecided Core",
+            "binary": "decided",
+            "version": core_version(),
+        } if {"rac", "rac_snippets"} & set(arms) else None,
         # Provenance so the cost-vs-N curve can be recomputed offline (no spend).
         "pool_dir": pool_dir,
         "scenarios_dir": scenarios_dir,
@@ -464,7 +468,7 @@ def build_dataset_batched(
 ) -> dict:
     """Same adherence-vs-N curve as build_dataset, but the held-constant answering
     calls go through the Message Batches API (≈50% of standard price, and it runs
-    server-side so it survives a client restart). Grounding assembly (rac CLI /
+    server-side so it survives a client restart). Grounding assembly (AsDecided Core /
     embeddings) still happens locally up front; only the answering is batched.
 
     Pinned to the claude model — the offline stub has nothing to batch.
diff --git a/decisiongrounding/scripts/report.py b/decisiongrounding/scripts/report.py
index 66de176..6fbb032 100644
--- a/decisiongrounding/scripts/report.py
+++ b/decisiongrounding/scripts/report.py
@@ -38,7 +38,7 @@
     "naive_rag": "embeds the corpus and retrieves the top-k chunks (classic RAG)",
     "naive_rag_full": "cosine retrieval, but supplies each top hit's WHOLE artifact (whole-artifact granularity at equal retrieval)",
     "no_grounding": "supplies nothing — the answering model's parametric memory only (control)",
-    "rac": "supplies typed, supersession-aware grounding assembled by the rac CLI",
+    "rac": "supplies typed, supersession-aware grounding assembled by AsDecided Core",
     "rac_snippets": "rac's typed retrieval, but supplies section snippets under naive_rag's token budget (equal-budget typed retrieval)",
     "memory_provider": "a pluggable external memory provider (stub)",
 }
@@ -178,7 +178,7 @@ def _offline_cost_curve(dataset: dict, pool_dir=None, scen_dir=None) -> dict | N
     """Measure mean grounding tokens per (arm, N) WITHOUT answering calls.
     Reconstructs the same corpora as the crossover and only assembles grounding.
     Free: uses the local-hash embedder (token COUNT of top-k is ~embedder
-    independent) and the rac CLI. Returns {arm: {N: mean_tokens}} or None."""
+    independent) and AsDecided Core. Returns {arm: {N: mean_tokens}} or None."""
     from scenarios.loader import load_pool, load_scenarios
     from scoring.crossover import DISCRIMINATING, make_real_distractors
     from providers import build_provider, ScriptedAnsweringModel
diff --git a/decisiongrounding/tests/test_hardening.py b/decisiongrounding/tests/test_hardening.py
index b2f99f2..857e94f 100644
--- a/decisiongrounding/tests/test_hardening.py
+++ b/decisiongrounding/tests/test_hardening.py
@@ -44,11 +44,11 @@ def test_preflight_claude_without_backend_fails_fast(monkeypatch):
 
 
 def test_preflight_rac_arm_without_cli_fails_fast(monkeypatch):
-    # Point RAC_BIN at something guaranteed absent so the check is hermetic.
-    monkeypatch.setenv("RAC_BIN", "definitely-not-a-real-binary-xyz")
+    # Point DECIDED_BIN at something guaranteed absent so the check is hermetic.
+    monkeypatch.setenv("DECIDED_BIN", "definitely-not-a-real-binary-xyz")
     with pytest.raises(SystemExit) as exc:
         _preflight(("rac",), "offline-stub", "local-hash")
-    assert "rac" in str(exc.value)
+    assert "AsDecided Core" in str(exc.value)
 
 
 def test_preflight_offline_default_passes(monkeypatch):
diff --git a/decisiongrounding/tests/test_parity_arms.py b/decisiongrounding/tests/test_parity_arms.py
index d522a4c..4765cb5 100644
--- a/decisiongrounding/tests/test_parity_arms.py
+++ b/decisiongrounding/tests/test_parity_arms.py
@@ -98,7 +98,7 @@ def test_rac_snippets_grounding_within_budget(monkeypatch):
     sc = load_scenarios(_SCENARIOS)[0]
     p = RacSnippetsProvider(ScriptedAnsweringModel(), token_budget=200)
     p._by_id = {a.id: a for a in sc.corpus}
-    # Bypass the rac CLI: _resolve just returns the corpus ids in order.
+    # Bypass Core: _resolve just returns the corpus ids in order.
     monkeypatch.setattr(p, "_resolve", lambda task: [a.id for a in sc.corpus])
     g = p.assemble(sc.task)
     assert g.text  # non-empty when candidates exist
@@ -148,9 +148,9 @@ def test_naive_rag_full_run_one_is_schema_valid():
 # ---------------------------------------------------------------- preflight
 
 
-def test_preflight_requires_rac_cli_for_rac_snippets(monkeypatch):
+def test_preflight_requires_core_cli_for_rac_snippets(monkeypatch):
     from runner.cli import _preflight
 
     monkeypatch.setattr(shutil, "which", lambda *_a, **_k: None)
-    with pytest.raises(SystemExit, match="rac"):
+    with pytest.raises(SystemExit, match="AsDecided Core"):
         _preflight(("rac_snippets",), "offline-stub", "local-hash")
diff --git a/decisiongrounding/tests/test_rac_version.py b/decisiongrounding/tests/test_rac_version.py
index 49c292b..375a703 100644
--- a/decisiongrounding/tests/test_rac_version.py
+++ b/decisiongrounding/tests/test_rac_version.py
@@ -1,12 +1,11 @@
-"""rac --version provenance: the system under test is recorded in every
-report (backend_versions) and crossover envelope (rac_version)."""
+"""AsDecided Core provenance for the stable rac experimental arms."""
 
 import stat
 from pathlib import Path
 
 import pytest
 
-from providers.rac import _rac_version, rac_version
+from providers.rac import _core_version, core_version
 from runner.cli import _backend_versions
 from scenarios.loader import load_scenarios
 from scoring.crossover import build_dataset
@@ -17,64 +16,74 @@
 
 @pytest.fixture(autouse=True)
 def _fresh_version_cache():
-    _rac_version.cache_clear()
+    _core_version.cache_clear()
     yield
-    _rac_version.cache_clear()
+    _core_version.cache_clear()
 
 
-def _fake_rac(tmp_path, body):
-    p = tmp_path / "rac"
+def _fake_decided(tmp_path, body):
+    p = tmp_path / "decided"
     p.write_text("#!/bin/sh\n" + body, encoding="utf-8")
     p.chmod(p.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
     return p
 
 
-def test_rac_version_unavailable(monkeypatch):
-    monkeypatch.setenv("RAC_BIN", "/nonexistent/rac-binary")
-    assert rac_version() is None
+def test_core_version_unavailable(monkeypatch):
+    monkeypatch.setenv("DECIDED_BIN", "/nonexistent/decided-binary")
+    assert core_version() is None
 
 
-def test_rac_version_from_fake_binary(tmp_path, monkeypatch):
-    monkeypatch.setenv("RAC_BIN", str(_fake_rac(tmp_path, 'echo "rac 9.9.9"\n')))
-    assert rac_version() == "rac 9.9.9"
+def test_core_version_from_fake_binary(tmp_path, monkeypatch):
+    monkeypatch.setenv(
+        "DECIDED_BIN", str(_fake_decided(tmp_path, 'echo "decided 9.9.9"\n'))
+    )
+    assert core_version() == "decided 9.9.9"
 
 
-def test_rac_version_none_on_nonzero_exit(tmp_path, monkeypatch):
-    monkeypatch.setenv("RAC_BIN", str(_fake_rac(tmp_path, "exit 3\n")))
-    assert rac_version() is None
+def test_core_version_none_on_nonzero_exit(tmp_path, monkeypatch):
+    monkeypatch.setenv("DECIDED_BIN", str(_fake_decided(tmp_path, "exit 3\n")))
+    assert core_version() is None
 
 
-def test_rac_version_cached_per_bin(tmp_path, monkeypatch):
+def test_core_version_cached_per_bin(tmp_path, monkeypatch):
     marker = tmp_path / "calls"
-    monkeypatch.setenv("RAC_BIN", str(_fake_rac(
-        tmp_path, f'echo x >> "{marker}"\necho "rac 1.0"\n')))
-    assert rac_version() == "rac 1.0"
-    assert rac_version() == "rac 1.0"
+    monkeypatch.setenv("DECIDED_BIN", str(_fake_decided(
+        tmp_path, f'echo x >> "{marker}"\necho "decided 1.0"\n')))
+    assert core_version() == "decided 1.0"
+    assert core_version() == "decided 1.0"
     assert len(marker.read_text().splitlines()) == 1
 
 
-def test_backend_versions_includes_rac_when_present(tmp_path, monkeypatch):
-    monkeypatch.setenv("RAC_BIN", str(_fake_rac(tmp_path, 'echo "rac 2.0"\n')))
-    assert _backend_versions().get("rac") == "rac 2.0"
+def test_backend_versions_includes_core_when_present(tmp_path, monkeypatch):
+    monkeypatch.setenv(
+        "DECIDED_BIN", str(_fake_decided(tmp_path, 'echo "decided 2.0"\n'))
+    )
+    assert _backend_versions().get("asdecided_core") == "decided 2.0"
 
 
-def test_backend_versions_omits_rac_when_absent(monkeypatch):
-    monkeypatch.setenv("RAC_BIN", "/nonexistent/rac-binary")
-    assert "rac" not in _backend_versions()
+def test_backend_versions_omits_core_when_absent(monkeypatch):
+    monkeypatch.setenv("DECIDED_BIN", "/nonexistent/decided-binary")
+    assert "asdecided_core" not in _backend_versions()
 
 
-def test_envelope_rac_version_gating(monkeypatch):
-    monkeypatch.setenv("RAC_BIN", "/nonexistent/rac-binary")
+def test_envelope_system_under_test_gating(monkeypatch):
+    monkeypatch.setenv("DECIDED_BIN", "/nonexistent/decided-binary")
     ds = build_dataset(load_scenarios(_SCENARIOS),
                        arms=("context_dump", "naive_rag"), ns=(10,))
-    assert "rac_version" in ds
-    assert ds["rac_version"] is None
+    assert "system_under_test" in ds
+    assert ds["system_under_test"] is None
 
 
-def test_envelope_rac_version_recorded_for_rac_arm(tmp_path, monkeypatch):
+def test_envelope_core_version_recorded_for_rac_arm(tmp_path, monkeypatch):
     """The gate is on the arm list, not on whether the arm's cells succeed —
     with a fake binary the rac cells error out, but provenance still lands."""
-    monkeypatch.setenv("RAC_BIN", str(_fake_rac(tmp_path, 'echo "rac 3.1"\n')))
+    monkeypatch.setenv(
+        "DECIDED_BIN", str(_fake_decided(tmp_path, 'echo "decided 3.1"\n'))
+    )
     ds = build_dataset(load_scenarios(_SCENARIOS),
                        arms=("context_dump", "rac"), ns=(10,))
-    assert ds["rac_version"] == "rac 3.1"
+    assert ds["system_under_test"] == {
+        "product": "AsDecided Core",
+        "binary": "decided",
+        "version": "decided 3.1",
+    }
diff --git a/decisiongrounding/tests/test_real_backends.py b/decisiongrounding/tests/test_real_backends.py
index 07834c4..9aebe27 100644
--- a/decisiongrounding/tests/test_real_backends.py
+++ b/decisiongrounding/tests/test_real_backends.py
@@ -1,8 +1,8 @@
 """Cover the real-backend wiring: recall metric, supersedes resolution, pins.
 
 These exercise the offline-testable surface of Steps 1-3 (real answering model,
-real embeddings, rac arm). The backends that need network/credentials/the rac
-CLI are constructed but not invoked here.
+real embeddings, rac arm). The backends that need network/credentials or
+AsDecided Core are constructed but not invoked here.
 """
 
 from pathlib import Path
diff --git a/decisiongrounding/tests/test_real_scenarios.py b/decisiongrounding/tests/test_real_scenarios.py
index 134a3e0..b5be5e7 100644
--- a/decisiongrounding/tests/test_real_scenarios.py
+++ b/decisiongrounding/tests/test_real_scenarios.py
@@ -13,6 +13,7 @@
 
 import hashlib
 import json
+import os
 import shutil
 import subprocess
 from pathlib import Path
@@ -25,7 +26,8 @@
 from scenarios.loader import load_scenario, load_scenarios
 from scoring.scorer import score
 
-_HAS_RAC = shutil.which("rac") is not None
+_DECIDED_BIN = os.environ.get("DECIDED_BIN", "decided")
+_HAS_CORE = shutil.which(_DECIDED_BIN) is not None
 
 _ROOT = Path(__file__).resolve().parent.parent
 _REAL_DIR = _ROOT / "scenarios_real"
@@ -95,11 +97,11 @@ def test_query_tokens_keeps_salient_terms_drops_noise():
     assert "add" not in toks and "the" not in toks and "to" not in toks
 
 
-@pytest.mark.skipif(not _HAS_RAC, reason="rac CLI not on PATH")
+@pytest.mark.skipif(not _HAS_CORE, reason="AsDecided Core CLI not on PATH")
 def test_rac_arm_follows_supersedes_to_live_decision():
     """The rac arm must classify the PEPs, follow the supersedes edge, and supply
     the live successor (PEP-0440) rather than the superseded PEP-0386 — the whole
-    typed-retrieval thesis, exercised against the real rac CLI."""
+    typed-retrieval thesis, exercised against the real AsDecided Core CLI."""
     sc = load_scenario(_PILOT)
     arm = build_provider("rac", make_answering_model("offline-stub", 0), "local-hash")
     arm.prepare(list(sc.corpus))
@@ -109,13 +111,13 @@ def test_rac_arm_follows_supersedes_to_live_decision():
     assert "PEP-0386" not in supplied, f"superseded decision was not dropped: {supplied}"
 
 
-@pytest.mark.skipif(not _HAS_RAC, reason="rac CLI not on PATH")
+@pytest.mark.skipif(not _HAS_CORE, reason="AsDecided Core CLI not on PATH")
 def test_rac_corpus_relationships_resolve_cleanly():
-    """`rac relationships --validate` must resolve the Supersedes reference; a
+    """`decided relationships --validate` must resolve the Supersedes reference; a
     dangling reference would mean the rac arm can't follow the edge."""
     corpus_dir = _PILOT / "corpus"
     out = subprocess.run(
-        ["rac", "relationships", str(corpus_dir), "--validate", "--json"],
+        [_DECIDED_BIN, "relationships", str(corpus_dir), "--validate", "--json"],
         capture_output=True,
         text=True,
     )