aps-agent/server/agent_core/intent.py

# ============================================================
# 意图识别两级管线（moduleId: core-intent, 可重生 ✅）
# plan.md §9.6：一级规则快路（<10ms，POC 已验证）→ 二级 LLM 语义解析（JSON 强校验）
# 低置信拒识；LLM 不可用/输出非法 → 自动降级为 unknown（引导用户换说法）
# ============================================================
from __future__ import annotations                    # 前向类型引用

import re                                              # 正则快路
from typing import Any                                 # 类型标注

from pydantic import ValidationError                   # 契约校验异常

from server.agent_core.providers import get_provider   # LLM Provider
from server.contracts import IntentResult              # 意图结果契约

# 世界状态类型别名（快路需要查产线表做聚焦解析）
World = dict[str, Any]

# ---------------- LLM 系统提示词（意图枚举 + 槽位说明 + 输出 Schema） ----------------
_LLM_SYSTEM = """你是工厂排产系统的意图解析器。把用户的中文口令解析为 JSON（只输出 JSON，不要多余文字）。
输出格式：{"intent": "...", "params": {...}, "confidence": 0.0~1.0}
可选 intent 及其 params：
- schedule.run     试排/排产/重排。params: strategy ∈ [DELIVERY_FIRST交期优先, CAPACITY_BALANCE产能均衡, CHANGEOVER_MIN换型最小化, CAMPAIGN战役合并, COST_FIRST成本最优(换型代理), FIFO先进先出, COMPREHENSIVE综合]（默认COMPREHENSIVE）, engine ∈ [RULE规则, CP约束规划(OR-Tools), HYBRID混合(RULE热启动+CP改良), GA遗传(暂RULE代跑)]；未点名引擎时用排产参数 defaultEngine
- schedule.publish 发布/下发当前排产版本。params: {}
- campaign.preview 战役/批次合并预览。params: windowDays=交期窗口天数（默认7）- order.upsert     新建或修改销售订单。params: orderNo=订单号(仅修改时给,如 SO20260716001), customerName=客户名, customerLevel ∈ [VIP,A,B,C], productCode=成品编码或名称, quantity=数量, deliveryDate=交期(YYYY-MM-DD), priority=1~9, isRush=是否加急
- order.cancel     取消销售订单。params: orderNo=订单号（如 SO20260716001）
- order.complete   完成销售订单。params: orderNo=订单号（如 SO20260716001）
- order.delete     删除销售订单（物理移除）。params: orderNo=订单号
- order.clear      一键清空全部订单与采购委外建议。params: {}
- order.submit     提交订单审核。params: orderNo=订单号
- order.approve    批准订单（可批量）。params: orderNo 或 orderIds
- order.reject     驳回订单。params: orderNo, reviewNote=原因（可选）
- rush.evaluate    紧急插单影响快评（固定轨沙盒）。params: orderNo=已有订单号（可选）, customerName, customerLevel, productCode, quantity, deliveryDate, priority, strategy
- rush.apply       采用上次插单快评结果（写主干+草稿排产）。params: {} 或与 evaluate 相同字段
- forecast.query   查看预测/长周期订单。params: {}
- forecast.upsert  新建或编辑预测订单。params: productCode, quantity, bucket∈[DAY,WEEK,MONTH], periodStart, dueDate, confidence, status
- forecast.delete  删除预测订单。params: forecastNo
- forecast.convert 预测转正为销售订单。params: forecastNo
- plan.buckets     时间分桶计划/日周月粗能力。params: mode∈[DAY,WEEK,MONTH,HYBRID], capacityMode∈[FINITE有限,INFINITE无限], horizonDays, includeForecast
- plan.rccp        有限/无限产能粗评估对照。params: mode, horizonDays, includeForecast
- plan.feasibility 交期可行性分析（能否按期/缺口）。params: horizonDays, includeForecast
- plan.inventory   库存投影/库存曲线。params: materialCode, materialType∈[FINISHED_PRODUCT,RAW_MATERIAL], bucket∈[DAY,WEEK], horizonDays, includeForecast
- plan.leveling    产能平衡/削峰建议。params: mode∈[DAY,WEEK,MONTH,HYBRID], targetLoad, horizonDays, includeForecast
- plan.supply      产供方向决策（加班/扩线/外协）。params: mode, targetLoad, horizonDays, includeForecast
- order.decompose  订单分解/展开BOM/生成采购委外建议。params: orderNo=订单号（可选，缺省=全部可排产订单）
- mrp.release       下达/确认下达采购或委外建议单（草稿转正式）。params: orderNo=订单号（可选）, kind ∈ [all全部, purchase采购, outsource委外]（默认all）
- plan.trace        追溯/钉扎/看订单依据/从哪排的/BOM库存负荷。params: orderNo=订单号（可选，FO-/SO-）, track ∈ [fixed, flex, auto]
- master.material.upsert 新建物料主数据。params: code=编码, name=名称, type ∈ [FINISHED_PRODUCT成品, SEMI_FINISHED半成品, RAW_MATERIAL原料], unit=单位, stock=库存, procurementLeadTime=采购前置期天数
- master.changeover.upsert 换型矩阵写入。params: fromFamily, toFamily, setupMinutes, note?; delete=true+id 删除
- changeover.query 查看换型矩阵。params: 无
- master.clear      一键清理主数据（清空）。params: scope ∈ [resource资源, process工艺模型, calendar日历维保, flex柔性资源, all全部]
- master.query     查订单/物料/工序/BOM/工艺路线/主数据概览/柔性资源/委外/采购建议。params: entity ∈ [order, material, operation, bom, routing, overview, flex, mrp], code=订单号或料号（可选）, orderRef=last, aspect ∈ [outsource, purchase, all], query=原口令
- params.update     更新排产参数/客户等级权重。params: vipWeight/aWeight/bWeight/cWeight（可选数字）, resetDefaults=是否恢复默认
- params.query      查看当前排产参数/客户等级权重。params: {}
- constraint.profile.query 查看约束配置。params: {}
- constraint.profile.save  更新约束配置。params: constraintId, enabled, kind∈[hard,soft], resetDefaults
- data.import       批量导入订单或物料（自然语言多行/CSV）。params: kind ∈ [orders, materials], text=原始导入正文
- flex.site.load   加载现场完整生产路线/替换柔性演示数据。params: routePath=xlsx路径（可选）, dataDir=源表目录（可选）, includeSiblings=是否带同源其它单
- flex.schedule    柔性排产/能力池排产/虚拟产线/多品种小批量/走全流程排产/滚动排产/把这个订单排产/计划排产/用外部算法试排。params: sortMode ∈ [ASC正排, DESC倒排, BOTTLENECK瓶颈锚]（默认BOTTLENECK）, window ∈ [realtime实时60m, short短窗2h, mid中窗2d, long长窗7d, full全量]（可选）, orderNo=订单号（可选）, orderRef=last（指代刚查过的订单）, engine=EXTERNAL（外部算法）, skillId=skill_id（可选）, useExternal=true（可选）
- flex.reschedule  短窗重排/日窗重排/局部重排/分级重排。params: level ∈ [L2短窗, L3日窗, L4全局]
- flex.swap        L1局部换机/备机接手。params: equipmentCode（如 PRESS-01）, woId（可选）, markFault（默认true）
- flex.capacity    瓶颈产能/产能池评估/各工序能做多少。params: {}
- flex.simulate_due 询问某产品多少数量何时能交（交期承诺）。params: productCode ∈ [HV-HARNESS高压线束, PDU-UNIT PDU配电单元], quantity=数量
- flex.compare     三模式对比/正排倒排瓶颈锚对比。params: {}
- flex.rush        柔性紧急插单。params: productCode, quantity, dueDate（可选）, priority（默认1）
- flex.fault       设备故障/停机/恢复。params: equipmentCode, status ∈ [MAINTENANCE故障, RUNNING恢复]
- flex.resource.patch 改设备区域状态或模具寿命锁定。params: kind ∈ [equipment, mold], code, status/zone/lifeUsed
- conflict.list    查看冲突/冲突中心/有哪些冲突。params: scope ∈ [flex, fixed, all]
- flex.conflict.resolve 解决冲突/修复冲突。params: conflictId, action（可选）
- sap.status       SAP连接/集成状态。params: {}
- sap.sync.inbound 从SAP拉单/同步SAP订单/同步库存。params: {}
- sap.sync.outbound 回写SAP/完工回写。params: {}
- mes.status       MES连接/车间系统状态。params: {}
- mes.dispatch     下发MES/下发车间。params: track ∈ [flex柔性, fixed固定]
- mes.report       报工/模拟报工。params: woId=工单号（可选）, track, progressPct, finish
- scenario.compare 多方案/多策略对比试排（沙盒，不影响当前方案）。params: {}
- scenario.sensitivity 主控参数敏感性分析 Tornado（沙盒）。params: strategy=策略模板（可选）
- sop.compile      把SOP编译成约束规则包预览。params: query=SOP标题或关键词（如换线）
- sop.apply        应用SOP规则包（P2）。params: query=同上 或 pack=编译结果对象
- checkpoint.create 存档/建检查点/打快照。params: label=快照名（可选）
- checkpoint.rollback 回滚/回到某个检查点。params: pairId=检查点ID（可选，缺省=最近一个）
- knowledge.query   查知识库/问规定/问SOP/问策略原理（如"换线有什么规定"）。params: query=原始问题
- knowledge.import  导入知识文档（PDF/docx/md）。params: path=本地文件路径, kind ∈ [sop,process,algorithm,case]（可选）, title=标题（可选）
- schedule.wizard   引导式排产向导（我要排产/帮我排产/怎么排产/不会排产）。params: {}
- readiness.query   数据齐备度检查/工时维护情况（哪些工时没维护、排产数据够不够）。params: {}
- data.analyze      分析项目/文件/当前数据内容，整理盘点并列出排产缺口。params: query=原口令
- folder.analyze    解析工程目录里的 Excel（读内容/样例/能否开排）。params: {}
- folder.schedule   根据工程目录数据导入并试排。params: {}
- assistant.reply   通用排产问答（怎么用/你是谁/解释现状/开放问题）。params: query=原口令
- flex.time.update  更新单件工时（如"把部装工时改成50分钟"）。params: operationCode=工序编码或名称, productCode=产品编码（可选）, stdMin=分钟数
- skill.list        查看已接入外部算法。params: {}
- skill.health      算法 skill 健康检查。params: skillId（可选）
- skill.register    登记算法 skill。params: skill_id, endpoint, name（可选）, track ∈ [flex,fixed], auth（可选）
- skill.enable      启用/停用算法 skill。params: skillId, enabled=true|false
- report.generate   生成报告。params: reportType ∈ [daily日报, version-diff版本对比, plan排产方案], orderNo=订单号（可选）, orderRef=last（可选）
- viewport.mode    切换视图。params: mode ∈ [gantt甘特图, load负荷热力, util资源利用率, due交期承诺看板, flex柔性甘特, pool产能池, kpi KPI仪表盘, compare方案对比表]
- viewport.filter  过滤订单。params: type ∈ [vip, customer]; type=customer 时给 name=客户名
- viewport.focus   聚焦某条产线。params: lineCode 如 "L001"（产线A=L001 产线B=L002 产线C=L003）
- viewport.highlight 高亮风险。params: what ∈ [overdue超期, conflict冲突]
- viewport.timescale 时间粒度。params: scale ∈ [day, hour]
- viewport.reset   重置视图。params: {}
- query.kpi        查询指标/KPI/利用率/情况/打开仪表盘。params: {}
- guidance.next    下一步建议/该做什么/空态引导。params: {}
- data.reset       清空数据重新初始化。params: {}
- help             询问能做什么。params: {}
- unknown          无法归类。confidence 给低值。
只输出一个 JSON 对象。confidence 表示你对解析的把握。"""


