feat: 리밸런싱 엔진 V1 + GAS 버그 수정 (2026-06-13)

주요 변경:
- tools/build_rebalance_engine_v1.py: REBALANCE_ENGINE_V1 신규
  * account_snapshot 직접 합산(_build_snap_position_map) → 소수주 분리 행 병합
  * 레짐 소스 macro.REGIME_PRELIM 최우선 (GAS 와 동일)
- src/gas_adapter_parts/gdf_06_rebalance.gs: runRebalanceSheet_() 신규
  * Logger.log / getSpreadsheet_() 로 run_all 연동 수정
- src/gas_adapter_parts/gdc_01_fetch_fundamentals.gs
  * _mergePositionRecord_(): 소수주 중복 행 합산 신규
  * parseInt → parseFloat (qty, availQty)
- src/gas_adapter_parts/gdf_01_price_metrics.gs
  * 미보유 종목 SELL_READY → WATCH_EXIT_SIGNAL
- spec/41_release_dag.yaml: build_rebalance_sheet 노드 추가 (step_count 63)
- spec/51_formula_lifecycle_registry.yaml: REBALANCE_ENGINE_V1 등록

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/quant_engine/models/__init__.py

@@ -0,0 +1 @@
+"""Auto-generated quant_engine.models package."""

src/quant_engine/models/generated/__init__.py

@@ -0,0 +1 @@
+"""Auto-generated schema model package."""

src/quant_engine/models/generated/absolute_risk_stop_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ABSOLUTE_RISK_STOP_V1'
+SCHEMA_ID = 'schema://formula/ABSOLUTE_RISK_STOP_V1'
+SCHEMA_PATH = 'schemas/generated/absolute_risk_stop_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/absolute_risk_stop_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ABSOLUTE_RISK_STOP_V1",
+  "title": "ABSOLUTE_RISK_STOP_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ABSOLUTE_RISK_STOP_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "holdings",
+    "df_map"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/algorithm_guidance_proof_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ALGORITHM_GUIDANCE_PROOF_V1'
+SCHEMA_ID = 'schema://formula/ALGORITHM_GUIDANCE_PROOF_V1'
+SCHEMA_PATH = 'schemas/generated/algorithm_guidance_proof_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/algorithm_guidance_proof_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ALGORITHM_GUIDANCE_PROOF_V1",
+  "title": "ALGORITHM_GUIDANCE_PROOF_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ALGORITHM_GUIDANCE_PROOF_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/alpha_evaluation_window_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ALPHA_EVALUATION_WINDOW_V1'
+SCHEMA_ID = 'schema://formula/ALPHA_EVALUATION_WINDOW_V1'
+SCHEMA_PATH = 'schemas/generated/alpha_evaluation_window_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/alpha_evaluation_window_v1_schema.schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ALPHA_EVALUATION_WINDOW_V1",
+  "title": "ALPHA_EVALUATION_WINDOW_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ALPHA_EVALUATION_WINDOW_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "entry_date",
+    "position_class",
+    "t20_return_pct",
+    "t60_return_pct",
+    "benchmark_core_return_pct"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/alpha_feedback_loop_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ALPHA_FEEDBACK_LOOP_V1'
+SCHEMA_ID = 'schema://formula/ALPHA_FEEDBACK_LOOP_V1'
+SCHEMA_PATH = 'schemas/generated/alpha_feedback_loop_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/alpha_feedback_loop_v1_schema.schema.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ALPHA_FEEDBACK_LOOP_V1",
+  "title": "ALPHA_FEEDBACK_LOOP_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ALPHA_FEEDBACK_LOOP_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "alpha_evaluation_window_json",
+    "saqg_v1",
+    "brt_verdict",
+    "market_regime"
+  ],
+  "x_formula_outputs": [
+    {
+      "field": "alpha_feedback_json",
+      "subfields": [
+        "eligible_t20_fail_rate",
+        "eligible_t60_fail_rate",
+        "recommended_filter_adjustments",
+        "cases_analyzed"
+      ]
+    }
+  ]
+}

