aps-agent/server/aps_domain/workflow.py

# ============================================================
# 排产工作流编排（moduleId: domain-workflow, 可重生 ✅）
# 职责：意图 → 动作 → AgentReply（文本 + 视口命令 + UI 块）
# 权力路由：P0/P1 直接执行；P2（发布/重置）经门禁出确认卡（§3.3）
# ============================================================
from __future__ import annotations                    # 前向类型引用

import re
import os
from typing import Any                                 # 类型标注

from server.agent_core import harness                  # 门禁 v1
from server.agent_core.audit import write_audit        # 审计写入
from server.contracts import (                         # 跨层契约
    AgentReply, IntentResult, ScheduleResult, ViewportCommand,
)
from server.engines import get_engine                  # 引擎工厂
from server.engines.base import EngineParams           # 引擎入参
from server.state.checkpoints import get_checkpoints   # 成对快照仓（§4.3）
from server.state.store import WorldStore              # 世界状态存储
from server.timeutil import add_minutes, fmt_date, today0  # 日期工具
from server.aps_domain.scenario import compare_scenarios   # 方案对比（Explore 沙盒 §9.7）
from server.aps_domain.reports import build_report, persist_report_xlsx  # 报告生成 v1（§9.10）
from server.knowledge import get_knowledge, get_preferences  # 知识库与偏好仓（M3 §8）
from server.contracts import UIBlock                   # 报告/证据块组装

# 帮助文案：能力清单（help 意图与拒识兜底共用）
_HELP = "\n".join([
    "可执行的排产能力：",
    "· 查询现场数据：有哪些订单 / 查订单 102285668 / 这个订单有委外吗 / 查物料 / 查 BOM / 查工艺路线",
    "· 知识库：机加工工艺怎么生成 / 车削工艺模式 / 装配工艺模式 / 知识清单 / 导入知识文档",
    "· 生成排产草案：试排一版交期优先 / 产能均衡重排 / 用规则引擎试排",
    "· 柔性排产（能力池+虚拟产线）：跑一版柔性排产 / 把这个订单排产 / 正排 / 倒排 / 瓶颈锚",
    "· 外部算法：用外部算法试排 / 查看已接入算法 / skill 健康检查",
    "· 瓶颈产能：瓶颈产能 / 各工序能做多少（按能力池实时算）",
    "· 交期承诺：某产品 N 套什么时候能交",
    "· 方案评估：多策略方案对比（沙盒运行，不影响当前版本）",
    "· 紧急插单：插单快评 / 采用插单（需确认）",
    "· 预测订单：查看预测 / 新建预测 / 预测纳入试排",
    "· 切到负荷热力图 / 交期承诺看板 / 甘特图 / 柔性甘特",
    "· 标出超期订单 / 查看冲突 / 按小时看 / 重置视图",
    "· 建一个检查点 / 回滚到上一个检查点（需确认）",
    "· 换线有什么规定 / @知识:机加工工艺路线生成总则（知识库带出处）",
    "· 生成排产方案报告（下载 Excel 工作计划表） / 生成日报 / 生成版本对比报告",
    "· 查看当前KPI / 下一步建议 / 发布当前排产版本（需确认）/ 重置数据（需确认）",
])

# 策略模板的中文名（回复文案用）
_STRATEGY_CN = {"DELIVERY_FIRST": "交期优先", "CAPACITY_BALANCE": "产能均衡",
                "COST_FIRST": "成本最优(换型代理)", "CHANGEOVER_MIN": "换型最小化",
                "CAMPAIGN": "战役合并", "FIFO": "先进先出", "COMPREHENSIVE": "综合优化"}

# OR-04：最近一次插单快评（供「采用插单」复用；进程内存）
_LAST_RUSH_EVAL: dict[str, Any] = {}


def _run_schedule(store: WorldStore, intent: IntentResult, actor: str) -> AgentReply:
    """执行试排（P1：写草稿版本 + 落盘；发布另走 P2 门禁）。"""
    # 偏好个性化（§8.3 第一层）：用户没点名策略时用其历史最常用策略
    explicit = intent.params.get("strategy")           # 用户明确点名的策略（可能为空）
    pref_note = ""                                     # 个性化说明（透明可解释）
    if explicit:                                       # 点名 → 直接用
        strategy = explicit
    else:                                              # 未点名 → 查偏好仓
        strategy, scores = get_preferences().preferred_strategy(default="COMPREHENSIVE")
        if scores:                                     # 有历史信号才标注（避免误导）
            pref_note = f"\n（按你的使用偏好选了{_STRATEGY_CN.get(strategy, strategy)}，历史使用 {scores.get(strategy, 0)} 次；点名策略可覆盖）"
    from server.aps_domain.params import get_schedule_params
    from server.aps_domain.constraints import engine_constraint_flags
    sp = get_schedule_params(store.data)
    params = EngineParams(                             # 组装引擎入参
        orderIds=[],                                   # M1：全部待排订单
        engineType=intent.params.get("engine") or sp.get("defaultEngine") or "HYBRID",
        strategyTemplate=strategy,                     # 策略模板（点名或偏好）
        planningHorizonDays=int(sp.get("planningHorizonDays") or 14),  # 展望期（OR-02 可配）
        startDate=fmt_date(add_minutes(today0(), 24 * 60)),        # 明天开排
        includeForecast=bool(intent.params.get("includeForecast")),  # OR-05：预测纳入试排
        constraints=engine_constraint_flags(store.data),           # SC-04 约束剖面 → 引擎开关
        timeLimitSeconds=float(sp["cpTimeLimitSeconds"]) if sp.get("cpTimeLimitSeconds") is not None else 8.0,
    )
    engine = get_engine(params.engineType)             # CP / HYBRID 真管线；GA 仍 RULE 代跑
    result: ScheduleResult = engine.solve(store.data, params, store.next_id)  # 求解（写内存世界）
    # 审计：算法运行留痕（§3.6.2 算法运行类：引擎/策略/计数可复算）
    write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="schedule.run",
                target={"type": "SCHEDULE_VERSION", "id": result.versionId},
                power="P1", rationale={"strategy": params.strategyTemplate, "engine": params.engineType,
                                       "evidence": result.evidenceRefs,
                                       "solveStatus": result.solveStatus,
                                       "solveTimeSec": result.solveTimeSec,
                                       "gap": result.optimalityGap})
    store.save()                                       # 试排结果落盘（草稿版本也持久化）
    get_preferences().record(params.strategyTemplate, source="schedule.run", actor=actor)  # 偏好信号沉淀（§8.3）
    engine_note = ""
    if params.engineType in ("CP", "HYBRID"):
        st = result.solveStatus or "—"
        gap = result.optimalityGap
        gap_txt = f"{gap:.2%}" if gap is not None else "—"
        tsec = result.solveTimeSec
        t_txt = f"{tsec:.2f}s" if tsec is not None else "—"
        pipe = "RULE→CP-SAT" if params.engineType == "HYBRID" else "CP-SAT"
        engine_note = (
            f"\n（{pipe}：状态 {st} · 耗时 {t_txt} · gap {gap_txt}；工序落槽=班次占槽）"
        )
    elif params.engineType == "GA":
        engine_note = "\n（注：GA 真管线尚未接入，本次由规则引擎代跑并留 engineType 痕）"
    text = (f"排产完成 ✅ 版本 {result.versionNo}（{_STRATEGY_CN.get(result.strategy, result.strategy)}）\n"
            f"生产订单 {result.poCount} 个 / 工单 {result.woCount} 个"
            + ("（含预测）" if params.includeForecast else "") + "\n"
            f"冲突 {result.conflictCount} 项 · 总延迟 {round(result.totalTardiness)}h · "
            f"平均利用率 {round(result.avgUtilization * 100)}%{engine_note}{pref_note}\n"
            f"右侧甘特已刷新为该版本。执行“发布当前排产版本”可进入 P2 发布确认。")   # 回复正文（含下一步引导）
    blocks: list[UIBlock] = []
    if result.conflictCount >= 3:
        from server.aps_domain.guidance import build_guidance
        blocks.append(UIBlock(
            blockId="guidance-after-run", type="guidance",
            props=build_guidance(store.data, context="high_conflict")))
    return AgentReply(text=text, blocks=blocks, commands=[            # 联动命令：切甘特 + 重拉世界数据
        ViewportCommand(cmd="viewport.mode", params={"mode": "gantt"}, issuedBy="LLM"),
        ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM"),
    ])


def _stage_publish(store: WorldStore, session_id: str, actor: str) -> AgentReply:
    """把“发布版本”压入门禁（P2：出确认卡，不立即执行）。"""
    versions = store.data["scheduleVersions"]          # 版本表
    if not versions:                                   # 无版本可发布
        from server.aps_domain.guidance import build_guidance
        block = UIBlock(blockId="guidance-no-version", type="guidance",
                        props=build_guidance(store.data, context="empty_schedule"))
        return AgentReply(
            text="当前没有可发布的排产版本。请先生成排产草案，例如：试排一版交期优先。",
            blocks=[block])
    v = versions[-1]                                   # 最新版本
    if v["status"] == "PUBLISHED":                     # 已发布防重
        return AgentReply(text=f"版本 {v['versionNo']} 已是发布状态，无需重复发布。")
    from server.aps_domain.constraints import hard_blocking_conflicts
    blockers = hard_blocking_conflicts(store.data, version_id=v["id"], track="fixed")
    if blockers:
        names = "、".join(sorted({b.get("constraintId", "?") for b in blockers})[:5])
        return AgentReply(
            text=(f"版本 {v['versionNo']} 存在 {len(blockers)} 项硬约束冲突（{names}），"
                  "按约束配置不可发布。请先解决冲突，或将对应约束改为软约束/关闭后再试。\n"
                  "可说「查看冲突」或「打开约束配置」。"))
    block = harness.stage_confirmation(                # 生成确认卡并登记待确认队列
        session_id, "schedule.publish", {"versionId": v["id"]},
        title=f"发布排产版本 {v['versionNo']}",
        summary_lines=[                                # 影响面说明（计划员据此决策）
            f"生产订单 {v['poCount']} 个 / 工单 {v['woCount']} 个将转入执行准备",
            f"未解决冲突 {v['conflictCount']} 项 · 总延迟 {round(v['totalTardiness'])}h",
            "发布后该版本成为执行基准（P2 写主干世界状态）",
        ])
    # 审计：门禁出卡事件（GATE 类）
    write_audit(store.data, store.next_id, actor=actor, category="GATE", action="schedule.publish.stage",
                target={"type": "SCHEDULE_VERSION", "id": v["id"]}, power="P2",
                rationale={"confirmId": block.props["confirmId"]})
    store.save()                                       # 审计落盘
    return AgentReply(text=f"发布版本 {v['versionNo']} 属于 P2 写操作，需要你确认（见下方确认卡）。", blocks=[block])


def _stage_order_upsert(store: WorldStore, session_id: str, intent: IntentResult, actor: str) -> AgentReply:
    """对话侧新建/编辑订单（P2 → 确认卡）：解析槽位 + 成品，缺项则追问。"""
    from server.aps_domain.orders import (confirmation_for_order_action, find_order,
                                           find_product_by_hint)
    p = dict(intent.params or {})
    order_no = str(p.get("orderNo") or "")
    existing = find_order(store.data, order_no=order_no) if order_no else None
    if order_no and existing is None:
        return AgentReply(text=f"没找到订单 {order_no}，无法修改。可在订单面板核对订单号。")

    payload: dict[str, Any] = {}
    if existing:                                           # 编辑：以现单兜底未给字段
        first = (existing.get("items") or [{}])[0]
        payload.update({
            "id": existing["id"], "customerName": existing["customerName"],
            "customerLevel": existing["customerLevel"], "deliveryDate": existing["deliveryDate"],
            "priority": existing.get("priority", 5), "status": existing.get("status", "CONFIRMED"),
            "productId": first.get("productId"), "quantity": first.get("quantity", 1),
            "isRush": existing.get("isRush", False),
            "specialRequirements": existing.get("specialRequirements", ""),
        })
    # 覆盖用户明确给出的字段
    for k in ("customerName", "customerLevel", "deliveryDate", "priority", "quantity"):
        if p.get(k) not in (None, ""):
            payload[k] = p[k]
    if "isRush" in p:
        payload["isRush"] = p["isRush"]
    prod_hint = p.get("productCode") or p.get("productName")
    if prod_hint:
        prod = find_product_by_hint(store.data, str(prod_hint))
        if prod is None:
            names = "、".join(m["name"] for m in store.data["materials"] if m["type"] == "FINISHED_PRODUCT")
            return AgentReply(text=f"没找到成品「{prod_hint}」。可选成品：{names}。")
        payload["productId"] = prod["id"]

    missing = [label for key, label in (("customerName", "客户名称"), ("productId", "产品"),
                                        ("deliveryDate", "交期"), ("quantity", "数量"))
               if not payload.get(key)]
    if missing:
        verb = "修改" if existing else "新建"
        return AgentReply(text=f"要{verb}订单还差：{'、'.join(missing)}。\n"
                               "可以一次说清，例如：「新建订单 客户 康尼机电 产品 PDU配电单元 数量 500 交期 2026-08-20」。")
    try:
        title, lines = confirmation_for_order_action(store.data, "order.upsert", payload)
    except ValueError as exc:
        return AgentReply(text=f"订单信息有误：{exc}")
    block = harness.stage_confirmation(session_id, "order.upsert", payload, title=title, summary_lines=lines)
    write_audit(store.data, store.next_id, actor=actor, category="GATE", action="order.upsert.stage",
                target={"type": "SALES_ORDER", "id": payload.get("id") or "NEW"}, power="P2",
                rationale={"confirmId": block.props["confirmId"]})
    store.save()
    return AgentReply(text=f"{title} 属于 P2 订单写入，需要你确认。", blocks=[block])


def _stage_reset(store: WorldStore, session_id: str, actor: str) -> AgentReply:
    """把“重置数据”压入门禁（P2：破坏性操作必须确认）。"""
    block = harness.stage_confirmation(                # 生成确认卡
        session_id, "data.reset", {},
        title="清空并重置演示数据",
        summary_lines=["将删除全部排产版本/工单/审计并重新播种（不可恢复）"])
    return AgentReply(text="重置数据是破坏性操作（P2），需要你确认。", blocks=[block])


