diff --git a/bj_power_mes/frontend/src/components/PageHelp.vue b/bj_power_mes/frontend/src/components/PageHelp.vue
index 675678d..6ac86ef 100644
--- a/bj_power_mes/frontend/src/components/PageHelp.vue
+++ b/bj_power_mes/frontend/src/components/PageHelp.vue
@@ -1,10 +1,6 @@
 <template>
-  <!-- 页面左下角 "?" 帮助按钮：点击弹出当前页面整体介绍 + 字段说明 -->
+  <!-- 页面帮助抽屉：由右上角「帮助」按钮或点击页面标题触发（mes:open-page-help 事件） -->
   <div class="page-help">
-    <el-tooltip content="本页操作说明" placement="left">
-      <el-button class="help-fab" circle @click="open">?</el-button>
-    </el-tooltip>
-
     <el-drawer v-model="show" :title="data.title || '操作说明'" size="520px" append-to-body class="ph-drawer">
       <!-- 顶部概览 -->
       <div class="ph-inner">
@@ -58,7 +54,7 @@
 </template>
 
 <script setup>
-import { ref } from 'vue'
+import { ref, onMounted, onBeforeUnmount } from 'vue'
 
 defineProps({
   data: { type: Object, default: () => ({ title: '操作说明', overview: '', fields: [] }) }
@@ -66,17 +62,12 @@ defineProps({
 
 const show = ref(false)
 function open() { show.value = true }
+
+onMounted(() => window.addEventListener('mes:open-page-help', open))
+onBeforeUnmount(() => window.removeEventListener('mes:open-page-help', open))
 </script>
 
 <style scoped>
-.page-help { position: fixed; left: 18px; bottom: 18px; z-index: 2050; }
-.help-fab {
-  width: 42px; height: 42px; background: #1668dc; color: #fff; font-weight: 700;
-  font-size: 20px; box-shadow: 0 3px 10px rgba(22,50,79,.3);
-  transition: transform .15s;
-}
-.help-fab:hover { background: #0e57c3; transform: scale(1.06); }
-
 .ph-inner { padding: 0 6px 24px; }
 
 /* 顶部深色横幅 */
diff --git a/bj_power_mes/frontend/src/components/ProcessSeqPicker.vue b/bj_power_mes/frontend/src/components/ProcessSeqPicker.vue
new file mode 100644
index 0000000..2c5993b
--- /dev/null
+++ b/bj_power_mes/frontend/src/components/ProcessSeqPicker.vue
@@ -0,0 +1,58 @@
+<template>
+  <div class="seq-picker">
+    <div class="seq-actions">
+      <el-button size="small" @click="checkAll">全选</el-button>
+      <el-button size="small" @click="clearAll">清空</el-button>
+      <span class="seq-summary">{{ summary }}</span>
+    </div>
+    <el-checkbox-group v-model="codes" class="seq-group">
+      <el-checkbox v-for="i in 12" :key="i" :label="i" class="seq-item">工位{{ i }}</el-checkbox>
+    </el-checkbox-group>
+  </div>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+
+const props = defineProps({
+  modelValue: { type: String, default: '' }
+})
+const emit = defineEmits(['update:modelValue'])
+
+function seqToCodes(s) {
+  if (!s) return []
+  const out = []
+  String(s).split(',').forEach((p) => {
+    const n = Number(p)
+    if (n >= 1 && n <= 12 && !out.includes(n)) out.push(n)
+  })
+  return out.sort((a, b) => a - b)
+}
+
+const codes = computed({
+  get: () => seqToCodes(props.modelValue),
+  set: (v) => emit('update:modelValue', [...v].sort((a, b) => a - b).join(','))
+})
+
+const summary = computed(() => {
+  const c = seqToCodes(props.modelValue)
+  if (!c.length) return '未选择工位'
+  if (c.length === 12) return '全部工位（按 1→12 顺序执行）'
+  return `按顺序执行：${c.map((x) => `工位${x}`).join(' → ')}`
+})
+
+function checkAll() {
+  codes.value = Array.from({ length: 12 }, (_, i) => i + 1)
+}
+function clearAll() {
+  codes.value = []
+}
+</script>
+
+<style scoped>
+.seq-picker { width: 100%; }
+.seq-actions { margin-bottom: 8px; display: flex; align-items: center; gap: 8px; }
+.seq-summary { color: #1668dc; font-size: 12px; }
+.seq-group { display: flex; flex-wrap: wrap; gap: 4px 8px; }
+.seq-item { margin-right: 0; }
+</style>
diff --git a/bj_power_mes/frontend/src/help.js b/bj_power_mes/frontend/src/help.js
index 9e4cd03..d9fbdcc 100644
--- a/bj_power_mes/frontend/src/help.js
+++ b/bj_power_mes/frontend/src/help.js
@@ -5,7 +5,7 @@
 export const helpProductType = {
   title: '产品类型（档案维护）',
   overview:
-    '产品类型是"生产什么产品"的分类档案，是整条产线的源头基础数据。\n\n生产主数据链条：产品类型 → 建工单(选产品类型) → 配物料清单(BOM) → 日排产 → 备料 → PLC/AGV 配送 → 工位装配。\n必须先在这里维护好产品类型，后面所有环节(工单/BOM/备料/拧紧/追溯)才有可选对象。',
+    '产品类型 = 企业要生产哪些产品的分类档案，是整条产线的源头基础数据。\n\n主数据链条：产品类型 → 工单(选产品类型) → 物料清单(给该产品编码配料) → 日排产 → 备料单 → 库房出库 → 产线生产。\n\n关系说明（几对几）：\n· 产品类型 ↔ 工单：1 对 N。一个产品类型可以建多个工单（同一型号今天做一批、明天做一批，工单号不同、产品编码相同）。\n· 产品类型 ↔ 物料清单：按产品编码 1 对 1。同型号产品共用一份 BOM。\n· 产品类型 ↔ 备料单：间接。备料单由「日排产 × 该产品 BOM」算出，与产品类型无直接约束。\n· 强约束：工单/物料清单都挂在产品编码下，产品类型编码变了，下游关联会断，建议建好后不要改。\n· 与 WMS 的关系：两套系统解耦。本页(MES)维护产品与 BOM；WMS(库房)维护物料档案与库存，靠「物料编码」对齐；成品编码由人员手动录入 WMS 实现两系统对齐。',
   fields: [
     { name: '名称', source: '手工填写。用户自定义，无上游来源。', purpose: '产品类型的中文名，用于识别与下拉展示', fill: '如：智能电表、断路器、配电柜' },
     {
@@ -21,32 +21,24 @@ export const helpProductType = {
 }
 
 export const helpWorkOrder = {
-  title: '工单管理（新建 / 编辑工单）',
+  title: '工单管理（新建 / 编辑 / 删除工单）',
   overview:
-    '工单 = 一个"合同/生产批次"的唯一载体，是生产执行和仓库出库挂靠的核心对象。\n\n全流程：先有产品类型 → 建工单(选产品类型、定数量、定工序组合) → 进"物料清单"给该产品配料 → 行内"日排产"排哪天产多少 → 仓库按排产备料出库 → 产线装配/拧紧/报工 → 完工。\n工单号会贯穿 备料单、拧紧查询、手动报工、工件追溯、操作日志 全链路。',
+    '工单 = 一个"合同/生产批次"的唯一载体，是生产执行和仓库出库挂靠的核心对象。\n\n全流程：先有产品类型 → 建工单(选产品类型、定数量、勾选工位组合) → 进"物料清单"给该产品配料 → 到"日排产"排哪天产多少 → 仓库按排产备料出库 → 产线装配/拧紧/报工 → 完工。\n工单号会贯穿 备料单、拧紧查询、手动报工、工件追溯、操作日志 全链路。\n\n查询：支持按 工单号 / 产品编码 / 产品名称（模糊） / 状态 组合筛选。\n删除：仅「已创建 / 待排产 / 已发布」且无排产、备料、生产数据的工单可删除（操作列「删除」），生产中或已完成的工单不可删除。',
   fields: [
-    { name: '工单号', source: '系统自动生成(WO+时间戳)，可手工改。新建时自动带出。', purpose: '唯一标识一个工单，备料/出库/报工/追溯都挂在此号下', fill: '打开新建对话框时已自动生成，一般不用改；如改动须保证唯一' },
-    { name: '产品类型', source: '下拉选择。数据来自"产品类型"页面已启用的记录。', purpose: '说明这批生产的是什么产品，并决定物料清单内容', fill: '先到"产品类型"页面建好记录，再到这边下拉选择；没有可选项=还没建产品类型' },
+    { name: '工单号', source: '系统自动生成(WO+时间戳)，可手工改。新建时自动带出。', purpose: '唯一标识一个工单，备料/出库/报工/追溯都挂在此号下', fill: '一般不用改；如改动须保证唯一' },
+    { name: '产品类型', source: '下拉选择。数据来自"产品类型"页面已启用的记录。', purpose: '说明这批生产的是什么产品，并决定物料清单内容', fill: '先到"产品类型"页面建好记录再选择' },
     { name: '产品编码', source: '手工填写。通常与所选产品类型的编码一致。', purpose: '产品唯一编码，用于展示与追溯', fill: '如 METER-01，与产品类型编码对齐' },
     { name: '产品名称', source: '手工填写。通常与产品类型名称一致。', purpose: '产品中文名，用于展示', fill: '如 智能电表' },
     { name: '数量', source: '手工填写整数。', purpose: '本工单生产总数量(合同台数)，决定需求量与排产上限', fill: '整数 ≥1，如 100' },
-    { name: '工序组合', source: '手工填写数字序列。', purpose: '本工单要在产线执行的工序集合，PLC 按此组合下发到各工位', fill: '组合写入PLC：135=只做第1/3/5序；全工序=123456789101112' },
-    { name: '状态', source: '手动选择(新建时)。后续由系统流程自动推进。', purpose: '工单生命周期：创建→发布→生产→完成', fill: '新建时选"已创建"，后续按流程推进无需手改' }
+    { name: '工位组合', source: '勾选 12 个工位(工位1~工位12)。', purpose: '本工单要经过的工位集合，PLC 按此组合下发控制产线', fill: '勾选要经过的工位即可，系统自动按 1→12 顺序执行(传送带不回走)；半成品再上线可只勾漏做的工位' },
+    { name: '状态', source: '新建时选"已创建"，后续由流程推进。', purpose: '工单生命周期：创建→发布→生产→完成', fill: '新建时选"已创建"；也可在列表操作列点「状态」快捷流转(发布/开工/完工)' }
   ],
   sections: [
     {
-      title: '行内"日排产"弹窗',
-      overview: '对当前这行工单，排"哪天生产多少台"。排产结果会通知仓库按此备料/配送。',
+      title: '行内"工位组合"维护',
+      overview: '对当前工单快速维护要经过的工位组合。\n可自由勾选、补工位(半成品再上线)：如本应走第3/5工位却做成半成品，可在此只勾第2工位重上线完成闭环。',
       fields: [
-        { name: '日期', source: '手动选择日期。', purpose: '计划生产日期，仓库按它哪天备料', fill: '选一个日期，可对同一工单排未来多天' },
-        { name: '计划数量', source: '手动填写整数。', purpose: '当天计划产量，作为仓库备料/AGV配送的前瞻依据', fill: '≤ 工单总数量；如今天产 20 台' }
-      ]
-    },
-    {
-      title: '行内"工序组合"弹窗',
-      overview: '对当前这行工单快速维护要执行的工序组合，PLC 按此组合下发到工位。\n可自由拆组合、补工序(半成品再上线)：如本应做第3/5序却做成了半成品，可在此把该件的组合改成只做漏掉的第2序，重上线完成闭环。',
-      fields: [
-        { name: '工序组合', source: '人工自由维护。', purpose: '本工单在产线执行的工序集合，PLC 组合下发', fill: '只做第1/3/5序填 135；全序填 123456789101112；半成品补做第2序填 2' }
+        { name: '工位组合', source: '勾选 12 个工位。', purpose: '本工单经过的工位集合，PLC 组合下发', fill: '勾选即可，按工位号顺序执行；全选=全部工位' }
       ]
     }
   ]
@@ -68,14 +60,14 @@ export const helpDailyPlan = {
 export const helpBom = {
   title: '物料清单（产品 BOM）',
   overview:
-    '物料清单 = 生产 1 台该产品需要哪些物料、各用多少。\n按产品编码维护：同型号产品今天做一批、明天做一批，工单号不同、产品编码相同，共用这一份 BOM。\n仓库(库房)按工单取其产品的 BOM 计算备料/出库需求量，并强约束累计出库 ≤ 需求总量。\n\n职责分工：本页(MES)只维护「产品由哪几种料、各用几个」；每种物料叫什么、规格、是批次件还是 SN 件、库存有多少，统一在 WMS(库房)的「物料档案」里维护，两套系统互相解耦。\n\n数据链路：先建「产品类型」→ 到本页选产品编码，为它逐条添加物料(编码要与 WMS 物料档案一致) → 之后仓库才能为对应工单领料。',
+    '物料清单 = 生产 1 台该产品需要哪些物料、各用多少。\n按产品编码维护：同型号产品今天做一批、明天做一批，工单号不同、产品编码相同，共用这一份 BOM。\n仓库(库房)按工单取其产品的 BOM 计算备料/出库需求量，并强约束累计出库 ≤ 需求总量。\n\n与 WMS 的关系：本页(MES)只维护「产品由哪几种料、各用几个」；每种物料叫什么、规格、是精密件(SN)还是结构件(批次)、库存有多少，统一在 WMS(库房)的「物料档案」里维护，两套系统互相解耦、通过物料编码对齐。\n\n编码对应规则：本页的「物料编码」必须与 WMS 物料档案里的「编码」完全一致；「管理方式」也要对应（精密件=SN 逐件，结构件=批次）。编码对不上，WMS 将无法为对应工单备料/出库。\n\n数据链路：先建「产品类型」→ 到本页选产品编码，为它逐条添加物料 → 之后仓库才能为对应工单领料。',
   fields: [
-    { name: '产品编码', source: '下拉/输入选择。来自「产品类型」管理里建的编码；同一型号可对应多个工单。', purpose: '要为哪个产品配置物料清单', fill: '选择产品编码后加载该产品已有清单' },
-    { name: '物料编码', source: '手工填写。必须与 WMS(库房) 物料档案的编码一致。', purpose: '该物料在库房的全库唯一编码，两条系统靠它关联', fill: '如 螺丝=SCREW-M3、主控芯片=IC-001；编码对不上 WMS 将无法备料' },
+    { name: '产品编码', source: '下拉选择。来自「产品类型」里建的编码。', purpose: '要为哪个产品配置物料清单', fill: '在查询区或「添加物料」弹窗里选择产品编码' },
+    { name: '物料编码', source: '手工填写。必须与 WMS(库房) 物料档案的编码一致。', purpose: '该物料在库房的全库唯一编码，两系统靠它关联', fill: '如 螺丝=GJ-LUOSI-M16；编码对不上 WMS 将无法备料' },
     { name: '物料名称', source: '手工填写。', purpose: '物料中文名，便于识别', fill: '如 十字螺丝、主控芯片' },
-    { name: '规格', source: '手工填写。', purpose: '物料规格型号', fill: '如 M3×8 / SMT-48脚' },
+    { name: '规格', source: '手工填写。', purpose: '物料规格型号', fill: '如 M16×80 / SMT-48脚' },
     { name: '单位', source: '手工填写。', purpose: '计量单位，用于算量', fill: '个 / 件 / 套 / kg' },
-    { name: '管理方式', source: '单选。按物料类型决定，与 WMS 一致。', purpose: '精密件=逐件按SN管理；结构件=按批次管理', fill: '电子件选"精密件 SN"；螺丝等标准件选"结构件 批次"' },
+    { name: '管理方式', source: '单选。按物料类型决定，与 WMS 一致。', purpose: '精密件=逐件按SN管理；结构件=按批次管理', fill: '电子件/精密件选"精密件 SN"；螺丝等标准件选"结构件 批次"' },
     { name: '单台用量', source: '手工填写。', purpose: '生产 1 台产品用的该物料数量', fill: '如每台 8 颗螺丝 → 填 8' },
     { name: '损耗率%', source: '手工填写。', purpose: '考虑报废/损耗的加放比例', fill: '如 2% 填 2；0=不计算损耗' },
     { name: '需求量', source: '自动计算 = 数量×单台用量×(1+损耗率)，可覆盖。', purpose: '该物料总需求，出库不能超它', fill: '一般自动算，不必改' }
@@ -83,32 +75,43 @@ export const helpBom = {
 }
 
 export const helpMaterial = {
-  title: '备料单（查询）',
+  title: '备料单（按日排产自动算料）',
   overview:
-    '备料单按"日排产"自动算出某天需要的全部物料，仓库据此备料、由 AGV 配送到各工位(DOCK)。\n本页是只读查询，不修改数据。\n\n数据链路：日排产(工单内) → 本页按日期取那天所有工单的物料汇总 → 仓库出库 → AGV 配送。',
-  fields: [
-    { name: '日期', source: '手动选择。筛选条件。', purpose: '查看哪一天的备料需求', fill: '选择某排产日期' },
-    { name: '工单号', source: '手动输入。筛选条件。', purpose: '只查看指定工单的备料', fill: '可空，空=看全部工单' },
-    { name: '状态', source: '下拉。数据来自备料执行状态。', purpose: '按备料进度筛选', fill: '可空' }
+    '备料单 = 仓库备料的依据：某天要生产的所有工单，各需要哪些物料、各要多少。\n\n操作方式：① 先到「日排产」排好某天的计划数量；② 回到本页选该「日期」；③ 点「按日排产生成备料」，系统按各产品 BOM 自动计算（计划数量 × 单台用量 × (1+损耗率)）并生成备料单明细；④ 仓库据此备料出库，由 AGV 配送到各工位。\n\n数据链路：日排产 → 本页按日期自动算料生成备料单 → 仓库出库 → AGV 配送。',
+  sections: [
+    {
+      title: '生成备料',
+      overview: '按所选日期，取当天所有排产工单，依据各自产品的 BOM 自动汇总所需物料。',
+      fields: [
+        { name: '日期', source: '手动选择。', purpose: '按哪个排产日期生成备料', fill: '先选择排产日期，再点「按日排产生成备料」' }
+      ]
+    },
+    {
+      title: '查询字段',
+      fields: [
+        { name: '工单号', source: '手动输入。筛选条件。', purpose: '只查看指定工单的备料', fill: '可空，空=看全部工单' },
+        { name: '状态', source: '下拉。待备料/已确认。', purpose: '按备料进度筛选', fill: '可空' }
+      ]
+    }
   ]
 }
 
 export const helpPlc = {
-  title: 'PLC 工序下发',
+  title: '工位组合下发（业务说明）',
   overview:
-    '把工序组合写入西门子 S7-1214 PLC 寄存器，产线传送带据此只执行对应工序。\n系统遵循"未收到完成信号不下发下一条"，确保产线不串序。\n\n数据链路：工单(含工序组合) → 下发到 S7-1214 → PLC 驱动工位/传送带 → 收到完成信号再下发下一条。',
+    '这个菜单做什么用：把某个工单/工件的「工位组合」写入西门子 S7-1214 PLC，产线传送带据此只停靠勾选的工位，其余工位不加工。\n\n什么时候用：一个工件进线/上线时，需要告诉 PLC「这件货要走哪几个工位」，就在这里下发。\n\n为什么单独一个菜单：产线偶尔需要人工干预——比如本该走 3 号工位却做成了半成品，人工在此改成只补第 2 工位重上线，完成闭环。一切交给人工自行判断。\n\n核心约束：系统遵循「上一条未收到完成信号，不下发下一条」，确保产线不串序。\n\n数据链路：工单(含工位组合) → 本页下发到 S7-1214 → PLC 驱动传送带/工位 → 收到完成信号再下发下一条。',
   fields: [
-    { name: '工单号', source: '手动输入/选择。来自工单。', purpose: '当前生产的工单，追溯依据', fill: '选择或输入工单号' },
+    { name: '工单号', source: '下拉选择/输入。来自工单。', purpose: '当前生产的工单，追溯依据', fill: '选择或输入工单号' },
     { name: '工件SN', source: '扫码枪扫描。来自工件条码。', purpose: '当前流经的工件唯一序列号', fill: '扫码枪扫入；可空(按工单整体下发)' },
-    { name: '工位', source: '手动填写。', purpose: '下发到哪个工位(1~12)', fill: '输入 1~12 的整数' },
-    { name: '工序组合', source: '手动填写。通常与工单的工序组合一致。', purpose: '该工位要执行的工序，PLC 组合执行', fill: '如 135(做第1/3/5序)；全序=123456789101112' }
+    { name: '当前工位', source: '手动填写。', purpose: '当前要下发的工位(1~12)', fill: '输入 1~12 的整数' },
+    { name: '工位组合', source: '勾选 12 个工位。通常与工单的工位组合一致。', purpose: '该工件要经过的工位，PLC 控制停靠', fill: '勾选即可，按工位号顺序执行' }
   ]
 }
 
 export const helpTorque = {
   title: '拧紧数据（查询/录入）',
   overview:
-    '接收丹尼科尔拧紧工具的采集结果(扭矩/角度/时间/结果/操作人)，用于质量追溯。\n数据在工位终端点"工序完成上报"后由拧紧枪数据同步到 MES。本页可查询，也可手工补录。',
+    '接收丹尼科尔拧紧工具的采集结果(扭矩/角度/时间/结果/操作人)，用于质量追溯。\n数据在工位终端点"工位完成上报"后由拧紧枪数据同步到 MES。本页可查询，也可手工补录。',
   fields: [
     { name: 'SN', source: '扫码枪/手工。来自工件条码。', purpose: '被拧紧的工件唯一序列号', fill: '扫码枪扫描' },
     { name: '工单号', source: '自动带出/选择。来自工单。', purpose: '该工件所属工单', fill: '选择工单号' },
@@ -120,34 +123,31 @@ export const helpTorque = {
 }
 
 export const helpScan = {
-  title: '手动报工（工位工序完成上报）',
+  title: '手动报工（工位工序步骤完成上报）',
   overview:
-    '每个工位装配/检测相对工序完成后，在【手动报工】页选择工位、扫入工件SN、选工序号，系统按该工序已维护的【工艺参数】模板动态展开需要采集的参数，人工录入并提交。\n提交后写工序实绩 + 步骤数据，系统按步骤考核标准自动判定 OK/NG。\n\n数据链路：工艺参数(维护每道工序要收集哪些参数、判定标准) → 手动报工页扫SN逐参数录入 → 判 OK/NG → 工件追溯可见。',
+    '每个工位完成本工位的工序步骤后，在【手动报工】页选择工位、扫入工件SN，系统按该工位「启用」的工艺流程自动展开其工序步骤（扭矩/角度/尺寸等采集项），人工录入并提交。\n提交后写报工实绩 + 步骤数据，系统按步骤考核标准自动判定 OK/NG。\n\n数据链路：工艺流程(为工位维护工序步骤与考核标准) → 手动报工页选工位扫SN → 自动载入该工位工序步骤 → 逐参数录入 → 判 OK/NG → 工件追溯可见。',
   fields: [
-    { name: '工位', source: '下拉选择(1~12)。', purpose: '哪个工位在报工', fill: '选择工位 1~12' },
-    { name: '工件SN', source: '扫码枪扫描。来自工件条码。', purpose: '工件的唯一序列号，报工对象', fill: '扫码枪扫入，触发载入参数模板' },
-    { name: '工序号', source: '手动选择(1~12)。', purpose: '本次完成的工序，展开该工序的参数模板', fill: '选择 1~12' },
-    { name: '各步骤采集值', source: '手工填写 或 拧紧枪自动带出(视采集方式)。字段由【工艺参数】维护页人为定义，可增加/删除/改采集方式与判定标准。', purpose: '收集该工序的扭矩/角度/尺寸等参数，按标准判定合格与否', fill: '逐条填采集值，未维护标准的步骤仅记录' }
+    { name: '工位', source: '下拉选择(1~12)。', purpose: '哪个工位在报工，自动带出该工位的工序步骤', fill: '选择工位 1~12' },
+    { name: '工件SN', source: '扫码枪扫描。来自工件条码。', purpose: '工件的唯一序列号，报工对象', fill: '扫码枪扫入，触发载入工序步骤' },
+    { name: '各步骤采集值', source: '手工填写 或 拧紧枪自动带出(视采集方式)。字段由【工艺流程】的工序步骤人为定义。', purpose: '收集该工位的扭矩/角度/尺寸等参数，按标准判定合格与否', fill: '逐条填采集值，未维护标准的步骤仅记录' }
   ]
 }
 
-export const helpProcessStep = {
-  title: '工艺参数（工序步骤与考核标准维护）',
+export const helpStation = {
+  title: '关联工位（工位总览）',
   overview:
-    '人为维护【每道工序要收集哪些参数】及【合格判定标准】，是手动报工的基础——报工页按这里的模板动态渲染参数输入框。\n· 一道工序可有多个步骤(参数)；\n· 每步可选择采集方式：拧紧枪自动 / 手填 / 仅记录；\n· 每步可设考核标准(如扭矩在 [35,45] N·m 为合格)，报工时系统自动判 OK/NG。',
+    '产线固定 12 个工位，本页是工位总览：查看每个工位绑定了哪个工艺流程，可修改工位名称（不增删工位）。\n\n模型：一个工艺流程服务于一个工位（工艺流程页选择工位号）；一个工位只能有一个「启用」的工艺流程；流程启用后自动绑定到该工位，停用后自动解绑。\n\n数据链路：工艺流程(选工位号+维护工序步骤+启用) → 自动绑定工位 → 手动报工/工位终端按该流程的工序步骤采集 → 报工判定 OK/NG。',
   fields: [
-    { name: '工序号', source: '手动选择(1~12)。', purpose: '给哪道工序配置步骤', fill: '选择工序号，加载该工序现有步骤' },
-    { name: '步骤名称', source: '人为定义。', purpose: '该参数叫什么(如 装配完成/拧紧扭矩)', fill: '输入中文名称' },
-    { name: '采集方式', source: '人为选择。', purpose: '该参数怎么来：拧紧枪自动/手填/仅记录', fill: 'AUTO=拧紧枪自动；MANUAL=手填；NONE=仅记录' },
-    { name: '是否为拧紧', source: '开关。', purpose: '标识是否属于拧紧采集', fill: '拧紧扭矩/角度步骤打开' },
-    { name: '判定标准', source: '人为定义。可为一条或多条。', purpose: '报工时自动判定 OK/NG 的依据', fill: '如 扭矩 RANGE [35,45]；角度 GE 90 等' }
+    { name: '工位号', source: '系统固定(1~12)，不可增删。', purpose: '产线物理工位编号', fill: '无需填写' },
+    { name: '工位名称', source: '可编辑。默认如 装配工位1。', purpose: '工位的显示名称', fill: '如 一号装配工位' },
+    { name: '绑定工艺流程', source: '自动来自「工艺流程」页：流程选工位号并启用即绑定。', purpose: '该工位执行的工艺流程（决定工序步骤/考核标准/PDF）', fill: '到「工艺流程」页为该工位启用流程；本页只读展示' }
   ]
 }
 
 export const helpTrace = {
   title: '工件追溯',
   overview:
-    '输入工件 SN，查它的完整履历：进线/完工时间、各工序时间线、步骤考核数据(扭矩/角度)、拧紧记录、以及它用了哪些批次/精密件。\n\n数据来源：全部由前端各环节自动写入(扫码报工、拧紧采集、PLC下发、工序完成)，本页只读查询。',
+    '输入工件 SN，查它的完整履历：进线/完工时间、各工位时间线、步骤考核数据(扭矩/角度)、拧紧记录、以及它用了哪些批次/精密件。\n\n数据来源：全部由前端各环节自动写入(扫码报工、拧紧采集、PLC下发、工位完成)，本页只读查询。',
   fields: [
     { name: '工件SN', source: '扫码枪/手输。来自工件条码。', purpose: '要追溯的工件唯一序列号', fill: '扫 SN 或手动输入后点查询' }
   ]
@@ -156,7 +156,7 @@ export const helpTrace = {
 export const helpRbac = {
   title: '角色权限管理（用户/角色/权限）',
   overview:
-    '管控谁能登录、能看哪些菜单。建议只给操作员分配其工序所需菜单权限。\n登录 token 有效期短(1800秒)，超时自动失效需重新登录。',
+    '管控谁能登录、能看哪些菜单。建议只给操作员分配其工位所需菜单权限。\n登录 token 有效期短(1800秒)，超时自动失效需重新登录。',
   sections: [
     {
       title: '用户（新建/编辑）',
@@ -203,28 +203,48 @@ export const helpEventLog = {
 }
 
 export const helpProcessFlow = {
-  title: '工艺流程（流程图 ↔ 工序编号 ↔ 工位）',
+  title: '工艺流程（服务于固定工位，含工序步骤）',
   overview:
-    '维护「流程图 → 工序编号(1~12) → 工位」三层关系，是工位终端和巡检的基础。\n\n模型：一个流程图只包含一个工序编号(如"工序3")，一个工序编号可有多个流程图版本(如 工序3_2026版/工序3_2027版)，一个工位同时只绑定一个流程图。工位绑定流程图后，工位终端报工时 processCode 从流程取。\n\n数据链路：本页维护流程图+步骤模板+考核标准 → 工位绑定流程图 → 工位终端扫码采集按步骤模板渲染 → 报工写步骤数据并按标准判 OK/NG → 工件追溯/绩效报表可见。\n步骤的采集方式与考核标准与【工艺参数】页共用同一套模板数据。',
+    '工艺流程 = 某个固定工位(1~12)的作业指导：包含 工位号、工艺图纸PDF、工序步骤（含采集方式与考核标准）。\n\n概念统一说明：\n· 工位：产线固定 12 个物理工位（工位1~工位12），本流程页选择流程服务于哪个工位。\n· 工艺流程：一个流程服务于一个工位，可有多版本(如 3号工位_2026版)；一个工位只能有一个「启用」的流程。\n· 工序步骤：流程内包含多个工序步骤（如：装配完成、拧紧扭矩、测试）。\n\n绑定规则：流程选工位号并「启用」后，自动绑定到该工位；「停用」后自动解绑。手动报工页选工位时，自动带出该工位启用流程的工序步骤。\n\n数据链路：本页维护流程+工序步骤+考核标准 → 自动绑定工位 → 手动报工/工位终端按工序步骤采集 → 报工按考核标准自动判 OK/NG → 工件追溯/绩效报表可见。',
   fields: [
-    { name: '流程名称', source: '手工填写。人为定义。', purpose: '流程图版本名，用于区分同工序的不同版本', fill: '如 工序3_2026版' },
-    { name: '工序编号', source: '下拉选择(1~12)。与产线 12 道工序一一对应。', purpose: '该流程图绑定哪道工序；一个流程只能绑一道', fill: '如 3' },
-    { name: '工艺图纸(PDF)', source: '本页上传。上传的文件由 MES 服务器保存，生成文件名。', purpose: '该工序的作业指导图，工位终端打开并预览', fill: '选择 PDF 文件上传，上传成功后显示文件名，可预览' },
-    { name: '步骤模板', source: '本页维护(步骤名/采集方式/是否拧紧)。采集方式三选一：AUTO=拧紧枪自动采集、MANUAL=手动录入、NONE=仅记录。', purpose: '工位终端报工时按此模板动态渲染参数输入；AUTO 步骤的值由拧紧枪采集结果带出', fill: '如 拧紧扭矩(MANUAL)、装配完成(NONE)' },
-    { name: '考核标准', source: '本页为每个步骤维护(名称/单位/判定逻辑/目标值或上下限)。', purpose: '报工时系统按此标准自动判定该步骤 OK/NG，判定结果进入追溯与流程卡', fill: '如 扭矩 RANGE [35,45]；角度 GE 90' },
-    { name: '工位号', source: '【工位管理】tab 维护。下拉选择本页流程，即完成工位绑定。', purpose: '工位(1~12)绑定哪个流程图；一个工位同时只绑一个', fill: '选择工位号 + 该工位要用的流程' }
+    { name: '流程名称', source: '手工填写。人为定义。', purpose: '流程版本名，用于区分同一工位的不同版本', fill: '如 3号工位装配流程 / 3号工位_2026版' },
+    { name: '工位号', source: '下拉选择(1~12)。产线固定 12 个工位。', purpose: '该流程服务于哪个工位；一个工位只能有一个启用流程', fill: '如 3；该工位已有启用流程时需先停用再启用新流程' },
+    { name: '状态', source: '下拉选择 启用/停用。也可在列表操作列点「启用/停用」快捷切换。', purpose: '启用=自动绑定该工位并参与生产；停用=自动解绑工位', fill: '启用后自动绑定工位；停用后自动解绑' },
+    { name: '工艺图纸(PDF)', source: '本页上传。文件由 MES 服务器保存。', purpose: '该工位的作业指导图，工位终端打开预览', fill: '选择 PDF 上传，成功后显示文件名可预览' },
+    { name: '工序步骤', source: '本页维护(步骤名/采集方式/是否拧紧/考核标准)。', purpose: '手动报工/工位终端报工时按此动态渲染参数输入', fill: '一个流程可含多个工序步骤，按序号顺序执行' }
+  ],
+  sections: [
+    {
+      title: '采集方式（每个工序步骤三选一）',
+      overview: '决定该步骤的数值从哪里来。',
+      fields: [
+        { name: '拧紧枪自动', source: '拧紧枪设备自动回传。', purpose: '扭矩/角度等由拧紧枪采集，工人无需手输', fill: '选「拧紧枪自动」，并在「是否拧紧」打开开关' },
+        { name: '手填', source: '工人在工位终端/报工页手动输入数值。', purpose: '无法自动采集的参数(如尺寸、电压)由人工录入', fill: '选「手填」' },
+        { name: '仅记录', source: '无数据，只做操作步骤确认(如"装配完成")。', purpose: '记录该步骤已执行，不采集数值、不判定', fill: '选「仅记录」' }
+      ]
+    },
+    {
+      title: '考核标准（每个步骤可设多条）',
+      overview: '用于报工时自动判定该步骤「合格/不合格」。在哪用：工位终端/手动报工提交该步骤数值时，系统按此标准判 OK/NG，结果进入工件追溯与流程卡。如何收集：数值来自上面的采集方式(拧紧枪自动或手填)。',
+      fields: [
+        { name: '指标名', source: '人为定义。', purpose: '标准叫什么(如 扭矩/角度/尺寸)', fill: '如 扭矩' },
+        { name: '单位', source: '人为填写。', purpose: '数值单位', fill: '如 N·m、°、mm' },
+        { name: '逻辑', source: '下拉选择 ≥/≤/>/</区间/=。', purpose: '判定关系', fill: '区间需填上下限；其余填目标值' },
+        { name: '目标值/下限/上限', source: '人为填写。', purpose: '合格范围', fill: '如 扭矩区间 [35,45] N·m' }
+      ]
+    }
   ]
 }
 
 export const helpPerformance = {
   title: '绩效报表（工人工作量统计）',
   overview:
-    '按 操作人 × 日期 × 工序 汇总每个工人的完成/合格/NG 数量，用于工作量与绩效统计。\n\n数据来源：全部由工位终端/手动报工的「工序完成上报」自动写入工序实绩(workpiece_process)，本页只读统计，不手工录入。\n\n数据链路：工位终端报工(写工序实绩) → 本页按人/天/工序聚合 → 出报表。',
+    '按 操作人 × 日期 × 工位 汇总每个工人的完成/合格/NG 数量，用于工作量与绩效统计。\n\n数据来源：全部由工位终端/手动报工的「工位完成上报」自动写入报工实绩(workpiece_process)，本页只读统计，不手工录入。\n\n数据链路：工位终端报工(写报工实绩) → 本页按人/天/工位聚合 → 出报表。',
   fields: [
-    { name: '操作人', source: '筛选条件。来自工序实绩的 operator 字段(工位终端登录人)。', purpose: '只看某个工人的工作量', fill: '输入姓名/账号，可空=全部' },
-    { name: '日期范围', source: '筛选条件。来自工序实绩的产生时间。', purpose: '按时间段统计', fill: '选择起止日期，可空=全部' },
-    { name: '完成数', source: '自动汇总。该 操作人×日期×工序 的报工次数。', purpose: '工作量核心指标', fill: '只读' },
-    { name: '合格数/NG数', source: '自动汇总。按工序实绩 result 字段(OK/NG)分类计数。', purpose: '质量指标，OK+NG=完成数', fill: '只读' },
+    { name: '操作人', source: '筛选条件。来自报工实绩的 operator 字段(工位终端登录人)。', purpose: '只看某个工人的工作量', fill: '输入姓名/账号，可空=全部' },
+    { name: '日期范围', source: '筛选条件。来自报工实绩的产生时间。', purpose: '按时间段统计', fill: '选择起止日期，可空=全部' },
+    { name: '完成数', source: '自动汇总。该 操作人×日期×工位 的报工次数。', purpose: '工作量核心指标', fill: '只读' },
+    { name: '合格数/NG数', source: '自动汇总。按报工实绩 result 字段(OK/NG)分类计数。', purpose: '质量指标，OK+NG=完成数', fill: '只读' },
     { name: '合格率', source: '自动计算 = 合格数/完成数。', purpose: '质量表现', fill: '只读' }
   ]
 }
@@ -253,7 +273,7 @@ export const helpInspect = {
     {
       title: '过程巡检',
       fields: [
-        { name: '工单号', source: '手动选择/搜索。来自【工单管理】已建工单。', purpose: '对哪个工单巡检，可查看其当前工序进度', fill: '搜索选择工单号' },
+        { name: '工单号', source: '手动选择/搜索。来自【工单管理】已建工单。', purpose: '对哪个工单巡检，可查看其当前工位进度', fill: '搜索选择工单号' },
         { name: '合格/不合格', source: '手动选择(OK/NG)。', purpose: '本次巡检结论', fill: '选择合格或不合格' },
         { name: '签字', source: '手写/输入签字内容。', purpose: '检验人签字留证', fill: '输入签字内容' }
       ]
@@ -261,8 +281,8 @@ export const helpInspect = {
     {
       title: '完工确认',
       fields: [
-        { name: '工单号', source: '手动选择/搜索。来自【工单管理】。', purpose: '确认哪个工单全部工序完成', fill: '搜索选择工单号' },
-        { name: '确认全部工序完成', source: '手动勾选。', purpose: '声明该工单全部工序已完成', fill: '勾选确认' },
+        { name: '工单号', source: '手动选择/搜索。来自【工单管理】。', purpose: '确认哪个工单全部工位完成', fill: '搜索选择工单号' },
+        { name: '确认全部工位完成', source: '手动勾选。', purpose: '声明该工单全部工位已完成', fill: '勾选确认' },
         { name: '签字', source: '手写/输入。', purpose: '确认人签字留证', fill: '输入签字内容' }
       ]
     },
diff --git a/bj_power_mes/frontend/src/layouts/MainLayout.vue b/bj_power_mes/frontend/src/layouts/MainLayout.vue
index e484bfd..802effd 100644
--- a/bj_power_mes/frontend/src/layouts/MainLayout.vue
+++ b/bj_power_mes/frontend/src/layouts/MainLayout.vue
@@ -5,6 +5,7 @@
       <el-menu v-if="menus.length" :default-active="$route.path" router background-color="#001529"
         text-color="#a6adb4" active-text-color="#409eff" style="border-right:none">
         <el-menu-item v-for="m in menus" :key="m.path" :index="m.path">
+          <el-icon style="margin-right:8px"><component :is="m.icon" /></el-icon>
           <span>{{ m.name }}</span>
         </el-menu-item>
       </el-menu>
@@ -17,10 +18,17 @@
       <el-header class="header">
         <span class="page-title">{{ $route.meta.title || '' }}</span>
         <div class="spacer"></div>
-        <div>
-          <span style="margin-right:16px">{{ userName }}</span>
-          <el-button size="small" @click="router.push('/change-password')">修改密码</el-button>
-          <el-button size="small" @click="doLogout">退出</el-button>
+        <div class="header-right">
+          <el-button class="help-btn" text @click="openHelp">帮助</el-button>
+          <el-dropdown trigger="click" @command="onUserCmd">
+            <span class="user-name">{{ userName }} <span class="caret">▾</span></span>
+            <template #dropdown>
+              <el-dropdown-menu>
+                <el-dropdown-item command="password">修改密码</el-dropdown-item>
+                <el-dropdown-item divided command="logout">退出登录</el-dropdown-item>
+              </el-dropdown-menu>
+            </template>
+          </el-dropdown>
         </div>
       </el-header>
       <el-main style="padding:14px">
@@ -33,6 +41,10 @@
 <script setup>
 import { ref, computed, onMounted } from 'vue'
 import { useRouter } from 'vue-router'
+import {
+  Document, Calendar, Box, Goods, ShoppingCart, Monitor, Tools,
+  Operation, Link, DataLine, EditPen, Search, CircleCheck, Clock, User
+} from '@element-plus/icons-vue'
 import { getUser, logout } from '../utils/auth'
 import request from '../utils/request'
 
@@ -51,10 +63,10 @@ const defaultMenus = [
   { code: 'produce.dailyplan', name: '日排产', path: '/daily-plan' },
   { code: 'produce.bom', name: '物料清单', path: '/bom' },
   { code: 'produce.material', name: '备料单', path: '/material-request' },
-  { code: 'produce.plc', name: 'PLC工序下发', path: '/plc-send' },
+  { code: 'produce.plc', name: '工位组合下发', path: '/plc-send' },
   { code: 'produce.torque', name: '拧紧查询', path: '/torque' },
-  { code: 'produce.step', name: '工艺参数', path: '/process-step' },
   { code: 'produce.processflow', name: '工艺流程', path: '/process-flow' },
+  { code: 'produce.station', name: '关联工位', path: '/station' },
   { code: 'produce.performance', name: '绩效报表', path: '/performance' },
   { code: 'produce.scan', name: '手动报工', path: '/scan' },
   { code: 'produce.trace', name: '工件追溯', path: '/trace' },
@@ -80,6 +92,19 @@ function doLogout() {
   logout()
   router.replace('/login')
 }
+
+// 打开当前页面帮助（PageHelp 监听该全局事件弹出抽屉）
+function openHelp() {
+  window.dispatchEvent(new CustomEvent('mes:open-page-help'))
+}
+
+function onUserCmd(cmd) {
+  if (cmd === 'password') {
+    router.push('/change-password')
+  } else if (cmd === 'logout') {
+    doLogout()
+  }
+}
 </script>
 
 <style scoped>
@@ -90,4 +115,9 @@ function doLogout() {
 .header { display: flex; align-items: center; justify-content: space-between; background: #fff; border-bottom: 1px solid #eee; }
 .page-title { font-size: 16px; font-weight: 600; color: #303133; }
 .spacer { flex: 1; }
+.header-right { display: flex; align-items: center; gap: 6px; }
+.help-btn { font-size: 13px; color: #606266; }
+.user-name { display: inline-flex; align-items: center; gap: 4px; cursor: pointer; font-size: 14px; color: #303133; outline: none; padding: 4px 6px; border-radius: 4px; }
+.user-name:hover { color: #1668dc; background: #f2f6fc; }
+.caret { font-size: 10px; color: #909399; }
 </style>
\ No newline at end of file
diff --git a/bj_power_mes/frontend/src/pages/Bom.vue b/bj_power_mes/frontend/src/pages/Bom.vue
index d306112..bd7ba60 100644
--- a/bj_power_mes/frontend/src/pages/Bom.vue
+++ b/bj_power_mes/frontend/src/pages/Bom.vue
@@ -2,7 +2,7 @@
   <el-card>
     <el-form inline>
       <el-form-item label="产品编码">
-        <el-select v-model="productCode" filterable allow-create default-first-option placeholder="请选择/输入产品编码" style="width:240px" @change="load">
+        <el-select v-model="productCode" filterable clearable placeholder="选择产品编码查看其物料清单" style="width:240px" @change="load">
           <el-option v-for="p in products" :key="p.code" :label="`${p.code}　${p.name || ''}`" :value="p.code" />
         </el-select>
       </el-form-item>
@@ -13,12 +13,13 @@
     </el-form>
 
     <el-table :data="list" border size="small">
+      <el-table-column prop="productCode" label="产品编码" min-width="120" />
       <el-table-column prop="materialCode" label="物料编码" min-width="120" />
       <el-table-column prop="materialName" label="物料名称" min-width="120" />
       <el-table-column prop="spec" label="规格" />
       <el-table-column prop="unit" label="单位" width="70" />
-      <el-table-column prop="manageMode" label="管理方式" width="100">
-        <template #default="{row}">{{ row.manageMode === '1' ? '精密件(SN)' : '结构件(批次)' }}</template>
+      <el-table-column prop="manageMode" label="管理方式" width="110">
+        <template #default="{row}">{{ row.manageMode === '1' ? '结构件(批次)' : '精密件(SN)' }}</template>
       </el-table-column>
       <el-table-column prop="unitQty" label="单台用量" width="90" />
       <el-table-column prop="lossRate" label="损耗率%" width="90" />
@@ -31,15 +32,22 @@
     </el-table>
 
     <el-dialog v-model="add.show" title="添加物料清单" width="520px">
+      <el-alert type="info" :closable="false" style="margin-bottom:12px"
+        title="物料编码须与 WMS(库房)「物料档案」的编码完全一致，才能备料/出库。管理方式：精密件按 SN 逐件、结构件按批次。" />
       <el-form :model="add" label-width="90px">
-        <el-form-item label="物料编码"><el-input v-model="add.materialCode" /></el-form-item>
+        <el-form-item label="产品编码" required>
+          <el-select v-model="add.productCode" filterable placeholder="选择产品编码" style="width:100%">
+            <el-option v-for="p in products" :key="p.code" :label="`${p.code}　${p.name || ''}`" :value="p.code" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="物料编码" required><el-input v-model="add.materialCode" placeholder="须与 WMS 物料档案编码一致" /></el-form-item>
         <el-form-item label="物料名称"><el-input v-model="add.materialName" /></el-form-item>
         <el-form-item label="规格"><el-input v-model="add.spec" /></el-form-item>
         <el-form-item label="单位"><el-input v-model="add.unit" /></el-form-item>
         <el-form-item label="管理方式">
           <el-radio-group v-model="add.manageMode">
-            <el-radio label="1">精密件(SN)</el-radio>
-            <el-radio label="2">结构件(批次)</el-radio>
+            <el-radio label="2">精密件(SN)</el-radio>
+            <el-radio label="1">结构件(批次)</el-radio>
           </el-radio-group>
         </el-form-item>
         <el-form-item label="单台用量"><el-input-number v-model="add.unitQty" :min="0" /></el-form-item>
@@ -66,19 +74,22 @@ import { helpBom } from '../help'
 const productCode = ref('')
 const products = ref([])
 const list = ref([])
-const add = reactive({ show: false, materialCode: '', materialName: '', spec: '', unit: '', manageMode: '2', unitQty: 1, lossRate: 0, requiredQty: 1 })
+const add = reactive({ show: false, productCode: '', materialCode: '', materialName: '', spec: '', unit: '', manageMode: '2', unitQty: 1, lossRate: 0, requiredQty: 1 })
 
 async function load() {
-  if (!productCode.value) return ElMessage.warning('请选择/输入产品编码')
+  if (!productCode.value) return ElMessage.warning('请选择产品编码')
   list.value = (await request.get('/bom', { params: { productCode: productCode.value } })) || []
 }
 function openAdd() {
-  Object.assign(add, { show: true, materialCode: '', materialName: '', spec: '', unit: '', manageMode: '2', unitQty: 1, lossRate: 0, requiredQty: 1 })
+  Object.assign(add, { show: true, productCode: productCode.value || '', materialCode: '', materialName: '', spec: '', unit: '', manageMode: '2', unitQty: 1, lossRate: 0, requiredQty: 1 })
 }
 async function save() {
-  await request.put('/bom', { productCode: productCode.value, items: [add] })
+  if (!add.productCode) return ElMessage.warning('请选择产品编码')
+  if (!add.materialCode) return ElMessage.warning('请填写物料编码')
+  await request.put('/bom', { productCode: add.productCode, items: [add] })
   ElMessage.success('保存成功')
   add.show = false
+  productCode.value = add.productCode
   load()
 }
 async function remove(row) {
@@ -92,4 +103,4 @@ async function remove(row) {
 onMounted(async () => {
   products.value = (await request.get('/product-types')) || []
 })
-</script>
\ No newline at end of file
+</script>
diff --git a/bj_power_mes/frontend/src/pages/Inspect.vue b/bj_power_mes/frontend/src/pages/Inspect.vue
index 334d123..82277b9 100644
--- a/bj_power_mes/frontend/src/pages/Inspect.vue
+++ b/bj_power_mes/frontend/src/pages/Inspect.vue
@@ -63,7 +63,7 @@
             </el-select>
           </el-form-item>
           <el-alert v-if="process.order" type="info" :closable="false" class="order-info">
-            已选工单：{{ process.order.workOrderNo }}<template v-if="process.order.productName"> · {{ process.order.productName }}</template><template v-if="process.order.processSeq"> · 工序组合 {{ process.order.processSeq }}</template><template v-if="process.order.status"> · {{ statusText(process.order.status) }}</template>
+            已选工单：{{ process.order.workOrderNo }}<template v-if="process.order.productName"> · {{ process.order.productName }}</template><template v-if="process.order.processSeq"> · 工位组合 {{ process.order.processSeq }}</template><template v-if="process.order.status"> · {{ statusText(process.order.status) }}</template>
           </el-alert>
           <el-form-item label="巡检结果">
             <el-radio-group v-model="process.result">
@@ -90,7 +90,7 @@
             </el-select>
           </el-form-item>
           <el-form-item label="完工确认">
-            <el-checkbox v-model="done.confirmed">确认该工单全部工序已完成</el-checkbox>
+            <el-checkbox v-model="done.confirmed">确认该工单全部工位已完成</el-checkbox>
           </el-form-item>
           <el-form-item label="签字确认">
             <el-input v-model="done.remark" placeholder="输入姓名签字确认" />
@@ -293,7 +293,7 @@ async function submitProcess() {
 
 async function submitDone() {
   if (!done.orderNo) return ElMessage.warning('请选择工单号')
-  if (!done.confirmed) return ElMessage.warning('请确认全部工序已完成')
+  if (!done.confirmed) return ElMessage.warning('请确认全部工位已完成')
   if (!done.remark.trim()) return ElMessage.warning('请签字确认')
   submitting.value = true
   try {
diff --git a/bj_power_mes/frontend/src/pages/MaterialRequest.vue b/bj_power_mes/frontend/src/pages/MaterialRequest.vue
index 3b51758..4333d61 100644
--- a/bj_power_mes/frontend/src/pages/MaterialRequest.vue
+++ b/bj_power_mes/frontend/src/pages/MaterialRequest.vue
@@ -1,11 +1,19 @@
 <template>
   <el-card>
+    <el-alert type="info" :closable="false" style="margin-bottom:12px"
+      title="备料单：根据「日排产」自动算出某天要生产的所有工单所需物料。选好排产日期后点「按日排产生成备料」，系统按各产品 BOM（单台用量×计划数量×(1+损耗率)）自动汇总生成备料单，仓库据此备料出库。" />
+
     <el-form inline>
       <el-form-item label="日期">
         <el-date-picker v-model="query.planDate" type="date" value-format="YYYY-MM-DD" @change="load" />
       </el-form-item>
       <el-form-item label="工单号"><el-input v-model="query.orderNo" clearable style="width:160px" @keyup.enter="load" /></el-form-item>
-      <el-form-item label="状态"><el-input v-model="query.status" style="width:120px" @keyup.enter="load" /></el-form-item>
+      <el-form-item label="状态">
+        <el-select v-model="query.status" clearable placeholder="全部" style="width:130px">
+          <el-option label="待备料" value="PENDING" />
+          <el-option label="已确认" value="CONFIRMED" />
+        </el-select>
+      </el-form-item>
       <el-form-item>
         <el-button type="primary" @click="load">查询</el-button>
         <el-button v-if="can('produce.material:generate')" type="success" @click="generate">按日排产生成备料</el-button>
@@ -20,10 +28,12 @@
       <el-table-column prop="materialName" label="物料名称" min-width="110" />
       <el-table-column prop="unit" label="单位" width="70" />
       <el-table-column prop="manageMode" label="管理方式" width="110">
-        <template #default="{row}">{{ row.manageMode === '1' ? 'SN' : '批次' }}</template>
+        <template #default="{row}">{{ row.manageMode === '1' ? '结构件(批次)' : '精密件(SN)' }}</template>
       </el-table-column>
       <el-table-column prop="reqQty" label="需求数量" width="90" />
-      <el-table-column prop="status" label="状态" width="90" />
+      <el-table-column prop="status" label="状态" width="90">
+        <template #default="{row}">{{ statusText(row.status) }}</template>
+      </el-table-column>
       <el-table-column prop="operator" label="操作人" width="90" />
     </el-table>
   </el-card>
@@ -32,7 +42,7 @@
 
 <script setup>
 import { reactive, ref, onMounted } from 'vue'
-import { ElMessage } from 'element-plus'
+import { ElMessage, ElMessageBox } from 'element-plus'
 import request from '../utils/request'
 import { can } from '../utils/perm'
 import PageHelp from '../components/PageHelp.vue'
@@ -41,11 +51,16 @@ import { helpMaterial } from '../help'
 const query = reactive({ planDate: '', orderNo: '', status: '' })
 const list = ref([])
 
+const statusText = (s) => (s === 'PENDING' ? '待备料' : s === 'CONFIRMED' ? '已确认' : s)
+
 async function load() {
   list.value = (await request.get('/material-requests', { params: query })) || []
 }
 async function generate() {
   if (!query.planDate) return ElMessage.warning('请先选择排产日期')
+  await ElMessageBox.confirm(
+    `将按排产日期 ${query.planDate} 的所有工单，根据各产品 BOM 自动计算所需物料并生成备料单。确认继续？`,
+    '生成备料', { type: 'info' })
   const data = await request.post('/material-requests/generate', { planDate: query.planDate })
   ElMessage.success(`已生成 ${data?.count || 0} 条备料`)
   load()
@@ -54,4 +69,4 @@ onMounted(() => {
   query.planDate = new Date().toISOString().slice(0, 10)
   load()
 })
-</script>
\ No newline at end of file
+</script>
diff --git a/bj_power_mes/frontend/src/pages/Performance.vue b/bj_power_mes/frontend/src/pages/Performance.vue
index a117b02..a91a6b2 100644
--- a/bj_power_mes/frontend/src/pages/Performance.vue
+++ b/bj_power_mes/frontend/src/pages/Performance.vue
@@ -53,8 +53,8 @@
     <el-table :data="rows" border size="small">
       <el-table-column prop="operator" label="操作人" min-width="110" />
       <el-table-column prop="date" label="日期" width="110" />
-      <el-table-column prop="processCode" label="工序" width="80" align="center" />
-      <el-table-column prop="processName" label="工序名" min-width="130" show-overflow-tooltip />
+      <el-table-column prop="processCode" label="工位" width="80" align="center" />
+      <el-table-column prop="processName" label="工位名" min-width="130" show-overflow-tooltip />
       <el-table-column prop="doneCount" label="完成数" width="90" align="right" />
       <el-table-column prop="okCount" label="合格数" width="90" align="right" />
       <el-table-column prop="ngCount" label="NG数" width="90" align="right" />
@@ -117,7 +117,7 @@ async function load() {
 // 导出 CSV（块6）：按当前查询结果生成，含 BOM 以便 Excel 打开中文不乱码
 function exportCsv() {
   if (!rows.value.length) return ElMessage.warning('当前无数据可导出')
-  const header = ['操作人', '日期', '工序', '工序名', '完成数', '合格数', 'NG数', '合格率']
+  const header = ['操作人', '日期', '工位', '工位名', '完成数', '合格数', 'NG数', '合格率']
   const lines = rows.value.map((r) => {
     const rate = Number(r.doneCount) ? ((Number(r.okCount) / Number(r.doneCount)) * 100).toFixed(1) + '%' : '-'
     return [r.operator, r.date, r.processCode, r.processName, r.doneCount, r.okCount, r.ngCount, rate]
diff --git a/bj_power_mes/frontend/src/pages/PlcSend.vue b/bj_power_mes/frontend/src/pages/PlcSend.vue
index 0aa44e4..448dd13 100644
--- a/bj_power_mes/frontend/src/pages/PlcSend.vue
+++ b/bj_power_mes/frontend/src/pages/PlcSend.vue
@@ -1,19 +1,37 @@
 <template>
   <el-card>
+    <el-alert type="info" :closable="false" style="margin-bottom:12px"
+      title="工位组合下发：把某工单/工件要经过的「工位组合」写入西门子 S7-1214 PLC，产线传送带据此只停靠对应工位。系统保证「上一条未收到完成信号前不下发下一条」，避免串序。" />
+
     <el-form inline>
-      <el-form-item label="工单号"><el-input v-model="send.orderNo" style="width:170px" /></el-form-item>
-      <el-form-item label="工件SN"><el-input v-model="send.sn" style="width:170px" /></el-form-item>
-      <el-form-item label="工位"><el-input-number v-model="send.stationNo" :min="1" :max="12" /></el-form-item>
-      <el-form-item label="工序组合"><el-input v-model="send.processCombination" placeholder="如 135" style="width:110px" /></el-form-item>
-      <el-form-item>
-        <el-button v-if="can('produce.plc:send')" type="primary" @click="doSend">下发工序码</el-button>
+      <el-form-item label="工单号">
+        <el-select v-model="send.orderNo" filterable allow-create clearable placeholder="请选择/输入工单号" style="width:200px">
+          <el-option v-for="w in workOrders" :key="w.workOrderNo" :label="w.workOrderNo" :value="w.workOrderNo" />
+        </el-select>
+      </el-form-item>
+      <el-form-item label="工件SN">
+        <el-input v-model="send.sn" placeholder="扫码或手输" style="width:160px" />
+      </el-form-item>
+      <el-form-item label="当前工位">
+        <el-input-number v-model="send.stationNo" :min="1" :max="12" />
       </el-form-item>
     </el-form>
+    <el-form-item label="工位组合">
+      <ProcessSeqPicker v-model="send.processCombination" />
+    </el-form-item>
+    <el-form-item>
+      <el-button v-if="can('produce.plc:send')" type="primary" @click="doSend">下发工位码</el-button>
+    </el-form-item>
 
     <el-divider content-position="left">下发日志</el-divider>
     <el-form inline>
       <el-form-item label="工单号"><el-input v-model="query.orderNo" clearable style="width:160px" /></el-form-item>
-      <el-form-item label="状态"><el-input v-model="query.status" style="width:120px" /></el-form-item>
+      <el-form-item label="状态">
+        <el-select v-model="query.status" clearable placeholder="全部" style="width:120px">
+          <el-option label="已下发" value="SENT" />
+          <el-option label="已完成" value="DONE" />
+        </el-select>
+      </el-form-item>
       <el-form-item><el-button @click="loadLogs">刷新</el-button></el-form-item>
     </el-form>
     <el-table :data="logs" border size="small">
@@ -21,9 +39,12 @@
       <el-table-column prop="orderNo" label="工单号" min-width="130" />
       <el-table-column prop="sn" label="SN" min-width="130" />
       <el-table-column prop="stationNo" label="工位" width="70" />
-      <el-table-column prop="processCombination" label="工序组合" width="100" />
-      <el-table-column prop="processCodes" label="工序码" width="120" />
-      <el-table-column prop="status" label="状态" width="90" />
+      <el-table-column prop="processCombination" label="工位组合" width="140" />
+      <el-table-column label="状态" width="90">
+        <template #default="{row}">
+          <el-tag :type="row.status === 'DONE' ? 'success' : 'warning'" size="small">{{ plcStatusText(row.status) }}</el-tag>
+        </template>
+      </el-table-column>
       <el-table-column prop="ack" label="完成" width="70">
         <template #default="{row}">{{ row.ack ? '是' : '否' }}</template>
       </el-table-column>
@@ -41,22 +62,29 @@ import { ElMessage } from 'element-plus'
 import request from '../utils/request'
 import { can } from '../utils/perm'
 import PageHelp from '../components/PageHelp.vue'
+import ProcessSeqPicker from '../components/ProcessSeqPicker.vue'
 import { helpPlc } from '../help'
 
 const send = reactive({ orderNo: '', sn: '', stationNo: 1, processCombination: '' })
 const query = reactive({ orderNo: '', status: '' })
 const logs = ref([])
+const workOrders = ref([])
+
+const plcStatusText = (s) => (s === 'DONE' ? '已完成' : '已下发')
 
 async function doSend() {
-  if (!send.orderNo || !send.processCombination) return ElMessage.warning('请填写工单号和工序组合')
+  if (!send.orderNo || !send.processCombination) return ElMessage.warning('请选择工单号和工位组合')
   try {
     await request.post('/plc/send-process', { ...send })
-    ElMessage.success('工序码下发成功（未收到完成信号不会下发下一条）')
+    ElMessage.success('工位码下发成功（未收到完成信号不会下发下一条）')
     loadLogs()
   } catch (e) { /* 拦截器已提示，如"上一条未完成" */ }
 }
 async function loadLogs() {
   logs.value = (await request.get('/plc/send-logs', { params: query })) || []
 }
-onMounted(loadLogs)
-</script>
\ No newline at end of file
+onMounted(async () => {
+  workOrders.value = (await request.get('/work-orders')) || []
+  loadLogs()
+})
+</script>
diff --git a/bj_power_mes/frontend/src/pages/ProcessFlow.vue b/bj_power_mes/frontend/src/pages/ProcessFlow.vue
index 5946baf..12856a1 100644
--- a/bj_power_mes/frontend/src/pages/ProcessFlow.vue
+++ b/bj_power_mes/frontend/src/pages/ProcessFlow.vue
@@ -1,103 +1,79 @@
 <template>
   <el-card>
-    <el-tabs v-model="tab" @tab-change="onTabChange">
-      <!-- ============ Tab1：工艺流程管理 ============ -->
-      <el-tab-pane label="工艺流程管理" name="flows">
-        <el-form inline>
-          <el-form-item label="工序号">
-            <el-select v-model="query.processCode" placeholder="全部" clearable style="width:140px" @change="loadFlows">
-              <el-option v-for="i in 12" :key="i" :label="`工序${i}`" :value="i" />
-            </el-select>
-          </el-form-item>
-          <el-form-item>
-            <el-button type="primary" @click="loadFlows">查询</el-button>
-          </el-form-item>
-          <el-form-item>
-            <el-button v-if="can('produce.processflow:add')" type="success" @click="openFlow()">新增流程</el-button>
-          </el-form-item>
-        </el-form>
+    <el-form inline>
+      <el-form-item label="工位号">
+        <el-select v-model="query.stationNo" placeholder="全部" clearable style="width:140px" @change="loadFlows">
+          <el-option v-for="i in 12" :key="i" :label="`工位${i}`" :value="i" />
+        </el-select>
+      </el-form-item>
+      <el-form-item>
+        <el-button type="primary" @click="loadFlows">查询</el-button>
+      </el-form-item>
+      <el-form-item>
+        <el-button v-if="can('produce.processflow:add')" type="success" @click="openFlow()">新增流程</el-button>
+      </el-form-item>
+    </el-form>
 
-        <el-table :data="flows" border size="small">
-          <el-table-column prop="id" label="ID" width="60" />
-          <el-table-column prop="name" label="流程名" min-width="120" show-overflow-tooltip />
-          <el-table-column prop="processCode" label="工序编号" width="90" align="center" />
-          <el-table-column label="PDF" width="130" align="center">
-            <template #default="{ row }">
-              <el-button v-if="row.pdfFile" link type="primary" @click="previewPdf(row.pdfFile)">预览</el-button>
-              <span v-else>-</span>
-            </template>
-          </el-table-column>
-          <el-table-column label="状态" width="90" align="center">
-            <template #default="{ row }">
-              <el-tag :type="row.status === 'ACTIVE' ? 'success' : 'info'">{{ row.status }}</el-tag>
-            </template>
-          </el-table-column>
-          <el-table-column label="绑定工位" min-width="110">
-            <template #default="{ row }">{{ (row.stations || []).join(', ') || '-' }}</template>
-          </el-table-column>
-          <el-table-column label="步骤" min-width="150">
-            <template #default="{ row }">
-              <el-tooltip
-                v-if="row.steps && row.steps.length"
-                :content="row.steps.map(s => `${s.seq}.${s.name}`).join('  ')">
-                <span>{{ row.steps.length }} 步</span>
-              </el-tooltip>
-              <span v-else>0 步</span>
-            </template>
-          </el-table-column>
-          <el-table-column prop="remark" label="备注" min-width="120" show-overflow-tooltip />
-          <el-table-column label="创建时间" width="150">
-            <template #default="{ row }">{{ fmt(row.createdAt) }}</template>
-          </el-table-column>
-          <el-table-column label="操作" width="150" align="center" fixed="right">
-            <template #default="{ row }">
-              <el-button
-                v-if="can('produce.processflow:add') || can('produce.processflow:edit')"
-                size="small" @click="openFlow(row)">编辑</el-button>
-              <el-button v-if="can('produce.processflow:delete')" size="small" type="danger" @click="delFlow(row)">删除</el-button>
-            </template>
-          </el-table-column>
-        </el-table>
-      </el-tab-pane>
-
-      <!-- ============ Tab2：工位管理 ============ -->
-      <el-tab-pane label="工位管理" name="stations">
-        <div style="margin-bottom:10px">
-          <el-button v-if="can('produce.station:edit')" type="success" @click="openStation()">新增工位</el-button>
-        </div>
-        <el-table :data="stations" border size="small">
-          <el-table-column prop="id" label="ID" width="60" />
-          <el-table-column prop="stationNo" label="工位号" width="90" align="center" />
-          <el-table-column prop="name" label="工位名称" min-width="130" show-overflow-tooltip />
-          <el-table-column prop="flowName" label="绑定流程" min-width="150" show-overflow-tooltip />
-          <el-table-column prop="processCode" label="工序编号" width="90" align="center" />
-          <el-table-column label="状态" width="90" align="center">
-            <template #default="{ row }">
-              <el-tag :type="row.status === 'ACTIVE' ? 'success' : 'info'">{{ row.status }}</el-tag>
-            </template>
-          </el-table-column>
-          <el-table-column label="操作" width="90" align="center" fixed="right">
-            <template #default="{ row }">
-              <el-button v-if="can('produce.station:edit')" size="small" @click="openStation(row)">编辑</el-button>
-            </template>
-          </el-table-column>
-        </el-table>
-      </el-tab-pane>
-    </el-tabs>
+    <el-table :data="flows" border size="small">
+      <el-table-column prop="id" label="ID" width="60" />
+      <el-table-column prop="name" label="流程名" min-width="130" show-overflow-tooltip />
+      <el-table-column prop="stationNo" label="工位号" width="90" align="center" />
+      <el-table-column label="PDF" width="90" align="center">
+        <template #default="{ row }">
+          <el-button v-if="row.pdfFile" link type="primary" @click="previewPdf(row.pdfFile)">预览</el-button>
+          <span v-else>-</span>
+        </template>
+      </el-table-column>
+      <el-table-column label="状态" width="90" align="center">
+        <template #default="{ row }">
+          <el-tag :type="row.status === 'ACTIVE' ? 'success' : 'info'">{{ statusText(row.status) }}</el-tag>
+        </template>
+      </el-table-column>
+      <el-table-column label="绑定工位" min-width="120">
+        <template #default="{ row }">{{ (row.stations || []).map(s => `工位${s}`).join('、') || '-' }}</template>
+      </el-table-column>
+      <el-table-column label="步骤" min-width="120">
+        <template #default="{ row }">
+          <el-tooltip
+            v-if="row.steps && row.steps.length"
+            :content="row.steps.map(s => `${s.seq}.${s.name}`).join('  ')">
+            <span>{{ row.steps.length }} 步</span>
+          </el-tooltip>
+          <span v-else>0 步</span>
+        </template>
+      </el-table-column>
+      <el-table-column prop="remark" label="备注" min-width="120" show-overflow-tooltip />
+      <el-table-column label="创建时间" width="150">
+        <template #default="{ row }">{{ fmt(row.createdAt) }}</template>
+      </el-table-column>
+      <el-table-column label="操作" width="220" align="center" fixed="right">
+        <template #default="{ row }">
+          <el-button
+            v-if="can('produce.processflow:add') || can('produce.processflow:edit')"
+            size="small" @click="openFlow(row)">编辑</el-button>
+          <el-button
+            v-if="can('produce.processflow:edit')"
+            size="small" :type="row.status === 'ACTIVE' ? 'danger' : 'success'" @click="toggleStatus(row)">
+            {{ row.status === 'ACTIVE' ? '停用' : '启用' }}
+          </el-button>
+          <el-button v-if="can('produce.processflow:delete')" size="small" type="danger" @click="delFlow(row)">删除</el-button>
+        </template>
+      </el-table-column>
+    </el-table>
 
     <!-- ============ 工艺流程 新增/编辑 ============ -->
-    <el-dialog v-model="flowDlg.show" :title="flowDlg.id ? '编辑工艺流程' : '新增工艺流程'" width="920px" top="6vh">
+    <el-dialog v-model="flowDlg.show" :title="flowDlg.id ? '编辑工艺流程' : '新增工艺流程'" width="940px" top="6vh">
       <el-form :model="flowDlg" label-width="90px">
         <el-row :gutter="12">
           <el-col :span="12">
             <el-form-item label="流程名" required>
-              <el-input v-model="flowDlg.name" placeholder="如 一号线总装流程" />
+              <el-input v-model="flowDlg.name" placeholder="如 3号工位装配流程" />
             </el-form-item>
           </el-col>
           <el-col :span="12">
-            <el-form-item label="工序编号" required>
-              <el-select v-model="flowDlg.processCode" style="width:100%">
-                <el-option v-for="i in 12" :key="i" :label="`工序${i}`" :value="i" />
+            <el-form-item label="工位号" required>
+              <el-select v-model="flowDlg.stationNo" placeholder="请选择工位号（固定12个）" style="width:100%">
+                <el-option v-for="i in 12" :key="i" :label="`工位${i}`" :value="i" />
               </el-select>
             </el-form-item>
           </el-col>
@@ -105,14 +81,14 @@
         <el-row :gutter="12">
           <el-col :span="12">
             <el-form-item label="状态">
-              <el-select v-model="flowDlg.status" style="width:100%">
+              <el-select v-model="flowDlg.status" placeholder="请选择状态" style="width:100%">
                 <el-option label="启用" value="ACTIVE" />
                 <el-option label="停用" value="INACTIVE" />
               </el-select>
             </el-form-item>
           </el-col>
           <el-col :span="12">
-            <el-form-item label="工序PDF">
+            <el-form-item label="作业指导PDF">
               <el-button
                 v-if="can('produce.processflow:upload')"
                 type="primary" plain :loading="flowDlg.uploading" @click="pickPdf">
@@ -130,8 +106,8 @@
           <el-input v-model="flowDlg.remark" placeholder="备注(可空)" />
         </el-form-item>
 
-        <!-- 步骤模板子表 -->
-        <el-form-item label="步骤模板">
+        <!-- 工序步骤子表 -->
+        <el-form-item label="工序步骤">
           <div style="width:100%">
             <el-table :data="flowDlg.steps" border size="small">
               <el-table-column label="步骤" width="80" align="center">
@@ -142,7 +118,7 @@
               <el-table-column label="步骤名称" min-width="140">
                 <template #default="{ row }"><el-input v-model="row.name" placeholder="如 拧紧扭矩" /></template>
               </el-table-column>
-              <el-table-column label="采集方式" width="130">
+              <el-table-column label="采集方式" width="140">
                 <template #default="{ row }">
                   <el-select v-model="row.collectType" placeholder="请选择">
                     <el-option value="AUTO" label="拧紧枪自动" />
@@ -157,64 +133,19 @@
               <el-table-column label="备注" min-width="120">
                 <template #default="{ row }"><el-input v-model="row.remark" placeholder="备注(可空)" /></template>
               </el-table-column>
-              <el-table-column label="操作" width="120" align="center">
+              <el-table-column label="考核标准" width="110" align="center">
                 <template #default="{ row }">
-                  <el-button link type="primary" size="small" @click="row._showCrit = !row._showCrit">
-                    {{ row._showCrit ? '收起标准' : '考核标准' }}
+                  <el-button link type="primary" size="small" @click="openCriteria(row)">
+                    {{ (row.criteria || []).length }} 条
                   </el-button>
+                </template>
+              </el-table-column>
+              <el-table-column label="操作" width="70" align="center">
+                <template #default="{ row }">
                   <el-button link type="danger" size="small" @click="removeStep(row)">删</el-button>
                 </template>
               </el-table-column>
             </el-table>
-
-            <!-- 考核标准编辑 -->
-            <template v-for="row in flowDlg.steps" :key="row._key">
-              <div v-if="row._showCrit" class="crit-box">
-                <b>考核标准：{{ row.name || '(未命名步骤)' }}</b>
-                <el-table :data="row.criteria" border size="small" style="margin-top:8px">
-                  <el-table-column label="指标名" min-width="110">
-                    <template #default="{ row: c }"><el-input v-model="c.name" placeholder="如 扭矩" /></template>
-                  </el-table-column>
-                  <el-table-column label="单位" width="80">
-                    <template #default="{ row: c }"><el-input v-model="c.unit" placeholder="N·m" /></template>
-                  </el-table-column>
-                  <el-table-column label="逻辑" width="120">
-                    <template #default="{ row: c }">
-                      <el-select v-model="c.logic" placeholder="请选择">
-                        <el-option value="GE" label="≥" />
-                        <el-option value="LE" label="≤" />
-                        <el-option value="GT" label=">" />
-                        <el-option value="LT" label="<" />
-                        <el-option value="RANGE" label="区间" />
-                        <el-option value="EQUAL" label="=" />
-                      </el-select>
-                    </template>
-                  </el-table-column>
-                  <el-table-column v-if="cLogicNeedsTarget(row)" label="目标值" width="110">
-                    <template #default="{ row: c }">
-                      <el-input-number v-model="c.target" :step="1" controls-position="right" style="width:100%" />
-                    </template>
-                  </el-table-column>
-                  <el-table-column v-if="editingRanges(row)" label="下限" width="110">
-                    <template #default="{ row: c }">
-                      <el-input-number v-model="c.min" :step="1" controls-position="right" style="width:100%" />
-                    </template>
-                  </el-table-column>
-                  <el-table-column v-if="editingRanges(row)" label="上限" width="110">
-                    <template #default="{ row: c }">
-                      <el-input-number v-model="c.max" :step="1" controls-position="right" style="width:100%" />
-                    </template>
-                  </el-table-column>
-                  <el-table-column label="操作" width="70" align="center">
-                    <template #default="{ row: c }">
-                      <el-button link type="danger" size="small" @click="removeCriterion(row, c)">删</el-button>
-                    </template>
-                  </el-table-column>
-                </el-table>
-                <el-button size="small" style="margin-top:8px" @click="addCriterion(row)">新增标准行</el-button>
-              </div>
-            </template>
-
             <el-button size="small" style="margin-top:10px" @click="addStep">新增步骤</el-button>
           </div>
         </el-form-item>
@@ -227,26 +158,54 @@
       </template>
     </el-dialog>
 
-    <!-- ============ 工位 新增/编辑 ============ -->
-    <el-dialog v-model="stationDlg.show" :title="stationDlg.id ? '编辑工位' : '新增工位'" width="460px">
-      <el-form :model="stationDlg" label-width="90px">
-        <el-form-item label="工位号" required>
-          <el-select v-model="stationDlg.stationNo" style="width:100%">
-            <el-option v-for="i in 12" :key="i" :label="`工位${i}`" :value="i" />
-          </el-select>
-        </el-form-item>
-        <el-form-item label="工位名称" required>
-          <el-input v-model="stationDlg.name" placeholder="如 一号工位" />
-        </el-form-item>
-        <el-form-item label="绑定流程" required>
-          <el-select v-model="stationDlg.flowId" filterable placeholder="请选择工艺流程" style="width:100%">
-            <el-option v-for="f in flowOptions" :key="f.id" :label="f.name" :value="f.id" />
-          </el-select>
-        </el-form-item>
-      </el-form>
+    <!-- ============ 考核标准编辑（每步骤独立弹窗，单独保存） ============ -->
+    <el-dialog v-model="critDlg.show" :title="`考核标准 - ${critDlg.stepName || ''}`" width="720px" top="10vh" append-to-body>
+      <el-alert type="info" :closable="false" style="margin-bottom:12px"
+        title="为「步骤」设置合格判定标准：报工时按此标准自动判定合格/不合格；未设标准则该步骤仅记录、不判定。" />
+      <el-table :data="critDlg.criteria" border size="small">
+        <el-table-column label="指标名" min-width="120">
+          <template #default="{ row }"><el-input v-model="row.name" placeholder="如 扭矩" /></template>
+        </el-table-column>
+        <el-table-column label="单位" width="80">
+          <template #default="{ row }"><el-input v-model="row.unit" placeholder="N·m" /></template>
+        </el-table-column>
+        <el-table-column label="逻辑" width="120">
+          <template #default="{ row }">
+            <el-select v-model="row.logic" placeholder="请选择">
+              <el-option value="GE" label="≥ 大于等于" />
+              <el-option value="LE" label="≤ 小于等于" />
+              <el-option value="GT" label="> 大于" />
+              <el-option value="LT" label="< 小于" />
+              <el-option value="RANGE" label="区间" />
+              <el-option value="EQUAL" label="= 等于" />
+            </el-select>
+          </template>
+        </el-table-column>
+        <el-table-column v-if="needsTarget" label="目标值" width="110">
+          <template #default="{ row }">
+            <el-input-number v-model="row.target" :step="1" controls-position="right" style="width:100%" />
+          </template>
+        </el-table-column>
+        <el-table-column v-if="needsRange" label="下限" width="110">
+          <template #default="{ row }">
+            <el-input-number v-model="row.min" :step="1" controls-position="right" style="width:100%" />
+          </template>
+        </el-table-column>
+        <el-table-column v-if="needsRange" label="上限" width="110">
+          <template #default="{ row }">
+            <el-input-number v-model="row.max" :step="1" controls-position="right" style="width:100%" />
+          </template>
+        </el-table-column>
+        <el-table-column label="操作" width="70" align="center">
+          <template #default="{ row }">
+            <el-button link type="danger" size="small" @click="removeCriterion(row)">删</el-button>
+          </template>
+        </el-table-column>
+      </el-table>
+      <el-button size="small" style="margin-top:10px" @click="addCriterion">新增标准行</el-button>
       <template #footer>
-        <el-button @click="stationDlg.show = false">取消</el-button>
-        <el-button v-if="can('produce.station:edit')" type="primary" @click="saveStation">保存</el-button>
+        <el-button @click="critDlg.show = false">取消</el-button>
+        <el-button type="primary" @click="saveCriteria">确定</el-button>
       </template>
     </el-dialog>
   </el-card>
@@ -254,18 +213,14 @@
 </template>
 
 <script setup>
-import { ref, reactive, onMounted } from 'vue'
+import { ref, reactive, computed, onMounted } from 'vue'
 import PageHelp from '../components/PageHelp.vue'
 import { helpProcessFlow } from '../help'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import request from '../utils/request'
 
-const tab = ref('flows')
 const flows = ref([])
-const stations = ref([])
-const flowOptions = ref([])
-const query = reactive({ processCode: undefined })
-
+const query = reactive({ stationNo: undefined })
 const pdfInput = ref(null)
 
 /* ---------- 权限 ---------- */
@@ -280,6 +235,10 @@ function can(code) {
   }
 }
 
+function statusText(s) {
+  return s === 'ACTIVE' ? '启用' : '停用'
+}
+
 /* ---------- 工艺流程 ---------- */
 function blankStep(seq) {
   return {
@@ -289,14 +248,13 @@ function blankStep(seq) {
     collectType: 'MANUAL',
     isTorque: false,
     remark: '',
-    criteria: [],
-    _showCrit: false
+    criteria: []
   }
 }
 
 async function loadFlows() {
   const params = {}
-  if (query.processCode) params.processCode = query.processCode
+  if (query.stationNo) params.stationNo = query.stationNo
   flows.value = (await request.get('/process-flows', { params })) || []
 }
 
@@ -334,7 +292,7 @@ async function onPdfChange(e) {
 }
 
 const flowDlg = reactive({
-  show: false, id: 0, name: '', processCode: 1, pdfFile: '', status: 'ACTIVE',
+  show: false, id: 0, name: '', stationNo: 1, pdfFile: '', status: 'ACTIVE',
   remark: '', uploading: false, steps: []
 })
 
@@ -342,7 +300,7 @@ function openFlow(row) {
   if (row) {
     flowDlg.id = row.id
     flowDlg.name = row.name || ''
-    flowDlg.processCode = row.processCode
+    flowDlg.stationNo = row.stationNo || 1
     flowDlg.pdfFile = row.pdfFile || ''
     flowDlg.status = row.status || 'ACTIVE'
     flowDlg.remark = row.remark || ''
@@ -353,12 +311,11 @@ function openFlow(row) {
       collectType: s.collectType || 'MANUAL',
       isTorque: !!s.isTorque,
       remark: s.remark || '',
-      criteria: (s.criteria || []).map((c) => ({ ...c })),
-      _showCrit: false
+      criteria: (s.criteria || []).map((c) => ({ ...c }))
     }))
   } else {
     Object.assign(flowDlg, {
-      id: 0, name: '', processCode: 1, pdfFile: '', status: 'ACTIVE', remark: '', steps: []
+      id: 0, name: '', stationNo: 1, pdfFile: '', status: 'ACTIVE', remark: '', steps: []
     })
   }
   if (!flowDlg.steps.length) flowDlg.steps.push(blankStep(1))
@@ -373,31 +330,46 @@ function removeStep(row) {
   const i = flowDlg.steps.indexOf(row)
   if (i >= 0) flowDlg.steps.splice(i, 1)
 }
-function addCriterion(row) {
-  row.criteria.push({ name: '', unit: '', logic: 'GE', target: null, min: null, max: null })
+
+/* ---------- 考核标准（独立弹窗） ---------- */
+const critDlg = reactive({ show: false, stepName: '', criteria: [], _step: null })
+
+const needsTarget = computed(() => critDlg.criteria.some((c) => c.logic && c.logic !== 'RANGE'))
+const needsRange = computed(() => critDlg.criteria.some((c) => c.logic === 'RANGE'))
+
+function openCriteria(step) {
+  critDlg._step = step
+  critDlg.stepName = step.name || '(未命名步骤)'
+  critDlg.criteria = (step.criteria || []).map((c) => ({ ...c }))
+  critDlg.show = true
 }
-function removeCriterion(row, c) {
-  const i = row.criteria.indexOf(c)
-  if (i >= 0) row.criteria.splice(i, 1)
+function addCriterion() {
+  critDlg.criteria.push({ name: '', unit: '', logic: 'GE', target: null, min: null, max: null })
 }
-function cLogicNeedsTarget(row) {
-  return row.criteria.some((c) => c.logic && c.logic !== 'RANGE')
+function removeCriterion(c) {
+  const i = critDlg.criteria.indexOf(c)
+  if (i >= 0) critDlg.criteria.splice(i, 1)
 }
-function editingRanges(row) {
-  return row.criteria.some((c) => c.logic === 'RANGE')
+function saveCriteria() {
+  if (critDlg._step) {
+    critDlg._step.criteria = critDlg.criteria
+      .filter((c) => c.name)
+      .map((c) => ({ ...c }))
+  }
+  critDlg.show = false
 }
 
 async function saveFlow() {
   if (!flowDlg.name) return ElMessage.warning('请填写流程名')
-  if (!flowDlg.processCode) return ElMessage.warning('请选择工序编号')
+  if (!flowDlg.stationNo) return ElMessage.warning('请选择工位号（1~12）')
   const body = {
     id: flowDlg.id || undefined,
     name: flowDlg.name,
-    processCode: flowDlg.processCode,
+    stationNo: flowDlg.stationNo,
     pdfFile: flowDlg.pdfFile,
     status: flowDlg.status,
     remark: flowDlg.remark,
-    steps: flowDlg.steps.map(({ _key, _showCrit, ...st }) => ({
+    steps: flowDlg.steps.map(({ _key, ...st }) => ({
       seq: st.seq,
       name: st.name,
       collectType: st.collectType,
@@ -419,61 +391,26 @@ async function delFlow(row) {
   loadFlows()
 }
 
-/* ---------- 工位管理 ---------- */
-async function loadStations() {
-  stations.value = (await request.get('/stations')) || []
-}
-async function loadFlowOptions() {
-  const list = (await request.get('/process-flows', { params: {} })) || []
-  flowOptions.value = list.map((f) => ({ id: f.id, name: f.name }))
-}
-
-const stationDlg = reactive({ show: false, id: 0, stationNo: 1, name: '', flowId: null })
-
-function openStation(row) {
-  if (row) {
-    Object.assign(stationDlg, {
-      show: true, id: row.id, stationNo: row.stationNo, name: row.name || '', flowId: row.flowId || null
-    })
+async function toggleStatus(row) {
+  const toStatus = row.status === 'ACTIVE' ? 'INACTIVE' : 'ACTIVE'
+  const action = toStatus === 'INACTIVE' ? '停用' : '启用'
+  if (toStatus === 'INACTIVE') {
+    await ElMessageBox.confirm(
+      `确认停用「${row.name}」？停用后将自动解除工位${row.stationNo || ''}的绑定，且该流程不可再被工位使用。`,
+      '提示', { type: 'warning' })
   } else {
-    Object.assign(stationDlg, { show: true, id: 0, stationNo: 1, name: '', flowId: null })
+    await ElMessageBox.confirm(
+      `确认启用「${row.name}」？启用后将自动绑定到工位${row.stationNo || ''}（该工位若有其他启用流程需先停用）。`,
+      '提示', { type: 'warning' })
   }
-}
-
-async function saveStation() {
-  if (!stationDlg.stationNo) return ElMessage.warning('请选择工位号')
-  if (!stationDlg.name) return ElMessage.warning('请填写工位名称')
-  if (!stationDlg.flowId) return ElMessage.warning('请选择绑定流程')
-  const body = {
-    id: stationDlg.id || undefined,
-    stationNo: stationDlg.stationNo,
-    name: stationDlg.name,
-    flowId: stationDlg.flowId
-  }
-  await request.post('/stations', body)
-  ElMessage.success('保存成功')
-  stationDlg.show = false
-  loadStations()
-}
-
-function onTabChange(name) {
-  if (name === 'stations') {
-    loadStations()
-    loadFlowOptions()
-  }
-}
-
-onMounted(() => {
+  await request.post('/process-flows/status', { id: row.id, status: toStatus })
+  ElMessage.success(`已${action}`)
   loadFlows()
-  loadStations()
-  loadFlowOptions()
-})
+}
+
+onMounted(loadFlows)
 </script>
 
 <style scoped>
 .pdf-name { margin-left: 10px; color: #606266; font-size: 13px; }
-.crit-box {
-  border: 1px solid #ebeef5; border-radius: 6px; padding: 10px; margin: 8px 0;
-  background: #fafbfc;
-}
 </style>
diff --git a/bj_power_mes/frontend/src/pages/ProcessStep.vue b/bj_power_mes/frontend/src/pages/ProcessStep.vue
deleted file mode 100644
index 916aac9..0000000
--- a/bj_power_mes/frontend/src/pages/ProcessStep.vue
+++ /dev/null
@@ -1,141 +0,0 @@
-<template>
-  <el-card>
-    <el-form inline>
-      <el-form-item label="工序号">
-        <el-select v-model="processCode" placeholder="请选择工序" style="width:140px">
-          <el-option v-for="i in 12" :key="i" :value="i" :label="`工序${i}`" />
-        </el-select>
-      </el-form-item>
-      <el-form-item><el-button type="primary" @click="load">加载</el-button></el-form-item>
-      <el-form-item><el-button v-if="can('produce.processflow:edit')" type="success" @click="save">保存该工序参数</el-button></el-form-item>
-    </el-form>
-
-    <el-alert type="info" :closable="false"
-      title="为每道工序配置【步骤/参数】与【判定标准】，手动报工页会按此动态渲染采集框；标准可为空=仅记录不判定"
-      style="margin-bottom:12px" />
-
-    <el-table :data="steps" border size="small">
-      <el-table-column prop="seq" label="步骤" width="70" align="center">
-        <template #default="{ row }"><el-input-number v-model="row.seq" :min="1" size="small" controls-position="right" style="width:80px" /></template>
-      </el-table-column>
-      <el-table-column label="步骤名称" min-width="150">
-        <template #default="{ row }"><el-input v-model="row.name" placeholder="如 拧紧扭矩" /></template>
-      </el-table-column>
-      <el-table-column label="采集方式" width="140">
-        <template #default="{ row }">
-          <el-select v-model="row.collectType" placeholder="请选择">
-            <el-option value="AUTO" label="拧紧枪自动" />
-            <el-option value="MANUAL" label="手填" />
-            <el-option value="NONE" label="仅记录" />
-          </el-select>
-        </template>
-      </el-table-column>
-      <el-table-column label="是否拧紧" width="90" align="center">
-        <template #default="{ row }"><el-switch v-model="row.isTorque" /></template>
-      </el-table-column>
-      <el-table-column label="备注" min-width="140">
-        <template #default="{ row }"><el-input v-model="row.remark" placeholder="备注(可空)" /></template>
-      </el-table-column>
-      <el-table-column label="操作" width="110" align="center">
-        <template #default="{ row }">
-          <el-button link type="primary" size="small" @click="addCriterion(row)">加标准</el-button>
-          <el-button link type="danger" size="small" @click="remove(row)">删</el-button>
-        </template>
-      </el-table-column>
-    </el-table>
-
-    <!-- 编辑判定标准 -->
-    <template v-for="row in steps" :key="row.id + '-' + row.seq">
-      <div v-if="row._showCrit" style="border:1px solid #ebeef5;border-radius:6px;padding:10px;margin:8px 0">
-        <b>标准：{{ row.name }}</b>
-        <el-table :data="row.criteria" border size="small" style="margin-top:8px">
-          <el-table-column label="指标名" min-width="120">
-            <template #default="{ row: c }"><el-input v-model="c.name" placeholder="如 扭矩" /></template>
-          </el-table-column>
-          <el-table-column label="单位" width="80">
-            <template #default="{ row: c }"><el-input v-model="c.unit" placeholder="N·m" /></template>
-          </el-table-column>
-          <el-table-column label="逻辑" width="120">
-            <template #default="{ row: c }">
-              <el-select v-model="c.logic" placeholder="请选择">
-                <el-option value="GE" label="≥" />
-                <el-option value="LE" label="≤" />
-                <el-option value="GT" label=">" />
-                <el-option value="LT" label="<" />
-                <el-option value="RANGE" label="区间" />
-                <el-option value="EQUAL" label="=" />
-              </el-select>
-            </template>
-          </el-table-column>
-          <el-table-column v-if="cLogicNeedsTarget(row)" label="目标值" width="110">
-            <template #default="{ row: c }"><el-input-number v-model="c.target" :step="1" controls-position="right" style="width:100%" /></template>
-          </el-table-column>
-          <el-table-column v-if="editingRanges(row)" label="下限" width="110">
-            <template #default="{ row: c }"><el-input-number v-model="c.min" :step="1" controls-position="right" style="width:100%" /></template>
-          </el-table-column>
-          <el-table-column v-if="editingRanges(row)" label="上限" width="110">
-            <template #default="{ row: c }"><el-input-number v-model="c.max" :step="1" controls-position="right" style="width:100%" /></template>
-          </el-table-column>
-          <el-table-column label="操作" width="80" align="center">
-            <template #default="{ row: c }"><el-button link type="danger" size="small" @click="removeCriterion(row, c)">删</el-button></template>
-          </el-table-column>
-        </el-table>
-        <el-button size="small" style="margin-top:8px" @click="row.criteria.push({ name: '', unit: '', logic: 'GE', target: 0, min: null, max: null })">新增标准行</el-button>
-      </div>
-    </template>
-
-    <div style="margin:12px 0">
-      <el-button v-if="can('produce.processflow:edit')" @click="addStep">新增步骤</el-button>
-    </div>
-  </el-card>
-  <PageHelp :data="helpProcessStep" />
-</template>
-
-<script setup>
-import { reactive, ref, onMounted } from 'vue'
-import { ElMessage } from 'element-plus'
-import request from '../utils/request'
-import { can } from '../utils/perm'
-import PageHelp from '../components/PageHelp.vue'
-import { helpProcessStep } from '../help'
-
-const processCode = ref(1)
-const steps = ref([])
-
-function blankStep() {
-  return { id: 0, processCode: processCode.value, seq: steps.value.length + 1, name: '', collectType: 'MANUAL', isTorque: false, remark: '', criteria: [], _showCrit: false }
-}
-function addStep() { steps.value.push(blankStep()) }
-function addCriterion(row) {
-  row._showCrit = !row._showCrit
-}
-function remove(row) {
-  const i = steps.value.indexOf(row)
-  if (i >= 0) steps.value.splice(i, 1)
-}
-function cLogicNeedsTarget(row) {
-  return row.criteria.some(c => c.logic && c.logic !== 'RANGE')
-}
-function editingRanges(row) {
-  return row.criteria.some(c => c.logic === 'RANGE')
-}
-function removeCriterion(row, c) {
-  const i = row.criteria.indexOf(c)
-  if (i >= 0) row.criteria.splice(i, 1)
-}
-
-async function load() {
-  try {
-    const data = await request.get('/process-steps', { params: { processCode: processCode.value } }) || []
-    steps.value = data.map(s => ({ ...s, criteria: s.criteria || [], _showCrit: false }))
-    if (!steps.value.length) steps.value.push(blankStep())
-  } catch { steps.value = [blankStep()] }
-}
-async function save() {
-  const body = steps.value.map(({ _showCrit, ...st }) => st)
-  await request.post('/process-steps', body)
-  ElMessage.success('工艺参数已保存')
-  load()
-}
-onMounted(load)
-</script>
\ No newline at end of file
diff --git a/bj_power_mes/frontend/src/pages/Scan.vue b/bj_power_mes/frontend/src/pages/Scan.vue
index 00a476b..7899c20 100644
--- a/bj_power_mes/frontend/src/pages/Scan.vue
+++ b/bj_power_mes/frontend/src/pages/Scan.vue
@@ -2,19 +2,18 @@
   <el-card>
     <el-form inline>
       <el-form-item label="工位">
-        <el-select v-model="form.stationNo" placeholder="请选择工位" style="width:110px">
+        <el-select v-model="form.stationNo" placeholder="请选择工位" style="width:120px" @change="loadSteps">
           <el-option v-for="i in 12" :key="i" :value="i" :label="`工位${i}`" />
         </el-select>
       </el-form-item>
-      <el-form-item label="工件SN"><el-input v-model="form.sn" style="width:170px" @change="loadSteps" /></el-form-item>
-      <el-form-item label="工序号"><el-input-number v-model="form.processCode" :min="1" :max="12" @change="loadSteps" /></el-form-item>
-      <el-form-item><el-button type="primary" @click="loadSteps">载入参数模板</el-button></el-form-item>
+      <el-form-item label="工件SN"><el-input v-model="form.sn" placeholder="扫码或手输" style="width:190px" @change="loadSteps" /></el-form-item>
+      <el-form-item><el-button type="primary" @click="loadSteps">载入工序步骤</el-button></el-form-item>
     </el-form>
 
-    <!-- 参数采集区：按已维护的步骤模板动态渲染 -->
+    <!-- 参数采集区：按该工位启用工艺流程的工序步骤动态渲染 -->
     <el-card v-if="steps.length" shadow="never" style="margin-bottom:12px">
       <div slot="header" style="display:flex;justify-content:space-between;align-items:center">
-        <b>工位 {{ form.stationNo }} / 工序 {{ form.processCode }} 参数采集</b>
+        <b>工位 {{ form.stationNo }} 参数采集{{ flowName ? '（' + flowName + '）' : '' }}</b>
         <el-button v-if="can('produce.scan')" type="primary" size="small" :loading="saving" @click="submit">提交报工</el-button>
       </div>
       <el-table :data="steps" border size="small">
@@ -45,7 +44,7 @@
         </el-table-column>
       </el-table>
     </el-card>
-    <el-alert v-else type="info" :closable="false" title="请选择工位、SN 与工序号后点【载入参数模板】" />
+    <el-alert v-else type="info" :closable="false" title="请选择工位、输入SN后点【载入工序步骤】；若提示未配置工序步骤，请到「工艺流程」为该工位启用流程并维护工序步骤" />
 
     <el-divider content-position="left">报工记录</el-divider>
     <el-form inline>
@@ -58,7 +57,7 @@
       <el-table-column prop="orderNo" label="工单号" min-width="130" />
       <el-table-column prop="station" label="工位" width="80" />
       <el-table-column prop="type" label="类型" width="110" />
-      <el-table-column prop="processCode" label="工序号" width="80" />
+      <el-table-column prop="processCode" label="工位号" width="80" />
       <el-table-column prop="operator" label="操作人" width="90" />
       <el-table-column prop="time" label="时间" min-width="170" />
     </el-table>
@@ -74,8 +73,9 @@ import { can } from '../utils/perm'
 import PageHelp from '../components/PageHelp.vue'
 import { helpScan } from '../help'
 
-const form = reactive({ stationNo: 1, sn: '', processCode: 1 })
+const form = reactive({ stationNo: 1, sn: '' })
 const steps = ref([])
+const flowName = ref('')
 const saving = ref(false)
 const query = reactive({ sn: '', orderNo: '' })
 const list = ref([])
@@ -92,19 +92,22 @@ function critText(c) {
   }
 }
 
-// 从后端步骤模板构造报工所需字段（value 挂在 row 上，提交时收集）
+// 从后端加载该工位启用工艺流程的工序步骤（value 挂在 row 上，提交时收集）
 async function loadSteps() {
   if (!form.sn) return ElMessage.warning('请先输入工件SN')
-  if (!form.processCode) return ElMessage.warning('请选择工序号')
   try {
-    const data = await request.get('/process-steps', { params: { processCode: form.processCode } }) || []
+    const data = await request.get('/process-steps', { params: { stationNo: form.stationNo } }) || []
     steps.value = data.map(s => ({ ...s, value: '', text: '' }))
+    flowName.value = ''
+    if (!steps.value.length) {
+      ElMessage.warning(`工位${form.stationNo} 未配置启用的工艺流程，请到「工艺流程」维护`)
+    }
   } catch { steps.value = [] }
 }
 
 async function submit() {
   if (!form.sn) return ElMessage.warning('请输入SN')
-  if (!form.processCode) return ElMessage.warning('请选择工序号')
+  if (!steps.value.length) return ElMessage.warning('该工位未配置工序步骤，无法报工')
   const stepReq = steps.value
     .filter(s => s.collectType !== 'NONE' && (s.text !== '' || s.value !== ''))
     .map(s => ({
@@ -113,10 +116,10 @@ async function submit() {
       value: Number(s.value) || 0,
       text: s.text || String(s.value || '')
     }))
-  // 手动报工走工序实绩 + 步骤考核
+  // 手动报工：processCode = 工位号（工位 1~12 固定）
   await request.post('/workpiece/process/report', {
     sn: form.sn,
-    processCode: form.processCode,
+    processCode: form.stationNo,
     stationNo: form.stationNo,
     steps: stepReq
   })
@@ -130,4 +133,4 @@ async function load() {
   list.value = (await request.get('/scan/records', { params: query })) || []
 }
 onMounted(load)
-</script>
\ No newline at end of file
+</script>
diff --git a/bj_power_mes/frontend/src/pages/Station.vue b/bj_power_mes/frontend/src/pages/Station.vue
new file mode 100644
index 0000000..a0828af
--- /dev/null
+++ b/bj_power_mes/frontend/src/pages/Station.vue
@@ -0,0 +1,84 @@
+<template>
+  <el-card>
+    <el-alert type="info" :closable="false" style="margin-bottom:12px"
+      title="产线固定 12 个工位，本页为工位总览（不增删工位）。每个工位的工艺流程在「工艺流程」页维护：工艺流程选工位号并启用后，即自动绑定到该工位；一个工位只能有一个启用的工艺流程。" />
+
+    <el-table :data="rows" border size="small">
+      <el-table-column prop="stationNo" label="工位号" width="90" align="center" />
+      <el-table-column prop="name" label="工位名称" min-width="170" show-overflow-tooltip />
+      <el-table-column label="绑定工艺流程" min-width="220" show-overflow-tooltip>
+        <template #default="{ row }">
+          <span v-if="row.flowName">{{ row.flowName }}</span>
+          <span v-else style="color:#909399">未绑定（请在「工艺流程」页为该工位启用流程）</span>
+        </template>
+      </el-table-column>
+      <el-table-column label="操作" width="120" align="center" fixed="right">
+        <template #default="{ row }">
+          <el-button v-if="can('produce.station:edit')" size="small" @click="openName(row)">改名</el-button>
+        </template>
+      </el-table-column>
+    </el-table>
+
+    <el-dialog v-model="dlg.show" :title="`工位${dlg.stationNo} - 修改名称`" width="420px">
+      <el-form :model="dlg" label-width="90px">
+        <el-form-item label="工位名称" required>
+          <el-input v-model="dlg.name" placeholder="如 一号装配工位" />
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <el-button @click="dlg.show = false">取消</el-button>
+        <el-button v-if="can('produce.station:edit')" type="primary" @click="save">保存</el-button>
+      </template>
+    </el-dialog>
+  </el-card>
+  <PageHelp :data="helpStation" />
+</template>
+
+<script setup>
+import { reactive, ref, computed, onMounted } from 'vue'
+import { ElMessage } from 'element-plus'
+import request from '../utils/request'
+import { can } from '../utils/perm'
+import PageHelp from '../components/PageHelp.vue'
+import { helpStation } from '../help'
+
+const stations = ref([])
+
+const rows = computed(() => {
+  const map = {}
+  stations.value.forEach((s) => { map[s.stationNo] = s })
+  const out = []
+  for (let i = 1; i <= 12; i++) {
+    const s = map[i]
+    out.push({
+      stationNo: i,
+      name: s ? s.name : `工位${i}`,
+      flowName: s ? s.flowName : '',
+      flowId: s ? s.flowId : 0
+    })
+  }
+  return out
+})
+
+const dlg = reactive({ show: false, id: 0, stationNo: 1, name: '' })
+
+async function load() {
+  stations.value = (await request.get('/stations')) || []
+}
+
+function openName(row) {
+  Object.assign(dlg, { show: true, id: row.id, stationNo: row.stationNo, name: row.name })
+}
+
+async function save() {
+  if (!dlg.name) return ElMessage.warning('请输入工位名称')
+  await request.post('/stations', {
+    id: dlg.id, stationNo: dlg.stationNo, name: dlg.name
+  })
+  ElMessage.success('已保存')
+  dlg.show = false
+  load()
+}
+
+onMounted(load)
+</script>
diff --git a/bj_power_mes/frontend/src/pages/Trace.vue b/bj_power_mes/frontend/src/pages/Trace.vue
index 0714783..f6fa5e6 100644
--- a/bj_power_mes/frontend/src/pages/Trace.vue
+++ b/bj_power_mes/frontend/src/pages/Trace.vue
@@ -17,18 +17,18 @@
         <el-descriptions-item label="SN">{{ data.workpiece?.sn }}</el-descriptions-item>
         <el-descriptions-item label="工单号">{{ data.workpiece?.orderNo }}</el-descriptions-item>
         <el-descriptions-item label="状态">{{ data.workpiece?.status }}</el-descriptions-item>
-        <el-descriptions-item label="当前工序">{{ data.workpiece?.currentProcess }}</el-descriptions-item>
+        <el-descriptions-item label="当前工位">{{ data.workpiece?.currentProcess }}</el-descriptions-item>
         <el-descriptions-item label="进线时间">{{ fmt(data.workpiece?.onlineAt) }}</el-descriptions-item>
         <el-descriptions-item label="完工时间">{{ fmt(data.workpiece?.doneAt) }}</el-descriptions-item>
       </el-descriptions>
 
       <el-tabs>
-        <el-tab-pane label="工序时间线">
+        <el-tab-pane label="工位时间线">
           <el-timeline>
             <el-timeline-item v-for="p in (data.processTimeline||[])" :key="p.id"
               :timestamp="p.operator ? (p.operator+' · '+fmt(p.endedAt)) : fmt(p.endedAt)"
               :type="p.result==='NG'?'danger':'success'">
-              {{ p.processName }}（工序 {{ p.processCode }}，工位 {{ p.stationNo }}）— {{ p.result }}
+              {{ p.processName }}（工位 {{ p.stationNo || p.processCode }}）— {{ p.result }}
             </el-timeline-item>
           </el-timeline>
         </el-tab-pane>
diff --git a/bj_power_mes/frontend/src/pages/WorkOrder.vue b/bj_power_mes/frontend/src/pages/WorkOrder.vue
index b49bd36..469d6f7 100644
--- a/bj_power_mes/frontend/src/pages/WorkOrder.vue
+++ b/bj_power_mes/frontend/src/pages/WorkOrder.vue
@@ -3,7 +3,13 @@
     <el-card>
       <el-form inline>
         <el-form-item label="工单号">
-          <el-input v-model="query.orderNo" placeholder="模糊查询" clearable style="width:180px" @keyup.enter="load" />
+          <el-input v-model="query.orderNo" placeholder="模糊查询" clearable style="width:160px" @keyup.enter="load" />
+        </el-form-item>
+        <el-form-item label="产品编码">
+          <el-input v-model="query.productCode" placeholder="模糊查询" clearable style="width:160px" @keyup.enter="load" />
+        </el-form-item>
+        <el-form-item label="产品名称">
+          <el-input v-model="query.productName" placeholder="模糊查询" clearable style="width:160px" @keyup.enter="load" />
         </el-form-item>
         <el-form-item label="状态">
           <el-select v-model="query.status" clearable placeholder="请选择状态" style="width:150px">
@@ -23,33 +29,47 @@
         <el-table-column prop="productName" label="产品名称" min-width="120" />
         <el-table-column prop="quantity" label="数量" width="70" />
         <el-table-column prop="finishedNum" label="已完工" width="70" />
-        <el-table-column prop="processSeq" label="工序组合" width="120" />
+        <el-table-column label="工位组合" min-width="170" show-overflow-tooltip>
+          <template #default="{ row }">{{ seqText(row.processSeq) }}</template>
+        </el-table-column>
         <el-table-column prop="status" label="状态" width="100">
           <template #default="{ row }">{{ statusText(row.status) }}</template>
         </el-table-column>
-        <el-table-column label="操作" width="230" fixed="right">
+        <el-table-column label="操作" width="320" fixed="right">
           <template #default="{ row }">
-            <el-button v-if="can('produce.workorder:dailyplan')" size="small" @click="openDaily(row)">日排产</el-button>
-            <el-button v-if="can('produce.workorder:edit')" size="small" type="primary" plain @click="openSeq(row)">工序组合</el-button>
+            <el-button v-if="can('produce.workorder:edit')" size="small" type="primary" plain @click="openSeq(row)">工位组合</el-button>
             <el-button v-if="can('produce.workorder:edit')" size="small" type="warning" @click="openEdit(row)">编辑</el-button>
+            <el-dropdown
+              v-if="can('produce.workorder:edit') && statusActions(row.status).length"
+              trigger="click" @command="(cmd) => changeStatus(row, cmd)">
+              <el-button size="small">状态 ▾</el-button>
+              <template #dropdown>
+                <el-dropdown-menu>
+                  <el-dropdown-item v-for="a in statusActions(row.status)" :key="a.v" :command="a.v">{{ a.l }}</el-dropdown-item>
+                </el-dropdown-menu>
+              </template>
+            </el-dropdown>
+            <el-button v-if="can('produce.workorder:delete')" size="small" type="danger" @click="del(row)">删除</el-button>
           </template>
         </el-table-column>
       </el-table>
     </el-card>
 
     <!-- 新建/编辑工单 -->
-    <el-dialog v-model="dialog.show" :title="dialog.id ? '编辑工单' : '新建工单'" width="520px">
+    <el-dialog v-model="dialog.show" :title="dialog.id ? '编辑工单' : '新建工单'" width="560px">
       <el-form :model="dialog" label-width="90px">
         <el-form-item label="工单号"><el-input v-model="dialog.workOrderNo" /></el-form-item>
         <el-form-item label="产品类型">
-          <el-select v-model="dialog.productTypeId" placeholder="选择产品类型" style="width:100%">
-            <el-option v-for="p in productTypes" :key="p.id" :label="p.name + (p.code? ' / '+p.code:'')" :value="p.id" />
+          <el-select v-model="dialog.productTypeId" placeholder="请选择产品类型" style="width:100%">
+            <el-option v-for="p in productTypes" :key="p.id" :label="p.name + (p.code ? ' / ' + p.code : '')" :value="p.id" />
           </el-select>
         </el-form-item>
-        <el-form-item label="产品编码"><el-input v-model="dialog.productCode" /></el-form-item>
-        <el-form-item label="产品名称"><el-input v-model="dialog.productName" /></el-form-item>
+        <el-form-item label="产品编码"><el-input v-model="dialog.productCode" placeholder="请输入产品编码" /></el-form-item>
+        <el-form-item label="产品名称"><el-input v-model="dialog.productName" placeholder="请输入产品名称" /></el-form-item>
         <el-form-item label="数量"><el-input-number v-model="dialog.quantity" :min="1" /></el-form-item>
-        <el-form-item label="工序组合"><el-input v-model="dialog.processSeq" placeholder="如 135" /></el-form-item>
+        <el-form-item label="工位组合">
+          <ProcessSeqPicker :model-value="dialog.processSeq" @update:model-value="dialog.processSeq = $event" />
+        </el-form-item>
         <el-form-item label="状态">
           <el-select v-model="dialog.status" placeholder="请选择状态" style="width:100%">
             <el-option v-for="s in statusOptions" :key="s.v" :label="s.l" :value="s.v" />
@@ -62,46 +82,17 @@
       </template>
     </el-dialog>
 
-    <!-- 日排产 -->
-    <el-dialog v-model="plan.show" title="日排产" width="720px">
-      <el-form inline style="margin-bottom:10px">
-        <el-form-item label="日期">
-          <el-date-picker v-model="plan.date" type="date" value-format="YYYY-MM-DD" />
-        </el-form-item>
-        <el-form-item label="计划数量">
-          <el-input-number v-model="plan.qty" :min="1" />
-        </el-form-item>
-        <el-form-item>
-          <el-button v-if="can('produce.workorder:dailyplan')" type="primary" @click="savePlan">保存排产</el-button>
-          <el-button @click="loadPlans">刷新</el-button>
-        </el-form-item>
-      </el-form>
-      <el-table :data="planList" border size="small">
-        <el-table-column prop="planDate" label="日期" width="120" />
-        <el-table-column prop="planQty" label="计划数量" width="100" />
-        <el-table-column prop="completedQty" label="已完成" />
-        <el-table-column label="状态">
-          <template #default="{ row }">{{ statusText(row.status) }}</template>
-        </el-table-column>
-        <el-table-column prop="operator" label="操作人" />
-      </el-table>
-    </el-dialog>
-
-    <!-- 工序组合维护 -->
-    <el-dialog v-model="seq.show" :title="`维护工序组合 - ${seq.orderNo}`" width="520px">
+    <!-- 工位组合维护 -->
+    <el-dialog v-model="seq.show" :title="`维护工位组合 - ${seq.orderNo}`" width="600px">
       <el-alert type="info" :closable="false"
-        title="人工自由维护本工单执行的工序组合（如只做第1/3/5序可填135；半成品再上线补做第2序填2）。PLC 会按此组合下发。"
+        title="勾选本工单要经过的工位（按工位号 1→12 顺序执行，传送带不回走）。半成品再上线可只勾漏做的工位完成闭环。"
         style="margin-bottom:14px" />
       <el-form label-width="90px">
         <el-form-item label="工单号"><el-input :model-value="seq.orderNo" disabled /></el-form-item>
-        <el-form-item label="产品编码">
-          <el-input :model-value="seq.productCode" disabled />
-        </el-form-item>
-        <el-form-item label="产品名称">
-          <el-input :model-value="seq.productName" disabled />
-        </el-form-item>
-        <el-form-item label="工序组合">
-          <el-input v-model="seq.processSeq" placeholder="如 135；全序=123456789101112" />
+        <el-form-item label="产品编码"><el-input :model-value="seq.productCode" disabled /></el-form-item>
+        <el-form-item label="产品名称"><el-input :model-value="seq.productName" disabled /></el-form-item>
+        <el-form-item label="工位组合">
+          <ProcessSeqPicker :model-value="seq.processSeq" @update:model-value="seq.processSeq = $event" />
         </el-form-item>
       </el-form>
       <template #footer>
@@ -115,10 +106,11 @@
 
 <script setup>
 import { ref, reactive, onMounted } from 'vue'
-import { ElMessage } from 'element-plus'
+import { ElMessage, ElMessageBox } from 'element-plus'
 import request from '../utils/request'
 import { can } from '../utils/perm'
 import PageHelp from '../components/PageHelp.vue'
+import ProcessSeqPicker from '../components/ProcessSeqPicker.vue'
 import { helpWorkOrder } from '../help'
 
 const statusOptions = [
@@ -128,13 +120,41 @@ const statusOptions = [
 ]
 const statusText = (s) => (statusOptions.find((x) => x.v === s) || {}).l || s
 
-const query = reactive({ orderNo: '', status: '' })
+// 状态流转：给出当前状态可执行的下一个动作
+function statusActions(status) {
+  const map = {
+    CREATED: [{ v: 'RELEASED', l: '发布' }],
+    PENDING: [{ v: 'RELEASED', l: '发布' }],
+    RELEASED: [{ v: 'IN_PROGRESS', l: '开工' }],
+    IN_PROGRESS: [{ v: 'DONE', l: '完工' }]
+  }
+  return map[status] || []
+}
+
+function seqToCodes(s) {
+  if (!s) return []
+  const out = []
+  String(s).split(',').forEach((p) => {
+    const n = Number(p)
+    if (n >= 1 && n <= 12 && !out.includes(n)) out.push(n)
+  })
+  return out.sort((a, b) => a - b)
+}
+function codesToSeq(codes) {
+  return [...codes].sort((a, b) => a - b).join(',')
+}
+function seqText(s) {
+  const codes = seqToCodes(s)
+  if (!codes.length) return '-'
+  if (codes.length === 12) return '全部工位'
+  return codes.map((c) => `工位${c}`).join('、')
+}
+
+const query = reactive({ orderNo: '', productCode: '', productName: '', status: '' })
 const list = ref([])
 const productTypes = ref([])
 
 const dialog = reactive({ show: false, id: 0, workOrderNo: '', productTypeId: 0, productCode: '', productName: '', quantity: 1, processSeq: '', status: 'CREATED' })
-const plan = reactive({ show: false, orderNo: '', date: '', qty: 1 })
-const planList = ref([])
 const seq = reactive({ show: false, id: 0, orderNo: '', productCode: '', productName: '', processSeq: '' })
 
 async function load() {
@@ -145,10 +165,10 @@ async function loadProducts() {
   productTypes.value = (await request.get('/product-types')) || []
 }
 function openCreate() {
-  Object.assign(dialog, { show: true, id: 0, workOrderNo: `WO${Date.now()}`, productTypeId: 0, productCode: '', productName: '', quantity: 1, processSeq: '123456789101112', status: 'CREATED' })
+  Object.assign(dialog, { show: true, id: 0, workOrderNo: `WO${Date.now()}`, productTypeId: 0, productCode: '', productName: '', quantity: 1, processSeq: '1,2,3,4,5,6,7,8,9,10,11,12', status: 'CREATED' })
 }
 function openEdit(row) {
-  Object.assign(dialog, { show: true, id: row.id, workOrderNo: row.workOrderNo, productTypeId: row.productTypeId, productCode: row.productCode, productName: row.productName, quantity: row.quantity, processSeq: row.processSeq, status: row.status })
+  Object.assign(dialog, { show: true, id: row.id, workOrderNo: row.workOrderNo, productTypeId: row.productTypeId, productCode: row.productCode, productName: row.productName, quantity: row.quantity, processSeq: row.processSeq || '1,2,3,4,5,6,7,8,9,10,11,12', status: row.status })
 }
 async function save() {
   const body = { id: dialog.id, workOrderNo: dialog.workOrderNo, productTypeId: dialog.productTypeId, productCode: dialog.productCode, productName: dialog.productName, quantity: dialog.quantity, processSeq: dialog.processSeq, status: dialog.status }
@@ -158,40 +178,43 @@ async function save() {
   dialog.show = false
   load()
 }
-function openDaily(row) {
-  plan.orderNo = row.workOrderNo
-  plan.date = new Date().toISOString().slice(0, 10)
-  plan.qty = row.quantity
-  plan.show = true
-  loadPlans()
-}
 
 function openSeq(row) {
   Object.assign(seq, {
     show: true, id: row.id, orderNo: row.workOrderNo,
     productCode: row.productCode, productName: row.productName,
-    processSeq: row.processSeq || ''
+    processSeq: row.processSeq || '1,2,3,4,5,6,7,8,9,10,11,12'
   })
 }
 
 async function saveSeq() {
-  if (!seq.processSeq) return ElMessage.warning('工序组合不能为空')
+  const codes = seqToCodes(seq.processSeq)
+  if (!codes.length) return ElMessage.warning('请至少勾选一个工位')
   await request.put('/work-orders', {
     id: seq.id, workOrderNo: seq.orderNo, productCode: seq.productCode,
-    productName: seq.productName, processSeq: seq.processSeq
+    productName: seq.productName, processSeq: codesToSeq(codes)
   })
-  ElMessage.success('工序组合已保存')
+  ElMessage.success('工位组合已保存')
   seq.show = false
   load()
 }
-async function loadPlans() {
-  planList.value = (await request.get('/daily-plans', { params: { orderNo: plan.orderNo } })) || []
+
+async function changeStatus(row, status) {
+  const label = statusText(status)
+  await ElMessageBox.confirm(`确认将工单「${row.workOrderNo}」状态改为「${label}」？`, '提示', { type: 'warning' })
+  await request.post('/work-orders/status', { id: row.id, status })
+  ElMessage.success('状态已更新')
+  load()
 }
-async function savePlan() {
-  await request.post('/daily-plans', { orderNo: plan.orderNo, planDate: plan.date, planQty: plan.qty })
-  ElMessage.success('排产保存成功')
-  loadPlans()
+
+async function del(row) {
+  await ElMessageBox.confirm(
+    `确认删除工单「${row.workOrderNo}」？\n仅「已创建/待排产/已发布」且无排产、备料、生产数据的工单可删除。`,
+    '删除工单', { type: 'warning', confirmButtonText: '删除', confirmButtonClass: 'el-button--danger' })
+  await request.delete(`/work-orders/${row.id}`)
+  ElMessage.success('工单已删除')
+  load()
 }
 
 onMounted(() => { load(); loadProducts() })
-</script>
\ No newline at end of file
+</script>
diff --git a/bj_power_mes/frontend/src/router/index.js b/bj_power_mes/frontend/src/router/index.js
index 32bdc02..fd8b023 100644
--- a/bj_power_mes/frontend/src/router/index.js
+++ b/bj_power_mes/frontend/src/router/index.js
@@ -12,10 +12,10 @@ const routes = [
       { path: 'daily-plan', name: 'DailyPlan', component: () => import('../pages/DailyPlan.vue'), meta: { title: '日排产' } },
       { path: 'bom', name: 'Bom', component: () => import('../pages/Bom.vue'), meta: { title: '物料清单' } },
       { path: 'material-request', name: 'MaterialRequest', component: () => import('../pages/MaterialRequest.vue'), meta: { title: '备料单' } },
-      { path: 'plc-send', name: 'PlcSend', component: () => import('../pages/PlcSend.vue'), meta: { title: 'PLC工序下发' } },
+      { path: 'plc-send', name: 'PlcSend', component: () => import('../pages/PlcSend.vue'), meta: { title: '工位组合下发' } },
       { path: 'torque', name: 'Torque', component: () => import('../pages/Torque.vue'), meta: { title: '拧紧查询' } },
-      { path: 'process-step', name: 'ProcessStep', component: () => import('../pages/ProcessStep.vue'), meta: { title: '工艺参数' } },
       { path: 'process-flow', name: 'ProcessFlow', component: () => import('../pages/ProcessFlow.vue'), meta: { title: '工艺流程' } },
+      { path: 'station', name: 'Station', component: () => import('../pages/Station.vue'), meta: { title: '关联工位' } },
       { path: 'performance', name: 'Performance', component: () => import('../pages/Performance.vue'), meta: { title: '绩效报表' } },
       { path: 'inspect', name: 'Inspect', component: () => import('../pages/Inspect.vue'), meta: { title: '巡检终端' } },
       { path: 'scan', name: 'Scan', component: () => import('../pages/Scan.vue'), meta: { title: '手动报工' } },
diff --git a/bj_power_mes/internal/handler/perm.go b/bj_power_mes/internal/handler/perm.go
index 0f94955..822b24f 100644
--- a/bj_power_mes/internal/handler/perm.go
+++ b/bj_power_mes/internal/handler/perm.go
@@ -16,12 +16,14 @@ var pathPermMap = map[string]string{
 	"DELETE:/api/v1/product-types/*":          "produce.product:delete",
 	"POST:/api/v1/work-orders":                "produce.workorder:add",
 	"PUT:/api/v1/work-orders":                 "produce.workorder:edit",
+	"POST:/api/v1/work-orders/status":         "produce.workorder:edit",
 	"DELETE:/api/v1/work-orders/*":            "produce.workorder:delete",
 	"POST:/api/v1/daily-plans":                "produce.workorder:dailyplan",
 	"PUT:/api/v1/bom":                         "produce.bom:edit",
 	"POST:/api/v1/material-requests/generate": "produce.material:generate",
 	"POST:/api/v1/plc/send-process":           "produce.plc:send",
 	"POST:/api/v1/process-flows":              "produce.processflow:add",
+	"POST:/api/v1/process-flows/status":       "produce.processflow:edit",
 	"DELETE:/api/v1/process-flows/*":          "produce.processflow:delete",
 	"POST:/api/v1/process-flows/upload":       "produce.processflow:upload",
 	"POST:/api/v1/process-steps":              "produce.processflow:edit",
diff --git a/bj_power_mes/internal/handler/processflow.go b/bj_power_mes/internal/handler/processflow.go
index 95e5679..e0b8c29 100644
--- a/bj_power_mes/internal/handler/processflow.go
+++ b/bj_power_mes/internal/handler/processflow.go
@@ -8,11 +8,11 @@ import (
 	"bj_power_mes/internal/svc"
 )
 
-// ListProcessFlowsHandler GET /process-flows?processCode=
+// ListProcessFlowsHandler GET /process-flows?stationNo=
 func ListProcessFlowsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		code := atoiDefault(r.URL.Query().Get("processCode"), 0)
-		data, err := logic.New(svcCtx).ListFlows(r.Context(), code)
+		stationNo := atoiDefault(r.URL.Query().Get("stationNo"), 0)
+		data, err := logic.New(svcCtx).ListFlows(r.Context(), stationNo)
 		if err != nil {
 			httpx.Fail(w, 2201, err.Error())
 			return
@@ -21,7 +21,7 @@ func ListProcessFlowsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	}
 }
 
-// SaveProcessFlowHandler POST /process-flows（新建或更新工艺流程，含步骤模板）
+// SaveProcessFlowHandler POST /process-flows（新建或更新工艺流程，含工序步骤）
 func SaveProcessFlowHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var req logic.FlowReq
@@ -98,3 +98,22 @@ func SaveStationHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		httpx.OkMessage(w, "工位绑定已保存", nil)
 	}
 }
+
+// SetFlowStatusHandler POST /process-flows/status（工艺流程启用/停用）
+func SetFlowStatusHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req struct {
+			Id     int    `json:"id"`
+			Status string `json:"status"`
+		}
+		if err := httpx.ParseJSON(r, &req); err != nil {
+			httpx.BadRequest(w, "请求体解析失败")
+			return
+		}
+		if err := logic.New(svcCtx).SetFlowStatus(r.Context(), req.Id, req.Status, operator(r, "")); err != nil {
+			httpx.Fail(w, 2207, err.Error())
+			return
+		}
+		httpx.OkMessage(w, "操作成功", nil)
+	}
+}
diff --git a/bj_power_mes/internal/handler/production/plc_torque_scan.go b/bj_power_mes/internal/handler/production/plc_torque_scan.go
index e3bac5e..6f641b1 100644
--- a/bj_power_mes/internal/handler/production/plc_torque_scan.go
+++ b/bj_power_mes/internal/handler/production/plc_torque_scan.go
@@ -104,20 +104,16 @@ func ScanRecordsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	}
 }
 
-// ProcessStepsHandler 查询工位工序的步骤模板（参数采集模板），供手动报工页动态渲染
+// ProcessStepsHandler 查询工位的工序步骤（参数采集模板），供手动报工页动态渲染。
+// 按 stationNo 加载该工位启用工艺流程的工序步骤。
 func ProcessStepsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		code := atoiDefault(r.URL.Query().Get("processCode"), 0)
-		if code <= 0 {
-			data, err := logic.New(svcCtx).AllProcessSteps(r.Context(), 0)
-			if err != nil {
-				httpx.Fail(w, 3207, err.Error())
-				return
-			}
-			httpx.Ok(w, data)
+		stationNo := atoiDefault(r.URL.Query().Get("stationNo"), 0)
+		if stationNo <= 0 {
+			httpx.Fail(w, 3207, "缺少 stationNo 参数")
 			return
 		}
-		data, err := logic.New(svcCtx).ListProcessSteps(r.Context(), code)
+		data, err := logic.New(svcCtx).ListStationSteps(r.Context(), stationNo)
 		if err != nil {
 			httpx.Fail(w, 3207, err.Error())
 			return
@@ -125,19 +121,3 @@ func ProcessStepsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 		httpx.Ok(w, data)
 	}
 }
-
-// SaveProcessStepsHandler 覆盖式保存某工序的步骤模板及考核标准
-func SaveProcessStepsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var req []logic.StepItemReq
-		if err := httpx.ParseJSON(r, &req); err != nil {
-			httpx.BadRequest(w, "请求体解析失败")
-			return
-		}
-		if err := logic.New(svcCtx).SaveProcessSteps(r.Context(), req, operator(r, "")); err != nil {
-			httpx.Fail(w, 3208, err.Error())
-			return
-		}
-		httpx.OkMessage(w, "工艺参数已保存", nil)
-	}
-}
diff --git a/bj_power_mes/internal/handler/production/production.go b/bj_power_mes/internal/handler/production/production.go
index 67aaf6c..6a679b8 100644
--- a/bj_power_mes/internal/handler/production/production.go
+++ b/bj_power_mes/internal/handler/production/production.go
@@ -94,7 +94,7 @@ func WorkpieceTraceInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc
 func OrderQueryInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		orderNo := r.URL.Query().Get("orderNo")
-		list, err := logic.New(svcCtx).ListWorkOrders(r.Context(), orderNo, "")
+		list, err := logic.New(svcCtx).ListWorkOrders(r.Context(), orderNo, "", "", "")
 		if err != nil {
 			httpx.Fail(w, 2004, err.Error())
 			return
diff --git a/bj_power_mes/internal/handler/production/workorder.go b/bj_power_mes/internal/handler/production/workorder.go
index 8710f3b..bcf3f49 100644
--- a/bj_power_mes/internal/handler/production/workorder.go
+++ b/bj_power_mes/internal/handler/production/workorder.go
@@ -75,9 +75,9 @@ func DeleteProductTypeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 
 func ListWorkOrdersHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		orderNo := r.URL.Query().Get("orderNo")
-		status := r.URL.Query().Get("status")
-		data, err := logic.New(svcCtx).ListWorkOrders(r.Context(), orderNo, status)
+		q := r.URL.Query()
+		data, err := logic.New(svcCtx).ListWorkOrders(r.Context(),
+			q.Get("orderNo"), q.Get("status"), q.Get("productCode"), q.Get("productName"))
 		if err != nil {
 			httpx.Fail(w, 3004, err.Error())
 			return
@@ -127,6 +127,36 @@ func GetWorkOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	}
 }
 
+// SetWorkOrderStatusHandler POST /work-orders/status（工单状态流转）
+func SetWorkOrderStatusHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req struct {
+			Id     int    `json:"id"`
+			Status string `json:"status"`
+		}
+		if err := httpx.ParseJSON(r, &req); err != nil {
+			httpx.BadRequest(w, "请求体解析失败")
+			return
+		}
+		if err := logic.New(svcCtx).SetWorkOrderStatus(r.Context(), req.Id, req.Status, operator(r, "")); err != nil {
+			httpx.Fail(w, 3008, err.Error())
+			return
+		}
+		httpx.OkMessage(w, "状态已更新", nil)
+	}
+}
+
+// DeleteWorkOrderHandler DELETE /work-orders/:id（满足安全条件时删除）
+func DeleteWorkOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if err := logic.New(svcCtx).DeleteWorkOrder(r.Context(), pathID(r), operator(r, "")); err != nil {
+			httpx.Fail(w, 3009, err.Error())
+			return
+		}
+		httpx.OkMessage(w, "工单已删除", nil)
+	}
+}
+
 // ---------- 日排产 ----------
 
 func SaveDailyPlanHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
diff --git a/bj_power_mes/internal/handler/routes_production.go b/bj_power_mes/internal/handler/routes_production.go
index 7ad0852..269e3d8 100644
--- a/bj_power_mes/internal/handler/routes_production.go
+++ b/bj_power_mes/internal/handler/routes_production.go
@@ -82,7 +82,9 @@ func RegisterProductionRoutes(server *rest.Server, serverCtx *svc.ServiceContext
 		{Method: http.MethodGet, Path: "/work-orders", Handler: production.ListWorkOrdersHandler(serverCtx)},
 		{Method: http.MethodPost, Path: "/work-orders", Handler: production.CreateWorkOrderHandler(serverCtx)},
 		{Method: http.MethodPut, Path: "/work-orders", Handler: production.UpdateWorkOrderHandler(serverCtx)},
+		{Method: http.MethodPost, Path: "/work-orders/status", Handler: production.SetWorkOrderStatusHandler(serverCtx)},
 		{Method: http.MethodGet, Path: "/work-orders/:id", Handler: production.GetWorkOrderHandler(serverCtx)},
+		{Method: http.MethodDelete, Path: "/work-orders/:id", Handler: production.DeleteWorkOrderHandler(serverCtx)},
 		{Method: http.MethodPost, Path: "/daily-plans", Handler: production.SaveDailyPlanHandler(serverCtx)},
 		{Method: http.MethodPut, Path: "/daily-plans", Handler: production.SaveDailyPlanHandler(serverCtx)},
 		{Method: http.MethodGet, Path: "/daily-plans", Handler: production.ListDailyPlansHandler(serverCtx)},
@@ -103,7 +105,6 @@ func RegisterProductionRoutes(server *rest.Server, serverCtx *svc.ServiceContext
 		{Method: http.MethodPost, Path: "/scan/report", Handler: production.ScanReportHandler(serverCtx)},
 		{Method: http.MethodGet, Path: "/scan/records", Handler: production.ScanRecordsHandler(serverCtx)},
 		{Method: http.MethodGet, Path: "/process-steps", Handler: production.ProcessStepsHandler(serverCtx)},
-		{Method: http.MethodPost, Path: "/process-steps", Handler: production.SaveProcessStepsHandler(serverCtx)},
 
 		{Method: http.MethodPost, Path: "/workpiece/online", Handler: production.OnlineWorkpieceHandler(serverCtx)},
 		{Method: http.MethodPost, Path: "/workpiece/process/report", Handler: production.ReportWorkpieceProcessHandler(serverCtx)},
@@ -119,6 +120,7 @@ func RegisterProductionRoutes(server *rest.Server, serverCtx *svc.ServiceContext
 		// ---------- 工艺流程/工位（块3） ----------
 		{Method: http.MethodGet, Path: "/process-flows", Handler: ListProcessFlowsHandler(serverCtx)},
 		{Method: http.MethodPost, Path: "/process-flows", Handler: SaveProcessFlowHandler(serverCtx)},
+		{Method: http.MethodPost, Path: "/process-flows/status", Handler: SetFlowStatusHandler(serverCtx)},
 		{Method: http.MethodDelete, Path: "/process-flows/:id", Handler: DeleteProcessFlowHandler(serverCtx)},
 		{Method: http.MethodPost, Path: "/process-flows/upload", Handler: UploadPdfHandler(serverCtx)},
 		{Method: http.MethodGet, Path: "/stations", Handler: ListStationsHandler(serverCtx)},
diff --git a/bj_power_mes/internal/handler/station.go b/bj_power_mes/internal/handler/station.go
index 636b6f7..c1df75d 100644
--- a/bj_power_mes/internal/handler/station.go
+++ b/bj_power_mes/internal/handler/station.go
@@ -106,10 +106,11 @@ func StationReportInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 }
 
 // WorkloadInternalHandler 工作量/绩效报表（工位终端"我的工作量" + MES 绩效报表共用）
+// operator=操作人、stationNo=工位号（空=全部工位）、from/to=日期范围
 func WorkloadInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		q := r.URL.Query()
-		data, err := logic.New(svcCtx).Workload(r.Context(), q.Get("operator"), q.Get("from"), q.Get("to"))
+		data, err := logic.New(svcCtx).Workload(r.Context(), q.Get("operator"), q.Get("stationNo"), q.Get("from"), q.Get("to"))
 		if err != nil {
 			httpx.Fail(w, 2105, err.Error())
 			return
diff --git a/bj_power_mes/internal/logic/dailyplan.go b/bj_power_mes/internal/logic/dailyplan.go
index 8a33fc0..6819420 100644
--- a/bj_power_mes/internal/logic/dailyplan.go
+++ b/bj_power_mes/internal/logic/dailyplan.go
@@ -37,15 +37,21 @@ func (s *Service) SaveDailyPlan(ctx context.Context, req DailyPlanReq, operator
 	if err != nil {
 		return errors.New("工单不存在")
 	}
+	if wo.Status == "DONE" || wo.Status == "CLOSED" {
+		return errors.New("该工单已完成/关闭，不能排产")
+	}
 	cur, err := s.ctx.EntClient.DailyPlan.Query().
 		Where(dailyplan.OrderNo(req.OrderNo)).All(ctx)
 	if err != nil {
 		return err
 	}
+	// 计算合计：同「工单+日期」的记录无论原状态如何，都以本次新值替换（只算一次），避免旧值+新值重复累计
 	total := 0
 	for _, p := range cur {
-		if p.PlanDate == req.PlanDate && p.Status == "PENDING" {
-			// 覆盖同一 工单+日期 时，旧数量换掉
+		if p.PlanDate == req.PlanDate {
+			if p.CompletedQty > 0 {
+				return errors.New("该排产日已有完工数量，不能修改计划数量")
+			}
 			total += req.PlanQty
 			continue
 		}
diff --git a/bj_power_mes/internal/logic/dashboard.go b/bj_power_mes/internal/logic/dashboard.go
index 5950746..64a91d5 100644
--- a/bj_power_mes/internal/logic/dashboard.go
+++ b/bj_power_mes/internal/logic/dashboard.go
@@ -98,7 +98,7 @@ func (s *Service) DashboardAlarms(ctx context.Context) (any, error) {
 			alarms = append(alarms, map[string]any{"level": "WARN", "type": "torque_ng", "message": "存在拧紧NG记录", "count": ngTorque})
 		}
 		if openPlc > 0 {
-			alarms = append(alarms, map[string]any{"level": "INFO", "type": "plc_pending", "message": "存在待完成PLC工序", "count": openPlc})
+			alarms = append(alarms, map[string]any{"level": "INFO", "type": "plc_pending", "message": "存在待完成工位组合", "count": openPlc})
 		}
 		if plcTimeout > 0 {
 			alarms = append(alarms, map[string]any{"level": "CRITICAL", "type": "plc_timeout", "message": "存在PLC下发超时", "count": plcTimeout})
diff --git a/bj_power_mes/internal/logic/plc.go b/bj_power_mes/internal/logic/plc.go
index d09d22f..eb8c79f 100644
--- a/bj_power_mes/internal/logic/plc.go
+++ b/bj_power_mes/internal/logic/plc.go
@@ -20,7 +20,7 @@ type PlcSendReq struct {
 // 约束：上一条工序未收到完成信号，不下发下一条（模拟 S7 握手）。
 func (s *Service) SendProcess(ctx context.Context, req PlcSendReq, operator string) (*ent.PlcSendLog, error) {
 	if req.ProcessCombination == "" {
-		return nil, errors.New("工序组合不能为空")
+		return nil, errors.New("工位组合不能为空")
 	}
 	// 检查是否存在未完成的同工位下发
 	last, err := s.ctx.EntClient.PlcSendLog.Query().
@@ -37,7 +37,7 @@ func (s *Service) SendProcess(ctx context.Context, req PlcSendReq, operator stri
 	now := time.Now()
 	rec, err := s.ctx.EntClient.PlcSendLog.Create().
 		SetOrderNo(req.OrderNo).SetSn(req.Sn).SetStationNo(req.StationNo).
-		SetProcessCombination(req.ProcessCombination).SetProcessCodes(parseCodes(req.ProcessCombination)).
+		SetProcessCombination(req.ProcessCombination).SetProcessCodes(ParseProcessSeq(req.ProcessCombination)).
 		SetStatus("SENT").SetSendTime(now).SetOperator(operator).Save(ctx)
 	if err != nil {
 		return nil, err
@@ -47,7 +47,7 @@ func (s *Service) SendProcess(ctx context.Context, req PlcSendReq, operator stri
 	if err != nil {
 		return nil, err
 	}
-	s.ctx.EventLog.Write(ctx, "plc.send", req.OrderNo, operator, "plc_send_log", req.Sn, "PLC工序码下发", map[string]any{"combination": req.ProcessCombination})
+	s.ctx.EventLog.Write(ctx, "plc.send", req.OrderNo, operator, "plc_send_log", req.Sn, "工位组合下发", map[string]any{"combination": req.ProcessCombination})
 
 	// mock 完成信号：延时后置为完成（演示"未完成不下发下一条"握手）
 	go func(id int) {
@@ -60,19 +60,6 @@ func (s *Service) SendProcess(ctx context.Context, req PlcSendReq, operator stri
 	return rec, nil
 }
 
-func parseCodes(combination string) []int {
-	var out []int
-	for _, ch := range combination {
-		if ch >= '1' && ch <= '9' {
-			out = append(out, int(ch-'0'))
-		} else if ch == '1' || ch == '0' {
-			// 允许 "10","11","12" 两位工序
-			continue
-		}
-	}
-	return out
-}
-
 // ListPlcSendLogs 查询 PLC 下发日志
 func (s *Service) ListPlcSendLogs(ctx context.Context, orderNo, status string) ([]*ent.PlcSendLog, error) {
 	q := s.ctx.EntClient.PlcSendLog.Query()
diff --git a/bj_power_mes/internal/logic/processflow.go b/bj_power_mes/internal/logic/processflow.go
index 80e55be..413ed4d 100644
--- a/bj_power_mes/internal/logic/processflow.go
+++ b/bj_power_mes/internal/logic/processflow.go
@@ -3,6 +3,7 @@ package logic
 import (
 	"context"
 	"errors"
+	"fmt"
 	"sort"
 	"time"
 
@@ -18,33 +19,34 @@ import (
 // ---------- 工艺流程（块3） ----------
 
 type FlowReq struct {
-	Id          int           `json:"id"`
-	Name        string        `json:"name"`
-	ProcessCode int           `json:"processCode"`
-	PdfFile     string        `json:"pdfFile"`
-	Status      string        `json:"status"`
-	Remark      string        `json:"remark"`
-	Steps       []StepItemReq `json:"steps"`
+	Id        int           `json:"id"`
+	Name      string        `json:"name"`
+	StationNo int           `json:"stationNo"`
+	PdfFile   string        `json:"pdfFile"`
+	Status    string        `json:"status"`
+	Remark    string        `json:"remark"`
+	Steps     []StepItemReq `json:"steps"`
 }
 
-// FlowVO 流程图视图（含步骤模板 + 绑定该流程的工位号）
+// FlowVO 工艺流程视图（含工序步骤 + 绑定该流程的工位号）
 type FlowVO struct {
-	Id          int                  `json:"id"`
-	Name        string               `json:"name"`
-	ProcessCode int                  `json:"processCode"`
-	PdfFile     string               `json:"pdfFile"`
-	Status      string               `json:"status"`
-	Remark      string               `json:"remark"`
-	Stations    []int                `json:"stations"`
-	Steps       []*ProcessStepTemplate `json:"steps"`
-	CreatedAt   time.Time            `json:"createdAt"`
+	Id        int                    `json:"id"`
+	Name      string                 `json:"name"`
+	StationNo int                    `json:"stationNo"`
+	PdfFile   string                 `json:"pdfFile"`
+	Status    string                 `json:"status"`
+	Remark    string                 `json:"remark"`
+	Stations  []int                  `json:"stations"`
+	Steps     []*ProcessStepTemplate `json:"steps"`
+	CreatedAt time.Time              `json:"createdAt"`
 }
 
-func (s *Service) ListFlows(ctx context.Context, processCode int) ([]*FlowVO, error) {
+// ListFlows 查询工艺流程（可按工位号过滤）
+func (s *Service) ListFlows(ctx context.Context, stationNo int) ([]*FlowVO, error) {
 	q := s.ctx.EntClient.ProcessFlow.Query().
 		Order(ent.Asc(processflow.FieldProcessCode), ent.Asc(processflow.FieldID))
-	if processCode > 0 {
-		q = q.Where(processflow.ProcessCode(processCode))
+	if stationNo > 0 {
+		q = q.Where(processflow.ProcessCode(stationNo))
 	}
 	flows, err := q.All(ctx)
 	if err != nil {
@@ -54,7 +56,7 @@ func (s *Service) ListFlows(ctx context.Context, processCode int) ([]*FlowVO, er
 	out := make([]*FlowVO, 0, len(flows))
 	for _, f := range flows {
 		vo := &FlowVO{
-			Id: f.ID, Name: f.Name, ProcessCode: f.ProcessCode,
+			Id: f.ID, Name: f.Name, StationNo: f.ProcessCode,
 			PdfFile: f.PdfFile, Status: f.Status, Remark: f.Remark,
 			Stations: []int{}, Steps: s.flowSteps(ctx, f.ID, f.ProcessCode), CreatedAt: f.CreatedAt,
 		}
@@ -69,17 +71,36 @@ func (s *Service) ListFlows(ctx context.Context, processCode int) ([]*FlowVO, er
 }
 
 func (s *Service) SaveFlow(ctx context.Context, req FlowReq, operator string) error {
-	if req.Name == "" || req.ProcessCode <= 0 {
-		return errors.New("流程名称与工序编号必填")
+	if req.Name == "" {
+		return errors.New("流程名称必填")
+	}
+	if req.StationNo < 1 || req.StationNo > 12 {
+		return errors.New("请选择工位号（1~12，固定12个工位）")
 	}
 	status := req.Status
 	if status == "" {
 		status = "ACTIVE"
 	}
+	oldStationNo := 0
+	if req.Id > 0 {
+		if old, err := s.ctx.EntClient.ProcessFlow.Get(ctx, req.Id); err == nil {
+			oldStationNo = old.ProcessCode
+		}
+	}
+	if status == "ACTIVE" {
+		q := s.ctx.EntClient.ProcessFlow.Query().
+			Where(processflow.ProcessCode(req.StationNo), processflow.Status("ACTIVE"))
+		if req.Id > 0 {
+			q = q.Where(processflow.IDNEQ(req.Id))
+		}
+		if exist, err := q.Exist(ctx); err == nil && exist {
+			return fmt.Errorf("工位 %d 已存在启用的工艺流程，请先停用旧流程", req.StationNo)
+		}
+	}
 	var flowID int
 	if req.Id > 0 {
 		upd := s.ctx.EntClient.ProcessFlow.UpdateOneID(req.Id).
-			SetName(req.Name).SetProcessCode(req.ProcessCode).SetStatus(status).SetRemark(req.Remark)
+			SetName(req.Name).SetProcessCode(req.StationNo).SetStatus(status).SetRemark(req.Remark)
 		if req.PdfFile != "" {
 			upd.SetPdfFile(req.PdfFile)
 		}
@@ -89,21 +110,35 @@ func (s *Service) SaveFlow(ctx context.Context, req FlowReq, operator string) er
 		flowID = req.Id
 	} else {
 		f, err := s.ctx.EntClient.ProcessFlow.Create().
-			SetName(req.Name).SetProcessCode(req.ProcessCode).SetPdfFile(req.PdfFile).
+			SetName(req.Name).SetProcessCode(req.StationNo).SetPdfFile(req.PdfFile).
 			SetStatus(status).SetRemark(req.Remark).Save(ctx)
 		if err != nil {
 			return err
 		}
 		flowID = f.ID
 	}
-	// 覆盖式重建该流程的步骤模板及考核标准
+	// 工位号变更：解绑旧工位
+	if oldStationNo > 0 && oldStationNo != req.StationNo {
+		_, _ = s.ctx.EntClient.Station.Update().
+			Where(station.StationNo(oldStationNo), station.FlowId(flowID)).
+			SetFlowId(0).Save(ctx)
+	}
+	// 绑定同步：工位N 绑定该启用流程
+	if status == "ACTIVE" {
+		s.syncStationFlow(ctx, req.StationNo, flowID)
+	} else {
+		_, _ = s.ctx.EntClient.Station.Update().
+			Where(station.StationNo(req.StationNo), station.FlowId(flowID)).
+			SetFlowId(0).Save(ctx)
+	}
+	// 覆盖式重建该流程的工序步骤及考核标准
 	_, _ = s.ctx.EntClient.ProcessStep.Delete().Where(processstep.FlowId(flowID)).Exec(ctx)
 	for _, st := range req.Steps {
 		if st.Name == "" {
 			continue
 		}
 		rec, err := s.ctx.EntClient.ProcessStep.Create().
-			SetFlowId(flowID).SetProcessCode(req.ProcessCode).SetSeq(st.Seq).SetName(st.Name).
+			SetFlowId(flowID).SetProcessCode(req.StationNo).SetSeq(st.Seq).SetName(st.Name).
 			SetCollectType(st.CollectType).SetIsTorque(st.IsTorque).SetRemark(st.Remark).Save(ctx)
 		if err != nil {
 			return err
@@ -127,10 +162,22 @@ func (s *Service) SaveFlow(ctx context.Context, req FlowReq, operator string) er
 		}
 	}
 	s.ctx.EventLog.Write(ctx, "process.flow.save", "", operator, "process_flow", "", "维护工艺流程",
-		map[string]any{"flowId": flowID, "processCode": req.ProcessCode, "steps": len(req.Steps)})
+		map[string]any{"flowId": flowID, "stationNo": req.StationNo, "steps": len(req.Steps)})
 	return nil
 }
 
+// syncStationFlow 同步工位绑定：工位 stationNo 绑定到 flowID（无工位记录时自动创建）
+func (s *Service) syncStationFlow(ctx context.Context, stationNo, flowID int) {
+	st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx)
+	if err != nil {
+		_, _ = s.ctx.EntClient.Station.Create().
+			SetStationNo(stationNo).SetName(fmt.Sprintf("工位%d", stationNo)).
+			SetFlowId(flowID).Save(ctx)
+		return
+	}
+	_, _ = s.ctx.EntClient.Station.UpdateOneID(st.ID).SetFlowId(flowID).Save(ctx)
+}
+
 func (s *Service) DeleteFlow(ctx context.Context, id int, operator string) error {
 	// 有工位绑定的流程不允许删除
 	cnt, err := s.ctx.EntClient.Station.Query().Where(station.FlowId(id)).Count(ctx)
@@ -142,7 +189,7 @@ func (s *Service) DeleteFlow(ctx context.Context, id int, operator string) error
 	return s.ctx.EntClient.ProcessFlow.DeleteOneID(id).Exec(ctx)
 }
 
-// flowSteps 查询某流程的步骤模板（含考核标准）
+// flowSteps 查询某流程的工序步骤（含考核标准）
 func (s *Service) flowSteps(ctx context.Context, flowId, processCode int) []*ProcessStepTemplate {
 	steps, _ := s.ctx.EntClient.ProcessStep.Query().
 		Where(processstep.FlowId(flowId)).Order(ent.Asc(processstep.FieldSeq)).All(ctx)
@@ -214,18 +261,65 @@ func (s *Service) SaveStation(ctx context.Context, req StationReq, operator stri
 	st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(req.StationNo)).First(ctx)
 	if err != nil {
 		if _, err := s.ctx.EntClient.Station.Create().
-			SetStationNo(req.StationNo).SetName(req.Name).SetFlowId(req.FlowId).
-			SetStatus("ENABLED").Save(ctx); err != nil {
+			SetStationNo(req.StationNo).SetName(req.Name).Save(ctx); err != nil {
 			return err
 		}
 	} else {
-		if _, err := s.ctx.EntClient.Station.UpdateOneID(st.ID).
-			SetName(req.Name).SetFlowId(req.FlowId).Save(ctx); err != nil {
+		// 仅改名称：flowId 不传时保留原绑定
+		upd := s.ctx.EntClient.Station.UpdateOneID(st.ID).SetName(req.Name)
+		if req.FlowId > 0 {
+			flow, fErr := s.ctx.EntClient.ProcessFlow.Get(ctx, req.FlowId)
+			if fErr != nil {
+				return errors.New("所选工艺流程不存在")
+			}
+			if flow.Status != "ACTIVE" {
+				return errors.New("该工艺流程已停用，请先启用后再绑定工位")
+			}
+			upd.SetFlowId(req.FlowId)
+		}
+		if _, err := upd.Save(ctx); err != nil {
 			return err
 		}
 	}
-	s.ctx.EventLog.Write(ctx, "station.save", "", operator, "station", "", "维护工位绑定",
-		map[string]any{"stationNo": req.StationNo, "flowId": req.FlowId})
+	s.ctx.EventLog.Write(ctx, "station.save", "", operator, "station", "", "维护工位",
+		map[string]any{"stationNo": req.StationNo})
+	return nil
+}
+
+// SetFlowStatus 工艺流程启用/停用。
+// 停用：自动解绑对应工位；启用：校验该工位无其他启用流程后自动绑定。
+func (s *Service) SetFlowStatus(ctx context.Context, id int, status, operator string) error {
+	if id <= 0 {
+		return errors.New("缺少 id")
+	}
+	if status != "ACTIVE" && status != "INACTIVE" {
+		return errors.New("非法状态")
+	}
+	flow, err := s.ctx.EntClient.ProcessFlow.Get(ctx, id)
+	if err != nil {
+		return errors.New("工艺流程不存在")
+	}
+	if status == "INACTIVE" {
+		// 自动解绑该流程对应的工位
+		_, _ = s.ctx.EntClient.Station.Update().
+			Where(station.StationNo(flow.ProcessCode), station.FlowId(flow.ID)).
+			SetFlowId(0).Save(ctx)
+	} else {
+		q := s.ctx.EntClient.ProcessFlow.Query().
+			Where(processflow.ProcessCode(flow.ProcessCode), processflow.Status("ACTIVE"), processflow.IDNEQ(flow.ID))
+		if exist, err := q.Exist(ctx); err == nil && exist {
+			return fmt.Errorf("工位 %d 已存在其他启用的工艺流程，请先停用旧流程", flow.ProcessCode)
+		}
+		s.syncStationFlow(ctx, flow.ProcessCode, flow.ID)
+	}
+	if err := s.ctx.EntClient.ProcessFlow.UpdateOneID(id).SetStatus(status).Exec(ctx); err != nil {
+		return err
+	}
+	action := "停用工艺流程"
+	if status == "ACTIVE" {
+		action = "启用工艺流程"
+	}
+	s.ctx.EventLog.Write(ctx, "process.flow.status", "", operator, "process_flow", "", action, map[string]any{"flowId": id, "status": status, "name": flow.Name, "stationNo": flow.ProcessCode})
 	return nil
 }
 
@@ -264,6 +358,7 @@ func (s *Service) StationTask(ctx context.Context, stationNo int) (map[string]an
 
 type WorkloadRow struct {
 	Operator    string `json:"operator"`
+	StationNo   string `json:"stationNo"`
 	Date        string `json:"date"`
 	ProcessCode int    `json:"processCode"`
 	ProcessName string `json:"processName"`
@@ -272,11 +367,14 @@ type WorkloadRow struct {
 	NgCount     int    `json:"ngCount"`
 }
 
-func (s *Service) Workload(ctx context.Context, operator, from, to string) (map[string]any, error) {
+func (s *Service) Workload(ctx context.Context, operator, stationNo, from, to string) (map[string]any, error) {
 	q := s.ctx.EntClient.WorkpieceProcess.Query()
 	if operator != "" {
 		q = q.Where(workpieceprocess.Operator(operator))
 	}
+	if stationNo != "" {
+		q = q.Where(workpieceprocess.StationNo(stationNo))
+	}
 	if from != "" {
 		if f, err := time.Parse("2006-01-02", from); err == nil {
 			q = q.Where(workpieceprocess.CreatedAtGTE(f))
@@ -291,13 +389,13 @@ func (s *Service) Workload(ctx context.Context, operator, from, to string) (map[
 	if err != nil {
 		return nil, err
 	}
-	type key struct{ op, date string; code int }
+	type key struct{ op, station, date string; code int }
 	agg := map[key]*WorkloadRow{}
 	for _, r := range rows {
-		k := key{r.Operator, r.CreatedAt.Format("2006-01-02"), r.ProcessCode}
+		k := key{r.Operator, r.StationNo, r.CreatedAt.Format("2006-01-02"), r.ProcessCode}
 		row, ok := agg[k]
 		if !ok {
-			row = &WorkloadRow{Operator: r.Operator, Date: k.date, ProcessCode: r.ProcessCode, ProcessName: r.ProcessName}
+			row = &WorkloadRow{Operator: r.Operator, StationNo: r.StationNo, Date: k.date, ProcessCode: r.ProcessCode, ProcessName: r.ProcessName}
 			agg[k] = row
 		}
 		row.DoneCount++
@@ -315,6 +413,9 @@ func (s *Service) Workload(ctx context.Context, operator, from, to string) (map[
 		if list[i].Operator != list[j].Operator {
 			return list[i].Operator < list[j].Operator
 		}
+		if list[i].StationNo != list[j].StationNo {
+			return list[i].StationNo < list[j].StationNo
+		}
 		if list[i].Date != list[j].Date {
 			return list[i].Date < list[j].Date
 		}
diff --git a/bj_power_mes/internal/logic/processseq.go b/bj_power_mes/internal/logic/processseq.go
new file mode 100644
index 0000000..21b3712
--- /dev/null
+++ b/bj_power_mes/internal/logic/processseq.go
@@ -0,0 +1,57 @@
+package logic
+
+import (
+	"errors"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// FullProcessSeq 全部 12 个工位的完整组合（按顺序执行）
+const FullProcessSeq = "1,2,3,4,5,6,7,8,9,10,11,12"
+
+// ParseProcessSeq 解析工位组合字符串为升序去重的工位码列表。
+// 唯一格式：逗号分隔 "1,3,5" / "10,11,12"。传送带不回走，故组合天然按工位号升序执行。
+func ParseProcessSeq(s string) []int {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return nil
+	}
+	seen := map[int]bool{}
+	out := make([]int, 0, 12)
+	for _, p := range strings.Split(s, ",") {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		n, err := strconv.Atoi(p)
+		if err != nil || n < 1 || n > 12 || seen[n] {
+			continue
+		}
+		seen[n] = true
+		out = append(out, n)
+	}
+	sort.Ints(out)
+	return out
+}
+
+// NormalizeProcessSeq 规范化：解析后重排为逗号分隔升序，非法/空返回空串。
+func NormalizeProcessSeq(s string) string {
+	codes := ParseProcessSeq(s)
+	if len(codes) == 0 {
+		return ""
+	}
+	parts := make([]string, len(codes))
+	for i, c := range codes {
+		parts[i] = strconv.Itoa(c)
+	}
+	return strings.Join(parts, ",")
+}
+
+// ValidateProcessSeq 校验工位组合：非空、1~12 升序执行。
+func ValidateProcessSeq(s string) error {
+	if len(ParseProcessSeq(s)) == 0 {
+		return errors.New("工位组合不能为空，请至少选择一个工位")
+	}
+	return nil
+}
diff --git a/bj_power_mes/internal/logic/seed.go b/bj_power_mes/internal/logic/seed.go
index 00a3cd1..6bfa612 100644
--- a/bj_power_mes/internal/logic/seed.go
+++ b/bj_power_mes/internal/logic/seed.go
@@ -4,12 +4,12 @@ import (
 	"context"
 	"strconv"
 
+	"bj_power_mes/ent"
 	"bj_power_mes/ent/permission"
 	"bj_power_mes/ent/processflow"
 	"bj_power_mes/ent/processstep"
 	"bj_power_mes/ent/role"
 	"bj_power_mes/ent/station"
-	"bj_power_mes/ent/stationprocess"
 	"bj_power_mes/ent/user"
 
 	"golang.org/x/crypto/bcrypt"
@@ -28,7 +28,7 @@ func (s *Service) Seed(ctx context.Context) error {
 		if r.code == "OPERATOR" {
 			codes = []string{
 				"produce.workorder", "produce.dailyplan", "produce.bom", "produce.material", "produce.scan",
-				"produce.trace", "produce.torque", "produce.plc", "produce.product", "produce.step",
+				"produce.trace", "produce.torque", "produce.plc", "produce.product",
 				"produce.processflow", "produce.station", "produce.performance",
 				// 按钮级权限（块2）
 				"produce.workorder:add", "produce.workorder:edit", "produce.workorder:delete",
@@ -73,13 +73,12 @@ func (s *Service) Seed(ctx context.Context) error {
 		{"produce.dailyplan", "日排产", "MENU", "/daily-plan"},
 		{"produce.bom", "物料清单", "MENU", "/bom"},
 		{"produce.material", "备料单", "MENU", "/material-request"},
-		{"produce.plc", "PLC工序下发", "MENU", "/plc-send"},
+		{"produce.plc", "工位组合下发", "MENU", "/plc-send"},
 		{"produce.torque", "拧紧查询", "MENU", "/torque"},
-		{"produce.step", "工艺参数", "MENU", "/process-step"},
 		{"produce.processflow", "工艺流程", "MENU", "/process-flow"},
-		{"produce.station", "工位管理", "MENU", "/station"},
+		{"produce.station", "关联工位", "MENU", "/station"},
 		{"produce.performance", "绩效报表", "MENU", "/performance"},
-		{"produce.scan", "扫码报工", "MENU", "/scan"},
+		{"produce.scan", "手动报工", "MENU", "/scan"},
 		{"produce.trace", "工件追溯", "MENU", "/trace"},
 		{"produce.product", "产品类型", "MENU", "/product-type"},
 		{"sys.inspect", "巡检终端", "MENU", "/inspect"},
@@ -102,7 +101,7 @@ func (s *Service) Seed(ctx context.Context) error {
 		{"produce.workorder:dailyplan", "工单-日排产", "BUTTON", ""},
 		{"produce.bom:edit", "物料清单-维护", "BUTTON", ""},
 		{"produce.material:generate", "备料单-生成", "BUTTON", ""},
-		{"produce.plc:send", "PLC工序-下发", "BUTTON", ""},
+		{"produce.plc:send", "工位组合-下发", "BUTTON", ""},
 		{"produce.product:add", "产品类型-新增", "BUTTON", ""},
 		{"produce.product:edit", "产品类型-编辑", "BUTTON", ""},
 		{"produce.product:delete", "产品类型-删除", "BUTTON", ""},
@@ -129,29 +128,25 @@ func (s *Service) Seed(ctx context.Context) error {
 			SetCode(b.code).SetName(b.name).SetType(b.typ).SetPath(b.path).Exec(ctx)
 	}
 
-	// 4. 12 道工序默认工艺流程 + 工位绑定（流程挂 process_code，工位绑流程）
+	// 4. 12 个工位默认工艺流程 + 工位绑定（流程挂 process_code，工位绑流程）
 	seedFlowsAndStations(ctx, s)
-	// 5. 12 工位 ↔ 工序 派工（工位N 默认做工序N）
-	for i := 1; i <= 12; i++ {
-		if s.ctx.EntClient.StationProcess.Query().Where(stationprocess.StationNo(i), stationprocess.ProcessCode(i)).ExistX(ctx) {
-			continue
-		}
-		_ = s.ctx.EntClient.StationProcess.Create().
-			SetStationNo(i).SetProcessCode(i).SetEffectDate("").Exec(ctx)
-	}
 	return nil
 }
 
 func seedFlowsAndStations(ctx context.Context, s *Service) {
-	// 每个工序编号（1~12）创建默认工艺流程，并为每道工序补默认步骤模板（挂到流程下）
+	// 每个工位（1~12）若未配置工艺流程，则创建默认流程并绑定；已有流程则跳过
 	for i := 1; i <= 12; i++ {
 		flow, err := s.ctx.EntClient.ProcessFlow.Query().
-			Where(processflow.ProcessCode(i), processflow.Name("工序"+strconv.Itoa(i)+"_默认")).First(ctx)
+			Where(processflow.ProcessCode(i)).
+			Order(ent.Asc(processflow.FieldID)).First(ctx)
 		if err != nil {
 			flow, _ = s.ctx.EntClient.ProcessFlow.Create().
-				SetName("工序" + strconv.Itoa(i) + "_默认").
+				SetName("工位" + strconv.Itoa(i) + "_默认").
 				SetProcessCode(i).SetStatus("ACTIVE").SetRemark("默认工艺流程").Save(ctx)
 		}
+		if flow == nil {
+			continue
+		}
 		cnt, _ := s.ctx.EntClient.ProcessStep.Query().Where(processstep.FlowId(flow.ID)).Count(ctx)
 		if cnt == 0 {
 			stepID := 0
@@ -166,7 +161,7 @@ func seedFlowsAndStations(ctx context.Context, s *Service) {
 					SetCollectType("AUTO").SetIsTorque(true).Save(ctx)
 			}
 		}
-		// 工位 N 绑定工序 N 的默认流程
+		// 工位 N 绑定工位 N 的默认流程
 		st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(i)).First(ctx)
 		if err != nil {
 			_, _ = s.ctx.EntClient.Station.Create().
diff --git a/bj_power_mes/internal/logic/torque.go b/bj_power_mes/internal/logic/torque.go
index 3cdabcc..aacebbd 100644
--- a/bj_power_mes/internal/logic/torque.go
+++ b/bj_power_mes/internal/logic/torque.go
@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"bj_power_mes/ent"
-	"bj_power_mes/ent/processstep"
+	"bj_power_mes/ent/processflow"
 	"bj_power_mes/ent/stepcriterion"
 	"bj_power_mes/ent/torquerecord"
 	"bj_power_mes/ent/workpieceprocess"
@@ -122,32 +122,19 @@ type CriterionVO struct {
 	Max    *float64 `json:"max"`
 }
 
-// ListProcessSteps 查询某工序的步骤模板（含考核标准），供手动报工页动态渲染参数输入
-func (s *Service) ListProcessSteps(ctx context.Context, processCode int) ([]*ProcessStepTemplate, error) {
-	steps, err := s.ctx.EntClient.ProcessStep.Query().
-		Where(processstep.ProcessCode(processCode)).
-		Order(ent.Asc(processstep.FieldSeq)).All(ctx)
+// ListStationSteps 按工位号加载该工位「启用」工艺流程的工序步骤（含考核标准）。
+// 手动报工页：选工位 → 自动带出该工位的工序步骤。
+func (s *Service) ListStationSteps(ctx context.Context, stationNo int) ([]*ProcessStepTemplate, error) {
+	if stationNo < 1 || stationNo > 12 {
+		return []*ProcessStepTemplate{}, nil
+	}
+	flow, err := s.ctx.EntClient.ProcessFlow.Query().
+		Where(processflow.ProcessCode(stationNo), processflow.Status("ACTIVE")).First(ctx)
 	if err != nil {
-		return nil, err
+		// 该工位未配置启用的工艺流程：返回空模板（前端提示）
+		return []*ProcessStepTemplate{}, nil
 	}
-	out := make([]*ProcessStepTemplate, 0, len(steps))
-	for _, st := range steps {
-		t := &ProcessStepTemplate{
-			ID: st.ID, ProcessCode: st.ProcessCode, Seq: st.Seq,
-			Name: st.Name, CollectType: st.CollectType, IsTorque: st.IsTorque,
-			Remark: st.Remark, Criteria: []CriterionVO{},
-		}
-		crits, _ := s.ctx.EntClient.StepCriterion.Query().
-			Where(stepcriterion.StepId(st.ID)).All(ctx)
-		for _, c := range crits {
-			t.Criteria = append(t.Criteria, CriterionVO{
-				ID: c.ID, Name: c.Name, Unit: c.Unit, Logic: c.Logic,
-				Target: c.Target, Min: c.Min, Max: c.Max,
-			})
-		}
-		out = append(out, t)
-	}
-	return out, nil
+	return s.flowSteps(ctx, flow.ID, flow.ProcessCode), nil
 }
 
 // StepItemReq 一次保存的一个步骤（含其考核标准）
@@ -161,68 +148,3 @@ type StepItemReq struct {
 	Remark      string        `json:"remark"`
 	Criteria    []CriterionVO `json:"criteria"`
 }
-
-// SaveProcessSteps 覆盖式保存某工序的步骤模板及考核标准（供"工艺参数"维护页调用）
-func (s *Service) SaveProcessSteps(ctx context.Context, steps []StepItemReq, operator string) error {
-	for _, st := range steps {
-		if st.ProcessCode <= 0 || st.Name == "" {
-			continue
-		}
-		var stepID int
-		if st.ID > 0 {
-			upd := s.ctx.EntClient.ProcessStep.UpdateOneID(st.ID).
-				SetSeq(st.Seq).SetName(st.Name).SetCollectType(st.CollectType).
-				SetIsTorque(st.IsTorque).SetRemark(st.Remark)
-			_, err := upd.Save(ctx)
-			if err != nil {
-				return err
-			}
-			stepID = st.ID
-		} else {
-			rec, err := s.ctx.EntClient.ProcessStep.Create().
-				SetProcessCode(st.ProcessCode).SetSeq(st.Seq).SetName(st.Name).
-				SetCollectType(st.CollectType).SetIsTorque(st.IsTorque).SetRemark(st.Remark).Save(ctx)
-			if err != nil {
-				return err
-			}
-			stepID = rec.ID
-		}
-		// 覆盖式重建该步骤的考核标准
-		_, _ = s.ctx.EntClient.StepCriterion.Delete().Where(stepcriterion.StepId(stepID)).Exec(ctx)
-		for _, c := range st.Criteria {
-			if c.Name == "" || c.Logic == "" || c.Logic == "NONE" {
-				continue
-			}
-			b := s.ctx.EntClient.StepCriterion.Create().
-				SetStepId(stepID).SetName(c.Name).SetUnit(c.Unit).SetLogic(c.Logic).
-				SetTarget(c.Target)
-			if c.Min != nil {
-				b = b.SetMin(*c.Min)
-			}
-			if c.Max != nil {
-				b = b.SetMax(*c.Max)
-			}
-			if err := b.Exec(ctx); err != nil {
-				return err
-			}
-		}
-	}
-	s.ctx.EventLog.Write(ctx, "process.steps.save", "", operator, "process_step", "", "维护工艺参数", map[string]any{"count": len(steps)})
-	return nil
-}
-
-// AllProcessSteps 查询全部工序的步骤模板（含 12 道工序），供维护页按工序分组展示
-func (s *Service) AllProcessSteps(ctx context.Context, processCode int) ([]*ProcessStepTemplate, error) {
-	if processCode > 0 {
-		return s.ListProcessSteps(ctx, processCode)
-	}
-	out := []*ProcessStepTemplate{}
-	for code := 1; code <= 12; code++ {
-		sub, err := s.ListProcessSteps(ctx, code)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, sub...)
-	}
-	return out, nil
-}
diff --git a/bj_power_mes/internal/logic/workorder.go b/bj_power_mes/internal/logic/workorder.go
index c234d27..bf32484 100644
--- a/bj_power_mes/internal/logic/workorder.go
+++ b/bj_power_mes/internal/logic/workorder.go
@@ -5,7 +5,10 @@ import (
 	"errors"
 
 	"bj_power_mes/ent"
+	"bj_power_mes/ent/dailyplan"
+	"bj_power_mes/ent/materialrequest"
 	"bj_power_mes/ent/workorder"
+	"bj_power_mes/ent/workpiece"
 )
 
 type WorkOrderReq struct {
@@ -37,8 +40,11 @@ func (s *Service) CreateWorkOrder(ctx context.Context, req WorkOrderReq, operato
 		status = "CREATED"
 	}
 	if req.ProcessSeq == "" {
-		req.ProcessSeq = "123456789101112"
+		req.ProcessSeq = FullProcessSeq
+	} else if err := ValidateProcessSeq(req.ProcessSeq); err != nil {
+		return err
 	}
+	req.ProcessSeq = NormalizeProcessSeq(req.ProcessSeq)
 	b := s.ctx.EntClient.WorkOrder.Create().
 		SetWorkOrderNo(req.WorkOrderNo).
 		SetProductTypeId(req.ProductTypeId).
@@ -68,8 +74,25 @@ func (s *Service) UpdateWorkOrder(ctx context.Context, req WorkOrderReq, operato
 	if req.Id == 0 {
 		return errors.New("缺少 id")
 	}
-	u := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id).
-		SetStatus(req.Status).SetQuantity(req.Quantity).SetProcessSeq(req.ProcessSeq)
+	if req.ProcessSeq != "" {
+		if err := ValidateProcessSeq(req.ProcessSeq); err != nil {
+			return err
+		}
+		req.ProcessSeq = NormalizeProcessSeq(req.ProcessSeq)
+	}
+	u := s.ctx.EntClient.WorkOrder.UpdateOneID(req.Id).SetProcessSeq(req.ProcessSeq)
+	if req.Status != "" {
+		u.SetStatus(req.Status)
+	}
+	if req.Quantity > 0 {
+		u.SetQuantity(req.Quantity)
+	}
+	if req.ProductCode != "" {
+		u.SetProductCode(req.ProductCode)
+	}
+	if req.ProductName != "" {
+		u.SetProductName(req.ProductName)
+	}
 	if req.PlanStart != "" {
 		if t, err := parseDate(req.PlanStart); err == nil {
 			u.SetPlanStart(t)
@@ -90,8 +113,8 @@ func (s *Service) UpdateWorkOrder(ctx context.Context, req WorkOrderReq, operato
 	return nil
 }
 
-// ListWorkOrders 查询工单（支持工单号/状态过滤）
-func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status string) ([]*ent.WorkOrder, error) {
+// ListWorkOrders 查询工单（支持工单号/状态/产品编码/产品名称 过滤）
+func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status, productCode, productName string) ([]*ent.WorkOrder, error) {
 	q := s.ctx.EntClient.WorkOrder.Query()
 	if orderNo != "" {
 		q = q.Where(workorder.WorkOrderNoContains(orderNo))
@@ -99,6 +122,12 @@ func (s *Service) ListWorkOrders(ctx context.Context, orderNo, status string) ([
 	if status != "" {
 		q = q.Where(workorder.Status(status))
 	}
+	if productCode != "" {
+		q = q.Where(workorder.ProductCodeContains(productCode))
+	}
+	if productName != "" {
+		q = q.Where(workorder.ProductNameContains(productName))
+	}
 	return q.Order(ent.Desc(workorder.FieldID)).All(ctx)
 }
 
@@ -107,4 +136,57 @@ func (s *Service) GetWorkOrder(ctx context.Context, id int) (*ent.WorkOrder, err
 		return s.ctx.EntClient.WorkOrder.Get(ctx, id)
 	}
 	return s.ctx.EntClient.WorkOrder.Query().Order(ent.Desc(workorder.FieldID)).First(ctx)
+}
+
+// 工单状态白名单
+var workOrderStatuses = map[string]bool{
+	"CREATED": true, "RELEASED": true, "IN_PROGRESS": true, "DONE": true,
+	"PENDING": true, "CONFIRMED": true,
+}
+
+// SetWorkOrderStatus 工单状态流转（发布/开工/完工等），操作列快捷操作。
+func (s *Service) SetWorkOrderStatus(ctx context.Context, id int, status, operator string) error {
+	if id <= 0 {
+		return errors.New("缺少 id")
+	}
+	if !workOrderStatuses[status] {
+		return errors.New("非法的工单状态")
+	}
+	if err := s.ctx.EntClient.WorkOrder.UpdateOneID(id).SetStatus(status).Exec(ctx); err != nil {
+		return err
+	}
+	if wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id); err == nil {
+		s.ctx.EventLog.Write(ctx, "work.order.status", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "变更工单状态", map[string]any{"status": status})
+	}
+	return nil
+}
+
+// DeleteWorkOrder 删除工单。
+// 安全条件：① 状态仅限 已创建/待排产/已发布（未开始生产）；② 无日排产记录；
+// ③ 未生成备料单；④ 无任何工件生产数据。
+func (s *Service) DeleteWorkOrder(ctx context.Context, id int, operator string) error {
+	if id <= 0 {
+		return errors.New("缺少 id")
+	}
+	wo, err := s.ctx.EntClient.WorkOrder.Get(ctx, id)
+	if err != nil {
+		return errors.New("工单不存在")
+	}
+	if wo.Status != "CREATED" && wo.Status != "PENDING" && wo.Status != "RELEASED" {
+		return errors.New("仅「已创建 / 待排产 / 已发布」状态的工单可删除，生产中或已完成的工单不能删除")
+	}
+	if n, err := s.ctx.EntClient.DailyPlan.Query().Where(dailyplan.OrderNo(wo.WorkOrderNo)).Count(ctx); err == nil && n > 0 {
+		return errors.New("该工单已有日排产记录，请先删除对应排产后再删除工单")
+	}
+	if n, err := s.ctx.EntClient.MaterialRequest.Query().Where(materialrequest.OrderNo(wo.WorkOrderNo)).Count(ctx); err == nil && n > 0 {
+		return errors.New("该工单已生成备料单，不能删除")
+	}
+	if n, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.OrderNo(wo.WorkOrderNo)).Count(ctx); err == nil && n > 0 {
+		return errors.New("该工单已有工件生产数据，不能删除")
+	}
+	if err := s.ctx.EntClient.WorkOrder.DeleteOneID(id).Exec(ctx); err != nil {
+		return err
+	}
+	s.ctx.EventLog.Write(ctx, "work.order.delete", wo.WorkOrderNo, operator, "work_order", wo.WorkOrderNo, "删除工单", map[string]any{"status": wo.Status})
+	return nil
 }
\ No newline at end of file
diff --git a/bj_power_mes/internal/logic/workpiece.go b/bj_power_mes/internal/logic/workpiece.go
index c19d9cd..8feff1c 100644
--- a/bj_power_mes/internal/logic/workpiece.go
+++ b/bj_power_mes/internal/logic/workpiece.go
@@ -22,7 +22,7 @@ func processName(code int) string {
 	if n, ok := names[code]; ok {
 		return n
 	}
-	return "工序" + itoa(code)
+	return "工位" + itoa(code)
 }
 
 // evalLogic 依据考核逻辑判定
@@ -73,7 +73,7 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s
 	}
 	seq := req.ProcessSeq
 	if seq == "" {
-		seq = "123456789101112"
+		seq = FullProcessSeq
 	}
 	if req.WorkOrderId == 0 {
 		if wo, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(req.OrderNo)).First(ctx); err == nil {
@@ -83,6 +83,7 @@ func (s *Service) OnlineWorkpiece(ctx context.Context, req OnlineReq, operator s
 			}
 		}
 	}
+	seq = NormalizeProcessSeq(seq)
 	err := s.ctx.EntClient.Workpiece.Create().
 		SetSn(req.Sn).SetOrderNo(req.OrderNo).SetWorkOrderId(req.WorkOrderId).
 		SetProcessSeq(seq).SetStatus("ONLINE").SetOnlineAt(time.Now()).Exec(ctx)
@@ -100,7 +101,7 @@ type ReportProcessReq struct {
 	Steps       []StepDataReq `json:"steps"`
 }
 
-// ReportProcess 工位工序报工：写工序实绩 + 步骤考核（step_data，扭矩在RANGE自动判定 OK/NG）
+// ReportProcess 工位报工：写报工实绩 + 步骤考核（step_data，扭矩在RANGE自动判定 OK/NG）
 func (s *Service) ReportProcess(ctx context.Context, req ReportProcessReq, operator string) error {
 	if req.Sn == "" || req.ProcessCode == 0 {
 		return errors.New("sn 与 processCode 必填")
@@ -139,7 +140,7 @@ func (s *Service) ReportProcess(ctx context.Context, req ReportProcessReq, opera
 		SetCurrentProcess(req.ProcessCode).SetStatus("PROCESSING").Save(ctx)
 
 	s.ctx.EventLog.Write(ctx, "workpiece.process.report", wp.OrderNo, operator, "workpiece", req.Sn,
-		"工位工序报工", map[string]any{"processCode": req.ProcessCode, "result": result})
+		"工位报工", map[string]any{"processCode": req.ProcessCode, "result": result})
 	return nil
 }
 
diff --git a/bj_power_mes/internal/plc/plc.go b/bj_power_mes/internal/plc/plc.go
index e7950fc..c5084f7 100644
--- a/bj_power_mes/internal/plc/plc.go
+++ b/bj_power_mes/internal/plc/plc.go
@@ -2,6 +2,7 @@ package plc
 
 import (
 	"context"
+	"strconv"
 	"strings"
 	"time"
 
@@ -12,7 +13,7 @@ import (
 // 生产对接西门子 S7：写入工序码寄存器，读完成信号位；未收到完成信号不下发下一条。
 // mock 模式下直接模拟：下发后置发送状态，可主动标记完成。
 type Client interface {
-	// SendProcessCode 下发工序组合（如 "135"），返回已下发工序码
+	// SendProcessCode 下发工位组合（如 "1,3,5"），返回已下发工位码
 	SendProcessCode(ctx context.Context, processCombination string) ([]int, error)
 	// QueryDone 查询最近一次下发是否收到完成信号，完成则返回 true
 	QueryDone(ctx context.Context) (bool, error)
@@ -40,13 +41,19 @@ func (m *Manager) Get() Client { return m.client }
 
 func (m *Manager) IsMock() bool { return m.mock }
 
-// parseCombination 解析 "135" -> [1,3,5]
+// parseCombination 解析工位组合 "1,3,5" / "10,11,12" -> [1,3,5] / [10,11,12]
 func parseCombination(s string) []int {
 	var out []int
-	for _, ch := range strings.TrimSpace(s) {
-		if ch >= '1' && ch <= '9' {
-			out = append(out, int(ch-'0'))
+	for _, p := range strings.Split(s, ",") {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
 		}
+		n, err := strconv.Atoi(p)
+		if err != nil || n < 1 || n > 12 {
+			continue
+		}
+		out = append(out, n)
 	}
 	return out
 }
diff --git a/bj_power_mes/public/index.html b/bj_power_mes/public/index.html
index 8753d40..01eda4c 100644
--- a/bj_power_mes/public/index.html
+++ b/bj_power_mes/public/index.html
@@ -4,8 +4,8 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" />
   <title>MES 产线控制</title>
-  <script type="module" crossorigin src="./assets/index-B-nVZ8ou.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-Dh90yOUJ.css">
+  <script type="module" crossorigin src="./assets/index-CEKQX1B2.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-HmZIfQ_J.css">
 </head>
 <body>
   <div id="app"></div>
diff --git a/bj_power_wms/internal/handler/auth.go b/bj_power_wms/internal/handler/auth.go
index 1b7d851..7978f76 100644
--- a/bj_power_wms/internal/handler/auth.go
+++ b/bj_power_wms/internal/handler/auth.go
@@ -124,3 +124,52 @@ func roleOrDefault(r string) string {
 		return "operator"
 	}
 }
+
+// changePasswordHandler POST /api/user/change-password（需登录 JWT）
+// 当前登录用户修改自己的密码；登录人由中间件写入的 X-Username 头确定。
+func changePasswordHandler(ctx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		username := strings.TrimSpace(r.Header.Get("X-Username"))
+		if username == "" {
+			fail(w, http.StatusUnauthorized, "未登录或登录状态缺失")
+			return
+		}
+		var req struct {
+			OldPassword string `json:"oldPassword"`
+			NewPassword string `json:"newPassword"`
+		}
+		if err := parseJSON(r, &req); err != nil {
+			fail(w, http.StatusBadRequest, "参数错误")
+			return
+		}
+		if req.OldPassword == "" || req.NewPassword == "" {
+			fail(w, http.StatusBadRequest, "请输入旧密码和新密码")
+			return
+		}
+		if len(req.NewPassword) < 6 {
+			fail(w, http.StatusBadRequest, "新密码长度至少 6 位")
+			return
+		}
+		u, err := ctx.EntClient.User.Query().
+			Where(user.UsernameEQ(username)).
+			Only(ctx0())
+		if err != nil {
+			fail(w, http.StatusNotFound, "用户不存在")
+			return
+		}
+		if bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(req.OldPassword)) != nil {
+			fail(w, http.StatusBadRequest, "旧密码不正确")
+			return
+		}
+		hash, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
+		if err != nil {
+			fail(w, http.StatusInternalServerError, "密码加密失败")
+			return
+		}
+		if err := ctx.EntClient.User.UpdateOneID(u.ID).SetPassword(string(hash)).Exec(ctx0()); err != nil {
+			fail(w, http.StatusInternalServerError, "密码保存失败")
+			return
+		}
+		ok(w, nil)
+	}
+}
diff --git a/bj_power_wms/internal/handler/routes.go b/bj_power_wms/internal/handler/routes.go
index 4e02e5a..6976b3c 100644
--- a/bj_power_wms/internal/handler/routes.go
+++ b/bj_power_wms/internal/handler/routes.go
@@ -19,6 +19,13 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
 
 	server.Use(authInterceptor(ctx))
 
+	// 当前登录用户（JWT 鉴权）
+	server.AddRoutes(
+		[]rest.Route{
+			{Method: http.MethodPost, Path: "/api/user/change-password", Handler: changePasswordHandler(ctx)},
+		},
+	)
+
 	// 物料档案
 	server.AddRoutes(
 		[]rest.Route{
diff --git a/bj_power_wms_client/frontend/src/components/PageHelp.vue b/bj_power_wms_client/frontend/src/components/PageHelp.vue
index 2eeee43..b469149 100644
--- a/bj_power_wms_client/frontend/src/components/PageHelp.vue
+++ b/bj_power_wms_client/frontend/src/components/PageHelp.vue
@@ -56,7 +56,7 @@
 </template>
 
 <script setup>
-import { ref } from 'vue'
+import { ref, onMounted, onBeforeUnmount } from 'vue'
 
 defineProps({
   data: { type: Object, default: () => ({ title: '操作说明', overview: '', fields: [] }) }
@@ -64,6 +64,10 @@ defineProps({
 
 const show = ref(false)
 function open() { show.value = true }
+
+// 右上角「帮助」按钮（MainLayout）通过 wms:open-page-help 事件触发当前页帮助抽屉
+onMounted(() => window.addEventListener('wms:open-page-help', open))
+onBeforeUnmount(() => window.removeEventListener('wms:open-page-help', open))
 </script>
 
 <style scoped>
diff --git a/bj_power_wms_client/frontend/src/layouts/MainLayout.vue b/bj_power_wms_client/frontend/src/layouts/MainLayout.vue
index 7496968..f8c3b7c 100644
--- a/bj_power_wms_client/frontend/src/layouts/MainLayout.vue
+++ b/bj_power_wms_client/frontend/src/layouts/MainLayout.vue
@@ -12,6 +12,7 @@ const route = useRoute()
 const router = useRouter()
 
 const user = getUser()
+const userName = computed(() => user?.realName || user?.username || '未登录')
 const pageTitle = computed(() => route.meta?.title || '')
 
 const menus = [
@@ -27,6 +28,19 @@ const menus = [
   { path: '/base-data', title: '基础数据', icon: EditPen }
 ]
 
+// 打开当前页面帮助（各页面 PageHelp 监听 wms:open-page-help 事件弹出抽屉）
+function openHelp() {
+  window.dispatchEvent(new CustomEvent('wms:open-page-help'))
+}
+
+function onUserCmd(cmd) {
+  if (cmd === 'password') {
+    router.push('/change-password')
+  } else if (cmd === 'logout') {
+    onLogout()
+  }
+}
+
 function onLogout() {
   logout()
   ElMessage.success('已退出登录')
@@ -57,8 +71,16 @@ function onLogout() {
         <el-button text type="primary" @click="router.push('/display')">
           <el-icon style="margin-right:4px"><Monitor /></el-icon>免登录大屏
         </el-button>
-        <el-tag effect="plain">{{ user?.realName || user?.username || '未登录' }}</el-tag>
-        <el-button text type="danger" @click="onLogout">退出登录</el-button>
+        <el-button class="help-btn" text @click="openHelp">帮助</el-button>
+        <el-dropdown trigger="click" @command="onUserCmd">
+          <span class="user-name">{{ userName }} <span class="caret">▾</span></span>
+          <template #dropdown>
+            <el-dropdown-menu>
+              <el-dropdown-item command="password">修改密码</el-dropdown-item>
+              <el-dropdown-item divided command="logout">退出登录</el-dropdown-item>
+            </el-dropdown-menu>
+          </template>
+        </el-dropdown>
       </el-header>
       <el-main class="main">
         <router-view />
@@ -83,5 +105,12 @@ function onLogout() {
 }
 .title { font-size: 16px; font-weight: 600; }
 .spacer { flex: 1; }
+.help-btn { font-size: 13px; color: #606266; }
+.user-name {
+  display: inline-flex; align-items: center; gap: 4px; cursor: pointer;
+  font-size: 14px; color: #303133; outline: none; padding: 4px 6px; border-radius: 4px;
+}
+.user-name:hover { color: #1668dc; background: #f2f6fc; }
+.caret { font-size: 10px; color: #909399; }
 .main { background: #f0f2f5; padding: 14px; overflow: auto; }
 </style>
\ No newline at end of file
diff --git a/bj_power_wms_client/frontend/src/pages/ChangePassword.vue b/bj_power_wms_client/frontend/src/pages/ChangePassword.vue
new file mode 100644
index 0000000..0857798
--- /dev/null
+++ b/bj_power_wms_client/frontend/src/pages/ChangePassword.vue
@@ -0,0 +1,63 @@
+<template>
+  <el-card style="max-width:480px;margin-top:20px">
+    <template #header><b>修改我的密码</b></template>
+    <el-alert type="warning" :closable="false" style="margin-bottom:16px"
+      title="密码修改成功后需重新登录" />
+    <el-form :model="form" label-width="100px" @submit.prevent>
+      <el-form-item label="旧密码">
+        <el-input v-model="form.oldPassword" type="password" show-password
+          placeholder="请输入当前密码" />
+      </el-form-item>
+      <el-form-item label="新密码">
+        <el-input v-model="form.newPassword" type="password" show-password
+          placeholder="至少 6 位" />
+      </el-form-item>
+      <el-form-item label="确认新密码">
+        <el-input v-model="form.confirmPassword" type="password" show-password
+          placeholder="请再次输入新密码" />
+      </el-form-item>
+      <el-form-item>
+        <el-button type="primary" :loading="loading" @click="submit">保存</el-button>
+        <el-button @click="reset">重置</el-button>
+      </el-form-item>
+    </el-form>
+  </el-card>
+</template>
+
+<script setup>
+import { reactive, ref } from 'vue'
+import { ElMessage } from 'element-plus'
+import { useRouter } from 'vue-router'
+import { logout } from '../utils/auth'
+import request from '../utils/request'
+
+const router = useRouter()
+const loading = ref(false)
+const form = reactive({ oldPassword: '', newPassword: '', confirmPassword: '' })
+
+async function submit() {
+  if (!form.oldPassword || !form.newPassword) return ElMessage.warning('请填写旧密码和新密码')
+  if (form.newPassword !== form.confirmPassword) return ElMessage.warning('两次输入的新密码不一致')
+  if (form.newPassword.length < 6) return ElMessage.warning('新密码长度至少 6 位')
+  loading.value = true
+  try {
+    await request.post('/user/change-password', {
+      oldPassword: form.oldPassword,
+      newPassword: form.newPassword
+    })
+    ElMessage.success('密码修改成功，请重新登录')
+    logout()
+    router.replace('/login')
+  } catch (e) {
+    /* 错误已由请求拦截器提示 */
+  } finally {
+    loading.value = false
+  }
+}
+
+function reset() {
+  form.oldPassword = ''
+  form.newPassword = ''
+  form.confirmPassword = ''
+}
+</script>
diff --git a/bj_power_wms_client/frontend/src/router/index.js b/bj_power_wms_client/frontend/src/router/index.js
index d366014..2c7e5b3 100644
--- a/bj_power_wms_client/frontend/src/router/index.js
+++ b/bj_power_wms_client/frontend/src/router/index.js
@@ -18,7 +18,8 @@ const routes = [
       { path: 'semi', name: 'Semi', component: () => import('../pages/Semi.vue'), meta: { title: '半成品/成品' } },
       { path: 'package', name: 'Package', component: () => import('../pages/Package.vue'), meta: { title: '包装绑定' } },
       { path: 'ledger', name: 'Ledger', component: () => import('../pages/Ledger.vue'), meta: { title: '备料台账' } },
-      { path: 'base-data', name: 'BaseData', component: () => import('../pages/BaseData.vue'), meta: { title: '基础数据' } }
+      { path: 'base-data', name: 'BaseData', component: () => import('../pages/BaseData.vue'), meta: { title: '基础数据' } },
+      { path: 'change-password', name: 'ChangePassword', component: () => import('../pages/ChangePassword.vue'), meta: { title: '修改密码' } }
     ]
   },
   { path: '/:pathMatch(.*)*', redirect: '/' }
diff --git a/bj_power_workstation/etc/bj_power_workstation.yaml b/bj_power_workstation/etc/bj_power_workstation.yaml
index 81fe35f..11fda94 100644
--- a/bj_power_workstation/etc/bj_power_workstation.yaml
+++ b/bj_power_workstation/etc/bj_power_workstation.yaml
@@ -24,9 +24,10 @@ Internal:
 Sim:
   Enable: true
 
-# 工位配置：Code 留空则前端可自选工位；ScrewCount 为本工位需拧紧的螺丝颗数
+# 工位配置：StationNo 固定本终端工位号（1~12，仅允许运维改配置后重启生效，工人无法在前端修改）；
+# ScrewCount 为本工位需拧紧的螺丝颗数
 Station:
-  Code: ""
+  StationNo: 1
   ScrewCount: 10
 
 # 工艺文件 PDF 本地预缓存目录（留空关闭缓存）
diff --git a/bj_power_workstation/frontend/index.html b/bj_power_workstation/frontend/index.html
index 321a4e9..aca9ac6 100644
--- a/bj_power_workstation/frontend/index.html
+++ b/bj_power_workstation/frontend/index.html
@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>北京动力 · 工位终端</title>
+    <title>工位终端</title>
   </head>
   <body>
     <div id="app"></div>
diff --git a/bj_power_workstation/frontend/src/views/Login.vue b/bj_power_workstation/frontend/src/views/Login.vue
index 42644ed..c7abc5a 100644
--- a/bj_power_workstation/frontend/src/views/Login.vue
+++ b/bj_power_workstation/frontend/src/views/Login.vue
@@ -27,16 +27,7 @@
       </div>
       <div class="field">
         <span class="lab">工位</span>
-        <el-select
-          v-if="!fixedStation"
-          v-model="stationNo"
-          size="large"
-          class="station-el"
-          placeholder="请选择工位"
-        >
-          <el-option v-for="n in 12" :key="n" :label="'工位 ' + n" :value="n" />
-        </el-select>
-        <span v-else class="station-fixed">工位 {{ fixedStation }}</span>
+        <span class="station-fixed">{{ fixedStation ? '工位 ' + fixedStation : '工位加载中…' }}</span>
       </div>
 
       <el-button class="btn-login" type="primary" size="large" :loading="loading" @click="submit">
@@ -55,22 +46,20 @@ import { ElMessage } from 'element-plus'
 import { getConfig, login } from '../api'
 import { setAuth } from '../utils/request'
 
-const STATION_KEY = 'ws_station_no'
 const router = useRouter()
 const username = ref('')
 const password = ref('')
-const stationNo = ref(null)
 const fixedStation = ref(0)
 const loading = ref(false)
 
+// 工位由服务端配置文件固定（1~12），一个工位一个终端，终端不允许修改工位
 onMounted(async () => {
   try {
     const cfg = await getConfig()
     if (cfg?.stationNo > 0) fixedStation.value = cfg.stationNo
   } catch {
-    // 网络异常时忽略，工位仍可自选
+    // 网络异常时保留 0，登录会提示配置未加载
   }
-  stationNo.value = fixedStation.value || Number(localStorage.getItem(STATION_KEY)) || null
 })
 
 async function submit() {
@@ -78,9 +67,8 @@ async function submit() {
     ElMessage.warning('请输入账号和密码')
     return
   }
-  const sn = fixedStation.value || stationNo.value
-  if (!sn) {
-    ElMessage.warning('请选择工位')
+  if (!fixedStation.value) {
+    ElMessage.warning('工位配置未加载，请检查服务端配置文件后重启')
     return
   }
   loading.value = true
@@ -88,10 +76,9 @@ async function submit() {
     const data = await login({
       username: username.value,
       password: password.value,
-      stationNo: sn
+      stationNo: fixedStation.value
     })
     setAuth(data.accessToken, data.user)
-    localStorage.setItem(STATION_KEY, String(sn))
     ElMessage.success('登录成功')
     router.push('/main')
   } catch (e) {
diff --git a/bj_power_workstation/frontend/src/views/Main.vue b/bj_power_workstation/frontend/src/views/Main.vue
index ddf77d9..2c0257f 100644
--- a/bj_power_workstation/frontend/src/views/Main.vue
+++ b/bj_power_workstation/frontend/src/views/Main.vue
@@ -4,15 +4,10 @@
     <header class="top-bar">
       <div class="brand">工位终端</div>
 
-      <div v-if="!fixedStation" class="dock-select">
+      <!-- 工位固定：由服务端配置文件加载（1~12），终端不允许修改 -->
+      <div class="dock-select">
         <span class="dock-lab">工位</span>
-        <el-select v-model="stationNo" size="large" class="dock-el">
-          <el-option v-for="n in 12" :key="n" :label="'工位 ' + n" :value="n" />
-        </el-select>
-      </div>
-      <div v-else class="dock-select">
-        <span class="dock-lab">工位</span>
-        <span class="dock-fixed">{{ fixedStation }}</span>
+        <span class="dock-fixed">{{ stationNo ? '工位 ' + stationNo : '…' }}</span>
       </div>
 
       <div class="spacer"></div>
@@ -169,9 +164,15 @@
     <!-- 操作说明帮助 -->
     <PageHelp :data="helpWorkstation" />
 
-    <!-- 我的工作量弹窗（块6） -->
-    <el-dialog v-model="workload.show" title="我的工作量" width="720px" top="8vh">
+    <!-- 我的工作量弹窗（块6）：当前登录人所有工位的工作，默认当前工位，可按工位/时间筛选 -->
+    <el-dialog v-model="workload.show" title="我的工作量" width="760px" top="8vh">
       <el-form inline>
+        <el-form-item label="工位">
+          <el-select v-model="workload.stationNo" size="large" style="width:160px">
+            <el-option label="全部工位" :value="0" />
+            <el-option v-for="n in 12" :key="n" :label="'工位 ' + n" :value="n" />
+          </el-select>
+        </el-form-item>
         <el-form-item label="日期范围">
           <el-date-picker
             v-model="workload.range"
@@ -192,6 +193,7 @@
         <el-col :span="6"><el-card shadow="never" class="wl-stat"><div class="wl-label">总合格率</div><div class="wl-value">{{ workload.summary.rate }}</div></el-card></el-col>
       </el-row>
       <el-table :data="workload.rows" border size="small" max-height="360">
+        <el-table-column prop="stationNo" label="工位" width="90" align="center" />
         <el-table-column prop="date" label="日期" width="110" />
         <el-table-column prop="processCode" label="工序" width="80" align="center" />
         <el-table-column prop="processName" label="工序名" min-width="130" show-overflow-tooltip />
@@ -209,7 +211,7 @@
 </template>
 
 <script setup>
-import { computed, onBeforeUnmount, onMounted, reactive, ref, watch } from 'vue'
+import { computed, onBeforeUnmount, onMounted, reactive, ref } from 'vue'
 import { useRouter } from 'vue-router'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import PageHelp from '../components/PageHelp.vue'
@@ -227,30 +229,23 @@ import {
 } from '../api'
 import { clearAuth, getUser } from '../utils/request'
 
-const STATION_KEY = 'ws_station_no'
 const router = useRouter()
 const user = getUser()
 
-// ---------- 工位配置（固定工位号锁定，否则 1~12 自选，存 localStorage） ----------
-const fixedStation = ref(0)
-const stationNo = ref(Number(localStorage.getItem(STATION_KEY)) || 1)
+// ---------- 工位配置（固定工位号：由服务端 yaml 配置在启动时加载，终端不允许修改） ----------
+const stationNo = ref(0)
 const screwCount = ref(0)
 
 async function loadConfig() {
   try {
     const cfg = await getConfig()
-    if (cfg?.stationNo > 0) fixedStation.value = cfg.stationNo
+    if (cfg?.stationNo > 0) stationNo.value = cfg.stationNo
     if (cfg?.screwCount > 0) screwCount.value = cfg.screwCount
   } catch {
     /* 配置加载失败静默 */
   }
 }
 
-watch(stationNo, (v) => {
-  localStorage.setItem(STATION_KEY, String(v))
-  refreshAll()
-})
-
 // ---------- 当前任务（MES） ----------
 const task = ref(null)
 const flowName = computed(() => task.value?.flow?.name || '-')
@@ -534,15 +529,17 @@ async function manualFlush() {
   }
 }
 
-// ---------- 我的工作量（块6） ----------
+// ---------- 我的工作量（块6）：当前登录人所有工位的工作，可筛工位（默认当前工位）/时间 ----------
 const workload = reactive({
   show: false,
+  stationNo: 0, // 0=全部工位；默认打开时设为当前工位
   range: null,
   rows: [],
   summary: { doneCount: 0, okCount: 0, ngCount: 0, rate: '-' }
 })
 
 function openWorkload() {
+  if (!workload.stationNo) workload.stationNo = stationNo.value // 默认当前工位
   workload.show = true
   loadWorkload()
 }
@@ -551,6 +548,7 @@ async function loadWorkload() {
   const [from, to] = workload.range || []
   const params = {
     operator: user.name || user.username || '',
+    stationNo: workload.stationNo || 0, // 0=全部工位
     from: from || '',
     to: to || ''
   }
@@ -591,7 +589,6 @@ function logout() {
 
 onMounted(async () => {
   await loadConfig()
-  if (fixedStation.value) stationNo.value = fixedStation.value
   refreshAll()
   focusScan()
   window.addEventListener('focus', focusScan)
diff --git a/bj_power_workstation/internal/config/config.go b/bj_power_workstation/internal/config/config.go
index aedcc35..7cc939a 100644
--- a/bj_power_workstation/internal/config/config.go
+++ b/bj_power_workstation/internal/config/config.go
@@ -31,10 +31,11 @@ type SqliteConfig struct {
 	Path string `json:",default=workstation.db"`
 }
 
-// StationConfig 工位配置：可从配置文件指定固定工位号（1~12），留空则由终端自选
+// StationConfig 工位配置：启动时由 yaml 加载到内存，固定本终端工位号（1~12）。
+// 一个工位一个终端，终端不允许修改工位；变更工位只能改配置并重启服务。
 type StationConfig struct {
-	Code       string `json:",optional"` // 固定工位号（如 "3"）；留空则由终端自选 1~12
-	ScrewCount int    `json:",default=10"` // 本工位需拧紧的螺丝颗数（进度 9/10 用）
+	StationNo  int `json:",default=1"`  // 固定工位号（1~12），启动时校验范围
+	ScrewCount int `json:",default=10"` // 本工位需拧紧的螺丝颗数（进度 9/10 用）
 }
 
 // PdfCacheConfig 工艺文件 PDF 本地预缓存目录
diff --git a/bj_power_workstation/internal/handler/auth.go b/bj_power_workstation/internal/handler/auth.go
index 0d9b3e1..7ececc2 100644
--- a/bj_power_workstation/internal/handler/auth.go
+++ b/bj_power_workstation/internal/handler/auth.go
@@ -5,10 +5,7 @@ import (
 	"strings"
 	"time"
 
-	"bj_power_workstation/internal/auth"
 	"bj_power_workstation/internal/svc"
-
-	"golang.org/x/crypto/bcrypt"
 )
 
 func healthHandler(ctx *svc.ServiceContext) http.HandlerFunc {
@@ -60,11 +57,11 @@ func loginHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 }
 
 // configHandler GET /api/config 返回工位配置：
-// 固定工位号 stationNo（Station.Code 为空则前端可自选 1~12）、本工位需拧紧的螺丝颗数。
+// 固定工位号 stationNo（1~12，由 yaml 配置在启动时加载，终端不可修改）、本工位需拧紧的螺丝颗数。
 func configHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		ok(w, map[string]any{
-			"stationNo":  atoi(ctx.Config.Station.Code, 0),
+			"stationNo":  ctx.Config.Station.StationNo,
 			"screwCount": ctx.Config.Station.ScrewCount,
 		})
 	}
diff --git a/bj_power_workstation/internal/handler/proxy.go b/bj_power_workstation/internal/handler/proxy.go
index 184a134..2722d81 100644
--- a/bj_power_workstation/internal/handler/proxy.go
+++ b/bj_power_workstation/internal/handler/proxy.go
@@ -34,17 +34,21 @@ func taskCurrentHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 	}
 }
 
-// workloadHandler 代理 MES GET /api/internal/station/workload?operator=&from=&to=（块6）。
-// 工位终端「我的工作量」仅查询当前登录人数据；MES 响应体原样透传。
+// workloadHandler 代理 MES GET /api/internal/station/workload?operator=&stationNo=&from=&to=（块6）。
+// 工位终端「我的工作量」查询当前登录人全部工位的工作，stationNo 为空=全部工位；MES 响应体原样透传。
 func workloadHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		operator := strings.TrimSpace(r.URL.Query().Get("operator"))
+		stationNo := strings.TrimSpace(r.URL.Query().Get("stationNo"))
 		from := strings.TrimSpace(r.URL.Query().Get("from"))
 		to := strings.TrimSpace(r.URL.Query().Get("to"))
 		params := url.Values{}
 		if operator != "" {
 			params.Set("operator", operator)
 		}
+		if stationNo != "" {
+			params.Set("stationNo", stationNo)
+		}
 		if from != "" {
 			params.Set("from", from)
 		}
diff --git a/bj_power_workstation/internal/tightening/tightening.go b/bj_power_workstation/internal/tightening/tightening.go
index 6441b7e..d95f8c1 100644
--- a/bj_power_workstation/internal/tightening/tightening.go
+++ b/bj_power_workstation/internal/tightening/tightening.go
@@ -28,11 +28,9 @@ type MockSource struct {
 	dockCode string // 模拟枪挂载的工位
 }
 
-// NewMockSource dockCode 为空时回落到 DOCK01。
-func NewMockSource(db *store.Store, mc *mes.Client, dockCode string) *MockSource {
-	if dockCode == "" {
-		dockCode = "DOCK01"
-	}
+// NewMockSource 模拟枪挂载在固定工位（stationNo 1~12），DOCK 编码为 DOCK01~DOCK12。
+func NewMockSource(db *store.Store, mc *mes.Client, stationNo int) *MockSource {
+	dockCode := fmt.Sprintf("DOCK%02d", stationNo)
 	return &MockSource{db: db, mes: mc, dockCode: dockCode}
 }
 
diff --git a/bj_power_workstation/main.go b/bj_power_workstation/main.go
index 63605ac..9e11e46 100644
--- a/bj_power_workstation/main.go
+++ b/bj_power_workstation/main.go
@@ -32,6 +32,13 @@ func main() {
 	var c config.Config
 	conf.MustLoad(*configFile, &c)
 
+	// 工位号固定（1~12）：一个工位一个终端，终端不允许修改工位。
+	// 启动时加载到内存并强校验，变更工位只能改配置文件后重启服务。
+	if c.Station.StationNo < 1 || c.Station.StationNo > 12 {
+		panic(fmt.Sprintf("Station.StationNo 必须在 1~12 之间，当前配置为 %d（工位由配置文件固定，请修改 yaml 后重启）", c.Station.StationNo))
+	}
+	logx.Infof("固定工位号: %d, 本工位螺丝颗数: %d", c.Station.StationNo, c.Station.ScrewCount)
+
 	staticFS, err := fs.Sub(webFS, "web/static")
 	if err != nil {
 		panic(fmt.Sprintf("加载内嵌前端资源失败: %v", err))
@@ -59,7 +66,7 @@ func main() {
 
 	// 内置模拟拧紧枪数据源（Sim.Enable=true 时启动；正式丹尼科尔协议接入后由 NetSource 替代）
 	if c.Sim.Enable {
-		go tightening.NewMockSource(st, mc, c.Station.Code).Start(rootCtx)
+		go tightening.NewMockSource(st, mc, c.Station.StationNo).Start(rootCtx)
 	}
 
 	// 工艺文件 PDF 本地预缓存
diff --git a/bj_power_workstation/web/static/index.html b/bj_power_workstation/web/static/index.html
index a8ba66b..16aaf76 100644
--- a/bj_power_workstation/web/static/index.html
+++ b/bj_power_workstation/web/static/index.html
@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>北京动力 · 工位终端</title>
+    <title>工位终端</title>
     <script type="module" crossorigin src="/assets/index-CpYENLUl.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Dz4RGjfJ.css">
   </head>
diff --git a/操作手册.md b/操作手册.md
index e69de29..4c7fa6a 100644
--- a/操作手册.md
+++ b/操作手册.md
@@ -0,0 +1,136 @@
+# MES 产线控制 · 操作手册
+
+> 面向产线管理人员、生产操作员、质检员、库房保管员。本文档说明「做什么、按什么顺序做、每个字段怎么填」。页面右上角「帮助」按钮或点击页面标题，也可弹出对应页面的在线帮助。
+
+## 一、系统概述
+
+MES 是装配线的控制中心：从「产品类型 → 工单 → 物料清单 → 日排产 → 备料 → 工位组合下发 → 工位报工 → 完工追溯」一条链路串起整条产线。
+
+产线共 12 个固定工位（工位1 ~ 工位12），设备只有「扫码枪 + 拧紧枪」，其余为人工操作。传送带单向流转（工位 1 → 2 → … → 12），不会往回走。
+
+**统一概念**（避免混淆）：
+- **工位**：产线固定的 12 个物理位置，编号 1~12。
+- **工艺流程**：服务于某个固定工位的作业指导（含工位号、PDF、工序步骤）。一个工位只能有一个「启用」的工艺流程。
+- **工序步骤**：工艺流程内的具体作业/采集项（如 装配完成、拧紧扭矩）。
+
+五个系统分工：
+
+| 系统 | 用途 |
+|------|------|
+| MES（本项目） | 生产主数据、工单、排产、工艺流程、报工、追溯 |
+| WMS | 仓库库存、出入库、物料档案（独立数据库） |
+| WMS 客户端 | 库房出/入库操作台（带扫码枪） |
+| 工位终端 | 12 个工位的触控一体机，扫码报工、采集拧紧数据 |
+| 看板 | 厂房大屏，展示产线状态（数据来自 MES） |
+
+---
+
+## 二、登录
+
+1. 浏览器打开 MES 地址，输入账号密码登录。
+2. 内置超级管理员：`admin` / `123456`。
+3. 密码要求：至少 6 位，不能是纯数字。若为纯数字密码，登录时会提示「安全级别低」，但仍可继续登录，建议登录后立即修改。
+4. 修改密码：点击右上角自己的用户名 → 「修改密码」。
+
+---
+
+## 三、主数据操作顺序（首次上线务必按顺序）
+
+1. **产品类型**：建立「生产什么」的档案（名称 + 编码）。
+2. **工艺流程**：为每个工位维护流程（选工位号）+ 工序步骤 + 考核标准 + 作业指导 PDF；**启用后自动绑定到该工位**。
+3. **关联工位**：查看 12 个工位的绑定总览（绑定由工艺流程自动建立），可改工位名称。
+4. **工单管理**：建工单，勾选要经过的**工位组合**。
+5. **物料清单**：给工单对应的产品配置 BOM。
+6. **日排产**：安排哪天生产多少（合计不得超过工单总数）。
+7. **备料单**：按日排产自动算料，供仓库备料。
+8. **工位组合下发**：工件上线时把工位组合下发给 PLC。
+9. **手动报工 / 工位终端**：选工位 → 自动载入该工位工序步骤 → 采集数据、判合格。
+10. **工件追溯 / 绩效报表**：查看结果。
+
+---
+
+## 四、菜单操作说明
+
+### 1. 产品类型
+- 维护产品的名称、编码、类别、启用状态、备注。
+- 编码自动生成（`PROD-YYYYMMDD-序号`），可修改。
+- **关系**：产品类型 ↔ 工单 = 1 对 N（同型号可多工单）；产品类型 ↔ 物料清单 = 按产品编码 1 对 1；备料单由「日排产 × BOM」间接产生。
+- 产品编码与 WMS 是两套系统、互相解耦，成品入库时由操作人员把该编码**手动录入 WMS** 对齐。
+
+### 2. 工单管理
+- **新建工单**：自动生成工单号；选择产品类型（未选时显示"请选择"）；填产品编码/名称、数量；**勾选工位组合**。
+- **查询**：支持 工单号 / 产品编码 / 产品名称（模糊）/ 状态 组合筛选。
+- **工位组合**：勾选本工单要经过的工位（1~12），系统自动按 `1 → 2 → … → 12` 顺序执行。全选 = 全部工位；只走部分工位就只勾那几道。半成品再上线时，可只勾「漏掉的工位」完成闭环。
+- **状态流转**：列表操作列「状态」按钮，按 已创建 → 发布 → 开工 → 完工 推进。
+- **删除**：仅「已创建 / 待排产 / 已发布」且无排产、备料、生产数据的工单可删除（操作列「删除」按钮）。
+- 工单号贯穿备料、报工、追溯、日志全链路。
+
+### 3. 日排产
+- 按「工单号 + 日期」排哪天生产多少。
+- 同一工单多天排产的**合计数量不能超过工单总数量**（系统强校验，已修复重复累计 bug）。
+- 已完成/关闭的工单不能再排产；某天已有完工数量的排产不能改数量。
+- 排产是仓库备料的触发依据。
+
+### 4. 物料清单（BOM）
+- 维护「生产 1 台产品需要哪些物料、各用多少」，按产品编码归类。
+- **与 WMS 的关系**：本页只维护「产品由哪几种料、各用几个」；物料名称/规格/库存统一在 WMS 的「物料档案」维护。两系统靠**物料编码**对齐。
+- **编码对应**：本页「物料编码」必须与 WMS 物料档案的「编码」完全一致，否则仓库无法备料/出库。
+- **管理方式**：精密件 = 按 SN 逐件；结构件 = 按批次。
+- 添加物料：点「添加物料」→ 在弹窗里选产品编码、填物料信息、保存。
+
+### 5. 备料单
+- ① 先到「日排产」排好某天计划；② 回本页选该「日期」；③ 点「按日排产生成备料」，系统按各产品 BOM 自动算料生成备料单；④ 仓库据此备料出库。
+
+### 6. 工位组合下发
+- 把工单/工件的**工位组合**写入西门子 S7-1214 PLC，传送带据此只停靠勾选的工位。
+- 工件上线、或半成品补工位时，人工在此下发。
+- 约束：上一条未收到完成信号，不下发下一条，防止串序。
+
+### 7. 工艺流程
+- 每个流程服务于一个**固定工位（1~12）**，一个工位可有多个流程版本，但**只能有一个「启用」的流程**。
+- 流程内容：名称、工位号、状态（启用/停用）、作业指导 PDF、**工序步骤**。
+- **工序步骤**：每步设「采集方式」（拧紧枪自动 / 手填 / 仅记录）和「考核标准」。
+- **考核标准**：在步骤行点「考核标准」弹出独立窗口，设指标名/单位/逻辑/目标值或区间；报工时按此自动判合格/不合格。未设标准 = 仅记录不判定。
+- **启用/停用**：列表操作列点「启用/停用」。**启用 = 自动绑定到该工位；停用 = 自动解绑该工位**。同一工位已有启用流程时，新流程无法启用，需先停用旧流程。
+
+### 8. 关联工位
+- 产线固定 12 个工位，本页是工位总览：查看每个工位绑定的工艺流程、修改工位名称。
+- 绑定关系由「工艺流程」页自动建立（流程选工位号并启用即绑定），本页不需要手动选流程。
+
+### 9. 拧紧查询
+- 查询/补录拧紧数据（扭矩、角度、结果、操作人），用于质量追溯。
+
+### 10. 手动报工
+- 选**工位**、扫工件 SN → 系统自动载入该工位启用工艺流程的**工序步骤** → 逐条填采集值 → 提交。
+- 系统按考核标准自动判定合格/不合格（OK/NG）。
+- 若提示未配置工序步骤：请到「工艺流程」为该工位启用流程并维护工序步骤。
+
+### 11. 工件追溯
+- 输入 SN 查完整履历：各工位时间线、步骤考核数据、拧紧记录、用了哪些批次/SN。
+
+### 12. 绩效报表
+- 按 操作人 × 日期 × 工位 统计完成数、合格数、NG 数、合格率。
+
+### 13. 巡检终端
+- 检验员/线长用平板或电脑做：开工签到、工位点检、过程巡检、完工确认、异常上报、记录查看。
+
+### 14. 操作日志
+- 记录所有关键操作，按工单号、操作人、类型可追溯，只读。
+
+### 15. 角色权限管理
+- 管理用户/角色/权限。**角色不可删除、编辑；管理员至少保留一个**。
+
+---
+
+## 五、常见问题
+
+| 问题 | 解决 |
+|------|------|
+| 工艺流程无法启用 | 该工位已存在其他启用的流程，先停用旧流程 |
+| 停用流程后工位没流程了 | 正常，停用即解绑；再到「工艺流程」为该工位启用另一个流程 |
+| 关联工位显示"未绑定" | 到「工艺流程」为该工位号启用一个流程 |
+| 备料/出库提示物料不存在 | 物料清单里的「物料编码」与 WMS 物料档案不一致，核对编码 |
+| 报工页没有采集框 | 该工位未启用流程，或流程没维护工序步骤；到「工艺流程」处理 |
+| 排产保存失败 | 多天排产合计超过工单总数量，或该工单已完成/关闭 |
+| 工单删不掉 | 仅「已创建/待排产/已发布」且无排产、备料、生产数据的工单可删除 |
+| 修改密码后要重新登录 | 正常现象，密码变更即失效当前登录 |
diff --git a/问题修复记录.md b/问题修复记录.md
index 2d3a8c2..89fc2dc 100644
--- a/问题修复记录.md
+++ b/问题修复记录.md
@@ -511,3 +511,40 @@ GET /api/internal/process-card/list
 ```
 
 
+
+
+一、
+mes --- > 工艺流程----> 工位管理 ， 1、状态不要用 ENABLED 等英文。2、一个工位只能 有一个 启用的 工艺流程。  这个启用，分两个维度，1、工艺流程是否启动，第二工位管理有没有启用这个工艺流程。我建议简单化，把第二个去掉。所以逻辑就成了，一个工位只能绑定一个工艺流程即可。
+另外，工艺流程里面 也有英文 ACTIVE ，请改成中文
+另外，工位管理，改为关联工位。因为工位数量是不变的
+另外，请考虑，工艺流程、工序，叫法是否合适，如果合适，就保持不变即可。
+
+二、工艺流程 ---> 编辑工艺流程
+1、采集方式：在帮助文档里面，给一个详细说明
+2、考核标准：在帮助文档里面，给一个详细说明，在什么地方用，如何收集数据等。
+3、菜单，工艺参数 ，和，工艺流程 里面的  步骤模版，重复了。我理解对吗，我建议，去除 工艺参数。 并提出建议：编辑工艺流程--》步骤模板---》考核标准  ，点击多个考核标准时，都出现在下面，不好，不知道哪个是哪个，也没有一个单独的保存按钮。你再设计设计。
+
+4、工位绑定，倒是可以从工艺流程里面，拿出来，将来好分配菜单权限。
+
+
+三、我现在仍然不知道如何操作。原因：1、问号帮助文档，内容还是不够详细。2、缺少：操作手册.md
+
+
+四、PLC工序下发，我们聊过，菜单，做什么用的，我仍然没明白。帮助文档里面，也没有业务说明。你再捋捋，弄清楚些
+
+五、帮助按钮，太大了。放到右上角，是不是更好？ 右上角优化，点击 登录人名称 例如“系统管理员”，修改密码，即可。修改密码，按钮，不要了。 帮助文档 点击标题 弹出来（不是左边菜单，是右边大模块左上角的标题，例如 工单管理）
+
+
+五、工单管理---> 维护工序组合123456789101112 ，这也太潦草了。 如何区分 11 还是 11 。要求，1、必须按顺序执行，比如，可以是123不能是 132，传送带不会往回走。要求2，可以选择 启动或未启动的 工序，如果工序禁用，这个工位就不走。 另外说明，当 操作 一个工艺流程，让他变成 停用时，必须先跟工位解绑。 同理，工位绑定 工艺流程，必须是 启用的。
+另外，工艺流程 菜单，里面的 操作列，加上 按钮 “启用”“停用”。同理，同操作习惯 工单管理也加上 状态操作，在操作里面
+
+
+六、菜单：工单管理，里面有个 日排产 。和 菜单： 日排产，重复了，菜单责任划分不明确。应该去除 前者。
+
+七、添加物料清单，跟 wms什么关系，帮助也没说清楚。 编码如何对应。等等 。
+操作方式，非常错误。 选择：产品编码， 点击 添加物料 。列表，又没有 产品编码 。非常反人类。禁止这种 标题选择添加，有病吗，你的设计。添加物料清单，就好好添加，在选择框里面选择 产品编码。 你有病吗
+备料单---》按日排产生成备料， 不明不白，你有病吗。是互联网操作方式吗。
+
+
+
+
diff --git a/问题记录.md b/问题记录.md
index 12b81fd..aa9dcb7 100644
--- a/问题记录.md
+++ b/问题记录.md
@@ -1,38 +1,32 @@
-一、
-mes --- > 工艺流程----> 工位管理 ， 1、状态不要用 ENABLED 等英文。2、一个工位只能 有一个 启用的 工艺流程。  这个启用，分两个维度，1、工艺流程是否启动，第二工位管理有没有启用这个工艺流程。我建议简单化，把第二个去掉。所以逻辑就成了，一个工位只能绑定一个工艺流程即可。
-另外，工艺流程里面 也有英文 ACTIVE ，请改成中文
-另外，工位管理，改为关联工位。因为工位数量是不变的
-另外，请考虑，工艺流程、工序，叫法是否合适，如果合适，就保持不变即可。
 
-二、工艺流程 ---> 编辑工艺流程
-1、采集方式：在帮助文档里面，给一个详细说明
-2、考核标准：在帮助文档里面，给一个详细说明，在什么地方用，如何收集数据等。
-3、菜单，工艺参数 ，和，工艺流程 里面的  步骤模版，重复了。我理解对吗，我建议，去除 工艺参数。 并提出建议：编辑工艺流程--》步骤模板---》考核标准  ，点击多个考核标准时，都出现在下面，不好，不知道哪个是哪个，也没有一个单独的保存按钮。你再设计设计。
-
-4、工位绑定，倒是可以从工艺流程里面，拿出来，将来好分配菜单权限。
-
-
-三、我现在仍然不知道如何操作。原因：1、问号帮助文档，内容还是不够详细。2、缺少：操作手册.md
-
-
-四、PLC工序下发，我们聊过，菜单，做什么用的，我仍然没明白。帮助文档里面，也没有业务说明。你再捋捋，弄清楚些
-
-五、帮助按钮，太大了。放到右上角，是不是更好？ 右上角优化，点击 登录人名称 例如“系统管理员”，修改密码，即可。修改密码，按钮，不要了。 帮助文档 点击标题 弹出来（不是左边菜单，是右边大模块左上角的标题，例如 工单管理）
-
-
-五、工单管理---> 维护工序组合123456789101112 ，这也太潦草了。 如何区分 11 还是 11 。要求，1、必须按顺序执行，比如，可以是123不能是 132，传送带不会往回走。要求2，可以选择 启动或未启动的 工序，如果工序禁用，这个工位就不走。 另外说明，当 操作 一个工艺流程，让他变成 停用时，必须先跟工位解绑。 同理，工位绑定 工艺流程，必须是 启用的。
-另外，工艺流程 菜单，里面的 操作列，加上 按钮 “启用”“停用”。同理，同操作习惯 工单管理也加上 状态操作，在操作里面
-
-
-六、菜单：工单管理，里面有个 日排产 。和 菜单： 日排产，重复了，菜单责任划分不明确。应该去除 前者。
-
-七、添加物料清单，跟 wms什么关系，帮助也没说清楚。 编码如何对应。等等 。
-操作方式，非常错误。 选择：产品编码， 点击 添加物料 。列表，又没有 产品编码 。非常反人类。禁止这种 标题选择添加，有病吗，你的设计。添加物料清单，就好好添加，在选择框里面选择 产品编码。 你有病吗
-备料单---》按日排产生成备料， 不明不白，你有病吗。是互联网操作方式吗。
+一、菜单：工单管理
+1、新建工单， 产品类型 选择框，用户未选择时， 选择框显示“请选择”。所有选择框，都应如此。
+2、工单，不能删除吗。 满足某些条件时，应该可以删除。请考虑一下
+3、查询条件，多一些，比如：产品编码、产品名称 模糊查询
+4、新建工单、工序组合，是不是应该是  工位 ？ 你看看，怎么更合适
 
 
 
+二、菜单： 工艺流程
+1、名称起的有些不合适： 工艺流程、 流程名称叫 “工序1_默认” ，流程，和工序，是不一样的。不能叫工序。原设计，一个流程包含多个序
+2、编辑工艺流程 ---> 工序编号 ? 应该是工位编码吧，固定 12个。认真审核，名字统一。
+3、编辑工艺流程 ---> 步骤模板 ?   工序步骤吧。 你好好统一一下，现在非常容易混淆。 比如，去除 工艺  概念 ？ 去除 工序 概念。你好好考虑
+
+三、菜单： PLC工序下发
+这个全人工操作，挺好的。名称变一下，更符合业务场景，操作人员更容易理解。见名知意。
 
 
 
+四、菜单： 日排产
+工单号：WO1787966513636 ， 计划数量 总和，超出了 工单的 工件 数量。是个bug
+
+
+五、菜单： 产品类型
+帮助文档，说清楚，和工单、物料清单、备料单、如何分工，几对几关系，有没有强约束，等。 相关菜单，也要把这些关系写清楚。 如果有和wms关联的，更要说清楚。
+
+
+
+整体建议：
+菜单，能不能，分分类。包括 wms，先优化，后分类。 仅思考，判定是否合适，给方案。
+