src/quant_engine/models/generated/anti_chase_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ANTI_CHASE_V1'
+SCHEMA_ID = 'schema://formula/ANTI_CHASE_V1'
+SCHEMA_PATH = 'schemas/generated/anti_chase_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/anti_chase_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ANTI_CHASE_V1",
+  "title": "ANTI_CHASE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ANTI_CHASE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/anti_chasing_velocity_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ANTI_CHASING_VELOCITY_V1'
+SCHEMA_ID = 'schema://formula/ANTI_CHASING_VELOCITY_V1'
+SCHEMA_PATH = 'schemas/generated/anti_chasing_velocity_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/anti_chasing_velocity_v1_schema.schema.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ANTI_CHASING_VELOCITY_V1",
+  "title": "ANTI_CHASING_VELOCITY_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ANTI_CHASING_VELOCITY_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "close",
+    "close_1d_ago",
+    "close_5d_ago",
+    "market_regime"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/anti_late_entry_gate_v2_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ANTI_LATE_ENTRY_GATE_V2'
+SCHEMA_ID = 'schema://formula/ANTI_LATE_ENTRY_GATE_V2'
+SCHEMA_PATH = 'schemas/generated/anti_late_entry_gate_v2.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/anti_late_entry_gate_v2_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ANTI_LATE_ENTRY_GATE_V2",
+  "title": "ANTI_LATE_ENTRY_GATE_V2",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ANTI_LATE_ENTRY_GATE_V2"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/anti_whipsaw_gate_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ANTI_WHIPSAW_GATE_V1'
+SCHEMA_ID = 'schema://formula/ANTI_WHIPSAW_GATE_V1'
+SCHEMA_PATH = 'schemas/generated/anti_whipsaw_gate_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/anti_whipsaw_gate_v1_schema.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ANTI_WHIPSAW_GATE_V1",
+  "title": "ANTI_WHIPSAW_GATE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ANTI_WHIPSAW_GATE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "close_price",
+    "ma20",
+    "rsi14"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/artifact_freshness_gate_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ARTIFACT_FRESHNESS_GATE_V1'
+SCHEMA_ID = 'schema://formula/ARTIFACT_FRESHNESS_GATE_V1'
+SCHEMA_PATH = 'schemas/generated/artifact_freshness_gate_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/artifact_freshness_gate_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ARTIFACT_FRESHNESS_GATE_V1",
+  "title": "ARTIFACT_FRESHNESS_GATE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ARTIFACT_FRESHNESS_GATE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/audit_replay_snapshot_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'AUDIT_REPLAY_SNAPSHOT_V1'
+SCHEMA_ID = 'schema://formula/AUDIT_REPLAY_SNAPSHOT_V1'
+SCHEMA_PATH = 'schemas/generated/audit_replay_snapshot_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/audit_replay_snapshot_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/AUDIT_REPLAY_SNAPSHOT_V1",
+  "title": "AUDIT_REPLAY_SNAPSHOT_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "AUDIT_REPLAY_SNAPSHOT_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/benchmark_relative_timeseries_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'BENCHMARK_RELATIVE_TIMESERIES_V1'
+SCHEMA_ID = 'schema://formula/BENCHMARK_RELATIVE_TIMESERIES_V1'
+SCHEMA_PATH = 'schemas/generated/benchmark_relative_timeseries_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/benchmark_relative_timeseries_v1_schema.schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/BENCHMARK_RELATIVE_TIMESERIES_V1",
+  "title": "BENCHMARK_RELATIVE_TIMESERIES_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "BENCHMARK_RELATIVE_TIMESERIES_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "price.ret5D",
+    "price.ret20D",
+    "price.ret60D",
+    "price.close",
+    "high52w",
+    "globalKospiRet5D_",
+    "globalKospiRet20D_",
+    "globalKospiRet60D_",
+    "globalKospiDrawdown_"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/blank_cell_audit_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'BLANK_CELL_AUDIT_V1'
+SCHEMA_ID = 'schema://formula/BLANK_CELL_AUDIT_V1'
+SCHEMA_PATH = 'schemas/generated/blank_cell_audit_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/blank_cell_audit_v1_schema.schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/BLANK_CELL_AUDIT_V1",
+  "title": "BLANK_CELL_AUDIT_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "BLANK_CELL_AUDIT_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "operational_report_json"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/breakeven_ratchet_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'BREAKEVEN_RATCHET_V1'
+SCHEMA_ID = 'schema://formula/BREAKEVEN_RATCHET_V1'
+SCHEMA_PATH = 'schemas/generated/breakeven_ratchet_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/breakeven_ratchet_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/BREAKEVEN_RATCHET_V1",
+  "title": "BREAKEVEN_RATCHET_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "BREAKEVEN_RATCHET_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "average_cost",
+    "highest_price_since_entry"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/breakout_quality_gate_v2_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'BREAKOUT_QUALITY_GATE_V2'
+SCHEMA_ID = 'schema://formula/BREAKOUT_QUALITY_GATE_V2'
+SCHEMA_PATH = 'schemas/generated/breakout_quality_gate_v2.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/breakout_quality_gate_v2_schema.schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/BREAKOUT_QUALITY_GATE_V2",
+  "title": "BREAKOUT_QUALITY_GATE_V2",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "BREAKOUT_QUALITY_GATE_V2"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "close",
+    "ma20",
+    "ret_3d",
+    "ret_1d",
+    "disparity",
+    "rsi14",
+    "volume",
+    "avg_volume_5d",
+    "timing_score_exit",
+    "distribution_risk_score",
+    "late_chase_risk_score"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/canonical_artifact_resolver_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CANONICAL_ARTIFACT_RESOLVER_V1'
+SCHEMA_ID = 'schema://formula/CANONICAL_ARTIFACT_RESOLVER_V1'
+SCHEMA_PATH = 'schemas/generated/canonical_artifact_resolver_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/canonical_artifact_resolver_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CANONICAL_ARTIFACT_RESOLVER_V1",
+  "title": "CANONICAL_ARTIFACT_RESOLVER_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CANONICAL_ARTIFACT_RESOLVER_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/canonical_metrics_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CANONICAL_METRICS_V1'
+SCHEMA_ID = 'schema://formula/CANONICAL_METRICS_V1'
+SCHEMA_PATH = 'schemas/generated/canonical_metrics_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/canonical_metrics_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CANONICAL_METRICS_V1",
+  "title": "CANONICAL_METRICS_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CANONICAL_METRICS_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/capital_style_allocation_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CAPITAL_STYLE_ALLOCATION_V1'
+SCHEMA_ID = 'schema://formula/CAPITAL_STYLE_ALLOCATION_V1'
+SCHEMA_PATH = 'schemas/generated/capital_style_allocation_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/capital_style_allocation_v1_schema.schema.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CAPITAL_STYLE_ALLOCATION_V1",
+  "title": "CAPITAL_STYLE_ALLOCATION_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CAPITAL_STYLE_ALLOCATION_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "smart_money_flow_signal_v2_json",
+    "fundamental_multifactor_v3_json",
+    "macro_event_ticker_impact_v1_json",
+    "liquidity_flow_signal_v1_json"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_creation_purpose_lock_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_CREATION_PURPOSE_LOCK_V1'
+SCHEMA_ID = 'schema://formula/CASH_CREATION_PURPOSE_LOCK_V1'
+SCHEMA_PATH = 'schemas/generated/cash_creation_purpose_lock_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_creation_purpose_lock_v1_schema.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_CREATION_PURPOSE_LOCK_V1",
+  "title": "CASH_CREATION_PURPOSE_LOCK_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_CREATION_PURPOSE_LOCK_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "composite_verdict",
+    "rs_verdict",
+    "brt_verdict",
+    "excess_drawdown_pctp",
+    "recovery_ratio_20d",
+    "sfg_v1"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_floor_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_FLOOR_V1'
+SCHEMA_ID = 'schema://formula/CASH_FLOOR_V1'
+SCHEMA_PATH = 'schemas/generated/cash_floor_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_floor_v1_schema.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_FLOOR_V1",
+  "title": "CASH_FLOOR_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_FLOOR_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "total_asset",
+    "settlement_cash_d2_krw",
+    "market_risk_score"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_raise_pareto_executor_v2_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_RAISE_PARETO_EXECUTOR_V2'
+SCHEMA_ID = 'schema://formula/CASH_RAISE_PARETO_EXECUTOR_V2'
+SCHEMA_PATH = 'schemas/generated/cash_raise_pareto_executor_v2.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_raise_pareto_executor_v2_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_RAISE_PARETO_EXECUTOR_V2",
+  "title": "CASH_RAISE_PARETO_EXECUTOR_V2",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_RAISE_PARETO_EXECUTOR_V2"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_raise_value_optimizer_v3_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_RAISE_VALUE_OPTIMIZER_V3'
+SCHEMA_ID = 'schema://formula/CASH_RAISE_VALUE_OPTIMIZER_V3'
+SCHEMA_PATH = 'schemas/generated/cash_raise_value_optimizer_v3.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_raise_value_optimizer_v3_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_RAISE_VALUE_OPTIMIZER_V3",
+  "title": "CASH_RAISE_VALUE_OPTIMIZER_V3",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_RAISE_VALUE_OPTIMIZER_V3"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_ratios_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_RATIOS_V1'
+SCHEMA_ID = 'schema://formula/CASH_RATIOS_V1'
+SCHEMA_PATH = 'schemas/generated/cash_ratios_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_ratios_v1_schema.schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_RATIOS_V1",
+  "title": "CASH_RATIOS_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_RATIOS_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "settlement_cash",
+    "reserved_order_amount",
+    "planned_buy_amount",
+    "sell_cash_proceeds_d2",
+    "total_asset"
+  ],
+  "x_formula_outputs": {
+    "settlement_cash_ratio": "settlement_cash / total_asset * 100",
+    "total_cash_ratio": "settlement_cash / total_asset * 100",
+    "buy_power_cash": "settlement_cash - reserved_order_amount",
+    "buy_power_ratio": "(settlement_cash - reserved_order_amount) / total_asset * 100",
+    "post_trade_total_cash_ratio": "(settlement_cash - planned_buy_amount + sell_cash_proceeds_d2) / total_asset * 100"
+  }
+}