_LEVEL_MAP = {"VIP": "VIP", "甲": "A", "乙": "B", "丙": "C", "A": "A", "B": "B", "C": "C"}


def _parse_due_date(t: str) -> str | None:
    """从口令里抽交期：支持 YYYY-MM-DD / YYYY/MM/DD / M月D日 / M-D（缺省当年）。"""
    import datetime as _dt
    m = re.search(r"(20\d{2})[-/.](\d{1,2})[-/.](\d{1,2})", t)
    if m:
        y, mo, d = int(m.group(1)), int(m.group(2)), int(m.group(3))
    else:
        m2 = re.search(r"(\d{1,2})\s*月\s*(\d{1,2})\s*[日号]?", t)
        if not m2:
            return None
        y, mo, d = _dt.date.today().year, int(m2.group(1)), int(m2.group(2))
    try:
        return _dt.date(y, mo, d).strftime("%Y-%m-%d")
    except ValueError:
        return None


def _order_upsert_slots(t: str, world: World) -> dict:
    """尽力从口令抽取建/改单槽位（缺失项留空，由 handler 追问或用现单兜底）。"""
    params: dict[str, Any] = {}
    m_no = re.search(r"(SO\d{6,})", t, re.I)               # 编辑目标订单号
    if m_no:
        params["orderNo"] = m_no.group(1).upper()
    m_cust = re.search(r"客户\s*[:：]?\s*([^\s，,。：:]{1,16})", t) \
        or re.search(r"(?:给|向|为)\s*([^\s，,。]{1,16}?)\s*(?:新建|新增|下|加|开|录)", t)
    if m_cust:
        params["customerName"] = m_cust.group(1).strip()
    prod = None                                            # 成品解析：先名称/编码扫描
    for m in world.get("materials", []):
        if m.get("type") == "FINISHED_PRODUCT" and (m["name"] in t or m["code"].lower() in t.lower()):
            prod = m
            break
    if prod:
        params["productCode"] = prod["code"]
    m_qty = re.search(r"数量\s*[:：]?\s*(\d{1,6})", t) \
        or re.search(r"(\d{1,6})\s*(?:套|个|件|台|只|pcs)", t, re.I)
    if m_qty:
        params["quantity"] = int(m_qty.group(1))
    due = _parse_due_date(t)
    if due:
        params["deliveryDate"] = due
    m_lvl = re.search(r"\b(VIP)\b|([甲乙丙])类?客户|等级\s*([ABC])", t, re.I)
    if m_lvl:
        key = (m_lvl.group(1) or m_lvl.group(2) or m_lvl.group(3) or "").upper()
        if key in _LEVEL_MAP:
            params["customerLevel"] = _LEVEL_MAP[key]
    if re.search(r"加急|插单|紧急|急单", t):
        params["isRush"] = True
    return params


def _work_dir_has_tables() -> bool:
    """任一工程项目目录下已有 Excel/CSV → 开排优先走目录导入。"""
    try:
        import os
        from server.state.projects import get_project_store
        snap = get_project_store().snapshot(include_messages=False)
    except Exception:
        return False
    for p in snap.get("projects") or []:
        if not isinstance(p, dict):
            continue
        work = str(p.get("workDir") or "").strip()
        if not work or not os.path.isdir(work):
            continue
        try:
            names = os.listdir(work)
        except OSError:
            continue
        if any(
            (
                re.search(r"\.(xlsx|xlsm|csv|txt|sql)$", n, re.I)
                and not n.startswith("~$") and not n.startswith(".")
            )
            for n in names
        ):
            return True
    return False


def _is_imperative_schedule(text: str) -> bool:
    """用户明确要求「现在就排」，不是问概念/向导。"""
    t = (text or "").strip()
    if re.search(r"什么叫|什么是|啥叫|怎么排|如何排|会不会|能不能排产吗|向导", t):
        return False
    return bool(re.search(
        r"^(给我|帮我|为我|请|麻烦).{0,6}(模拟|试)?排(产|程)?(一下|一版)?[!！。.~～]*$"
        r"|^(我要你|你给我|你帮我|要你).{0,6}(模拟|试)?排(产|程)?(一下|一版)?[!！。.~～]*$"
        r"|^排产(吧|啊|呀|啦|！|!)?(一下|一版)?$"
        r"|^(开始|马上|赶紧|直接).{0,4}(给我|帮我)?(模拟|试)?排(产|程)?(一下|一版)?[!！。.~～]*$"
        r"|^(排一下|开排|开干(排产)?|去排产|模拟排产(一下)?|(试|模拟)排(一版|一下)?)[!！。.~～]*$"
        r"|我要你排产|给我排产|你给我排产|帮我排产吧|模拟排产一下|帮我模拟排产|给我模拟排产",
        t,
    ))


