From 239065a7d326830a820960b9f35d702efda18e2b Mon Sep 17 00:00:00 2001
From: zhanghao <774378400@qq.com>
Date: Tue, 18 Aug 2026 11:32:34 +0800
Subject: [PATCH 1/4] =?UTF-8?q?docs:=20=E8=A1=A5=E5=85=85=E4=BB=BB?=
 =?UTF-8?q?=E5=8A=A1=E6=97=A5=E5=BF=97=E4=B8=8E=E6=9C=BA=E6=A2=B0=E8=87=82?=
 =?UTF-8?q?=E8=8A=82=E7=82=B9=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/utils/robotDevice.js                      |  2 +
 .../flow/components/TaskExecutionLog.vue      | 94 +++++++++++++++++++
 src/views/flow/config.js                      |  4 +
 src/views/inspection/runTask/index.vue        |  3 +
 .../intelligenceTest/runningTask/index.vue    | 17 +++-
 .../intelligenceTest/runningTask/task-log.vue | 87 +++++++++++++----
 6 files changed, 185 insertions(+), 22 deletions(-)

diff --git a/src/utils/robotDevice.js b/src/utils/robotDevice.js
index 6890543..7117333 100644
--- a/src/utils/robotDevice.js
+++ b/src/utils/robotDevice.js
@@ -21,6 +21,8 @@ export const DEVICE_KIND_BY_ACTION = Object.freeze({
   AGV_MOVE_TO_STATION: DEVICE_KIND.AGV,
   ARM_MOVE_TO_POINT: DEVICE_KIND.ARM,
   ARM_MOVE_TO_J: DEVICE_KIND.ARM,
+  // 机械臂使能/去使能虽然没有运动参数，仍必须绑定 ARM 设备，
+  // 这样运行前的资源校验和设备下拉筛选才能为节点分配正确的机械臂终端。
   ARM_ENABLE: DEVICE_KIND.ARM,
   ARM_DISABLE: DEVICE_KIND.ARM,
   TOUCH: DEVICE_KIND.ARM,
diff --git a/src/views/flow/components/TaskExecutionLog.vue b/src/views/flow/components/TaskExecutionLog.vue
index f4bab02..1b40a16 100644
--- a/src/views/flow/components/TaskExecutionLog.vue
+++ b/src/views/flow/components/TaskExecutionLog.vue
@@ -1,10 +1,14 @@
 <template>
   <div ref="messageContainer" class="task-log" :style="{ height: `${height}px` }">
+    <!-- 每条日志由固定宽度的时间列和自适应内容列组成；没有后端 ID 时使用数组下标兜底。 -->
     <div v-for="(log, index) in list" :key="log.id || index" class="task-log__item">
       <div class="task-log__time">{{ formatDate(log.logTime) }}</div>
       <div class="task-log__body">
         <div class="task-log__content">{{ log.logContent }}</div>
+
+        <!-- 只有 analysisOf 能确认是音频或视频分析日志时，才展示结构化分析结果。 -->
         <div v-if="analysisOf(log)" class="task-log__analysis">
+          <!-- 标题行展示分析类型、执行状态、模型名称和耗时；缺失字段不会留下空占位。 -->
           <div class="task-log__analysis-heading">
             <el-tag :type="analysisOf(log).tagType" size="small">
               {{ analysisOf(log).title }} · {{ analysisOf(log).statusLabel }}
@@ -16,6 +20,8 @@
               耗时：{{ analysisOf(log).timingMs }}ms
             </span>
           </div>
+
+          <!-- 常用结果采用四列摘要，便于快速比较；详细扩展字段放到下方 JSON 区域。 -->
           <div class="task-log__analysis-grid">
             <div v-if="analysisOf(log).label" class="task-log__analysis-field">
               <span>识别结果</span>
@@ -37,14 +43,20 @@
           <div v-if="analysisOf(log).summary" class="task-log__analysis-summary">
             {{ analysisOf(log).summary }}
           </div>
+
+          <!-- 关键事件可能来自模型输出数组，analysisOf 已限制最多展示前 20 条。 -->
           <div v-if="analysisOf(log).events.length" class="task-log__analysis-events">
             <div class="task-log__analysis-label">关键事件</div>
             <div v-for="(event, eventIndex) in analysisOf(log).events" :key="eventIndex" class="task-log__analysis-event">
               {{ event }}
             </div>
           </div>
+
+          <!-- 未被结构化消费的字段以格式化 JSON 展示，保留排查模型输出的能力。 -->
           <pre v-if="analysisOf(log).details" class="task-log__analysis-details">{{ analysisOf(log).details }}</pre>
         </div>
+
+        <!-- 同一日志可同时携带多种媒体；mediaOf 负责从新旧字段提取并按“类型+URL”去重。 -->
         <div v-if="mediaOf(log).length" class="task-log__media">
           <template v-for="media in mediaOf(log)" :key="`${media.type}:${media.url}`">
             <el-image
@@ -55,6 +67,7 @@
               preview-teleported
               fit="cover"
             />
+            <!-- 视频和音频只预加载元数据，避免日志列表初次渲染时下载完整媒体文件。 -->
             <video v-else-if="media.type === 'video'" class="task-log__video" :src="media.url" controls preload="metadata" />
             <audio v-else class="task-log__audio" :src="media.url" controls preload="metadata" />
           </template>
@@ -68,14 +81,26 @@
 import { nextTick, onMounted, ref, watch } from 'vue'
 import { formatDate } from '@/utils/index'
 
+/**
+ * list: 任务或流程节点产生的日志数组。组件只负责展示，不修改日志对象。
+ * height: 日志容器固定高度；内容超出后在容器内滚动，默认 150px。
+ */
 const props = defineProps({
   list: { type: Array, default: () => [] },
   height: { type: Number, default: 150 },
 })
 
+// 保存日志滚动容器 DOM，用于首次渲染和日志更新后滚动到最新一条。
 const messageContainer = ref(null)
+
+// 以日志对象本身作为弱引用键缓存媒体解析结果；日志对象回收后缓存会自动释放，不产生长期内存占用。
 const mediaCache = new WeakMap()
 
+/**
+ * 将扩展结果安全转换为普通对象。
+ * 后端历史数据可能返回 JSON 字符串，新版接口可能直接返回对象；空值、基础类型或非法 JSON 均降级为空对象，
+ * 避免一条格式异常的日志阻断整个列表渲染。
+ */
 const parseObject = (value) => {
   if (!value) return {}
   if (typeof value === 'object') return value
@@ -87,6 +112,11 @@ const parseObject = (value) => {
   }
 }
 
+/**
+ * 把一个或多个媒体 URL 追加到结果数组。
+ * seen 使用“媒体类型:URL”作为去重键，因此同一 URL 以图片和视频两种类型出现时仍会分别保留；
+ * 非字符串、空白字符串和已经添加过的条目会被忽略。
+ */
 const addMedia = (result, seen, type, value) => {
   const values = Array.isArray(value) ? value : [value]
   values.forEach((item) => {
@@ -99,18 +129,31 @@ const addMedia = (result, seen, type, value) => {
   })
 }
 
+// 分析结果的计算相对复杂，使用 WeakMap 保证模板多次调用 analysisOf(log) 时只解析一次。
 const analysisCache = new WeakMap()
+
+/**
+ * 把日志中的音视频分析结果转换成模板直接使用的展示模型。
+ * 返回 null 表示该日志不是可展示的音视频分析结果；否则返回状态、模型、置信度、结论和扩展详情等字段。
+ */
 const analysisOf = (log) => {
+  // 防御非对象输入，同时优先读取缓存，避免模板中多个字段重复做 JSON.parse 和格式化工作。
   if (!log || typeof log !== 'object') return null
   if (analysisCache.has(log)) return analysisCache.get(log)
+
+  // extraInfo 后展开，因此同名字段会覆盖 actualResult；这是为了让后续补充/修正的信息优先显示。
   const output = {
     ...parseObject(log.actualResult),
     ...parseObject(log.extraInfo),
   }
+
+  // 新日志通过 analysisType/profileCode 标识媒体类型，logType=3/4 用于兼容旧版视频/音频日志。
   const analysisType = String(output.analysisType || '').toUpperCase()
   const profileCode = String(output.profileCode || '').toLowerCase()
   const isAudio = analysisType.includes('AUDIO') || profileCode.includes('audio') || Number(log.logType) === 4
   const isVideo = analysisType.includes('VIDEO') || profileCode.includes('video') || Number(log.logType) === 3
+
+  // 仅有媒体类型还不足以展示分析面板，至少要存在一个分析状态或业务结果字段。
   const hasResult = Boolean(
     output.analysisStatus
     || output.analysisType
@@ -121,6 +164,8 @@ const analysisOf = (log) => {
     || output.conclusion
     || output.passed !== undefined
   )
+
+  // 非分析日志也缓存 null，避免之后每次渲染都重复执行同一套识别逻辑。
   if (!hasResult || (!isAudio && !isVideo)) {
     analysisCache.set(log, null)
     return null
@@ -130,25 +175,41 @@ const analysisOf = (log) => {
   const matched = output.matched
   const passed = output.passed
   const confidenceValue = Number(output.confidence)
+
+  // 置信度兼容 0~1 和 0~100 两种协议，统一限制到 0~100 并保留一位小数。
+  // 非数字值返回 null，模板据此隐藏置信度字段，而不是展示 NaN。
   const confidence = Number.isFinite(confidenceValue)
     ? Math.max(0, Math.min(100, confidenceValue <= 1 ? confidenceValue * 100 : confidenceValue)).toFixed(1)
     : null
+
+  // 常见成功/失败枚举转换为中文；未知状态保留原值，完全缺失时使用中性的“已返回结果”。
   const statusLabel = status === 'SUCCEEDED' || status === 'SUCCESS'
     || status === 'COMPLETED'
     ? '分析完成'
     : status === 'FAILED' || status === 'ERROR'
       ? '分析失败'
       : status || '已返回结果'
+
+  // 复制一份原始输出用于生成扩展详情，后续删除操作不会修改日志本身或合并后的 output。
   const detailSource = { ...output }
+
+  // _executionContext 只用于前端把日志归属到任务中的检测项和执行次数，属于内部路由元数据。
+  // 它与已经结构化展示的分析字段一起从“详情”中移除，避免用户看到重复且难以理解的底层上下文。
   ;[
     'analysisStatus', 'analysisType', 'profileCode', 'analysisModel', 'analysisTimingMs',
     'mediaUrl', 'audioUrl', 'videoUrl', 'imageUrl', 'label', 'labelName', 'matched',
     'confidence', 'passed', 'summary', 'conclusion', 'events', '_executionContext',
   ].forEach((key) => delete detailSource[key])
+
+  // 所有已知字段删除后还有剩余内容时，才生成详情 JSON，避免显示空对象。
   const hasDetails = Object.keys(detailSource).length > 0
+
+  // 统一生成展示模型，模板不需要了解各版本日志字段和状态枚举的差异。
   const result = {
     title: isAudio ? '声音分析' : '视频分析',
     statusLabel,
+
+    // 分析失败或业务判断未通过使用红色；仅匹配失败使用警告色，其余使用成功色。
     tagType: status === 'FAILED' || status === 'ERROR' || passed === false
       ? 'danger'
       : matched === false ? 'warning' : 'success',
@@ -161,56 +222,83 @@ const analysisOf = (log) => {
     confidence,
     passedLabel: passed === true ? '通过' : passed === false ? '未通过' : '',
     summary: output.summary || output.conclusion || '',
+
+    // 限制最多 20 条关键事件，防止模型返回超大数组导致单条日志撑满页面。
+    // 对象事件转成紧凑 JSON，字符串事件保持原样。
     events: Array.isArray(output.events)
       ? output.events.slice(0, 20).map((event) => typeof event === 'string' ? event : JSON.stringify(event))
       : [],
     details: hasDetails ? JSON.stringify(detailSource, null, 2) : '',
   }
+
+  // 正常分析结果也写入缓存，后续模板读取状态、模型、摘要等字段时直接复用同一对象。
   analysisCache.set(log, result)
   return result
 }
 
+/**
+ * 从日志的新旧字段中提取所有可播放/预览的媒体资源。
+ * 返回值格式统一为 { type, url }，模板无需关心 URL 原来位于 actualResult、extraInfo 还是日志顶层。
+ */
 const mediaOf = (log) => {
   if (!log || typeof log !== 'object') return []
   if (mediaCache.has(log)) return mediaCache.get(log)
+
   const result = []
   const seen = new Set()
+
+  // 与分析结果相同，extraInfo 中的同名字段优先于 actualResult。
   const output = {
     ...parseObject(log.actualResult),
     ...parseObject(log.extraInfo),
   }
+
+  // 优先读取类型明确的新字段，它们不需要额外推断媒体类型。
   addMedia(result, seen, 'image', output.imageUrl)
   addMedia(result, seen, 'video', output.videoUrl)
   addMedia(result, seen, 'audio', output.audioUrl)
   const analysisType = String(output.analysisType || '').toUpperCase()
   const profileCode = String(output.profileCode || '').toLowerCase()
+
+  // mediaUrl 本身没有类型，必须结合分析类型或 profileCode 后才能作为视频/音频加入。
   if (analysisType.includes('VIDEO') || profileCode.includes('video')) addMedia(result, seen, 'video', output.mediaUrl)
   if (analysisType.includes('AUDIO') || profileCode.includes('audio')) addMedia(result, seen, 'audio', output.mediaUrl)
   addMedia(result, seen, 'image', log.screenshotUrl)
   addMedia(result, seen, 'video', log.videoUrl)
+
+  // 旧版日志把媒体统一放在顶层 mediaUrl，并通过 logType=2/3/4 区分图片、视频和音频。
   const legacyType = Number(log.logType) === 2 ? 'image'
     : Number(log.logType) === 3 ? 'video'
       : Number(log.logType) === 4 ? 'audio' : ''
   if (legacyType) addMedia(result, seen, legacyType, log.mediaUrl)
+
+  // 即使没有找到媒体也缓存空数组，避免无媒体日志在每次渲染时重复扫描全部字段。
   mediaCache.set(log, result)
   return result
 }
 
+// Element Plus 图片预览需要同一条日志下的纯图片 URL 数组，视频和音频不会进入预览列表。
 const imageUrlsOf = (log) => mediaOf(log)
   .filter((item) => item.type === 'image')
   .map((item) => item.url)
 
+/**
+ * 将滚动位置移动到容器底部，让用户默认看到最新日志。
+ * nextTick 等待 Vue 完成 DOM 更新，否则新日志节点尚未插入时 scrollHeight 仍是旧值。
+ */
 const scrollToBottom = () => {
   nextTick(() => {
     if (messageContainer.value) messageContainer.value.scrollTop = messageContainer.value.scrollHeight
   })
 }
 
+// deep 监听既覆盖追加/删除日志，也覆盖现有日志对象字段更新；组件挂载时同样执行一次初始定位。
 watch(() => props.list, scrollToBottom, { deep: true })
 onMounted(scrollToBottom)
 </script>
 
 <style scoped lang="scss">
+/* 外层容器固定高度并独立滚动，避免持续增长的日志改变父页面布局。 */
 .task-log {
   margin-top: 12px;
   padding: 12px;
@@ -220,6 +308,7 @@ onMounted(scrollToBottom)
   border-radius: 8px;
 }
 
+/* 桌面端使用“时间 + 内容”两列布局；内容列 minmax(0, 1fr) 允许长文本正确收缩。 */
 .task-log__item {
   display: grid;
   grid-template-columns: 145px minmax(0, 1fr);
@@ -244,6 +333,7 @@ onMounted(scrollToBottom)
   line-height: 20px;
 }
 
+/* 分析结果使用左侧强调线与普通日志正文区分，但保持在同一条日志的内容列中。 */
 .task-log__analysis {
   margin-top: 9px;
   padding: 10px 12px;
@@ -266,6 +356,7 @@ onMounted(scrollToBottom)
   font-size: 12px;
 }
 
+/* 四列摘要分别承载识别结果、匹配状态、置信度和判断结果。 */
 .task-log__analysis-grid {
   display: grid;
   grid-template-columns: repeat(4, minmax(0, 1fr));
@@ -305,6 +396,7 @@ onMounted(scrollToBottom)
   line-height: 18px;
 }
 
+/* 原始扩展详情限制最大高度并允许内部滚动，长 JSON 不会无限撑高单条日志。 */
 .task-log__analysis-details {
   max-height: 180px;
   margin: 9px 0 0;
@@ -318,6 +410,7 @@ onMounted(scrollToBottom)
   word-break: break-word;
 }
 
+/* 媒体资源允许自动换行；每种播放器使用稳定尺寸，资源加载后不会造成明显布局跳动。 */
 .task-log__media {
   display: flex;
   flex-wrap: wrap;
@@ -343,6 +436,7 @@ onMounted(scrollToBottom)
   height: 40px;
 }
 
+/* 窄屏改为上下布局，并把分析摘要缩减为两列，保证字段名称和结果仍有可读宽度。 */
 @media (max-width: 640px) {
   .task-log__item {
     grid-template-columns: 1fr;
diff --git a/src/views/flow/config.js b/src/views/flow/config.js
index 01d2e98..0128ca3 100644
--- a/src/views/flow/config.js
+++ b/src/views/flow/config.js
@@ -389,6 +389,8 @@ function handler(params) {
         ],
         outputType: 'json'
       },
+      // 使能状态由两个独立节点显式控制。节点本身不接收参数，也不依赖前一运动节点的隐式使能，
+      // 因而可在流程开始、异常恢复或任务收尾位置按业务需要自由编排。
       {
         icon: videoSvg,
         name: "开启机械臂使能",
@@ -400,6 +402,8 @@ function handler(params) {
         outputParams: [],
         outputType: 'json'
       },
+      // 关闭节点与开启节点使用不同 action，边缘执行器据此下发去使能指令；
+      // 空 outputParams 表示该节点只负责设备状态切换，不向后续节点暴露业务输出。
       {
         icon: videoSvg,
         name: "关闭机械臂使能",
diff --git a/src/views/inspection/runTask/index.vue b/src/views/inspection/runTask/index.vue
index 1c5d842..2c4d98b 100644
--- a/src/views/inspection/runTask/index.vue
+++ b/src/views/inspection/runTask/index.vue
@@ -506,6 +506,8 @@ const subscribeDebounced = debounce(async (sub) => {
 
         const callback = (data) => {
             if (data !== '500') {
+                // WebSocket 可能把状态作为字符串发送，先转成数字再判断，避免 '0' !== 0 导致终态被误当成运行日志。
+                // 0=完成、2=失败、4=终止，这三种状态都会结束当前实例，不再追加实时日志和进度。
                 const status = Number(data.status)
                 const terminal = [0, 2, 4].includes(status)
                 if (!terminal) {
@@ -527,6 +529,7 @@ const subscribeDebounced = debounce(async (sub) => {
                         ...data
                     })
                 } else {
+                    // 终态到达后清理内存中的实时快照，再从接口刷新当前队列与历史列表，保证页面以持久化结果为准。
                     delete taskRunningInfo.value[data.taskInstanceId]
                     delete taskLogList.value[data.taskInstanceId]
                     getList()
diff --git a/src/views/intelligenceTest/runningTask/index.vue b/src/views/intelligenceTest/runningTask/index.vue
index 87bad74..cdd5794 100644
--- a/src/views/intelligenceTest/runningTask/index.vue
+++ b/src/views/intelligenceTest/runningTask/index.vue
@@ -66,7 +66,10 @@
                             :activeStep="taskRunningInfo[runTask.id]?.activeStep || 0" />
                         <div class="run-log-container">
                             <div>执行日志</div>
-                            <!-- 传入任务定义 ID，task-log 会据此查询检测项并按检测项归类当前实例日志。 -->
+                            <!--
+                                taskId 用于查询检测项，taskStatus 用于在完成/失败/终止后推导最后一个已执行检测项的状态；
+                                两者与实例日志分开传入，避免把任务级字段重复写进每一条日志。
+                            -->
                             <taskLog :height="460" :task-id="runTask.taskId" :task-status="runTask.status"
                                 :list="taskLogList[runTask.id]" />
                         </div>
@@ -156,7 +159,10 @@
         </el-dialog>
 
         <el-dialog title="任务执行日志" v-model="logDialogVisible" width="800px" append-to-body>
-            <!-- 历史弹窗也传入对应任务定义 ID，确保没有实时进度数据时仍能展示完整检测项列表。 -->
+            <!--
+                历史弹窗没有 WebSocket 实时上下文，因此同时传入任务定义 ID 和历史终态；
+                日志组件据此补齐未执行项，并正确区分最后一项是完成、失败还是终止。
+            -->
             <taskLog v-loading="logDialogLoading" :task-id="logDialogTaskId" :task-status="logDialogTaskStatus"
                 :list="logDialogData" :height="500" />
         </el-dialog>
@@ -552,6 +558,8 @@ const subscribeDebounced = debounce(async (sub) => {
 
         const callback = (data) => {
             if (data !== '500') {
+                // 统一处理数字和字符串状态。0=完成、2=失败、4=终止，均属于任务实例终态。
+                // 终态消息只触发列表刷新，不作为普通节点日志追加，否则会产生一个无法归属检测项的伪日志。
                 const status = Number(data.status)
                 const terminal = [0, 2, 4].includes(status)
                 if (!terminal) {
@@ -573,6 +581,7 @@ const subscribeDebounced = debounce(async (sub) => {
                         ...data
                     })
                 } else {
+                    // 清除实时缓存后重新查询任务队列和历史记录，让最终状态与后端持久化结果保持一致。
                     delete taskRunningInfo.value[data.taskInstanceId]
                     delete taskLogList.value[data.taskInstanceId]
                     getList()
@@ -599,6 +608,8 @@ const logDialogData = ref([])
 
 // 历史表格行里的 taskId 是任务定义 ID；日志组件使用它查询本次任务包含的全部检测项。
 const logDialogTaskId = ref('')
+
+// 保存当前历史实例的终态，供日志组件判断最后一个产生过日志的检测项是完成、失败还是被终止。
 const logDialogTaskStatus = ref(null)
 const logDialogLoading = ref(false)
 let logDialogRequestId = 0
@@ -608,6 +619,8 @@ const handleOpenLog = async (row) => {
 
     // 在请求实例日志前先更新 taskId，让检测项请求与日志请求并行执行，减少弹窗等待时间。
     logDialogTaskId.value = row.taskId
+
+    // 状态与 taskId 同步切换，防止连续打开不同历史任务时短暂沿用上一个实例的状态。
     logDialogTaskStatus.value = row.status
     logDialogData.value = []
     logDialogLoading.value = true
diff --git a/src/views/intelligenceTest/runningTask/task-log.vue b/src/views/intelligenceTest/runningTask/task-log.vue
index eff06ea..8090d07 100644
--- a/src/views/intelligenceTest/runningTask/task-log.vue
+++ b/src/views/intelligenceTest/runningTask/task-log.vue
@@ -21,15 +21,17 @@
             <ArrowRight />
           </el-icon>
           <span class="task-log__order">{{ String(index + 1).padStart(2, '0') }}</span>
+          <!-- 同一个检测项被任务重复编排时保留原名称，并用“第 N 次”明确区分每个执行分组。 -->
           <span class="task-log__name" :title="group.fullName">
             {{ group.name }}
             <span v-if="group.repeatLabel" class="task-log__repeat">{{ group.repeatLabel }}</span>
           </span>
+          <!-- 执行状态和分析结论是两个维度：前者表示流程是否执行完成，后者表示检测结果是否通过。 -->
           <span class="task-log__statuses">
-            <el-tag :type="group.status.type" size="small">{{ group.status.label }}</el-tag>
             <el-tag v-if="group.analysisStatus" :type="group.analysisStatus.type" effect="plain" size="small">
               {{ group.analysisStatus.label }}
             </el-tag>
+            <el-tag :type="group.status.type" size="small">{{ group.status.label }}</el-tag>
           </span>
         </button>
 
@@ -62,6 +64,7 @@ import TaskExecutionLog from '@/views/flow/components/TaskExecutionLog.vue'
 
 /**
  * taskId: 任务定义 ID，用于查询该任务绑定的全部检测项。
+ * taskStatus: 当前任务实例状态，用于历史任务结束后判断最后一个有日志的检测项最终状态。
  * list: 当前任务实例产生的日志，检测项加载完成后会按 itemId/itemOrder 分组。
  * items: 可选的外部检测项数据；传入后优先使用，可避免父组件已经查询时重复请求。
  * height: 整个检测项日志区域的固定高度，内部超出部分滚动显示。
@@ -127,6 +130,8 @@ const itemKeysOf = (item) => uniqueValues([
 const logKeysOf = (log) => {
   const actualResult = parseObject(log?.actualResult)
   const extraInfo = parseObject(log?.extraInfo)
+
+  // 新版执行器把重复检测项的归属信息写入 actualResult._executionContext，旧版顶层字段仍继续兼容。
   const executionContext = parseObject(actualResult?._executionContext)
   return uniqueValues([
     log?.itemId,
@@ -144,6 +149,11 @@ const logKeysOf = (log) => {
   ])
 }
 
+/**
+ * 提取日志在任务编排中的位置。
+ * 顶层 itemOrder/itemOccurrence 优先，因为它们是日志接口的正式字段；缺失时再读取
+ * actualResult._executionContext，以兼容由节点执行结果携带上下文的新格式。
+ */
 const logExecutionContextOf = (log) => {
   const actualResult = parseObject(log?.actualResult)
   const context = parseObject(actualResult?._executionContext)
@@ -176,6 +186,11 @@ const nodeNameOf = (log) => {
 // 状态统一转为小写字符串，使数字枚举和英文状态值可以使用同一套判断逻辑。
 const normalizedStatus = (value) => String(value ?? '').trim().toLowerCase()
 
+/**
+ * 判断一条节点日志是否明确表示“当前检测项执行结束”。
+ * 只有结束节点（nodeType=END）的完成事件（eventType=NODE_COMPLETED）才算检测项完成，
+ * 普通业务节点完成只代表流程推进，不能提前把整个检测项标记为已完成。
+ */
 const isItemCompletionLog = (log) => {
   const actualResult = parseObject(log?.actualResult)
   const context = parseObject(actualResult?._executionContext)
@@ -186,7 +201,8 @@ const isItemCompletionLog = (log) => {
 /**
  * 根据一个检测项下的全部日志推导检测项状态。
  * 优先级为：失败 > 终止 > 暂停 > 完成 > 执行中；没有日志时固定为“未执行”。
- * 完成状态同时识别状态字段、progress=100 以及 completed/finished 布尔标记。
+ * 对已经结束的任务，还会结合任务终态和“最后一个有日志的检测项”判断失败/终止落在哪一项；
+ * 完成状态最后再兼容状态字段、结束节点事件、progress=100 以及 completed/finished 布尔标记。
  */
 const statusOf = (logs, execution = {}) => {
   if (!logs.length) return { label: '未执行', type: 'info' }
@@ -209,20 +225,30 @@ const statusOf = (logs, execution = {}) => {
   if (statuses.some((status) => ['3', 'paused', 'pause'].includes(status))) {
     return { label: '已暂停', type: 'warning' }
   }
+
+  // taskStatus 为空时用 NaN 表示“无任务级结论”，避免 Number(null) 被错误转换为完成状态 0。
   const taskStatus = execution.taskStatus === null || execution.taskStatus === undefined || execution.taskStatus === ''
     ? Number.NaN
     : Number(execution.taskStatus)
+
+  // 整个任务正常完成时，所有实际产生过日志的检测项都可视为已完成。
   if (taskStatus === 0) return { label: '已完成', type: 'success' }
+
+  // 任务失败时，最后一个有日志的检测项视为失败；它之前的检测项已经顺序执行完成。
   if (taskStatus === 2) {
     return execution.groupIndex < execution.lastLoggedIndex
       ? { label: '已完成', type: 'success' }
       : { label: '执行失败', type: 'danger' }
   }
+
+  // 任务被终止时采用同样的位置规则，仅将当时正在执行的最后一项标记为“已终止”。
   if (taskStatus === 4) {
     return execution.groupIndex < execution.lastLoggedIndex
       ? { label: '已完成', type: 'success' }
       : { label: '已终止', type: 'warning' }
   }
+
+  // 对仍在运行的任务，只要后续检测项已经产生日志，当前项就必然已经按顺序执行完成。
   if (execution.groupIndex < execution.lastLoggedIndex) {
     return { label: '已完成', type: 'success' }
   }
@@ -238,6 +264,10 @@ const statusOf = (logs, execution = {}) => {
   return { label: '执行中', type: 'primary' }
 }
 
+/**
+ * 将分析结果中的布尔值规范为 true/false/null。
+ * 部分接口会返回字符串 "true"/"false"；null 表示字段缺失或值无法识别，调用方应继续尝试其他结论字段。
+ */
 const booleanValue = (value) => {
   if (value === true || value === false) return value
   if (typeof value === 'string') {
@@ -247,6 +277,11 @@ const booleanValue = (value) => {
   return null
 }
 
+/**
+ * 从单条日志中提取分析判定：true=通过、false=不通过、null=这不是分析日志。
+ * 识别范围包含音视频 analysisType/profileCode、analysisStatus、passed、matched 和旧版 testStatus。
+ * 判定优先级为：分析执行失败 > passed > matched > testStatus，避免旧字段覆盖更明确的新字段。
+ */
 const analysisVerdictOf = (log) => {
   const output = {
     ...parseObject(log?.actualResult),
@@ -273,6 +308,10 @@ const analysisVerdictOf = (log) => {
   return false
 }
 
+/**
+ * 汇总一个检测项下的全部分析日志。
+ * 没有分析日志时不展示结论标签；只要任意一次分析不通过，检测项结论就是“不通过”。
+ */
 const analysisStatusOf = (logs) => {
   const verdicts = logs.map(analysisVerdictOf).filter((value) => value !== null)
   if (!verdicts.length) return null
@@ -287,10 +326,12 @@ const taskItemsSource = computed(() => props.items.length ? props.items : taskIt
 /**
  * 将“检测项列表”和“任务实例日志”合并成页面需要的分组结构：
  * 1. 先为每个检测项创建空分组，保证尚未执行的检测项也能显示；
- * 2. 建立检测项 ID 到分组的索引，再把每条日志放入对应分组；
- * 3. 最后计算节点名称集合和检测项状态。
+ * 2. 对重复编排的同一检测项记录出现次数，并建立一个 ID 对应多个候选分组的索引；
+ * 3. 按 itemOrder、历史 progress、itemOccurrence/ID 的优先级把每条日志放入对应分组；
+ * 4. 最后计算节点名称、流程执行状态和分析结论。
  */
 const groups = computed(() => {
+  // occurrenceByItemKey 记录当前遍历到第几次，totalByItemKey 用于判断是否需要显示“第 N 次”。
   const occurrenceByItemKey = new Map()
   const totalByItemKey = new Map()
   taskItemsSource.value.forEach((item) => {
@@ -307,6 +348,7 @@ const groups = computed(() => {
     const repeatLabel = repeated ? `第 ${occurrence} 次` : ''
     const name = nameOf(item)
     return {
+      // key 同时包含编排顺序、检测项 ID 和出现次数，重复检测项也能保持独立的展开状态。
       key: `order-${index + 1}:${primaryKey}:${occurrence}`,
       name,
       fullName: repeatLabel ? `${name}（${repeatLabel}）` : name,
@@ -318,7 +360,7 @@ const groups = computed(() => {
   })
   const keyToGroups = new Map()
 
-  // 一个检测项可能同时存在 detectItemId、testCaseId 等多个 ID，全部映射到同一个分组。
+  // 一个检测项 ID 可能对应多个重复执行分组，因此索引值必须是候选数组，不能只保存第一个分组。
   taskItemsSource.value.forEach((item, index) => {
     const group = result[index]
     itemKeysOf(item).forEach((key) => {
@@ -333,11 +375,11 @@ const groups = computed(() => {
     const order = Number(executionContext.itemOrder)
     const occurrence = Number(executionContext.itemOccurrence)
 
-    // itemOrder 是任务内的 1 基序号，存在时可以准确处理同一检测项被重复编排的情况。
+    // 第一优先级：itemOrder 是任务内的 1 基绝对序号，存在时可以直接定位，包括重复编排的检测项。
     const orderedGroup = Number.isInteger(order) && order > 0 ? result[order - 1] : null
 
-    // Older persisted logs did not contain itemOrder. Their monotonically increasing
-    // progress still identifies the binding segment and keeps repeated items separate.
+    // 第二优先级：旧持久化日志没有 itemOrder，但任务 progress 单调递增，可按检测项总数反推出所在区间。
+    // 反推后还要校验日志 ID 是否属于该分组，防止进度精度或边界值把日志分配给错误检测项。
     const progress = Number(log?.progress)
     const progressOrder = Number.isFinite(progress) && progress > 0 && result.length
       ? Math.max(1, Math.min(result.length, Math.ceil(progress * result.length / 100)))
@@ -349,7 +391,8 @@ const groups = computed(() => {
       ? progressGroup
       : null
 
-    // 没有有效序号时，再使用日志 itemId 与检测项 detectItemId 等字段进行匹配。
+    // 第三优先级：使用 itemId 等兼容键查找候选分组；如果上下文带 itemOccurrence，
+    // 选择对应的第 N 个候选，否则退回第一个，兼容完全没有执行上下文的最早期日志。
     const matchedGroup = orderedGroup || compatibleProgressGroup || logKeys.map((key) => {
       const candidates = keyToGroups.get(key) || []
       return Number.isInteger(occurrence) && occurrence > 0
@@ -360,22 +403,24 @@ const groups = computed(() => {
     else unmatchedLogs.push(log)
   })
 
-  // 无法关联的日志不能静默丢失，统一放入兜底分组，便于发现后端字段或历史数据问题。
+  // 最后一个有日志的索引用于解释任务级失败/终止状态：顺序执行模型下，更早的分组已完成，最后一组是中断点。
   const lastLoggedIndex = result.reduce((lastIndex, group, index) => (
     group.logs.length ? index : lastIndex
   ), -1)
 
-  if (unmatchedLogs.length) {
-    result.push({
-      key: 'unmatched',
-      name: '未关联检测项',
-      fullName: '未关联检测项',
-      itemKeys: [],
-      repeatLabel: '',
-      logs: unmatchedLogs,
-    })
-  }
+  // 无法关联的日志不能静默丢失，统一放入兜底分组，便于发现后端字段或历史数据问题。
+  // if (unmatchedLogs.length) {
+  //   result.push({
+  //     key: 'unmatched',
+  //     name: '未关联检测项',
+  //     fullName: '未关联检测项',
+  //     itemKeys: [],
+  //     repeatLabel: '',
+  //     logs: unmatchedLogs,
+  //   })
+  // }
 
+  // 页面最终消费的分组在这里统一补齐节点摘要、执行状态和分析结论，模板不再重复计算业务规则。
   return result.map((group, index) => ({
     ...group,
     nodeNames: uniqueValues(group.logs.map(nodeNameOf)),
@@ -520,6 +565,7 @@ watch(() => groups.value.map((group) => group.key), (keys) => {
 }
 
 .task-log__repeat {
+  // 重复次数作为名称的辅助信息，视觉权重低于检测项主名称。
   display: inline-block;
   margin-left: 6px;
   color: #409eff;
@@ -528,6 +574,7 @@ watch(() => groups.value.map((group) => group.key), (keys) => {
 }
 
 .task-log__statuses {
+  // 状态区域允许换行，窄屏下两个标签不会挤压或遮挡检测项名称。
   display: flex;
   flex-wrap: wrap;
   gap: 6px;

From 6a24cd17cc6a07e0771c4dea231d9ed6d8eff5a5 Mon Sep 17 00:00:00 2001
From: zhanghao <774378400@qq.com>
Date: Tue, 18 Aug 2026 13:32:49 +0800
Subject: [PATCH 2/4] =?UTF-8?q?feat:=20=E6=8C=89=E9=80=89=E4=B8=AD?=
 =?UTF-8?q?=E4=BB=BB=E5=8A=A1=E5=B1=95=E7=A4=BA=E8=BF=90=E8=A1=8C=E8=AF=A6?=
 =?UTF-8?q?=E6=83=85?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/views/inspection/runTask/index.vue        | 85 ++++++++++++------
 .../intelligenceTest/runningTask/index.vue    | 86 ++++++++++++-------
 2 files changed, 115 insertions(+), 56 deletions(-)

diff --git a/src/views/inspection/runTask/index.vue b/src/views/inspection/runTask/index.vue
index 2c4d98b..099c61c 100644
--- a/src/views/inspection/runTask/index.vue
+++ b/src/views/inspection/runTask/index.vue
@@ -6,18 +6,20 @@
                 <el-button type="primary" @click="addTask">添加任务</el-button>
             </div>
             <div class="taskList-container">
-                <div class="task-item" v-for="task in runTaskList">
+                <div v-for="task in runTaskList" :key="task.id" class="task-item"
+                    :class="{ 'is-selected': isSelectedTask(task) }"
+                    :aria-current="isSelectedTask(task) ? 'true' : undefined" @click="selectTask(task)">
                     <div class="task-content">
                         <div class="task-title">{{ task.taskName }}</div>
                         <div class="task-actions">
                             <SvgIcon class="icon" v-if="task.status === '1'" name="pause" :size="24" color="#FFB300"
-                                @click="pauseTask(task)" />
+                                @click.stop="pauseTask(task)" />
                             <SvgIcon class="icon" v-if="task.status === '3' || task.status === '5'" name="start"
-                                :size="24" color="#00FF88" @click="startTask(task)" />
+                                :size="24" color="#00FF88" @click.stop="startTask(task)" />
                             <SvgIcon class="icon" v-if="task.status != '5'" name="stop" :size="24" color="#d81e06"
-                                @click="stopTask(task)" />
+                                @click.stop="stopTask(task)" />
                             <SvgIcon class="icon" v-if="task.status === '5'" name="remove" :size="24" color="#FFB300"
-                                @click="removeTask(task)" />
+                                @click.stop="removeTask(task)" />
                         </div>
                     </div>
                     <div class="robot">主要机器人：{{ task.robotName || '执行时安排' }}</div>
@@ -35,38 +37,38 @@
             </div>
             <div class="context-container">
                 <div v-if="activePanel === 'current'">
-                    <!-- 当前任务内容 -->
-                    <div class="task" v-for="runTask in runingTaskList" :key="runTask.id"
-                        :data-task-id="runTask.id" :class="{ 'task--selected': selectedTaskId === runTask.id }"
-                        @click="selectedTaskId = runTask.id">
+                    <!-- 当前任务区域只展示左侧任务队列中选中的任务，避免同时渲染所有执行中任务。 -->
+                    <div v-if="selectedRunTask" :key="selectedRunTask.id" class="task"
+                        :data-task-id="selectedRunTask.id">
                         <div class="task-header">
                             <div class="header-container">
                                 <div class="task-info">
-                                    <div class="title">{{ runTask.taskName }}</div>
-                                    <div class="id">ID: {{ runTask.taskId }}</div>
+                                    <div class="title">{{ selectedRunTask.taskName }}</div>
+                                    <div class="id">ID: {{ selectedRunTask.taskId }}</div>
                                 </div>
                                 <div class="robot">
-                                    <div>主要机器人：{{ runTask.robotName || '按流程角色安排' }}</div>
-                                    <div>开始时间: {{ formatDate(runTask.startTime) }}</div>
+                                    <div>主要机器人：{{ selectedRunTask.robotName || '按流程角色安排' }}</div>
+                                    <div>开始时间: {{ formatDate(selectedRunTask.startTime) }}</div>
                                 </div>
                             </div>
                             <div>
-                                <el-tag :type="runTask.status === '3' ? 'primary' : 'warning'">
-                                    {{ taskStatusMap[runTask.status] || '未知状态' }}
+                                <el-tag :type="selectedRunTask.status === '3' ? 'primary' : 'warning'">
+                                    {{ taskStatusMap[selectedRunTask.status] || '未知状态' }}
                                 </el-tag>
                             </div>
                         </div>
 
                         <div class="progress-label">执行进度</div>
                         <el-progress :color="customColorMethod"
-                            :percentage="parseFloat(taskRunningInfo[runTask.id]?.progress?.toFixed(2)) || 0" />
-                        <taskSteps :list="pointList_runningTask[runTask.taskId]"
-                            :activeStep="taskRunningInfo[runTask.id]?.activeStep || 0" />
+                            :percentage="parseFloat(taskRunningInfo[selectedRunTask.id]?.progress?.toFixed(2)) || 0" />
+                        <taskSteps :list="pointList_runningTask[selectedRunTask.taskId]"
+                            :activeStep="taskRunningInfo[selectedRunTask.id]?.activeStep || 0" />
                         <div class="run-log-container">
                             <div>执行日志</div>
-                            <taskLog :list="taskLogList[runTask.id]" />
+                            <taskLog :list="taskLogList[selectedRunTask.id]" />
                         </div>
                     </div>
+                    <el-empty v-else description="暂无任务" />
                 </div>
                 <div v-else-if="activePanel === 'history'">
                     <div :style="containerHeight">
@@ -170,7 +172,7 @@ import taskSteps from "./task-steps.vue";
 import taskLog from "./task-log.vue";
 import { useContainerHeight } from "@/hooks/tableHeight";
 import { getTaskList, getWaypointByTaskId } from "@/api/inspection/task";
-import { onMounted, onUnmounted } from "vue";
+import { computed, onMounted, onUnmounted } from "vue";
 import { addRunTask, getRunTaskList, startRunTask, rerunRunTask, pauseRunTask, stopRunTask, resumeRunTask, deleteRunTask, getTaskLogListApi } from "@/api/inspection/runTask";
 import { ElMessage, ElMessageBox } from "element-plus";
 import { formatDate } from "@/utils/index";
@@ -220,6 +222,23 @@ const rules = reactive({
 const taskList = ref([]);
 const runTaskList = ref([]);
 
+// 接口和 WebSocket 可能分别以数字、字符串返回任务实例 ID，统一转换后再判断是否为选中任务。
+const isSelectedTask = (task) => String(task?.id ?? '') === String(selectedTaskId.value)
+
+// 当前任务详情直接从完整任务队列中取得，因此未执行、执行中和已暂停任务都可以被选中查看。
+const selectedRunTask = computed(() => runTaskList.value.find(isSelectedTask) || null)
+
+/**
+ * 点击左侧任务卡片时切换右侧当前任务详情，并从历史记录面板返回当前任务面板。
+ * 卡片内的启动、暂停、停止和删除图标均使用 .stop 阻止冒泡，执行操作时不会意外改变当前选择。
+ *
+ * @param {Object} task 左侧任务队列中被点击的任务实例
+ */
+const selectTask = (task) => {
+    selectedTaskId.value = task.id
+    activePanel.value = 'current'
+}
+
 const normalizeTaskStatus = (tasks = []) => tasks.map(item => ({
     ...item,
     status: String(item.status),
@@ -264,9 +283,12 @@ const cancelTaskDialog = () => {
 }
 
 
-const runingTaskList = ref([])
 /**
- * 获取任务队列
+ * 获取任务队列并维护当前选中的任务：
+ * 1. 页面首次加载时默认选中队列第一条任务；
+ * 2. 队列刷新后，如果原任务仍存在，则保留用户当前选择；
+ * 3. 如果原任务已经结束或被删除，则选择刷新后队列中的第一条任务；
+ * 4. 如果任务队列为空，则清空选择并由模板展示空状态。
  */
 const getList = () => {
     return getRunTaskList({
@@ -275,7 +297,9 @@ const getList = () => {
         if (res.code === 200) {
             const tasks = normalizeTaskStatus(res.rows)
             runTaskList.value = tasks;
-            runingTaskList.value = tasks.filter(item => item.status !== '5')
+            if (!tasks.some(isSelectedTask)) {
+                selectedTaskId.value = tasks[0]?.id ?? ''
+            }
             for (let i = 0; i < runTaskList.value.length; i++) {
                 getPointByTaskId(runTaskList.value[i].taskId)
                 getTaskLogList(runTaskList.value[i].id)
@@ -618,6 +642,17 @@ onUnmounted(() => {
                 box-shadow: inset 0 0 0 1px #eee;
                 border-radius: 8px;
                 margin-bottom: 16px;
+                cursor: pointer;
+                transition: background-color 0.2s ease, box-shadow 0.2s ease;
+
+                &:hover {
+                    background: var(--el-fill-color-light);
+                }
+
+                &.is-selected {
+                    background: var(--el-color-primary-light-9);
+                    box-shadow: inset 0 0 0 2px var(--el-color-primary);
+                }
 
                 .task-content {
                     display: flex;
@@ -684,10 +719,6 @@ onUnmounted(() => {
             border-radius: 20px;
             margin-bottom: 12px;
 
-            &--selected {
-                box-shadow: inset 0 0 0 2px var(--el-color-primary);
-            }
-
             .task-header {
                 display: flex;
                 justify-content: space-between;
diff --git a/src/views/intelligenceTest/runningTask/index.vue b/src/views/intelligenceTest/runningTask/index.vue
index cdd5794..ab3e0de 100644
--- a/src/views/intelligenceTest/runningTask/index.vue
+++ b/src/views/intelligenceTest/runningTask/index.vue
@@ -6,18 +6,20 @@
                 <el-button type="primary" @click="addTask">添加任务</el-button>
             </div>
             <div class="taskList-container">
-                <div class="task-item" v-for="task in runTaskList">
+                <div v-for="task in runTaskList" :key="task.id" class="task-item"
+                    :class="{ 'is-selected': isSelectedTask(task) }"
+                    :aria-current="isSelectedTask(task) ? 'true' : undefined" @click="selectTask(task)">
                     <div class="task-content">
                         <div class="task-title">{{ task.taskName }}</div>
                         <div class="task-actions">
                             <SvgIcon class="icon" v-if="task.status == '1'" name="pause" :size="24" color="#FFB300"
-                                @click="pauseTask(task)" />
+                                @click.stop="pauseTask(task)" />
                             <SvgIcon class="icon" v-if="task.status == '3' || task.status == '5'" name="start"
-                                :size="24" color="#00FF88" @click="startTask(task)" />
+                                :size="24" color="#00FF88" @click.stop="startTask(task)" />
                             <SvgIcon class="icon" v-if="task.status != '5'" name="stop" :size="24" color="#d81e06"
-                                @click="stopTask(task)" />
+                                @click.stop="stopTask(task)" />
                             <SvgIcon class="icon" v-if="task.status == '5'" name="remove" :size="24" color="#FFB300"
-                                @click="removeTask(task)" />
+                                @click.stop="removeTask(task)" />
                         </div>
                     </div>
                     <div class="robot">手机：{{ task.phoneName }}</div>
@@ -36,44 +38,44 @@
             </div>
             <div class="context-container">
                 <div v-if="activePanel === 'current'">
-                    <!-- 当前任务内容 -->
-                    <div class="task" v-for="runTask in runingTaskList" :key="runTask.id"
-                        :data-task-id="runTask.id" :class="{ 'task--selected': selectedTaskId === runTask.id }"
-                        @click="selectedTaskId = runTask.id">
+                    <!-- 当前任务区域只展示左侧队列选中的任务，不再同时渲染全部执行中任务。 -->
+                    <div v-if="selectedRunTask" :key="selectedRunTask.id" class="task"
+                        :data-task-id="selectedRunTask.id">
                         <div class="task-header">
                             <div class="header-container">
                                 <div class="task-info">
-                                    <div class="title">{{ runTask.taskName }}</div>
-                                    <div class="id">ID: {{ runTask.taskId }}</div>
+                                    <div class="title">{{ selectedRunTask.taskName }}</div>
+                                    <div class="id">ID: {{ selectedRunTask.taskId }}</div>
                                 </div>
                                 <div class="robot">
-                                    <div>手机：{{ runTask.phoneName }}</div>
-                                    <div>车辆：{{ runTask.vehicleName }}</div>
-                                    <div>开始时间: {{ formatDate(runTask.startTime) }}</div>
+                                    <div>手机：{{ selectedRunTask.phoneName }}</div>
+                                    <div>车辆：{{ selectedRunTask.vehicleName }}</div>
+                                    <div>开始时间: {{ formatDate(selectedRunTask.startTime) }}</div>
                                 </div>
                             </div>
                             <div>
-                                <el-tag :type="runTask.status === '3' ? 'primary' : 'warning'">
-                                    {{ taskStatusMap[runTask.status] || '未知状态' }}
+                                <el-tag :type="selectedRunTask.status === '3' ? 'primary' : 'warning'">
+                                    {{ taskStatusMap[selectedRunTask.status] || '未知状态' }}
                                 </el-tag>
                             </div>
                         </div>
 
                         <div class="progress-label">执行进度</div>
                         <el-progress :color="customColorMethod"
-                            :percentage="parseFloat(taskRunningInfo[runTask.id]?.progress?.toFixed(2)) || 0" />
-                        <taskSteps :list="pointList_runningTask[runTask.taskId]"
-                            :activeStep="taskRunningInfo[runTask.id]?.activeStep || 0" />
+                            :percentage="parseFloat(taskRunningInfo[selectedRunTask.id]?.progress?.toFixed(2)) || 0" />
+                        <taskSteps :list="pointList_runningTask[selectedRunTask.taskId]"
+                            :activeStep="taskRunningInfo[selectedRunTask.id]?.activeStep || 0" />
                         <div class="run-log-container">
                             <div>执行日志</div>
                             <!--
                                 taskId 用于查询检测项，taskStatus 用于在完成/失败/终止后推导最后一个已执行检测项的状态；
                                 两者与实例日志分开传入，避免把任务级字段重复写进每一条日志。
                             -->
-                            <taskLog :height="460" :task-id="runTask.taskId" :task-status="runTask.status"
-                                :list="taskLogList[runTask.id]" />
+                            <taskLog :height="460" :task-id="selectedRunTask.taskId"
+                                :task-status="selectedRunTask.status" :list="taskLogList[selectedRunTask.id]" />
                         </div>
                     </div>
+                    <el-empty v-else description="暂无任务" />
                 </div>
                 <div v-else-if="activePanel === 'history'">
                     <div :style="containerHeight">
@@ -191,7 +193,7 @@ import { useContainerHeight } from "@/hooks/tableHeight";
 import { getTaskList, getTestCaseByTaskId } from "@/api/intelligenceTest/taskManage";
 import { getPhoneList } from "@/api/intelligenceTest/mobilePhone";
 import { getVehicleList } from "@/api/intelligenceTest/car";
-import { onMounted, onUnmounted } from "vue";
+import { computed, onMounted, onUnmounted } from "vue";
 import { 
     addTaskinstance,
     getTaskinstanceList,
@@ -253,6 +255,21 @@ const phoneList = ref([]);
 
 const runTaskList = ref([]);
 
+// 任务实例 ID 在接口和 WebSocket 中可能分别是数字或字符串，统一按字符串比较选中状态。
+const isSelectedTask = (task) => String(task?.id ?? '') === String(selectedTaskId.value)
+
+// 右侧当前任务始终从完整任务队列中取选中的一条，包括尚未执行、执行中和已暂停任务。
+const selectedRunTask = computed(() => runTaskList.value.find(isSelectedTask) || null)
+
+/**
+ * 点击左侧任务卡片时切换右侧详情，并自动回到“当前任务”面板。
+ * 卡片内部操作按钮使用 .stop 阻止冒泡，因此执行暂停/启动等命令时不会意外切换选择。
+ */
+const selectTask = (task) => {
+    selectedTaskId.value = task.id
+    activePanel.value = 'current'
+}
+
 const normalizeTaskStatus = (tasks = []) => tasks.map(item => ({
     ...item,
     status: String(item.status),
@@ -317,9 +334,11 @@ const cancelTaskDialog = () => {
 }
 
 
-const runingTaskList = ref([])
 /**
- * 获取任务队列
+ * 获取任务队列，并维护当前选中任务：
+ * 1. 首次加载默认选择队列第一条；
+ * 2. 刷新后原任务仍在队列中则保持选择；
+ * 3. 原任务已结束或被删除时回退到新的第一条，队列为空时清空选择。
  */
 const getList = () => {
     return getTaskinstanceList({
@@ -328,7 +347,9 @@ const getList = () => {
         if (res.code === 200) {
             const tasks = normalizeTaskStatus(res.rows)
             runTaskList.value = tasks;
-            runingTaskList.value = tasks.filter(item => item.status !== '5')
+            if (!tasks.some(isSelectedTask)) {
+                selectedTaskId.value = tasks[0]?.id ?? ''
+            }
             for (let i = 0; i < runTaskList.value.length; i++) {
                 getCaseByTaskId(runTaskList.value[i].taskId)
                 getTaskLogList(runTaskList.value[i].id)
@@ -684,6 +705,17 @@ onUnmounted(() => {
                 box-shadow: inset 0 0 0 1px #eee;
                 border-radius: 8px;
                 margin-bottom: 16px;
+                cursor: pointer;
+                transition: background-color 0.2s ease, box-shadow 0.2s ease;
+
+                &:hover {
+                    background: var(--el-fill-color-light);
+                }
+
+                &.is-selected {
+                    background: var(--el-color-primary-light-9);
+                    box-shadow: inset 0 0 0 2px var(--el-color-primary);
+                }
 
                 .task-content {
                     display: flex;
@@ -750,10 +782,6 @@ onUnmounted(() => {
             border-radius: 20px;
             margin-bottom: 12px;
 
-            &--selected {
-                box-shadow: inset 0 0 0 2px var(--el-color-primary);
-            }
-
             .task-header {
                 display: flex;
                 justify-content: space-between;

From f26519a8244307f67210f60582892e71acee5593 Mon Sep 17 00:00:00 2001
From: zhanghao <774378400@qq.com>
Date: Tue, 18 Aug 2026 13:45:45 +0800
Subject: [PATCH 3/4] =?UTF-8?q?feat:=20=E5=8A=A8=E6=80=81=E8=AE=A1?=
 =?UTF-8?q?=E7=AE=97=E4=BB=BB=E5=8A=A1=E6=97=A5=E5=BF=97=E9=AB=98=E5=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/views/inspection/runTask/index.vue        | 41 +++++++++++++++++--
 .../intelligenceTest/runningTask/index.vue    | 41 +++++++++++++++++--
 2 files changed, 74 insertions(+), 8 deletions(-)

diff --git a/src/views/inspection/runTask/index.vue b/src/views/inspection/runTask/index.vue
index 099c61c..3435138 100644
--- a/src/views/inspection/runTask/index.vue
+++ b/src/views/inspection/runTask/index.vue
@@ -35,7 +35,7 @@
                 <div class="label" :class="{ active: activePanel === 'history' }" @click="activePanel = 'history'">历史记录
                 </div>
             </div>
-            <div class="context-container">
+            <div ref="contextContainerRef" class="context-container">
                 <div v-if="activePanel === 'current'">
                     <!-- 当前任务区域只展示左侧任务队列中选中的任务，避免同时渲染所有执行中任务。 -->
                     <div v-if="selectedRunTask" :key="selectedRunTask.id" class="task"
@@ -63,9 +63,9 @@
                             :percentage="parseFloat(taskRunningInfo[selectedRunTask.id]?.progress?.toFixed(2)) || 0" />
                         <taskSteps :list="pointList_runningTask[selectedRunTask.taskId]"
                             :activeStep="taskRunningInfo[selectedRunTask.id]?.activeStep || 0" />
-                        <div class="run-log-container">
-                            <div>执行日志</div>
-                            <taskLog :list="taskLogList[selectedRunTask.id]" />
+                        <div ref="taskLogContainerRef" class="run-log-container">
+                            <div ref="taskLogTitleRef">执行日志</div>
+                            <taskLog :height="taskLogHeight" :list="taskLogList[selectedRunTask.id]" />
                         </div>
                     </div>
                     <el-empty v-else description="暂无任务" />
@@ -173,6 +173,7 @@ import taskLog from "./task-log.vue";
 import { useContainerHeight } from "@/hooks/tableHeight";
 import { getTaskList, getWaypointByTaskId } from "@/api/inspection/task";
 import { computed, onMounted, onUnmounted } from "vue";
+import { useElementBounding, useElementSize } from '@vueuse/core'
 import { addRunTask, getRunTaskList, startRunTask, rerunRunTask, pauseRunTask, stopRunTask, resumeRunTask, deleteRunTask, getTaskLogListApi } from "@/api/inspection/runTask";
 import { ElMessage, ElMessageBox } from "element-plus";
 import { formatDate } from "@/utils/index";
@@ -189,6 +190,38 @@ import {
 
 const topContainerRef = ref();
 const containerHeight = useContainerHeight(topContainerRef);
+const contextContainerRef = ref(null)
+const taskLogContainerRef = ref(null)
+const taskLogTitleRef = ref(null)
+
+// 通过元素边界实时获取当前任务内容区底部和日志容器顶部，避免依赖固定的 460px。
+const { bottom: contextContainerBottom } = useElementBounding(contextContainerRef)
+const { top: taskLogContainerTop } = useElementBounding(taskLogContainerRef)
+const { height: taskLogTitleHeight } = useElementSize(taskLogTitleRef)
+
+const TASK_LOG_MARGIN_TOP = 12
+const CURRENT_TASK_BOTTOM_PADDING = 16
+const MIN_TASK_LOG_HEIGHT = 150
+
+/**
+ * 计算当前任务页面中日志组件可以使用的剩余高度。
+ *
+ * 计算基准是右侧内容区的底部，而不是窗口高度，因此页面外层布局、浏览器窗口
+ * 尺寸或右侧面板高度发生变化时都能得到正确结果。日志容器顶部到内容区底部之间，
+ * 还需要扣除“执行日志”标题高度、taskLog 组件自身的上间距，以及当前任务卡片的
+ * 底部内边距，确保日志不会覆盖任务卡片边界。元素尚未挂载时使用最低高度作为初始值，
+ * 待 VueUse 完成首次测量后会自动更新为实际剩余高度。
+ */
+const taskLogHeight = computed(() => {
+    const remainingHeight = contextContainerBottom.value
+        - taskLogContainerTop.value
+        - taskLogTitleHeight.value
+        - TASK_LOG_MARGIN_TOP
+        - CURRENT_TASK_BOTTOM_PADDING
+
+    return Math.max(MIN_TASK_LOG_HEIGHT, Math.floor(remainingHeight))
+})
+
 const socket = inject('ws');
 const startDialogVisible = ref(false)
 const startSubmitting = ref(false)
diff --git a/src/views/intelligenceTest/runningTask/index.vue b/src/views/intelligenceTest/runningTask/index.vue
index ab3e0de..a9b1fa9 100644
--- a/src/views/intelligenceTest/runningTask/index.vue
+++ b/src/views/intelligenceTest/runningTask/index.vue
@@ -36,7 +36,7 @@
                 <div class="label" :class="{ active: activePanel === 'history' }" @click="activePanel = 'history'">历史记录
                 </div>
             </div>
-            <div class="context-container">
+            <div ref="contextContainerRef" class="context-container">
                 <div v-if="activePanel === 'current'">
                     <!-- 当前任务区域只展示左侧队列选中的任务，不再同时渲染全部执行中任务。 -->
                     <div v-if="selectedRunTask" :key="selectedRunTask.id" class="task"
@@ -65,13 +65,13 @@
                             :percentage="parseFloat(taskRunningInfo[selectedRunTask.id]?.progress?.toFixed(2)) || 0" />
                         <taskSteps :list="pointList_runningTask[selectedRunTask.taskId]"
                             :activeStep="taskRunningInfo[selectedRunTask.id]?.activeStep || 0" />
-                        <div class="run-log-container">
-                            <div>执行日志</div>
+                        <div ref="taskLogContainerRef" class="run-log-container">
+                            <div ref="taskLogTitleRef">执行日志</div>
                             <!--
                                 taskId 用于查询检测项，taskStatus 用于在完成/失败/终止后推导最后一个已执行检测项的状态；
                                 两者与实例日志分开传入，避免把任务级字段重复写进每一条日志。
                             -->
-                            <taskLog :height="460" :task-id="selectedRunTask.taskId"
+                            <taskLog :height="taskLogHeight" :task-id="selectedRunTask.taskId"
                                 :task-status="selectedRunTask.status" :list="taskLogList[selectedRunTask.id]" />
                         </div>
                     </div>
@@ -194,6 +194,7 @@ import { getTaskList, getTestCaseByTaskId } from "@/api/intelligenceTest/taskMan
 import { getPhoneList } from "@/api/intelligenceTest/mobilePhone";
 import { getVehicleList } from "@/api/intelligenceTest/car";
 import { computed, onMounted, onUnmounted } from "vue";
+import { useElementBounding, useElementSize } from '@vueuse/core'
 import { 
     addTaskinstance,
     getTaskinstanceList,
@@ -219,6 +220,38 @@ import {
 
 const topContainerRef = ref();
 const containerHeight = useContainerHeight(topContainerRef);
+const contextContainerRef = ref(null)
+const taskLogContainerRef = ref(null)
+const taskLogTitleRef = ref(null)
+
+// 通过元素边界实时获取当前任务内容区底部和日志容器顶部，避免依赖固定的 460px。
+const { bottom: contextContainerBottom } = useElementBounding(contextContainerRef)
+const { top: taskLogContainerTop } = useElementBounding(taskLogContainerRef)
+const { height: taskLogTitleHeight } = useElementSize(taskLogTitleRef)
+
+const TASK_LOG_MARGIN_TOP = 12
+const CURRENT_TASK_BOTTOM_PADDING = 16
+const MIN_TASK_LOG_HEIGHT = 150
+
+/**
+ * 计算当前任务页面中日志组件可以使用的剩余高度。
+ *
+ * 计算基准是右侧内容区的底部，而不是窗口高度，因此页面外层布局、浏览器窗口
+ * 尺寸或右侧面板高度发生变化时都能得到正确结果。日志容器顶部到内容区底部之间，
+ * 还需要扣除“执行日志”标题高度、taskLog 组件自身的上间距，以及当前任务卡片的
+ * 底部内边距，确保日志不会覆盖任务卡片边界。元素尚未挂载时使用最低高度作为初始值，
+ * 待 VueUse 完成首次测量后会自动更新为实际剩余高度。
+ */
+const taskLogHeight = computed(() => {
+    const remainingHeight = contextContainerBottom.value
+        - taskLogContainerTop.value
+        - taskLogTitleHeight.value
+        - TASK_LOG_MARGIN_TOP
+        - CURRENT_TASK_BOTTOM_PADDING
+
+    return Math.max(MIN_TASK_LOG_HEIGHT, Math.floor(remainingHeight))
+})
+
 const socket = inject('ws');
 const startDialogVisible = ref(false)
 const startSubmitting = ref(false)

From 15f82efb4901d1a15582aeeb2f77cfdb5b196485 Mon Sep 17 00:00:00 2001
From: zhanghao <774378400@qq.com>
Date: Tue, 18 Aug 2026 14:11:17 +0800
Subject: [PATCH 4/4] =?UTF-8?q?feat:=20=E6=8C=89=E7=82=B9=E4=BD=8D?=
 =?UTF-8?q?=E5=88=86=E7=B1=BB=E5=B7=A1=E6=A3=80=E4=BB=BB=E5=8A=A1=E6=97=A5?=
 =?UTF-8?q?=E5=BF=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/views/inspection/runTask/index.vue    |  17 +-
 src/views/inspection/runTask/task-log.vue | 461 +++++++++++++++++++++-
 2 files changed, 473 insertions(+), 5 deletions(-)

diff --git a/src/views/inspection/runTask/index.vue b/src/views/inspection/runTask/index.vue
index 3435138..9db75fc 100644
--- a/src/views/inspection/runTask/index.vue
+++ b/src/views/inspection/runTask/index.vue
@@ -65,7 +65,10 @@
                             :activeStep="taskRunningInfo[selectedRunTask.id]?.activeStep || 0" />
                         <div ref="taskLogContainerRef" class="run-log-container">
                             <div ref="taskLogTitleRef">执行日志</div>
-                            <taskLog :height="taskLogHeight" :list="taskLogList[selectedRunTask.id]" />
+                            <taskLog :height="taskLogHeight" :task-id="selectedRunTask.taskId"
+                                :task-status="selectedRunTask.status"
+                                :points="pointList_runningTask[selectedRunTask.taskId]"
+                                :list="taskLogList[selectedRunTask.id]" />
                         </div>
                     </div>
                     <el-empty v-else description="暂无任务" />
@@ -143,8 +146,9 @@
             </template>
         </el-dialog>
 
-        <el-dialog title="任务执行日志" v-model="logDialogVisible" width="500px" append-to-body>
-            <taskLog v-loading="logDialogLoading" :list="logDialogData" :height="300" />
+        <el-dialog title="任务执行日志" v-model="logDialogVisible" width="800px" append-to-body>
+            <taskLog v-loading="logDialogLoading" :task-id="logDialogTaskId" :task-status="logDialogTaskStatus"
+                :list="logDialogData" :height="500" />
         </el-dialog>
 
         <el-dialog title="本次执行安排" v-model="startDialogVisible" width="820px" append-to-body>
@@ -610,11 +614,18 @@ const subscribeDebounced = debounce(async (sub) => {
 
 const logDialogVisible = ref(false)
 const logDialogData = ref([])
+// 历史日志组件需要任务定义 ID 查询该任务绑定的点位，并用任务终态推导未单独记录状态的点位结果。
+const logDialogTaskId = ref('')
+const logDialogTaskStatus = ref(null)
 const logDialogLoading = ref(false)
 let logDialogRequestId = 0
 const handleOpenLog = async (row) => {
     const requestId = ++logDialogRequestId
     logDialogVisible.value = true
+
+    // 先切换任务上下文，再请求日志；点位请求和日志请求可以并行，避免弹窗一直沿用上一次任务的数据。
+    logDialogTaskId.value = row.taskId
+    logDialogTaskStatus.value = row.status
     logDialogData.value = []
     logDialogLoading.value = true
     try {
diff --git a/src/views/inspection/runTask/task-log.vue b/src/views/inspection/runTask/task-log.vue
index 9156739..31e8947 100644
--- a/src/views/inspection/runTask/task-log.vue
+++ b/src/views/inspection/runTask/task-log.vue
@@ -1,12 +1,469 @@
 <template>
-  <TaskExecutionLog :list="list" :height="height" />
+  <div class="task-log" :style="{ height: `${height}px` }">
+    <!-- 折叠状态只展示点位名称和执行状态，节点日志需要点击点位后才展开。 -->
+    <div class="task-log__heading">
+      <span>点位</span>
+      <span>状态</span>
+    </div>
+
+    <div v-if="loading" class="task-log__empty">点位加载中...</div>
+    <div v-else-if="!groups.length" class="task-log__empty">暂无点位</div>
+    <div v-else class="task-log__groups">
+      <section v-for="(group, index) in groups" :key="group.key" class="task-log__group">
+        <!-- 整行可点击；aria-expanded 同步展开状态，便于键盘和辅助技术识别。 -->
+        <button
+          type="button"
+          class="task-log__group-header"
+          :aria-expanded="isExpanded(group.key)"
+          @click="toggleGroup(group.key)"
+        >
+          <el-icon class="task-log__expand-icon" :class="{ 'is-expanded': isExpanded(group.key) }">
+            <ArrowRight />
+          </el-icon>
+          <span class="task-log__order">{{ String(index + 1).padStart(2, '0') }}</span>
+          <span class="task-log__name" :title="group.fullName">{{ group.name }}</span>
+          <span class="task-log__statuses">
+            <el-tag :type="group.status.type" size="small">{{ group.status.label }}</el-tag>
+          </span>
+        </button>
+
+        <!-- 展开后只渲染当前点位对应的节点日志，避免不同点位的日志混在一起。 -->
+        <div v-if="isExpanded(group.key)" class="task-log__details">
+          <div class="task-log__details-heading">
+            <span>节点执行日志</span>
+            <span class="task-log__details-count">{{ group.logs.length }} 条</span>
+          </div>
+          <div v-if="group.nodeNames.length" class="task-log__nodes">
+            节点：{{ group.nodeNames.join('、') }}
+          </div>
+          <TaskExecutionLog
+            v-if="group.logs.length"
+            :list="group.logs"
+            :height="logHeight(group.logs)"
+          />
+          <div v-else class="task-log__details-empty">该点位暂未产生节点日志</div>
+        </div>
+      </section>
+    </div>
+  </div>
 </template>
 
 <script setup>
+import { computed, ref, watch } from 'vue'
+import { ArrowRight } from '@element-plus/icons-vue'
+import { getWaypointByTaskId } from '@/api/inspection/task'
 import TaskExecutionLog from '@/views/flow/components/TaskExecutionLog.vue'
 
-defineProps({
+/**
+ * taskId: 任务定义 ID。当父组件没有传入 points 时，用它查询任务所属的全部点位。
+ * taskStatus: 任务实例状态，用于在任务结束、失败或终止后推导点位的最终状态。
+ * list: 当前任务实例产生的日志；巡检日志接口中的 itemId 是点位的 detectItemId。
+ * points: 父组件已经查询到的点位列表，传入后优先使用，避免当前任务重复请求点位接口。
+ * height: 整个点位日志区域的高度，超出的点位和节点日志在区域内部滚动。
+ */
+const props = defineProps({
+  taskId: { type: [String, Number], default: '' },
+  taskStatus: { type: [String, Number], default: null },
   list: { type: Array, default: () => [] },
+  points: { type: Array, default: () => [] },
   height: { type: Number, default: 150 },
 })
+
+const taskPoints = ref([])
+const loading = ref(false)
+
+// 默认全部折叠，页面初始只显示点位和状态，不提前占用节点日志空间。
+const expandedKeys = ref(new Set())
+
+// 请求序号用于防止快速切换任务时，旧任务的点位响应覆盖新任务。
+let requestId = 0
+
+/**
+ * 后端 ID 可能以数字或字符串返回。统一转成字符串后再建立索引，避免 1 和 "1" 匹配失败。
+ * 空值不参与点位和日志归类，后续会进入“未关联点位”兜底分组，避免日志静默丢失。
+ */
+const valueOf = (value) => value === null || value === undefined || value === '' ? '' : String(value)
+
+/**
+ * 点位的唯一归属键。业务约定点位 detectItemId 与点位 ID 一一对应，日志 itemId 保存的是
+ * detectItemId，因此日志归类必须使用这个字段，而不是直接拿日志 itemId 去匹配点位 id。
+ */
+const pointKeyOf = (point) => valueOf(point?.detectItemId)
+
+// 巡检日志接口中的 itemId 就是点位的 detectItemId，这是唯一的主归类字段。
+const logKeyOf = (log) => valueOf(log?.itemId)
+
+// 点位名称兼容不同接口 DTO，正常情况下使用 waypointName。
+const nameOf = (point) => point?.waypointName || point?.name || point?.pointName || '未命名点位'
+
+/**
+ * 从日志中提取节点名称，用于展开区域的节点摘要。
+ * 兼容节点名称位于顶层、node 对象或 actualResult/extraInfo JSON 字段的情况。
+ */
+const parseObject = (value) => {
+  if (!value) return {}
+  if (typeof value === 'object') return value
+  try {
+    const parsed = JSON.parse(value)
+    return parsed && typeof parsed === 'object' ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+const uniqueValues = (values) => [...new Set(values.map(valueOf).filter(Boolean))]
+
+const nodeNameOf = (log) => {
+  const actualResult = parseObject(log?.actualResult)
+  const extraInfo = parseObject(log?.extraInfo)
+  return log?.nodeName
+    || log?.nodeTitle
+    || log?.node?.name
+    || log?.node?.nodeName
+    || actualResult.nodeName
+    || extraInfo.nodeName
+    || log?.nodeId
+    || ''
+}
+
+const normalizedStatus = (value) => String(value ?? '').trim().toLowerCase()
+
+/**
+ * 判断日志是否表示该点位已经执行完成。
+ * 普通节点完成只能说明流程继续推进，进度达到 100 或明确的成功状态才作为完成候选；
+ * 顺序执行任务中，如果后面的点位已经有日志，前面的点位也会由 statusOf 统一判定完成。
+ */
+const isPointCompletionLog = (log) => {
+  const statuses = [
+    log?.itemStatus,
+    log?.executionStatus,
+    log?.runStatus,
+    log?.resultStatus,
+    log?.state,
+    log?.status,
+  ].map(normalizedStatus)
+
+  return statuses.some((status) => ['0', 'success', 'succeeded', 'completed', 'complete', 'finished'].includes(status))
+    || Number(log?.progress) >= 100
+    || log?.completed === true
+    || log?.finished === true
+}
+
+/**
+ * 根据点位日志和任务实例状态计算点位状态。
+ * 优先级为：失败 > 终止 > 暂停 > 已完成 > 执行中；没有日志的点位固定为未执行。
+ * 对失败、终止和暂停任务，按顺序执行规则把最后一个产生日志的点位视为中断点。
+ */
+const statusOf = (logs, execution = {}) => {
+  if (!logs.length) return { label: '未执行', type: 'info' }
+
+  const statuses = logs.flatMap((log) => [
+    log?.itemStatus,
+    log?.executionStatus,
+    log?.runStatus,
+    log?.resultStatus,
+    log?.state,
+    log?.status,
+  ].map(normalizedStatus))
+
+  if (statuses.some((status) => ['2', 'failed', 'failure', 'error', 'exception'].includes(status))) {
+    return { label: '执行失败', type: 'danger' }
+  }
+  if (statuses.some((status) => ['4', 'stopped', 'terminated', 'aborted'].includes(status))) {
+    return { label: '已终止', type: 'warning' }
+  }
+  if (statuses.some((status) => ['3', 'paused', 'pause'].includes(status))) {
+    return { label: '已暂停', type: 'warning' }
+  }
+
+  const taskStatus = execution.taskStatus === null || execution.taskStatus === undefined || execution.taskStatus === ''
+    ? Number.NaN
+    : Number(execution.taskStatus)
+
+  // 任务整体完成时，所有实际产生过日志的点位都视为完成。
+  if (taskStatus === 0) return { label: '已完成', type: 'success' }
+
+  // 失败、终止或暂停时，最后一个有日志的点位是任务中断位置。
+  if (taskStatus === 2 || taskStatus === 4 || taskStatus === 3) {
+    if (execution.groupIndex < execution.lastLoggedIndex) {
+      return { label: '已完成', type: 'success' }
+    }
+    if (taskStatus === 2) return { label: '执行失败', type: 'danger' }
+    if (taskStatus === 4) return { label: '已终止', type: 'warning' }
+    return { label: '已暂停', type: 'warning' }
+  }
+
+  // 后续点位已经产生日志，说明当前点位已经执行完毕。
+  if (execution.groupIndex < execution.lastLoggedIndex) {
+    return { label: '已完成', type: 'success' }
+  }
+  if (logs.some(isPointCompletionLog)) {
+    return { label: '已完成', type: 'success' }
+  }
+  return { label: '执行中', type: 'primary' }
+}
+
+// 父组件传入点位时优先使用；历史日志弹窗没有现成点位时再使用 taskId 请求。
+const taskPointsSource = computed(() => props.points.length ? props.points : taskPoints.value)
+
+/**
+ * 将点位和日志合并成页面分组：
+ * 1. 先为每个点位创建空日志分组，保证没有执行过的点位也展示为未执行；
+ * 2. 使用 point.detectItemId 建立索引；
+ * 3. 使用 log.itemId 查找对应分组，确保一个点位的节点日志不会进入其他点位；
+ * 4. 最后计算节点摘要和点位执行状态。
+ */
+const groups = computed(() => {
+  const result = taskPointsSource.value.map((point, index) => {
+    const pointKey = pointKeyOf(point)
+    const name = nameOf(point)
+    return {
+      key: `point-${pointKey || index}`,
+      name,
+      fullName: name,
+      pointKey,
+      logs: [],
+    }
+  })
+
+  const keyToGroup = new Map()
+  result.forEach((group) => {
+    if (group.pointKey) keyToGroup.set(group.pointKey, group)
+  })
+
+  const unmatchedLogs = []
+  props.list.forEach((log) => {
+    const group = keyToGroup.get(logKeyOf(log))
+    if (group) group.logs.push(log)
+    else unmatchedLogs.push(log)
+  })
+
+  // 后端数据异常或历史日志字段不完整时保留日志，避免用户看不到已经产生的执行记录。
+  // if (unmatchedLogs.length) {
+  //   result.push({
+  //     key: 'unmatched',
+  //     name: '未关联点位',
+  //     fullName: '未关联点位',
+  //     pointKey: '',
+  //     logs: unmatchedLogs,
+  //   })
+  // }
+
+  const lastLoggedIndex = result.reduce((lastIndex, group, index) => (
+    group.logs.length ? index : lastIndex
+  ), -1)
+
+  return result.map((group, index) => ({
+    ...group,
+    nodeNames: uniqueValues(group.logs.map(nodeNameOf)),
+    status: statusOf(group.logs, {
+      groupIndex: index,
+      lastLoggedIndex,
+      taskStatus: props.taskStatus,
+    }),
+  }))
+})
+
+const isExpanded = (key) => expandedKeys.value.has(key)
+
+// 使用新 Set 替换旧值，确保 Vue 能可靠追踪集合变化并立即更新展开区域。
+const toggleGroup = (key) => {
+  const next = new Set(expandedKeys.value)
+  if (next.has(key)) next.delete(key)
+  else next.add(key)
+  expandedKeys.value = next
+}
+
+// 节点日志较少时避免留下大块空白，日志较多时在点位详情内部滚动。
+const logHeight = (logs) => Math.max(120, Math.min(320, 78 + logs.length * 58))
+
+/**
+ * 根据任务 ID 查询点位列表。父组件传入 points 时不重复请求；请求版本号保证快速切换
+ * 历史任务时，旧任务响应不会覆盖当前任务的点位列表。
+ */
+const loadTaskPoints = async (taskId) => {
+  const currentRequestId = ++requestId
+  if (!taskId || props.points.length) {
+    taskPoints.value = []
+    loading.value = false
+    return
+  }
+
+  loading.value = true
+  try {
+    const res = await getWaypointByTaskId(taskId)
+    if (currentRequestId === requestId) {
+      taskPoints.value = Array.isArray(res?.data)
+        ? res.data
+        : Array.isArray(res?.rows)
+          ? res.rows
+          : []
+    }
+  } catch {
+    if (currentRequestId === requestId) taskPoints.value = []
+  } finally {
+    if (currentRequestId === requestId) loading.value = false
+  }
+}
+
+// taskId 或外部点位列表变化时重新加载数据；计算分组会自动响应日志 list 的实时更新。
+watch(
+  () => [props.taskId, props.points.length],
+  ([taskId]) => loadTaskPoints(taskId),
+  { immediate: true },
+)
+
+// 切换任务后清理旧任务的展开项，避免新任务复用旧任务的展开状态。
+watch(() => groups.value.map((group) => group.key), (keys) => {
+  expandedKeys.value = new Set([...expandedKeys.value].filter((key) => keys.includes(key)))
+})
 </script>
+
+<style scoped lang="scss">
+.task-log {
+  margin-top: 12px;
+  overflow-y: auto;
+  background: #fff;
+  border: 1px solid #eee;
+  border-radius: 8px;
+}
+
+.task-log__heading,
+.task-log__group-header {
+  display: grid;
+  grid-template-columns: 22px 34px minmax(0, 1fr) auto;
+  gap: 8px;
+  align-items: center;
+}
+
+.task-log__heading {
+  padding: 10px 14px;
+  color: #98a2b3;
+  font-size: 12px;
+  border-bottom: 1px solid #f0f2f5;
+}
+
+.task-log__heading span:first-child {
+  grid-column: 3;
+}
+
+.task-log__heading span:last-child {
+  grid-column: 4;
+}
+
+.task-log__groups {
+  padding: 0 8px 8px;
+}
+
+.task-log__group {
+  border-bottom: 1px solid #f0f2f5;
+}
+
+.task-log__group:last-child {
+  border-bottom: 0;
+}
+
+.task-log__group-header {
+  width: 100%;
+  min-height: 48px;
+  padding: 8px 6px;
+  color: #344054;
+  text-align: left;
+  cursor: pointer;
+  background: transparent;
+  border: 0;
+}
+
+.task-log__group-header:hover {
+  background: #f8fafc;
+}
+
+.task-log__expand-icon {
+  color: #98a2b3;
+  transition: transform 0.2s ease;
+}
+
+.task-log__expand-icon.is-expanded {
+  transform: rotate(90deg);
+}
+
+.task-log__order {
+  color: #98a2b3;
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+}
+
+.task-log__name {
+  min-width: 0;
+  overflow: hidden;
+  font-size: 14px;
+  font-weight: 500;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.task-log__statuses {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  justify-self: end;
+}
+
+.task-log__details {
+  margin: 0 6px 10px 64px;
+  padding: 10px 12px 12px;
+  background: #f8fafc;
+  border-left: 2px solid #d0d5dd;
+}
+
+.task-log__details-heading {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  color: #475467;
+  font-size: 13px;
+  font-weight: 500;
+}
+
+.task-log__details-count,
+.task-log__nodes {
+  color: #98a2b3;
+  font-size: 12px;
+  font-weight: 400;
+}
+
+.task-log__nodes {
+  margin-top: 6px;
+  line-height: 18px;
+  word-break: break-word;
+}
+
+.task-log__details :deep(.task-log) {
+  margin-top: 8px;
+  border-color: #eaecf0;
+}
+
+.task-log__empty,
+.task-log__details-empty {
+  padding: 28px 12px;
+  color: #98a2b3;
+  font-size: 13px;
+  text-align: center;
+}
+
+.task-log__details-empty {
+  padding: 18px 0 6px;
+}
+
+@media (max-width: 640px) {
+  .task-log__details {
+    margin-left: 12px;
+  }
+
+  .task-log__heading,
+  .task-log__group-header {
+    grid-template-columns: 22px 26px minmax(0, 1fr) auto;
+    gap: 6px;
+  }
+}
+</style>