def execute_confirmed(store: WorldStore, confirm_id: str, approve: bool, actor: str) -> str:
    """执行/驳回一条已出卡的 P2 动作（确认卡回传入口；一次性令牌）。

    权力等级：P2（本函数是 P2 动作的唯一执行通道，§3.3 门禁放行后）。
    Returns: 面向用户的结果文案。
    """
    pending = harness.take_confirmation(confirm_id)    # 取出待确认动作（取后即失效）
    if pending is None:                                # 过期/重复点击
        return "该确认卡已失效（可能已处理过）。"
    action, params = pending["action"], pending["params"]  # 解构动作
    if not approve:                                    # ---- 驳回分支 ----
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action=action + ".reject",
                    target=params, power="P2", rationale={"confirmId": confirm_id}, result="DENIED")  # 驳回留痕
        store.save()                                   # 落盘
        return "已驳回，未做任何变更。"
    if action == "schedule.publish":                   # ---- 批准：发布版本 ----
        v = next(x for x in store.data["scheduleVersions"] if x["id"] == params["versionId"])  # 目标版本
        from server.aps_domain.constraints import hard_blocking_conflicts
        blockers = hard_blocking_conflicts(store.data, version_id=v["id"], track="fixed")
        if blockers:
            return (f"发布被硬约束门禁拦截：仍有 {len(blockers)} 项未解决硬约束冲突。"
                    "请先处理冲突或调整约束配置。")
        # 回滚防线（§3.3 防线 3）：P2 写主干前自动·强制建成对快照（回滚锚点）
        get_checkpoints().create(store.data, label=f"发布前基线 {v['versionNo']}",
                                 reason="auto:publish", conversation_note=f"批准发布 {v['versionNo']}")
        v["status"] = "PUBLISHED"                      # 置为已发布
        from datetime import datetime                  # 局部导入避免顶部循环
        from server.timeutil import fmt_dt             # 时间格式化
        v["publishedAt"] = fmt_dt(datetime.now())      # 发布时间
        for po in store.data["productionOrders"]:      # 该版本 PO 推进为已确认
            if po["schedulingVersionId"] == v["id"]:
                po["status"] = "CONFIRMED"
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="schedule.publish",
                    target={"type": "SCHEDULE_VERSION", "id": v["id"]}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor})  # 发布留痕（谁批的）
        store.save()                                   # 主干写入落盘
        return f"版本 {v['versionNo']} 已发布 ✅ 生产订单已转入执行准备（审计已留痕）。"
    if action == "data.reset":                         # ---- 批准：重置数据 ----
        # 回滚防线：重置前自动建档（重置本身也可被撤销）
        get_checkpoints().create(store.data, label="重置前基线", reason="auto:reset",
                                 conversation_note="批准重置数据")
        store.reset()                                  # 重新播种（含落盘）
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="data.reset",
                    target={"type": "WORLD", "id": 0}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor})  # 重置留痕
        store.save()                                   # 审计落盘
        return "数据已重置为种子状态 ✅（重置前状态已自动存档，可回滚）"
    if action == "checkpoint.rollback":                # ---- 批准：回滚到检查点 ----
        pair = get_checkpoints().get(params["pairId"])  # 取目标快照（完整世界）
        if pair is None:                               # 快照不存在（被淘汰）
            return "目标检查点不存在（可能已被容量策略淘汰）。"
        # 回滚防线：回滚前先把"现在"也存档（允许撤销这次回滚——时间旅行可往返 §4.4）
        get_checkpoints().create(store.data, label="回滚前状态", reason="auto:rollback",
                                 conversation_note=f"回滚到 {pair['label']}")
        store.restore(pair["world"])                   # 整体替换主干世界（成对恢复的世界侧）
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="checkpoint.rollback",
                    target={"type": "CHECKPOINT", "id": params["pairId"]}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor, "label": pair["label"]})  # 回滚留痕
        store.save()                                   # 落盘
        return f"已回滚到检查点【{pair['label']}】（{pair['createdAt']}）✅ 回滚前状态已自动存档。"
    if action in ("order.upsert", "order.cancel", "order.complete", "order.delete", "order.clear",
                  "order.approve", "order.reject"):  # ---- 批准：订单写入 / 审核 ----
        from server.aps_domain.orders import apply_order_action
        get_checkpoints().create(store.data, label="订单变更前基线", reason=f"auto:{action}",
                                 conversation_note=f"批准执行 {action}")  # P2 写前自动建档
        applied = apply_order_action(store.data, store.next_id, action, params)
        order = applied["order"]
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action=action,
                    target={"type": "SALES_ORDER", "id": order["id"], "orderNo": order["orderNo"]},
                    power="P2", rationale={"confirmId": confirm_id, "approver": actor,
                                           "beforeStatus": applied.get("beforeStatus"),
                                           "afterStatus": order["status"],
                                           "approvedCount": applied.get("approvedCount"),
                                           "rejectedCount": applied.get("rejectedCount")})
        store.save()
        if action == "order.approve":
            return (f"已批准 ✅ {applied.get('approvedCount', 1)} 条订单 → APPROVED，"
                    f"可参与正式排产：{'、'.join(applied.get('orderNos') or [order['orderNo']])}")
        if action == "order.reject":
            return (f"已驳回 ✅ {applied.get('rejectedCount', 1)} 条："
                    f"{'、'.join(applied.get('orderNos') or [order['orderNo']])}")
        if action == "order.upsert":
            verb = "已新增" if applied.get("created") else "已更新"
            return f"{verb}订单 {order['orderNo']} ✅ 后续试排会使用最新订单池。"
        if action == "order.cancel":
            return f"订单 {order['orderNo']} 已取消 ✅ 后续试排将不再纳入。"
        if action == "order.delete":
            return f"订单 {order['orderNo']} 已删除 ✅ 已从订单池移除。"
        if action == "order.clear":
            return (f"订单池已清空 ✅ 销售 {applied.get('clearedOrders', 0)} 条 / "
                    f"采购 {applied.get('clearedPurchase', 0)} / 委外 {applied.get('clearedOutsource', 0)}。"
                    "后续可重新导入或新建订单。")
        return f"订单 {order['orderNo']} 已完成 ✅ 后续试排将不再纳入。"
    if action == "rush.apply":                         # ---- OR-04：采用紧急插单 ----
        from server.aps_domain.rush import apply_rush
        get_checkpoints().create(store.data, label="插单采用前基线", reason="auto:rush.apply",
                                 conversation_note="采用紧急插单前自动建档")
        applied = apply_rush(store.data, store.next_id, params)
        order = applied["order"]
        result = applied["result"]
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="rush.apply",
                    target={"type": "SALES_ORDER", "id": order["id"], "orderNo": order["orderNo"]},
                    power="P2", rationale={"confirmId": confirm_id, "approver": actor,
                                           "versionNo": result.versionNo,
                                           "strategy": applied.get("strategy"),
                                           "evalId": params.get("evalId")})
        store.save()
        _LAST_RUSH_EVAL.clear()
        return (f"插单已采用 ✅ {order['orderNo']}（急单）已入池；"
                f"草稿版本 {result.versionNo} · 订单 {result.orderCount} · "
                f"冲突 {result.conflictCount} · 延迟 {round(result.totalTardiness)}h。"
                f"可用检查点回滚到采用前。")
    if action in ("forecast.upsert", "forecast.delete", "forecast.convert"):
        from server.aps_domain.forecast import apply_forecast_action
        get_checkpoints().create(store.data, label="预测变更前基线", reason=f"auto:{action}",
                                 conversation_note=f"批准执行 {action}")
        applied = apply_forecast_action(store.data, store.next_id, action, params)
        fc = applied["forecast"]
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action=action,
                    target={"type": "FORECAST_ORDER", "id": fc.get("id"), "forecastNo": fc.get("forecastNo")},
                    power="P2", rationale={"confirmId": confirm_id, "approver": actor,
                                           "beforeStatus": applied.get("beforeStatus"),
                                           "convertedOrderNo": applied.get("convertedOrderNo")})
        store.save()
        if action == "forecast.convert":
            return (f"预测已转正 ✅ {fc.get('forecastNo')} → 销售订单 {applied.get('convertedOrderNo')}，"
                    "可参与正式排产。")
        if action == "forecast.delete":
            return f"预测 {fc.get('forecastNo')} 已删除 ✅"
        verb = "已新建" if applied.get("created") else "已更新"
        return f"{verb}预测 {fc.get('forecastNo')} ✅（默认不进正式排产，可说「预测纳入试排」）。"
    if action == "data.import":                        # ---- 批准：批量导入 ----
        from server.aps_domain.intake import apply_import
        get_checkpoints().create(store.data, label="批量导入前基线", reason="auto:data.import",
                                 conversation_note=f"批准导入 {params.get('kind')}")
        applied = apply_import(store.data, store.next_id, params)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="data.import",
                    target={"type": "IMPORT", "id": params.get("kind")}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor, "count": applied["count"]})
        store.save()
        label = "订单" if applied["kind"] == "orders" else "物料"
        sample = "、".join(applied["created"][:5])
        more = f" 等 {applied['count']} 条" if applied["count"] > 5 else f"共 {applied['count']} 条"
        return f"已导入{label} ✅ {sample}{more}。"
    if action == "flex.site.load":                     # ---- 批准：现场生产路线 ----
        from server.importers import import_site_excel
        get_checkpoints().create(store.data, label="现场路线导入前基线", reason="auto:flex.site.load",
                                 conversation_note="批准加载完整生产路线")
        meta = import_site_excel(
            store.data,
            profile_id=params.get("profileId") or "kangni",
            route_path=params.get("routePath") or None,
            data_dir=params.get("dataDir") or None,
            include_sibling_orders=params.get("includeSiblings", False) is True,
            station_count=int(params.get("stationCount") or 0) or None,
        )
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="flex.site.load",
                    target={"type": "FLEX_SITE", "id": meta.get("primaryOrder")}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor, "meta": meta})
        store.save()
        return (f"现场生产路线已加载 ✅ 主单 {meta.get('primaryOrder')}，"
                f"订单 {meta.get('orderCount')} / 工序 {meta.get('operationCount')} / BOM {meta.get('bomCount')}。"
                f"演示 flex* 已清空。可说「柔性排产」。")
    if action == "import.commit":                      # ---- 批准：Excel/CSV 入库 ----
        from server.aps_domain.importers import apply_import_commit
        get_checkpoints().create(store.data, label="文件导入前基线", reason="auto:import.commit",
                                 conversation_note=f"批准导入 {params.get('filename')}")
        applied = apply_import_commit(store.data, store.next_id, params.get("batches") or [])
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="import.commit",
                    target={"type": "IMPORT", "id": params.get("filename")}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor, "summary": applied["summary"]})
        store.save()
        detail = "、".join(f"{k}×{v}" for k, v in applied["summary"].items()) or "无行"
        return f"文件导入完成 ✅ 共 {applied['total']} 条（{detail}）。"
    if action == "folder.schedule":
        from server.aps_domain.importers import apply_import_commit
        from server.aps_domain.folder_pack import analyze_work_dir
        get_checkpoints().create(store.data, label="工程目录导入前基线",
                                 reason="auto:folder.schedule",
                                 conversation_note="批准导入工程目录并试排")
        batches = params.get("batches") or []
        sql_already = bool(params.get("sqlApplied"))
        if not batches and not sql_already:
            report = analyze_work_dir(
                store.data, params.get("sessionId"), force_sql_replace=True)
            batches = report.get("batches") or []
            sql_already = bool(report.get("sqlApplied"))
        applied = {"total": 0, "summary": {}}
        if batches:
            applied = apply_import_commit(store.data, store.next_id, batches)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="folder.schedule.import",
                    target={"type": "FOLDER_PACK", "id": params.get("workDir") or "workDir"},
                    power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor,
                               "summary": applied.get("summary"), "sqlApplied": sql_already})
        store.save()
        from server.aps_domain.readiness import check_readiness, readiness_text
        ready = check_readiness(store.data)
        detail = "、".join(f"{k}×{v}" for k, v in (applied.get("summary") or {}).items()) or (
            "SQL 已入库" if sql_already else "无行"
        )
        head = f"工程目录已导入 ✅（{detail}）。"
        # 有订单+工艺+设备即可开排（工时推断/缺 BOM 不拦死）
        has_core = (
            bool(store.data.get("flexOrders"))
            and bool(store.data.get("flexRoutings"))
            and any(e.get("status") == "RUNNING" for e in (store.data.get("flexEquipment") or []))
        )
        if ready["summary"].get("ready", 0) == 0 and not has_core:
            return head + "\n\n导入后仍不具备开排条件：\n" + readiness_text(ready)
        from server.aps_domain.flex import run_flex_schedule
        result = run_flex_schedule(
            store, sort_mode=params.get("sortMode") or "BOTTLENECK", actor=actor)
        ver = (result or {}).get("versionNo") or ""
        return (head + f"\n已按目录数据试排一版：**{ver}**"
                f"（虚拟产线 {(result or {}).get('vlCount', 0)} · "
                f"冲突 {(result or {}).get('conflictCount', 0)}）。"
                "可在右侧柔性工作台看甘特，或再说「查看冲突」。")
    if action == "flex.reschedule":
        from server.aps_domain.flex import reschedule_by_level
        get_checkpoints().create(store.data, label=f"{params.get('level', 'L2')} 重排前基线",
                                 reason="auto:flex.reschedule",
                                 conversation_note=f"批准 {params.get('level')} 重排")
        r = reschedule_by_level(store, level=params.get("level") or "L2",
                                sort_mode=params.get("sortMode"), actor=actor)
        sch = r["schedule"]
        # EX-03：若从冲突修复卡进入，标记原冲突已解决
        cid = params.get("resolveConflictId")
        if cid is not None:
            for cf in store.data.get("flexConflicts", []):
                if cf.get("id") == cid:
                    cf["isResolved"] = True
                    cf["resolutionAction"] = f"flex.reschedule:{r['level']}"
                    cf["resolvedBy"] = actor
                    break
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="flex.reschedule.approve", target={"type": "FLEX_VERSION",
                                                              "id": sch.get("versionId")},
                    power="P2", rationale={"confirmId": confirm_id, "level": r["level"],
                                           "frozenWo": r.get("frozenWo"),
                                           "mutableOrders": r.get("mutableOrders"),
                                           "resolveConflictId": cid})
        store.save()
        return (f"{r['level']} 重排已执行 ✅ 版本 {sch.get('versionNo')}："
                f"冻结 {r.get('frozenWo', 0)} / 重排 {r.get('mutableOrders', 0)} 单，"
                f"冲突 {sch.get('conflictCount', 0)}。")
    if action == "flex.adjust.commit":
        from server.aps_domain.adjust import commit_flex_adjust
        get_checkpoints().create(store.data, label="甘特调程前基线",
                                 reason="auto:flex.adjust.commit",
                                 conversation_note=f"批准拖拽工单 #{params.get('woId')}")
        r = commit_flex_adjust(store, int(params["woId"]), str(params["newStart"]), actor=actor)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="flex.adjust.approve",
                    target={"type": "FLEX_VERSION", "id": r.get("versionId")},
                    power="P2", rationale={"confirmId": confirm_id, "woId": params.get("woId")})
        store.save()
        return r.get("message") or "调程已执行 ✅"
    if action == "schedule.adjust.commit":
        from server.aps_domain.adjust import commit_fixed_adjust
        get_checkpoints().create(store.data, label="固定甘特调程前基线",
                                 reason="auto:schedule.adjust.commit",
                                 conversation_note=f"批准拖拽工单 #{params.get('woId')}")
        r = commit_fixed_adjust(store, int(params["woId"]), str(params["newStart"]), actor=actor)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="schedule.adjust.approve",
                    target={"type": "SCHEDULE_VERSION", "id": r.get("versionId")},
                    power="P2", rationale={"confirmId": confirm_id, "woId": params.get("woId")})
        store.save()
        return r.get("message") or "调程已执行 ✅"
    if action == "sap.sync.inbound":
        from server.aps_domain.sap_sync import apply_inbound
        get_checkpoints().create(store.data, label="SAP 入站前基线",
                                 reason="auto:sap.sync.inbound",
                                 conversation_note="批准 SAP 入站同步")
        r = apply_inbound(store, actor=actor)
        return r.get("message") or "SAP 入站完成 ✅"
    if action == "sap.sync.outbound":
        from server.aps_domain.sap_sync import apply_outbound
        get_checkpoints().create(store.data, label="SAP 出站前基线",
                                 reason="auto:sap.sync.outbound",
                                 conversation_note="批准 SAP 出站回写")
        r = apply_outbound(store, actor=actor)
        return r.get("message") or "SAP 出站完成 ✅"
    if action == "mes.dispatch":
        from server.aps_domain.mes import apply_dispatch
        get_checkpoints().create(store.data, label="MES 下发前基线",
                                 reason="auto:mes.dispatch",
                                 conversation_note=f"批准 MES 下发 {params.get('track')}")
        r = apply_dispatch(store, track=params.get("track") or "flex", actor=actor)
        return r.get("message") or "MES 下发完成 ✅"
    if action == "mrp.release":                        # ---- 批准：MRP 建议单下达 ----
        from server.aps_domain.mrp import apply_mrp_release
        get_checkpoints().create(store.data, label="MRP 下达前基线", reason="auto:mrp.release",
                                 conversation_note="批准下达 MRP 建议单")  # P2 写前自动建档
        applied = apply_mrp_release(store.data, params.get("orderNo"), params.get("kind", "all"))
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="mrp.release",
                    target={"type": "MRP", "id": params.get("orderNo") or "ALL"}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor,
                               "purchase": applied["purchaseCount"], "outsource": applied["outsourceCount"]})
        store.save()
        return (f"已下达 ✅ 采购单 {applied['purchaseCount']} 条 / 委外单 {applied['outsourceCount']} 条转为正式（RELEASED），"
                "可在订单面板「分解建议」查看状态。")
    if action.startswith("master."):                   # ---- 批准：主数据写入（白名单见 masterdata.MASTER_ACTIONS） ----
        from server.aps_domain.masterdata import apply_master_action
        get_checkpoints().create(store.data, label="主数据变更前基线", reason=f"auto:{action}",
                                 conversation_note=f"批准执行 {action}")  # P2 写前自动建档
        applied = apply_master_action(store.data, store.next_id, action, params)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action=action,
                    target={"type": f"MASTER_{applied['kind']}", "id": applied["id"], "name": applied["name"]},
                    power="P2", rationale={"confirmId": confirm_id, "approver": actor,
                                           "before": applied.get("beforeStatus", applied.get("beforeStock")),
                                           "after": applied.get("afterStatus", applied.get("afterStock"))})
        store.save()
        kind_cn = {
            "LINE": "产线", "MATERIAL": "物料", "MAINTENANCE": "维保计划",
            "BOM_ITEM": "BOM 明细", "BOM": "BOM", "ROUTING_STEP": "工艺步骤",
            "ROUTING": "工艺路线", "OPERATION": "工序", "LINE_PRODUCT": "产线绑定",
            "MASTER_CLEAR": "主数据清理",
        }.get(applied["kind"], applied["kind"])
        if applied["kind"] == "MASTER_CLEAR":
            detail = ", ".join(applied.get("cleared") or applied.get("restored") or []) or "无数据"
            return f"主数据已按【{applied['name']}】清空 ✅ {detail}（变更前已自动建档）。"
        return f"{kind_cn}【{applied['name']}】主数据已更新 ✅ 只影响后续新排产版本（变更前已自动建档）。"
    if action == "params.update":                      # ---- 批准：排产参数（OR-02） ----
        from server.aps_domain.params import apply_params_update
        get_checkpoints().create(store.data, label="排产参数变更前基线", reason="auto:params.update",
                                 conversation_note="批准更新排产参数")
        applied = apply_params_update(store.data, params)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="params.update",
                    target={"type": "SCHEDULE_PARAMS", "id": "scheduleParams"}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor,
                               "before": applied["before"].get("customerLevelWeights"),
                               "after": applied["after"].get("customerLevelWeights"),
                               "reset": applied.get("reset")})
        store.save()
        lw = applied["after"]["customerLevelWeights"]
        return (f"排产参数已更新 ✅ 客户等级权重 VIP={lw['VIP']} / A={lw['A']} / B={lw['B']} / C={lw['C']}。"
                "只影响后续新排产版本（变更前已自动建档）。")
    if action == "constraint.profile.save":            # ---- 批准：约束剖面（SC-04） ----
        from server.aps_domain.constraints import apply_profile_save
        get_checkpoints().create(store.data, label="约束配置变更前基线", reason="auto:constraint.profile.save",
                                 conversation_note="批准更新约束配置")
        applied = apply_profile_save(store.data, params)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="constraint.profile.save",
                    target={"type": "CONSTRAINT_PROFILE", "id": applied["id"]}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor, "reset": applied.get("reset")})
        store.save()
        enabled = sum(1 for c in applied["after"]["constraints"] if c["enabled"])
        hard_n = sum(1 for c in applied["after"]["constraints"] if c["kind"] == "hard" and c["enabled"])
        return (f"约束配置已更新 ✅ 启用 {enabled} 条 / 其中硬约束 {hard_n} 条。"
                "硬约束违反将阻止发布（变更前已自动建档）。")
    if action == "sop.apply":                          # ---- 批准：SOP 规则包（IND-02） ----
        from server.aps_domain.sop_rules import apply_sop_pack, compile_sop_by_query
        pack = params.get("pack")
        if not isinstance(pack, dict):
            compiled = compile_sop_by_query(get_knowledge().assets, params.get("query"))
            if not compiled.get("ok"):
                return compiled.get("error") or "SOP 编译失败"
            pack = compiled["pack"]
        get_checkpoints().create(store.data, label="SOP规则包应用前基线", reason="auto:sop.apply",
                                 conversation_note="批准应用 SOP→约束")
        applied = apply_sop_pack(store.data, pack)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="sop.apply",
                    target={"type": "RULE_PACK", "id": applied["packId"]}, power="P2",
                    rationale={"confirmId": confirm_id, "approver": actor,
                               "applied": applied.get("applied"), "source": pack.get("source")})
        store.save()
        note = "；".join(applied.get("notes") or []) or "无额外流程提示"
        return (
            f"已应用 SOP 规则包 ✅ {pack.get('title')}（{applied['packId']}）。\n"
            f"生效项：{', '.join(applied.get('applied') or [])}\n{note}"
        )
    if action == "knowledge.import":
        from server.knowledge.embedding import index_units
        from server.knowledge.ingest import apply_knowledge_import, preview_ingest
        path = params.get("path")
        if not path:
            return "缺少文件路径，无法导入知识文档"
        try:
            preview = preview_ingest(
                params.get("filename") or path, path=path,
                kind=params.get("kind") or "sop", title=params.get("title"),
            )
            applied = apply_knowledge_import(preview)
            # 尝试建向量索引（无嵌入后端则跳过）
            from server.knowledge.assets import get_knowledge
            index_units(get_knowledge().iter_search_units())
        except (FileNotFoundError, ValueError) as exc:
            return str(exc)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="knowledge.import",
                    target={"type": "KNOWLEDGE", "id": applied["assetId"]}, power="P2",
                    rationale={"confirmId": confirm_id, "chunkCount": applied.get("chunkCount"),
                               "title": applied.get("title")})
        store.save()
        return (f"知识文档已入库 ✅ 《{applied['title']}》{applied['version']}，"
                f"切块 {applied['chunkCount']} 段（资产 {applied['assetId']}）。")
    if action == "skill.register":
        from server.agent_core.skills import get_skills
        payload = {
            "skill_id": params.get("skill_id") or params.get("skillId"),
            "name": params.get("name") or params.get("skill_id") or params.get("skillId"),
            "endpoint": params.get("endpoint"),
            "auth": params.get("auth") or "",
            "track": params.get("track") or "flex",
            "enabled": params.get("enabled", True),
            "description": params.get("description") or "",
        }
        saved = get_skills().upsert(payload)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="skill.register",
                    target={"type": "SKILL", "id": saved["skill_id"]}, power="P2",
                    rationale={"confirmId": confirm_id, "endpoint": saved.get("endpoint")})
        store.save()
        return f"已登记算法 Skill ✅ {saved['skill_id']}（{saved['name']}）→ {saved['endpoint']}"
    if action == "skill.enable":
        from server.agent_core.skills import get_skills
        sid = params.get("skill_id") or params.get("skillId")
        enabled = bool(params.get("enabled", True))
        saved = get_skills().set_enabled(sid, enabled)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="skill.enable",
                    target={"type": "SKILL", "id": sid}, power="P2",
                    rationale={"confirmId": confirm_id, "enabled": enabled})
        store.save()
        return f"算法 Skill {sid} 已{'启用' if enabled else '停用'} ✅"
    if action == "flex.time.update":                   # ---- 批准：工时维护 ----
        op_code = str(params.get("operationCode") or "")
        op_codes = set(params.get("operationCodes") or ([op_code] if op_code else []))
        pc = str(params.get("productCode") or "")
        std_min = float(params.get("stdMin") or 0)
        source = params.get("source") or "实测"
        hits = 0
        for step in store.data.get("flexRoutings") or []:
            if op_codes and step.get("operationCode") not in op_codes:
                continue
            if pc and step.get("productCode") != pc:
                continue
            step["stdTimePerUnit"] = std_min
            step["stdTimeSource"] = source
            hits += 1
        # 同步工序库标准工时（主数据页显示口径）
        for op in store.data.get("flexOperations") or []:
            if op.get("code") in op_codes and not pc:
                op["stdTimeMin"] = std_min
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="flex.time.update",
                    target={"type": "ROUTING_TIME", "id": f"{pc or '*'}/{op_code or '*'}"}, power="P2",
                    rationale={"confirmId": confirm_id, "stdMin": std_min, "hits": hits, "source": source})
        store.save()
        ops_label = "、".join(sorted(op_codes)) or "全部工序"
        if not hits:
            return f"未找到匹配的路线步骤（产品={pc or '任意'}，工序={ops_label}），未做修改。"
        return (f"工时已更新 ✅ {pc or '全部产品'} × {ops_label} → "
                f"{std_min} 分钟/件（来源={source}，{hits} 条路线步骤）。")
    if action == "routing.template.apply":             # ---- 批准：模板生成工艺路线 ----
        from server.knowledge.routing_templates import apply_template_to_product
        get_checkpoints().create(store.data, label="模板生成路线前基线",
                                 reason="auto:routing.template.apply",
                                 conversation_note=f"模板 {params.get('templateCode')} → {params.get('productCode')}")
        try:
            applied = apply_template_to_product(
                store.data, str(params.get("templateCode") or ""),
                str(params.get("productCode") or ""),
                str(params.get("productName") or ""))
        except ValueError as exc:
            return str(exc)
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                    action="routing.template.apply",
                    target={"type": "ROUTING", "id": applied["productCode"]}, power="P2",
                    rationale={"confirmId": confirm_id, "template": applied["template"],
                               "steps": applied["steps"], "assetId": applied.get("assetId")})
        store.save()
        return (f"工艺路线已生成 ✅ {applied['productCode']} ← 模板「{applied['templateName']}」"
                f"（{applied['steps']} 步，工时标「模板」，出处 {applied.get('assetId') or '内置'}）。"
                f"可说「数据齐备度」复查后「柔性排产」。")
    return "未知动作，已忽略。"                          # 白名单外兜底（理论不可达）