# ---------------- 一级：规则快路（移植 POC parseNL，P0 纯解析） ----------------
def parse_fast(text: str, world: World) -> IntentResult | None:
    """正则词表快路：命中返回高置信意图；未命中返回 None（交给 LLM）。"""
    t = text.strip()                                   # 去除首尾空白

    # 快路辅助：构造高置信结果（来源标注 RULE_FAST）
    def hit(intent: str, params: dict | None = None) -> IntentResult:
        return IntentResult(intent=intent, params=params or {}, confidence=0.95, source="RULE_FAST")

    if re.search(r"重置数据|清空数据|重新初始化", t):       # 数据重置
        return hit("data.reset")
    # 工程图纸：仅命中明确的 DXF/图纸解析、预览或主数据映射表达。
    drawing_path = re.search(r"([A-Za-z]:[\\/][^\n\r\"']+?\.dxf)\b", t, re.I)
    if re.search(r"(?:DXF|图纸)", t, re.I):
        params = {"query": t}
        if drawing_path:
            params["path"] = drawing_path.group(1)
        if re.search(r"预览|可视化|打开|查看", t):
            params["drawingAction"] = "preview"
            return hit("data.analyze", params)
        if re.search(r"映射|转成|生成|写入|入库|物料|BOM|工艺", t, re.I):
            params["drawingAction"] = "stage"
            return hit("data.analyze", params)
        if re.search(r"解析|分析|识别|读取|扫描", t):
            params["drawingAction"] = "analyze"
            return hit("data.analyze", params)
    # 带真实表格/SQL 路径的口令优先按数据处理，不能被句尾「知识库」误吞。
    has_data_path = bool(re.search(r"[A-Za-z]:[\\/].*\.(xlsx|xlsm|csv|txt|sql)\b", t, re.I))
    if has_data_path and re.search(r"排产|试排|开排", t):
        return hit("folder.schedule", {"query": t})
    if has_data_path and re.search(r"解析|分析|读取|识别|导入|入库|主数据|知识库", t):
        return hit("data.analyze", {"query": t})
    # 工程目录：深度解析 / 按目录数据排产（靠前）
    if re.search(
        r"根据.{0,16}排产|用.{0,8}(目录|文件夹|这些数据).{0,8}排产"
        r"|以上数据|这些(数据|文件|表格).{0,12}排|按(上面|这些|目录).{0,8}排"
        r"|导入.{0,6}(目录|文件夹).{0,6}(并)?(试)?排",
        t,
    ):
        return hit("folder.schedule", {"query": t})
    if re.search(
        r"文件夹|工程目录|工作目录|"
        r"项目(里|里面|内)(的)?(文件|数据|资料)|项目(文件夹|目录)|"
        r"解析.{0,8}(文件夹|目录)|"
        r"读取.{0,6}(文件夹|目录)|分析.{0,6}(文件夹|目录)|再解析.*目录|重新解析.*目录",
        t, re.I,
    ):
        return hit("folder.analyze", {"query": t})

    # —— 明确「开排」祈使句：直接干，禁止再甩四选一菜单 ——
    # 有工程目录表格 → 按目录导入试排；否则直接柔性排一版
    if _is_imperative_schedule(t):
        if _work_dir_has_tables():
            return hit("folder.schedule", {"query": t})
        return hit("flex.schedule", {"sortMode": "BOTTLENECK", "query": t})
    # 小白引导（怎么排 / 不会排）才进向导；「我要排产」保留向导兼容
    if re.search(
        r"怎么排产|排产向导|带我排(一版|产)?|教我排|一步步排|"
        r"不(会|懂)排产|第一次排产|从头排产|^我要排产$",
        t,
    ):
        return hit("schedule.wizard")
    if re.search(r"直接排(一版|产)?|赶紧排|马上排|帮我排一下", t):
        return hit("flex.schedule", {"sortMode": "BOTTLENECK"})

    # 问候 / 几点了 / 概念 / 能力 → 通用助理（什么都能问）
    if re.search(r"^(你好|您好|嗨|hi|hello|在吗)[\s!！.。？?]*$", t, re.I) \
            or re.search(r"(现在|当前)?(几点|几时了)|几点了|今天(几号|日期|星期几)|现在是几号", t) \
            or re.search(r"你是谁|你能做什么|怎么用|如何使用|介绍一下(你自己|系统|助手)?|你会什么", t) \
            or re.search(r"(什么叫|什么是|啥叫|解释).{0,8}排产|排产.{0,4}(什么意思|是什么|啥意思)|你会排产|会不会排产", t) \
            or re.search(r"讲个笑话|来个笑话|算一下|\d+\s+[+\-*/×÷]\s+\d+", t):  # 须空格，勿匹配交期 2026-08
        return hit("assistant.reply", {"query": t})
    # 闲聊 / 发牢骚（勿用「带我/教我」抢排产口令）
    if re.search(
        r"天气|下雨|吃饭|午饭|晚饭|累了|无聊|哈哈|呵呵|讲个笑话|"
        r"上班好烦|不想干|摸鱼|咋整|怎么办啊",
        t, re.I,
    ) and not re.search(r"排产|排程|试排|排一版", t):
        return hit("assistant.reply", {"query": t})
    # 开放式项目/现状问答（先于过宽的 KPI「怎么样」）
    if re.search(
        r"(现在|当前|项目).{0,6}(怎么样|什么情况|进度|状态|有什么数据)"
        r"|帮我看看|看看(现在|当前|项目)|解释一下|总结一下|现状"
        r"|不知道(该|怎么)|该怎么(办|做|开始)|从哪(里)?开始"
        r"|能不能排|随便问问|跟你聊聊",
        t,
    ):
        return hit("assistant.reply", {"query": t})
    # 分析项目/文件/数据（靠前：避免落到 unknown + 能力清单）
    if re.search(
        r"【文件解析】|我已提供主数据材料"
        r"|分析.{0,16}(文件|数据|项目|excel|表格|内容|附件)"
        r"|(这个|该|此).{0,4}文件|文件里面|项目数据|数据内容"
        r"|整理.{0,8}(数据|缺口)|排产还缺什么|还缺什么.*排产",
        t, re.I,
    ):
        return hit("data.analyze", {"query": t})
    # MES 下发须先于泛化「下发」（否则「下发MES」会误进 schedule.publish）
    if re.search(r"下发\s*MES|下发车间|MES\s*下发|推送车间", t, re.I):
        tr = "fixed" if re.search(r"固定", t) else "flex"
        return hit("mes.dispatch", {"track": tr})
    if re.search(r"模拟报工|报工回流|工序报工|完工报工", t, re.I):
        p: dict = {"track": "fixed" if re.search(r"固定", t) else "flex"}
        if re.search(r"全部|一键|批量", t):
            p["finishAll"] = True
        m_wo = re.search(r"(?:工单|#)\s*(\d+)", t)
        if m_wo:
            p["woId"] = int(m_wo.group(1))
        if re.search(r"完工|100|完成", t):
            p["finish"] = True
        return hit("mes.report", p)
    if re.search(r"MES\s*状态|车间系统状态|执行进度", t, re.I):
        return hit("mes.status")
    if re.search(r"发布|下发", t):                          # 发布版本（P2；MES 下发已在上方拦截）
        return hit("schedule.publish")
    # 批量导入（须先于单条新建：含「导入订单/物料」）
    kind = None
    from server.aps_domain.intake import detect_import_kind
    kind = detect_import_kind(t)
    if kind:
        return hit("data.import", {"kind": kind, "text": t})
    # 删除订单（物理移除；与「取消」区分）
    m_order_del = re.search(r"(删除|删掉|移除).{0,6}(订单)?\s*(SO\d{6,})", t, re.I)
    if m_order_del:
        return hit("order.delete", {"orderNo": m_order_del.group(3).upper()})
    # OR-03 订单池审核
    if re.search(r"批量批准|全部批准待审|批准全部待审", t):
        return hit("order.approve", {"orderIds": "pending"})
    m_ap = re.search(r"(批准|通过审核|审核通过)\s*(订单)?\s*(SO\d{6,})", t, re.I)
    if m_ap:
        return hit("order.approve", {"orderNo": m_ap.group(3).upper()})
    m_rj = re.search(r"(驳回|拒绝)\s*(订单)?\s*(SO\d{6,})", t, re.I)
    if m_rj:
        p = {"orderNo": m_rj.group(3).upper()}
        m_note = re.search(r"原因[:：\s]+(.+)$", t)
        if m_note:
            p["reviewNote"] = m_note.group(1).strip()
        return hit("order.reject", p)
    m_sub = re.search(r"(提交审核|送审|提交)\s*(订单)?\s*(SO\d{6,})", t, re.I)
    if m_sub:
        return hit("order.submit", {"orderNo": m_sub.group(3).upper()})
    if re.search(r"提交审核|送审", t) and re.search(r"订单", t):
        return hit("order.submit", {})
    if re.search(r"订单池|待审核订单|订单看板", t):
        return hit("order.pool")
    # 一键清理订单池 / 主数据板块
    if re.search(r"(一键)?(清理|清空|清除).{0,6}(全部)?(销售)?订单|清空订单池", t):
        return hit("order.clear")
    if re.search(r"(一键)?(清理|清空|清除).{0,8}(主数据|工艺模型|物料|维保|产线资源)", t):
        scope = ("process" if re.search(r"工艺|物料|BOM|工序|路线", t)
                 else "calendar" if re.search(r"维保|日历", t)
                 else "resource" if re.search(r"资源|产线", t)
                 else "all")
        return hit("master.clear", {"scope": scope})
    m_order_cancel = re.search(r"(取消|作废).{0,6}(订单)?\s*(SO\d{8,}\d*)", t, re.I)
    if m_order_cancel:
        return hit("order.cancel", {"orderNo": m_order_cancel.group(3).upper()})
    m_order_done = re.search(r"(完成|完结|关闭).{0,6}(订单)?\s*(SO\d{8,}\d*)", t, re.I)
    if m_order_done:
        return hit("order.complete", {"orderNo": m_order_done.group(3).upper()})
    # 委外/采购建议问答（须先于下达/分解动作与泛化查数）
    if re.search(r"委外|外协|采购建议|分解建议", t) and not re.search(
        r"下达|确认下达|正式下单|转正式|生成(采购|委外)建议|订单分解|分解(全部|所有)?订单|展开\s*BOM", t, re.I
    ):
        from server.aps_domain.master_query import extract_code, _mrp_aspect
        code = extract_code(t)
        params: dict = {"entity": "mrp", "query": t, "aspect": _mrp_aspect(t)}
        if code:
            params["code"] = code
        elif re.search(r"(这个|该|此|本).{0,4}订单|订单.{0,6}(有没有|有无|有|吗)", t):
            params["orderRef"] = "last"
        return hit("master.query", params)
    # 订单分解（MRP）：分解订单 SOxxx / 订单分解 / 生成采购建议 / 展开 BOM
    m_decomp = re.search(r"(分解|展开).{0,6}(订单)?\s*(SO\d{8,}\d*)", t, re.I)
    if m_decomp:
        return hit("order.decompose", {"orderNo": m_decomp.group(3).upper()})
    if re.search(r"(下达|确认下达|正式下单|转正式).{0,6}(采购|委外|建议单?|MRP)|把.{0,8}建议.{0,4}下达|建议单下达", t, re.I):
        kind_mrp = ("purchase" if re.search(r"采购", t) and not re.search(r"委外", t)
                else "outsource" if re.search(r"委外", t) and not re.search(r"采购", t)
                else "all")
        m_no = re.search(r"(SO\d{6,})", t, re.I)
        p: dict = {"kind": kind_mrp}
        if m_no:
            p["orderNo"] = m_no.group(1).upper()
        return hit("mrp.release", p)
    # 计划追溯 / 订单钉扎（OR-06）：固定 SO 或柔性 FO
    if re.search(r"追溯|钉扎|排产依据|怎么排的|从哪排|单据链|看(一下)?(订单)?依据|(BOM|库存|负荷).{0,6}(追溯|依据)|订单.{0,4}(追溯|依据|钉扎)", t, re.I):
        m_no = re.search(r"(SO\d{6,}|FO-[\w-]+|RUSH-\d+)", t, re.I)
        params: dict = {}
        if m_no:
            params["orderNo"] = m_no.group(1).upper()
        if re.search(r"柔性|钉扎|FO-|虚拟产线", t, re.I) or (params.get("orderNo") or "").startswith(("FO-", "RUSH-")):
            params["track"] = "flex"
        elif re.search(r"固定|销售订单", t):
            params["track"] = "fixed"
        return hit("plan.trace", params)
    if re.search(r"订单分解|分解(全部|所有)?订单|生成(采购|委外)建议|展开\s*BOM|物料需求(计划|分解)|MRP", t, re.I):
        return hit("order.decompose")
    # 新建物料（主数据对话录入）
    if re.search(r"(新建|新增|创建|录入).{0,4}物料|加一?个?(原料|成品|半成品)", t):
        from server.aps_domain.intake import parse_material_slots
        return hit("master.material.upsert", parse_material_slots(t))
    # MD-06 换型矩阵
    if re.search(r"查看换型|换型矩阵|产品族换型|打开换型", t):
        return hit("changeover.query")
    m_co = re.search(
        r"(设置|录入|修改|更新)?换型\s*([A-Za-z0-9_-]+)\s*(到|→|->|至)\s*([A-Za-z0-9_-]+)\s*(\d+(?:\.\d+)?)\s*分?",
        t, re.I,
    )
    if m_co:
        return hit("master.changeover.upsert", {
            "fromFamily": m_co.group(2).upper(),
            "toFamily": m_co.group(4).upper(),
            "setupMinutes": float(m_co.group(5)),
        })
    # 主数据/订单只读检索（实例数据；工艺模式/模板走知识库）
    if not re.search(r"模式|模板|怎么生成|总则|车削|铣削|磨削|特征驱动|知识清单", t) and (
        re.search(r"(查|查看|看看|检索|有哪些|列出|查询).{0,8}(订单|物料|成品|原料|工序|BOM|物料清单|工艺路线|主数据|柔性资源|能力池)|主数据概览|订单池里有什么|现在有哪些订单", t, re.I)
        or re.search(r"查(一下)?\s*(订单|物料|BOM|工艺路线|工序)\s*[\w\-]{4,}", t)
    ):
        from server.aps_domain.master_query import detect_entity, extract_code
        ent = detect_entity(t)
        code = extract_code(t)
        params: dict = {"entity": ent, "query": t}
        if code:
            params["code"] = code
        return hit("master.query", params)
    # M-F 引导式排产向导（靠前入口已覆盖；此处兜底小白说法）
    if re.search(r"^我要排产$|怎么排产|排产向导|不(会|懂)排产|第一次排产|从头排产", t):
        return hit("schedule.wizard")
    # 「帮我排产」等祈使句已在上方走 flex/folder；此处勿再抢
    # 现场完整生产路线导入（须先于泛化「柔性排产」）
    if re.search(r"加载现场(生产)?(订单)?路线|导入完整生产路线|加载现场订单|替换柔性演示|现场数据导入", t):
        p: dict = {}
        if re.search(r"仅主单|只要主单|不带其它", t):
            p["includeSiblings"] = False
        return hit("flex.site.load", p)
    # 新建/编辑订单（order.upsert，P2）：动词 + "订单"；尽力抽取槽位，缺失由 handler 追问
    if re.search(r"(新建|新增|创建|录入|下|加|新来|来).{0,4}(一?[张个笔条])?\s*(销售)?订单|录单|建单|开一?张单", t) \
            or re.search(r"(修改|编辑|更新|改).{0,4}(销售)?订单\s*(SO\d{6,})", t, re.I):
        return hit("order.upsert", _order_upsert_slots(t, world))
    # IND-02 SOP→约束（须在知识库问答之前，避免「SOP」只走 knowledge.query）
    if re.search(r"应用.{0,8}(SOP|规则包)|把.{0,12}(SOP|规则).{0,8}(应用|落地|写入约束)", t, re.I):
        q = "换线"
        if re.search(r"齐套|库存|缺料", t):
            q = "齐套"
        elif re.search(r"插单|急单", t):
            q = "插单"
        elif re.search(r"换线|换型", t):
            q = "换线"
        m_t = re.search(r"[《「]?([\u4e00-\u9fffA-Za-z0-9\-_]{2,24}SOP)[》」]?", t)
        if m_t:
            q = m_t.group(1)
        return hit("sop.apply", {"query": q})
    if re.search(r"编译.{0,6}(SOP|规则)|SOP.{0,6}(编译|转约束|规则包)|把.{0,8}SOP.{0,8}(编译|转成约束)", t, re.I):
        q = "换线"
        if re.search(r"齐套|库存|缺料", t):
            q = "齐套"
        elif re.search(r"插单|急单", t):
            q = "插单"
        elif re.search(r"换线|换型", t):
            q = "换线"
        return hit("sop.compile", {"query": q})
    # SC-06 敏感性分析（须在方案对比之前，避免「对比参数」误触）
    if re.search(r"敏感性|敏感度|Tornado|龙卷风图|参数扰动|主控参数分析", t, re.I):
        params: dict[str, Any] = {}
        if re.search(r"交期优先", t):
            params["strategy"] = "DELIVERY_FIRST"
        elif re.search(r"均衡", t):
            params["strategy"] = "CAPACITY_BALANCE"
        elif re.search(r"换型", t):
            params["strategy"] = "CHANGEOVER_MIN"
        elif re.search(r"战役|批次", t):
            params["strategy"] = "CAMPAIGN"
        return hit("scenario.sensitivity", params)
    # 方案对比：多方案/多策略/对比几种策略/对比一下（Explore 沙盒 §5.1）
    if re.search(r"多方案|多策略|方案对比|(对比|比较).{0,8}(策略|方案|排法)|对比一下|三种策略|沙盒对比", t):
        return hit("scenario.compare")
    # 报告生成（M3 §9.10）：日报 / 版本对比 / 排产方案
    if re.search(r"排产方案报告|排产报告|方案报告|下载排产|导出排产|生成排产方案|下载方案报告", t):
        from server.aps_domain.master_query import extract_code
        params: dict = {"reportType": "plan"}
        code = extract_code(t)
        if code:
            params["orderNo"] = code
        elif re.search(r"(这个|该|此|本).{0,4}订单|本单|当前订单", t):
            params["orderRef"] = "last"
        return hit("report.generate", params)
    if re.search(r"(生成|出|来一份|写)?(排产)?日报", t) and re.search(r"日报", t):
        return hit("report.generate", {"reportType": "daily"})
    if re.search(r"版本对比|对比报告|新旧版本", t) and re.search(r"报告|对比", t):
        return hit("report.generate", {"reportType": "version-diff"})
    # RAG：导入知识文档（须在知识问答之前，避免「知识」抢答）
    m_imp = re.search(
        r"(?:导入|加载|入库).{0,6}知识(文档|文件|资料)?\s*(.+)?$|知识(文档|文件).{0,6}(导入|入库)\s*(.+)?$",
        t, re.I)
    if m_imp or re.search(r"^导入知识", t):
        path = None
        m_path = re.search(r"([A-Za-z]:[\\/][^\s\"']+\.\w{1,8}|/[^\s\"']+\.\w{1,8})", t)
        if m_path:
            path = m_path.group(1).strip().rstrip("。，,")
        else:
            # 取「导入知识文档」后的路径片段
            m2 = re.search(r"导入知识(?:文档|文件|资料)?\s+(.+)$", t)
            if m2:
                path = m2.group(1).strip().rstrip("。，,")
        kind = "sop"
        if re.search(r"工艺", t):
            kind = "process"
        elif re.search(r"算法", t):
            kind = "algorithm"
        elif re.search(r"案例", t):
            kind = "case"
        return hit("knowledge.import", {"path": path, "kind": kind, "query": t})
    # 外部算法 Skill（须在知识问答 / 柔性排产之前）
    if re.search(r"(查看|列出|有哪些).{0,6}(算法\s*)?(skill|技能)|已接入算法|算法\s*skill\s*清单|查看已接入算法", t, re.I):
        return hit("skill.list")
    if re.search(r"(skill|算法).{0,6}健康检查|健康检查.{0,6}(skill|算法)|检查算法(服务|skill)", t, re.I):
        # 仅接受 ASCII skill id（algo.xxx 或 skillId=xxx），避免「健康检查」中文被 \w 吞掉
        m_sid = re.search(r"(?:skill[_ ]?id|skill)\s*[=:：\s]+(algo\.[A-Za-z0-9._-]+|[A-Za-z][A-Za-z0-9._-]*)", t, re.I)
        if not m_sid:
            m_sid = re.search(r"(algo\.[A-Za-z0-9._-]+)", t, re.I)
        sid = m_sid.group(1) if m_sid else None
        return hit("skill.health", {"skillId": sid} if sid else {})
    if re.search(r"登记(算法)?\s*skill|注册(算法)?\s*skill|接入(算法|外部算法)", t, re.I):
        params: dict[str, Any] = {}
        m_id = re.search(r"(?:id|skill[_]?id)\s*[=:：]\s*([\w.-]+)", t, re.I)
        m_ep = re.search(r"(?:endpoint|url|端点)\s*[=:：]\s*(\S+)", t, re.I)
        m_name = re.search(r"(?:name|名称)\s*[=:：]\s*(\S+)", t, re.I)
        if m_id:
            params["skill_id"] = m_id.group(1)
        if m_ep:
            params["endpoint"] = m_ep.group(1).rstrip("，,。")
        if m_name:
            params["name"] = m_name.group(1)
        if re.search(r"固定轨|fixed", t, re.I):
            params["track"] = "fixed"
        else:
            params["track"] = "flex"
        return hit("skill.register", params)
    if re.search(r"(启用|开启|打开|停用|禁用|关闭)\s*(算法\s*)?skill", t, re.I):
        enabled = not bool(re.search(r"停用|禁用|关闭", t))
        m_sid = re.search(r"skill\s+(algo\.[A-Za-z0-9._-]+|[A-Za-z][A-Za-z0-9._-]*)", t, re.I)
        sid = m_sid.group(1) if m_sid else None
        return hit("skill.enable", {"skillId": sid, "enabled": enabled, "query": t})
    if re.search(r"用外部算法(试排|排产)|外部算法试排|切换算法\s*skill|走外部(算法|skill)排产", t, re.I):
        params: dict[str, Any] = {"sortMode": "BOTTLENECK", "engine": "EXTERNAL", "useExternal": True}
        m_sid = re.search(r"(?:skill|算法)\s+(algo\.[A-Za-z0-9._-]+)", t, re.I)
        if not m_sid:
            m_sid = re.search(r"(algo\.[A-Za-z0-9._-]+)", t, re.I)
        if m_sid:
            params["skillId"] = m_sid.group(1)
        return hit("flex.schedule", params)
    # M-B 数据齐备度 / 工时维护（须在知识问答之前，避免「工时」被吞）
    if re.search(r"工时(维护)?情况|哪些工时(还)?(没|未|待)维护|工时(缺失|齐不齐|完整吗)"
                 r"|数据(齐备|完整)度|排产数据(检查|齐不齐|够不够)|readiness", t, re.I):
        return hit("readiness.query")
    m_time = re.search(r"把\s*(\S{1,24}?)\s*(?:的)?工时(?:改|设|调)(?:成|为|到)?\s*(\d+(?:\.\d+)?)\s*分钟?", t)
    if m_time:
        target = m_time.group(1).strip()
        params_t: dict[str, Any] = {"stdMin": float(m_time.group(2)), "operationCode": target}
        # 「把产品X的部装工时…」形态：产品 空格/的 工序
        m_pc = re.search(r"把\s*([A-Za-z0-9\-]{4,})\s+(\S{1,16}?)\s*(?:的)?工时", t)
        if m_pc:
            params_t = {"stdMin": float(m_time.group(2)),
                        "productCode": m_pc.group(1), "operationCode": m_pc.group(2)}
        return hit("flex.time.update", params_t)
    # 知识库检索（M3 §8.2）：@知识 引用 / 明确问规定与 SOP
    m_kn = re.search(r"@知识[:：]\s*(\S{1,24})", t)
    if m_kn:
        return hit("knowledge.query", {"query": m_kn.group(1), "assetTitle": m_kn.group(1)})
    if re.search(r"有什么规定|什么规定|规定是什么|SOP|标准是什么|审批流程|知识库"
                 r"|机加工|工艺路线生成|工艺路线模式|工艺模式|车削工艺|铣削|磨削|装配工艺"
                 r"|特征驱动|工艺怎么(生成|排)|知识清单|有哪些知识|城轨机构装配路线", t, re.I):
        return hit("knowledge.query", {"query": t})
    # 回滚到指定检查点（时间线导轨点击会合成此口令；ID 为 10 位十六进制）
    m_rb = re.search(r"回滚到检查点\s*([0-9a-f]{6,12})", t, re.I)
    if m_rb:
        return hit("checkpoint.rollback", {"pairId": m_rb.group(1)})
    # 回滚到最近检查点（口语形态）
    if re.search(r"回滚|回到上一?个?(检查点|存档|快照)", t):
        return hit("checkpoint.rollback")
    # 手动建档：存档/存个档/检查点/快照（可带名字："存档 叫 发布前基线"）
    m_ck = re.search(r"(存个?档|建一?个?检查点|打个?快照)(?:[，,\s]*(?:叫|为|名字是)?\s*(.{1,16}))?$", t)
    if m_ck and re.search(r"存个?档|检查点|快照", t):
        label = (m_ck.group(2) or "").strip()          # 提取可选命名
        return hit("checkpoint.create", {"label": label} if label else {})
    if re.search(r"MES\s*状态|车间系统状态|执行进度", t, re.I):
        return hit("mes.status")
    # SAP 集成（MD-05）
    if re.search(r"回写\s*SAP|完工回写|推送\s*SAP|出站同步", t, re.I):
        return hit("sap.sync.outbound")
    if re.search(r"从\s*SAP\s*拉|同步\s*SAP|拉\s*SAP|入站同步|同步库存|SAP\s*拉单", t, re.I):
        return hit("sap.sync.inbound")
    if re.search(r"SAP\s*状态|SAP\s*连接|集成状态", t, re.I):
        return hit("sap.status")
    # 冲突中心 / 修复（EX-03）
    if re.search(r"解决冲突|修复冲突|一键修复|处理冲突", t):
        m_id = re.search(r"#?\s*(\d+)", t)
        return hit("flex.conflict.resolve",
                   {"conflictId": int(m_id.group(1))} if m_id else {})
    if re.search(r"查看冲突|冲突中心|有哪些冲突|冲突列表|看冲突", t):
        scope = ("all" if re.search(r"全部|所有", t)
                 else "fixed" if re.search(r"固定", t) else "flex")
        return hit("conflict.list", {"scope": scope})
    # L1 局部换机须先于故障口令（同含设备码）
    if re.search(r"局部换机|L1\s*换机|备机接手|换到备机|换机\s*(PRESS|WELD|CUT|TEST|LEAK)", t, re.I):
        code = "PRESS-01"
        m_code = re.search(r"(PRESS|WELD|CUT|TEST|LEAK)-\d+", t, re.I)
        if m_code:
            code = m_code.group(0).upper()
        mark = not bool(re.search(r"不标故障|仅换机", t))
        return hit("flex.swap", {"equipmentCode": code, "markFault": mark})
    # 分级重排须先于普通柔性排产
    if re.search(r"短窗重排|日窗重排|局部重排|分级重排|窗内重排|L2重排|L3重排|L4重排", t, re.I):
        level = ("L4" if re.search(r"L4|全局", t, re.I)
                 else "L3" if re.search(r"L3|日窗|中窗|2\s*天", t, re.I)
                 else "L2")
        return hit("flex.reschedule", {"level": level})
    # 三模式对比须先于「正排/倒排」单模式排产
    if re.search(r"三模式|正倒排对比|模式对比|(对比|比较).{0,6}(正排|倒排|瓶颈)", t):
        return hit("flex.compare")
    # 设备故障 / 恢复（DY-01）
    if re.search(r"设备故障|恢复设备|设备.{0,8}(故障|坏了|宕机|停机|恢复)|(PRESS|WELD)-\d+.{0,6}(故障|停机|恢复)", t, re.I):
        status = "RUNNING" if re.search(r"恢复|修好|上线", t) else "MAINTENANCE"
        code = "WELD-01" if re.search(r"焊接|激光|WELD", t, re.I) else "PRESS-01"
        m_code = re.search(r"(PRESS|WELD|CUT|TEST|LEAK)-\d+", t, re.I)
        if m_code:
            code = m_code.group(0).upper()
        return hit("flex.fault", {"equipmentCode": code, "status": status})
    # 柔性紧急插单（DY-01）：须带「柔性」以免与 OR-04 固定轨插单冲突
    if re.search(r"柔性\s*(紧急)?插单|柔性急单", t):
        code = "PDU-UNIT" if re.search(r"PDU", t, re.I) else "HV-HARNESS"
        qty_m = re.search(r"(\d+)\s*(套|件|个)", t)
        qty = int(qty_m.group(1)) if qty_m else 50
        return hit("flex.rush", {"productCode": code, "quantity": qty, "priority": 1})
    # OR-04 固定轨紧急插单：采用 / 快评
    if re.search(r"采用插单|确认采用插单|应用插单|插单采用", t):
        return hit("rush.apply")
    if re.search(r"插单快评|评估插单|插单影响|紧急插单评估|插单评估", t) or (
        re.search(r"紧急插单|加急插单|插一?[张个]?急单", t) and not re.search(r"柔性", t)
    ):
        params: dict[str, Any] = {}
        m_so = re.search(r"(SO\d{8,})", t, re.I)
        if m_so:
            params["orderNo"] = m_so.group(1).upper()
        qty_m = re.search(r"(\d+)\s*(套|件|个)", t)
        if qty_m:
            params["quantity"] = int(qty_m.group(1))
        if not params.get("orderNo"):
            if re.search(r"控制器A|A型|CTRL-A", t, re.I):
                params["productCode"] = "CTRL-A"
            elif re.search(r"控制器B|B型|CTRL-B", t, re.I):
                params["productCode"] = "CTRL-B"
            elif re.search(r"控制器C|C型|CTRL-C", t, re.I):
                params["productCode"] = "CTRL-C"
            else:
                params.setdefault("productCode", "CTRL-A")
        if re.search(r"交期优先", t):
            params["strategy"] = "DELIVERY_FIRST"
        elif re.search(r"产能均衡|均衡", t):
            params["strategy"] = "CAPACITY_BALANCE"
        m_cust = re.search(r"(?:给|为|客户)\s*([^\s，,。]{2,12})", t)
        if m_cust and m_cust.group(1) not in ("插单", "急单", "订单"):
            params["customerName"] = m_cust.group(1)
        return hit("rush.evaluate", params)
    # 把这个订单排产 / 给订单xxx做计划排产（须先于泛化「柔性排产」「试排」）
    if re.search(r"排产", t) and not re.search(r"查|查看|有哪些|插单|分解|追溯|发布", t) and (
        re.search(r"(这个|该|此|本).{0,4}订单|(给|把|对).{0,8}订单|订单\s*[\dA-Za-z\-]{5,}.{0,12}排产|计划排产", t)
    ):
        from server.aps_domain.master_query import extract_code
        code = extract_code(t)
        # 现场/柔性订单优先走能力池排产
        has_flex = bool(world.get("flexOrders"))
        params: dict = {"sortMode": "BOTTLENECK"}
        if code:
            params["orderNo"] = code
        else:
            params["orderRef"] = "last"
        if has_flex or re.search(r"柔性|能力池|虚拟产线", t):
            return hit("flex.schedule", params)
        # 仅固定轨时走规则试排
        return hit("schedule.run", params)
    # 柔性排产（能力池 + 虚拟产线）：须在固定产线 schedule.run 之前判定
    if re.search(r"柔性排产|柔性排一?版|能力池排产|按能力池|虚拟产线|多品种小批量"
                 r"|全流程排产|走一?个?全流程|正排|顺排|倒排|逆排|瓶颈锚|滚动排产|短窗排产|中窗排产"
                 r"|实时排产|分钟级排产", t):
        mode = ("ASC" if re.search(r"正排|顺排", t)
                else "DESC" if re.search(r"倒排|逆排", t)
                else "BOTTLENECK")
        win = ("realtime" if re.search(r"实时|分钟级", t)
               else "short" if re.search(r"短窗", t)
               else "mid" if re.search(r"中窗|日窗|2\s*天", t)
               else "long" if re.search(r"长窗|周窗|7\s*天", t)
               else "full" if re.search(r"全量|全窗", t)
               else None)
        params: dict = {"sortMode": mode}
        if win:
            params["window"] = win
        elif re.search(r"滚动", t):
            params["window"] = "short"
        return hit("flex.schedule", params)
    # 瓶颈产能评估（瓶颈产能法）
    if re.search(r"瓶颈产能|产能池|产能评估|各?工序产能|瓶颈在哪|产能瓶颈|能做多少|日产能", t):
        return hit("flex.capacity")
    # 交期承诺模拟：问「何时/多久能交/做完」+ 产品 + 数量
    m_prod = re.search(r"(高压线束|线束|PDU|HV-?HARNESS|PDU-?UNIT)", t, re.I)
    m_qty = re.search(r"(\d{1,6})\s*(套|个|件|pcs)?", t, re.I)
    if (re.search(r"(什么时候|多久|何时|几天).{0,6}(能|可以)?.{0,2}(交|交货|完成|做完|下线|出货)|交期(承诺|模拟|评估)|能不能按期",
                  t) and m_prod and m_qty):
        code = "PDU-UNIT" if re.search(r"PDU", t, re.I) else "HV-HARNESS"
        return hit("flex.simulate_due", {"productCode": code, "quantity": int(m_qty.group(1))})
    # OR-05 预测订单（须在 schedule.run 之前）
    if re.search(r"预测转正|转正预测", t):
        m_fc = re.search(r"(FC\d{8,})", t, re.I)
        return hit("forecast.convert", {"forecastNo": m_fc.group(1).upper()} if m_fc else {})
    if re.search(r"删除预测|去掉预测", t):
        m_fc = re.search(r"(FC\d{8,})", t, re.I)
        return hit("forecast.delete", {"forecastNo": m_fc.group(1).upper()} if m_fc else {})
    if re.search(r"新建预测|创建预测|加一?[条个]?预测", t):
        params: dict[str, Any] = {"status": "ACTIVE", "bucket": "WEEK"}
        qty_m = re.search(r"(\d+)\s*(套|件|个)", t)
        if qty_m:
            params["quantity"] = int(qty_m.group(1))
        if re.search(r"控制器A|CTRL-A", t, re.I):
            params["productCode"] = "CTRL-A"
        elif re.search(r"控制器B|CTRL-B", t, re.I):
            params["productCode"] = "CTRL-B"
        elif re.search(r"控制器C|CTRL-C", t, re.I):
            params["productCode"] = "CTRL-C"
        else:
            params["productCode"] = "CTRL-A"
        if re.search(r"月", t):
            params["bucket"] = "MONTH"
        elif re.search(r"日|天", t):
            params["bucket"] = "DAY"
        return hit("forecast.upsert", params)
    if re.search(r"预测订单|查看预测|长周期(订单|需求)|预测需求|预测台账", t):
        return hit("forecast.query")
    # PL-06 产供方向（先于削峰通用口令，避免「外协建议」落到 MRP）
    if re.search(r"产供(方向|决策)?|产能决策|加班建议|扩线建议|外协建议|外协产能|打开产供", t):
        params: dict[str, Any] = {"mode": "WEEK", "includeForecast": True, "targetLoad": 0.85}
        if re.search(r"混合", t):
            params["mode"] = "HYBRID"
        elif re.search(r"月", t):
            params["mode"] = "MONTH"
        elif re.search(r"日|天", t):
            params["mode"] = "DAY"
        if re.search(r"不含预测|不要预测|仅确定", t):
            params["includeForecast"] = False
        return hit("plan.supply", params)
    # PL-05 产能平衡/削峰（须在「产能均衡试排」之前；勿抢 schedule.run）
    if re.search(r"削峰|产能平衡|负荷削峰|计划层均衡|平衡负荷|打开削峰|leveling", t, re.I):
        params: dict[str, Any] = {"mode": "WEEK", "includeForecast": True, "targetLoad": 0.85}
        if re.search(r"混合", t):
            params["mode"] = "HYBRID"
        elif re.search(r"月", t):
            params["mode"] = "MONTH"
        elif re.search(r"日|天", t):
            params["mode"] = "DAY"
        elif re.search(r"周", t):
            params["mode"] = "WEEK"
        if re.search(r"不含预测|不要预测|仅确定", t):
            params["includeForecast"] = False
        return hit("plan.leveling", params)
    # PL-04 库存投影
    if re.search(r"库存投影|库存曲线|投影库存|物料库存投影|打开库存投影", t):
        params: dict[str, Any] = {"includeForecast": True, "bucket": "DAY", "horizonDays": 30}
        if re.search(r"按周|周投影|周桶", t):
            params["bucket"] = "WEEK"
        if re.search(r"原料|原材料", t):
            params["materialType"] = "RAW_MATERIAL"
        elif re.search(r"成品", t):
            params["materialType"] = "FINISHED_PRODUCT"
        m_code = re.search(r"(CTRL-[ABC]|PCB-00[12]|RC-001|CASE-001|SCR-001|WIRE-001|LABEL-001)", t, re.I)
        if m_code:
            params["materialCode"] = m_code.group(1).upper()
        if re.search(r"不含预测|不要预测|仅确定", t):
            params["includeForecast"] = False
        return hit("plan.inventory", params)
    # PL-03 可行性（先于分桶/粗能力通用口令）
    if re.search(r"可行性(分析|评估|检查)?|能否按期|交期可行性|计划可行性|可行不可行", t):
        params: dict[str, Any] = {"includeForecast": True}
        if re.search(r"不含预测|不要预测|仅确定|只要订单", t):
            params["includeForecast"] = False
        return hit("plan.feasibility", params)
    # PL-02 粗能力双模式（先于通用分桶口令）
    if re.search(r"有限无限|无限有限|粗能力对比|RCCP对比|对比粗能力", t, re.I):
        return hit("plan.rccp", {"mode": "HYBRID", "includeForecast": True})
    if re.search(r"无限产能|无限粗(能力|评|估)|无限RCCP", t, re.I):
        return hit("plan.buckets", {"mode": "HYBRID", "capacityMode": "INFINITE", "includeForecast": True})
    if re.search(r"有限产能粗|有限粗(能力|评|估)|粗能力评估|RCCP|有限RCCP", t, re.I):
        return hit("plan.buckets", {"mode": "HYBRID", "capacityMode": "FINITE", "includeForecast": True})
    # PL-01 时间分桶（须在「试排」等动词前，避免「周计划」误触排产）
    if re.search(r"时间分桶|分桶计划|计划分桶|混合分桶|查看分桶|打开分桶|"
                 r"周计划表|月计划表|日计划桶|粗能力分桶|计划层分桶", t):
        params: dict[str, Any] = {"mode": "HYBRID", "includeForecast": True, "capacityMode": "FINITE"}
        if re.search(r"混合", t):
            params["mode"] = "HYBRID"
        elif re.search(r"月", t):
            params["mode"] = "MONTH"
        elif re.search(r"周", t):
            params["mode"] = "WEEK"
        elif re.search(r"日|天", t):
            params["mode"] = "DAY"
        if re.search(r"不含预测|不要预测|仅确定|只要订单", t):
            params["includeForecast"] = False
        if re.search(r"无限", t):
            params["capacityMode"] = "INFINITE"
        return hit("plan.buckets", params)
    # SC-08 战役合并预览 / 试排（须在换型最小化与通用试排之前）
    if re.search(r"战役(合并)?预览|批次(合并)?预览|合并预览|看(一下)?战役", t):
        params: dict[str, Any] = {"windowDays": 7}
        m_w = re.search(r"(\d+)\s*天", t)
        if m_w:
            params["windowDays"] = int(m_w.group(1))
        return hit("campaign.preview", params)
    if re.search(r"战役合并|批次合并|同品合并|合并战役|合并批次", t):
        params = {"strategy": "CAMPAIGN", "engine": "HYBRID"}
        if re.search(r"规则", t):
            params["engine"] = "RULE"
        elif re.search(r"约束规划|CP-?SAT|\bCP\b", t, re.I):
            params["engine"] = "CP"
        if re.search(r"预测", t):
            params["includeForecast"] = True
        return hit("schedule.run", params)
    # SC-07 换型最小化试排（须在通用「试排」与「产能均衡」之前）
    if re.search(r"换型最小化|减少换型|换型优先|最小化换型|少换型", t):
        params: dict[str, Any] = {"strategy": "CHANGEOVER_MIN", "engine": "HYBRID"}
        if re.search(r"规则", t):
            params["engine"] = "RULE"
        elif re.search(r"约束规划|CP-?SAT|\bCP\b", t, re.I):
            params["engine"] = "CP"
        if re.search(r"预测", t):
            params["includeForecast"] = True
        return hit("schedule.run", params)
    # 执行排产：要求"动词形态"命中（试排/重排/排一版/执行|开始|重新排产），
    # 避免仅出现"排产"名词的闲聊被误判（该类输入应交给二级 LLM 判定）
    if re.search(r"预测纳入试排|含预测试排|带预测试排|试排.*预测|预测.*试排", t):
        return hit("schedule.run", {"includeForecast": True, "engine": "HYBRID"})
    if re.search(r"试排|重排|排一版|(执行|开始|重新|跑一?版?)排产", t):
        strategy = ("KITTING_FIRST" if re.search(r"齐套优先|优先齐套|按齐套", t)
                    else "SKILL_FIRST" if re.search(r"技能优先|优先技能|按技能", t)
                    else "DELIVERY_FIRST" if re.search(r"交期", t)
                    else "CAPACITY_BALANCE" if re.search(r"均衡|产能", t)
                    else "CAMPAIGN" if re.search(r"战役|批次|合并", t)
                    else "CHANGEOVER_MIN" if re.search(r"换型", t)
                    else "COST_FIRST" if re.search(r"成本", t)
                    else "FIFO" if re.search(r"FIFO|先进先出", t, re.I)
                    else None)                         # 未点名策略 → 交给偏好个性化（§8.3）
        engine = None
        if re.search(r"规则", t):
            engine = "RULE"
        elif re.search(r"约束规划|CP-?SAT|\bCP\b", t, re.I):
            engine = "CP"
        elif re.search(r"遗传|\bGA\b", t, re.I):
            engine = "GA"
        elif re.search(r"混合|\bHYBRID\b", t, re.I):
            engine = "HYBRID"
        params: dict = {}
        if engine:
            params["engine"] = engine
        if strategy:                                   # 用户明确点名才带策略槽位
            params["strategy"] = strategy
        if re.search(r"预测", t):
            params["includeForecast"] = True
        return hit("schedule.run", params)
    if re.search(r"资源利用率|设备利用率|班组(负荷|并发)|利用率视口|打开利用率|利用率分析", t, re.I):
        return hit("viewport.mode", {"mode": "util"})
    if re.search(r"分桶视口|打开计划层|计划分桶视口", t):
        return hit("viewport.mode", {"mode": "plan"})
    if re.search(r"热力|负荷图|负荷热力", t):                          # 负荷热力图（避免单独「负荷」抢利用率）
        return hit("viewport.mode", {"mode": "load"})
    if re.search(r"KPI\s*仪表盘|运营仪表盘|打开仪表盘", t, re.I):
        return hit("query.kpi")
    if re.search(r"方案对比表|打开对比表|对比表视口", t):
        return hit("scenario.compare")
    if re.search(r"交期|承诺|看板", t):                     # 交期承诺看板
        return hit("viewport.mode", {"mode": "due"})
    if re.search(r"甘特|排程图", t):                        # 甘特图
        return hit("viewport.mode", {"mode": "gantt"})
    if re.search(r"只看|过滤", t):                          # 过滤（VIP / 客户名）
        if re.search(r"VIP", t, re.I):                 # VIP 过滤
            return hit("viewport.filter", {"type": "vip"})
        m = re.search(r"只看(.{1,8}?)的?(订单|单子)", t)     # 提取客户名
        if m:
            return hit("viewport.filter", {"type": "customer", "name": m.group(1)})
    m_code = re.search(r"L00(\d)", t, re.I)                 # 产线编码匹配
    m_name = re.search(r"产线\s*([ABC])", t)                # 产线口语匹配
    if re.search(r"聚焦|放大|定位|只看|看看|看一下", t) and (m_code or m_name):  # 聚焦产线
        code = f"L00{m_code.group(1)}" if m_code else None  # 编码直取
        if not code and m_name:                        # 名称转编码（查产线表）
            line = next((l for l in world["lines"] if l["name"].endswith(m_name.group(1))), None)
            code = line["code"] if line else None      # 命中则取编码
        if code:                                       # 拿到编码才算命中
            return hit("viewport.focus", {"lineCode": code})
    if re.search(r"超期|逾期|延迟", t):                     # 高亮超期
        return hit("viewport.highlight", {"what": "overdue"})
    if re.search(r"冲突", t):                               # 高亮冲突
        return hit("viewport.highlight", {"what": "conflict"})
    if re.search(r"按小时|小时粒度", t):                    # 小时粒度
        return hit("viewport.timescale", {"scale": "hour"})
    if re.search(r"按天|天粒度", t):                        # 天粒度
        return hit("viewport.timescale", {"scale": "day"})
    if re.search(r"重置|清除|复位", t):                     # 重置视口
        return hit("viewport.reset")
    if re.search(r"指标|KPI|利用率|仪表盘|(KPI|指标|利用率).{0,4}怎么样", t, re.I):       # KPI 查询 / EX-08
        return hit("query.kpi")
    # SC-04 约束配置
    if re.search(r"恢复默认约束|重置约束(配置|剖面)?", t):
        return hit("constraint.profile.save", {"resetDefaults": True})
    if re.search(r"关闭物料齐套|不管物料|先不管齐套|禁用齐套约束", t):
        return hit("constraint.profile.save", {
            "constraints": {"C6_material_kit": {"enabled": False}}})
    if re.search(r"打开物料齐套|启用齐套约束|开启物料齐套", t):
        return hit("constraint.profile.save", {
            "constraints": {"C6_material_kit": {"enabled": True}}})
    if re.search(r"齐套改(为|成)?软约束|物料齐套软约束", t):
        return hit("constraint.profile.save", {
            "constraints": {"C6_material_kit": {"enabled": True, "kind": "soft"}}})
    if re.search(r"齐套改(为|成)?硬约束|物料齐套硬约束", t):
        return hit("constraint.profile.save", {
            "constraints": {"C6_material_kit": {"enabled": True, "kind": "hard"}}})
    if re.search(r"打开约束配置|查看约束配置|约束剖面|约束中心|有哪些约束", t):
        return hit("constraint.profile.query")
    # OR-02 排产参数 / 客户等级权重
    if re.search(r"恢复默认(排产)?参数|重置(客户)?等级权重|恢复权重默认", t):
        return hit("params.update", {"resetDefaults": True})
    m_vip_w = re.search(r"(提高|调高|设置|改|把).{0,8}VIP.{0,8}权重\s*(到|为|成|=)?\s*(\d+(?:\.\d+)?)", t, re.I)
    if m_vip_w:
        return hit("params.update", {"vipWeight": float(m_vip_w.group(3))})
    if re.search(r"提高VIP权重|调高VIP权重|VIP权重提高", t, re.I):
        return hit("params.update", {"vipWeight": 10.0})
    if re.search(r"查看排产参数|当前(客户)?等级权重|排产权重|打开排产参数", t):
        return hit("params.query")
    if re.search(r"下一步建议|下一步做什么|该做什么|给我建议|主动引导|空态引导", t):
        return hit("guidance.next")
    if re.search(r"帮助|能做什么|help", t, re.I):           # 帮助
        return hit("help")
    return None                                        # 快路未命中 → 交给二级 LLM


