"Vibe-Trading: Your Personal Trading Agent"
Python ai-agentalgorithmic-tradingbacktestingfintechllmmcpmulti-agentpythonquantitative-financetrading
fix(agent): read percent-named evidence fields as points in derived-figure checks
Yufeng He3e7491df49be
diff --git a/agent/src/agent/grounding/policies.py b/agent/src/agent/grounding/policies.pyindex 5a6cb0e9d..32ec10eb6 100644--- a/agent/src/agent/grounding/policies.py+++ b/agent/src/agent/grounding/policies.py@@ -166,6 +166,12 @@ def _explicit_sign(text: str) -> int:return 1 if head == "+" else -1 if head == "-" else 0+def _is_percent_field(name: str) -> bool:+ """Whether a field name says its value is already in percentage points."""+ lowered = name.lower()+ return "percent" in lowered or "pct" in lowered or lowered.endswith("%")++def _is_plain_count(figure: Figure) -> bool:"""Whether a figure can be a count or a parameter the model chose.@@ -1805,17 +1811,20 @@ class _PolicyMixin:money: bool = False,percent: bool = False,scalar_parameters: Sequence[float] = (),- ) -> tuple[float, list[float]] | str | None:+ ) -> tuple[float, list[float], bool] | str | None:"""Evaluate a declaration's note as an observation-anchored formula.- Returns the ``(result, operands)`` pair when the note is arithmetic- over at least two operands. Data operands must be observed; chosen- scalar parameters must be declared and visible. Every added or+ Returns the ``(result, operands, points)`` triple when the note is+ arithmetic over at least two operands. Data operands must be observed;+ chosen scalar parameters must be declared and visible. Every added orsubtracted term still needs an observed anchor. Literal 1 is themultiplicative identity (also used in ratio-minus-one expressions),and square/cube exponents belong to the operator, not the operands.A percent claim's explicit trailing *100 is normalized as a unit- conversion before checking the remaining data operands.+ conversion before checking the remaining data operands. ``points`` is+ True when every data operand anchored only to percent-named fields+ (``changepercent`` and friends already carry points, #1820), so the+ caller compares the result against the percent figure directly."""if declaration is None or not declaration.note.strip():return "no_formula"@@ -1827,6 +1836,7 @@ class _PolicyMixin:# Normalize ONLY an outer, trailing literal *100 back to a fraction;# do not broaden result matching or exempt any inner data operand.# Numeric magnitude elsewhere never decides whether an operand is data.+ normalized_x100 = Falseif (percentand isinstance(tree.body, ast.BinOp)@@ -1838,6 +1848,7 @@ class _PolicyMixin:result /= 100operands = operands[:-1]tree = ast.Expression(body=tree.body.left)+ normalized_x100 = True# Two instruments' bars and no resolved symbol: arithmetic anchored on# the session's pools, or on one instrument's prints the ref names,# would look anchored with nothing to anchor it to. Only evidence that@@ -1887,22 +1898,96 @@ class _PolicyMixin:for operand in operands):return "operand_not_observed"- return result, operands+ # The result's unit follows the evidence the operands anchored to:+ # percent-named fields already carry points (#1820), an explicit+ # trailing *100 was normalized above, anything else is a fraction.+ points = (+ percent+ and not normalized_x100+ and self._operands_read_as_points(+ operands, symbol, records, scalar_parameters+ )+ )+ return result, operands, points++ def _operands_read_as_points(+ self,+ operands: Sequence[float],+ symbol: str | None,+ records: Sequence[EvidenceRecord],+ scalar_parameters: Sequence[float],+ ) -> bool:+ """Whether every data operand anchored only to percent-named fields.++ A field named ``changepercent`` already carries percentage points, so+ a formula over such fields evaluates in points and a percent figure+ must meet the result directly, not ``result * 100``. Conservative by+ construction: an operand whose magnitude also appears under a+ non-percent field makes the unit undecidable, and the caller keeps+ the fraction reading.+ """+ data = [+ operand+ for operand in operands+ if operand != 1+ and not any(+ math.isclose(abs(operand), abs(parameter), rel_tol=1e-12, abs_tol=0.0)+ for parameter in scalar_parameters+ )+ ]+ if not data:+ return False+ candidates = list(self._price_candidates(symbol, records))+ candidates += [+ record+ for record in self._evidence+ if record.status == "observed"+ and record.value is not None+ and record.tool in {"get_market_data", "bash"}+ and (not symbol or record.symbol == symbol)+ ]+ candidates += [+ record+ for record in self._evidence+ if record.status == "observed"+ and record.value is not None+ and _metric_kind_for_path(record.field) is not None+ and (not symbol or not record.symbol or record.symbol == symbol)+ ]+ for operand in data:+ saw_percent = saw_plain = False+ for record in candidates:+ if math.isclose(+ abs(float(record.value)), abs(operand), rel_tol=1e-9, abs_tol=1e-12+ ):+ if _is_percent_field(record.field):+ saw_percent = True+ else:+ saw_plain = True+ if not saw_percent or saw_plain:+ return False+ return True@staticmethod- def _result_matches(figure: Figure, result: float) -> bool:+ def _result_matches(figure: Figure, result: float, *, points: bool = False) -> bool:"""Whether a formula's result is the value the prose figure states.The band is half a unit of the last digit the PROSE was written with("约 37%" for 36.75%), so a coarser declaration cannot widen it. A "%"- figure is compared only in percentage points, since against the fraction- a half-unit band spans fifty points; a bare figure is tried both ways.+ figure is compared in one unit only, since against the other reading+ a half-unit band spans fifty points: against the fraction+ (``result * 100``) by default, against the points the formula+ evaluates to when every data operand came from a percent-named field+ (#1820). A bare figure is tried both ways.Magnitudes are compared, because a fall is noted either as``(low − high) / high`` or as the drop, unless the prose wrote a sign."""# The normalized reading, so "0,666" is three decimals and "−5,13%" is signed.half_unit = _written_half_unit(figure.digits or figure.text)- targets = {result * 100.0} if figure.percent else {result, result * 100.0}+ if figure.percent:+ targets = {result} if points else {result * 100.0}+ else:+ targets = {result, result * 100.0}sign = _explicit_sign(figure.sign or figure.text)value = abs(figure.value)return any(@@ -1949,16 +2034,19 @@ class _PolicyMixin:"least two operands with one of them observed in this session",)]- result, _ = derivation- if self._result_matches(figure, result):+ result, _, points = derivation+ if self._result_matches(figure, result, points=points):return []# Reported in the figure's own units, as ``_result_matches`` compares it.- scaled = result * 100.0 if figure.percent else result+ if figure.percent:+ scaled = result if points else result * 100.0+ else:+ scaled = resultshown = f"{scaled:.6g}%" if figure.percent else f"{scaled:.6g}"# "−1.51pp" beside "12.87% − 11.36%": the size is right and the formula# runs the other way. Still refused (the sign is part of the claim),# but said, or the model rewrites the number instead of the formula.- reversed_sign = self._result_matches(figure, -result)+ reversed_sign = self._result_matches(figure, -result, points=points)return [self._figure_issue("numeric_claim_conflict",diff --git a/agent/tests/test_grounding_percent_unit_fields.py b/agent/tests/test_grounding_percent_unit_fields.pynew file mode 100644index 000000000..76f6b3ae0--- /dev/null+++ b/agent/tests/test_grounding_percent_unit_fields.py@@ -0,0 +1,125 @@+"""Percent-unit evidence fields: a percent figure meets the formula's own unit.++Regression coverage for HKUDS/Vibe-Trading#1820: A-share rows carry fields+literally named ``changepercent`` whose values are already percentage points+(0.52 means 0.52%). A derived figure over such fields needs no trailing+``*100``, so the result is in points — but the gate compared percent figures+only against ``result * 100``. A correct claim was rejected, and the 100x+wrong claim passed; the model learned to write the wrong number.++The gate now follows the evidence: when every data operand anchors only to+percent-named fields, the result is read as points. Anything less certain+(mixed fields, a magnitude that also appears under a plain field) keeps the+fraction reading, so the fix never widens acceptance for ambiguous units.+"""++from __future__ import annotations++import json+from pathlib import Path++from src.agent.grounding import GroundingLedger+++def _ledger_with_rows(tmp_path: Path, rows: list[dict]) -> GroundingLedger:+ ledger = GroundingLedger(run_dir=tmp_path, user_message="Analyze 600519.SH")+ ledger.ingest_tool_result(+ tool_name="get_market_data",+ arguments={"codes": ["600519.SH"]},+ result=json.dumps({"600519.SH": rows}),+ call_id="quote",+ success=True,+ )+ return ledger+++def _verdict(ledger: GroundingLedger, value: str, expression: str) -> tuple[bool, set[str]]:+ result = ledger.validate_final_answer(+ f"600519.SH (CNY) move check: {value}.\n\n"+ f"```figures\n{value} | derived | scenario result: {expression} | quote\n```"+ )+ return result.valid, {issue.get("reason") for issue in result.issues}+++def test_percent_unit_fields_accept_the_correct_claim(tmp_path: Path) -> None:+ """changepercent 0.52 vs 1.41: the spread is -0.89 points, no *100 needed."""+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "changepercent": 0.52},+ {"trade_date": "2026-08-04", "changepercent": 1.41},+ ],+ )+ valid, reasons = _verdict(ledger, "-0.89%", "0.52 - 1.41")+ assert valid, reasons+++def test_percent_unit_fields_reject_the_hundredfold_wrong_claim(tmp_path: Path) -> None:+ """The claim the old code taught: -89% for a -0.89-point spread."""+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "changepercent": 0.52},+ {"trade_date": "2026-08-04", "changepercent": 1.41},+ ],+ )+ valid, reasons = _verdict(ledger, "-89%", "0.52 - 1.41")+ assert not valid+ assert "derivation_result_mismatch" in reasons+++def test_fraction_evidence_still_rejects_the_colliding_tiny_percent(tmp_path: Path) -> None:+ """Prices give a fraction (0.124); declaring 0.124% must stay refused.++ Symmetric matching would accept it and re-open the 100x hole from the+ other side; the unit is resolved from field names, not by trying both.+ """+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "close": 100.0},+ {"trade_date": "2026-09-02", "close": 112.4},+ ],+ )+ valid, reasons = _verdict(ledger, "0.124%", "(112.4 - 100.0) / 100.0")+ assert not valid+ assert "derivation_result_mismatch" in reasons+++def test_fraction_evidence_still_accepts_the_honest_percent(tmp_path: Path) -> None:+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "close": 100.0},+ {"trade_date": "2026-09-02", "close": 112.4},+ ],+ )+ valid, reasons = _verdict(ledger, "12.4%", "(112.4 - 100.0) / 100.0")+ assert valid, reasons+++def test_explicit_trailing_x100_still_normalizes(tmp_path: Path) -> None:+ """The pre-existing path: the note spells the unit conversion itself."""+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "close": 100.0},+ {"trade_date": "2026-09-02", "close": 112.4},+ ],+ )+ valid, reasons = _verdict(ledger, "12.4%", "(112.4 - 100.0) / 100.0 * 100")+ assert valid, reasons+++def test_mixed_fields_keep_the_fraction_reading(tmp_path: Path) -> None:+ """One percent field and one plain price: the unit is undecidable, so a+ points-shaped claim is refused exactly as before the fix."""+ ledger = _ledger_with_rows(+ tmp_path,+ [+ {"trade_date": "2026-08-03", "changepercent": 0.52, "close": 1.41},+ ],+ )+ valid, reasons = _verdict(ledger, "1.93%", "0.52 + 1.41")+ assert not valid+ assert "derivation_result_mismatch" in reasons