indiciumforge-workflow 2.0.0__py3-none-any.whl

indiciumforge_workflow/market_gate/active_watch.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import pandas as pd
+from indiciumforge_core.labels.market_gate import (
+    GATE_RESULT_OBSERVATION,
+    GATE_RESULT_STRICT,
+    MARKET_DAILY,
+    REVIEW_COLUMNS,
+    WORKFLOW_ZH,
+)
+from indiciumforge_core.text import clean_text, join_unique, u
+
+
+def market_gate_active_watch(
+    row: pd.Series,
+    gate_result: str,
+    strong: list[str],
+    observe_reasons: list[str],
+    reject_reasons: list[str],
+) -> dict[str, str]:
+    if gate_result == GATE_RESULT_STRICT:
+        return {"level": u("\\u4e25\\u683c\\u6267\\u884c\\u95e8"), "reason": "", "action": ""}
+
+    stock_name = clean_text(row.get(REVIEW_COLUMNS["stock_name"]))
+    if "ST" in stock_name.upper() or u("\\u9000") in stock_name:
+        return {"level": "", "reason": "", "action": ""}
+
+    rating = clean_text(row.get(REVIEW_COLUMNS["rating"]))
+    short_level = clean_text(row.get(REVIEW_COLUMNS["short_level"]))
+    priority = clean_text(row.get(REVIEW_COLUMNS["priority_bucket"]))
+    mainline_strength = clean_text(row.get(REVIEW_COLUMNS["mainline_strength"]))
+    pattern_confidence = clean_text(row.get(REVIEW_COLUMNS["pattern_confidence"]))
+    narrative_stage = clean_text(row.get(REVIEW_COLUMNS["narrative_stage"]))
+    holding_period = clean_text(row.get(REVIEW_COLUMNS["holding_period"]))
+    reasons: list[str] = []
+
+    if strong:
+        resonance_label = u("\\u76d8\\u9762\\u5171\\u632f")
+        reasons.append(f"{resonance_label}={join_unique(strong)}")
+    if observe_reasons:
+        reasons.extend(observe_reasons)
+    if short_level == WORKFLOW_ZH["short_high"]:
+        reasons.append(f"{REVIEW_COLUMNS['short_level']}={short_level}")
+    if priority in {u("\\u91cd\\u70b9\\u76ef\\u76d8"), u("\\u89c2\\u5bdf\\u8ddf\\u8e2a")}:
+        reasons.append(f"{REVIEW_COLUMNS['priority_bucket']}={priority}")
+    if mainline_strength in {"strong_persistent", "strong_short_pulse"}:
+        reasons.append(f"{REVIEW_COLUMNS['mainline_strength']}={mainline_strength}")
+    if pattern_confidence in {u("\\u9ad8"), "high"}:
+        reasons.append(f"{REVIEW_COLUMNS['pattern_confidence']}={pattern_confidence}")
+    if rating.startswith("C-") and (
+        strong
+        or short_level == WORKFLOW_ZH["short_high"]
+        or mainline_strength in {"strong_persistent", "strong_short_pulse"}
+    ):
+        reasons.append(u("C\\u7ea7\\u4f46\\u5177\\u5907\\u5f3a\\u52bf/\\u627f\\u63a5\\u7ebf\\u7d22"))
+
+    hard_reject = any(
+        token in join_unique(reject_reasons)
+        for token in (
+            u("\\u98ce\\u9669\\u8bc1\\u5238"),
+            MARKET_DAILY["hard_weak"],
+        )
+    )
+    if hard_reject or not reasons:
+        return {"level": "", "reason": "", "action": ""}
+
+    if gate_result == GATE_RESULT_OBSERVATION:
+        level = u("\\u53ef\\u4e3b\\u52a8\\u590d\\u6838")
+        action = u(
+            "\\u89c2\\u5bdf\\u627f\\u63a5\\u4e0e\\u56de\\u8e29\\uff0c"
+            "\\u4e0d\\u89c6\\u4e3a\\u4e25\\u683c\\u4e70\\u70b9"
+        )
+    elif rating.startswith("C-") or holding_period == u("\\u4ec5\\u590d\\u76d8"):
+        level = u("\\u9057\\u6f0f\\u5ba1\\u8ba1")
+        action = u(
+            "\\u8ddf\\u8e2a\\u662f\\u5426\\u89c4\\u5219\\u8fc7\\u4e25\\uff0c"
+            "\\u4e0d\\u8fdb\\u5165\\u6267\\u884c\\u95e8"
+        )
+    elif narrative_stage == u("\\u540e\\u6bb5\\u62e5\\u6324"):
+        level = u("\\u9ad8\\u6f6e\\u4e0d\\u8ffd")
+        action = u("\\u53ea\\u770b\\u98ce\\u9669\\u4e0e\\u9000\\u6f6e")
+    else:
+        level = u("\\u4ec5\\u89c2\\u5bdf")
+        action = u("\\u4fdd\\u7559\\u89c2\\u5bdf\\uff0c\\u7b49\\u66f4\\u5f3a\\u8bc1\\u636e")
+    return {"level": level, "reason": join_unique(reasons), "action": action}

