fix(strategy): formalize canary and verified provenance

Co-Authored-By: Codex <noreply@openai.com>

Author: Pigbibi

schemas/strategy-review.v1.schema.json

@@ -85,7 +85,19 @@
             "research_auto_after_hard_gates": { "const": true },
             "shadow_auto_after_hard_gates": { "const": true },
             "canary_mode": { "const": "bounded_preapproved_only" },
-            "canary_limits": { "type": "object" },
+            "canary_limits": {
+              "type": "object",
+              "required": ["max_capital", "capital_currency", "max_duration_days", "max_drawdown_fraction", "max_leverage", "max_concurrency"],
+              "properties": {
+                "max_capital": { "type": "number", "exclusiveMinimum": 0 },
+                "capital_currency": { "type": "string", "minLength": 3 },
+                "max_duration_days": { "type": "integer", "minimum": 1 },
+                "max_drawdown_fraction": { "type": "number", "exclusiveMinimum": 0, "exclusiveMaximum": 1 },
+                "max_leverage": { "type": "number", "exclusiveMinimum": 0 },
+                "max_concurrency": { "type": "integer", "minimum": 1 }
+              },
+              "additionalProperties": false
+            },
             "auto_scale_allowed": { "const": false },
             "normal_live_requires_human": { "const": true },
             "funding_leverage_risk_override_requires_human": { "const": true },

scripts/validate_strategy_review.py

@@ -47,6 +47,7 @@ def validate_review(payload: Any) -> list[str]:
     if not isinstance(payload.get("scorecard"), dict):
         issues.append("scorecard must be an object")
     evidence = payload.get("evidence")
+    provenance: dict[str, Any] = {}
     if not isinstance(evidence, dict):
         issues.append("evidence must be an object")
     else:
@@ -69,6 +70,14 @@ def validate_review(payload: Any) -> list[str]:
                     issues.append(f"evidence.provenance.{source}.{field} must be non-empty")
             if item.get("status") not in {"verified", "legacy_missing", "unavailable"}:
                 issues.append(f"evidence.provenance.{source}.status is invalid")
+            if item.get("status") == "verified":
+                try:
+                    from datetime import datetime
+                    timestamp = datetime.fromisoformat(item["data_timestamp"].replace("Z", "+00:00"))
+                    if timestamp.tzinfo is None:
+                        raise ValueError
+                except (AttributeError, TypeError, ValueError):
+                    issues.append(f"evidence.provenance.{source}.verified requires a real timestamp")
         if evidence.get("placeholder_metrics") is not False:
             issues.append("placeholder metrics are not admissible evidence")
         if not isinstance(evidence.get("sample_count"), int) or isinstance(evidence.get("sample_count"), bool) or evidence["sample_count"] < 0:
@@ -109,6 +118,18 @@ def validate_review(payload: Any) -> list[str]:
                     issues.append(f"decision_packet.automation_boundary.{field} is unsafe")
             if not isinstance(boundary.get("canary_limits"), dict):
                 issues.append("decision_packet.automation_boundary.canary_limits must be an object")
+            else:
+                limits = boundary["canary_limits"]
+                checks = {
+                    "max_capital": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool) and v > 0,
+                    "capital_currency": lambda v: isinstance(v, str) and len(v.strip()) >= 3,
+                    "max_duration_days": lambda v: isinstance(v, int) and not isinstance(v, bool) and v >= 1,
+                    "max_drawdown_fraction": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool) and 0 < v < 1,
+                    "max_leverage": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool) and v > 0,
+                    "max_concurrency": lambda v: isinstance(v, int) and not isinstance(v, bool) and v >= 1,
+                }
+                if set(limits) != set(checks) or any(not check(limits.get(key)) for key, check in checks.items()):
+                    issues.append("decision_packet.automation_boundary.canary_limits is incomplete or invalid")
         allowed = packet.get("allowed_human_decisions")
         if not isinstance(allowed, list) or not allowed or any(item not in {"approve_research", "approve_shadow", "approve_canary", "approve_live", "reject_rollback"} for item in allowed):
             issues.append("decision_packet.allowed_human_decisions is invalid")

src/quant_platform_kit/strategy_lifecycle/performance_export.py

@@ -146,7 +146,7 @@ def export_strategy_performance(
                             "source_revision": backtest.source_revision or "legacy_missing",
                             "cost_model": backtest.cost_model or "legacy_missing",
                             "data_timestamp": backtest.end_date.isoformat() if backtest.end_date else "unavailable",
-                            "status": "verified" if backtest.source_revision and backtest.cost_model else "legacy_missing",
+                            "status": "verified" if backtest.source_revision and backtest.cost_model and backtest.end_date else "legacy_missing",
                         },
                     },
                     "data_timestamp": snapshot.as_of.isoformat(),

tests/test_strategy_review_validator.py

@@ -49,7 +49,7 @@ def _review(**overrides: object) -> dict[str, object]:
                 "research_auto_after_hard_gates": True,
                 "shadow_auto_after_hard_gates": True,
                 "canary_mode": "bounded_preapproved_only",
-                "canary_limits": {"capital": "preapproved", "duration": "preapproved", "max_drawdown": "preapproved", "max_leverage": "preapproved", "max_concurrency": "preapproved"},
+                "canary_limits": {"max_capital": 1000.0, "capital_currency": "USD", "max_duration_days": 14, "max_drawdown_fraction": 0.05, "max_leverage": 1.0, "max_concurrency": 1},
                 "auto_scale_allowed": False,
                 "normal_live_requires_human": True,
                 "funding_leverage_risk_override_requires_human": True,