# ---------------- 柔性排产（M5：能力池 + 虚拟产线 / 瓶颈产能 / 交期承诺） ----------------
_FLEX_MODE_CN = {"ASC": "正排(交期优先)", "DESC": "倒排(交期倒推)", "BOTTLENECK": "瓶颈锚"}


def _flex_product_name(store: WorldStore, code: str) -> str:
    """物料/产品编码 → 中文名（回复文案友好化）。"""
    m = next((x for x in store.data.get("flexMaterials", []) if x["code"] == code), None)
    return f"{m['name']}({code})" if m else code


def _resolve_order_reference(store: WorldStore, session_id: str, intent: IntentResult) -> IntentResult:
    """把 orderRef=last / 口令中的订单号 解析为 flex orderIds 或 orderNo。"""
    from server.agent_core.session_focus import get_last_order_no, set_focus

    params = dict(intent.params or {})
    wanted_ref = params.get("orderRef") in ("last", "this", "focus")
    order_no = str(params.get("orderNo") or "").strip()
    if not order_no and wanted_ref:
        order_no = get_last_order_no(session_id) or ""
    if not order_no:
        # 世界里只有一单时自动锁定（现场常见：刚导入的主单）
        flex = store.data.get("flexOrders") or []
        sales = store.data.get("salesOrders") or []
        if len(flex) == 1:
            order_no = str(flex[0].get("orderNo") or "")
        elif len(sales) == 1:
            order_no = str(sales[0].get("orderNo") or "")
    if order_no:
        params.pop("_missingFocus", None)
        params["orderNo"] = order_no
        set_focus(session_id, orderNo=order_no)
        fo = next((o for o in (store.data.get("flexOrders") or [])
                   if str(o.get("orderNo")) == order_no), None)
        if fo and intent.intent == "flex.schedule":
            params["orderIds"] = [fo["id"]]
    elif wanted_ref:
        # 「这个订单」但会话未锁定、且池内多单 → 不瞎排全池
        params["_missingFocus"] = True
    return IntentResult(intent=intent.intent, params=params,
                        confidence=intent.confidence, source=intent.source)