indiciumforge_workflow/market_gate/calibration.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+
+import pandas as pd
+from indiciumforge_core.labels.market_gate import MARKET_GATE_COLUMNS, REVIEW_COLUMNS
+from indiciumforge_core.text import u
+
+
+def market_gate_calibration_audit(
+    gated: pd.DataFrame,
+    *,
+    strict: pd.DataFrame,
+    observation: pd.DataFrame,
+    rejected: pd.DataFrame,
+    active_watch: pd.DataFrame,
+    trade_date: date,
+) -> dict[str, Any]:
+    watch_columns = [
+        REVIEW_COLUMNS["code"],
+        REVIEW_COLUMNS["stock_name"],
+        REVIEW_COLUMNS["rating"],
+        MARKET_GATE_COLUMNS["gate_result"],
+        MARKET_GATE_COLUMNS["active_watch_level"],
+        MARKET_GATE_COLUMNS["active_watch_reason"],
+        MARKET_GATE_COLUMNS["reject_reason"],
+        MARKET_GATE_COLUMNS["observe_reason"],
+    ]
+    available = [column for column in watch_columns if column in active_watch.columns]
+    top_missed = active_watch[available].head(30).to_dict(orient="records") if available else []
+    warning = ""
+    if len(gated) > 0 and len(strict) == 0:
+        warning = u(
+            "\\u4e25\\u683c\\u6267\\u884c\\u95e8\\u4e3a0\\uff1a\\u4e0d\\u4ee3\\u8868"
+            "\\u5e02\\u573a\\u6ca1\\u6709\\u673a\\u4f1a\\uff0c\\u9700\\u540c\\u65f6\\u67e5\\u770b"
+            "\\u4e3b\\u52a8\\u89c2\\u5bdf\\u548c\\u9057\\u6f0f\\u5ba1\\u8ba1"
+        )
+    elif len(strict) <= max(1, int(len(gated) * 0.002)) and len(gated) >= 200:
+        warning = u(
+            "\\u4e25\\u683c\\u6267\\u884c\\u95e8\\u547d\\u4e2d\\u7387\\u6781\\u4f4e\\uff1a"
+            "\\u9700\\u5b9a\\u671f\\u6821\\u51c6\\u89c4\\u5219\\u662f\\u5426\\u8fc7\\u4e25"
+        )
+    return {
+        "schema": "indiciumgrid.workflow_market_gate_calibration_audit.v1",
+        "trade_date": trade_date.isoformat(),
+        "candidate_count": int(len(gated)),
+        "strict_count": int(len(strict)),
+        "observation_count": int(len(observation)),
+        "watch_count": int(len(active_watch)),
+        "rejected_count": int(len(rejected)),
+        "quality_gate_warning": warning,
+        "outcome_status": u("\\u5f85\\u540e\\u7eed\\u6536\\u76d8\\u6570\\u636e\\u56de\\u586b"),
+        "future_metrics": {
+            "d1_return": None,
+            "d2_return": None,
+            "max_drawdown": None,
+            "missed_strong_move": None,
+        },
+        "top_missed_candidates": top_missed,
+        "notes": [
+            u(
+                "\\u672c\\u5ba1\\u8ba1\\u4e0d\\u653e\\u677emarket-gate\\u4e25\\u683c\\u6267\\u884c\\u95e8"
+            ),
+            u(
+                "\\u8d22\\u52a1\\u7ea2\\u65d7\\u662f\\u89c2\\u5bdf\\u98ce\\u9669\\u4e0a\\u4e0b\\u6587\\uff0c"
+                "\\u4e0d\\u662f\\u4e3b\\u52a8\\u89c2\\u5bdf\\u5c42\\u7684\\u4e00\\u7968\\u5426\\u51b3"
+            ),
+            u(
+                "C\\u7ea7\\u5019\\u9009\\u9700\\u533a\\u5206\\u5f62\\u6001\\u8d70\\u574f\\u4e0e"
+                "\\u89c4\\u5219\\u672a\\u8986\\u76d6\\u7684\\u5f3a\\u52bf\\u6837\\u672c"
+            ),
+        ],
+    }