# ---------------- 二级：LLM 语义解析（JSON Schema 强校验 + 降级） ----------------
async def parse_llm(text: str) -> IntentResult:
    """调用 LLM 做意图分类+槽位填充；输出非法/不可用一律降级为 assistant.reply。"""
    raw = await get_provider().chat_json(_LLM_SYSTEM, text)  # 请求 LLM（强制 JSON）
    if raw is None:                                    # LLM 不可用 → 通用助理（带上下文作答）
        return IntentResult(intent="assistant.reply", params={"query": text},
                            confidence=0.9, source="LLM")
    try:
        raw.setdefault("params", {})
        raw["source"] = "LLM"
        result = IntentResult(**raw)
    except ValidationError:
        return IntentResult(intent="assistant.reply", params={"query": text},
                            confidence=0.85, source="LLM")
    if result.confidence < 0.5 or result.intent == "unknown":
        return IntentResult(intent="assistant.reply", params={"query": text},
                            confidence=0.85, source="LLM")
    # 保证下游能拿到原话
    if "query" not in result.params:
        result.params["query"] = text
    return result


# ---------------- 管线入口 ----------------
async def recognize(text: str, world: World) -> IntentResult:
    """两级意图管线总入口：快路优先，未命中走 LLM（P0：纯解析无副作用）。"""
    fast = parse_fast(text, world)                     # 一级：规则快路
    if fast is not None:                               # 命中即返回（毫秒级、零成本）
        return fast
    return await parse_llm(text)                       # 二级：LLM 或通用助理