Clean up stale mode references in docs and tests

Update architecture/blueprint/tools docs to reflect completed CapabilityMode
removal. Rename test_descriptors_have_correct_ids_and_modes to drop "modes".
Fix stale EXPLORE comment in polynomial interval test.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: morluto

AGENTS.md

@@ -30,9 +30,8 @@ HEURISTIC/COMPUTED/VERIFIED slogans. Optional envelope fields may exist on the
 wire during migration; do not design new behavior around them as the product.
 
 **Checker tools are additional tools.** Independent check is a **separate
-catalog ID** (e.g. `….verify`, `lean.check`), not a mode on the producer. **No
-dual-mode tools.** Legacy `mode` / dual-mode descriptors:
-[#1143](https://github.com/morluto/jacobian/issues/1143).
+catalog ID** (e.g. `….verify`, `lean.check`), not a role on the producer. **No
+dual-mode tools.**
 
 - Server: typed contracts, resource bounds, catalog install, checker
   authorization.

docs/explanation/architecture.md

@@ -19,10 +19,8 @@ agent
 
 Ordinary tools return **calculations** (values) plus execution status. Checker
 tools are **additional catalog IDs** that return a check **verdict**; they are
-never a second mode on the same tool. Independent checkers are
-operator-authorized packages, not self-certified producer success. Legacy
-`mode` / dual-mode descriptors are tech debt
-([#1143](https://github.com/morluto/jacobian/issues/1143)).
+never a second role on the same tool. Independent checkers are
+operator-authorized packages, not self-certified producer success.
 
 Models, search algorithms, and domain solvers may be heuristic or incomplete.
 That does not change the product rule: return the math; use a separate tool
@@ -111,8 +109,7 @@ math.run
 - Checker tools: **separate IDs**; verdict from operator-authorized independent
   replay only.
 - Timeout, cancel, error, invalid input: non-conclusions.
-- No new dual-mode tools; split leftovers
-  ([#1143](https://github.com/morluto/jacobian/issues/1143)).
+- No dual-mode tools; checkers are separate catalog IDs.
 
 One `math.run` may call several backends only when they implement **one**
 agent-visible outcome.

docs/explanation/product-blueprint.md

@@ -98,10 +98,8 @@ share an ID with the producer.
 
 Rules:
 
-- **No dual-mode tools.** One ID is not both “compute X” and “verify X.”
-- **No explore/verify research modes** as product design. Legacy wire `mode`
-  fields are scheduled for removal
-  ([#1143](https://github.com/morluto/jacobian/issues/1143)).
+- **No dual-mode tools.** One ID is not both "compute X" and "verify X."
+- **No explore/verify research modes** as product design.
 - **Failed or incomplete runs are not mathematical conclusions.**
 - **Producers do not self-certify** as independently verified theorems.
 
@@ -188,9 +186,6 @@ Illustrative catalog entries (not a closed ontology):
 Example composition: put or compute values → search → optionally run
 `witness.verify` on a found witness. Two tools, not one dual-mode tool.
 
-Dual-mode leftovers (one ID advertising both compute and verify) are tech debt
-to split; do not add more.
-
 ## Local and remote hosts
 
 The local Codex host uses STDIO. It exposes `capability://catalog`,

docs/index.md

@@ -9,7 +9,7 @@ read the explanations for design rationale.
 Jacobian is a **toolbox of atomic math tools** for AI agents: find them with
 `math.find`, run them with `math.run`, get **mathematical results**, and
 compose those values across turns. Checker tools are optional **additional**
-catalog IDs—not dual-mode producers. Catalog entries are often still called
+catalog IDs—separate from producers. Catalog entries are often still called
 *capabilities* in the API. The [product model](explanation/product-blueprint.md)
 and [Search and execute](explanation/architecture.md#search-and-execute) define
 the contract.

docs/reference/tools.md

@@ -41,21 +41,12 @@ descriptor.
 3. Execution status as above.
 
 There are **no dual-mode tools** in the product model: one ID is not both
-“compute X” and “independently verify X.” Use two IDs (e.g.
+"compute X" and "independently verify X." Use two IDs (e.g.
 `polynomial.compute.gcd` and `polynomial.gcd.verify`).
 
 Failed or incomplete runs are not mathematical conclusions. A successful
 ordinary run is a value, not a self-certified theorem.
 
-### Legacy wire (migration)
-
-Until [#1143](https://github.com/morluto/jacobian/issues/1143):
-
-- `mode` (`EXPLORE` | `VERIFY`) may still appear on `math.run` / find filters.
-- Envelope fields such as `assurance` may still be present.
-- Do not design new tools or agent guidance around them.
-- Split any remaining dual-mode descriptors into two tools.
-
 Domain adapters validate the full Pydantic request before work. JSON Schema is
 for discovery; Pydantic owns cross-field rules.
 

src/jacobian/adapters/mcp/tools.py

@@ -667,7 +667,7 @@ async def capability_invoke(
     *,
     ctx: Context[AppState, Any],
 ) -> CapabilityRunToolResult:
-    """Run one math tool. Role comes from the tool ID, not a mode switch."""
+    """Run one math tool. Role comes from the tool ID."""
     with _runtime(ctx) as active_runtime:
         result = await _invoke_capability_attempt(
             active_runtime,

tests/boundary/providers/lean/test_lean_statement_capabilities.py

@@ -520,7 +520,7 @@ def test_compare_rejects_forbidden_statement(tmp_path: Path) -> None:
 # ---------------------------------------------------------------------------
 
 
-def test_descriptors_have_correct_ids_and_modes(tmp_path: Path) -> None:
+def test_descriptors_have_correct_ids(tmp_path: Path) -> None:
     propose, compare = _build_adapters(tmp_path)
 
     assert propose.descriptor.capability_id == "lean.statement.propose"

tests/domain/polynomial/test_polynomial_interval_capabilities.py

@@ -129,7 +129,7 @@ def test_verify_capability_confirms_a_valid_enclosure(installation) -> None:
     enclose, verify = adapters
     assert verify is not None
 
-    # First compute the enclosure via EXPLORE, then verify the claimed values.
+    # First compute the enclosure, then verify the claimed values.
     enclose_result = enclose.invoke(
         CapabilityRequest(
             capability_id="polynomial.interval.enclose",