def _run_flex(store: WorldStore, intent: IntentResult, actor: str) -> AgentReply:
    """触发柔性排产并回执（短文案 + 结构化 flex-schedule 块：KPI + 虚拟产线表 + 瓶颈）。"""
    from server.aps_domain.flex import run_flex_schedule
    from server.timeutil import parse_dt
    mode = intent.params.get("sortMode") or "BOTTLENECK"
    window = intent.params.get("window")
    order_ids = intent.params.get("orderIds")
    if isinstance(order_ids, list):
        order_ids = [int(x) for x in order_ids if str(x).isdigit() or isinstance(x, int)]
    else:
        order_ids = None
    engine = str(intent.params.get("engine") or "").upper()
    use_ext = bool(engine.startswith("EXTERNAL") or intent.params.get("skillId")
                   or intent.params.get("useExternal"))
    if use_ext:
        from server.engines.external_engine import run_external_flex
        try:
            result = run_external_flex(
                store, skill_id=intent.params.get("skillId"),
                order_ids=order_ids, actor=actor,
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN",
                    action="flex.schedule.external",
                    target={"type": "FLEX", "id": result.get("versionNo")}, power="P1",
                    rationale={"skillId": result.get("skillId"), "runId": result.get("runId")})
        store.save()
    else:
        result = run_flex_schedule(store, sort_mode=mode, order_ids=order_ids or None,
                                   actor=actor, window=window)  # P1
    mode_cn = _FLEX_MODE_CN.get(result["sortMode"], result["sortMode"])
    if result.get("sortMode") == "EXTERNAL" or use_ext:
        mode_cn = f"外部算法({result.get('skillId') or 'skill'})"
    win_cn = {"short": "短窗2h", "mid": "中窗2d", "long": "长窗7d", "full": "全量"}.get(
        result.get("window") or "full", result.get("window") or "full")
    vls = [v for v in store.data["flexVirtualLines"] if v["versionId"] == result["versionId"]]
    orders_by_no = {o["orderNo"]: o for o in store.data["flexOrders"]}

    def _on_time(v) -> bool:                                                # 完工是否不晚于交期
        o = orders_by_no.get(v["orderNo"])
        return bool(o and v["plannedEnd"] and parse_dt(v["plannedEnd"]) <= parse_dt(o["dueDate"] + " 18:00"))

    wos_by_vl: dict[int, list] = {}                                    # 工单按虚拟产线归集（下钻依据）
    for w in store.data["flexWorkOrders"]:
        if w["versionId"] == result["versionId"]:
            wos_by_vl.setdefault(w["vlId"], []).append(w)

    def _steps(vl_id: int) -> list[dict]:                              # 单条虚拟产线的工序级明细
        rows = sorted(wos_by_vl.get(vl_id, []), key=lambda w: w["seq"])
        return [{
            "seq": w["seq"], "operationName": w["operationName"],
            "equipmentName": w["equipmentName"], "equipmentCode": w["equipmentCode"],
            "zone": w.get("zone"), "moldCode": w.get("moldCode"),
            "changeoverMin": w.get("changeoverMin", 0), "moveMin": w.get("moveMin", 0),
            "runMin": w.get("runMin", 0),
            "start": w["plannedStartTime"], "end": w["plannedEndTime"],
            "isBottleneck": w.get("isBottleneck", False),
        } for w in rows]

    lines = [{
        "vlNo": v["vlNo"], "orderNo": v["orderNo"], "product": _flex_product_name(store, v["productCode"]),
        "quantity": v["quantity"], "start": v["plannedStart"], "end": v["plannedEnd"],
        "due": (orders_by_no.get(v["orderNo"]) or {}).get("dueDate"),
        "priority": (orders_by_no.get(v["orderNo"]) or {}).get("priority"),
        "stepCount": len(wos_by_vl.get(v["id"], [])),
        "onTime": _on_time(v),
        "status": "scheduled",
        "steps": _steps(v["id"]),                                      # 工单级依据（点开可见）
    } for v in vls]
    # 未排出的订单也上表，避免「有 KPI、表却空」
    scheduled_nos = {ln["orderNo"] for ln in lines}
    for c in store.data.get("flexConflicts") or []:
        if c.get("versionId") != result["versionId"]:
            continue
        ono = c.get("orderNo")
        if not ono or ono in scheduled_nos:
            continue
        o = orders_by_no.get(ono) or {}
        lines.append({
            "vlNo": "—", "orderNo": ono,
            "product": _flex_product_name(store, o.get("productCode") or ""),
            "quantity": o.get("quantity"), "start": None, "end": None,
            "due": o.get("dueDate"), "priority": o.get("priority"),
            "stepCount": 0, "onTime": False, "status": "blocked",
            "steps": [],
            "blockReason": c.get("description") or c.get("conflictType"),
        })
        scheduled_nos.add(ono)
    lines.sort(key=lambda x: (0 if x.get("status") == "scheduled" else 1, x.get("due") or "", x.get("orderNo") or ""))

    conflicts = [{
        "type": c["conflictType"], "orderNo": c.get("orderNo"),
        "severity": c.get("severity"), "description": c.get("description"),
        "suggestion": c.get("suggestedSolution"),
    } for c in store.data["flexConflicts"] if c["versionId"] == result["versionId"]]

    block = UIBlock(
        blockId=f"flex-sched-{result['versionId']}", type="flex-schedule",
        props={
            "versionNo": result["versionNo"], "modeCn": mode_cn,
            "stats": {"vlCount": result["vlCount"], "woCount": result["woCount"],
                      "makespan": result.get("makespan"), "onTimeCount": result.get("onTimeCount", 0),
                      "conflictCount": result["conflictCount"],
                      "utilization": round(result["avgUtilization"] * 100)},
            "bottleneck": [{"name": b["operationName"], "count": b["poolEquipmentCount"]}
                           for b in result.get("bottleneck", [])],
            "lines": lines,
            "conflicts": conflicts,
            "orderNo": intent.params.get("orderNo"),
            "downloadUrl": None,
            "filename": None,
            "emptyHint": None if lines else "本版没有排出虚拟产线：多半是订单缺工艺/设备。请先「分析一下这个项目」。",
        })
    # 同步生成 Excel 工作计划表，排产结果块可直接下载
    try:
        plan = build_report(store.data, "plan", order_no=intent.params.get("orderNo"))
        if plan.get("reportId") and plan.get("xlsxBytes"):
            saved = persist_report_xlsx(plan["reportId"], plan["xlsxBytes"], plan.get("filename"))
            block.props["downloadUrl"] = f"/api/reports/files/{plan['reportId']}"
            block.props["filename"] = saved["filename"]
            block.props["reportId"] = plan["reportId"]
    except Exception:
        pass
    deferred = result.get("deferredCount") or 0
    focus_no = intent.params.get("orderNo")
    focus_hint = f"订单 {focus_no} · " if focus_no and order_ids else ""
    dl_hint = "点结果块「下载 Excel 工作计划表」可导出完整工序计划。" if block.props.get("downloadUrl") else "可说「生成排产方案报告」下载。"
    text = (f"柔性排产完成 ✅ {focus_hint}版本 {result['versionNo']}（{mode_cn}·{win_cn}）："
            f"{result['vlCount']} 条虚拟产线 / {result['woCount']} 个工单，冲突 {result['conflictCount']} 项"
            + (f"，窗外延期 {deferred}" if deferred else "")
            + f"。{dl_hint}")
    return AgentReply(text=text, blocks=[block],
                      commands=[                                       # 联动：切柔性甘特 + 重拉世界数据
                          ViewportCommand(cmd="viewport.mode", params={"mode": "flex"}, issuedBy="LLM"),
                          ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")])


def _flex_reschedule(store: WorldStore, intent: IntentResult, session_id: str, actor: str) -> AgentReply:
    """分级重排（DY-01）：L2/L3/L4 一律出 P2 确认卡。"""
    from server.aps_domain.flex import preview_reschedule
    from server.agent_core import harness
    level = str(intent.params.get("level") or "L2").upper()
    title, lines = preview_reschedule(store, level)
    params = {"level": level, "sortMode": intent.params.get("sortMode")}
    block = harness.stage_confirmation(session_id, "flex.reschedule", params,
                                       title=title, summary_lines=lines)
    write_audit(store.data, store.next_id, actor=actor, category="GATE",
                action="flex.reschedule.stage", target={"type": "FLEX", "id": level},
                power="P2", rationale={"confirmId": block.props["confirmId"], "level": level})
    store.save()
    return AgentReply(text=f"{title} 属于 P2，需要你确认后执行。", blocks=[block])


def _flex_swap(store: WorldStore, intent: IntentResult, actor: str) -> AgentReply:
    """L1 局部换机：池内备机接手。"""
    from server.aps_domain.flex import local_swap_equipment
    code = intent.params.get("equipmentCode")
    wo_id = intent.params.get("woId")
    try:
        r = local_swap_equipment(
            store, equipment_code=code, wo_id=int(wo_id) if wo_id else None,
            target_code=intent.params.get("targetCode"),
            mark_fault=bool(intent.params.get("markFault", True)), actor=actor)
    except ValueError as exc:
        return AgentReply(text=str(exc))
    lines = [f"{s['orderNo']} {s['operationCode']}：{s['from']} → {s['to']}" for s in r["swapped"][:5]]
    more = f" 等 {len(r['swapped'])} 条" if len(r["swapped"]) > 5 else ""
    fail_n = len(r.get("failed") or [])
    text = (f"L1 局部换机完成 ✅ {len(r['swapped'])} 条工单改挂备机"
            + (f"；{fail_n} 条无备机" if fail_n else "")
            + (f"；设备 {r['faulted']} 已标故障" if r.get("faulted") else "")
            + ("：" + "；".join(lines) + more if lines else "。"))
    return AgentReply(text=text, commands=[
        ViewportCommand(cmd="viewport.mode", params={"mode": "flex"}, issuedBy="LLM"),
        ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM"),
    ])


def _flex_capacity(store: WorldStore) -> AgentReply:
    """瓶颈产能法：短文案 + flex-capacity 块（各池日产能条形 + 瓶颈标注）。"""
    from server.aps_domain.flex import capacity_analysis
    cap = capacity_analysis(store.data)
    if not cap["pools"]:
        return AgentReply(text="尚无可用的柔性产能池数据（无在运设备）。")
    max_daily = max((p["dailyCapacity"] for p in cap["pools"]), default=1) or 1
    pools = [{
        "name": p["operationName"], "equipmentCount": p["equipmentCount"],
        "dailyCapacity": p["dailyCapacity"], "workDays": p["workDays"],
        "isBottleneck": p["isBottleneck"],
        "pct": round(p["dailyCapacity"] / max_daily * 100),                # 相对最大池的产能占比（条形宽度）
    } for p in cap["pools"]]
    bp = cap["bottleneckPool"]
    block = UIBlock(blockId="flex-cap", type="flex-capacity",
                    props={"bottleneckName": bp["operationName"], "bottleneckDaily": bp["dailyCapacity"],
                           "pools": pools})
    text = (f"瓶颈产能评估完成：限制性瓶颈是【{bp['operationName']}】，"
            f"全厂节拍上界≈{bp['dailyCapacity']}件/天（按能力池实时算）。")
    return AgentReply(text=text, blocks=[block],
                      commands=[  # EX-10：切产能池仪表盘 + 刷新世界
                          ViewportCommand(cmd="viewport.mode", params={"mode": "pool"}, issuedBy="LLM"),
                          ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")])


def _flex_simulate_due(store: WorldStore, intent: IntentResult) -> AgentReply:
    """交期承诺模拟：短文案 + flex-due 块（乐观/预计/悲观 + 缺口）。"""
    from server.aps_domain.flex import simulate_due
    code = str(intent.params.get("productCode") or "")
    qty = int(intent.params.get("quantity") or 0)
    if not code or qty <= 0:
        return AgentReply(text="请告诉我产品与数量，例如：「PDU 500套什么时候能交」或「高压线束 800件多久能做完」。")
    r = simulate_due(store, code, qty, sort_mode=intent.params.get("sortMode"))
    block = UIBlock(blockId=f"flex-due-{code}", type="flex-due",
                    props={"productName": _flex_product_name(store, code), "quantity": qty,
                           "optimistic": r.get("optimisticFinish"), "expected": r.get("expectedFinish"),
                           "pessimistic": r.get("pessimisticFinish"),
                           "gaps": r.get("gaps") or [],
                           "bottleneck": [{"name": b["operationName"], "count": b["poolEquipmentCount"]}
                                          for b in r.get("bottleneck", [])]})
    gaps_txt = "；".join(g["message"] for g in (r.get("gaps") or [])[:2])
    text = (f"交期承诺模拟完成：{_flex_product_name(store, code)} × {qty}"
            f"（乐观 {r.get('optimisticFinish') or '—'} / 预计 {r.get('expectedFinish') or '—'} / "
            f"悲观 {r.get('pessimisticFinish') or '—'}）。{gaps_txt}")
    return AgentReply(text=text, blocks=[block])


def _flex_compare(store: WorldStore) -> AgentReply:
    from server.aps_domain.analytics import matrix_from_flex_rows
    from server.aps_domain.flex import compare_sort_modes
    cmp = compare_sort_modes(store, compress_due=True)
    block = UIBlock(blockId="flex-compare", type="flex-compare",
                    props={"rows": cmp["rows"], "hint": cmp["hint"], "compressedDue": cmp["compressedDue"],
                           "table": matrix_from_flex_rows(cmp["rows"], hint=cmp.get("hint"))})
    best = min(cmp["rows"], key=lambda r: (r["totalTardiness"], -r["onTimeCount"]))
    text = (f"三模式对比完成（已压缩交期制造压力）。当前压力下较优："
            f"【{best['label']}】延迟 {best['totalTardiness']}h、准时 {best['onTimeCount']}/{best['orderCount']}。"
            "已打开对比表视口。")
    return AgentReply(
        text=text, blocks=[block],
        commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "compare"}, issuedBy="LLM")])


def _flex_rush(store: WorldStore, intent: IntentResult, actor: str) -> AgentReply:
    from server.aps_domain.flex import insert_rush_order
    code = str(intent.params.get("productCode") or "HV-HARNESS")
    qty = int(intent.params.get("quantity") or 50)
    try:
        r = insert_rush_order(store, code, qty, due_date=intent.params.get("dueDate"),
                              priority=int(intent.params.get("priority") or 1), actor=actor)
    except ValueError as exc:
        return AgentReply(text=str(exc))
    o = r["order"]
    s = r["schedule"]
    text = (f"急单 {o['orderNo']} 已插入（{_flex_product_name(store, code)} × {qty}，交期 {o['dueDate']}），"
            f"瓶颈锚重排完成：版本 {s['versionNo']}，虚拟产线 {s['vlCount']}，"
            f"急单完工 {r.get('plannedEnd') or '—'}，冲突 {s['conflictCount']}。")
    return AgentReply(text=text, commands=[
        ViewportCommand(cmd="viewport.mode", params={"mode": "flex"}, issuedBy="LLM"),
        ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM"),
    ])


def _flex_fault(store: WorldStore, intent: IntentResult, actor: str) -> AgentReply:
    from server.aps_domain.flex import apply_equipment_fault
    code = str(intent.params.get("equipmentCode") or "PRESS-01")
    status = str(intent.params.get("status") or "MAINTENANCE").upper()
    try:
        r = apply_equipment_fault(store, code, status=status, reschedule=True, actor=actor)
    except ValueError as exc:
        return AgentReply(text=str(exc))
    eq = r["equipment"]
    bn_before = r.get("capacityBefore") or {}
    bn_after = r.get("capacityAfter") or {}
    no_cap = [c for c in r.get("conflicts") or [] if c.get("conflictType") == "NO_CAPABILITY"]
    level = r.get("responseLevel")
    text = (f"设备 {eq['code']}（{eq['name']}）{eq['beforeStatus']} → {eq['afterStatus']}。"
            f"瓶颈日产能 {bn_before.get('dailyCapacity', '—')} → {bn_after.get('dailyCapacity', '—')} 件/天。")
    if level == "L1":
        n = len((r.get("swap") or {}).get("swapped") or [])
        text += f" 已按 L1 局部换机处理（{n} 条工单改挂备机，他单不动）。"
    elif no_cap:
        text += f" 出现 {len(no_cap)} 条无能力设备冲突（单点瓶颈停摆风险）。"
    elif eq["afterStatus"] == "MAINTENANCE" and "PRESS" in eq["code"]:
        text += " 压接池仍有冗余；L1 不可用时已缩池重排。"
    s = r.get("schedule") or {}
    if s:
        text += f" 已重排版本 {s.get('versionNo')}，冲突 {s.get('conflictCount', 0)}。"
    return AgentReply(text=text, commands=[
        ViewportCommand(cmd="viewport.mode", params={"mode": "pool" if level != "L1" else "flex"},
                        issuedBy="LLM"),
        ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM"),
    ])


def _conflict_list(store: WorldStore, intent: IntentResult) -> AgentReply:
    from server.aps_domain.conflicts import list_conflict_center
    from server.contracts import UIBlock
    scope = str(intent.params.get("scope") or "flex")
    data = list_conflict_center(store.data, scope=scope)
    if not data["rows"]:
        return AgentReply(text="当前最新版本无未解决冲突 ✅")
    lines = []
    for r in data["rows"][:8]:
        top = (r["fixes"][0]["label"] if r.get("fixes") else "—")
        lines.append(f"#{r['id']} [{r['severity']}] {r['conflictType']}：{r['description']} → {top}")
    more = f"\n…共 {data['total']} 条" if data["total"] > 8 else ""
    block = UIBlock(
        blockId="conflict-center", type="conflict-center",
        props={"total": data["total"], "critical": data["critical"], "major": data["major"],
               "rows": data["rows"][:20]})
    return AgentReply(
        text=(f"冲突中心：共 {data['total']} 条（危急 {data['critical']} / 重大 {data['major']}）。\n"
              + "\n".join(lines) + more + "\n可在柔性工作台「冲突」页一键修复。"),
        blocks=[block],
        commands=[ViewportCommand(cmd="viewport.highlight", params={"what": "conflict"}, issuedBy="LLM")],
    )


def _conflict_resolve(store: WorldStore, intent: IntentResult, session_id: str, actor: str) -> AgentReply:
    from server.aps_domain.conflicts import apply_conflict_fix, list_conflict_center
    from server.contracts import UIBlock
    cid = intent.params.get("conflictId")
    action = intent.params.get("action")
    if not cid:
        data = list_conflict_center(store.data, scope="flex")
        if not data["rows"]:
            return AgentReply(text="没有可修复的冲突。")
        row = data["rows"][0]
        fixes = "；".join(f["label"] for f in row["fixes"][:3])
        return AgentReply(text=f"建议先处理 #{row['id']}：{row['description']}\n可选：{fixes}")
    try:
        r = apply_conflict_fix(store, int(cid), str(action or "note"),
                                params=intent.params.get("fixParams") or {},
                                actor=actor, session_id=session_id)
    except (ValueError, PermissionError) as exc:
        return AgentReply(text=str(exc))
    blocks = []
    if r.get("block"):
        blocks.append(UIBlock.model_validate(r["block"]))
    cmds = [ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")]
    if r.get("applied"):
        cmds.insert(0, ViewportCommand(cmd="viewport.mode", params={"mode": "flex"}, issuedBy="LLM"))
    return AgentReply(text=r.get("message") or "已处理", blocks=blocks, commands=cmds)


async def handle_intent(store: WorldStore, session_id: str, intent: IntentResult, actor: str = "planner") -> AgentReply:
    """意图 → 回复 的总编排（gateway 调用；P0/P1 直通，P2 出卡）。"""
    name = intent.intent                               # 意图名
    # 解析「这个订单」等指代 → 具体订单号 / flex orderIds
    if name in ("flex.schedule", "schedule.run", "plan.trace", "master.query", "report.generate"):
        intent = _resolve_order_reference(store, session_id, intent)
        if intent.params.get("_missingFocus") and name != "master.query":
            return AgentReply(
                text="刚才没有锁定具体订单。请先说「查询订单 102285668」，"
                     "或直接说「给订单 102285668 排产」。")
        if intent.params.get("_missingFocus") and name == "master.query" and intent.params.get("entity") == "mrp":
            return AgentReply(
                text="刚才没有锁定具体订单。请先说「查询订单 102285668」，"
                     "或直接问「订单 102285668 有委外吗」。")
    # ---- 排产（P1） ----
    if name == "schedule.run":
        return _run_schedule(store, intent, actor)     # 试排并回执
    # ---- 发布（P2 → 确认卡） ----
    if name == "schedule.publish":
        return _stage_publish(store, session_id, actor)
    # ---- 重置数据（P2 → 确认卡） ----
    if name == "data.reset":
        return _stage_reset(store, session_id, actor)
    # ---- 新建/编辑订单（P2 → 确认卡；对话侧建单） ----
    if name == "order.upsert":
        return _stage_order_upsert(store, session_id, intent, actor)
    # ---- 订单状态动作（P2 → 确认卡；对话与页面共用 action） ----
    if name in ("order.cancel", "order.complete", "order.delete"):
        from server.aps_domain.orders import confirmation_for_order_action, find_order
        order_no = str(intent.params.get("orderNo") or "")
        order = find_order(store.data, order_no=order_no)
        if order is None:
            return AgentReply(text=f"没找到订单 {order_no}，可以在订单面板核对订单号。")
        title, lines = confirmation_for_order_action(store.data, name, {"id": order["id"]})
        block = harness.stage_confirmation(session_id, name, {"id": order["id"]}, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action=name + ".stage",
                    target={"type": "SALES_ORDER", "id": order["id"], "orderNo": order["orderNo"]},
                    power="P2", rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 订单写入，需要你确认。", blocks=[block])
    if name == "order.clear":
        from server.aps_domain.orders import confirmation_for_order_action
        try:
            title, lines = confirmation_for_order_action(store.data, "order.clear", {})
        except ValueError as exc:
            return AgentReply(text=str(exc))
        block = harness.stage_confirmation(session_id, "order.clear", {}, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="order.clear.stage",
                    target={"type": "SALES_ORDER", "id": "ALL"}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 破坏性写入，需要你确认。", blocks=[block])
    # ---- OR-03 订单池：提交（P1）/ 批准驳回（P2）/ 摘要（P0） ----
    if name == "order.pool":
        from server.aps_domain.orders import list_orders, pool_summary
        sm = pool_summary(store.data)
        pending = [o for o in list_orders(store.data) if o["status"] == "SUBMITTED"]
        lines = [
            f"订单池：全部 {sm['all']} · 可排产 {sm['schedulable']} · 待审 {sm['pending']} · "
            f"已批 {sm['approved']} · 变更 {sm['changed']} · 草稿/驳回 {sm['draft']}",
        ]
        if pending:
            lines.append("待审：" + "、".join(f"{o['orderNo']}({o['customerName']})" for o in pending[:8]))
            lines.append("可说「批量批准」或「批准订单 SOxxx」。")
        else:
            lines.append("当前无待审订单。新建订单默认为 DRAFT，需「提交审核」后再批准。")
        return AgentReply(text="\n".join(lines))
    # ---- OR-04 紧急插单：快评（P1 沙盒）/ 采用（P2） ----
    if name == "rush.evaluate":
        from server.aps_domain.rush import evaluate_rush, format_impact_text, impact_to_block
        p = dict(intent.params or {})
        try:
            impact = harness.guard("rush.evaluate", p, lambda: evaluate_rush(store.data, p))
        except ValueError as exc:
            return AgentReply(text=str(exc))
        _LAST_RUSH_EVAL.clear()
        _LAST_RUSH_EVAL.update(impact)
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="rush.evaluate",
                    target={"type": "SANDBOX", "id": impact["evalId"]}, power="P1",
                    rationale={"affected": impact["affectedOrderCount"],
                               "delayDelta": impact["delayDelta"],
                               "conflictDelta": impact["conflictDelta"]})
        store.save()
        return AgentReply(
            text=format_impact_text(impact),
            blocks=[impact_to_block(impact)],
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "due"}, issuedBy="LLM")])
    if name == "rush.apply":
        p = dict(intent.params or {})
        if not p.get("payload") and not p.get("orderNo") and not p.get("productCode") and not p.get("productId"):
            if not _LAST_RUSH_EVAL:
                return AgentReply(text="还没有插单快评结果。请先说「插单快评」或「紧急插单 200件控制器A」。")
            p = {
                "payload": _LAST_RUSH_EVAL.get("payload"),
                "strategy": _LAST_RUSH_EVAL.get("strategy"),
                "evalId": _LAST_RUSH_EVAL.get("evalId"),
            }
        rush = p.get("payload") or p
        label = rush.get("orderNo") or f"{rush.get('customerName', '急单')}×{rush.get('quantity', '?')}"
        block = harness.stage_confirmation(
            session_id, "rush.apply", p,
            title=f"采用紧急插单 · {label}",
            summary_lines=[
                f"策略：{p.get('strategy') or 'DELIVERY_FIRST'}",
                "将写入主干订单池（APPROVED + isRush），并生成 DRAFT 排产版本",
                "基准已发布版本不回写；执行前自动建档，可回滚",
                f"快评 ID：{p.get('evalId') or '（直接采用）'}",
            ],
        )
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="rush.apply.stage",
                    target={"type": "SALES_ORDER", "id": rush.get("orderNo") or "NEW"}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text="采用插单属于 P2 写操作，需要你确认（见下方确认卡）。", blocks=[block])
    # ---- OR-05 预测 / 长周期订单 ----
    if name == "forecast.query":
        from server.aps_domain.forecast import forecast_summary, list_forecasts
        sm = forecast_summary(store.data)
        rows = list_forecasts(store.data)
        lines = [
            f"预测订单：全部 {sm['all']} · 生效 {sm['active']} · 草稿 {sm['draft']} · "
            f"已转正 {sm['consumed']} · 取消 {sm['cancelled']}",
        ]
        for f in rows[:8]:
            lines.append(
                f"· {f['forecastNo']} {f.get('productName')}×{f.get('quantity')} "
                f"{f.get('periodStart')}~{f.get('periodEnd')} · {f.get('status')} · "
                f"置信{int((f.get('confidence') or 0)*100)}%"
            )
        if sm["active"]:
            lines.append("可说「预测纳入试排」或「预测转正 FCxxx」。")
        return AgentReply(text="\n".join(lines))
    if name in ("forecast.upsert", "forecast.delete", "forecast.convert"):
        from server.aps_domain.forecast import confirmation_for_forecast_action
        p = dict(intent.params or {})
        try:
            title, lines = confirmation_for_forecast_action(store.data, name, p)
        except ValueError as exc:
            return AgentReply(text=str(exc))
        block = harness.stage_confirmation(session_id, name, p, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action=f"{name}.stage",
                    target={"type": "FORECAST_ORDER", "id": p.get("id") or p.get("forecastNo") or "NEW"},
                    power="P2", rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    # ---- PL-01/PL-02 时间分桶 + 粗能力 ----
    if name == "plan.buckets":
        from server.aps_domain.planning import build_plan_buckets
        p = dict(intent.params or {})
        try:
            report = build_plan_buckets(
                store.data,
                mode=str(p.get("mode") or "HYBRID"),
                start_date=p.get("startDate"),
                horizon_days=int(p.get("horizonDays") or 90),
                include_forecast=bool(p.get("includeForecast", True)),
                capacity_mode=str(p.get("capacityMode") or "FINITE"),
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        sm = report["summary"]
        cap_label = "无限" if report.get("capacityMode") == "INFINITE" else "有限"
        lines = [
            f"时间分桶（{report['mode']} · {cap_label}产能）：桶 {sm['bucketCount']} · "
            f"超载 {sm['overCount']} · 预警 {sm['warnCount']} · 正常 {sm['okCount']}",
            f"日产能 {report['dailyCapacity']} 件 · 展望 {report['horizonDays']} 天 · "
            + (
                f"峰值所需日产能 {sm.get('peakRequiredDaily')} · 有限参照超载桶 {sm.get('finiteOverCount')}"
                if report.get("capacityMode") == "INFINITE"
                else f"总负荷 {round(sm['overallLoad']*100)}%"
            )
            + ("（含预测）" if report["includeForecast"] else "（仅确定订单）"),
        ]
        for b in report["buckets"]:
            show = b["status"] in ("OVER", "WARN") or b["demandQty"] > 0 or b.get("finiteStatus") == "OVER"
            if not show:
                continue
            if report.get("capacityMode") == "INFINITE":
                lines.append(
                    f"· {b['label']}({b['kind']}) 需求{b['demandQty']} 需日产{b.get('requiredDaily')} "
                    f"有限参照{round((b.get('finiteLoadRatio') or 0)*100)}% [{b.get('finiteStatus')}]"
                )
            else:
                lines.append(
                    f"· {b['label']}({b['kind']}) 需求{b['demandQty']}/能力{b['capacity']} "
                    f"负荷{round(b['loadRatio']*100)}% [{b['status']}]"
                )
            if len(lines) > 14:
                lines.append("…（完整表见右侧「分桶计划」视口）")
                break
        return AgentReply(
            text="\n".join(lines),
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "plan"}, issuedBy="LLM")],
        )
    if name == "plan.rccp":
        from server.aps_domain.planning import build_rccp_compare
        p = dict(intent.params or {})
        try:
            cmp_ = build_rccp_compare(
                store.data,
                mode=str(p.get("mode") or "HYBRID"),
                start_date=p.get("startDate"),
                horizon_days=int(p.get("horizonDays") or 90),
                include_forecast=bool(p.get("includeForecast", True)),
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        d = cmp_["delta"]
        lines = [
            f"RCCP 粗能力对照（{cmp_['mode']}）：{d['message']}",
            f"日产能缺口（峰值所需−当前）≈ {d['capacityGapDaily']} 件/天",
        ]
        for s in (cmp_.get("shortfallBuckets") or [])[:6]:
            lines.append(
                f"· {s['label']} 有限缺口 {s['finiteGap']} · 所需日产 {s['requiredDaily']} "
                f"· 负荷 {round((s.get('finiteLoadRatio') or 0)*100)}%"
            )
        lines.append("可说「无限产能粗评」或在分桶视口切换有限/无限。")
        return AgentReply(
            text="\n".join(lines),
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "plan"}, issuedBy="LLM")],
        )
    if name == "plan.feasibility":
        from server.aps_domain.planning import build_feasibility
        p = dict(intent.params or {})
        try:
            report = build_feasibility(
                store.data,
                start_date=p.get("startDate"),
                horizon_days=int(p.get("horizonDays") or 90),
                include_forecast=bool(p.get("includeForecast", True)),
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        sm = report["summary"]
        verdict = report["verdict"]
        lines = [
            f"可行性结论：【{verdict}】 · 订单 {sm['all']} "
            f"（可行 {sm['feasible']} / 风险 {sm['atRisk']} / 不可行 {sm['infeasible']} / 过期 {sm['late']}）",
            f"日产能 {report['dailyCapacity']} · 超载桶 {sm['shortfallBucketCount']} · "
            f"分桶总负荷 {round((sm.get('overallLoad') or 0)*100)}%"
            + ("（含预测）" if report["includeForecast"] else "（仅确定订单）"),
        ]
        for g in (report.get("gaps") or [])[:5]:
            lines.append(f"· 缺口桶 {g['label']} 负荷{round((g.get('loadRatio') or 0)*100)}% 缺口{g.get('gap')}")
        risky = [o for o in report["orders"] if o["status"] in ("INFEASIBLE", "AT_RISK", "LATE")]
        for o in risky[:6]:
            reason = ("；".join(o.get("reasons") or []) or o["status"])
            lines.append(f"· {o['ref']} 交期{o['dueDate']} slack={o['slack']} [{o['status']}] {reason}")
        if not risky:
            lines.append("当前累计粗能力下，已批准需求均可按期覆盖。")
        lines.append("完整表见右侧「分桶计划」→ 可行性。")
        return AgentReply(
            text="\n".join(lines),
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "plan"}, issuedBy="LLM")],
        )
    if name == "plan.inventory":
        from server.aps_domain.inventory import build_inventory_projection
        p = dict(intent.params or {})
        try:
            report = build_inventory_projection(
                store.data,
                material_code=p.get("materialCode"),
                material_type=p.get("materialType"),
                horizon_days=int(p.get("horizonDays") or 30),
                bucket=str(p.get("bucket") or "DAY"),
                include_forecast=bool(p.get("includeForecast", True)),
                start_date=p.get("startDate"),
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        sm = report["summary"]
        lines = [
            f"库存投影（{report['bucket']} · {report['horizonDays']}天）："
            f"物料 {sm['materialCount']} · 断料 {sm['stockoutCount']} · "
            f"低于安全库存 {sm['belowSafetyCount']} · 正常 {sm['okCount']}",
        ]
        risky = [m for m in report["materials"] if m["alert"] != "OK"]
        for m in (risky or report["materials"])[:8]:
            lines.append(
                f"· {m['code']} {m['name']} 期初{m['openingStock']}→末{m['endingProjected']} "
                f"[{m['alert']}]"
                + (f" 首警{m['firstAlertDate']}" if m.get("firstAlertDate") else "")
            )
        lines.append("完整曲线见右侧「分桶计划」→ 库存投影。")
        return AgentReply(
            text="\n".join(lines),
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "plan"}, issuedBy="LLM")],
        )
    if name == "plan.leveling":
        from server.aps_domain.planning import build_leveling
        p = dict(intent.params or {})
        try:
            report = build_leveling(
                store.data,
                mode=str(p.get("mode") or "WEEK"),
                start_date=p.get("startDate"),
                horizon_days=int(p.get("horizonDays") or 90),
                include_forecast=bool(p.get("includeForecast", True)),
                target_load=float(p.get("targetLoad") or 0.85),
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        b, a, imp = report["before"], report["after"], report["improvement"]
        lines = [
            f"产能削峰（{report['mode']} · 目标≤{int(report['targetLoad']*100)}%）："
            f"峰值负荷 {round(b['peakLoad']*100)}%→{round(a['peakLoad']*100)}% · "
            f"超载桶 {b['overCount']}→{a['overCount']} · 建议挪动 {imp['moveCount']} 笔/{imp['movedQty']} 件",
        ]
        for m in report["moves"][:8]:
            arrow = "↑提前" if m["direction"] == "PULL_AHEAD" else "↓延后"
            lines.append(
                f"· {arrow} {m['quantity']}×{m.get('productCode') or '?'} "
                f"{m['fromLabel']}→{m['toLabel']}"
            )
        if not report["moves"]:
            lines.append("当前分桶无明显超载，无需削峰。")
        lines.append("完整对照见右侧「分桶计划」→ 削峰。本切片不改交期。")
        return AgentReply(
            text="\n".join(lines),
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "plan"}, issuedBy="LLM")],
        )
    if name == "plan.supply":
        from server.aps_domain.planning import build_supply_decisions
        p = dict(intent.params or {})
        try:
            report = build_supply_decisions(
                store.data,
                mode=str(p.get("mode") or "WEEK"),
                start_date=p.get("startDate"),
                horizon_days=int(p.get("horizonDays") or 90),
                include_forecast=bool(p.get("includeForecast", True)),
                target_load=float(p.get("targetLoad") or 0.85),
            )
        except ValueError as exc:
            return AgentReply(text=str(exc))
        lines = [
            f"产供决策【{report['verdict']}】：{report['message']}",
            f"削峰挪动 {report['leveling']['movedQty']} 件 · 残留缺口 {report['summary']['residualGap']} · "
            f"选项 {report['summary']['optionCount']} 条",
        ]
        for o in report["options"][:8]:
            lines.append(
                f"· [{o['label']}] {o['bucketLabel']} 覆盖{o['coverQty']} "
                f"成本指数{o['costIndex']} · {o['detail']}"
            )
        if report["verdict"] == "BALANCED":
            lines.append("可继续试排或查看库存投影。")
        else:
            lines.append("完整方案见右侧「分桶计划」→ 产供。本切片不写主干。")
        return AgentReply(
            text="\n".join(lines),
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "plan"}, issuedBy="LLM")],
        )
    if name == "order.submit":
        from server.aps_domain.orders import apply_order_submit, find_order
        p = dict(intent.params or {})
        if not p.get("id") and not p.get("orderNo"):
            # 无单号：取最近一条可提交订单
            cand = next((o for o in reversed(store.data.get("salesOrders", []))
                         if o.get("status") in ("DRAFT", "REJECTED", "CHANGED")), None)
            if not cand:
                return AgentReply(text="没有可提交审核的订单（需 DRAFT/REJECTED/CHANGED）。")
            p["id"] = cand["id"]
        try:
            applied = harness.guard("order.submit", p, lambda: apply_order_submit(store.data, p))
        except ValueError as exc:
            return AgentReply(text=str(exc))
        order = applied["order"]
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="order.submit",
                    target={"type": "SALES_ORDER", "id": order["id"], "orderNo": order["orderNo"]},
                    power="P1", rationale={"from": applied.get("beforeStatus"), "to": "SUBMITTED"})
        store.save()
        return AgentReply(
            text=(f"订单 {order['orderNo']} 已提交审核 ✅（{applied.get('beforeStatus')} → SUBMITTED）。"
                  f"可说「批准订单 {order['orderNo']}」或在订单面板批量批准。"),
            commands=[ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")])
    if name in ("order.approve", "order.reject"):
        from server.aps_domain.orders import confirmation_for_order_action, _resolve_order_ids
        payload = dict(intent.params or {})
        if payload.get("orderIds") == "pending":
            payload["orderIds"] = "pending"
        elif payload.get("orderNo") and not payload.get("id"):
            pass
        try:
            # 预检可解析到订单
            ids = _resolve_order_ids(store.data, payload)
            if not ids and payload.get("orderNo"):
                return AgentReply(text=f"订单 {payload['orderNo']} 不在待审状态（需 SUBMITTED/CHANGED）。")
            if not ids:
                return AgentReply(text="没有可审核的订单。可先「提交审核」或查看「订单池」。")
            payload["orderIds"] = ids
            title, lines = confirmation_for_order_action(store.data, name, payload)
        except ValueError as exc:
            return AgentReply(text=str(exc))
        block = harness.stage_confirmation(session_id, name, payload, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action=name + ".stage",
                    target={"type": "SALES_ORDER", "id": ids[0] if len(ids) == 1 else "BATCH"},
                    power="P2", rationale={"confirmId": block.props["confirmId"], "count": len(ids)})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    if name == "master.clear":
        from server.aps_domain.masterdata import confirmation_for_master_action
        scope = str(intent.params.get("scope") or "all")
        try:
            title, lines = confirmation_for_master_action(store.data, "master.clear", {"scope": scope})
        except ValueError as exc:
            return AgentReply(text=str(exc))
        block = harness.stage_confirmation(session_id, "master.clear", {"scope": scope}, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="master.clear.stage",
                    target={"type": "MASTER_CLEAR", "id": scope}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 主数据写入，需要你确认。", blocks=[block])
    # ---- 对话新建物料（P2） ----
    if name == "master.material.upsert":
        from server.aps_domain.masterdata import confirmation_for_master_action
        payload = dict(intent.params or {})
        missing = [label for key, label in (("code", "编码"), ("name", "名称")) if not payload.get(key)]
        if missing:
            return AgentReply(text=f"要新建物料还差：{'、'.join(missing)}。\n"
                                   "例如：「新建物料 编码 SCR-NEW 名称 不锈钢螺丝 类型 原料 库存 800」。")
        payload.setdefault("type", "RAW_MATERIAL")
        payload.setdefault("unit", "件")
        try:
            title, lines = confirmation_for_master_action(store.data, "master.material.upsert", payload)
        except ValueError as exc:
            return AgentReply(text=f"物料信息有误：{exc}")
        block = harness.stage_confirmation(session_id, "master.material.upsert", payload, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="master.material.upsert.stage",
                    target={"type": "MATERIAL", "id": payload.get("code")}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 主数据写入，需要你确认。", blocks=[block])
    if name == "changeover.query":
        from server.aps_domain.changeover import build_changeover_view
        view = build_changeover_view(store.data)
        lines = [
            f"换型矩阵：{len(view['rows'])} 条显式规则 · 产品族 {len(view['families'])} 个",
            f"缺省跨族 {view['defaultCrossFamilyMin']} 分；同族 0 分",
        ]
        for r in view["rows"][:12]:
            lines.append(f"· {r['fromFamily']} → {r['toFamily']} = {r['setupMinutes']} 分"
                         + (f"（{r['note']}）" if r.get("note") else ""))
        if not view["rows"]:
            lines.append("尚无显式规则，跨族走缺省。可说「设置换型 CTRL-STD 到 CTRL-HF 45分」。")
        lines.append("完整编辑见主数据 → 工艺模型 → 换型。")
        return AgentReply(text="\n".join(lines))
    if name == "campaign.preview":
        from server.aps_domain.campaign import preview_campaigns
        p = dict(intent.params or {})
        report = preview_campaigns(
            store.data,
            window_days=int(p.get("windowDays") or 7),
            include_forecast=bool(p.get("includeForecast", False)),
        )
        s = report["summary"]
        lines = [
            f"战役预览：输入 {s['inputOrders']} 单 → {s['campaignCount']} 场"
            f"（合并 {s['mergedCampaigns']} 场，省 {s['poSaved']} 个 PO）",
            f"交期窗口 {report['windowDays']} 天",
        ]
        for c in report["campaigns"][:10]:
            tag = "战役" if c["isCampaign"] else "单排"
            nos = "/".join(str(x) for x in (c.get("sourceOrderNos") or [])[:4])
            lines.append(
                f"· [{tag}] {c['productCode']} ×{c['totalQty']} · {c['memberCount']} 单"
                f" · 交期 {c.get('earliestDue')}~{c.get('latestDue')} · {nos}"
            )
        lines.append("确认后可说「战役合并试排」。")
        return AgentReply(text="\n".join(lines))
    if name == "master.changeover.upsert":
        from server.aps_domain.masterdata import confirmation_for_master_action
        payload = dict(intent.params or {})
        try:
            title, lines = confirmation_for_master_action(store.data, "master.changeover.upsert", payload)
        except ValueError as exc:
            return AgentReply(text=f"换型矩阵有误：{exc}")
        block = harness.stage_confirmation(
            session_id, "master.changeover.upsert", payload, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="master.changeover.upsert.stage",
                    target={"type": "CHANGEOVER",
                            "id": f"{payload.get('fromFamily')}→{payload.get('toFamily')}"},
                    power="P2", rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 主数据写入，需要你确认。", blocks=[block])
    # ---- 自然语言批量导入订单/物料（P2） ----
    if name == "data.import":
        from server.aps_domain.intake import confirmation_for_import, parse_import
        text = str(intent.params.get("text") or "")
        parsed = parse_import(text, store.data)
        if intent.params.get("kind") in ("orders", "materials"):
            parsed["kind"] = intent.params["kind"]
        if not parsed["rows"]:
            hint = ("订单格式示例：\n导入订单\n客户A,成品料号,200,2026-08-01,VIP\n客户 客户B 产品 成品名称 数量 100 交期 8月20日"
                    if parsed["kind"] == "orders" else
                    "物料格式示例：\n导入物料\nSCR-NEW,不锈钢螺丝,原料,包,800\n编码 PCB-X 名称 试验板 类型 原料 库存 200")
            err = "；".join(parsed.get("errors", [])[:3])
            return AgentReply(text=f"没有解析出可导入的行。{err}\n{hint}")
        title, lines = confirmation_for_import(parsed)
        payload = {"kind": parsed["kind"], "rows": parsed["rows"]}
        block = harness.stage_confirmation(session_id, "data.import", payload, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="data.import.stage",
                    target={"type": "IMPORT", "id": parsed["kind"]}, power="P2",
                    rationale={"confirmId": block.props["confirmId"], "count": len(parsed["rows"])})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写入，需要你确认。", blocks=[block])
    # ---- 订单分解（P1：MRP 建议草稿，不碰主数据与订单本体） ----
    if name == "order.decompose":
        from server.aps_domain.mrp import decompose_orders, summarize_decomposition
        try:
            result = decompose_orders(store.data, store.next_id, intent.params.get("orderNo"))
        except ValueError as exc:
            return AgentReply(text=str(exc))
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="order.decompose",
                    target={"type": "MRP", "id": intent.params.get("orderNo") or "ALL"}, power="P1",
                    rationale={"purchase": len(result["purchase"]), "outsource": len(result["outsource"])})
        store.save()
        return AgentReply(text=summarize_decomposition(result))

    # ---- 主数据/订单自然语言查询（P0 只读） ----
    if name == "master.query":
        from server.agent_core.session_focus import set_focus
        from server.aps_domain.master_query import format_master_query, run_master_query
        code = intent.params.get("code") or intent.params.get("orderNo")
        result = run_master_query(
            store.data,
            entity=intent.params.get("entity"),
            code=code,
            text=str(intent.params.get("query") or ""),
            aspect=intent.params.get("aspect"),
        )
        # 记住刚查到的订单，供「把这个订单排产 / 有委外吗」指代
        rows = result.get("rows") or []
        if result.get("entity") == "order" and rows:
            set_focus(session_id, orderNo=rows[0].get("orderNo"),
                      productCode=rows[0].get("productCode"))
        elif result.get("entity") == "mrp" and result.get("orderNo"):
            set_focus(session_id, orderNo=result.get("orderNo"),
                      productCode=result.get("productCode"))
        elif result.get("productCode"):
            set_focus(session_id, productCode=result.get("productCode"))
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="master.query",
                    target={"type": "MASTER", "id": result.get("entity") or "overview"}, power="P0",
                    rationale={"entity": result.get("entity"), "code": code,
                               "count": result.get("count")})
        store.save()
        return AgentReply(text=format_master_query(result))
    # ---- 计划追溯（P0：SO→主数据→分解→PO/WO→负荷/库存） ----
    if name == "plan.trace":
        from server.aps_domain.trace import plan_trace, summarize_trace
        track = intent.params.get("track")
        try:
            result = plan_trace(store.data, intent.params.get("orderNo"), track=track)
        except ValueError as exc:
            return AgentReply(text=str(exc))
        # both 形态：聊天只摘要；单轨带前 3 单
        if result.get("track") == "both":
            block = UIBlock(blockId="plan-trace", type="plan-trace",
                            props={"track": "both", "count": result["count"],
                                   "fixedCount": (result.get("fixed") or {}).get("count", 0),
                                   "flexCount": (result.get("flex") or {}).get("count", 0),
                                   "orders": ((result.get("flex") or {}).get("orders")
                                              or (result.get("fixed") or {}).get("orders") or [])[:2]})
        else:
            preview = {**result, "orders": result["orders"][:3]}
            block = UIBlock(blockId="plan-trace", type="plan-trace", props=preview)
        hint = ("完整链路可在「柔性工作台 → 钉扎」或「订单 → 追溯」查看。"
                if (result.get("track") == "flex"
                    or (intent.params.get("orderNo") or "").upper().startswith("FO-"))
                else "完整链路可在右侧「订单 → 追溯」查看。")
        return AgentReply(text=summarize_trace(result) + "\n" + hint, blocks=[block])
    # ---- MRP 建议单下达（P2 → 确认卡：DRAFT 采购/委外转正式） ----
    if name == "mrp.release":
        from server.aps_domain.mrp import confirmation_for_mrp_release
        order_no = str(intent.params.get("orderNo") or "") or None
        kind = str(intent.params.get("kind") or "all")
        try:
            title, lines = confirmation_for_mrp_release(store.data, order_no, kind)
        except ValueError as exc:
            return AgentReply(text=str(exc))
        params = {"orderNo": order_no, "kind": kind}
        block = harness.stage_confirmation(session_id, "mrp.release", params, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="mrp.release.stage",
                    target={"type": "MRP", "id": order_no or "ALL"}, power="P2",
                    rationale={"confirmId": block.props["confirmId"], "kind": kind})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    # ---- 现场完整生产路线（P2：替换 flex*） ----
    if name == "flex.site.load":
        from server.aps_domain.kangni_intake import build_flex_bundle, confirmation_for_site_load
        try:
            bundle = build_flex_bundle(
                intent.params.get("routePath") or None,
                intent.params.get("dataDir") or None,
                include_sibling_orders=intent.params.get("includeSiblings", False) is True,
                station_count=int(intent.params.get("stationCount") or 4),
            )
        except (FileNotFoundError, ValueError) as exc:
            return AgentReply(text=f"无法加载现场路线：{exc}")
        meta = bundle.get("_meta") or {}
        title, lines = confirmation_for_site_load(meta)
        params = {
            "routePath": intent.params.get("routePath"),
            "dataDir": intent.params.get("dataDir"),
            "includeSiblings": intent.params.get("includeSiblings", False) is True,
            "stationCount": int(intent.params.get("stationCount") or 4),
        }
        block = harness.stage_confirmation(session_id, "flex.site.load", params, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="flex.site.load.stage",
                    target={"type": "FLEX_SITE", "id": meta.get("primaryOrder")}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    # ---- 柔性排产（P1：能力池动态组虚拟产线，写草稿版本 §M5） ----
    if name == "flex.schedule":
        return _run_flex(store, intent, actor)
    if name == "flex.reschedule":
        return _flex_reschedule(store, intent, session_id, actor)
    if name == "flex.swap":
        return _flex_swap(store, intent, actor)
    # ---- 瓶颈产能评估（P0：只读，瓶颈产能法） ----
    if name == "flex.capacity":
        return _flex_capacity(store)
    # ---- 交期承诺模拟（P0：深拷贝沙盒试插单，不碰主干） ----
    if name == "flex.simulate_due":
        return _flex_simulate_due(store, intent)
    if name == "flex.compare":
        return _flex_compare(store)
    if name == "flex.rush":
        return _flex_rush(store, intent, actor)
    if name == "flex.fault":
        return _flex_fault(store, intent, actor)
    if name == "conflict.list":
        return _conflict_list(store, intent)
    if name == "flex.conflict.resolve":
        return _conflict_resolve(store, intent, session_id, actor)
    # ---- SAP 集成（MD-05：状态 P0 / 入出站 P2 确认卡） ----
    if name == "sap.status":
        from server.aps_domain.sap_sync import sap_connection_status
        st = sap_connection_status()
        return AgentReply(
            text=(f"SAP 连接：{'在线' if st.get('connected') else '离线'} · "
                  f"{st.get('mode')} · {st.get('system')}/{st.get('plant')} · "
                  f"待拉单 {st.get('openOrders')} · 已回写 {st.get('receiptCount')}。"))
    if name in ("sap.sync.inbound", "sap.sync.outbound"):
        from server.aps_domain.sap_sync import stage_sap_sync
        direction = "inbound" if name.endswith("inbound") else "outbound"
        r = stage_sap_sync(store, direction, session_id=session_id, actor=actor)
        return AgentReply(text=r["message"], blocks=[r["block"]])
    # ---- MES 下发 / 报工（EX-05 / EX-09） ----
    if name == "mes.status":
        from server.aps_domain.mes import list_execution, mes_connection_status
        st = mes_connection_status()
        ex = list_execution(store.data, "flex")
        return AgentReply(
            text=(f"MES：{'在线' if st.get('connected') else '离线'} · {st.get('system')} · "
                  f"外部工单 {st.get('woCount')}（未完 {st.get('openCount')}）· "
                  f"柔性已下发 {ex.get('total', 0)} / 完工 {ex.get('completed', 0)}。"))
    if name == "mes.dispatch":
        from server.aps_domain.mes import stage_dispatch
        r = stage_dispatch(store, track=intent.params.get("track") or "flex",
                           session_id=session_id, actor=actor)
        if r.get("block"):
            return AgentReply(text=r["message"], blocks=[r["block"]])
        return AgentReply(text=r.get("message") or "无法下发")
    if name == "mes.report":
        from server.aps_domain.mes import apply_report, list_execution
        track = intent.params.get("track") or "flex"
        wo_id = intent.params.get("woId")
        finish = bool(intent.params.get("finish") or intent.params.get("finishAll"))
        if intent.params.get("finishAll") or wo_id is None:
            ex = list_execution(store.data, track)
            targets = [r for r in ex.get("rows") or []
                       if r.get("status") != "COMPLETED" and (r.get("progressPct") or 0) < 100]
            if not targets:
                return AgentReply(text="没有已下发且未完工的工单。请先「下发MES」。")
            msgs = []
            for row in targets[:30]:
                try:
                    r = apply_report(store, int(row["woId"]), track=track,
                                     finish=True, actor=actor)
                    msgs.append(r["message"])
                except (ValueError, PermissionError) as exc:
                    msgs.append(str(exc))
            return AgentReply(
                text=f"批量报工完成 ✅ {len(msgs)} 条。\n" + "\n".join(msgs[:5]),
                commands=[ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")])
        try:
            r = apply_report(store, int(wo_id), track=track,
                             progress_pct=intent.params.get("progressPct"),
                             finish=finish, actor=actor)
        except (ValueError, PermissionError) as exc:
            return AgentReply(text=str(exc))
        return AgentReply(text=r["message"],
                          commands=[ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")])
    # ---- 方案对比（P1：Explore 沙盒，不碰主干 §5.1/§9.7） ----
    if name == "scenario.compare":
        from server.aps_domain.analytics import matrix_from_fixed_cards
        text, block = compare_scenarios(store.data)    # 沙盒并行试排三策略
        block.props["table"] = matrix_from_fixed_cards(
            block.props.get("cards") or [], baseline=block.props.get("baseline"))
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="scenario.compare",
                    target={"type": "SANDBOX", "id": block.blockId}, power="P1",
                    rationale={"strategies": [c["strategy"] for c in block.props["cards"]]})  # 沙盒运行留痕
        store.save()                                   # 审计落盘（世界业务数据未变）
        return AgentReply(
            text=text + "\n已打开方案对比表视口。", blocks=[block],
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "compare"}, issuedBy="LLM")])
    if name == "scenario.sensitivity":
        from server.aps_domain.sensitivity import run_sensitivity, sensitivity_as_block
        strategy = str((intent.params or {}).get("strategy") or "COMPREHENSIVE")
        report = run_sensitivity(store.data, strategy=strategy)
        block = sensitivity_as_block(report)
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN",
                    action="scenario.sensitivity",
                    target={"type": "SANDBOX", "id": block.blockId}, power="P1",
                    rationale={"strategy": strategy, "factors": [r["factorId"] for r in report["rows"]]})
        store.save()
        top = report["rows"][0] if report["rows"] else None
        head = (
            f"敏感性分析完成（策略 {strategy}）。基线延期 {report['baseline']['tardiness']} h。"
        )
        if top:
            head += f"\n最敏感因子：{top['label']}（摆幅 {top['swing']}）。"
        head += f"\n{report.get('hint') or ''}"
        return AgentReply(text=head, blocks=[block])
    # ---- 手动建档（P1：只新增快照 §4.3） ----
    if name == "checkpoint.create":
        label = intent.params.get("label") or f"手动存档 {fmt_date(today0())}"  # 缺省自动命名
        meta = get_checkpoints().create(store.data, label=label, reason="manual",
                                        conversation_note="用户口令建档")       # 建成对快照
        write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE", action="checkpoint.create",
                    target={"type": "CHECKPOINT", "id": meta["pairId"]}, power="P1",
                    rationale={"label": label})        # 建档留痕
        store.save()                                   # 审计落盘
        return AgentReply(text=f"已创建检查点【{label}】（ID: {meta['pairId']}）✅\n"
                               f"随时可以说“回滚到检查点 {meta['pairId']}”回到此刻。",
                          commands=[ViewportCommand(cmd="world.refresh", issuedBy="SYSTEM")])  # 刷新时间线导轨
    # ---- 回滚（P2 → 确认卡 §4.3） ----
    if name == "checkpoint.rollback":
        ckpt = get_checkpoints()                       # 快照仓
        pair_id = intent.params.get("pairId")          # 指定目标（时间线点击合成口令携带）
        pair = ckpt.get(pair_id) if pair_id else ckpt.latest()      # 缺省=最近一个
        if pair is None:                               # 无档可回
            return AgentReply(text="当前没有可回滚的检查点。可先执行“建一个检查点”。")
        block = harness.stage_confirmation(            # 回滚是 P2：出确认卡
            session_id, "checkpoint.rollback", {"pairId": pair["pairId"]},
            title=f"回滚到检查点【{pair['label']}】",
            summary_lines=[                            # 影响面说明
                f"目标时刻：{pair['createdAt']}（当时版本 {pair.get('versionNo') or '无'}）",
                "当前世界状态将被整体替换（对话与世界成对回滚 §4.2）",
                "回滚前会自动再存档一次，本次回滚可撤销",
            ])
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="checkpoint.rollback.stage",
                    target={"type": "CHECKPOINT", "id": pair["pairId"]}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})  # 出卡留痕
        store.save()                                   # 审计落盘
        return AgentReply(text=f"回滚是 P2 写操作，需要你确认（目标：{pair['label']}）。", blocks=[block])
    # ---- 视口命令族（P0：直接回传命令由前端执行） ----
    if name.startswith("viewport."):
        replies = {                                    # 各命令的回执文案
            "viewport.mode": {"gantt": "已切换为【甘特图】。", "load": "已切换为【负荷热力图】。",
                              "due": "已切换为【交期承诺看板】。",
                              "pool": "已切换为【产能池】。",
                              "flex": "已切换为【柔性甘特】。",
                              "kpi": "已切换为【KPI 仪表盘】。",
                              "compare": "已切换为【方案对比表】。",
                              "util": "已切换为【资源利用率】。",
                              "plan": "已切换为【分桶计划】。",
                              }.get(intent.params.get("mode", ""), "已切换视图。"),
            "viewport.filter": "已应用过滤，右侧只显示匹配的工单。",
            "viewport.focus": f"已聚焦产线 {intent.params.get('lineCode', '')}，其他产线已隐藏。",
            "viewport.highlight": "已高亮" + ("【超期风险】(红)" if intent.params.get("what") == "overdue" else "【冲突】(黄)") + "，其余淡出。",
            "viewport.timescale": "已切换时间粒度。",
            "viewport.reset": "已重置视口：清除过滤、聚焦与高亮。",
        }
        return AgentReply(text=replies.get(name, "已执行。"), commands=[  # 回传结构化视口命令
            ViewportCommand(cmd=name, params=intent.params,               # 命令与槽位原样下发
                            target=intent.params.get("lineCode"), issuedBy="LLM")])
    # ---- 知识库检索（P0：只读带出处 §8.2；可选 LLM 综合） ----
    if name == "knowledge.query":
        from server.agent_core.providers import get_provider
        from server.knowledge.retrieval import hybrid_search
        kb = get_knowledge()
        kb.ensure_seed_assets()
        q = str(intent.params.get("query") or "")
        title_hint = intent.params.get("assetTitle")
        if re.search(r"^(知识库|知识清单)$|有哪些知识|知识库(有什么|清单|目录)|工艺模式(有哪些|清单)", q.strip()):
            metas = kb.list_meta()
            by_kind: dict[str, list] = {}
            for m in metas:
                by_kind.setdefault(m.get("kind") or "other", []).append(m["title"])
            lines = [f"知识库共 {len(metas)} 条资产："]
            kind_cn = {"sop": "SOP", "algorithm": "算法", "process": "工艺", "case": "案例", "report": "报告"}
            for k, titles in by_kind.items():
                lines.append(f"【{kind_cn.get(k, k)}】{len(titles)} 条")
                for t in titles[:12]:
                    lines.append(f"  · {t}")
                if len(titles) > 12:
                    lines.append(f"  · …另有 {len(titles) - 12} 条")
            lines.append("可说「@知识:机加工工艺路线生成总则」或「导入知识文档」扩展语料。")
            write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="knowledge.query",
                        target={"type": "KNOWLEDGE", "id": "catalog"}, power="P0",
                        rationale={"query": q, "mode": "catalog", "count": len(metas)})
            store.save()
            return AgentReply(text="\n".join(lines))
        if title_hint:
            asset = kb.find_by_title(str(title_hint))
            hits = [{"assetId": asset["assetId"], "title": asset["title"], "kind": asset["kind"],
                     "version": asset["version"], "score": 1.0,
                     "snippet": asset["content"][:120], "content": asset["content"]}] if asset else []
        else:
            hits = hybrid_search(kb.iter_search_units(), q, top_k=5)
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="knowledge.query",
                    target={"type": "KNOWLEDGE", "id": hits[0]["assetId"] if hits else "miss"}, power="P0",
                    rationale={"query": intent.params.get("query"), "hits": [h["assetId"] for h in hits]})
        store.save()
        if not hits:
            from server.aps_domain.guidance import build_guidance
            block = UIBlock(blockId="guidance-kb-miss", type="guidance",
                            props=build_guidance(store.data, context="knowledge_miss"))
            return AgentReply(
                text="知识库里没有找到相关内容（不编造）。\n"
                     "可以换个说法，或说「知识库」查看已有资产清单。",
                blocks=[block])
        # 尝试 LLM 综合；失败则吐最相关原文
        top = hits[0]
        text = None
        ctx_parts = []
        for i, h in enumerate(hits[:4], 1):
            ctx_parts.append(
                f"[{i}] 《{h['title']}》{h['version']}"
                + (f" §{h['heading']}" if h.get("heading") else "")
                + f"\n{h['content'][:800]}"
            )
        sys_prompt = (
            "你是 APS 排产知识助手。只根据给定资料回答，禁止编造资料外的数字与规定。"
            "回答末尾列出引用的资料标题与版本。"
        )
        user_prompt = f"问题：{q}\n\n资料：\n" + "\n\n".join(ctx_parts)
        try:
            text = await get_provider().chat_text(sys_prompt, user_prompt)
        except Exception:
            text = None
        if not text:
            text = (f"{top['content']}\n\n"
                    f"—— 出处：【{top['title']}】{top['version']}（{top['kind']}）")
        else:
            cites = "；".join(f"【{h['title']}】{h['version']}" for h in hits[:4])
            if "出处" not in text and "【" not in text:
                text = text.rstrip() + f"\n\n—— 出处：{cites}"
        block = UIBlock(
            blockId=f"evidence-{top['assetId']}", type="evidence",
            props={"hits": [{k: h.get(k) for k in ("assetId", "title", "kind", "version", "score",
                                                    "snippet", "chunkId", "heading", "page")}
                            for h in hits]})
        return AgentReply(text=text, blocks=[block])

    # ---- 知识文档导入（P2 确认卡） ----
    if name == "knowledge.import":
        from server.knowledge.ingest import (
            confirmation_for_knowledge_import, preview_ingest,
        )
        path = intent.params.get("path") or intent.params.get("filePath")
        if not path:
            return AgentReply(text="请指定文件路径，例如：「导入知识文档 D:/docs/sop.md」")
        try:
            preview = preview_ingest(
                os.path.basename(str(path)), path=str(path),
                kind=str(intent.params.get("kind") or "sop"),
                title=intent.params.get("title"),
            )
        except (FileNotFoundError, ValueError) as exc:
            return AgentReply(text=str(exc))
        # 确认卡不塞全文 chunks，只留摘要；执行时再读 path
        title, lines = confirmation_for_knowledge_import(preview)
        slim = {
            "path": str(path), "filename": preview["filename"], "title": preview["title"],
            "kind": preview["kind"], "chunkCount": preview["chunkCount"],
            "sectionCount": preview["sectionCount"],
        }
        block = harness.stage_confirmation(
            session_id, "knowledge.import", slim, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="knowledge.import.stage",
                    target={"type": "KNOWLEDGE", "id": preview["filename"]}, power="P2",
                    rationale={"confirmId": block.props["confirmId"],
                               "chunkCount": preview["chunkCount"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2，需要你确认后入库。", blocks=[block])

    # ---- 外部算法 Skill ----
    if name == "skill.list":
        from server.agent_core.skills import get_skills
        rows = get_skills().list()
        if not rows:
            return AgentReply(text="尚未登记外部算法 skill。")
        lines = ["已接入算法 Skill："]
        for s in rows:
            flag = "启用" if s.get("enabled") else "停用"
            lines.append(f"· {s['skill_id']} 【{s['name']}】{flag} · {s.get('endpoint')} · 轨={s.get('track')}")
        lines.append("可说「用外部算法试排」或「skill 健康检查」。")
        return AgentReply(text="\n".join(lines))
    if name == "skill.health":
        from server.agent_core.skills import get_skills
        health = get_skills().health(intent.params.get("skillId"))
        lines = ["Skill 健康检查："]
        for h in health:
            ok = "OK" if h.get("ok") else "FAIL"
            lines.append(f"· {h['skill_id']} [{ok}] {h.get('detail')} "
                         f"{('· ' + str(h.get('latencyMs')) + 'ms') if h.get('latencyMs') is not None else ''}")
        return AgentReply(text="\n".join(lines))
    # ---- 引导式排产向导（M-F：readiness→缺口引导→模板推荐→试排） ----
    if name == "schedule.wizard":
        from server.agent_core.dialog import start_wizard
        return start_wizard(store, session_id, actor=actor)
    # ---- 数据齐备度 / 工时维护（M-B：排产数据闭环） ----
    if name == "readiness.query":
        from server.aps_domain.readiness import check_readiness, readiness_text, time_matrix
        report = harness.guard("readiness.query", {}, lambda: check_readiness(store.data))
        matrix = time_matrix(store.data)
        block = UIBlock(
            blockId="readiness-report", type="readiness",
            props={"summary": report["summary"], "orders": report["orders"],
                   "globalIssues": report["globalIssues"],
                   "timeMatrix": [r for r in matrix if r["source"] in ("推断", "待维护")][:40]},
        )
        return AgentReply(text=readiness_text(report), blocks=[block])
    if name == "data.analyze":
        from server.aps_domain.project_analyze import analyze_project_deep
        deep = harness.guard(
            "data.analyze", {},
            lambda: analyze_project_deep(
                store.data, session_id,
                apply_sql=True,
                query=str(intent.params.get("query") or ""),
            ),
        )
        store.save()
        block = UIBlock(blockId="project-analyze", type="project-analyze", props={
            "projectName": deep.get("projectName"),
            "workDir": deep.get("workDir"),
            "sources": deep.get("sources") or [],
            "summary": deep.get("summary") or {},
            "orders": deep.get("orders") or [],
            "materials": deep.get("materials") or [],
            "routings": deep.get("routings") or [],
            "equipment": deep.get("equipment") or [],
            "plan": deep.get("plan") or [],
            "kbActions": deep.get("kbActions") or [],
            "sqlPreview": deep.get("sqlPreview"),
            "canSchedule": bool(deep.get("canSchedule")),
            "applied": deep.get("applied") or {},
        })
        return AgentReply(text=deep.get("markdown") or "分析完成。", blocks=[block])
    if name == "folder.analyze":
        from server.aps_domain.folder_pack import analyze_work_dir
        report = harness.guard(
            "folder.analyze", {},
            lambda: analyze_work_dir(store.data, session_id),
        )
        block = UIBlock(blockId="folder-pack", type="folder-pack", props={
            "projectName": report.get("projectName"),
            "workDir": report.get("workDir"),
            "files": report.get("files") or [],
            "coverage": report.get("coverage") or {},
            "coverageDetail": report.get("coverageDetail") or [],
            "missing": report.get("missing") or [],
            "softMissing": report.get("softMissing") or [],
            "canSchedule": bool(report.get("canSchedule")),
            "totalOk": report.get("totalOk") or 0,
            "totalErrors": report.get("totalErrors") or 0,
            "error": report.get("error"),
        })
        return AgentReply(
            text=(
                f"**工程目录数据包 · {report.get('projectName') or '当前项目'}**\n\n"
                f"目录：`{report.get('workDir') or ''}`\n\n"
                + (report.get("error") or (
                    f"共读到 **{len(report.get('files') or [])}** 个表格，"
                    f"有效行 {report.get('totalOk') or 0}，问题行 {report.get('totalErrors') or 0}。"
                    + (" **还不能开排**，详见下表。" if not report.get("canSchedule")
                       else " **基本可以开排**，详见下表。")
                ))
            ),
            blocks=[block],
        )
    if name == "folder.schedule":
        from server.aps_domain.folder_pack import analyze_work_dir, confirmation_for_folder_schedule
        # 排产口令：强制用工程目录 SQL/表覆盖当前项目世界
        report = analyze_work_dir(store.data, session_id, force_sql_replace=True)
        store.save()
        analyze_block = UIBlock(blockId="folder-pack", type="folder-pack", props={
            "projectName": report.get("projectName"),
            "workDir": report.get("workDir"),
            "files": report.get("files") or [],
            "coverage": report.get("coverage") or {},
            "coverageDetail": report.get("coverageDetail") or [],
            "missing": report.get("missing") or [],
            "softMissing": report.get("softMissing") or [],
            "canSchedule": bool(report.get("canSchedule")),
            "totalOk": report.get("totalOk") or 0,
            "totalErrors": report.get("totalErrors") or 0,
            "error": report.get("error"),
            "sqlApplied": bool(report.get("sqlApplied")),
            "sqlStats": report.get("sqlStats") or {},
        })
        sql_ok = bool(report.get("sqlApplied")) and bool(report.get("canSchedule"))
        has_core = (
            bool(store.data.get("flexOrders"))
            and bool(store.data.get("flexRoutings"))
            and any(e.get("status") == "RUNNING" for e in (store.data.get("flexEquipment") or []))
        )
        # SQL 完整库：用户已说「根据这个排产」→ 直接开排，不再卡在「缺 Excel 批次/再确认」
        if sql_ok or (report.get("sqlApplied") and has_core):
            st = report.get("sqlStats") or {}
            write_audit(store.data, store.next_id, actor=actor, category="WORLD_WRITE",
                        action="folder.schedule.sql_direct",
                        target={"type": "FOLDER_PACK", "id": report.get("workDir") or "workDir"},
                        power="P2",
                        rationale={"sqlStats": st, "direct": True})
            store.save()
            flex_reply = _run_flex(
                store,
                IntentResult(intent="flex.schedule",
                             params={"sortMode": "BOTTLENECK"},
                             confidence=1.0, source="RULE_FAST"),
                actor,
            )
            head = (
                f"已按工程目录 SQL 入库并开排："
                f"订单 {st.get('orders', 0)} · 工艺步 {st.get('routing', 0)} · "
                f"已挂工艺产品 {st.get('routedProducts', 0)}/"
                f"{st.get('orderProducts', 0)}。\n\n"
            )
            return AgentReply(
                text=head + (flex_reply.text or ""),
                blocks=[analyze_block, *(flex_reply.blocks or [])],
                commands=flex_reply.commands or [],
            )
        if not report.get("batches") and not report.get("sqlApplied"):
            return AgentReply(
                text=(report.get("markdown") or "")
                + "\n\n目录里还没有可入库的有效行，我没法按这些表开排。"
                "请先把订单/物料/工艺/设备表或 SQL 库补齐。",
                blocks=[analyze_block],
            )
        if report.get("missing") and not has_core:
            return AgentReply(
                text=(report.get("markdown") or "")
                + "\n\n**还不能排：**还缺 "
                + "、".join(report["missing"])
                + "。补齐后再说「根据这些数据排产」。",
                blocks=[analyze_block],
            )
        title, lines = confirmation_for_folder_schedule(report)
        slim = [{"kind": b["kind"], "sheet": b.get("sheet"), "okRows": b.get("okRows") or []}
                for b in report["batches"] if b.get("okRows")]
        params = {
            "workDir": report.get("workDir"),
            "sessionId": session_id,
            "batches": slim,
            "sortMode": "BOTTLENECK",
            "sqlApplied": bool(report.get("sqlApplied")),
        }
        block = harness.stage_confirmation(
            session_id, "folder.schedule", params, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="folder.schedule.stage",
                    target={"type": "FOLDER_PACK", "id": report.get("workDir") or "workDir"},
                    power="P2", rationale={"confirmId": block.props["confirmId"],
                                           "totalOk": report.get("totalOk")})
        store.save()
        return AgentReply(
            text=(report.get("markdown") or "")
            + "\n\n必备数据已齐。下面请确认：**导入这些表格并试排一版**（可回滚）。",
            blocks=[analyze_block, block],
        )
    if name in ("assistant.reply", "unknown"):
        from server.agent_core.assistant import reply as assistant_reply
        q = str(intent.params.get("query") or intent.params.get("text") or "")
        hist = intent.params.get("_history") or []
        return await assistant_reply(store.data, q, history=hist, session_id=session_id)
    if name == "flex.time.update":
        pc = str(intent.params.get("productCode") or "")
        op_code = str(intent.params.get("operationCode") or "")
        std_min = intent.params.get("stdMin")
        if not op_code or not std_min:
            return AgentReply(text="请说明工序与工时，例如「把部装工时改成 50 分钟」"
                                   "或「把 0503727Z1M 工时改成 45 分钟」。")
        # 允许用工序名匹配（「部装」→ 所有名称含部装的工序编码）
        codes = [op_code]
        if not any(r.get("operationCode") == op_code for r in store.data.get("flexRoutings") or []):
            named = [o["code"] for o in store.data.get("flexOperations") or []
                     if op_code in (o.get("name") or "")]
            if named:
                codes = named
        staged_blocks = []
        title = f"更新工时：{pc or '全部产品'} × {'、'.join(codes)} → {std_min} 分钟/件"
        block = harness.stage_confirmation(
            session_id, "flex.time.update",
            {"productCode": pc, "operationCode": codes[0] if len(codes) == 1 else "",
             "operationCodes": codes, "stdMin": float(std_min), "source": "实测"},
            title=title,
            summary_lines=[f"匹配工序：{'、'.join(codes)}",
                           f"单件工时 → {std_min} 分钟（来源标记为「实测」）",
                           "确认后写入柔性工艺路线并同步数据库。"])
        staged_blocks.append(block)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="flex.time.update.stage",
                    target={"type": "ROUTING_TIME", "id": f"{pc or '*'}/{op_code}"}, power="P2",
                    rationale={"confirmId": block.props["confirmId"], "stdMin": std_min})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，请确认。", blocks=staged_blocks)
    if name == "skill.register":
        payload = dict(intent.params or {})
        if not payload.get("skill_id") or not payload.get("endpoint"):
            return AgentReply(text="登记 skill 需要 skill_id 与 endpoint，例如："
                                   "「登记算法skill id=algo.x endpoint=http://127.0.0.1:8101 name=我的算法」")
        title = f"登记算法 Skill {payload.get('skill_id')}"
        lines = [f"ID：{payload.get('skill_id')}", f"端点：{payload.get('endpoint')}",
                 f"名称：{payload.get('name') or payload.get('skill_id')}",
                 f"轨道：{payload.get('track') or 'flex'}"]
        block = harness.stage_confirmation(session_id, "skill.register", payload,
                                           title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="skill.register.stage",
                    target={"type": "SKILL", "id": payload.get("skill_id")}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2，确认后写入配置。", blocks=[block])
    if name == "skill.enable":
        sid = intent.params.get("skillId") or intent.params.get("skill_id")
        if not sid:
            return AgentReply(text="请指定 skillId，例如「启用 skill algo.stub」或「停用 skill algo.stub」。")
        enabled = intent.params.get("enabled")
        if enabled is None:
            enabled = not re.search(r"停用|禁用|关闭", str(intent.params.get("query") or ""))
        title = f"{'启用' if enabled else '停用'}算法 Skill {sid}"
        block = harness.stage_confirmation(
            session_id, "skill.enable", {"skill_id": sid, "enabled": bool(enabled)},
            title=title, summary_lines=[f"目标：{sid}", f"状态 → {'启用' if enabled else '停用'}"])
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="skill.enable.stage",
                    target={"type": "SKILL", "id": sid}, power="P2",
                    rationale={"confirmId": block.props["confirmId"], "enabled": enabled})
        store.save()
        return AgentReply(text=f"{title} 属于 P2，请确认。", blocks=[block])

    # ---- 报告生成（P1：产出文档并入知识库 §9.10） ----
    if name == "report.generate":
        report_type = str(intent.params.get("reportType") or "daily")   # 报告类型（缺省日报）
        order_no = str(intent.params.get("orderNo") or "").strip() or None
        report = build_report(store.data, report_type, order_no=order_no)  # 冻结快照 → 模板生成
        if not report["reportId"]:                     # 前置条件不满足（无版本/不足两版）
            return AgentReply(text=report["markdown"])
        # 报告入知识库（§9.10 规则3：报告本身成为 RAG 语料）
        asset = get_knowledge().add(kind="report", title=report["title"],
                                    content=report["markdown"], tags=[report_type, "报告"])
        download_url = None
        download_name = None
        fmt = "md"
        xlsx = report.get("xlsxBytes")
        if xlsx and report_type in ("plan", "schedule-plan", "flex-plan"):
            saved = persist_report_xlsx(report["reportId"], xlsx, report.get("filename"))
            download_url = f"/api/reports/files/{report['reportId']}"
            download_name = saved["filename"]
            fmt = "xlsx"
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="report.generate",
                    target={"type": "REPORT", "id": report["reportId"]}, power="P1",
                    rationale={"reportType": report_type, "assetId": asset["assetId"],
                               "orderNo": order_no, "format": fmt})
        store.save()
        block = UIBlock(
            blockId=f"report-{report['reportId']}", type="report",
            props={"reportId": report["reportId"], "title": report["title"],
                   "markdown": report["markdown"], "reportType": report_type,
                   "assetId": asset["assetId"], "format": fmt,
                   "downloadUrl": download_url, "filename": download_name})
        tip = ("点下方「下载 Excel 工作计划表」保存完整工序计划。"
               if fmt == "xlsx" else "可预览并下载 Markdown。")
        return AgentReply(
            text=f"已生成【{report['title']}】（数字取自冻结快照）。\n{tip}"
                 f"报告已入知识库（资产 {asset['assetId']}）。",
            blocks=[block])
    # ---- KPI 查询 / 仪表盘（P0，EX-08） ----
    if name == "query.kpi":
        from server.aps_domain.analytics import build_kpi_dashboard
        dash = build_kpi_dashboard(store.data)
        lines = [f"· {c['label']}：{c['value']}" for c in dash.get("cards") or []]
        text = "运营 KPI 仪表盘：\n" + ("\n".join(lines) if lines else "暂无数据，请先排产。")
        block = UIBlock(blockId="kpi-dash", type="kpi-dashboard", props=dash)
        return AgentReply(
            text=text, blocks=[block],
            commands=[ViewportCommand(cmd="viewport.mode", params={"mode": "kpi"}, issuedBy="LLM")])
    # ---- 主动引导（P0，AG-07） ----
    if name == "guidance.next":
        from server.aps_domain.guidance import build_guidance
        guide = build_guidance(store.data)
        lines = [f"· {s['label']}（{s['reason']}）" for s in guide.get("suggestions") or []]
        sig = guide.get("signals") or []
        head = "当前建议下一步：\n" if not sig else f"状态：{sig[0]['title']}。建议：\n"
        return AgentReply(
            text=head + ("\n".join(lines) if lines else "暂无特别建议，可说「帮助」。"),
            blocks=[UIBlock(blockId="guidance-next", type="guidance", props=guide)])
    # ---- 排产参数查询 / 更新（OR-02） ----
    if name == "params.query":
        from server.aps_domain.params import get_schedule_params
        p = get_schedule_params(store.data)
        lw = p["customerLevelWeights"]
        ow = p["weights"]
        text = (
            "当前排产参数：\n"
            f"· 客户等级权重：VIP={lw['VIP']} / A={lw['A']} / B={lw['B']} / C={lw['C']}\n"
            f"· 目标权重：交期={ow['tardiness']} / 成本={ow['cost']} / 利用率={ow['utilization']} / 均衡={ow['balance']}\n"
            f"· 展望期 {p['planningHorizonDays']} 天\n"
            "可在设置 → 排产参数调整，或说「提高VIP权重到10」「恢复默认排产参数」。"
        )
        return AgentReply(text=text)
    if name == "params.update":
        from server.aps_domain.params import confirmation_for_params_update
        raw = dict(intent.params or {})
        payload: dict[str, Any] = {}
        if raw.get("resetDefaults"):
            payload["resetDefaults"] = True
        else:
            levels: dict[str, float] = {}
            mapping = {"vipWeight": "VIP", "aWeight": "A", "bWeight": "B", "cWeight": "C",
                       "VIP": "VIP", "A": "A", "B": "B", "C": "C"}
            for src, dst in mapping.items():
                if raw.get(src) is not None and src in ("vipWeight", "aWeight", "bWeight", "cWeight", "VIP", "A", "B", "C"):
                    try:
                        levels[dst] = float(raw[src])
                    except (TypeError, ValueError):
                        return AgentReply(text=f"{dst} 权重必须是数字。")
            if raw.get("customerLevelWeights"):
                payload["customerLevelWeights"] = raw["customerLevelWeights"]
            elif levels:
                payload["customerLevelWeights"] = levels
            if raw.get("weights"):
                payload["weights"] = raw["weights"]
            if raw.get("planningHorizonDays") is not None:
                payload["planningHorizonDays"] = raw["planningHorizonDays"]
        try:
            title, lines = confirmation_for_params_update(store.data, payload)
        except ValueError as exc:
            return AgentReply(text=f"排产参数有误：{exc}")
        block = harness.stage_confirmation(session_id, "params.update", payload, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE", action="params.update.stage",
                    target={"type": "SCHEDULE_PARAMS", "id": "scheduleParams"}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    # ---- 约束配置（SC-04） ----
    if name == "constraint.profile.query":
        from server.aps_domain.constraints import get_constraint_profile
        profile = get_constraint_profile(store.data)
        lines = []
        for c in profile["constraints"]:
            if not c.get("configurable") and c["enabled"]:
                continue
            state = "开" if c["enabled"] else "关"
            kind = "硬" if c["kind"] == "hard" else "软"
            flag = "" if c.get("configurable") else "（内建）"
            lines.append(f"· [{c['code']}] {c['name']}：{state}/{kind}{flag}")
        text = f"约束剖面【{profile['name']}】：\n" + "\n".join(lines)
        text += "\n可说「关闭物料齐套」「齐套改为硬约束」或在设置 → 约束配置调整。"
        return AgentReply(text=text)
    if name == "constraint.profile.save":
        from server.aps_domain.constraints import confirmation_for_profile_save
        raw = dict(intent.params or {})
        payload: dict[str, Any] = {}
        if raw.get("resetDefaults"):
            payload["resetDefaults"] = True
        elif raw.get("constraints"):
            payload["constraints"] = raw["constraints"]
        else:
            cid = str(raw.get("constraintId") or "")
            if not cid:
                return AgentReply(text="请指定约束，例如：「关闭物料齐套」或「齐套改为硬约束」。")
            patch: dict[str, Any] = {}
            if "enabled" in raw:
                patch["enabled"] = bool(raw["enabled"])
            if raw.get("kind") in ("hard", "soft"):
                patch["kind"] = raw["kind"]
            payload["constraints"] = {cid: patch}
        try:
            title, lines = confirmation_for_profile_save(store.data, payload)
        except ValueError as exc:
            return AgentReply(text=f"约束配置有误：{exc}")
        block = harness.stage_confirmation(
            session_id, "constraint.profile.save", payload, title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="constraint.profile.save.stage",
                    target={"type": "CONSTRAINT_PROFILE", "id": "default"}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    # ---- IND-02 SOP→约束 ----
    if name == "sop.compile":
        from server.aps_domain.sop_rules import compile_sop_by_query, list_compilable_sops, sop_as_block
        q = str((intent.params or {}).get("query") or "换线")
        compiled = compile_sop_by_query(get_knowledge().assets, q)
        if not compiled.get("ok"):
            avail = compiled.get("available") or list_compilable_sops(get_knowledge().assets)
            titles = "、".join(a.get("title") or "?" for a in avail[:6])
            return AgentReply(text=f"{compiled.get('error')}\n可编译 SOP：{titles or '（无）'}")
        pack = compiled["pack"]
        write_audit(store.data, store.next_id, actor=actor, category="ALGO_RUN", action="sop.compile",
                    target={"type": "SOP", "id": (pack.get("source") or {}).get("assetId")}, power="P0",
                    rationale={"query": q, "effects": len(pack.get("effects") or [])})
        store.save()
        text = (
            f"已编译 SOP《{pack.get('title')}》→ 规则包预览。\n"
            f"{pack.get('summary')}\n"
            "确认落地请说「应用换线SOP」或「应用该规则包」（P2）。"
        )
        return AgentReply(text=text, blocks=[sop_as_block(pack)])
    if name == "sop.apply":
        from server.aps_domain.sop_rules import (
            compile_sop_by_query, confirmation_for_sop_apply,
        )
        raw = dict(intent.params or {})
        pack = raw.get("pack") if isinstance(raw.get("pack"), dict) else None
        if pack is None:
            compiled = compile_sop_by_query(get_knowledge().assets, raw.get("query") or "换线")
            if not compiled.get("ok"):
                return AgentReply(text=compiled.get("error") or "SOP 编译失败")
            pack = compiled["pack"]
        title, lines = confirmation_for_sop_apply(pack)
        block = harness.stage_confirmation(
            session_id, "sop.apply", {"pack": pack, "query": raw.get("query")},
            title=title, summary_lines=lines)
        write_audit(store.data, store.next_id, actor=actor, category="GATE",
                    action="sop.apply.stage",
                    target={"type": "RULE_PACK", "id": pack.get("packId")}, power="P2",
                    rationale={"confirmId": block.props["confirmId"]})
        store.save()
        return AgentReply(text=f"{title} 属于 P2 写操作，需要你确认。", blocks=[block])
    # ---- 帮助（P0） ----
    if name == "help":
        return AgentReply(text=_HELP)
    # ---- 拒识兜底：走通用助理（带上下文）----
    from server.agent_core.assistant import reply as assistant_reply
    return await assistant_reply(
        store.data,
        str(intent.params.get("query") or ""),
        history=intent.params.get("_history") or [],
        session_id=session_id,
    )