src/quant_engine/models/generated/cash_recovery_optimizer_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_RECOVERY_OPTIMIZER_V1'
+SCHEMA_ID = 'schema://formula/CASH_RECOVERY_OPTIMIZER_V1'
+SCHEMA_PATH = 'schemas/generated/cash_recovery_optimizer_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_recovery_optimizer_v1_schema.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_RECOVERY_OPTIMIZER_V1",
+  "title": "CASH_RECOVERY_OPTIMIZER_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_RECOVERY_OPTIMIZER_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "cash_shortfall_target_krw",
+    "cash_shortfall_min_krw",
+    "sell_candidates_json",
+    "immediate_sell_qty",
+    "sell_limit_price",
+    "holding_qty"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_recovery_optimizer_v4_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_RECOVERY_OPTIMIZER_V4'
+SCHEMA_ID = 'schema://formula/CASH_RECOVERY_OPTIMIZER_V4'
+SCHEMA_PATH = 'schemas/generated/cash_recovery_optimizer_v4.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_recovery_optimizer_v4_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_RECOVERY_OPTIMIZER_V4",
+  "title": "CASH_RECOVERY_OPTIMIZER_V4",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_RECOVERY_OPTIMIZER_V4"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cash_recovery_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASH_RECOVERY_V1'
+SCHEMA_ID = 'schema://formula/CASH_RECOVERY_V1'
+SCHEMA_PATH = 'schemas/generated/cash_recovery_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cash_recovery_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASH_RECOVERY_V1",
+  "title": "CASH_RECOVERY_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASH_RECOVERY_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cashflow_quality_signal_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASHFLOW_QUALITY_SIGNAL_V1'
+SCHEMA_ID = 'schema://formula/CASHFLOW_QUALITY_SIGNAL_V1'
+SCHEMA_PATH = 'schemas/generated/cashflow_quality_signal_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cashflow_quality_signal_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASHFLOW_QUALITY_SIGNAL_V1",
+  "title": "CASHFLOW_QUALITY_SIGNAL_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASHFLOW_QUALITY_SIGNAL_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cashflow_stability_gate_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CASHFLOW_STABILITY_GATE_V1'
+SCHEMA_ID = 'schema://formula/CASHFLOW_STABILITY_GATE_V1'
+SCHEMA_PATH = 'schemas/generated/cashflow_stability_gate_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cashflow_stability_gate_v1_schema.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CASHFLOW_STABILITY_GATE_V1",
+  "title": "CASHFLOW_STABILITY_GATE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CASHFLOW_STABILITY_GATE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "operating_cf_krw",
+    "free_cf_krw",
+    "accrual_ratio_pct"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cla_regime_exit_condition_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CLA_REGIME_EXIT_CONDITION_V1'
+SCHEMA_ID = 'schema://formula/CLA_REGIME_EXIT_CONDITION_V1'
+SCHEMA_PATH = 'schemas/generated/cla_regime_exit_condition_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cla_regime_exit_condition_v1_schema.schema.json