indiciumforge_workflow/market_gate/helpers.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import pandas as pd
+from indiciumforge_core.labels.market_gate import REVIEW_COLUMNS
+from indiciumforge_core.text import clean_text, u
+
+
+def trigger_count_value(value: object) -> int:
+    text = str(value or "")
+    digits = ""
+    for char in text:
+        if char.isdigit():
+            digits += char
+        elif digits:
+            break
+    return int(digits) if digits else 0
+
+
+def split_candidate_boards(value: str) -> list[str]:
+    out: list[str] = []
+    for raw in str(value or "").replace(",", ";").split(";"):
+        item = raw.strip()
+        if not item or item.startswith(("TDX:", "X:")):
+            continue
+        if item not in out:
+            out.append(item)
+    return out
+
+
+def candidate_gate_boards(row: pd.Series) -> list[str]:
+    boards: list[str] = []
+    for column in (
+        REVIEW_COLUMNS["board_info"],
+        REVIEW_COLUMNS["strong_boards_hit"],
+        REVIEW_COLUMNS["weak_boards_hit"],
+    ):
+        boards.extend(split_candidate_boards(str(row.get(column) or "")))
+    return list(dict.fromkeys(boards))
+
+
+def theme_state_lookup(
+    theme_state_ranking: pd.DataFrame,
+    *,
+    theme_name_key: str,
+    daily_keys: dict[str, str],
+) -> dict[str, dict[str, str]]:
+    if theme_state_ranking.empty or theme_name_key not in theme_state_ranking.columns:
+        return {}
+    lookup: dict[str, dict[str, str]] = {}
+    for _, row in theme_state_ranking.iterrows():
+        name = str(row.get(theme_name_key) or "").strip()
+        if not name:
+            continue
+        lookup[name] = {
+            "status": clean_text(row.get(daily_keys["status"])),
+            "daily_state": clean_text(row.get(daily_keys["daily_state"])),
+            "mid_state": clean_text(row.get(daily_keys["mid_state"])),
+            "risk_state": clean_text(row.get(daily_keys["risk_state"])),
+            "divergence_state": clean_text(row.get(daily_keys["divergence_state"])),
+        }
+    return lookup
+
+
+def market_gate_workflow_rejects(row: pd.Series) -> list[str]:
+    rejects: list[str] = []
+    stock_name = clean_text(row.get(REVIEW_COLUMNS["stock_name"]))
+    if "ST" in stock_name.upper() or u("\\u9000") in stock_name:
+        rejects.append(u("\\u98ce\\u9669\\u8bc1\\u5238"))
+    if clean_text(row.get(REVIEW_COLUMNS["holding_period"])) == u("\\u4ec5\\u590d\\u76d8"):
+        rejects.append(u("\\u6301\\u6709\\u5468\\u671f\\u5206\\u5c42=\\u4ec5\\u590d\\u76d8"))
+    if clean_text(row.get(REVIEW_COLUMNS["narrative_stage"])) == u("\\u540e\\u6bb5\\u62e5\\u6324"):
+        rejects.append(u("\\u4e3b\\u7ebf\\u9636\\u6bb5=\\u540e\\u6bb5\\u62e5\\u6324"))
+    return rejects
+
+
+def market_gate_workflow_risks(row: pd.Series) -> list[str]:
+    risks: list[str] = []
+    thesis_risk = clean_text(row.get(REVIEW_COLUMNS["thesis_risk"]))
+    if thesis_risk and thesis_risk != u("\\u6682\\u65e0"):
+        risks.append(f"{REVIEW_COLUMNS['thesis_risk']}={thesis_risk}")
+    trigger_count = clean_text(row.get(REVIEW_COLUMNS["trigger_count"]))
+    accounting_overview = clean_text(row.get(REVIEW_COLUMNS["accounting_risk_overview"]))
+    if trigger_count == u("\\u6570\\u636e\\u4e0d\\u8db3"):
+        risks.append(u("\\u4f1a\\u8ba1\\u6570\\u636e\\u4e0d\\u8db3"))
+    elif trigger_count_value(trigger_count) > 0:
+        risks.append(f"{REVIEW_COLUMNS['trigger_count']}={trigger_count}")
+    if accounting_overview and accounting_overview not in {
+        u("\\u672a\\u89c1\\u660e\\u663e\\u98ce\\u9669"),
+        u("\\u4e0d\\u9002\\u7528"),
+    }:
+        risks.append(f"{REVIEW_COLUMNS['accounting_risk_overview']}={accounting_overview}")
+    return risks

