quantnodes 3.0.0__tar.gz → 3.0.1__tar.gz

{quantnodes-3.0.0 → quantnodes-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantnodes
-Version: 3.0.0
+Version: 3.0.1
 Summary: AI-native quantitative research framework with symbolic computation and SQL pushdown
 Author-email: sn0wfree <snowfreedom0815@gmail.com>
 License: MIT

quantnodes-3.0.1/QuantNodes/agent/skills_quant/logic-mining/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: logic-mining
+description: 市场逻辑驱动的自动化因子挖掘 — Logic Mining + Γ 约束内层生成 + Wiki 沉淀。
+---
+
+# Logic Mining (v3.0.1)
+
+驱动 QuantNodes Logic Mining 端到端工作流：选取 source → 3-stage LLM 抽取逻辑 → 编译 Γ 约束 → 内层 Alpha-GPT 受约束生成因子 → 外层重构 → 写入 Wiki。
+
+## 工作流
+
+1. **选 source 与定逻辑种子** — 调用 `sources.list_available_sources` 列数据源 (`alpha101` / `alpha158` / `alpha191`)，`sources.get_formulas_from_source(lib, max_count=N, only_volume_price=True)` 加载前 N 条公式
+2. **3-stage 抽取逻辑** — 对每条公式:
+   - 调用 `LogicMiningPipeline.run(formula, source_lib=lib)` 走 3 个 sub-agent (structure / semantics / abstraction)
+   - 返回 `LogicAbstractionResult` 含 `structured_logic` (`WikiLogicStructured`)
+3. **编译 Γ 约束** — 调用 `logic_mining.compile_to_constraint(logic.structured, source_logic=name)` 生成 `CompiledConstraint`
+4. **注入 Alpha-GPT** — 在 `AlphaGptConfig.gamma = gamma` 透传；下游 `_step_formula_translator` 拒绝任何不符合 Γ 的公式
+5. **内层循环** — 调用 `AlphaGptWorkflow(config=...).run()`，产出 inner_results 与 per-logic `LogicPerformanceEvidence`
+6. **外层重构** — 调用 `MarketLogicGenerator.generate(library, current_logic, history, evidence, round_idx)` 与 `MarketLogicRefinementDirection.refine(...)` 进入下一轮 Algorithm 2 编排
+7. **沉淀 Wiki** — 调用 `wiki_write` 写入 `Logic/` 页面，附 Γ + evidence
+
+## 工具集
+
+| 工具 | 用途 |
+|------|------|
+| `logic_mine` | `mine_logic_from_formula(formula, source_lib, llm_client)` 走 3-stage |
+| `logic_compile` | `compile_to_constraint(logic, source_logic)` 生成 Γ |
+| `logic_refine` | `MarketLogicRefinementDirection.refine(current_logic, history, evidence)` |
+| `logic_validate` | `gamma.validate(formula_str)` 校验公式是否过 Γ |
+| `logic_library_build` | `build_initial_logic_library(source_libs, llm_client, max_per_lib)` |
+| `wiki_write` | 写入 Wiki Logic 页面 |
+
+## 验收标准
+
+- 初始逻辑库 ≥ 5 条 (从 alpha101 / alpha158 抽取)
+- 每条逻辑最终 γ.validate(formula) 在示例上通过
+- per-logic evidence 包含 `n_factors_explored` / `best_ir` / `best_ic`
+- IR 上升 → 窗口收窄 20% (Phase 3 P0-3 修复)
+- best_ic != best_ir (Phase 3 P0-2 修复)
+- alpha191 source 不再静默 (Phase 3 P0-1 修复)
+- silent fallback 通过 `pipeline.metrics` / `result.diagnostics` 暴露 (Phase 2)
+- 可选 `strict=StrictConfig(...)` 把失败升级为异常
+
+## 反模式
+
+- 不要直接调用 inner AlphaGptWorkflow 而跳过 3-stage logic 抽取（失去 Logic Mining 意义）
+- 不要忽略 `result.parse_error` / `result.diagnostics` 字段（silent fallback 信号）
+- 不要用 `best_ic` 字段当 IR 读 (v3.0.0 时期旧 docstring 是错的, P0-2 已修)
+- 不要在 IR 上升时反转 sign（这是 IR 下降的响应）
+- 不要修改 alpha191 数据源逻辑，它是 OHLCV-only 守卫

{quantnodes-3.0.0 → quantnodes-3.0.1}/QuantNodes/research/quant_alpha/logic_driven_pipeline.py

@@ -41,6 +41,8 @@ import polars as pl
 from QuantNodes.research.quant_alpha.logic_mining import (
     WikiLogicStructured,
     LogicPerformanceEvidence,
+    PipelineMetrics,
+    StrictConfig,
 )
 from QuantNodes.research.quant_alpha.pipeline import (
     AlphaPipeline,
@@ -124,6 +126,10 @@ class LogicDrivenPipelineConfig:
     alphalogics_initial_sources: Tuple[str, ...] = ("alpha101", "alpha158")
     alphalogics_initial_max_per_lib: int = 3
 
+    # v3.0.1 (Phase 2): silent fallback 可观测性
+    metrics: Optional[PipelineMetrics] = None
+    strict: Optional[StrictConfig] = None
+
     # 终止条件
     timeout_seconds: int = 3600
 
@@ -172,6 +178,8 @@ class LogicDrivenPipeline:
     ):
         self.config = config
         self.llm_client = llm_client
+        self.metrics: PipelineMetrics = config.metrics or PipelineMetrics()
+        self.strict: StrictConfig = config.strict or StrictConfig()
 
     def run(self, data: pl.DataFrame) -> LogicDrivenPipelineResult:
         """运行 Pipeline
@@ -273,6 +281,9 @@ class LogicDrivenPipeline:
             initial_logic_sources=self.config.alphalogics_initial_sources,
             initial_logic_max_per_lib=self.config.alphalogics_initial_max_per_lib,
             min_ir_threshold=self.config.min_ir_threshold,
+            # v3.0.1 (Phase 2): silent fallback 可观测性透传
+            metrics=self.metrics,
+            strict=self.strict,
         )
         workflow = AlphaLogicsWorkflow(config=config, llm_client=self.llm_client)
         return workflow.run()

{quantnodes-3.0.0 → quantnodes-3.0.1}/QuantNodes/research/quant_alpha/logic_mining/__init__.py

@@ -44,6 +44,11 @@ from QuantNodes.research.quant_alpha.logic_mining.generator import (
     MarketLogicRefinementDirection,
     generate_logic_name,
 )
+from QuantNodes.research.quant_alpha.logic_mining.metrics import (
+    PipelineMetrics,
+    StrictConfig,
+    LogicMiningStrictError,
+)
 
 __all__ = [
     # Models
@@ -71,4 +76,8 @@ __all__ = [
     "MarketLogicGenerator",
     "MarketLogicRefinementDirection",
     "generate_logic_name",
+    # Metrics (v3.0.1 Phase 2)
+    "PipelineMetrics",
+    "StrictConfig",
+    "LogicMiningStrictError",
 ]

{quantnodes-3.0.0 → quantnodes-3.0.1}/QuantNodes/research/quant_alpha/logic_mining/generator.py

@@ -35,6 +35,11 @@ from QuantNodes.research.quant_alpha.logic_mining.models import (
     LogicPerformanceEvidence,
     WikiLogicStructured,
 )
+from QuantNodes.research.quant_alpha.logic_mining.metrics import (
+    LogicMiningStrictError,
+    PipelineMetrics,
+    StrictConfig,
+)
 from QuantNodes.research.quant_alpha.logic_mining.parser import (
     parse_json_response,
 )
@@ -58,8 +63,18 @@ __all__ = [
 ]
 
 
-def _call_llm(llm_client: Any, agent_id: str, prompt: str, default_response: str) -> str:
-    """调用 LLM，无客户端或失败时返回 mock"""
+def _call_llm(
+    llm_client: Any,
+    agent_id: str,
+    prompt: str,
+    default_response: str,
+    metrics: Optional[PipelineMetrics] = None,
+    strict: Optional[StrictConfig] = None,
+) -> str:
+    """调用 LLM，无客户端或失败时返回 mock
+
+    v3.0.1 (Phase 2): metrics 接入与 strict 模式开关
+    """
     if llm_client is None:
         return default_response
     try:
@@ -68,6 +83,15 @@ def _call_llm(llm_client: Any, agent_id: str, prompt: str, default_response: str
         return llm_client(prompt)
     except Exception as e:
         logger.warning("LLM call failed for %s: %s, falling back to mock", agent_id, e)
+        if metrics is not None:
+            metrics.record_call_failure(agent_id)
+        if strict is not None and strict.call:
+            raise LogicMiningStrictError(
+                f"LLM call failed for {agent_id}: {e}",
+                kind="call",
+                agent_id=agent_id,
+                original_error=repr(e),
+            ) from e
         return default_response
 
 
@@ -171,9 +195,19 @@ class MarketLogicGenerator:
     """MarketLogicGeneratorAgent
 
     在初始轮基于 ℋ_init 发散生成；后续轮基于 ℋ_lib + 历史证据做有方向的生成/重构。
+
+    v3.0.1 (Phase 2): metrics/strict 入参透传给 _call_llm 与 _structured_from_dict
     """
     llm_client: Any = None
     base_name: str = "alpha_logic"
+    metrics: Optional[PipelineMetrics] = None
+    strict: Optional[StrictConfig] = None
+
+    def __post_init__(self) -> None:
+        if self.metrics is None:
+            self.metrics = PipelineMetrics()
+        if self.strict is None:
+            self.strict = StrictConfig()
 
     def generate(
         self,
@@ -206,11 +240,22 @@ class MarketLogicGenerator:
         # 调用 LLM
         prompt = _build_generator_prompt(library, current_logic, history, evidence, round_idx)
         raw = _call_llm(
-            self.llm_client, "market-logic-generator", prompt, mock_response
+            self.llm_client, "market-logic-generator", prompt, mock_response,
+            metrics=self.metrics, strict=self.strict,
         )
         result = parse_json_response(raw)
         if not result.ok:
             logger.warning("MarketLogicGenerator parse failed: %s, using mock data", result.error)
+            self.metrics.record_parse_failure("market-logic-generator", result.layer_reached)
+            if self.strict.parse:
+                raise LogicMiningStrictError(
+                    f"MarketLogicGenerator parse failed at layer {result.layer_reached}: "
+                    f"{result.error}",
+                    kind="parse",
+                    agent_id="market-logic-generator",
+                    layer=result.layer_reached,
+                    last_error=result.last_error,
+                )
             data = json.loads(mock_response)
         else:
             data = result.data
@@ -221,7 +266,15 @@ class MarketLogicGenerator:
             structured = _structured_from_dict(data)
         except Exception as e:
             logger.warning("Failed to build WikiLogicStructured: %s", e)
+            self.metrics.record_structured_failure("market-logic-generator")
             structured = None
+            if self.strict.structured:
+                raise LogicMiningStrictError(
+                    f"WikiLogicStructured build failed: {e}",
+                    kind="structured",
+                    agent_id="market-logic-generator",
+                    original_error=repr(e),
+                ) from e
 
         parent = current_logic.name if current_logic else None
         WikiLogic = _get_wiki_logic_class()
@@ -246,13 +299,18 @@ class MarketLogicGenerator:
         evidence: List[LogicPerformanceEvidence],
         round_idx: int,
     ) -> str:
-        """Mock 响应：基于历史证据趋势生成"""
+        """Mock 响应：基于历史证据趋势生成
+
+        v3.0.1 (Phase 3, P0-3):
+        - IR 上升: 窗口收窄 20% (在已有 parameter_ranges 上动), sign 保留
+        - IR 下降: 反转 sign
+        """
         # 基于当前逻辑变体
         if current_logic and current_logic.structured:
             base_predicates = [p.to_dict() for p in current_logic.structured.predicates]
             beh = current_logic.structured.behavior.to_dict()
             whitelist = current_logic.structured.operator_whitelist or ["rank"]
-            param_ranges = None
+            param_ranges: Dict[str, List[float]] = {}
             if current_logic.structured.parameter_ranges:
                 param_ranges = {
                     k: list(v)
@@ -268,12 +326,18 @@ class MarketLogicGenerator:
 
         # 根据 evidence 调整
         if evidence and len(evidence) >= 2:
-            # IR 提升则保持方向，否则反转
-            if evidence[-1].best_ir > evidence[-2].best_ir:
-                # 继续优化
-                pass
+            cur, prev = evidence[-1], evidence[-2]
+            if cur.best_ir > prev.best_ir and cur.n_factors_explored > 0:
+                # IR 提升 + 有可分析因子 → 窗口收窄 20%, 保留 sign
+                for op_key in list(param_ranges.keys()):
+                    lo, hi = param_ranges[op_key]
+                    if hi - lo > 1e-9:
+                        span = hi - lo
+                        new_lo = lo + span * 0.2
+                        new_hi = hi - span * 0.2
+                        param_ranges[op_key] = [new_lo, new_hi]
             else:
-                # 反转方向
+                # IR 未升 → 反转 sign
                 sign = -sign if sign else 1
 
         return json.dumps({
@@ -291,8 +355,18 @@ class MarketLogicRefinementDirection:
     """MarketLogicRefinementDirectionAgent
 
     综合所有该逻辑名下因子的回测表现，识别"逻辑过宽/过窄/与市场结构错配"的部分。
+
+    v3.0.1 (Phase 2): metrics/strict 入参透传
     """
     llm_client: Any = None
+    metrics: Optional[PipelineMetrics] = None
+    strict: Optional[StrictConfig] = None
+
+    def __post_init__(self) -> None:
+        if self.metrics is None:
+            self.metrics = PipelineMetrics()
+        if self.strict is None:
+            self.strict = StrictConfig()
 
     def refine(
         self,
@@ -323,11 +397,22 @@ class MarketLogicRefinementDirection:
         # 调用 LLM
         prompt = _build_refiner_prompt(current_logic, history, evidence)
         raw = _call_llm(
-            self.llm_client, "market-logic-refinement", prompt, mock_response
+            self.llm_client, "market-logic-refinement", prompt, mock_response,
+            metrics=self.metrics, strict=self.strict,
         )
         result = parse_json_response(raw)
         if not result.ok:
             logger.warning("Refinement parse failed: %s, using mock", result.error)
+            self.metrics.record_parse_failure("market-logic-refinement", result.layer_reached)
+            if self.strict.parse:
+                raise LogicMiningStrictError(
+                    f"MarketLogicRefinement parse failed at layer {result.layer_reached}: "
+                    f"{result.error}",
+                    kind="parse",
+                    agent_id="market-logic-refinement",
+                    layer=result.layer_reached,
+                    last_error=result.last_error,
+                )
             data = json.loads(mock_response)
         else:
             data = result.data

quantnodes-3.0.1/QuantNodes/research/quant_alpha/logic_mining/metrics.py

@@ -0,0 +1,134 @@
+# coding=utf-8
+"""
+metrics.py - Logic Mining 可观测性 & 严格模式
+
+Phase 2 (v3.0.1) 引入。为 silent-fallback 提供可观测指标，
+允许外部代码在 strict=True 时升级异常。
+
+设计要点:
+- 6 类计数 (call_failures / parse_failures / parse_layer_reached /
+  structured_failures / wiki_failures / inner_loop_failures)
+- PipelineMetrics 实例默认字段为空, 跨阶段共享
+- StrictConfig: 三挡开关 (call/parse/structured) 默认全 False
+- LogicMiningStrictError: strict=True 下静默升级为异常
+
+Usage::
+
+    from QuantNodes.research.quant_alpha.logic_mining.metrics import (
+        PipelineMetrics, StrictConfig, LogicMiningStrictError,
+    )
+
+    metrics = PipelineMetrics()
+    strict = StrictConfig(parse=True)
+
+    pipeline = LogicMiningPipeline(llm_client=client, metrics=metrics, strict=strict)
+    ...
+    print(metrics.to_dict())
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any, DefaultDict, Dict, Optional
+
+
+@dataclass
+class StrictConfig:
+    """严格模式配置: 控制哪些 silent fallback 升级为异常
+
+    Attributes:
+        call:       True 时 LLM 调用失败抛 LogicMiningStrictError
+        parse:      True 时 JSON parse 失败抛 LogicMiningStrictError
+        structured: True 时 WikiLogicStructured 构建失败抛 LogicMiningStrictError
+    """
+    call: bool = False
+    parse: bool = False
+    structured: bool = False
+
+    @classmethod
+    def all_off(cls) -> "StrictConfig":
+        return cls()
+
+
+@dataclass
+class PipelineMetrics:
+    """Logic Mining 可观测性指标
+
+    全部为弱默认, 调用方无须设置即可使用。线程不安全 (单线程 pipeline)
+    """
+    call_failures: DefaultDict[str, int] = field(default_factory=lambda: defaultdict(int))
+    parse_failures: DefaultDict[str, int] = field(default_factory=lambda: defaultdict(int))
+    parse_layer_reached: DefaultDict[str, int] = field(default_factory=lambda: defaultdict(int))
+    structured_failures: DefaultDict[str, int] = field(default_factory=lambda: defaultdict(int))
+    wiki_failures: int = 0
+    inner_loop_failures: int = 0
+
+    def record_call_failure(self, agent_id: str) -> None:
+        """记录 LLM 调用失败"""
+        self.call_failures[agent_id] += 1
+
+    def record_parse_failure(self, agent_id: str, layer_reached: int) -> None:
+        """记录 JSON 解析失败 + 最远触达层"""
+        self.parse_failures[agent_id] += 1
+        cur = self.parse_layer_reached[agent_id]
+        if layer_reached > cur:
+            self.parse_layer_reached[agent_id] = layer_reached
+
+    def record_structured_failure(self, agent_id: str) -> None:
+        """记录 WikiLogicStructured 数据解析失败"""
+        self.structured_failures[agent_id] += 1
+
+    def record_wiki_failure(self) -> None:
+        """记录 Wiki persistence 失败"""
+        self.wiki_failures += 1
+
+    def record_inner_loop_failure(self) -> None:
+        """记录内层 AlphaGptWorkflow 失败"""
+        self.inner_loop_failures += 1
+
+    def to_dict(self) -> Dict[str, Any]:
+        """导出为可序列化字典"""
+        return {
+            "call_failures": dict(self.call_failures),
+            "parse_failures": dict(self.parse_failures),
+            "parse_layer_reached": dict(self.parse_layer_reached),
+            "structured_failures": dict(self.structured_failures),
+            "wiki_failures": self.wiki_failures,
+            "inner_loop_failures": self.inner_loop_failures,
+        }
+
+    def total_failures(self) -> int:
+        """总失败计数"""
+        return (
+            sum(self.call_failures.values())
+            + sum(self.parse_failures.values())
+            + sum(self.structured_failures.values())
+            + self.wiki_failures
+            + self.inner_loop_failures
+        )
+
+
+class LogicMiningStrictError(RuntimeError):
+    """strict=True 模式下静默失败升级为异常
+
+    异常 message 包含:
+    - kind: 'call' / 'parse' / 'structured' / 'wiki' / 'inner_loop'
+    - agent_id / layer / 等上下文
+    """
+
+    def __init__(self, message: str, *, kind: str, **context: Any) -> None:
+        super().__init__(message)
+        self.kind = kind
+        self.context: Dict[str, Any] = dict(context)
+
+    def __repr__(self) -> str:
+        ctx = ", ".join(f"{k}={v!r}" for k, v in self.context.items())
+        return f"LogicMiningStrictError({self.kind}, {ctx}): {self.args[0]}"
+
+
+__all__ = [
+    "PipelineMetrics",
+    "StrictConfig",
+    "LogicMiningStrictError",
+]

{quantnodes-3.0.0 → quantnodes-3.0.1}/QuantNodes/research/quant_alpha/logic_mining/models.py

@@ -234,12 +234,16 @@ class LogicAbstractionResult:
         structured_logic: MarketLogicAbstractionAgent 输出
         source_formula: 原始公式
         source_lib: 来源库 ("alpha101" / "alpha158" / "alpha191")
+        parse_error:   v3.0.1 暴露三段式 parse 失败原因 (None=全成功)
+        parse_layer:   v3.0.1 记录最远触达的 layer (1/2/3), 0=空
     """
     formula_structure: Dict[str, Any] = field(default_factory=dict)
     financial_semantics: Dict[str, Any] = field(default_factory=dict)
     structured_logic: Optional[WikiLogicStructured] = None
     source_formula: str = ""
     source_lib: str = ""
+    parse_error: Optional[str] = None
+    parse_layer: int = 0
 
     def to_dict(self) -> Dict[str, Any]:
         """转换为字典"""
@@ -249,4 +253,6 @@ class LogicAbstractionResult:
             "structured_logic": self.structured_logic.to_dict() if self.structured_logic else None,
             "source_formula": self.source_formula,
             "source_lib": self.source_lib,
+            "parse_error": self.parse_error,
+            "parse_layer": self.parse_layer,
         }

{quantnodes-3.0.0 → quantnodes-3.0.1}/QuantNodes/research/quant_alpha/logic_mining/parser.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 import json
 import logging
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Tuple
 
 logger = logging.getLogger(__name__)
@@ -41,11 +41,24 @@ __all__ = [
 
 @dataclass
 class ParseResult:
-    """JSON 解析结果"""
+    """JSON 解析结果 (v3.0.1: 新增 layer_reached / last_error / layer_errors)
+
+    Attributes:
+        ok:              是否成功解析
+        data:            成功时的 dict (其余情况为 None)
+        error:           失败原因 (聚合)
+        raw:             原始输入文本
+        layer_reached:   触达的最高层 (0=空/未尝试, 1=直接, 2=md fence, 3=brace)
+        last_error:      最近一次的 JSONDecodeError 文本
+        layer_errors:    各层的错误文本 (用于定位失败层)
+    """
     ok: bool
     data: Optional[Dict[str, Any]] = None
     error: Optional[str] = None
     raw: str = ""
+    layer_reached: int = 0
+    last_error: Optional[str] = None
+    layer_errors: Dict[int, str] = field(default_factory=dict)
 
 
 def parse_json_response(raw: str) -> ParseResult:
@@ -59,34 +72,61 @@ def parse_json_response(raw: str) -> ParseResult:
         raw: LLM 输出文本
 
     Returns:
-        ParseResult
+        ParseResult — 失败时 layer_reached=0/1/2/3 标识最远触达层,
+        last_error 与 layer_errors 暴露每个被吞掉的 JSONDecodeError
     """
     if not raw:
-        return ParseResult(ok=False, error="empty response", raw=raw)
+        return ParseResult(
+            ok=False, error="empty response", raw=raw,
+            layer_reached=0, last_error=None, layer_errors={},
+        )
 
     # 第 1 层: 直接 JSON
     try:
-        return ParseResult(ok=True, data=json.loads(raw), raw=raw)
-    except json.JSONDecodeError:
-        pass
+        return ParseResult(
+            ok=True, data=json.loads(raw), raw=raw,
+            layer_reached=1, last_error=None, layer_errors={},
+        )
+    except json.JSONDecodeError as e:
+        first_err = str(e)
 
     # 第 2 层: 从 ```json ... ``` 中提取
     md_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", raw, re.DOTALL)
+    layer_errors: Dict[int, str] = {1: first_err}
     if md_match:
         try:
-            return ParseResult(ok=True, data=json.loads(md_match.group(1)), raw=raw)
-        except json.JSONDecodeError:
-            pass
+            return ParseResult(
+                ok=True, data=json.loads(md_match.group(1)), raw=raw,
+                layer_reached=2, last_error=None, layer_errors=layer_errors,
+            )
+        except json.JSONDecodeError as e:
+            layer_errors[2] = str(e)
+            last_err = str(e)
+    else:
+        last_err = first_err
 
     # 第 3 层: 找第一个 {...} 块
     brace_match = re.search(r"\{.*\}", raw, re.DOTALL)
     if brace_match:
         try:
-            return ParseResult(ok=True, data=json.loads(brace_match.group(0)), raw=raw)
-        except json.JSONDecodeError:
-            pass
-
-    return ParseResult(ok=False, error="Cannot parse JSON after 3 layers", raw=raw)
+            return ParseResult(
+                ok=True, data=json.loads(brace_match.group(0)), raw=raw,
+                layer_reached=3, last_error=None, layer_errors=layer_errors,
+            )
+        except json.JSONDecodeError as e:
+            layer_errors[3] = str(e)
+            last_err = str(e)
+
+    # 全部失败
+    max_layer = max(layer_errors.keys()) if layer_errors else 0
+    return ParseResult(
+        ok=False,
+        error=f"Cannot parse JSON after 3 layers (last layer={max_layer})",
+        raw=raw,
+        layer_reached=max_layer,
+        last_error=last_err,
+        layer_errors=layer_errors,
+    )
 
 
 def parse_formula_structure(raw: str) -> ParseResult:
@@ -106,11 +146,21 @@ def parse_formula_structure(raw: str) -> ParseResult:
 
     data = result.data
     if not isinstance(data, dict):
-        return ParseResult(ok=False, error="data is not a dict", raw=raw)
+        return ParseResult(
+            ok=False, error="data is not a dict", raw=raw,
+            layer_reached=result.layer_reached,
+            last_error=result.last_error,
+            layer_errors=result.layer_errors,
+        )
 
     # 必填字段验证
     if "operations" not in data:
-        return ParseResult(ok=False, error="missing 'operations' field", raw=raw)
+        return ParseResult(
+            ok=False, error="missing 'operations' field", raw=raw,
+            layer_reached=result.layer_reached,
+            last_error=result.last_error,
+            layer_errors=result.layer_errors,
+        )
 
     # 填充默认值
     validated = {
@@ -140,7 +190,12 @@ def parse_financial_semantics(raw: str) -> ParseResult:
 
     data = result.data
     if not isinstance(data, dict):
-        return ParseResult(ok=False, error="data is not a dict", raw=raw)
+        return ParseResult(
+            ok=False, error="data is not a dict", raw=raw,
+            layer_reached=result.layer_reached,
+            last_error=result.last_error,
+            layer_errors=result.layer_errors,
+        )
 
     validated = {
         "price_role": data.get("price_role", "unknown"),
@@ -170,11 +225,21 @@ def parse_market_logic(raw: str) -> ParseResult:
 
     data = result.data
     if not isinstance(data, dict):
-        return ParseResult(ok=False, error="data is not a dict", raw=raw)
+        return ParseResult(
+            ok=False, error="data is not a dict", raw=raw,
+            layer_reached=result.layer_reached,
+            last_error=result.last_error,
+            layer_errors=result.layer_errors,
+        )
 
     # 必填字段验证
     if "predicates" not in data or "behavior" not in data:
-        return ParseResult(ok=False, error="missing 'predicates' or 'behavior'", raw=raw)
+        return ParseResult(
+            ok=False, error="missing 'predicates' or 'behavior'", raw=raw,
+            layer_reached=result.layer_reached,
+            last_error=result.last_error,
+            layer_errors=result.layer_errors,
+        )
 
     return ParseResult(ok=True, data=data, raw=raw)