@@ -0,0 +1,59 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CLA_REGIME_EXIT_CONDITION_V1",
+  "title": "CLA_REGIME_EXIT_CONDITION_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CLA_REGIME_EXIT_CONDITION_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "ticker",
+    "rs_verdict",
+    "brt_verdict",
+    "frg_5d_sh",
+    "volume",
+    "avg_volume_5d",
+    "market_regime"
+  ],
+  "x_formula_outputs": [
+    {
+      "field": "cla_exit_status",
+      "unit": "enum [CLA_ACTIVE,CLA_EXIT_WARNING,CLA_EXIT_CONFIRMED]"
+    },
+    {
+      "field": "cla_exit_signals_triggered",
+      "unit": "list"
+    },
+    {
+      "field": "cla_exit_total_weight",
+      "unit": "int"
+    }
+  ]
+}

src/quant_engine/models/generated/completion_gap_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'COMPLETION_GAP_V1'
+SCHEMA_ID = 'schema://formula/COMPLETION_GAP_V1'
+SCHEMA_PATH = 'schemas/generated/completion_gap_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/completion_gap_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/COMPLETION_GAP_V1",
+  "title": "COMPLETION_GAP_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "COMPLETION_GAP_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/composite_verdict_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'COMPOSITE_VERDICT_V1'
+SCHEMA_ID = 'schema://formula/COMPOSITE_VERDICT_V1'
+SCHEMA_PATH = 'schemas/generated/composite_verdict_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/composite_verdict_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/COMPOSITE_VERDICT_V1",
+  "title": "COMPOSITE_VERDICT_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "COMPOSITE_VERDICT_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "ss001_grade",
+    "rs_verdict"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/comprehensive_proposal_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'COMPREHENSIVE_PROPOSAL_V1'
+SCHEMA_ID = 'schema://formula/COMPREHENSIVE_PROPOSAL_V1'
+SCHEMA_PATH = 'schemas/generated/comprehensive_proposal_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/comprehensive_proposal_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/COMPREHENSIVE_PROPOSAL_V1",
+  "title": "COMPREHENSIVE_PROPOSAL_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "COMPREHENSIVE_PROPOSAL_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/continuous_evaluation_dashboard_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CONTINUOUS_EVALUATION_DASHBOARD_V1'
+SCHEMA_ID = 'schema://formula/CONTINUOUS_EVALUATION_DASHBOARD_V1'
+SCHEMA_PATH = 'schemas/generated/continuous_evaluation_dashboard_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/continuous_evaluation_dashboard_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CONTINUOUS_EVALUATION_DASHBOARD_V1",
+  "title": "CONTINUOUS_EVALUATION_DASHBOARD_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CONTINUOUS_EVALUATION_DASHBOARD_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/cross_section_consistency_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'CROSS_SECTION_CONSISTENCY_V1'
+SCHEMA_ID = 'schema://formula/CROSS_SECTION_CONSISTENCY_V1'
+SCHEMA_PATH = 'schemas/generated/cross_section_consistency_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/cross_section_consistency_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/CROSS_SECTION_CONSISTENCY_V1",
+  "title": "CROSS_SECTION_CONSISTENCY_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "CROSS_SECTION_CONSISTENCY_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_integrity_100_lock_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_INTEGRITY_100_LOCK_V1'
+SCHEMA_ID = 'schema://formula/DATA_INTEGRITY_100_LOCK_V1'
+SCHEMA_PATH = 'schemas/generated/data_integrity_100_lock_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_integrity_100_lock_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_INTEGRITY_100_LOCK_V1",
+  "title": "DATA_INTEGRITY_100_LOCK_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_INTEGRITY_100_LOCK_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_integrity_100_lock_v2_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_INTEGRITY_100_LOCK_V2'
+SCHEMA_ID = 'schema://formula/DATA_INTEGRITY_100_LOCK_V2'
+SCHEMA_PATH = 'schemas/generated/data_integrity_100_lock_v2.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_integrity_100_lock_v2_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_INTEGRITY_100_LOCK_V2",
+  "title": "DATA_INTEGRITY_100_LOCK_V2",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_INTEGRITY_100_LOCK_V2"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_integrity_score_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_INTEGRITY_SCORE_V1'
+SCHEMA_ID = 'schema://formula/DATA_INTEGRITY_SCORE_V1'
+SCHEMA_PATH = 'schemas/generated/data_integrity_score_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_integrity_score_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_INTEGRITY_SCORE_V1",
+  "title": "DATA_INTEGRITY_SCORE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_INTEGRITY_SCORE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_maturity_truth_gate_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_MATURITY_TRUTH_GATE_V1'
+SCHEMA_ID = 'schema://formula/DATA_MATURITY_TRUTH_GATE_V1'
+SCHEMA_PATH = 'schemas/generated/data_maturity_truth_gate_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_maturity_truth_gate_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_MATURITY_TRUTH_GATE_V1",
+  "title": "DATA_MATURITY_TRUTH_GATE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_MATURITY_TRUTH_GATE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_maturity_truth_gate_validator_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_MATURITY_TRUTH_GATE_VALIDATOR_V1'
+SCHEMA_ID = 'schema://formula/DATA_MATURITY_TRUTH_GATE_VALIDATOR_V1'
+SCHEMA_PATH = 'schemas/generated/data_maturity_truth_gate_validator_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_maturity_truth_gate_validator_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_MATURITY_TRUTH_GATE_VALIDATOR_V1",
+  "title": "DATA_MATURITY_TRUTH_GATE_VALIDATOR_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_MATURITY_TRUTH_GATE_VALIDATOR_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_quality_gate_v2_py_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_QUALITY_GATE_V2_PY'
+SCHEMA_ID = 'schema://formula/DATA_QUALITY_GATE_V2_PY'
+SCHEMA_PATH = 'schemas/generated/data_quality_gate_v2_py.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_quality_gate_v2_py_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_QUALITY_GATE_V2_PY",
+  "title": "DATA_QUALITY_GATE_V2_PY",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_QUALITY_GATE_V2_PY"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/data_quality_gate_v3_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DATA_QUALITY_GATE_V3'
+SCHEMA_ID = 'schema://formula/DATA_QUALITY_GATE_V3'
+SCHEMA_PATH = 'schemas/generated/data_quality_gate_v3.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/data_quality_gate_v3_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DATA_QUALITY_GATE_V3",
+  "title": "DATA_QUALITY_GATE_V3",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DATA_QUALITY_GATE_V3"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/deterministic_routing_engine_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DETERMINISTIC_ROUTING_ENGINE_V1'
+SCHEMA_ID = 'schema://formula/DETERMINISTIC_ROUTING_ENGINE_V1'
+SCHEMA_PATH = 'schemas/generated/deterministic_routing_engine_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/deterministic_routing_engine_v1_schema.schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DETERMINISTIC_ROUTING_ENGINE_V1",
+  "title": "DETERMINISTIC_ROUTING_ENGINE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DETERMINISTIC_ROUTING_ENGINE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "harness_context"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/distribution_sell_detector_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DISTRIBUTION_SELL_DETECTOR_V1'
+SCHEMA_ID = 'schema://formula/DISTRIBUTION_SELL_DETECTOR_V1'
+SCHEMA_PATH = 'schemas/generated/distribution_sell_detector_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/distribution_sell_detector_v1_schema.schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DISTRIBUTION_SELL_DETECTOR_V1",
+  "title": "DISTRIBUTION_SELL_DETECTOR_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DISTRIBUTION_SELL_DETECTOR_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "close",
+    "high52w",
+    "avg_volume_5d",
+    "volume",
+    "ret5d",
+    "flow_credit",
+    "frg_5d_sh",
+    "inst_5d_sh",
+    "rsi14",
+    "obv_slope_20d"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/divergence_score_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DIVERGENCE_SCORE_V1'
+SCHEMA_ID = 'schema://formula/DIVERGENCE_SCORE_V1'
+SCHEMA_PATH = 'schemas/generated/divergence_score_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/divergence_score_v1_schema.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DIVERGENCE_SCORE_V1",
+  "title": "DIVERGENCE_SCORE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DIVERGENCE_SCORE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "close_price",
+    "ma20",
+    "frg_5d_sh",
+    "inst_5d_sh",
+    "flow_credit",
+    "frg_20d_sh"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/drawdown_guard_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DRAWDOWN_GUARD_V1'
+SCHEMA_ID = 'schema://formula/DRAWDOWN_GUARD_V1'
+SCHEMA_PATH = 'schemas/generated/drawdown_guard_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/drawdown_guard_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DRAWDOWN_GUARD_V1",
+  "title": "DRAWDOWN_GUARD_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DRAWDOWN_GUARD_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "win_loss_streak_state",
+    "win_loss_streak_buy_scale"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/dynamic_heat_gate_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'DYNAMIC_HEAT_GATE_V1'
+SCHEMA_ID = 'schema://formula/DYNAMIC_HEAT_GATE_V1'
+SCHEMA_PATH = 'schemas/generated/dynamic_heat_gate_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/dynamic_heat_gate_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/DYNAMIC_HEAT_GATE_V1",
+  "title": "DYNAMIC_HEAT_GATE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "DYNAMIC_HEAT_GATE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "market_regime",
+    "total_heat_pct"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/earnings_growth_quality_gate_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'EARNINGS_GROWTH_QUALITY_GATE_V1'
+SCHEMA_ID = 'schema://formula/EARNINGS_GROWTH_QUALITY_GATE_V1'
+SCHEMA_PATH = 'schemas/generated/earnings_growth_quality_gate_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/earnings_growth_quality_gate_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/EARNINGS_GROWTH_QUALITY_GATE_V1",
+  "title": "EARNINGS_GROWTH_QUALITY_GATE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "EARNINGS_GROWTH_QUALITY_GATE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "eps_growth_qoq_pct",
+    "eps_growth_yoy_pct"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/earnings_quality_signal_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'EARNINGS_QUALITY_SIGNAL_V1'
+SCHEMA_ID = 'schema://formula/EARNINGS_QUALITY_SIGNAL_V1'
+SCHEMA_PATH = 'schemas/generated/earnings_quality_signal_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/earnings_quality_signal_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/EARNINGS_QUALITY_SIGNAL_V1",
+  "title": "EARNINGS_QUALITY_SIGNAL_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "EARNINGS_QUALITY_SIGNAL_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/ecp_risk_scale_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'ECP_RISK_SCALE_V1'
+SCHEMA_ID = 'schema://formula/ECP_RISK_SCALE_V1'
+SCHEMA_PATH = 'schemas/generated/ecp_risk_scale_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/ecp_risk_scale_v1_schema.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/ECP_RISK_SCALE_V1",
+  "title": "ECP_RISK_SCALE_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "ECP_RISK_SCALE_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [
+    "total_asset",
+    "total_asset_ma10"
+  ],
+  "x_formula_outputs": []
+}