indiciumforge_workflow/market_gate/kernel.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import pandas as pd
+from indiciumforge_core.labels.market_gate import (
+    GATE_RESULT_OBSERVATION,
+    GATE_RESULT_REJECTED,
+    GATE_RESULT_STRICT,
+    MARKET_DAILY,
+    MARKET_GATE_COLUMNS,
+    MARKET_ZH,
+    REVIEW_COLUMNS,
+)
+from indiciumforge_core.text import clean_text, join_unique, u
+
+from indiciumforge_workflow.market_gate.active_watch import market_gate_active_watch
+from indiciumforge_workflow.market_gate.helpers import (
+    candidate_gate_boards,
+    market_gate_workflow_rejects,
+    market_gate_workflow_risks,
+    theme_state_lookup,
+)
+
+
+def apply_market_gate(review: pd.DataFrame, theme_state_ranking: pd.DataFrame) -> pd.DataFrame:
+    if review.empty:
+        out = review.copy()
+        for column in MARKET_GATE_COLUMNS.values():
+            out[column] = ""
+        return out
+    theme_lookup = theme_state_lookup(
+        theme_state_ranking,
+        theme_name_key=MARKET_ZH["theme_name"],
+        daily_keys=MARKET_DAILY,
+    )
+    out = review.copy()
+    rows = [_market_gate_row(row, theme_lookup) for _, row in out.iterrows()]
+    for key, column in MARKET_GATE_COLUMNS.items():
+        out[column] = [item[key] for item in rows]
+    order = {
+        GATE_RESULT_STRICT: 0,
+        GATE_RESULT_OBSERVATION: 1,
+        GATE_RESULT_REJECTED: 2,
+    }
+    out["_market_gate_order"] = out[MARKET_GATE_COLUMNS["gate_result"]].map(order).fillna(9)
+    sort_columns = ["_market_gate_order"]
+    if REVIEW_COLUMNS["rating"] in out.columns:
+        sort_columns.append(REVIEW_COLUMNS["rating"])
+    return out.sort_values(sort_columns, ascending=True).drop(columns=["_market_gate_order"])
+
+
+def _market_gate_row(row: pd.Series, themes: dict[str, dict[str, str]]) -> dict[str, str]:
+    boards = candidate_gate_boards(row)
+    matched = [(board, themes[board]) for board in boards if board in themes]
+    allowed_statuses = {
+        MARKET_DAILY["daily_strong"],
+        MARKET_DAILY["persistent"],
+        MARKET_DAILY["short_pulse"],
+    }
+    strong = [
+        board
+        for board, info in matched
+        if info["status"] in allowed_statuses
+        and info["risk_state"] != MARKET_DAILY["hard_weak"]
+        and info["divergence_state"] != MARKET_DAILY["divergent"]
+    ]
+    hard_weak = [
+        board
+        for board, info in matched
+        if info["risk_state"] == MARKET_DAILY["hard_weak"]
+        or info["status"] == MARKET_DAILY["hard_weak"]
+    ]
+    turning_weak = [
+        board
+        for board, info in matched
+        if info["status"] == MARKET_DAILY["mid_strong_daily_weak"]
+    ]
+    divergent = [
+        board
+        for board, info in matched
+        if info["divergence_state"] == MARKET_DAILY["divergent"]
+        or info["status"] == MARKET_DAILY["divergent"]
+    ]
+    workflow_rejects = market_gate_workflow_rejects(row)
+    workflow_risks = market_gate_workflow_risks(row)
+    reasons: list[str] = []
+    observe_reasons: list[str] = []
+    if not matched:
+        reasons.append(u("\\u672a\\u547d\\u4e2d\\u76d8\\u9762\\u65e5\\u62a5\\u65b9\\u5411"))
+    if hard_weak:
+        reasons.append(f"{MARKET_DAILY['hard_weak']}={join_unique(hard_weak)}")
+    if workflow_rejects:
+        reasons.extend(workflow_rejects)
+    if turning_weak:
+        observe_reasons.append(
+            f"{MARKET_DAILY['mid_strong_daily_weak']}={join_unique(turning_weak)}"
+        )
+    if divergent:
+        observe_reasons.append(f"{MARKET_DAILY['divergent']}={join_unique(divergent)}")
+    if workflow_risks:
+        observe_reasons.extend(workflow_risks)
+    if reasons:
+        gate_result = GATE_RESULT_REJECTED
+    elif strong and not observe_reasons:
+        gate_result = GATE_RESULT_STRICT
+    elif strong or observe_reasons:
+        gate_result = GATE_RESULT_OBSERVATION
+    else:
+        gate_result = GATE_RESULT_REJECTED
+        reasons.append(u("\\u672a\\u547d\\u4e2d\\u53ef\\u4e25\\u683c\\u901a\\u8fc7\\u65b9\\u5411"))
+    active = market_gate_active_watch(row, gate_result, strong, observe_reasons, reasons)
+    return {
+        "gate_result": gate_result,
+        "active_watch_level": active["level"],
+        "active_watch_reason": active["reason"],
+        "active_watch_action": active["action"],
+        "matched_themes": join_unique([board for board, _ in matched]),
+        "theme_status": join_unique(
+            [f"{board}={info['status']}" for board, info in matched if info["status"]]
+        ),
+        "daily_state": join_unique(
+            [f"{board}={info['daily_state']}" for board, info in matched if info["daily_state"]]
+        ),
+        "mid_state": join_unique(
+            [f"{board}={info['mid_state']}" for board, info in matched if info["mid_state"]]
+        ),
+        "risk_state": join_unique(
+            [f"{board}={info['risk_state']}" for board, info in matched if info["risk_state"]]
+        ),
+        "divergence_state": join_unique(
+            [
+                f"{board}={info['divergence_state']}"
+                for board, info in matched
+                if info["divergence_state"]
+            ]
+        ),
+        "reject_reason": join_unique(reasons),
+        "observe_reason": join_unique(observe_reasons),
+        "workflow_layer": clean_text(row.get(REVIEW_COLUMNS["holding_period"])),
+    }
+
+
+def split_market_gate_frames(
+    gated: pd.DataFrame,
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    strict = gated[gated[MARKET_GATE_COLUMNS["gate_result"]].eq(GATE_RESULT_STRICT)].copy()
+    observation = gated[
+        gated[MARKET_GATE_COLUMNS["gate_result"]].eq(GATE_RESULT_OBSERVATION)
+    ].copy()
+    rejected = gated[gated[MARKET_GATE_COLUMNS["gate_result"]].eq(GATE_RESULT_REJECTED)].copy()
+    active_watch = market_gate_active_watch_frame(gated)
+    return strict, observation, rejected, active_watch
+
+
+def market_gate_active_watch_frame(gated: pd.DataFrame) -> pd.DataFrame:
+    if gated.empty or MARKET_GATE_COLUMNS["active_watch_level"] not in gated.columns:
+        return gated.head(0).copy()
+    active = gated[
+        gated[MARKET_GATE_COLUMNS["active_watch_level"]].astype(str).str.strip().ne("")
+        & ~gated[MARKET_GATE_COLUMNS["gate_result"]].eq(GATE_RESULT_STRICT)
+    ].copy()
+    order = {
+        u("\\u53ef\\u4e3b\\u52a8\\u590d\\u6838"): 0,
+        u("\\u9057\\u6f0f\\u5ba1\\u8ba1"): 1,
+        u("\\u9ad8\\u6f6e\\u4e0d\\u8ffd"): 2,
+        u("\\u4ec5\\u89c2\\u5bdf"): 3,
+    }
+    active["_active_watch_order"] = (
+        active[MARKET_GATE_COLUMNS["active_watch_level"]].map(order).fillna(9)
+    )
+    sort_columns = ["_active_watch_order"]
+    if REVIEW_COLUMNS["rating"] in active.columns:
+        sort_columns.append(REVIEW_COLUMNS["rating"])
+    return active.sort_values(sort_columns).drop(columns=["_active_watch_order"])

indiciumforge_workflow/market_gate/render.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+
+import pandas as pd
+from indiciumforge_core.labels.market_gate import MARKET_GATE_COLUMNS, REVIEW_COLUMNS, WORKFLOW_ZH
+
+
+def render_market_gate_markdown(frame: pd.DataFrame, trade_date: date, label: str) -> str:
+    lines = [
+        f"# {trade_date.isoformat()} workflow market gate - {label}",
+        "",
+        WORKFLOW_ZH["disclaimer"],
+        "",
+        f"- {MARKET_GATE_COLUMNS['gate_result']}: {label}",
+        f"- rows: {len(frame)}",
+        "",
+    ]
+    if not frame.empty:
+        display_columns = [
+            REVIEW_COLUMNS["code"],
+            REVIEW_COLUMNS["stock_name"],
+            REVIEW_COLUMNS["rating"],
+            MARKET_GATE_COLUMNS["gate_result"],
+            MARKET_GATE_COLUMNS["matched_themes"],
+            MARKET_GATE_COLUMNS["theme_status"],
+            MARKET_GATE_COLUMNS["reject_reason"],
+            MARKET_GATE_COLUMNS["observe_reason"],
+            REVIEW_COLUMNS["holding_period"],
+            REVIEW_COLUMNS["narrative_stage"],
+            REVIEW_COLUMNS["thesis_risk"],
+        ]
+        columns = [column for column in display_columns if column in frame.columns]
+        lines.append(frame[columns].head(120).to_markdown(index=False))
+    return "\n".join(lines)
+
+
+def render_market_gate_active_watch_markdown(frame: pd.DataFrame, trade_date: date) -> str:
+    lines = [
+        f"# {trade_date.isoformat()} workflow market gate - active watch",
+        "",
+        WORKFLOW_ZH["disclaimer"],
+        "",
+        "- boundary: active watch is not strict execution pass",
+        f"- rows: {len(frame)}",
+        "",
+    ]
+    if not frame.empty:
+        display_columns = [
+            REVIEW_COLUMNS["code"],
+            REVIEW_COLUMNS["stock_name"],
+            REVIEW_COLUMNS["rating"],
+            MARKET_GATE_COLUMNS["gate_result"],
+            MARKET_GATE_COLUMNS["active_watch_level"],
+            MARKET_GATE_COLUMNS["active_watch_reason"],
+            MARKET_GATE_COLUMNS["active_watch_action"],
+            MARKET_GATE_COLUMNS["matched_themes"],
+            MARKET_GATE_COLUMNS["reject_reason"],
+            MARKET_GATE_COLUMNS["observe_reason"],
+        ]
+        columns = [column for column in display_columns if column in frame.columns]
+        lines.append(frame[columns].head(120).to_markdown(index=False))
+    return "\n".join(lines)
+
+
+def render_market_gate_summary_markdown(summary: dict[str, Any]) -> str:
+    lines = [
+        f"# workflow market gate summary - {summary.get('trade_date', '')}",
+        "",
+        WORKFLOW_ZH["disclaimer"],
+        "",
+        f"- rule_version: {summary.get('rule_version', '')}",
+        f"- candidate_count: {summary.get('candidate_count', 0)}",
+        f"- strict_count: {summary.get('strict_count', 0)}",
+        f"- observation_count: {summary.get('observation_count', 0)}",
+        f"- watch_count: {summary.get('watch_count', 0)}",
+        f"- rejected_count: {summary.get('rejected_count', 0)}",
+        f"- quality_gate_warning: {summary.get('quality_gate_warning', '')}",
+        f"- theme_state_ranking: {summary.get('theme_state_ranking', '')}",
+        f"- workflow_review: {summary.get('workflow_review', '')}",
+    ]
+    warnings = summary.get("warnings") or []
+    if warnings:
+        lines.extend(["", "## Warnings", ""])
+        lines.extend(f"- {item}" for item in warnings)
+    return "\n".join(lines)
+
+
+def render_market_gate_calibration_markdown(audit: dict[str, Any]) -> str:
+    lines = [
+        f"# workflow market gate calibration audit - {audit.get('trade_date', '')}",
+        "",
+        WORKFLOW_ZH["disclaimer"],
+        "",
+        "- strict execution gate stays strict; this audit is for rule calibration.",
+        f"- candidate_count: {audit.get('candidate_count', 0)}",
+        f"- strict_count: {audit.get('strict_count', 0)}",
+        f"- observation_count: {audit.get('observation_count', 0)}",
+        f"- watch_count: {audit.get('watch_count', 0)}",
+        f"- rejected_count: {audit.get('rejected_count', 0)}",
+        f"- quality_gate_warning: {audit.get('quality_gate_warning', '')}",
+        f"- outcome_status: {audit.get('outcome_status', '')}",
+        "",
+    ]
+    top_missed = audit.get("top_missed_candidates") or []
+    if top_missed:
+        table = pd.DataFrame(top_missed).to_markdown(index=False)
+        lines.extend(["## top_missed_candidates", "", table])
+    return "\n".join(lines)

indiciumforge_workflow/market_gate/resolver.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+
+from indiciumforge_core.artifacts.paths import workflow_root
+from indiciumforge_core.text import u
+
+
+@dataclass(frozen=True)
+class ReviewResolution:
+    path: Path
+    source_stage: str
+    warning: str
+
+
+def resolve_market_gate_review_path(artifact_root: Path, trade_date: date) -> ReviewResolution:
+    root = workflow_root(artifact_root, trade_date)
+    candidates = [
+        ("preopen", root / "preopen" / "buy_point_review_internal.csv", ""),
+        (
+            "preopen",
+            root / "preopen" / "buy_point_review.csv",
+            u(
+                "\\u672a\\u627e\\u5230preopen internal\\u5019\\u9009\\u8868\\uff0c"
+                "\\u5df2\\u56de\\u9000\\u8bfb\\u53d6preopen\\u516c\\u5f00\\u8868"
+            ),
+        ),
+        (
+            "post_close",
+            root / "post_close" / "buy_point_review_internal.csv",
+            u(
+                "\\u672a\\u627e\\u5230preopen\\u5019\\u9009\\u8868\\uff0c"
+                "\\u5df2\\u56de\\u9000\\u8bfb\\u53d6post_close internal\\u5019\\u9009\\u8868"
+            ),
+        ),
+        (
+            "post_close",
+            root / "post_close" / "buy_point_review.csv",
+            u(
+                "\\u672a\\u627e\\u5230preopen\\u5019\\u9009\\u8868\\uff0c"
+                "\\u5df2\\u56de\\u9000\\u8bfb\\u53d6post_close\\u516c\\u5f00\\u8868"
+            ),
+        ),
+    ]
+    for stage, path, warning in candidates:
+        if path.exists():
+            return ReviewResolution(path=path, source_stage=stage, warning=warning)
+    searched = ", ".join(str(path) for _, path, _ in candidates)
+    raise FileNotFoundError(f"missing workflow review for market-gate: {searched}")