Merge remote-tracking branch 'origin/main' into HEAD

Author: Grace Lee Rui Yue

.agents/skills/jacobian-math/SKILL.md

@@ -22,7 +22,7 @@ Keep decomposition and routing decisions agent-owned; composing already-known
 supporting operations remains allowed when clearer.
 Do not call Jacobian for definitions, formatting, or non-execution tasks.
 
-No discovery for stable producers: `{"capability_id":"<id>","input":<JSON>}`.
+No discovery for stable producers: `{"capability_id":"<id>","payload":<JSON>}`.
 Payloads:
 
 - `integer.compute.gcd`, `integer.compute.lcm`, or `integer.compute.extended_gcd`:

.github/ci-impact.json

@@ -57,9 +57,7 @@
       "providers": [
         "cvc5",
         "external_sat",
-        "flint",
-        "graph",
-        "sympy"
+        "flint"
       ]
     },
     "lean": {
@@ -663,9 +661,7 @@
       "patterns": [
         "tests/boundary/providers/cvc5/**",
         "tests/boundary/providers/external_sat/**",
-        "tests/boundary/providers/flint/**",
-        "tests/boundary/providers/graph/**",
-        "tests/boundary/providers/sympy/**"
+        "tests/boundary/providers/flint/**"
       ],
       "suites": [
         "provider",

AGENTS.md

@@ -76,6 +76,12 @@ representations differ. Cover producer-to-consumer compatibility and canonical
 or backend-native round trips in tests. Architecture checks must reject internal
 JSON round-trips and unsafe canonical conversions.
 
+Shared Pydantic mathematical contracts own provider-independent value identity.
+Domain-owned conversions connect them to backend-native computational values,
+and typed kernels sit below both capability operations and `jacobian.math`. Do
+not add a universal backend wrapper, automatic coercion framework, generic
+conversion language, or second semantic type system above maintained libraries.
+
 Canonical decimal strings are wire and persistence values, not computational
 values. Use the canonical conversion API before calling backends or constructing
 results. Do not directly apply `int()` or `str()` to canonical components or

docs/explanation/architecture.md

@@ -256,6 +256,46 @@ verification obligations remain visible; artifacts are materialized only when
 durable identity, independent retrieval, replay, resumability, evidence
 binding, or size-separated transport requires them.
 
+### Mathematical value and backend layers
+
+Shared Pydantic mathematical contracts own provider-independent value identity:
+the exact parent or coefficient domain, axes, basis, ordering, canonical
+representation, and other facts that change mathematical interpretation.
+Backend-native objects are computational representations of those values, not
+composition, wire, or persistence identities.
+
+```text
+jacobian.contracts
+    shared mathematical values
+             │
+             ▼
+jacobian.domains.<domain>
+    explicit contract ↔ backend conversions
+    typed mathematical kernels
+             │
+       ┌─────┴──────────────┐
+       ▼                    ▼
+jacobian.math        operation declarations
+native facade                 │
+                              ▼
+                        math.find / math.run
+```
+
+Conversions between a shared contract and SymPy, FLINT, NetworkX, or another
+maintained backend are explicit and domain-owned. The native API and catalog
+operations call the same typed kernels; neither calls through the other.
+Provider selection, invocation provenance, persistence, MCP transport, and
+checker assurance remain outside the mathematical value. A change of backend
+therefore does not change value identity unless it also changes mathematical
+meaning or canonicalization.
+
+This is a dependency direction, not a universal algebra framework. Jacobian
+does not add a second semantic type system, unrestricted backend wrapper,
+automatic coercion graph, or generic conversion language above its maintained
+libraries. Mathematical transformations such as basis change, restriction of
+scalars, quotient reduction, and nontrivial reindexing remain explicit
+domain-owned operations.
+
 ### Domain operation library
 
 Built-in mathematical producers live in explicit domain packages. A package

docs/explanation/product-blueprint.md

@@ -114,7 +114,10 @@ checker tools →  optional independent check of specific claims
 Shared mathematical objects (matrices, polynomials, graphs, …) are canonical
 values. Object validity is not a promise that every tool will accept them under
 every budget. Small results stay inline; do not materialize only to pass
-between ordinary tools.
+between ordinary tools. Their mathematical identity is independent of the
+operation or backend that produced them, the invocation record, and whether
+the value travels inline, through a request-local reference, or as a durable
+artifact.
 
 “Investigate this conjecture” is an **agent workflow** over many tool calls,
 not one primitive. Jacobian does not add top-level MCP tools for workflows.

docs/reference/domain-operation-library.md

@@ -61,9 +61,11 @@ The installer validates the complete request model before computation. On
 success it validates the returned result again and returns it inline as
 `COMPLETE · COMPUTED`, without generic input or result artifacts and without an
 episode. Neither exact arithmetic nor deterministic execution grants
-`VERIFIED`. A reusable mathematical object or evidence-bearing result belongs
-in an explicitly artifact-producing capability, not behind a persistence flag
-on an ordinary computation.
+`VERIFIED`. A bounded reusable mathematical value remains inline. Materialize
+it only when durable identity, independent retrieval, replay, resumability,
+evidence binding, or size-separated transport is part of the outcome; this is
+an explicit capability contract, not a persistence flag on an ordinary
+computation.
 
 ### Static type contract
 
@@ -98,14 +100,27 @@ SymPy, or NetworkX values as documented and call typed mathematical kernels
 directly. They do not construct the capability runtime or route through
 `math.run`.
 
-When a native function corresponds to a capability, both paths share the same
-domain-owned mathematical kernel. Explicit adapters translate between native
-values and the existing Pydantic request and result contracts. This keeps one
-mathematical implementation while preserving capability schemas, completeness,
-provenance, verification behavior, and artifact lineage when artifacts are
-part of the outcome. Generic
-reflection, automatic model generation, and universal value conversion are
-outside this library's contract.
+Shared Pydantic contracts own provider-independent mathematical value identity
+at capability, composition, wire, and persistence boundaries. Backend-native
+objects are in-process computational representations. Domain-owned adapters
+translate explicitly between the two, and typed kernels sit below both the
+native facade and capability operations:
+
+```text
+shared Pydantic value
+    ↕ explicit domain-owned conversion
+backend-native value
+    ↕ typed mathematical kernel
+maintained mathematical backend
+```
+
+When a native function corresponds to a capability, both paths share that
+kernel; neither invokes the other. This keeps one mathematical implementation
+while preserving capability schemas, completeness, provenance, verification
+behavior, and artifact lineage where those are part of the operation outcome.
+Generic reflection, automatic model generation, universal backend wrappers,
+automatic coercion, and a generic conversion framework are outside this
+library's contract.
 
 ## Bounded searches
 

docs/reference/python-api.md

@@ -38,4 +38,7 @@ This API shares typed mathematical kernels with the corresponding capability
 implementations, but it is not a facade over `math.run`. Capability
 requests, result contracts, artifacts, provenance, completeness, and
 verification remain available through the capability runtime and retain their
-existing wire semantics.
+existing wire semantics. Shared Pydantic contracts, rather than Python,
+SymPy, or NetworkX objects, own provider-independent value identity for
+capability composition and persistence. Explicit domain-owned conversions
+connect those contracts to the backend-native values accepted by this API.

docs/reference/testing-strategy.md

@@ -45,20 +45,29 @@ Lane identity also appears in Make targets and workflow jobs. Edit
 
 ### Hydration ladder
 
-Use the narrowest complete-runtime profile that proves the claim:
+Use the narrowest production service graph that proves the claim:
 
-1. `open_domain_services(bundle)` — one named domain bundle (producers only)
+1. `open_domain_services(...)` — foundational core/application services,
+   optionally with explicitly selected domain bundles (producers only)
 2. `open_exact_domain_services(bundle)` — one named domain bundle **with** its
    exact verification adapters (typed verified-domain seam)
-3. `attached_complete_runtime` — complete portfolio, **no** checker authority
+3. `open_reference_services(root, *names)` — only the explicitly selected
+   production reference installations
+4. `attached_complete_runtime` — complete portfolio, **no** checker authority
    (reference schemas/plugins are available without authorization)
-4. `attached_complete_runtime_read_only` — module-shared attached copy for
+5. `attached_complete_runtime_read_only` — module-shared attached copy for
    non-mutating catalog/discovery inspection (one private template copy per
    module; tests must not write artifacts or durable store state)
-5. `authorized_complete_runtime` — complete portfolio **with** authorized checkers
-6. `authorized_complete_runtime_read_only` — module-shared authorized copy for
+6. `authorized_complete_runtime` — complete portfolio **with** authorized checkers
+7. `authorized_complete_runtime_read_only` — module-shared authorized copy for
    non-mutating authorized catalog inspection
-7. `fresh_complete_runtime` — empty-root install / lifecycle ownership only
+8. `fresh_complete_runtime` — empty-root install / lifecycle ownership only
+
+When a focused capability is installed by a production installer rather than a
+`DomainBundle`, open `open_domain_services(...)` and run that installer plus its
+adapter registrations inside one `atomic_installation(...)` block. Preserve the
+production checker-authority decision in that graph. Do not reproduce portfolio
+installation policy in a test helper merely to avoid the complete runtime.
 
 Prefer `attached_*` over `fresh_*` whenever a private template copy isolates the
 mutation; reserve `fresh_*` for empty-root install and lifecycle ownership.

npm/skills/jacobian-math/SKILL.md

@@ -22,7 +22,7 @@ Keep decomposition and routing decisions agent-owned; composing already-known
 supporting operations remains allowed when clearer.
 Do not call Jacobian for definitions, formatting, or non-execution tasks.
 
-No discovery for stable producers: `{"capability_id":"<id>","input":<JSON>}`.
+No discovery for stable producers: `{"capability_id":"<id>","payload":<JSON>}`.
 Payloads:
 
 - `integer.compute.gcd`, `integer.compute.lcm`, or `integer.compute.extended_gcd`:

src/jacobian/domains/arithmetic/rationals.py

@@ -250,9 +250,12 @@
         "predicate",
         invocation_examples=(
             example(
-                "equal_two_fourths_one_half",
-                "Check equality of two equivalent rationals.",
-                {"left": {"num": "2", "den": "4"}, "right": {"num": "1", "den": "2"}},
+                "equal_negative_one_half_negative_one_half",
+                "Check equality of two reduced equivalent rationals.",
+                {
+                    "left": {"num": "-1", "den": "2"},
+                    "right": {"num": "-1", "den": "2"},
+                },
             ),
         ),
     ),