src/quant_engine/models/generated/ejce_divergence_audit_v1_schema.py

@@ -0,0 +1,33 @@
+"""Auto-generated schema model descriptor."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_TITLE = 'EJCE_DIVERGENCE_AUDIT_V1'
+SCHEMA_ID = 'schema://formula/EJCE_DIVERGENCE_AUDIT_V1'
+SCHEMA_PATH = 'schemas/generated/ejce_divergence_audit_v1.schema.json'
+SCHEMA_PROPERTIES = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+SCHEMA_REQUIRED = ['formula_id', 'owner', 'status', 'inputs', 'outputs']
+
+@dataclass(frozen=True)
+class SchemaModel:
+    title: str
+    schema_id: str
+    path: str
+    properties: list[str]
+    required: list[str]
+
+def load_schema() -> dict[str, Any]:
+    return json.loads(Path(__file__).with_suffix('.schema.json').read_text(encoding='utf-8'))
+
+def describe() -> SchemaModel:
+    return SchemaModel(
+        title=SCHEMA_TITLE,
+        schema_id=SCHEMA_ID,
+        path=SCHEMA_PATH,
+        properties=list(SCHEMA_PROPERTIES),
+        required=list(SCHEMA_REQUIRED),
+    )

src/quant_engine/models/generated/ejce_divergence_audit_v1_schema.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "schema://formula/EJCE_DIVERGENCE_AUDIT_V1",
+  "title": "EJCE_DIVERGENCE_AUDIT_V1",
+  "type": "object",
+  "properties": {
+    "formula_id": {
+      "const": "EJCE_DIVERGENCE_AUDIT_V1"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "formula_id",
+    "owner",
+    "status",
+    "inputs",
+    "outputs"
+  ],
+  "x_formula_inputs": [],
+  "x_formula_outputs": []
+}