aps-agent/server/engines/cp_engine.py

# ============================================================
# CP-SAT 排产引擎（moduleId: engines-cp, SC-03 首切片，可重生 ✅）
# OR-Tools：工序级 Interval / NoOverlap 模型（方向 D 升级）：
#   - 每订单每道工序一个 OptionalIntervalVar，工艺路线串联（C1）
#   - 同工位/设备工序 NoOverlap（C2）；同线不同工位可并行（流水）
#   - 换型矩阵在产线工序序列间计入 setup（C10，next-link 路径）
#   - 冻结窗内已发布/冻结工单作为固定障碍（C11）
#   - Cumulative 聚合容量（C12）：同一班组/工装在时间上并行的工序占用总和
#     ≤ 可用容量（AddCumulative；teamId/toolingId 挂在工位上，容量取班组/
#     工装主数据可用数量，personnel/tooling 开关控制启用）
#   物化仍走 RuleEngine 班次占槽（诚实留痕 placement=shift-slot）。
# ============================================================
from __future__ import annotations

import hashlib
import json
import os
import sys
from collections.abc import Callable
from itertools import pairwise
from typing import Any

from server.contracts import ScheduleResult
from server.engines.base import EngineParams
from server.engines.queries import (
    find_product_lines,
    find_routing_steps,
    find_workstation_for_operation,
)
from server.engines.rule_engine import RuleEngine
from server.timeutil import add_minutes, fmt_date, fmt_dt, parse_dt, today0

World = dict[str, Any]
CP_DIAGNOSTIC_RELAXABLE_CONSTRAINTS = frozenset({
    "C1_precedence",
    "C2_no_overlap",
    "C3_calendar",
    "C7_capacity",
    "C10_changeover",
    "C11_freeze",
    "C12_team",
    "C12_tooling",
})
CP_DIAGNOSTIC_RHS_PARAMETERS = frozenset({
    "C7_line_day_capacity_minutes",
    "C8_due_date_allowance",
    "C12_team_capacity",
    "C12_tooling_capacity",
})


def _normalize_rhs_perturbation(value: dict[str, Any] | None) -> dict[str, Any] | None:
    if value is None:
        return None
    if not isinstance(value, dict):
        raise TypeError("rhs_perturbation 必须是对象或 None")
    parameter_id = value.get("parameterId")
    if parameter_id not in CP_DIAGNOSTIC_RHS_PARAMETERS:
        raise ValueError(f"不支持 RHS 诊断参数：{parameter_id}")
    increment = value.get("increment")
    if isinstance(increment, bool) or not isinstance(increment, int) or increment <= 0:
        raise ValueError("RHS 诊断 increment 必须为正整数")
    if parameter_id == "C7_line_day_capacity_minutes":
        if set(value) != {"parameterId", "lineId", "bucketDate", "increment"}:
            raise ValueError("C7 RHS 诊断须包含 parameterId/lineId/bucketDate/increment")
        line_id = value.get("lineId")
        bucket_date = value.get("bucketDate")
        if isinstance(line_id, bool) or not isinstance(line_id, int) or line_id <= 0:
            raise ValueError("C7 RHS 诊断 lineId 必须为正整数")
        if not isinstance(bucket_date, str) or len(bucket_date) != 10:
            raise ValueError("C7 RHS 诊断 bucketDate 须为 YYYY-MM-DD")
        try:
            from datetime import date

            if date.fromisoformat(bucket_date).isoformat() != bucket_date:
                raise ValueError
        except ValueError as exc:
            raise ValueError("C7 RHS 诊断 bucketDate 须为 YYYY-MM-DD") from exc
        if increment > 1_440:
            raise ValueError("C7 line/day capacity increment 不得超过 1440 分钟")
        return {
            "parameterId": parameter_id,
            "lineId": line_id,
            "bucketDate": bucket_date,
            "increment": increment,
        }
    if parameter_id == "C8_due_date_allowance":
        if set(value) != {"parameterId", "increment"}:
            raise ValueError("C8 RHS 诊断仅接受 parameterId/increment")
        if increment > 10_080:
            raise ValueError("C8 due-date allowance increment 不得超过 10080 分钟")
        return {"parameterId": parameter_id, "increment": increment}
    if set(value) != {"parameterId", "resourceId", "increment"}:
        raise ValueError("C12 RHS 诊断须包含 parameterId/resourceId/increment")
    resource_id = value.get("resourceId")
    if isinstance(resource_id, bool) or not isinstance(resource_id, int) or resource_id <= 0:
        raise ValueError("C12 RHS 诊断 resourceId 必须为正整数")
    if increment > 100:
        raise ValueError("C12 capacity increment 不得超过 100")
    return {
        "parameterId": parameter_id,
        "resourceId": resource_id,
        "increment": increment,
    }


def _job_duration_min(world: World, item: dict, line: dict) -> int:
    """连续时间估算：工艺总分钟（含准备与转移/等待；不含跨族矩阵，物化阶段再加）。"""
    eff = float(line.get("efficiencyFactor") or 1.0) or 1.0
    total = 0.0
    for step in find_routing_steps(world, item["productId"]):
        total += float(step["setupTime"]) + (float(item["quantity"]) * float(step["runTimePerUnit"])) / eff
        total += float(step.get("transferTime") or 0) + float(step.get("waitTime") or 0)
    return max(1, round(total))


def _operation_duration_min(step: dict, item: dict, eff: float) -> int:
    """单工序连续分钟：准备 + 数量×单件/效率（不含转移/等待间隙）。"""
    dur = float(step["setupTime"]) + (float(item["quantity"]) * float(step["runTimePerUnit"])) / eff
    return max(1, round(dur))


def _operation_gap_min(step: dict) -> int:
    """工序后置间隙分钟：转移 + 等待（工序串联的间隔）。"""
    return max(0, round(float(step.get("transferTime") or 0) + float(step.get("waitTime") or 0)))


def _line_by_id(world: World, line_id: int) -> dict | None:
    """取产线对象；缺失返回 None。"""
    return next((l for l in world["lines"] if l["id"] == line_id), None)


def _family_of_product(world: World, product_id: int) -> str | None:
    """产品族（换型矩阵键）。"""
    from server.aps_domain.changeover import family_of_product
    return family_of_product(world, product_id)


def _changeover_setup_min(world: World, from_family: str | None, to_family: str | None) -> int:
    """换型矩阵分钟：同族 / 无前序为 0；缺矩阵条目走默认跨族分钟。"""
    from server.aps_domain.changeover import lookup_setup_minutes
    return max(0, round(lookup_setup_minutes(world, from_family, to_family)))


def _candidate_options(world: World, item: dict, line: dict) -> list[dict] | None:
    """某产品在指定产线上逐工序展开：绑定工位并估算工时。

    任一工序在该线缺可用工位 → 返回 None（CP 不选此线；物化阶段报 NO_WORKSTATION）。
    无工艺路线 → None（走哑元，物化阶段报 NO_LINE/NO_ROUTING）。
    """
    steps = find_routing_steps(world, item["productId"])
    if not steps:
        return None
    eff = float(line.get("efficiencyFactor") or 1.0) or 1.0
    specs: list[dict] = []
    for step in steps:
        ws = find_workstation_for_operation(world, int(line["id"]), int(step["operationId"]))
        if ws is None:
            return None
        specs.append({
            "step": step,
            "routingStepId": int(step["id"]),
            "operationId": int(step["operationId"]),
            "workstationId": int(ws["id"]),
            "teamId": ws.get("teamId"),        # C12：工位所属班组（累计资源）
            "toolingId": ws.get("toolingId"),  # C12：工位占用工装（累计资源）
            "dur": _operation_duration_min(step, item, eff),
            "gap": _operation_gap_min(step),
            "setupMin": round(float(step["setupTime"])),
        })
    return specs


def _team_capacity_by_id(world: World) -> dict[int, int]:
    """固定轨班组主数据 → 班组可用人数（C12_team 累计资源容量）。

    可用数量取 availableCount，缺省回退 memberCount；<=0 视为未接线（不建约束）。
    """
    caps: dict[int, int] = {}
    for team in world.get("teams") or []:
        cap = int(team.get("availableCount") or team.get("memberCount") or 0)
        if cap > 0:
            caps[int(team["id"])] = cap
    return caps


def _tooling_capacity_by_id(world: World) -> dict[int, int]:
    """固定轨工装主数据 → 工装可用数量（C12_tooling 累计资源容量）。

    可用数量取 availableCount，缺省回退 quantity/count；<=0 视为未接线。
    """
    caps: dict[int, int] = {}
    for tooling in world.get("toolings") or []:
        cap = int(tooling.get("availableCount") or tooling.get("quantity")
                  or tooling.get("count") or 0)
        if cap > 0:
            caps[int(tooling["id"])] = cap
    return caps


def _resource_code(world: World, kind: str, resource_id: int) -> str | None:
    """班组/工装主数据编码（solverMeta 展示用）。"""
    table = world.get("teams" if kind == "team" else "toolings") or []
    for row in table:
        if int(row.get("id", -1)) == resource_id:
            return str(row.get("code") or "")
    return None


def _line_code(world: World, line_id: int) -> str | None:
    line = _line_by_id(world, line_id)
    return str(line.get("code") or "") if line is not None else None


def _hm_minutes(value: str) -> int:
    hour, minute = str(value).split(":", 1)
    result = int(hour) * 60 + int(minute)
    if not 0 <= result <= 24 * 60:
        raise ValueError(f"非法班次时间：{value}")
    return result


