Merge remote-tracking branch 'origin/agent/fix-discrete-log-example-budget' 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`:

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.

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/number_theory/discrete_logarithm.py

@@ -168,7 +168,7 @@ def _obligation(
                 "base": 2,
                 "target": 1,
                 "modulus": 3,
-                "resource_budget": {"wall_seconds": 1},
+                "resource_budget": {"wall_seconds": 5},
             },
         ),
     ),

tests/unit/domains/number_theory/test_discrete_logarithm_protocol.py

@@ -3,12 +3,21 @@
 import pytest
 from pydantic import ValidationError
 
+from jacobian.domains.number_theory.discrete_logarithm import (
+    DISCRETE_LOGARITHM_CAPABILITY,
+)
 from jacobian.domains.number_theory.discrete_logarithm_protocol import (
     PROTOCOL,
     DiscreteLogarithmWorkerResult,
 )
 
 
+def test_discrete_logarithm_example_budgets_isolated_worker_startup() -> None:
+    example = DISCRETE_LOGARITHM_CAPABILITY.invocation_examples[0]
+
+    assert example.input["resource_budget"]["wall_seconds"] == 5
+
+
 def test_discrete_logarithm_worker_result_rejects_unknown_fields() -> None:
     with pytest.raises(ValidationError, match="extra_forbidden"):
         DiscreteLogarithmWorkerResult.model_validate(

tests/unit/tooling/test_codex_visibility.py

@@ -3,6 +3,7 @@
 import json
 import math
 import re
+from inspect import Parameter, signature
 from pathlib import Path
 
 import pytest
@@ -20,6 +21,7 @@
 from benchmarks.tooling.command_runner import ToolCommandResult, ToolCommandStatus
 from pydantic import ValidationError
 
+from jacobian.adapters.mcp.tools import capability_invoke
 from jacobian.contracts.combinatorics import CyclicDifferenceSetExtensionRequest
 from jacobian.contracts.matrix_operations import MatrixDeterminantRequest
 from jacobian.contracts.number_theory import IntegerPairRequest
@@ -179,7 +181,12 @@ def test_codex_skill_keeps_bounded_stable_direct_run_contracts() -> None:
     assert polynomial in skill
     extension_payload = '{"base_elements":["1","2","4","8","13"],"target_order":7}'
     assert extension_payload in skill
-    assert '"input":<JSON>' in skill
+    run_parameters = signature(capability_invoke).parameters
+    assert tuple(run_parameters) == ("capability_id", "payload", "ctx")
+    assert run_parameters["ctx"].kind is Parameter.KEYWORD_ONLY
+    direct_envelope = f'{{"capability_id":"<id>","{tuple(run_parameters)[1]}":<JSON>}}'
+    assert direct_envelope in skill
+    assert '{"capability_id":"<id>","input":<JSON>}' not in skill
     assert "No discovery for stable producers" in skill
     assert "never with `capability_id`" in skill
     assert '"candidate":<producer output.result>' in skill