def _line_day_buckets(
    world: World,
    line_ids: set[int],
    anchor,
    horizon: int,
) -> list[dict[str, Any]]:
    """Build strict natural-day C7 buckets from explicit shift-calendar rows."""
    anchor_minute = anchor.hour * 60 + anchor.minute
    day_count = max(1, (anchor_minute + horizon + 1439) // 1440)
    shifts = {int(row["id"]): row for row in world.get("shifts") or []}
    calendar = world.get("shiftCalendar") or []
    buckets: list[dict[str, Any]] = []
    for day_offset in range(day_count):
        bucket_date = fmt_date(add_minutes(anchor, day_offset * 1440))
        day_origin = day_offset * 1440 - anchor_minute
        bucket_start = max(0, day_origin)
        bucket_end = min(horizon, bucket_start + 1440 if day_offset else 1440 - anchor_minute)
        if bucket_end <= bucket_start:
            continue
        for line_id in sorted(line_ids):
            rows = [
                row for row in calendar
                if int(row.get("lineId", -1)) == line_id and row.get("date") == bucket_date
            ]
            if not rows:
                raise ValueError(f"C7 日历覆盖不完整：line={line_id}, date={bucket_date}")
            working = [row for row in rows if row.get("isWorking") is True]
            shift_windows: list[tuple[int, int]] = []
            effective_windows: list[dict[str, int]] = []
            capacity = 0
            shift_ids: list[int] = []
            calendar_ids: list[int] = []
            for row in working:
                shift_id = int(row.get("shiftId", -1))
                shift = shifts.get(shift_id)
                if shift is None:
                    raise ValueError(
                        f"C7 日历引用不存在班次：line={line_id}, date={bucket_date}, shift={shift_id}"
                    )
                start = _hm_minutes(str(shift.get("startTime") or ""))
                end = _hm_minutes(str(shift.get("endTime") or ""))
                if end <= start:
                    raise ValueError(f"C7 暂不支持跨午夜班次：shift={shift_id}")
                breaks: list[tuple[int, int]] = []
                for pause in shift.get("breakPeriods") or []:
                    pause_start = _hm_minutes(str(pause.get("start") or ""))
                    pause_end = _hm_minutes(str(pause.get("end") or ""))
                    if pause_end <= pause_start or pause_start < start or pause_end > end:
                        raise ValueError(f"C7 班次休息段非法：shift={shift_id}")
                    breaks.append((pause_start, pause_end))
                breaks.sort()
                if any(left[1] > right[0] for left, right in pairwise(breaks)):
                    raise ValueError(f"C7 班次休息段重叠：shift={shift_id}")
                shift_windows.append((start, end))
                cursor = start
                for pause_start, pause_end in breaks:
                    if cursor < pause_start:
                        window_start = max(0, day_origin + cursor)
                        window_end = min(horizon, day_origin + pause_start)
                        if window_start < window_end:
                            effective_windows.append({
                                "startMin": window_start,
                                "endMin": window_end,
                                "shiftId": shift_id,
                            })
                    cursor = pause_end
                if cursor < end:
                    window_start = max(0, day_origin + cursor)
                    window_end = min(horizon, day_origin + end)
                    if window_start < window_end:
                        effective_windows.append({
                            "startMin": window_start,
                            "endMin": window_end,
                            "shiftId": shift_id,
                        })
                capacity += end - start - sum(stop - begin for begin, stop in breaks)
                shift_ids.append(shift_id)
                calendar_ids.append(int(row.get("id", -1)))
            shift_windows.sort()
            if any(left[1] > right[0] for left, right in pairwise(shift_windows)):
                raise ValueError(f"C7 班次窗口重叠：line={line_id}, date={bucket_date}")
            buckets.append({
                "lineId": line_id,
                "lineCode": _line_code(world, line_id),
                "bucketDate": bucket_date,
                "bucketStartMin": bucket_start,
                "bucketEndMin": bucket_end,
                "baseCapacityMinutes": max(0, capacity),
                "capacityMinutes": max(0, capacity),
                "shiftIds": sorted(shift_ids),
                "shiftCalendarRowIds": sorted(calendar_ids),
                "effectiveWindows": effective_windows,
            })
    buckets.sort(key=lambda row: (int(row["lineId"]), str(row["bucketDate"])))
    return buckets


def _frozen_line_day_loads(world: World) -> dict[tuple[int, str], int]:
    published = {
        row.get("id") for row in world.get("scheduleVersions", [])
        if row.get("status") == "PUBLISHED"
    }
    production_versions = {
        row.get("id"): row.get("schedulingVersionId")
        for row in world.get("productionOrders", [])
    }
    loads: dict[tuple[int, str], int] = {}
    for work_order in world.get("workOrders", []):
        version_id = work_order.get("schedulingVersionId") or production_versions.get(
            work_order.get("productionOrderId")
        )
        if not work_order.get("isFrozen") and version_id not in published:
            continue
        if work_order.get("lineId") is None:
            continue
        start = str(work_order.get("plannedStartTime") or "")
        end = str(work_order.get("plannedEndTime") or "")
        if len(start) < 10 or not end:
            continue
        try:
            processing = work_order.get("processingMinutes")
            duration = (
                round(float(processing))
                if isinstance(processing, (int, float)) and not isinstance(processing, bool)
                else round((parse_dt(end) - parse_dt(start)).total_seconds() / 60.0)
            )
        except (TypeError, ValueError):
            continue
        if duration <= 0:
            continue
        key = (int(work_order["lineId"]), start[:10])
        loads[key] = loads.get(key, 0) + duration
    return loads


def _peak_overlap(intervals: list[tuple[int, int]]) -> int:
    """区间集 [start, end) 的最大同时重叠数（端点相切不算重叠）。"""
    if not intervals:
        return 0
    events: list[tuple[int, int]] = []
    for s, e in intervals:
        events.append((s, 1))
        events.append((e, -1))
    events.sort(key=lambda ev: (ev[0], ev[1]))  # 同点先出后进 → 相切不算重叠
    cur = peak = 0
    for _, d in events:
        cur += d
        peak = max(peak, cur)
    return peak


def _collect_frozen_obstacles(world: World, anchor, freeze_min: int, horizon: int) -> list[dict]:
    """冻结窗 [anchor, anchor+freeze_min] 内已发布/已冻结工单 → 固定障碍区间。

    返回区间以 anchor 为 0 点的分钟（裁剪到 [0, horizon]）；窗内工单不可重排，
    CP 只把它们当作不可重叠的固定障碍。
    """
    published = {v["id"] for v in world["scheduleVersions"] if v.get("status") == "PUBLISHED"}
    production_versions = {
        row.get("id"): row.get("schedulingVersionId")
        for row in world.get("productionOrders", [])
    }
    out: list[dict] = []
    for wo in world["workOrders"]:
        source_version_id = wo.get("schedulingVersionId") or production_versions.get(
            wo.get("productionOrderId")
        )
        frozen = bool(wo.get("isFrozen")) or source_version_id in published
        if not frozen or wo.get("workstationId") is None:
            continue
        try:
            ws_start = parse_dt(wo["plannedStartTime"])
            ws_end = parse_dt(wo["plannedEndTime"])
        except (KeyError, TypeError, ValueError):
            continue
        s_min = (ws_start - anchor).total_seconds() / 60.0
        e_min = (ws_end - anchor).total_seconds() / 60.0
        if e_min <= 0 or s_min >= freeze_min:
            continue  # 完全落在窗外
        s_int = max(0, round(s_min))
        e_int = min(horizon, max(s_int + 1, round(e_min)))
        if e_int <= s_int:
            continue
        out.append({
            "sourceWorkOrderId": wo.get("id"),
            "sourceSchedulingVersionId": source_version_id,
            "orderNo": wo.get("orderNo") or "",
            "workstationId": int(wo["workstationId"]),
            "lineId": wo.get("lineId"),
            "startMin": s_int,
            "endMin": e_int,
            "durationMin": e_int - s_int,
        })
    return out


def _due_minutes(so: dict, base_start, due_buffer: float) -> int:
    due = parse_dt(so["deliveryDate"] + " 18:00")
    if due_buffer < 1.0 - 1e-9:
        span = (due - base_start).total_seconds() / 60.0
        if span > 0:
            due = add_minutes(base_start, span * due_buffer)
    mins = int((due - base_start).total_seconds() / 60.0)
    return max(0, mins)


def build_rule_warm_start(
    world: World,
    entries: list[dict],
    params: EngineParams,
) -> list[dict[str, int]]:
    """按 RULE 启发式选线，构造连续时间上的贪心起止（供 CP AddHint）。"""
    _ = params  # 与 CP 共用签名；当前 hint 不依赖缓冲/冻结（物化阶段再应用）
    cursor_by_line: dict[int, int] = {}
    hints: list[dict[str, int]] = []
    for entry in entries:
        item = entry["item"]
        opts = find_product_lines(world, item["productId"])
        if not opts:
            hints.append({"lineId": -1, "start": 0, "end": 1})
            continue
        # 与 RULE 默认一致：优先级最高的产线
        line_id = int(opts[0]["lineId"])
        line = next(l for l in world["lines"] if l["id"] == line_id)
        dur = _job_duration_min(world, item, line)
        start = cursor_by_line.get(line_id, 0)
        end = start + dur
        hints.append({"lineId": line_id, "start": start, "end": end})
        cursor_by_line[line_id] = end
    return hints


def optimize_line_assignment(
    world: World,
    entries: list[dict],
    params: EngineParams,
    *,
    warm_start: list[dict[str, int]] | None = None,
    pipeline_label: str | None = None,
    relaxed_constraint_ids: list[str] | None = None,
    diagnostic_mode: bool = False,
    rhs_diagnostic_mode: bool = False,
    rhs_perturbation: dict[str, Any] | None = None,
) -> tuple[list[dict], dict[str, Any]]:
    """
    CP-SAT 工序级模型：每单一条可行产线；逐工序 IntervalVar 按工艺路线串联（C1），
    同工位/设备 NoOverlap（C2），换型矩阵 setup 计入产线工序序列（C10），
    冻结窗内已排工单固定为障碍（C11）；最小化加权延期。
    返回：带 forcedLineId 的重排序条目 + solverMeta（含 operationSlots）。
    warm_start：可选 RULE 初解 hint（lineId/start/end）。
    """
    try:
        from ortools.sat.python import cp_model
    except ImportError as exc:  # pragma: no cover
        raise RuntimeError(
            "未安装 ortools，无法运行 CP-SAT。请执行：pip install ortools"
        ) from exc

    from server.aps_domain.params import level_weight as _level_w

    n = len(entries)
    relaxed = {str(value) for value in (relaxed_constraint_ids or [])}
    normalized_rhs = _normalize_rhs_perturbation(rhs_perturbation)
    unknown_relaxed = relaxed - CP_DIAGNOSTIC_RELAXABLE_CONSTRAINTS
    if unknown_relaxed:
        raise ValueError(f"不支持诊断松弛约束：{sorted(unknown_relaxed)}")
    if rhs_diagnostic_mode and not diagnostic_mode:
        raise ValueError("RHS 诊断必须启用 diagnostic_mode")
    if normalized_rhs is not None and not rhs_diagnostic_mode:
        raise ValueError("普通排产和整约束诊断禁止 RHS 扰动")
    if rhs_diagnostic_mode and relaxed:
        raise ValueError("RHS 参数诊断与整约束移除不能混用")
    meta: dict[str, Any] = {
        "backend": "OR-Tools CP-SAT",
        "placement": "cp-calendar-segmented-advisory",
        "materializedBy": "RuleEngine",
        "directlyConsumedByMaterializer": False,
        "model": (
            "operation-level+calendar-segments+no-overlap+line-day-capacity+"
            "changeover+freeze+cumulative"
        ),
    }
    if pipeline_label:
        meta["pipeline"] = pipeline_label
    if warm_start:
        meta["warmStart"] = "RULE"
    if n == 0:
        if relaxed or normalized_rhs is not None:
            raise ValueError("空排产任务不能请求诊断松弛或 RHS 扰动")
        meta.update({
            "status": "TRIVIAL", "wallTimeSec": 0.0, "gap": 0.0, "objective": 0,
            "assumptionConstraints": [], "enforcedAssumptionConstraints": [],
            "relaxedConstraintIds": [], "activeAssumptionConstraints": [],
            "constraintInstanceCounts": {}, "diagnosticMode": bool(diagnostic_mode),
            "rhsDiagnosticMode": bool(rhs_diagnostic_mode), "rhsPerturbation": None,
            "rhsParameterState": {
                "dueDateAllowanceMinutes": 0, "dueDateEntryCount": 0,
                "lineDailyCapacities": [], "teamCapacities": [], "toolingCapacities": [],
            },
        })
        return entries, meta

    freeze_hours = float(params.freezeWindowHours) if params.freezeWindowHours is not None else 0.0
    freeze_min = max(0, int(freeze_hours * 60))
    anchor = (
        parse_dt(params.startDate + " 08:00") if params.startDate
        else add_minutes(today0(), 24 * 60)
    )
    base_start = add_minutes(anchor, freeze_min) if freeze_min > 0 else anchor
    due_buffer = (
        1.0 if params.deliveryBufferRatio is None
        else max(0.5, min(1.0, float(params.deliveryBufferRatio)))
    )
    horizon_days = int(params.planningHorizonDays or 14)
    # 保留历史 2×展望期余量；C3 coverage 必须覆盖完整 CP 时间域，
    # 不能只覆盖请求 planning horizon 后把余量当作无日历逃逸区。
    horizon = max(horizon_days * 24 * 60 * 2, 7 * 24 * 60)
    frozen = _collect_frozen_obstacles(world, anchor, freeze_min, horizon) if freeze_min > 0 else []
    changeover_enabled = bool(params.constraints.get("changeover", True))
    # C12 聚合容量开关：params.constraints 为旧接口（personnel/tooling），
    # 世界约束剖面 C12_team/C12_tooling 为权威开关（两者都开才启用）
    from server.aps_domain.constraints import is_enabled as _constraint_enabled
    line_capacity_enabled = bool(params.constraints.get("capacity", True)) and _constraint_enabled(
        world, "C7_capacity"
    )
    calendar_enabled = _constraint_enabled(world, "C3_calendar")
    team_cum_enabled = bool(params.constraints.get("personnel", True)) and _constraint_enabled(world, "C12_team")
    tooling_cum_enabled = bool(params.constraints.get("tooling", True)) and _constraint_enabled(world, "C12_tooling")
    team_caps = _team_capacity_by_id(world) if team_cum_enabled else {}
    tooling_caps = _tooling_capacity_by_id(world) if tooling_cum_enabled else {}
    due_allowance_min = 0
    rhs_parameter_id = normalized_rhs.get("parameterId") if normalized_rhs else None
    if rhs_parameter_id == "C8_due_date_allowance":
        due_allowance_min = int(normalized_rhs["increment"])
    elif rhs_parameter_id == "C7_line_day_capacity_minutes":
        if not line_capacity_enabled:
            raise ValueError("C7 capacity 在本次模型中未启用")
        line_id = int(normalized_rhs["lineId"])
        line = _line_by_id(world, line_id)
        if line is None or line.get("status", "ACTIVE") != "ACTIVE":
            raise ValueError(f"产线 {line_id} 未接入 C7 capacity 模型")
    elif rhs_parameter_id == "C12_team_capacity":
        resource_id = int(normalized_rhs["resourceId"])
        if resource_id not in team_caps:
            raise ValueError(f"班组资源 {resource_id} 未接入 C12 capacity 模型")
        team_caps[resource_id] += int(normalized_rhs["increment"])
    elif rhs_parameter_id == "C12_tooling_capacity":
        resource_id = int(normalized_rhs["resourceId"])
        if resource_id not in tooling_caps:
            raise ValueError(f"工装资源 {resource_id} 未接入 C12 capacity 模型")
        tooling_caps[resource_id] += int(normalized_rhs["increment"])

    # ---- 预计算工序级候选：每单每条产线 = 工序序列（工位/工时/间隙） ----
    job_opts: list[list[dict]] = []  # [j][k] = {lineId, specs, family}
    dues: list[int] = []
    weights: list[int] = []
    for entry in entries:
        so, item = entry["so"], entry["item"]
        family = _family_of_product(world, item["productId"])
        opts: list[dict] = []
        for lp in find_product_lines(world, item["productId"]):
            line = _line_by_id(world, int(lp["lineId"]))
            if line is None:
                continue
            specs = _candidate_options(world, item, line)
            if specs is None:
                continue  # 缺工位/无工艺：该线不作为候选（物化阶段报 NO_WORKSTATION/NO_ROUTING）
            opts.append({"lineId": int(lp["lineId"]), "specs": specs, "family": family})
        if not opts:
            # 无合格产线：仍参与序，物化阶段报 NO_LINE/NO_WORKSTATION
            dur = _job_duration_min(world, item, {"efficiencyFactor": 1.0})
            opts = [{"lineId": -1, "specs": [{
                "operationId": None, "workstationId": None,
                "dur": dur, "gap": 0, "setupMin": 0,
            }], "family": family}]
        job_opts.append(opts)
        dues.append(_due_minutes(so, base_start, due_buffer) + due_allowance_min)
        w = round(_level_w(world, so.get("customerLevel")) * 100)
        if so.get("isRush"):
            w += 200
        if so.get("isForecast"):
            w = max(1, w // 2)
        weights.append(max(1, w))

    candidate_line_ids = {
        int(option["lineId"])
        for options in job_opts
        for option in options
        if int(option["lineId"]) >= 0
    }
    calendar_buckets = (
        _line_day_buckets(world, candidate_line_ids, anchor, horizon)
        if calendar_enabled or line_capacity_enabled
        else []
    )
    calendar_windows_by_line: dict[int, list[dict[str, Any]]] = {}
    for bucket in calendar_buckets:
        line_id = int(bucket["lineId"])
        for window_index, window in enumerate(bucket.get("effectiveWindows") or []):
            calendar_windows_by_line.setdefault(line_id, []).append({
                **window,
                "bucketDate": str(bucket["bucketDate"]),
                "windowId": (
                    f"line-window:{line_id}:{bucket['bucketDate']}:"
                    f"{int(window['shiftId'])}:{window_index}"
                ),
            })
    for windows in calendar_windows_by_line.values():
        windows.sort(key=lambda row: (int(row["startMin"]), int(row["endMin"])))
    calendar_payload = [
        {
            "lineId": line_id,
            "windows": [
                {
                    key: window[key]
                    for key in ("windowId", "bucketDate", "shiftId", "startMin", "endMin")
                }
                for window in windows
            ],
        }
        for line_id, windows in sorted(calendar_windows_by_line.items())
    ]
    calendar_digest = hashlib.sha256(json.dumps(
        calendar_payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"),
    ).encode("utf-8")).hexdigest()
    calendar_selector_estimate = sum(
        len(calendar_windows_by_line.get(int(option["lineId"]), [])) * len(option["specs"])
        for options in job_opts
        for option in options
        if int(option["lineId"]) >= 0
    )
    if calendar_enabled and calendar_selector_estimate > 50_000:
        raise ValueError(
            "CP_CALENDAR_MODEL_TOO_LARGE: C3 segment interval count "
            f"{calendar_selector_estimate} exceeds 50000"
        )

    # 日历感知首解 hint：按产线串行、按有效窗口切段，并预留 C7 开工日负荷。
    # hint 不新增约束；共享班组/工装或冻结障碍有冲突时由 CP 自行修复。
    hint_line_by_job: dict[int, int] = {}
    hint_option_by_job: dict[int, dict[str, Any]] = {}
    hint_segments_by_operation: dict[tuple[int, int, int], list[dict[str, int | str]]] = {}
    hint_cursor_by_line: dict[int, int] = {}
    hint_lane_cursors: dict[tuple[str, int], list[int]] = {}
    hint_day_loads = _frozen_line_day_loads(world)
    hint_capacity_by_bucket = {
        (int(bucket["lineId"]), str(bucket["bucketDate"])): int(bucket["baseCapacityMinutes"])
        for bucket in calendar_buckets
    }
    if rhs_parameter_id == "C7_line_day_capacity_minutes":
        hint_key = (int(normalized_rhs["lineId"]), str(normalized_rhs["bucketDate"]))
        if hint_key in hint_capacity_by_bucket:
            hint_capacity_by_bucket[hint_key] += int(normalized_rhs["increment"])
    hint_last_family_by_line: dict[int, str | None] = {}
    requested_hint_lines = {
        index: int(hint.get("lineId", -1))
        for index, hint in enumerate(warm_start or [])
        if index < n
    }
    hint_freeze_min = 0 if "C11_freeze" in relaxed else freeze_min
    for j, options in enumerate(job_opts):
        requested_line = requested_hint_lines.get(j)
        selected = next(
            (option for option in options if int(option["lineId"]) == requested_line),
            min(
                (option for option in options if int(option["lineId"]) >= 0),
                key=lambda option: (
                    hint_cursor_by_line.get(int(option["lineId"]), hint_freeze_min),
                    int(option["lineId"]),
                ),
                default=options[0],
            ),
        )
        line_id = int(selected["lineId"])
        hint_line_by_job[j] = line_id
        hint_option_by_job[j] = selected
        if line_id < 0 or not calendar_enabled:
            continue
        cursor = max(hint_freeze_min, hint_cursor_by_line.get(line_id, hint_freeze_min))
        windows = calendar_windows_by_line.get(line_id, [])
        operation_hints: list[tuple[int, list[dict[str, int | str]]]] = []
        feasible_hint = True
        for s, spec in enumerate(selected["specs"]):
            duration = int(spec["dur"])
            setup = 0
            if s == 0 and changeover_enabled and line_id in hint_last_family_by_line:
                setup = _changeover_setup_min(
                    world, hint_last_family_by_line[line_id], selected["family"],
                )
                cursor += setup
            selected_lanes: list[tuple[list[int], int]] = []
            constrained_resources: list[tuple[tuple[str, int], int]] = []
            if "C2_no_overlap" not in relaxed:
                constrained_resources.append((
                    ("workstation", int(spec["workstationId"])), 1,
                ))
            if (
                team_cum_enabled and "C12_team" not in relaxed
                and spec.get("teamId") is not None
                and int(spec["teamId"]) in team_caps
            ):
                constrained_resources.append((
                    ("team", int(spec["teamId"])), int(team_caps[int(spec["teamId"])]),
                ))
            if (
                tooling_cum_enabled and "C12_tooling" not in relaxed
                and spec.get("toolingId") is not None
                and int(spec["toolingId"]) in tooling_caps
            ):
                constrained_resources.append((
                    ("tooling", int(spec["toolingId"])),
                    int(tooling_caps[int(spec["toolingId"])]),
                ))
            for resource_key, capacity in constrained_resources:
                lanes = hint_lane_cursors.setdefault(
                    resource_key, [hint_freeze_min] * max(1, capacity),
                )
                lane_index = min(range(len(lanes)), key=lanes.__getitem__)
                cursor = max(cursor, lanes[lane_index])
                selected_lanes.append((lanes, lane_index))
            allocation: list[dict[str, int | str]] | None = None
            for start_index, first_window in enumerate(windows):
                first_start = max(cursor, int(first_window["startMin"]))
                if first_start >= int(first_window["endMin"]):
                    continue
                bucket_key = (line_id, str(first_window["bucketDate"]))
                if line_capacity_enabled and (
                    hint_day_loads.get(bucket_key, 0) + duration + setup
                    > hint_capacity_by_bucket.get(bucket_key, 0)
                ):
                    continue
                remaining = duration
                candidate: list[dict[str, int | str]] = []
                for window_index in range(start_index, len(windows)):
                    window = windows[window_index]
                    segment_start = max(
                        first_start if window_index == start_index else int(window["startMin"]),
                        int(window["startMin"]),
                    )
                    available = int(window["endMin"]) - segment_start
                    if available <= 0:
                        continue
                    segment_size = min(remaining, available)
                    candidate.append({
                        "windowId": str(window["windowId"]),
                        "startMin": segment_start,
                        "endMin": segment_start + segment_size,
                        "durationMin": segment_size,
                    })
                    remaining -= segment_size
                    if remaining == 0:
                        allocation = candidate
                        if line_capacity_enabled:
                            hint_day_loads[bucket_key] = (
                                hint_day_loads.get(bucket_key, 0) + duration + setup
                            )
                        break
                if allocation is not None:
                    break
            if allocation is None:
                feasible_hint = False
                break
            operation_hints.append((s, allocation))
            for lanes, lane_index in selected_lanes:
                lanes[lane_index] = int(allocation[-1]["endMin"])
            cursor = int(allocation[-1]["endMin"]) + int(spec["gap"])
        if feasible_hint:
            for s, allocation in operation_hints:
                hint_segments_by_operation[(j, line_id, s)] = allocation
            hint_cursor_by_line[line_id] = int(operation_hints[0][1][-1]["endMin"])
            hint_last_family_by_line[line_id] = selected["family"]

    hinted_resource_intervals: dict[tuple[str, int], list[tuple[int, int]]] = {}
    hint_complete = len(hint_option_by_job) == n
    hint_missing_operations: list[dict[str, int]] = []
    hint_job_ends: list[int] = []
    for j in range(n):
        option = hint_option_by_job.get(j)
        if option is None or int(option["lineId"]) < 0:
            hint_complete = False
            continue
        operation_end = 0
        for s, spec in enumerate(option["specs"]):
            allocation = hint_segments_by_operation.get((j, int(option["lineId"]), s))
            if not allocation:
                hint_complete = False
                hint_missing_operations.append({
                    "orderIndex": j, "lineId": int(option["lineId"]), "operationIndex": s,
                })
                continue
            operation_end = max(operation_end, int(allocation[-1]["endMin"]))
            for segment in allocation:
                interval = (int(segment["startMin"]), int(segment["endMin"]))
                hinted_resource_intervals.setdefault(
                    ("workstation", int(spec["workstationId"])), []
                ).append(interval)
                if spec.get("teamId") is not None:
                    hinted_resource_intervals.setdefault(
                        ("team", int(spec["teamId"])), []
                    ).append(interval)
                if spec.get("toolingId") is not None:
                    hinted_resource_intervals.setdefault(
                        ("tooling", int(spec["toolingId"])), []
                    ).append(interval)
        hint_job_ends.append(operation_end)

    hint_resources_feasible = True
    for (kind, resource_id), intervals in hinted_resource_intervals.items():
        peak = _peak_overlap(intervals)
        if kind == "workstation" and "C2_no_overlap" not in relaxed and peak > 1:
            hint_resources_feasible = False
        elif (
            kind == "team" and team_cum_enabled and "C12_team" not in relaxed
            and resource_id in team_caps and peak > team_caps[resource_id]
        ):
            hint_resources_feasible = False
        elif (
            kind == "tooling" and tooling_cum_enabled and "C12_tooling" not in relaxed
            and resource_id in tooling_caps and peak > tooling_caps[resource_id]
        ):
            hint_resources_feasible = False
    zero_objective_feasible_hint = bool(
        hint_complete
        and hint_resources_feasible
        and len(hint_job_ends) == n
        and all(end <= due for end, due in zip(hint_job_ends, dues))
    )

    # ---- 建模 ----
    model = cp_model.CpModel()
    assumption_vars: dict[str, Any] = {}
    assumption_by_index: dict[int, str] = {}
    constraint_instance_counts = {
        constraint_id: 0 for constraint_id in CP_DIAGNOSTIC_RELAXABLE_CONSTRAINTS
    }

    def _assumption(constraint_id: str) -> Any:
        lit = model.NewBoolVar(f"assume_{constraint_id}")
        assumption_vars[constraint_id] = lit
        assumption_by_index[lit.Index()] = constraint_id
        if constraint_id in relaxed:
            model.Add(lit == 0)
        else:
            model.AddAssumption(lit)
        return lit

    def _gated_presence(pres: Any, gate: Any, name: str) -> Any:
        both = model.NewBoolVar(name)
        model.Add(both <= pres)
        model.Add(both <= gate)
        model.Add(both >= pres + gate - 1)
        return both

    def _gated_absence(pres: Any, gate: Any, name: str) -> Any:
        """Return ``pres AND NOT gate`` without relying on negated-literal arithmetic."""
        active = model.NewBoolVar(name)
        model.Add(active <= pres)
        model.Add(active + gate <= 1)
        model.Add(active >= pres - gate)
        return active

    assume_c1 = _assumption("C1_precedence")
    assume_c2 = _assumption("C2_no_overlap")
    assume_c3 = _assumption("C3_calendar") if calendar_enabled else None
    assume_c7 = _assumption("C7_capacity") if line_capacity_enabled else None
    assume_c10 = _assumption("C10_changeover") if changeover_enabled else None
    assume_c11 = _assumption("C11_freeze") if freeze_min > 0 else None
    assume_c12_team = _assumption("C12_team") if team_cum_enabled else None
    assume_c12_tooling = _assumption("C12_tooling") if tooling_cum_enabled else None
    intervals_by_ws: dict[int, list[dict[str, Any]]] = {}
    line_ops: dict[int, list[dict[str, Any]]] = {}
    cum_ivs: dict[tuple[str, int], list[dict[str, Any]]] = {}  # (kind,id) -> 工序区间
    unwired: dict[tuple[str, int], int] = {}                   # (kind,id) -> 引用次数
    job_start: list = []
    job_end: list = []
    chosen_line_vars: list[list] = []
    pres_by_line: list[dict[int, Any]] = []      # [j][lineId] -> pres bool var
    first_start_var: list[dict[int, Any]] = []   # [j][lineId] -> 首工序 start
    first_end_var: list[dict[int, Any]] = []     # [j][lineId] -> 首工序 end
    last_end_var: list[dict[int, Any]] = []      # [j][lineId] -> 末工序 end
    op_start_by_line: list[dict[int, list]] = []  # [j][lineId] -> [start...]
    op_end_by_line: list[dict[int, list]] = []
    op_meta_by_line: list[dict[int, list]] = []
    op_segments_by_line: list[dict[int, list[list[dict[str, Any]]]]] = []
    families: list[str | None] = []
    segment_interval_count = 0

    for j in range(n):
        pres_j: list[Any] = []
        line_ids_j: list[int] = []
        js = model.NewIntVar(0, horizon, f"js{j}")
        je = model.NewIntVar(0, horizon, f"je{j}")
        fsj, fej, lej, plj = {}, {}, {}, {}
        oss, oes, oms, osgs = {}, {}, {}, {}
        for k, opt in enumerate(job_opts[j]):
            pres = model.NewBoolVar(f"j{j}_k{k}")
            pres_j.append(pres)
            lid = int(opt["lineId"])
            line_ids_j.append(lid)
            plj[lid] = pres
            specs = opt["specs"]
            if lid < 0:
                # 哑元：零冲突占位
                st = model.NewIntVar(0, horizon, f"s{j}_{k}")
                en = model.NewIntVar(0, horizon, f"e{j}_{k}")
                model.Add(st == 0).OnlyEnforceIf(pres)
                model.Add(en == specs[0]["dur"]).OnlyEnforceIf(pres)
                fsj[lid], fej[lid], lej[lid] = st, en, en
                oss[lid], oes[lid] = [st], [en]
                osgs[lid] = [[]]
                oms[lid] = [{"sequenceNo": 0, "operationId": None, "workstationId": None,
                             "setupMin": 0, "durMin": specs[0]["dur"], "gapMin": 0}]
            else:
                sts: list[Any] = []
                ens: list[Any] = []
                metas: list[dict] = []
                segment_groups: list[list[dict[str, Any]]] = []
                for s, spec in enumerate(specs):
                    st = model.NewIntVar(0, horizon, f"s{j}_{k}_{s}")
                    en = model.NewIntVar(0, horizon, f"e{j}_{k}_{s}")
                    operation_segments: list[dict[str, Any]] = []
                    if assume_c3 is None:
                        free_mode = pres
                        calendar_mode = None
                    else:
                        free_mode = _gated_absence(
                            pres, assume_c3, f"c3_free_p{j}_{k}_{s}",
                        )
                        calendar_mode = _gated_presence(
                            pres, assume_c3, f"c3_calendar_p{j}_{k}_{s}",
                        )
                        constraint_instance_counts["C3_calendar"] += 1

                    model.Add(en == st + int(spec["dur"])).OnlyEnforceIf(free_mode)
                    operation_segments.append({
                        "mode": "unrestricted", "st": st, "en": en,
                        "size": int(spec["dur"]), "pres": free_mode, "window": None,
                    })

                    if calendar_mode is not None:
                        windows = calendar_windows_by_line.get(lid, [])
                        calendar_segments: list[dict[str, Any]] = []
                        segment_presence_lits: list[Any] = []
                        start_choices: list[Any] = []
                        end_choices: list[Any] = []
                        for window_index, window in enumerate(windows):
                            window_start = int(window["startMin"])
                            window_end = int(window["endMin"])
                            window_size = window_end - window_start
                            seg_pres = model.NewBoolVar(
                                f"c3_seg_p{j}_{k}_{s}_{window_index}"
                            )
                            seg_size = model.NewIntVar(
                                0, window_size, f"c3_seg_size{j}_{k}_{s}_{window_index}"
                            )
                            seg_start = model.NewIntVar(
                                window_start, window_end,
                                f"c3_seg_start{j}_{k}_{s}_{window_index}",
                            )
                            seg_end = model.NewIntVar(
                                window_start, window_end,
                                f"c3_seg_end{j}_{k}_{s}_{window_index}",
                            )
                            model.Add(seg_end == seg_start + seg_size).OnlyEnforceIf(seg_pres)
                            model.Add(seg_pres <= calendar_mode)
                            model.Add(seg_size >= 1).OnlyEnforceIf(seg_pres)
                            model.Add(seg_size == 0).OnlyEnforceIf(seg_pres.Not())
                            model.Add(seg_start == window_start).OnlyEnforceIf(seg_pres.Not())
                            model.Add(seg_end == window_start).OnlyEnforceIf(seg_pres.Not())
                            start_choice = model.NewIntVar(
                                0, horizon, f"c3_start_choice{j}_{k}_{s}_{window_index}"
                            )
                            end_choice = model.NewIntVar(
                                0, horizon, f"c3_end_choice{j}_{k}_{s}_{window_index}"
                            )
                            model.Add(start_choice == seg_start).OnlyEnforceIf(seg_pres)
                            model.Add(start_choice == horizon).OnlyEnforceIf(seg_pres.Not())
                            model.Add(end_choice == seg_end).OnlyEnforceIf(seg_pres)
                            model.Add(end_choice == 0).OnlyEnforceIf(seg_pres.Not())
                            segment_presence_lits.append(seg_pres)
                            start_choices.append(start_choice)
                            end_choices.append(end_choice)
                            record = {
                                "mode": "calendar", "st": seg_start, "en": seg_end,
                                "size": seg_size, "pres": seg_pres,
                                "window": window,
                            }
                            calendar_segments.append(record)
                            operation_segments.append(record)
                            segment_interval_count += 1
                        if calendar_segments:
                            # 0* 1* 0*：只允许连续选取有效窗口；中间段必须吃满窗口。
                            model.AddAutomaton(
                                segment_presence_lits,
                                0,
                                [0, 1, 2],
                                [(0, 0, 0), (0, 1, 1), (1, 1, 1),
                                 (1, 0, 2), (2, 0, 2)],
                            )
                            calendar_start = model.NewIntVar(
                                0, horizon, f"c3_calendar_start{j}_{k}_{s}"
                            )
                            calendar_end = model.NewIntVar(
                                0, horizon, f"c3_calendar_end{j}_{k}_{s}"
                            )
                            model.AddMinEquality(calendar_start, start_choices)
                            model.AddMaxEquality(calendar_end, end_choices)
                            model.Add(st == calendar_start).OnlyEnforceIf(calendar_mode)
                            model.Add(en == calendar_end).OnlyEnforceIf(calendar_mode)
                            for window_index in range(1, len(calendar_segments)):
                                previous = calendar_segments[window_index - 1]
                                current = calendar_segments[window_index]
                                model.Add(
                                    previous["en"] == int(previous["window"]["endMin"])
                                ).OnlyEnforceIf([previous["pres"], current["pres"]])
                                model.Add(
                                    current["st"] == int(current["window"]["startMin"])
                                ).OnlyEnforceIf([previous["pres"], current["pres"]])
                        else:
                            model.Add(calendar_mode == 0)
                        model.Add(
                            sum(segment["size"] for segment in calendar_segments)
                            == int(spec["dur"]) * calendar_mode
                        )

                    hint_allocation = hint_segments_by_operation.get((j, lid, s))
                    selected_hint = hint_line_by_job.get(j) == lid and hint_allocation is not None
                    if assume_c3 is not None:
                        if selected_hint:
                            model.AddHint(free_mode, 1 if "C3_calendar" in relaxed else 0)
                            model.AddHint(calendar_mode, 0 if "C3_calendar" in relaxed else 1)
                        elif hint_line_by_job.get(j) != lid:
                            model.AddHint(free_mode, 0)
                            model.AddHint(calendar_mode, 0)
                    if selected_hint:
                        hint_start = int(hint_allocation[0]["startMin"])
                        model.AddHint(st, hint_start)
                        model.AddHint(
                            en,
                            hint_start + int(spec["dur"])
                            if "C3_calendar" in relaxed
                            else int(hint_allocation[-1]["endMin"]),
                        )
                    hinted_by_window = {
                        str(segment["windowId"]): segment
                        for segment in (
                            [] if "C3_calendar" in relaxed else (hint_allocation or [])
                        )
                    }
                    for segment in operation_segments:
                        if segment["mode"] != "calendar":
                            continue
                        hint_segment = hinted_by_window.get(str(segment["window"]["windowId"]))
                        model.AddHint(segment["pres"], 1 if hint_segment is not None else 0)
                        if hint_segment is not None:
                            model.AddHint(segment["size"], int(hint_segment["durationMin"]))
                            model.AddHint(segment["st"], int(hint_segment["startMin"]))
                            model.AddHint(segment["en"], int(hint_segment["endMin"]))

                    for segment_index, segment in enumerate(operation_segments):
                        c2_pres = _gated_presence(
                            segment["pres"], assume_c2,
                            f"c2p{j}_{k}_{s}_{segment_index}",
                        )
                        c2_iv = model.NewOptionalIntervalVar(
                            segment["st"], segment["size"], segment["en"], c2_pres,
                            f"c2iv{j}_{k}_{s}_{segment_index}",
                        )
                        intervals_by_ws.setdefault(spec["workstationId"], []).append({
                            "iv": c2_iv,
                            "logicalKey": ("operation", j, lid, s),
                        })
                    if s > 0:
                        # C1 工艺先后序：前道完成 + 转移/等待 才能开下一道
                        model.Add(st >= ens[s - 1] + specs[s - 1]["gap"]).OnlyEnforceIf(
                            [pres, assume_c1])
                        constraint_instance_counts["C1_precedence"] += 1
                    sts.append(st)
                    ens.append(en)
                    metas.append({
                        "routingStepId": spec["routingStepId"],
                        "sequenceNo": int(spec["step"]["sequenceNo"]),
                        "operationId": spec["operationId"],
                        "workstationId": spec["workstationId"],
                        "teamId": spec.get("teamId"),
                        "toolingId": spec.get("toolingId"),
                        "setupMin": spec["setupMin"],
                        "durMin": spec["dur"],
                        "gapMin": spec["gap"],
                    })
                    line_ops.setdefault(lid, []).append({
                        "st": st, "en": en, "pres": pres, "dur": int(spec["dur"]),
                        "j": j, "operationId": spec["operationId"],
                    })
                    # C12 Cumulative 聚合容量：班组/工装共享容量，并行占用总和 ≤ 可用容量
                    if team_cum_enabled:
                        _tid = spec.get("teamId")
                        if _tid is not None:
                            _tid = int(_tid)
                            if _tid in team_caps:
                                for segment_index, segment in enumerate(operation_segments):
                                    team_pres = _gated_presence(
                                        segment["pres"], assume_c12_team,
                                        f"team_p{j}_{k}_{s}_{segment_index}",
                                    )
                                    team_iv = model.NewOptionalIntervalVar(
                                        segment["st"], segment["size"], segment["en"],
                                        team_pres, f"team_iv{j}_{k}_{s}_{segment_index}",
                                    )
                                    cum_ivs.setdefault(("team", _tid), []).append({
                                        "iv": team_iv, "st": segment["st"],
                                        "en": segment["en"], "pres": team_pres,
                                        "j": j, "op": spec["operationId"],
                                    })
                            else:
                                unwired[("team", _tid)] = unwired.get(("team", _tid), 0) + 1
                    if tooling_cum_enabled:
                        _toid = spec.get("toolingId")
                        if _toid is not None:
                            _toid = int(_toid)
                            if _toid in tooling_caps:
                                for segment_index, segment in enumerate(operation_segments):
                                    tooling_pres = _gated_presence(
                                        segment["pres"], assume_c12_tooling,
                                        f"tool_p{j}_{k}_{s}_{segment_index}",
                                    )
                                    tooling_iv = model.NewOptionalIntervalVar(
                                        segment["st"], segment["size"], segment["en"],
                                        tooling_pres, f"tool_iv{j}_{k}_{s}_{segment_index}",
                                    )
                                    cum_ivs.setdefault(("tooling", _toid), []).append({
                                        "iv": tooling_iv, "st": segment["st"],
                                        "en": segment["en"], "pres": tooling_pres,
                                        "j": j, "op": spec["operationId"],
                                    })
                            else:
                                unwired[("tooling", _toid)] = unwired.get(("tooling", _toid), 0) + 1
                    segment_groups.append(operation_segments)
                fsj[lid], fej[lid], lej[lid] = sts[0], ens[0], ens[-1]
                oss[lid], oes[lid], oms[lid], osgs[lid] = sts, ens, metas, segment_groups
            model.Add(js == fsj[lid]).OnlyEnforceIf(pres)
            model.Add(je == lej[lid]).OnlyEnforceIf(pres)
            if j in hint_line_by_job:
                model.AddHint(pres, 1 if hint_line_by_job.get(j) == lid else 0)
        model.Add(sum(pres_j) == 1)
        job_start.append(js)
        job_end.append(je)
        chosen_line_vars.append(list(zip(pres_j, line_ids_j)))
        pres_by_line.append(plj)
        first_start_var.append(fsj)
        first_end_var.append(fej)
        last_end_var.append(lej)
        op_start_by_line.append(oss)
        op_end_by_line.append(oes)
        op_meta_by_line.append(oms)
        op_segments_by_line.append(osgs)
        families.append(job_opts[j][0]["family"])

    # ---- C11 冻结窗：新排订单首工序不得早于冻结窗末端 ----
    if freeze_min > 0:
        for j in range(n):
            for lid in pres_by_line[j]:
                if lid >= 0:
                    model.Add(first_start_var[j][lid] >= freeze_min).OnlyEnforceIf(
                        [pres_by_line[j][lid], assume_c11])
                    constraint_instance_counts["C11_freeze"] += 1

    # ---- C12 Cumulative 聚合容量：班组/工装并行占用总和 ≤ 可用容量 ----
    cum_res: list[dict[str, Any]] = []
    cum_res_by_key: dict[tuple[str, int], dict[str, Any]] = {}
    for (kind, rid), ivs in cum_ivs.items():
        cap = team_caps[rid] if kind == "team" else tooling_caps[rid]
        logical_interval_count = len({(int(x["j"]), x["op"]) for x in ivs})
        if logical_interval_count >= 2:
            # 可选区间未排中（pres=0）不消耗资源；demand=1（每工序占用 1 单位）
            model.AddCumulative([x["iv"] for x in ivs], [1] * len(ivs), cap)
            constraint_instance_counts[
                "C12_team" if kind == "team" else "C12_tooling"
            ] += 1
        entry = {
            "kind": kind, "id": rid, "code": _resource_code(world, kind, rid),
            "capacity": cap, "intervalCount": logical_interval_count,
            "modelIntervalCount": len(ivs), "peakConcurrent": None,
        }
        cum_res.append(entry)
        cum_res_by_key[(kind, rid)] = entry
    if normalized_rhs is not None and rhs_parameter_id in {
        "C12_team_capacity", "C12_tooling_capacity",
    }:
        kind = "team" if rhs_parameter_id == "C12_team_capacity" else "tooling"
        resource_id = int(normalized_rhs["resourceId"])
        if len({
            (int(x["j"]), x["op"]) for x in cum_ivs.get((kind, resource_id), [])
        }) < 2:
            raise ValueError(
                f"资源 {kind}:{resource_id} 本次模型没有可增量的 Cumulative capacity 实例"
            )
    meta["cumulative"] = {
        "enabled": {"team": team_cum_enabled, "tooling": tooling_cum_enabled},
        "capacity": {"team": dict(team_caps), "tooling": dict(tooling_caps)},
        "resources": cum_res,
        "unwired": [{"kind": k, "id": i} for (k, i) in sorted(unwired)],
    }

    # ---- C11 冻结窗：窗内已排工单固定为障碍 ----
    for frozen_index, obs in enumerate(frozen):
        frozen_presence = _gated_presence(
            assume_c11, assume_c2, f"frozen_p_{frozen_index}",
        )
        fiv = model.NewOptionalFixedSizeIntervalVar(
            obs["startMin"], obs["durationMin"], frozen_presence, f"frozen_{obs['orderNo']}")
        intervals_by_ws.setdefault(obs["workstationId"], []).append({
            "iv": fiv,
            "logicalKey": ("frozen", frozen_index),
        })
        constraint_instance_counts["C11_freeze"] += 1
    active_frozen = (
        [] if relaxed & {"C2_no_overlap", "C11_freeze"} else frozen
    )
    for intervals in intervals_by_ws.values():
        logical_interval_count = len({row["logicalKey"] for row in intervals})
        if logical_interval_count >= 2:
            model.AddNoOverlap([row["iv"] for row in intervals])
            constraint_instance_counts["C2_no_overlap"] += 1

    # ---- C10 换型矩阵：产线工序序列 next-link 路径，相邻订单首工序间计入 setup ----
    next_vars_by_line: dict[int, dict[tuple[int, int], Any]] = {}
    changeover_loads: dict[int, list[dict[str, Any]]] = {}
    candidates_by_line: dict[int, list[int]] = {}
    for j in range(n):
        for lid in pres_by_line[j]:
            if lid >= 0:
                candidates_by_line.setdefault(lid, []).append(j)
    if changeover_enabled:
        for lid, j_list in candidates_by_line.items():
            if len(j_list) < 2:
                continue
            next_bools: dict[tuple[int, int], Any] = {}
            for a in j_list:
                for b in j_list:
                    if a != b:
                        next_bools[(a, b)] = model.NewBoolVar(f"next_{a}_{b}_l{lid}")
            next_vars_by_line[lid] = next_bools
            first_bools = {j: model.NewBoolVar(f"first_{j}_l{lid}") for j in j_list}
            any_on_line = model.NewBoolVar(f"any_l{lid}")
            model.AddMaxEquality(any_on_line, [pres_by_line[j][lid] for j in j_list])
            for j in j_list:
                pres = pres_by_line[j][lid]
                incoming = sum(next_bools[(a, j)] for a in j_list if a != j)
                outgoing = sum(next_bools[(j, b)] for b in j_list if b != j)
                # 每个在线上订单恰有一个前驱（含"首个"）
                model.Add(first_bools[j] + incoming == 1).OnlyEnforceIf(pres)
                model.Add(first_bools[j] + incoming == 0).OnlyEnforceIf(pres.Not())
                # 至多一个后继（单链路径）
                model.Add(outgoing <= 1).OnlyEnforceIf(pres)
                model.Add(outgoing == 0).OnlyEnforceIf(pres.Not())
            # 单链：整条线至多一个"首个"
            model.Add(sum(first_bools.values()) == any_on_line)
            # 换型时间：相邻首工序 start >= 前序首工序 end + setup(from→to)
            for (a, b), nv in next_bools.items():
                setup = _changeover_setup_min(world, families[a], families[b])
                if setup <= 0:
                    continue
                model.Add(
                    first_start_var[b][lid] >= first_end_var[a][lid] + setup
                ).OnlyEnforceIf([nv, assume_c10])
                constraint_instance_counts["C10_changeover"] += 1
                changeover_loads.setdefault(lid, []).append({
                    "st": first_start_var[b][lid],
                    "pres": _gated_presence(nv, assume_c10, f"c10_load_{a}_{b}_l{lid}"),
                    "dur": setup,
                    "kind": "changeover",
                })

    # ---- C7 产线/自然日容量：完整工时记入开工日，与 Rule 物化后检查同口径 ----
    line_day_resources: list[dict[str, Any]] = []
    line_day_assignments: dict[tuple[int, str], list[dict[str, Any]]] = {}
    fixed_line_day_loads = _frozen_line_day_loads(world)
    if line_capacity_enabled:
        buckets = _line_day_buckets(world, set(line_ops), anchor, horizon)
        buckets_by_line: dict[int, list[dict[str, Any]]] = {}
        for bucket in buckets:
            buckets_by_line.setdefault(int(bucket["lineId"]), []).append(bucket)
        all_loads = {
            line_id: [
                *({**term, "kind": "operation"} for term in line_ops.get(line_id, [])),
                *changeover_loads.get(line_id, []),
            ]
            for line_id in line_ops
        }
        for line_id, terms in all_loads.items():
            line_buckets = buckets_by_line.get(line_id, [])
            for term_index, term in enumerate(terms):
                active = _gated_presence(
                    term["pres"], assume_c7, f"c7_active_{line_id}_{term_index}",
                )
                day_lits: list[Any] = []
                for day_index, bucket in enumerate(line_buckets):
                    lit = model.NewBoolVar(f"c7_day_{line_id}_{term_index}_{day_index}")
                    model.Add(lit <= active)
                    model.Add(term["st"] >= int(bucket["bucketStartMin"])).OnlyEnforceIf(lit)
                    model.Add(term["st"] < int(bucket["bucketEndMin"])).OnlyEnforceIf(lit)
                    day_lits.append(lit)
                    line_day_assignments.setdefault(
                        (line_id, str(bucket["bucketDate"])), []
                    ).append({"lit": lit, "dur": int(term["dur"]), "kind": term["kind"]})
                model.Add(sum(day_lits) == active)
        for resource in buckets:
            key = (int(resource["lineId"]), str(resource["bucketDate"]))
            assignments = line_day_assignments.get(key, [])
            capacity = int(resource["baseCapacityMinutes"])
            if (
                rhs_parameter_id == "C7_line_day_capacity_minutes"
                and int(normalized_rhs["lineId"]) == key[0]
                and str(normalized_rhs["bucketDate"]) == key[1]
            ):
                capacity += int(normalized_rhs["increment"])
            model.Add(
                sum(item["dur"] * item["lit"] for item in assignments)
                + fixed_line_day_loads.get(key, 0)
                <= capacity
            ).OnlyEnforceIf(assume_c7)
            constraint_instance_counts["C7_capacity"] += 1
            line_day_resources.append({
                **resource,
                "capacityMinutes": capacity,
                "candidateLoadTermCount": len(assignments),
                "changeoverTermCount": sum(
                    1 for item in assignments if item["kind"] == "changeover"
                ),
                "fixedFrozenLoadMinutes": fixed_line_day_loads.get(key, 0),
                "usedMinutes": None,
                "assignedLoadTermCount": None,
            })
        if rhs_parameter_id == "C7_line_day_capacity_minutes" and not any(
            int(row["lineId"]) == int(normalized_rhs["lineId"])
            and row["bucketDate"] == normalized_rhs["bucketDate"]
            and int(row["candidateLoadTermCount"]) > 0
            and int(row["baseCapacityMinutes"]) > 0
            for row in line_day_resources
        ):
            raise ValueError("目标 line/day 本次模型没有可增量的工作日 C7 capacity 实例")
    meta["lineDailyCapacity"] = {
        "enabled": line_capacity_enabled,
        "accountingMethod": "start-day-full-duration.v1",
        "capacitySource": "shift-calendar-effective-minutes",
        "loadScope": "routing-setup+run+sequence-changeover",
        "efficiencyAppliedAt": "operation-duration",
        "isMaterializedShiftModel": False,
        "resources": line_day_resources,
    }
    calendar_dates = sorted({str(bucket["bucketDate"]) for bucket in calendar_buckets})
    meta["c3Calendar"] = {
        "schemaVersion": "cp-calendar-segmented.v1",
        "active": bool(calendar_enabled and "C3_calendar" not in relaxed),
        "modelMode": "assumption-gated-dual-mode" if calendar_enabled else "unrestricted",
        "pausePolicy": "calendar-boundary-only",
        "calendarMode": "calendar-boundary-only",
        "selectedMode": (
            "continuous" if "C3_calendar" in relaxed else "calendar-boundary-only"
        ),
        "timezone": "factory-local-naive",
        "anchor": anchor.strftime("%Y-%m-%d %H:%M"),
        "horizonMinutes": horizon,
        "coverageStart": calendar_dates[0] if calendar_dates else None,
        "coverageEnd": calendar_dates[-1] if calendar_dates else None,
        "coverageComplete": bool(calendar_enabled and calendar_dates),
        "normalizedCalendarDigest": calendar_digest,
        "calendarBucketCount": len(calendar_buckets),
        "lineWindowCounts": {
            str(line_id): len(windows)
            for line_id, windows in sorted(calendar_windows_by_line.items())
        },
        "segmentIntervalCount": segment_interval_count,
        "segmentIntervalLimit": 50_000,
        "modelSegmentCount": segment_interval_count,
        "modelSegmentLimit": 50_000,
        "maxSegmentsPerOperation": max(
            (len(windows) for windows in calendar_windows_by_line.values()), default=0,
        ),
        "directlyConsumedByMaterializer": False,
    }

    inactive_relaxed = {
        constraint_id for constraint_id in relaxed
        if constraint_instance_counts.get(constraint_id, 0) <= 0
    }
    if inactive_relaxed:
        raise ValueError(f"本次模型没有可松弛的约束实例：{sorted(inactive_relaxed)}")

    # 加权延期
    obj_terms = []
    for j in range(n):
        late = model.NewIntVar(0, horizon, f"late{j}")
        model.Add(late >= job_end[j] - dues[j])
        model.Add(late >= 0)
        obj_terms.append(late * weights[j])
    model.Minimize(sum(obj_terms))

    # RULE 热启动：仅 hint 选线（不 hint 起止，避免部分版本 fixed_search 崩溃）
    if warm_start and len(warm_start) == n and not calendar_enabled:
        for j, hint in enumerate(warm_start):
            want = int(hint.get("lineId", -1))
            for pres, lid in chosen_line_vars[j]:
                model.AddHint(pres, 1 if lid == want else 0)

    solver = cp_model.CpSolver()
    limit = float(params.timeLimitSeconds) if params.timeLimitSeconds is not None else 8.0
    solver.parameters.max_time_in_seconds = max(0.5, limit)
    # 有 hint 时单线程更稳（部分 ortools 在多 worker + hint 下会 check-fail）
    solver.parameters.num_search_workers = 1 if (warm_start or diagnostic_mode) else 4
    if calendar_enabled:
        solver.parameters.repair_hint = True
        solver.parameters.hint_conflict_limit = 2_000
        solver.parameters.cp_model_probing_level = 0
    if diagnostic_mode:
        solver.parameters.random_seed = 0
    status = solver.Solve(model)
    primary_wall = float(solver.WallTime())
    primary_best_bound = float(solver.BestObjectiveBound())
    fallback_wall = 0.0
    feasible_hint_fallback = False
    feasible_hint_fallback_status: str | None = None
    best_bound_override: float | None = None
    if (
        status == cp_model.UNKNOWN
        and hint_complete
        and hint_resources_feasible
        and calendar_enabled
    ):
        fallback_solver = cp_model.CpSolver()
        fallback_limit = 2.0
        fallback_solver.parameters.max_time_in_seconds = fallback_limit
        fallback_solver.parameters.num_search_workers = 1
        fallback_solver.parameters.random_seed = 0
        fallback_solver.parameters.cp_model_probing_level = 0
        fallback_solver.parameters.cp_model_presolve = False
        fallback_solver.parameters.fix_variables_to_their_hinted_value = True
        fallback_status = fallback_solver.Solve(model)
        feasible_hint_fallback_status = {
            cp_model.OPTIMAL: "OPTIMAL",
            cp_model.FEASIBLE: "FEASIBLE",
            cp_model.INFEASIBLE: "INFEASIBLE",
            cp_model.MODEL_INVALID: "MODEL_INVALID",
            cp_model.UNKNOWN: "UNKNOWN",
        }.get(fallback_status, str(fallback_status))
        fallback_wall = float(fallback_solver.WallTime())
        if fallback_status in (cp_model.OPTIMAL, cp_model.FEASIBLE):
            solver = fallback_solver
            status = cp_model.FEASIBLE
            feasible_hint_fallback = True
            best_bound_override = primary_best_bound

    status_name = {
        cp_model.OPTIMAL: "OPTIMAL",
        cp_model.FEASIBLE: "FEASIBLE",
        cp_model.INFEASIBLE: "INFEASIBLE",
        cp_model.MODEL_INVALID: "MODEL_INVALID",
        cp_model.UNKNOWN: "UNKNOWN",
    }.get(status, str(status))

    wall = round(primary_wall + fallback_wall, 4)
    meta["status"] = status_name
    meta["wallTimeSec"] = wall
    meta["timeLimitSec"] = limit
    meta["primaryWallTimeSec"] = round(primary_wall, 4)
    meta["feasibleHintFallback"] = feasible_hint_fallback
    meta["feasibleHintFallbackStatus"] = feasible_hint_fallback_status
    meta["feasibleHintFallbackWallTimeSec"] = round(fallback_wall, 4)
    meta["frozenCount"] = len(active_frozen)
    meta["detectedFrozenCount"] = len(frozen)
    meta["assumptionConstraints"] = sorted(assumption_vars)
    meta["enforcedAssumptionConstraints"] = sorted(set(assumption_vars) - relaxed)
    meta["relaxedConstraintIds"] = sorted(relaxed)
    meta["constraintInstanceCounts"] = {
        key: constraint_instance_counts[key] for key in sorted(constraint_instance_counts)
    }
    meta["activeAssumptionConstraints"] = sorted(
        key for key, count in constraint_instance_counts.items() if count > 0
    )
    meta["diagnosticMode"] = bool(diagnostic_mode)
    meta["rhsDiagnosticMode"] = bool(rhs_diagnostic_mode)
    meta["rhsPerturbation"] = normalized_rhs
    meta["rhsParameterState"] = {
        "dueDateAllowanceMinutes": due_allowance_min,
        "dueDateEntryCount": n,
        "lineDailyCapacities": [
            {
                key: row[key]
                for key in (
                    "lineId", "lineCode", "bucketDate", "bucketStartMin", "bucketEndMin",
                    "baseCapacityMinutes", "capacityMinutes", "candidateLoadTermCount",
                    "changeoverTermCount", "fixedFrozenLoadMinutes",
                    "shiftIds", "shiftCalendarRowIds",
                )
            }
            for row in line_day_resources
        ],
        "teamCapacities": [
            {
                "resourceId": resource_id,
                "capacity": capacity,
                "intervalCount": len({
                    (int(x["j"]), x["op"])
                    for x in cum_ivs.get(("team", resource_id), [])
                }),
            }
            for resource_id, capacity in sorted(team_caps.items())
        ],
        "toolingCapacities": [
            {
                "resourceId": resource_id,
                "capacity": capacity,
                "intervalCount": len({
                    (int(x["j"]), x["op"])
                    for x in cum_ivs.get(("tooling", resource_id), [])
                }),
            }
            for resource_id, capacity in sorted(tooling_caps.items())
        ],
    }
    meta["numSearchWorkers"] = int(solver.parameters.num_search_workers)
    meta["randomSeed"] = int(solver.parameters.random_seed)
    meta["zeroObjectiveHintCandidate"] = zero_objective_feasible_hint
    meta["zeroObjectiveHintFixed"] = False
    meta["calendarHintComplete"] = hint_complete
    meta["calendarHintResourcesFeasible"] = hint_resources_feasible
    meta["calendarHintMissingOperations"] = hint_missing_operations[:20]

    if status == cp_model.INFEASIBLE:
        raw_core = list(solver.SufficientAssumptionsForInfeasibility())
        core_ids = []
        for raw_literal in raw_core:
            index = int(raw_literal)
            if index < 0:
                index = -index - 1
            constraint_id = assumption_by_index.get(index)
            if constraint_id and constraint_id not in core_ids:
                core_ids.append(constraint_id)
        meta["nativeIis"] = {
            "schemaVersion": "cp-sat-native-core.v1",
            "method": "SufficientAssumptionsForInfeasibility",
            "native": True,
            "constraintIds": core_ids,
            "literalCount": len(raw_core),
            "minimality": "sufficient-assumption-core",
            "isMinimalIis": False,
        }

    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
        # gap=None 语义：仅可行性（UNKNOWN/INFEASIBLE）时无 objective/bound，
        # 无法计算 obj-vs-bound gap，诚实置 None 并保留启发式序（fallback）
        meta["gap"] = None
        meta["objective"] = None
        meta["fallback"] = "heuristic-order"
        # 诚实：无可行解时保留启发式序；若有 warm_start 则带上强制线
        if warm_start and len(warm_start) == n:
            out = []
            for entry, hint in zip(entries, warm_start):
                e = dict(entry)
                if int(hint.get("lineId", -1)) >= 0:
                    e["forcedLineId"] = int(hint["lineId"])
                out.append(e)
            return out, meta
        return entries, meta

    obj = float(solver.ObjectiveValue())
    bound = (
        best_bound_override
        if best_bound_override is not None
        else float(solver.BestObjectiveBound())
    )
    meta["objective"] = obj
    meta["bestBound"] = bound
    if obj > 1e-9:
        meta["gap"] = round(abs(obj - bound) / abs(obj), 6)
    else:
        meta["gap"] = 0.0

    # ---- 读解：选线 + 工序槽位 + 换型来源 + 按首工序开始排序 ----
    slots: list[dict] = []
    total_changeover = 0.0
    enriched: list[tuple[float, int, dict]] = []
    for j, entry in enumerate(entries):
        so, item = entry["so"], entry["item"]
        lid = None
        for pres, lid_c in chosen_line_vars[j]:
            if solver.Value(pres) == 1:
                lid = lid_c if lid_c >= 0 else None
                break
        e = dict(entry)
        if lid is not None:
            e["forcedLineId"] = lid
        # 换型前序（next-link 链上的直接前驱）
        pred_family: str | None = None
        if lid is not None and changeover_enabled and lid in next_vars_by_line:
            for (a, b), nv in next_vars_by_line[lid].items():
                if b == j and solver.Value(nv) == 1:
                    pred_family = families[a]
                    break
        chg = _changeover_setup_min(world, pred_family, families[j]) if lid is not None else 0
        if chg > 0:
            total_changeover += chg
        if lid is None:
            js_val = int(solver.Value(job_start[j]))
            je_val = int(solver.Value(job_end[j]))
            processing = max(1, je_val - js_val)
            slots.append({
                "schemaVersion": "cp-operation-slot.v1",
                "orderIndex": j, "orderNo": so["orderNo"], "productId": item["productId"],
                "salesOrderId": so["id"], "salesOrderItemId": item["id"],
                "routingStepId": None,
                "logicalOperationKey": f"{so['id']}:{item['id']}:dummy",
                "lineId": None, "sequenceNo": 0, "operationId": None, "workstationId": None,
                "teamId": None, "toolingId": None,
                "startMin": js_val, "endMin": je_val, "durationMin": processing,
                "processingMinutes": processing, "elapsedSpanMinutes": processing,
                "pauseMinutes": 0, "segmentCount": 1, "calendarCompliant": None,
                "calendarMode": "unrestricted",
                "segments": [{
                    "startMin": js_val, "endMin": je_val, "durationMin": processing,
                    "calendarWindowId": None, "bucketDate": None, "shiftId": None,
                }],
                "setupMin": 0, "changeoverMin": 0, "isFrozen": False,
            })
            enriched.append((float(js_val), j, e))
            continue
        for s, meta_s in enumerate(op_meta_by_line[j][lid]):
            st_v = int(solver.Value(op_start_by_line[j][lid][s]))
            en_v = int(solver.Value(op_end_by_line[j][lid][s]))
            solved_segments: list[dict[str, Any]] = []
            solved_mode = "continuous"
            for segment in op_segments_by_line[j][lid][s]:
                if int(solver.Value(segment["pres"])) != 1:
                    continue
                segment_start = int(solver.Value(segment["st"]))
                segment_end = int(solver.Value(segment["en"]))
                segment_size = (
                    int(segment["size"])
                    if isinstance(segment["size"], int)
                    else int(solver.Value(segment["size"]))
                )
                window = segment.get("window")
                if segment["mode"] == "calendar":
                    solved_mode = "calendar-boundary-only"
                solved_segments.append({
                    "startMin": segment_start,
                    "endMin": segment_end,
                    "durationMin": segment_size,
                    "calendarWindowId": window.get("windowId") if window else None,
                    "bucketDate": window.get("bucketDate") if window else None,
                    "shiftId": window.get("shiftId") if window else None,
                })
            solved_segments.sort(key=lambda row: (int(row["startMin"]), int(row["endMin"])))
            processing = sum(int(row["durationMin"]) for row in solved_segments)
            elapsed = max(0, en_v - st_v)
            line_windows = calendar_windows_by_line.get(lid, [])
            calendar_compliant = all(
                any(
                    int(row["startMin"]) >= int(window["startMin"])
                    and int(row["endMin"]) <= int(window["endMin"])
                    for window in line_windows
                )
                for row in solved_segments
            ) if calendar_enabled else None
            slots.append({
                "schemaVersion": "cp-operation-slot.v1",
                "orderIndex": j, "orderNo": so["orderNo"], "productId": item["productId"],
                "salesOrderId": so["id"], "salesOrderItemId": item["id"],
                "routingStepId": meta_s["routingStepId"],
                "logicalOperationKey": f"{so['id']}:{item['id']}:{meta_s['routingStepId']}",
                "lineId": lid, "sequenceNo": meta_s["sequenceNo"],
                "operationId": meta_s["operationId"], "workstationId": meta_s["workstationId"],
                "teamId": meta_s.get("teamId"), "toolingId": meta_s.get("toolingId"),
                "startMin": st_v, "endMin": en_v, "durationMin": processing,
                "processingMinutes": processing, "elapsedSpanMinutes": elapsed,
                "pauseMinutes": max(0, elapsed - processing),
                "segmentCount": len(solved_segments), "segments": solved_segments,
                "calendarCompliant": calendar_compliant, "calendarMode": solved_mode,
                "setupMin": meta_s["setupMin"],
                "changeoverMin": chg if s == 0 else 0,
                "isFrozen": False,
            })
        enriched.append((float(solver.Value(job_start[j])), j, e))
    for obs in active_frozen:
        frozen_compliant = any(
            int(obs["startMin"]) >= int(window["startMin"])
            and int(obs["endMin"]) <= int(window["endMin"])
            for window in calendar_windows_by_line.get(int(obs["lineId"]), [])
        ) if calendar_enabled and obs.get("lineId") is not None else None
        slots.append({
            "schemaVersion": "cp-operation-slot.v1",
            "orderIndex": -1, "orderNo": obs["orderNo"], "productId": None,
            "salesOrderId": None, "salesOrderItemId": None, "routingStepId": None,
            "logicalOperationKey": f"frozen:{obs['sourceWorkOrderId']}",
            "sourceWorkOrderId": obs["sourceWorkOrderId"],
            "sourceSchedulingVersionId": obs.get("sourceSchedulingVersionId"),
            "lineId": obs["lineId"], "sequenceNo": 0, "operationId": None,
            "workstationId": obs["workstationId"],
            "teamId": None, "toolingId": None,
            "startMin": obs["startMin"], "endMin": obs["endMin"],
            "durationMin": obs["durationMin"], "setupMin": 0, "changeoverMin": 0,
            "processingMinutes": obs["durationMin"],
            "elapsedSpanMinutes": obs["durationMin"], "pauseMinutes": 0,
            "segmentCount": 1, "calendarCompliant": frozen_compliant,
            "calendarMode": "fixed-existing",
            "segments": [{
                "startMin": obs["startMin"], "endMin": obs["endMin"],
                "durationMin": obs["durationMin"], "calendarWindowId": None,
                "bucketDate": None, "shiftId": None,
            }],
            "isFrozen": True,
        })
    for (kind, rid), ivs in cum_ivs.items():
        present = []
        for x in ivs:
            if solver.Value(x["pres"]) == 1:
                present.append((int(solver.Value(x["st"])), int(solver.Value(x["en"]))))
        entry = cum_res_by_key.get((kind, rid))
        if entry is not None:
            entry["peakConcurrent"] = _peak_overlap(present)
    for resource in line_day_resources:
        assignments = line_day_assignments.get(
            (int(resource["lineId"]), str(resource["bucketDate"])), []
        )
        resource["usedMinutes"] = sum(
            int(item["dur"]) * int(solver.Value(item["lit"])) for item in assignments
        ) + int(resource["fixedFrozenLoadMinutes"])
        resource["assignedLoadTermCount"] = sum(
            1 for item in assignments if int(solver.Value(item["lit"])) > 0
        )
    meta["operationSlots"] = slots
    meta["totalChangeoverMin"] = round(total_changeover, 1)
    solved_operation_slots = [slot for slot in slots if not slot.get("isFrozen")]
    meta["c3Calendar"].update({
        "selectedSegmentCount": sum(int(slot.get("segmentCount") or 0) for slot in solved_operation_slots),
        "maxSelectedSegmentsPerOperation": max(
            (int(slot.get("segmentCount") or 0) for slot in solved_operation_slots), default=0,
        ),
        "totalPauseMinutes": sum(int(slot.get("pauseMinutes") or 0) for slot in solved_operation_slots),
        "calendarCompliantOperationCount": sum(
            1 for slot in solved_operation_slots if slot.get("calendarCompliant") is True
        ),
        "calendarCompliant": all(
            slot.get("calendarCompliant") is True for slot in solved_operation_slots
        ),
    })

    enriched.sort(key=lambda t: (t[0], t[1]))
    return [e for _, _, e in enriched], meta


def _calendar_topology(
    world: World,
    line_ids: set[int],
    anchor,
    horizon: int,
) -> tuple[str, dict[str, dict[str, Any]]]:
    buckets = _line_day_buckets(world, line_ids, anchor, horizon)
    windows_by_line: dict[int, list[dict[str, Any]]] = {}
    windows_by_id: dict[str, dict[str, Any]] = {}
    for bucket in buckets:
        line_id = int(bucket["lineId"])
        for window_index, window in enumerate(bucket.get("effectiveWindows") or []):
            window_id = (
                f"line-window:{line_id}:{bucket['bucketDate']}:"
                f"{int(window['shiftId'])}:{window_index}"
            )
            normalized = {
                "windowId": window_id,
                "bucketDate": str(bucket["bucketDate"]),
                "shiftId": int(window["shiftId"]),
                "startMin": int(window["startMin"]),
                "endMin": int(window["endMin"]),
                "lineId": line_id,
            }
            windows_by_line.setdefault(line_id, []).append(normalized)
            windows_by_id[window_id] = normalized
    for windows in windows_by_line.values():
        windows.sort(key=lambda row: (int(row["startMin"]), int(row["endMin"])))
    payload = [
        {
            "lineId": line_id,
            "windows": [
                {
                    key: window[key]
                    for key in ("windowId", "bucketDate", "shiftId", "startMin", "endMin")
                }
                for window in windows
            ],
        }
        for line_id, windows in sorted(windows_by_line.items())
    ]
    digest = hashlib.sha256(json.dumps(
        payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"),
    ).encode("utf-8")).hexdigest()
    return digest, windows_by_id


def _prepare_cp_operation_timing(
    world: World,
    expected_entries: list[dict],
    ordered: list[dict],
    solver_meta: dict[str, Any],
) -> list[dict]:
    """Revalidate and bind feasible CP slots before Rule writes any business artifacts."""

    status = solver_meta.get("status")
    if status not in {"OPTIMAL", "FEASIBLE"}:
        solver_meta["placement"] = "heuristic-order-fallback"
        solver_meta["materializedBy"] = "RuleEngine"
        solver_meta["directlyConsumedByMaterializer"] = False
        c3_meta = solver_meta.get("c3Calendar")
        if isinstance(c3_meta, dict):
            c3_meta["directlyConsumedByMaterializer"] = False
        return ordered

    from server.engines.solver_process import SolverProcessError, _validate_operation_slots

    _validate_operation_slots(
        world,
        ordered,
        solver_meta,
        expected_entries=expected_entries,
    )
    c3_meta = solver_meta.get("c3Calendar")
    if not isinstance(c3_meta, dict):
        raise SolverProcessError("SOLVER_RESPONSE_INVALID", "可行解缺少 c3Calendar")
    try:
        anchor = parse_dt(str(c3_meta["anchor"]))
        horizon = int(c3_meta["horizonMinutes"])
    except (KeyError, TypeError, ValueError) as exc:
        raise SolverProcessError(
            "SOLVER_RESPONSE_INVALID", "可行解 c3Calendar anchor/horizon 非法",
        ) from exc
    slots = [
        slot for slot in solver_meta.get("operationSlots") or []
        if not slot.get("isFrozen")
    ]
    candidate_line_ids: set[int] = set()
    for entry in expected_entries:
        item = entry.get("item") or {}
        product_id = item.get("productId")
        if isinstance(product_id, bool) or not isinstance(product_id, int):
            raise SolverProcessError(
                "SOLVER_RESPONSE_INVALID", "排产条目缺少有效 productId",
            )
        for line_product in find_product_lines(world, product_id):
            line = _line_by_id(world, int(line_product["lineId"]))
            if line is not None and _candidate_options(world, item, line) is not None:
                candidate_line_ids.add(int(line["id"]))
    try:
        actual_digest, windows_by_id = _calendar_topology(
            world, candidate_line_ids, anchor, horizon,
        )
    except (KeyError, TypeError, ValueError) as exc:
        raise SolverProcessError(
            "SOLVER_RESPONSE_INVALID", "父进程无法重建 CP 日历拓扑", {"error": str(exc)},
        ) from exc
    if actual_digest != c3_meta.get("normalizedCalendarDigest"):
        raise SolverProcessError(
            "SOLVER_RESPONSE_INVALID",
            "CP 求解后日历拓扑发生漂移",
            {
                "expectedDigest": c3_meta.get("normalizedCalendarDigest"),
                "actualDigest": actual_digest,
            },
        )
    if c3_meta.get("active") is True:
        for slot in slots:
            for segment in slot["segments"]:
                window = windows_by_id.get(str(segment.get("calendarWindowId") or ""))
                if (
                    window is None
                    or int(window["lineId"]) != int(slot["lineId"])
                    or str(window["bucketDate"]) != str(segment.get("bucketDate"))
                    or int(window["shiftId"]) != int(segment.get("shiftId") or -1)
                    or int(segment["startMin"]) < int(window["startMin"])
                    or int(segment["endMin"]) > int(window["endMin"])
                ):
                    raise SolverProcessError(
                        "SOLVER_RESPONSE_INVALID",
                        "CP operationSlot segment 与父进程日历窗口不一致",
                        {"logicalOperationKey": slot.get("logicalOperationKey")},
                    )

    slots_by_index: dict[int, list[dict[str, Any]]] = {}
    for slot in slots:
        materialized_segments = [
            {
                "startTime": fmt_dt(add_minutes(anchor, int(segment["startMin"]))),
                "endTime": fmt_dt(add_minutes(anchor, int(segment["endMin"]))),
                "durationMin": int(segment["durationMin"]),
                "calendarWindowId": segment.get("calendarWindowId"),
                "bucketDate": segment.get("bucketDate"),
                "shiftId": segment.get("shiftId"),
            }
            for segment in slot["segments"]
        ]
        slots_by_index.setdefault(int(slot["orderIndex"]), []).append({
            **slot,
            "plannedStartTime": fmt_dt(add_minutes(anchor, int(slot["startMin"]))),
            "plannedEndTime": fmt_dt(add_minutes(anchor, int(slot["endMin"]))),
            "plannedSegments": materialized_segments,
        })
    for values in slots_by_index.values():
        values.sort(key=lambda slot: (int(slot["sequenceNo"]), int(slot["routingStepId"])))

    index_by_identity = {
        (entry["so"]["id"], entry["item"]["id"]): index
        for index, entry in enumerate(expected_entries)
    }
    prepared: list[dict] = []
    for entry in ordered:
        identity = (entry["so"]["id"], entry["item"]["id"])
        order_index = index_by_identity.get(identity)
        if order_index is None or order_index not in slots_by_index:
            raise SolverProcessError(
                "SOLVER_RESPONSE_INVALID", "无法把 operationSlots 绑定到稳定订单项身份",
            )
        bound = dict(entry)
        bound["_cpOperationTiming"] = slots_by_index[order_index]
        prepared.append(bound)

    solver_meta["operationSlotSchemaVersion"] = "cp-operation-slot.v1"
    solver_meta["operationTimingValidation"] = {
        "schemaVersion": "cp-operation-timing-validation.v1",
        "passed": True,
        "validatedBy": "solver-parent",
        "entryCount": len(expected_entries),
        "operationCount": len(slots),
        "calendarDigest": actual_digest,
    }
    solver_meta["placement"] = "cp-calendar-segmented-direct"
    solver_meta["materializedBy"] = "RuleEngine.validated-cp-timing"
    solver_meta["directlyConsumedByMaterializer"] = True
    c3_meta["directlyConsumedByMaterializer"] = True
    return prepared


def _unavailable_result(
    world: World,
    params: EngineParams,
    next_id: Callable[[str], int],
    campaign_meta: dict[str, Any],
    source_count: int,
    message: str,
    *,
    engine_type: str,
    error_code: str,
    diagnostics: dict[str, Any] | None = None,
) -> ScheduleResult:
    """Materialize one explicit non-publishable blocker without business work artifacts."""
    from datetime import datetime

    from server.aps_domain.constraints import profile_snapshot
    from server.timeutil import fmt_dt

    now = datetime.now()  # noqa: DTZ005
    version_id = next_id("scheduleVersion")
    version = {
        "id": version_id,
        "versionNo": "V" + fmt_date(now).replace("-", "") + f"-{len(world['scheduleVersions']) + 1:03d}",
        "versionName": params.name or (f"{engine_type} 求解器阻断 " + fmt_dt(now)),
        "triggerType": params.triggerType,
        "engineType": engine_type,
        "status": "DRAFT",
        "parentVersionId": world["scheduleVersions"][-1]["id"] if world["scheduleVersions"] else None,
        "orderCount": source_count, "poCount": 0, "woCount": 0,
        "totalTardiness": 0.0, "totalCost": 0.0, "avgUtilization": 0.0,
        "conflictCount": 1, "resolvedCount": 0,
        "createdBy": "agent", "createdAt": fmt_dt(now), "publishedAt": None,
        "publishReady": False, "dispatchReady": False,
        "note": f"solver={engine_type};status=UNAVAILABLE;errorCode={error_code}",
        "constraintProfile": profile_snapshot(world),
        "campaign": campaign_meta,
        "solverMeta": {
            "backend": "OR-Tools CP-SAT subprocess", "status": "UNAVAILABLE",
            "wallTimeSec": 0.0, "gap": None, "errorCode": error_code, "error": message,
            **dict(diagnostics or {}),
        },
    }
    world["scheduleVersions"].append(version)
    world["conflicts"].append({
        "id": next_id("conflict"), "versionId": version_id,
        "conflictType": "ENGINE_UNAVAILABLE", "severity": "CRITICAL",
        "isResolved": False, "resolutionAction": "",
        "resourceType": "ENGINE", "description": f"{error_code}: {message}",
        "suggestedSolution": "检查求解器隔离运行时、子进程协议与超时配置后重试",
    })
    return ScheduleResult(
        versionId=version_id, versionNo=version["versionNo"],
        engineType=engine_type, strategy=params.strategyTemplate, status="DRAFT",
        orderCount=source_count, poCount=0, woCount=0, conflictCount=1,
        totalTardiness=0.0, avgUtilization=0.0, totalCost=0.0,
        evidenceRefs=[
            f"run:{version['versionNo']}",
            "solver:UNAVAILABLE",
            f"solver-error:{error_code}",
        ],
        solveStatus="UNAVAILABLE", solveTimeSec=0.0, optimalityGap=None,
    )


def _solver_failure_diagnostics(exc: BaseException) -> dict[str, Any]:
    """Keep actionable runtime reasons without exposing child paths or package origins."""
    details = getattr(exc, "details", None)
    runtime = details.get("runtimeIdentity") if isinstance(details, dict) else None
    reasons = runtime.get("reasons") if isinstance(runtime, dict) else None
    if not isinstance(runtime, dict) or not isinstance(reasons, list):
        return {}
    safe_reasons = [str(reason) for reason in reasons if isinstance(reason, str) and reason]
    if not safe_reasons:
        return {}
    packages = runtime.get("packages")
    package_availability = {
        name: bool(isinstance(info, dict) and info.get("origin"))
        for name, info in dict(packages or {}).items()
        if isinstance(name, str)
    }
    child_executable = str(runtime.get("executable") or "")
    child_prefix = str(runtime.get("prefix") or "")
    return {
        "runtimeSafetyReasons": safe_reasons,
        "runtimePythonVersion": str(runtime.get("pythonVersion") or ""),
        "runtimeExecutableMatchesParent": bool(child_executable) and (
            os.path.normcase(os.path.abspath(child_executable))
            == os.path.normcase(os.path.abspath(sys.executable))
        ),
        "runtimePrefixMatchesParent": bool(child_prefix) and (
            os.path.normcase(os.path.abspath(child_prefix))
            == os.path.normcase(os.path.abspath(sys.prefix))
        ),
        "runtimePackageAvailability": package_availability,
        "solverChildCommandOverride": bool(os.environ.get("APS_SOLVER_CHILD_COMMAND_JSON")),
    }


def _validate_materialized_c7(
    world: World,
    result: ScheduleResult,
    next_id: Callable[[str], int],
    *,
    c7_enabled: bool,
) -> ScheduleResult:
    version = next(
        (row for row in world.get("scheduleVersions", []) if row.get("id") == result.versionId),
        None,
    )
    if version is None:
        return result
    from server.engines.queries import get_available_minutes

    production_order_ids = {
        row.get("id") for row in world.get("productionOrders", [])
        if row.get("schedulingVersionId") == result.versionId
    }
    loads: dict[tuple[int, str], float] = {
        key: float(value) for key, value in _frozen_line_day_loads(world).items()
    }
    for work_order in world.get("workOrders", []):
        if work_order.get("productionOrderId") not in production_order_ids:
            continue
        start = str(work_order.get("plannedStartTime") or "")
        if len(start) < 10 or work_order.get("lineId") is None:
            continue
        processing = work_order.get("processingMinutes")
        duration = (
            float(processing)
            if isinstance(processing, (int, float)) and not isinstance(processing, bool)
            else (
                parse_dt(str(work_order["plannedEndTime"]))
                - parse_dt(str(work_order["plannedStartTime"]))
            ).total_seconds() / 60.0
        )
        key = (int(work_order["lineId"]), start[:10])
        loads[key] = loads.get(key, 0.0) + duration
    violations = []
    for (line_id, bucket_date), used in sorted(loads.items()):
        available = get_available_minutes(world, line_id, bucket_date)
        if used > available + 1e-6:
            violations.append({
                "lineId": line_id,
                "bucketDate": bucket_date,
                "usedMinutes": round(used, 6),
                "capacityMinutes": available,
            })
    conflicts = [
        row for row in world.get("conflicts", [])
        if row.get("versionId") == result.versionId and row.get("conflictType") == "CAPACITY"
    ]
    line_names = {
        int(row["id"]): str(row.get("name") or row.get("code") or row["id"])
        for row in world.get("lines", [])
    }
    for violation in violations if c7_enabled else []:
        line_id = int(violation["lineId"])
        bucket_date = str(violation["bucketDate"])
        already_reported = any(
            (
                row.get("lineId") == line_id and row.get("bucketDate") == bucket_date
            ) or (
                row.get("resourceName") == line_names.get(line_id)
                and str(row.get("conflictTimeStart") or "").startswith(bucket_date)
            )
            for row in conflicts
        )
        if already_reported:
            continue
        conflict = {
            "id": next_id("conflict"),
            "versionId": result.versionId,
            "conflictType": "CAPACITY",
            "severity": "CRITICAL",
            "resourceType": "LINE",
            "resourceName": line_names.get(line_id, str(line_id)),
            "lineId": line_id,
            "bucketDate": bucket_date,
            "conflictTimeStart": bucket_date + " 00:00",
            "description": (
                f"CP C7 物化漂移：{line_names.get(line_id, line_id)} {bucket_date} "
                f"负荷 {violation['usedMinutes']} 分钟，超过精确容量 "
                f"{violation['capacityMinutes']} 分钟"
            ),
            "suggestedSolution": "调整物化日桶、分流产线或配置经确认的加班容量",
            "isResolved": False,
            "resolutionAction": "",
        }
        world.setdefault("conflicts", []).append(conflict)
        conflicts.append(conflict)
    if conflicts:
        version["conflictCount"] = len([
            row for row in world.get("conflicts", []) if row.get("versionId") == result.versionId
        ])
        result.conflictCount = int(version["conflictCount"])
    solver_meta = version.setdefault("solverMeta", {})
    solver_meta["materializedC7Validation"] = {
        "checked": bool(c7_enabled),
        "passed": not violations if c7_enabled else None,
        "accountingMethod": "start-day-full-duration.v1",
        "violations": violations,
        "conflictIds": [row.get("id") for row in conflicts],
    }
    return result


def _validate_materialized_c3(
    world: World,
    result: ScheduleResult,
    next_id: Callable[[str], int],
    *,
    c3_enabled: bool,
) -> ScheduleResult:
    """Verify Rule materialization against C3 without rewriting the CP solve status."""
    version = next(
        (row for row in world.get("scheduleVersions", []) if row.get("id") == result.versionId),
        None,
    )
    if version is None:
        return result
    solver_meta = version.setdefault("solverMeta", {})
    c3_meta = solver_meta.get("c3Calendar") or {}
    production_orders = {
        row.get("id"): row for row in world.get("productionOrders", [])
        if row.get("schedulingVersionId") == result.versionId
    }
    work_orders = [
        row for row in world.get("workOrders", [])
        if row.get("productionOrderId") in production_orders
    ]
    cp_timing_applied = bool(
        solver_meta.get("directlyConsumedByMaterializer") is True
        and solver_meta.get("operationTimingValidation", {}).get("passed") is True
    )
    if not c3_enabled or not c3_meta:
        solver_meta["materializedC3Validation"] = {
            "schemaVersion": "materialized-c3-validation.v1",
            "checked": False,
            "passed": None,
            "cpTimingApplied": cp_timing_applied,
            "exactAlignmentCount": 0,
            "validReassignmentCount": 0,
            "violationCount": 0,
            "violations": [],
            "conflictIds": [],
        }
        return result

    anchor = parse_dt(str(c3_meta.get("anchor")))
    horizon = int(c3_meta.get("horizonMinutes") or 0)
    line_ids = {
        int(row["lineId"]) for row in work_orders if row.get("lineId") is not None
    }
    buckets = _line_day_buckets(world, line_ids, anchor, horizon) if line_ids else []
    windows_by_line: dict[int, list[tuple[int, int]]] = {}
    for bucket in buckets:
        windows_by_line.setdefault(int(bucket["lineId"]), []).extend(
            (int(window["startMin"]), int(window["endMin"]))
            for window in bucket.get("effectiveWindows") or []
        )
    for windows in windows_by_line.values():
        windows.sort()

    cp_slots_by_key: dict[tuple[Any, ...], list[dict[str, Any]]] = {}
    cp_slots_by_identity: dict[tuple[int, int], dict[str, Any]] = {}
    for slot in solver_meta.get("operationSlots") or []:
        if slot.get("isFrozen") or slot.get("lineId") is None:
            continue
        key = (
            slot.get("orderNo"), slot.get("productId"), int(slot["lineId"]),
            slot.get("sequenceNo"), slot.get("operationId"),
        )
        cp_slots_by_key.setdefault(key, []).append(slot)
        order_index = slot.get("orderIndex")
        routing_step_id = slot.get("routingStepId")
        if (
            isinstance(order_index, int)
            and not isinstance(order_index, bool)
            and order_index >= 0
            and isinstance(routing_step_id, int)
            and not isinstance(routing_step_id, bool)
            and routing_step_id > 0
        ):
            cp_slots_by_identity[(order_index, routing_step_id)] = slot

    exact_alignment_count = 0
    valid_reassignment_count = 0
    violations: list[dict[str, Any]] = []
    for work_order in work_orders:
        line_id = int(work_order["lineId"])
        start_dt = parse_dt(str(work_order["plannedStartTime"]))
        end_dt = parse_dt(str(work_order["plannedEndTime"]))
        start_min = int(round((start_dt - anchor).total_seconds() / 60.0))
        end_min = int(round((end_dt - anchor).total_seconds() / 60.0))
        duration = max(0, end_min - start_min)
        production_order = production_orders.get(work_order.get("productionOrderId")) or {}
        key = (
            production_order.get("salesOrderNo"), work_order.get("productId"), line_id,
            work_order.get("sequenceNo"), work_order.get("operationId"),
        )
        if cp_timing_applied:
            cp_order_index = work_order.get("cpOrderIndex")
            routing_step_id = work_order.get("routingStepId")
            identity_valid = (
                isinstance(cp_order_index, int)
                and not isinstance(cp_order_index, bool)
                and cp_order_index >= 0
                and isinstance(routing_step_id, int)
                and not isinstance(routing_step_id, bool)
                and routing_step_id > 0
            )
            cp_slot = (
                cp_slots_by_identity.get((cp_order_index, routing_step_id))
                if identity_valid else None
            )
        else:
            candidates = cp_slots_by_key.get(key) or []
            cp_slot = candidates.pop(0) if candidates else None
        relative_segments: list[dict[str, Any]] = []
        segment_shape_valid = True
        if cp_timing_applied:
            planned_segments = work_order.get("plannedSegments")
            if not isinstance(planned_segments, list) or not planned_segments:
                segment_shape_valid = False
            else:
                for segment in planned_segments:
                    try:
                        segment_start = int(round((
                            parse_dt(str(segment["startTime"])) - anchor
                        ).total_seconds() / 60.0))
                        segment_end = int(round((
                            parse_dt(str(segment["endTime"])) - anchor
                        ).total_seconds() / 60.0))
                        relative_segments.append({
                            "startMin": segment_start,
                            "endMin": segment_end,
                            "durationMin": int(segment["durationMin"]),
                            "calendarWindowId": segment.get("calendarWindowId"),
                            "bucketDate": segment.get("bucketDate"),
                            "shiftId": segment.get("shiftId"),
                        })
                    except (KeyError, TypeError, ValueError):
                        segment_shape_valid = False
                        break
        expected_segments = list(cp_slot.get("segments") or []) if cp_slot else []
        exact = bool(
            cp_slot
            and int(cp_slot.get("startMin", -1)) == start_min
            and int(cp_slot.get("endMin", -1)) == end_min
            and (
                not cp_timing_applied
                or (
                    segment_shape_valid
                    and relative_segments == expected_segments
                    and work_order.get("processingMinutes") == cp_slot.get("processingMinutes")
                    and work_order.get("elapsedSpanMinutes") == cp_slot.get("elapsedSpanMinutes")
                    and work_order.get("pauseMinutes") == cp_slot.get("pauseMinutes")
                    and work_order.get("segmentCount") == cp_slot.get("segmentCount")
                )
            )
        )
        intervals = (
            [(int(segment["startMin"]), int(segment["endMin"])) for segment in relative_segments]
            if cp_timing_applied and segment_shape_valid
            else [(start_min, end_min)]
        )
        processing_duration = sum(max(0, right - left) for left, right in intervals)
        covered = sum(
            max(0, min(right, window_end) - max(left, window_start))
            for left, right in intervals
            for window_start, window_end in windows_by_line.get(line_id, [])
        )
        uncovered = max(0, processing_duration - covered)
        if cp_timing_applied and not exact:
            violations.append({
                "workOrderId": work_order.get("id"),
                "workOrderNo": work_order.get("orderNo"),
                "productionOrderId": work_order.get("productionOrderId"),
                "lineId": line_id,
                "startMin": start_min,
                "endMin": end_min,
                "durationMinutes": processing_duration,
                "coveredMinutes": covered,
                "uncoveredMinutes": uncovered,
                "reason": "direct-cp-timing-mismatch",
            })
            continue
        if uncovered <= 0:
            if exact:
                exact_alignment_count += 1
            else:
                valid_reassignment_count += 1
            continue
        violations.append({
            "workOrderId": work_order.get("id"),
            "workOrderNo": work_order.get("orderNo"),
            "productionOrderId": work_order.get("productionOrderId"),
            "lineId": line_id,
            "startMin": start_min,
            "endMin": end_min,
            "durationMinutes": processing_duration if cp_timing_applied else duration,
            "coveredMinutes": covered,
            "uncoveredMinutes": uncovered,
            "reason": (
                "cp-segment-outside-calendar-window"
                if cp_timing_applied else "continuous-materialization-crosses-calendar-gap"
            ),
        })

    conflicts = [
        row for row in world.get("conflicts", [])
        if row.get("versionId") == result.versionId and row.get("conflictType") == "CALENDAR"
    ]
    for violation in violations:
        if any(row.get("workOrderId") == violation["workOrderId"] for row in conflicts):
            continue
        conflict = {
            "id": next_id("conflict"),
            "versionId": result.versionId,
            "conflictType": "CALENDAR",
            "severity": "CRITICAL",
            "productionOrderId": violation["productionOrderId"],
            "workOrderId": violation["workOrderId"],
            "lineId": violation["lineId"],
            "resourceType": "LINE_CALENDAR",
            "description": (
                f"CP C3 物化漂移：{violation['workOrderNo']} 连续占槽包含 "
                f"{violation['uncoveredMinutes']} 分钟非工作窗口"
            ),
            "suggestedSolution": "让物化器直接消费 CP 分段，或把工单改排到完整有效窗口",
            "isResolved": False,
            "resolutionAction": "",
        }
        world.setdefault("conflicts", []).append(conflict)
        conflicts.append(conflict)
    if conflicts:
        version["publishReady"] = False
        version["dispatchReady"] = False
        version["conflictCount"] = len([
            row for row in world.get("conflicts", []) if row.get("versionId") == result.versionId
        ])
        result.conflictCount = int(version["conflictCount"])
        affected_po_ids = {row.get("productionOrderId") for row in conflicts}
        for production_order_id in affected_po_ids:
            production_order = production_orders.get(production_order_id)
            if production_order is not None:
                production_order["constraintCheckStatus"] = "FAILED"
                production_order["conflictCount"] = sum(
                    1 for row in world.get("conflicts", [])
                    if row.get("versionId") == result.versionId
                    and row.get("productionOrderId") == production_order_id
                )
    solver_meta["materializedC3Validation"] = {
        "schemaVersion": "materialized-c3-validation.v1",
        "checked": True,
        "passed": not violations,
        "cpTimingApplied": cp_timing_applied,
        "calendarDigest": c3_meta.get("normalizedCalendarDigest"),
        "exactAlignmentCount": exact_alignment_count,
        "validReassignmentCount": valid_reassignment_count,
        "violationCount": len(violations),
        "violations": violations,
        "conflictIds": [row.get("id") for row in conflicts],
    }
    return result


def _c7_enabled(world: World, params: EngineParams) -> bool:
    from server.aps_domain.constraints import is_enabled

    return bool(params.constraints.get("capacity", True)) and is_enabled(world, "C7_capacity")


def _c3_enabled(world: World) -> bool:
    from server.aps_domain.constraints import is_enabled

    return is_enabled(world, "C3_calendar")


class CpSatEngine(RuleEngine):
    """SC-03：CP-SAT 工序级排产（选线+排序），再班次占槽物化。"""

    name = "CP"
    supports_anytime = True

    def __init__(self) -> None:
        super().__init__(requested_type="CP")

    def solve(self, world: World, params: EngineParams, next_id: Callable[[str], int]) -> ScheduleResult:
        entries, campaign_meta, source_count = self.collect_and_order(world, params)
        pipeline_label = "CP-SAT→shift-slot"
        try:
            from server.engines.solver_process import (
                SolverProcessError,
                run_cp_assignment,
            )
        except ImportError as exc:
            return self._unavailable(
                world,
                params,
                next_id,
                campaign_meta,
                source_count,
                str(exc),
                error_code="SOLVER_RUNTIME_UNSAFE",
            )
        try:
            ordered, solver_meta = run_cp_assignment(
                world=world,
                entries=entries,
                params=params,
                pipeline_label=pipeline_label,
            )
        except SolverProcessError as exc:
            error_code = str(
                getattr(exc, "code", None)
                or getattr(exc, "error_code", None)
                or "SOLVER_PROCESS_EXITED"
            )
            return self._unavailable(
                world,
                params,
                next_id,
                campaign_meta,
                source_count,
                str(exc),
                error_code=error_code,
                diagnostics=_solver_failure_diagnostics(exc),
            )
        # pipeline 是父进程已知请求字段；由父进程回填，避免 Windows 文本传输替换非 ASCII 箭头。
        solver_meta = dict(solver_meta)
        solver_meta["pipeline"] = pipeline_label
        try:
            ordered = _prepare_cp_operation_timing(world, entries, ordered, solver_meta)
        except SolverProcessError as exc:
            return self._unavailable(
                world,
                params,
                next_id,
                campaign_meta,
                source_count,
                str(exc),
                error_code=str(getattr(exc, "code", None) or "SOLVER_RESPONSE_INVALID"),
            )
        result = self.materialize_schedule(
            world, params, next_id, ordered, campaign_meta, source_count, solver_meta=solver_meta,
        )
        result = _validate_materialized_c7(
            world, result, next_id, c7_enabled=_c7_enabled(world, params),
        )
        return _validate_materialized_c3(
            world, result, next_id, c3_enabled=_c3_enabled(world),
        )

    def _unavailable(
        self,
        world: World,
        params: EngineParams,
        next_id: Callable[[str], int],
        campaign_meta: dict[str, Any],
        source_count: int,
        message: str,
        *,
        error_code: str = "SOLVER_PROCESS_EXITED",
        diagnostics: dict[str, Any] | None = None,
    ) -> ScheduleResult:
        engine_type = "HYBRID" if self.name == "HYBRID" else "CP"
        return _unavailable_result(
            world,
            params,
            next_id,
            campaign_meta,
            source_count,
            message,
            engine_type=engine_type,
            error_code=error_code,
            diagnostics=diagnostics,
        )


class HybridEngine(RuleEngine):
    """SC-03：HYBRID = RULE 策略序/选线热启动 → CP-SAT 改良 → 班次占槽。"""

    name = "HYBRID"
    supports_anytime = True

    def __init__(self) -> None:
        super().__init__(requested_type="HYBRID")

    def solve(self, world: World, params: EngineParams, next_id: Callable[[str], int]) -> ScheduleResult:
        entries, campaign_meta, source_count = self.collect_and_order(world, params)
        warm = build_rule_warm_start(world, entries, params)
        pipeline_label = "RULE→CP-SAT→shift-slot"
        try:
            from server.engines.solver_process import (
                SolverProcessError,
                run_cp_assignment,
            )
        except ImportError as exc:
            return _unavailable_result(
                world,
                params,
                next_id,
                campaign_meta,
                source_count,
                str(exc),
                engine_type="HYBRID",
                error_code="SOLVER_RUNTIME_UNSAFE",
            )
        try:
            ordered, solver_meta = run_cp_assignment(
                world=world,
                entries=entries,
                params=params,
                warm_start=warm,
                pipeline_label=pipeline_label,
            )
        except SolverProcessError as exc:
            error_code = str(
                getattr(exc, "code", None)
                or getattr(exc, "error_code", None)
                or "SOLVER_PROCESS_EXITED"
            )
            # HYBRID 默认同样失败关闭；禁止把 native/runtime/protocol 故障伪装成 RULE 成功。
            return _unavailable_result(
                world,
                params,
                next_id,
                campaign_meta,
                source_count,
                str(exc),
                engine_type="HYBRID",
                error_code=error_code,
                diagnostics=_solver_failure_diagnostics(exc),
            )
        solver_meta = dict(solver_meta)
        solver_meta["pipeline"] = pipeline_label
        try:
            ordered = _prepare_cp_operation_timing(world, entries, ordered, solver_meta)
        except SolverProcessError as exc:
            return _unavailable_result(
                world,
                params,
                next_id,
                campaign_meta,
                source_count,
                str(exc),
                engine_type="HYBRID",
                error_code=str(getattr(exc, "code", None) or "SOLVER_RESPONSE_INVALID"),
            )
        result = self.materialize_schedule(
            world, params, next_id, ordered, campaign_meta, source_count, solver_meta=solver_meta,
        )
        result = _validate_materialized_c7(
            world, result, next_id, c7_enabled=_c7_enabled(world, params),
        )
        return _validate_materialized_c3(
            world, result, next_id, c3_enabled=_c3_enabled(world),
        )