android-midscene-automation 0.1.31 → 0.1.32

package/CHANGELOG.md

@@ -1,10 +1,19 @@
 # 更新记录
 
+## v0.1.32
+- 添加画面变化结束节点时，多组可配对检测支持按名称及开始节点编号选择，允许交叉结束；只有一组时直接添加，保留分支及重复结束校验。
+- 画面变化结束节点校验覆盖祖先及子分支：同一执行路径已存在对应结束节点时，后续分支不能重复添加；互斥分支仍可分别结束。
+- 脚本列表新增“历史结果对比”：保存运行结果、应用版本、设备、截图和日志，支持筛选查看通过率、耗时趋势与失败节点分布，对比两次运行并删除选中历史；手动终止不计入通过率，旧报告不自动补录。
+- 画面变化检测在每个结束节点执行后立即对比本次截图，避免循环及重复调用脚本时多组检测复用最后一轮图片；截图缺失时明确报告异常，不使用旧图替代。
+- “启动 APP”支持在流程中途、判断分支及循环体内多次添加，按所选位置执行；连接脚本仅跳过开头的应用初始化，中途启动操作正常保留。
+- Midscene 相关模块统一从 1.12.2 升级至 1.12.5。
+
+
 ## v0.1.31
 - 组件详情展示 Resource ID、Accessibility ID、XPath 和 UiAutomator 四种定位内容，支持分别复制，方便配置循环退出条件；缺少对应属性时显示未提供。
 - “流程控制”新增有界循环及退出循环：支持固定次数、元素出现或消失时退出，必须设置最大执行次数；循环体支持嵌套判断、合流和连接脚本。退出节点可选择当前或外层循环，退出外层时同时结束内部循环并直接执行目标循环结束路径，日志及 HTML 报告标注轮次和退出目标。
 - 新增流程节点搜索，支持按名称、操作类型、定位内容和日志关键字筛选，展示所属分支并在多个结果间切换；普通画布与流程总览支持定位高亮，不改变节点布局及批量选中状态。
-- Midscene 相关模块统一从 1.12.0 升级至 1.12.2，包含 Android、Android Playground、Core、Playground、Shared 和 Web。
+- Midscene 相关模块统一从 1.12.0 升级至 1.12.2。
 - 录制工作区支持拖拽调整设备预览、组件树栏宽，自动保存布局并支持恢复默认。 
 
 ## v0.1.30

package/README.md

@@ -1229,11 +1229,20 @@ Linux: ~/.local/share/android-midscene-automation
 
 # 项目更新记录
 
+## v0.1.32
+- 添加画面变化结束节点时，多组可配对检测支持按名称及开始节点编号选择，允许交叉结束；只有一组时直接添加，保留分支及重复结束校验。
+- 画面变化结束节点校验覆盖祖先及子分支：同一执行路径已存在对应结束节点时，后续分支不能重复添加；互斥分支仍可分别结束。
+- 脚本列表新增“历史结果对比”：保存运行结果、应用版本、设备、截图和日志，支持筛选查看通过率、耗时趋势与失败节点分布，对比两次运行并删除选中历史；手动终止不计入通过率，旧报告不自动补录。
+- 画面变化检测在每个结束节点执行后立即对比本次截图，避免循环及重复调用脚本时多组检测复用最后一轮图片；截图缺失时明确报告异常，不使用旧图替代。
+- “启动 APP”支持在流程中途、判断分支及循环体内多次添加，按所选位置执行；连接脚本仅跳过开头的应用初始化，中途启动操作正常保留。
+- Midscene 相关模块统一从 1.12.2 升级至 1.12.5。
+
+
 ## v0.1.31
 - 组件详情展示 Resource ID、Accessibility ID、XPath 和 UiAutomator 四种定位内容，支持分别复制，方便配置循环退出条件；缺少对应属性时显示未提供。
 - “流程控制”新增有界循环及退出循环：支持固定次数、元素出现或消失时退出，必须设置最大执行次数；循环体支持嵌套判断、合流和连接脚本。退出节点可选择当前或外层循环，退出外层时同时结束内部循环并直接执行目标循环结束路径，日志及 HTML 报告标注轮次和退出目标。
 - 新增流程节点搜索，支持按名称、操作类型、定位内容和日志关键字筛选，展示所属分支并在多个结果间切换；普通画布与流程总览支持定位高亮，不改变节点布局及批量选中状态。
-- Midscene 相关模块统一从 1.12.0 升级至 1.12.2，包含 Android、Android Playground、Core、Playground、Shared 和 Web。
+- Midscene 相关模块统一从 1.12.0 升级至 1.12.2。
 - 录制工作区支持拖拽调整设备预览、组件树栏宽，自动保存布局并支持恢复默认。 
 
 ## v0.1.30

package/bin/sync-readme-docs.mjs

@@ -0,0 +1,49 @@
+import { readFile, writeFile } from 'node:fs/promises';
+
+const generatedStart = '<!-- generated-docs:start -->';
+const generatedEnd = '<!-- generated-docs:end -->';
+const readmeUrl = new URL('../README.md', import.meta.url);
+
+const stripFirstHeading = (markdown) =>
+  markdown.replace(/^#\s+[^\r\n]+\r?\n+/, '').trim();
+
+const stripUsageFaqPointer = (markdown) =>
+  markdown.replace(
+    /\n## 常见问题\r?\n\r?\n常见问题已独立整理到 \[FAQ\.md\]\(\.\/FAQ\.md\)。\r?\n/g,
+    '\n',
+  );
+
+const linkReadmeAnchors = (markdown) =>
+  markdown.replace(/\[FAQ\.md\]\(\.\/FAQ\.md\)/g, '[常见问题](#常见问题)');
+
+const [readme, usage, faq, changelog] = await Promise.all([
+  readFile(readmeUrl, 'utf8'),
+  readFile(new URL('../USAGE.md', import.meta.url), 'utf8'),
+  readFile(new URL('../FAQ.md', import.meta.url), 'utf8'),
+  readFile(new URL('../CHANGELOG.md', import.meta.url), 'utf8'),
+]);
+
+const generatedIndex = readme.indexOf(generatedStart);
+const readmeBody = (
+  generatedIndex >= 0 ? readme.slice(0, generatedIndex) : readme
+).trimEnd();
+
+const generatedDocs = [
+  generatedStart,
+  '',
+  '# Appium 录制器使用说明',
+  '',
+  linkReadmeAnchors(stripUsageFaqPointer(stripFirstHeading(usage))),
+  '',
+  '# 常见问题',
+  '',
+  stripFirstHeading(faq),
+  '',
+  '# 项目更新记录',
+  '',
+  stripFirstHeading(changelog),
+  '',
+  generatedEnd,
+].join('\n');
+
+await writeFile(readmeUrl, `${readmeBody}\n\n${generatedDocs}\n`, 'utf8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "android-midscene-automation",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oooooooko/android-midscene-automation.git"
@@ -28,7 +28,7 @@
   ],
   "scripts": {
     "dev": "vite --host 127.0.0.1",
-    "prepack": "node scripts/sync-readme-docs.mjs",
+    "prepack": "node bin/sync-readme-docs.mjs",
     "remote-agent": "tsx remote-agent/index.ts",
     "build": "vue-tsc -b && vite build",
     "preview": "vite preview --host 127.0.0.1",
@@ -38,12 +38,12 @@
   "dependencies": {
     "@dagrejs/dagre": "1.1.5",
     "@element-plus/icons-vue": "2.3.2",
-    "@midscene/android": "https://registry.npmjs.org/@midscene/android/-/android-1.12.2.tgz",
-    "@midscene/android-playground": "https://registry.npmjs.org/@midscene/android-playground/-/android-playground-1.12.2.tgz",
-    "@midscene/core": "https://registry.npmjs.org/@midscene/core/-/core-1.12.2.tgz",
-    "@midscene/playground": "https://registry.npmjs.org/@midscene/playground/-/playground-1.12.2.tgz",
-    "@midscene/shared": "https://registry.npmjs.org/@midscene/shared/-/shared-1.12.2.tgz",
-    "@midscene/web": "https://registry.npmjs.org/@midscene/web/-/web-1.12.2.tgz",
+    "@midscene/android": "https://registry.npmjs.org/@midscene/android/-/android-1.12.5.tgz",
+    "@midscene/android-playground": "https://registry.npmjs.org/@midscene/android-playground/-/android-playground-1.12.5.tgz",
+    "@midscene/core": "https://registry.npmjs.org/@midscene/core/-/core-1.12.5.tgz",
+    "@midscene/playground": "https://registry.npmjs.org/@midscene/playground/-/playground-1.12.5.tgz",
+    "@midscene/shared": "https://registry.npmjs.org/@midscene/shared/-/shared-1.12.5.tgz",
+    "@midscene/web": "https://registry.npmjs.org/@midscene/web/-/web-1.12.5.tgz",
     "@vitejs/plugin-vue": "6.0.7",
     "@vue-flow/core": "1.48.2",
     "archiver": "7.0.1",

package/remote-agent/index.ts

@@ -18,7 +18,7 @@ const agentName = argValue('agent-name', agentId);
 const token = argValue('token', process.env.REMOTE_AGENT_TOKEN || '');
 
 if (!server) {
-  console.error('缺少 --server，例如：npm run remote-agent -- --server http://172.16.20.116:5173');
+  console.error('缺少 --server，例如：npm run remote-agent -- --server http://<控制台主机地址>:5173');
   process.exit(1);
 }
 

package/server/appium-recorder/appium-runner.ts

@@ -1,4 +1,5 @@
 import { execFile } from 'node:child_process';
+import { captureHistoryFrames, readAppVersion } from './history-capture';
 import { BoundedLoopTraversal } from './bounded-loop';
 import { validateLoopSteps } from '../../src/appium-recorder/bounded-loop';
 import { adbScreenshotBase64 } from './screenshot';
@@ -49,6 +50,8 @@ type PendingVisualChangeCheck = {
   step: AppiumRecordedStepRecord;
   nodeNumber: number;
   scriptName: string;
+  frameStart: number;
+  endFrameStart: number;
 };
 
 const replayContext = new AsyncLocalStorage<{
@@ -57,8 +60,10 @@ const replayContext = new AsyncLocalStorage<{
   serverUrl: string;
   deviceId: string;
   frames: AppiumReplayFrame[];
+  historyEvents: AppiumReplayFrame[];
   visualChecks: AppiumReplayVisualCheck[];
   pendingVisualChecks: PendingVisualChangeCheck[];
+  visualStartOffsets: Map<string, number>;
   softFailureCount: number;
   flowEnded?: boolean;
 }>();
@@ -332,6 +337,10 @@ async function captureReplayFrame(
 ) {
   const context = replayContext.getStore();
   if (!context || !context.deviceId) return;
+  // 执行记录独立于截图，设备截图失败不能让失败节点从统计中消失。
+  context.historyEvents.push({ sequence: context.historyEvents.length + 1, scriptName, nodeId: step.id,
+    nodeNumber, nodeLabel: step.label, nodeType: step.type, note: step.note || '',
+    selector: replayFrameSelector(step), phase, status, capturedAt: new Date().toISOString(), imageBase64: '' });
   const appendFrame = (imageBase64: string) => {
     context.frames.push({
       sequence: context.frames.length + 1,
@@ -519,6 +528,7 @@ async function saveScreenshot(deviceId: string) {
 type RunStepMeta = {
   nodeNumber: number;
   scriptName: string;
+  frameStart?: number;
 };
 
 type RunStepResult = string | {
@@ -560,10 +570,9 @@ function findVisualFrame(
 ) {
   const matches = frames.filter((frame) => frame.nodeId === nodeId && frame.scriptName === scriptName);
   if (!matches.length) return undefined;
-  const preferred = preferredPhase === 'before'
-    ? matches.find((frame) => frame.phase === preferredPhase)
-    : [...matches].reverse().find((frame) => frame.phase === preferredPhase);
-  return preferred || (preferredPhase === 'before' ? matches[0] : matches[matches.length - 1]);
+  const frame = preferredPhase === 'before' ? matches[0] : matches[matches.length - 1];
+  // A failed capture must not fall back to an older round or a before/error image.
+  return frame?.phase === preferredPhase ? frame : undefined;
 }
 
 const EMPTY_PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=';
@@ -574,12 +583,14 @@ function registerVisualChangeStep(
 ): RunStepResult {
   const config = step.visualChange;
   if (!config) throw new Error(`${step.label} 缺少画面变化检测配置`);
+  const context = replayContext.getStore();
   if (config.role === 'start') {
+    // Invalidate the previous capture even when this start's after screenshot fails.
+    context?.visualStartOffsets.set(JSON.stringify([meta.frameStart || 0, step.id]), context.frames.length);
     return {
       message: `已记录画面变化基准点：${config.pairLabel || step.label}`,
     };
   }
-  const context = replayContext.getStore();
   const endStep = {
     ...step,
     visualChange: {
@@ -587,7 +598,9 @@ function registerVisualChangeStep(
       endStepId: config.endStepId || step.id,
     },
   };
-  context?.pendingVisualChecks.push({ step: endStep, nodeNumber: meta.nodeNumber, scriptName: meta.scriptName });
+  context?.pendingVisualChecks.push({ step: endStep, nodeNumber: meta.nodeNumber, scriptName: meta.scriptName,
+    frameStart: context.visualStartOffsets.get(JSON.stringify([meta.frameStart || 0, config.startStepId])) ?? meta.frameStart ?? 0,
+    endFrameStart: context.frames.length });
   return {
     message: `已记录画面变化对比点：${config.pairLabel || step.label}`,
   };
@@ -624,16 +637,16 @@ function processPendingVisualChecks(lines: string[]) {
   const context = replayContext.getStore();
   if (!context || !context.pendingVisualChecks.length) return;
 
-  // Visual checks compare captured replay frames after the path finishes, so
-  // they never block or mutate the device state for downstream nodes.
+  // Resolve each pair immediately after its end capture, before later rounds
+  // or linked-script calls can replace the images associated with these IDs.
   context.pendingVisualChecks.forEach((check) => {
     const config = check.step.visualChange;
     if (!config?.startStepId || !config.endStepId) {
       appendVisualCheckFailure(lines, check, `${check.step.label} 缺少开始节点或结束节点`);
       return;
     }
-    const baselineFrame = findVisualFrame(context.frames, config.startStepId, check.scriptName, 'after');
-    const comparisonFrame = findVisualFrame(context.frames, config.endStepId, check.scriptName, 'after');
+    const baselineFrame = findVisualFrame(context.frames.slice(check.frameStart, check.endFrameStart), config.startStepId, check.scriptName, 'after');
+    const comparisonFrame = findVisualFrame(context.frames.slice(check.endFrameStart), config.endStepId, check.scriptName, 'after');
     if (!baselineFrame || !comparisonFrame) {
       const missing = [
         baselineFrame ? '' : '开始节点截图',
@@ -1005,12 +1018,17 @@ async function appendStepDiagnostics(lines: string[], deviceId: string, step: Ap
 }
 
 type ReplayStepOptions = {
+  frameStart?: number;
   skipAppInitialization?: boolean;
   scriptName?: string;
 };
 
-function shouldSkipLinkedScriptInitStep(options: ReplayStepOptions, step: AppiumRecordedStepRecord) {
-  return Boolean(options.skipAppInitialization && (step.type === 'launchApp' || step.type === 'clearAppData'));
+function shouldSkipLinkedScriptInitStep(options: ReplayStepOptions, step: AppiumRecordedStepRecord, steps: AppiumRecordedStepRecord[]) {
+  if (!options.skipAppInitialization) return false;
+  // Only the leading initialization sequence is redundant in a linked script.
+  // Launches inside branches or after other operations are intentional actions.
+  return steps.slice(0, steps.indexOf(step) + 1).every(item =>
+    !item.flow?.parentConditionId && (item.type === 'launchApp' || item.type === 'clearAppData'));
 }
 
 function linkedScriptInitSkipReason(step: AppiumRecordedStepRecord) {
@@ -1090,7 +1108,7 @@ async function replayLinearSteps(
   for (const [index, step] of steps.entries()) {
     if (replayContext.getStore()?.flowEnded) return;
     throwIfReplayStopped();
-    if (shouldSkipLinkedScriptInitStep(options, step)) {
+    if (shouldSkipLinkedScriptInitStep(options, step, steps)) {
       lines.push(`[节点 ${index + 1}] 跳过：${step.label}（${linkedScriptInitSkipReason(step)}）`);
       continue;
     }
@@ -1104,11 +1122,13 @@ async function replayLinearSteps(
         const result = await runStep(sessionId, deviceId, step, {
           nodeNumber: index + 1,
           scriptName: options.scriptName || '',
+          frameStart: options.frameStart,
         });
         softFailed = appendRunStepResult(lines, index + 1, result);
       }
       lines.push(`[节点 ${index + 1}] 完成：${step.label}${softFailed ? '（存在软失败，已继续）' : ''}`);
       await captureReplayFrame(sessionId, step, index + 1, options.scriptName || '', 'after', completedStepStatus(step, softFailed));
+      processPendingVisualChecks(lines);
     } catch (error) {
       if (isReplayStopped(error)) {
         lines.push(`[节点 ${index + 1}] 已终止：${step.label}`);
@@ -1144,7 +1164,7 @@ async function replayFlowSteps(
     traversal.visit(step);
     const loopContext = traversal.context(step);
     const frameStep = loopContext ? { ...step, label: `${step.label}（${loopContext}）` } : step;
-    if (shouldSkipLinkedScriptInitStep(options, step)) {
+    if (shouldSkipLinkedScriptInitStep(options, step, steps)) {
       lines.push(`[节点 ${index + 1}] 跳过：${step.label}（${linkedScriptInitSkipReason(step)}）`);
       index = nextIndexAfterStep(index, step);
       continue;
@@ -1225,11 +1245,13 @@ async function replayFlowSteps(
         const result = await runStep(sessionId, deviceId, step, {
           nodeNumber: index + 1,
           scriptName: options.scriptName || '',
+          frameStart: options.frameStart,
         });
         softFailed = appendRunStepResult(lines, index + 1, result);
       }
       lines.push(`[节点 ${index + 1}] 完成：${step.label}${softFailed ? '（存在软失败，已继续）' : ''}`);
       await captureReplayFrame(sessionId, frameStep, index + 1, options.scriptName || '', 'after', completedStepStatus(step, softFailed));
+      processPendingVisualChecks(lines);
       index = nextIndexAfterStep(index, step);
     } catch (error) {
       if (isReplayStopped(error)) {
@@ -1278,6 +1300,7 @@ async function replayScriptSteps(
   options: ReplayStepOptions = {},
 ) {
   validateLoopSteps(steps);
+  options = { ...options, frameStart: replayContext.getStore()?.frames.length || 0 };
   let trailingLinkIndex = steps.length;
   while (
     trailingLinkIndex > 0
@@ -1325,6 +1348,7 @@ export async function replayAppiumScript(
   if (!script.steps.length) throw new Error('脚本没有可回放步骤');
 
   const startedAt = new Date();
+  const appVersion = await readAppVersion(targetDeviceId, script.appPackage).catch(() => '');
   const lines: string[] = [];
   const pushLine = lines.push.bind(lines);
   lines.push = (...items: string[]) => {
@@ -1338,7 +1362,9 @@ export async function replayAppiumScript(
     serverUrl: configuredAppiumServerUrl(),
     deviceId: targetDeviceId,
     frames: [] as AppiumReplayFrame[],
+    historyEvents: [] as AppiumReplayFrame[],
     visualChecks: [] as AppiumReplayVisualCheck[],
+    visualStartOffsets: new Map<string, number>(),
     pendingVisualChecks: [] as PendingVisualChangeCheck[],
     softFailureCount: 0,
   };
@@ -1461,6 +1487,14 @@ export async function replayAppiumScript(
       logPath,
       htmlReportPath,
       softFailureCount: context.softFailureCount,
+      history: {
+        scriptId: script.id, scriptName: script.name, appPackage: script.appPackage,
+        appVersion, deviceId: targetDeviceId, startedAt: startedAt.toISOString(),
+        durationMs: completedAt.getTime() - startedAt.getTime(),
+        status: stopped ? 'stopped' as const : success ? 'passed' as const : 'failed' as const,
+        output: lines.join('\n'),
+        ...captureHistoryFrames(context.frames, context.visualChecks, context.historyEvents),
+      },
     };
   });
 }

package/server/appium-recorder/history-capture.ts

@@ -0,0 +1,34 @@
+import { execFile } from 'node:child_process';
+import { getAdbCommand } from '../android-sdk';
+import { htmlImageUrl, type AppiumReplayFrame, type AppiumReplayVisualCheck } from './report';
+import type { HistoryNode } from '../../src/appium-recorder/run-history';
+
+export function readAppVersion(deviceId: string, appPackage: string): Promise<string> {
+  if (!appPackage) return Promise.resolve('');
+  return new Promise(resolve => {
+    execFile(getAdbCommand(), ['-s', deviceId, 'shell', 'dumpsys', 'package', appPackage], { timeout: 5000, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => {
+      if (error) return resolve('');
+      const name = stdout.match(/\bversionName=([^\r\n]+)/)?.[1]?.trim();
+      const code = stdout.match(/\bversionCode=(\d+)/)?.[1];
+      resolve(name ? `${name}${code ? ` (${code})` : ''}` : '');
+    });
+  });
+}
+
+export function captureHistoryFrames(frames: AppiumReplayFrame[], checks: AppiumReplayVisualCheck[], events = frames) {
+  const cache = new Map<string, string>();
+  const nodes: HistoryNode[] = [];
+  const pending = new Map<string, AppiumReplayFrame>();
+  for (const frame of events) {
+    const key = frame.nodeId;
+    if (frame.phase === 'before') { pending.set(key, frame); continue; }
+    const start = pending.get(key);
+    pending.delete(key);
+    if (frame.phase !== 'stopped') nodes.push({ key, label: `${frame.scriptName} / ${frame.nodeLabel}`, failed: frame.phase === 'error', durationMs: start ? Math.max(0, Date.parse(frame.capturedAt) - Date.parse(start.capturedAt)) : null });
+  }
+  for (const check of checks.filter(check => check.status === 'failed')) {
+    const node = nodes.find(node => node.key === check.nodeId);
+    if (node) node.failed = true;
+  }
+  return { nodes, frames: frames.map(frame => ({ key: frame.nodeId, label: frame.nodeLabel, phase: frame.phase, capturedAt: frame.capturedAt, imageUrl: htmlImageUrl(frame.imageBase64, cache) })) };
+}

package/server/appium-recorder/report.ts

@@ -126,7 +126,7 @@ function compressHtmlPngBase64(base64: string) {
   }
 }
 
-function htmlImageUrl(base64: string, cache: Map<string, string>) {
+export function htmlImageUrl(base64: string, cache: Map<string, string>) {
   const cached = cache.get(base64);
   if (cached) return cached;
 

package/server/appium-recorder/routes.ts

@@ -1,4 +1,5 @@
 import { execFile } from 'node:child_process';
+import { deleteRunHistory, getRunHistory, listRunHistory, saveRunHistory } from './run-history';
 import { recognizeDeviceScreen } from './ai-recognition';
 import { readFreshWindowHierarchy } from './tree-dump';
 import type { IncomingMessage, ServerResponse } from 'node:http';
@@ -307,6 +308,21 @@ export async function handleAppiumRecorderRequest(
       return true;
     }
 
+    const historyMatch = pathname.match(/^\/api\/appium-recorder\/scripts\/([^/]+)\/history(?:\/([^/]+))?$/);
+    if (historyMatch) {
+      const scriptId = decodeURIComponent(historyMatch[1]);
+      const id = historyMatch[2] ? decodeURIComponent(historyMatch[2]) : '';
+      if (req.method === 'GET') {
+        const data = id ? getRunHistory(scriptId, id) : listRunHistory(scriptId);
+        sendJson(res, data, data ? 200 : 404);
+        return true;
+      }
+      if (req.method === 'DELETE' && id) {
+        deleteRunHistory(scriptId, id);
+        sendJson(res, { success: true });
+        return true;
+      }
+    }
     const replayMatch = pathname.match(/^\/api\/appium-recorder\/scripts\/([^/]+)\/replay$/);
     if (replayMatch && req.method === 'POST') {
       const parsed = await readBody<{ deviceId?: string }>(req);
@@ -323,13 +339,18 @@ export async function handleAppiumRecorderRequest(
         res.flushHeaders();
       }
       if (isRemoteDeviceId(deviceId)) {
-        const result = await sendRemoteCommand(deviceId, 'replay', { script }) as { success?: boolean; output?: string };
+        const result = await sendRemoteCommand(deviceId, 'replay', { script }) as Awaited<ReturnType<typeof replayAppiumScript>>;
+        if (result.history) {
+          try { saveRunHistory({ ...result.history, scriptId: script.id, deviceId }); }
+          catch { result.output += '\n历史记录保存失败'; }
+        }
+        const { history: _history, ...response } = result;
         if (streamOutput) {
           result.output?.split(/\r?\n/).forEach((line) => sendStreamEvent(res, { type: 'log', line }));
-          sendStreamEvent(res, { type: 'result', ...result });
+          sendStreamEvent(res, { type: 'result', ...response });
           res.end();
         } else {
-          sendJson(res, result, result.success ? 200 : 500);
+          sendJson(res, response, result.success ? 200 : 500);
         }
         return true;
       }
@@ -346,11 +367,14 @@ export async function handleAppiumRecorderRequest(
           streamOutput ? (line) => sendStreamEvent(res, { type: 'log', line }) : undefined,
           replayAbortController.signal,
         );
+        try { saveRunHistory(result.history); }
+        catch { result.output += '\n历史记录保存失败'; }
+        const { history: _history, ...response } = result;
         if (streamOutput) {
-          sendStreamEvent(res, { type: 'result', ...result });
+          sendStreamEvent(res, { type: 'result', ...response });
           res.end();
         } else {
-          sendJson(res, result, result.success ? 200 : 500);
+          sendJson(res, response, result.success ? 200 : 500);
         }
       } finally {
         replayingDevices.delete(deviceId);

package/server/appium-recorder/run-history.ts

@@ -0,0 +1,34 @@
+import { createId, querySql, runSql, sqlJson, sqlString } from '../storage/sqlite';
+import type { RunDetail, RunSummary } from '../../src/appium-recorder/run-history';
+
+function ensureTable() {
+  runSql(`CREATE TABLE IF NOT EXISTS appium_run_history (
+    id TEXT PRIMARY KEY, script_id TEXT NOT NULL, started_at TEXT NOT NULL,
+    summary TEXT NOT NULL, detail TEXT NOT NULL
+  ); CREATE INDEX IF NOT EXISTS appium_run_history_script ON appium_run_history(script_id, started_at);`);
+}
+
+export function saveRunHistory(input: Omit<RunDetail, 'id'>) {
+  ensureTable();
+  const record = { ...input, id: createId('run') };
+  const { frames, output, ...summary } = record;
+  runSql(`INSERT INTO appium_run_history VALUES (${sqlString(record.id)}, ${sqlString(record.scriptId)}, ${sqlString(record.startedAt)}, ${sqlJson(summary)}, ${sqlJson({ frames, output })});`);
+  return record.id;
+}
+
+export function listRunHistory(scriptId: string): RunSummary[] {
+  ensureTable();
+  return (querySql<{ summary: string }>(`SELECT summary FROM appium_run_history WHERE script_id=${sqlString(scriptId)} ORDER BY started_at DESC;`) || []).map(row => JSON.parse(row.summary));
+}
+
+export function getRunHistory(scriptId: string, id: string): RunDetail | null {
+  ensureTable();
+  const row = querySql<{ summary: string; detail: string }>(`SELECT summary, detail FROM appium_run_history WHERE script_id=${sqlString(scriptId)} AND id=${sqlString(id)};`)?.[0];
+  return row ? { ...JSON.parse(row.summary), ...JSON.parse(row.detail) } : null;
+}
+
+export function deleteRunHistory(scriptId: string, id: string) {
+  ensureTable();
+  // 不接受文件路径，也不删除原始报告；只删除这条历史的自包含快照。
+  runSql(`PRAGMA secure_delete=ON; DELETE FROM appium_run_history WHERE script_id=${sqlString(scriptId)} AND id=${sqlString(id)};`);
+}

package/src/appium-recorder/AppiumPage.vue

@@ -2,11 +2,13 @@
 import { computed, h, onMounted, onUnmounted, provide, reactive, shallowRef, watch } from 'vue';
 import { flowBackgroundKey, normalizeFlowBackground } from './flow-appearance';
 import { ElForm, ElFormItem, ElInputNumber, ElMessage, ElMessageBox, ElOption, ElSelect } from 'element-plus';
-import { Check, CircleClose, CopyDocument, Delete, Document, Download, Edit, Plus, Refresh, Upload, VideoPlay, View } from '@element-plus/icons-vue';
+import { Check, CircleClose, CopyDocument, Delete, Document, Download, Edit, Plus, Refresh, Upload, VideoPlay, View, Clock } from '@element-plus/icons-vue';
+import RunHistoryDialog from './RunHistoryDialog.vue';
 import type { AndroidDevice, AppPreset, DeviceAction } from '../types';
 import DevicePreviewPanel from '../components/device/DevicePreviewPanel.vue';
 import LoopSettings from './components/LoopSettings.vue';
 import BreakLoopSettings from './components/BreakLoopSettings.vue';
+import VisualChangeEndPicker from './components/VisualChangeEndPicker.vue';
 import { defaultLoopConfig, enclosingLoops, breakLoopTarget, validateLoop, validateLoopSteps } from './bounded-loop';
 import {
   clearAppiumDeviceAppData,
@@ -53,7 +55,7 @@ import {
   visualRegionToBounds,
 } from './visual-change';
 import {
-  findOpenVisualChangeStart,
+  findOpenVisualChangeStarts,
   nextVisualChangePairLabel,
 } from './visual-change-pairs';
 import type {
@@ -80,6 +82,7 @@ type RecorderAction = InsertAction;
 
 const WORKBENCH_TAB_STORAGE_KEY = 'android-midscene-automation:appium-workbench-tab';
 const workspaceRef = shallowRef<InstanceType<typeof RecorderWorkspace>>();
+const historyScript = shallowRef<{ id: string; name: string } | null>(null);
 const AUTO_TREE_REFRESH_INTERVAL_MS = 1800;
 
 const insertableRecorderActions: RecorderAction[] = [
@@ -1266,11 +1269,6 @@ async function addAction(
 ) {
   if (recordingBusy.value) return;
   if (!ensureAppPackageSelected()) return;
-  const previousStep = typeof index === 'number' && index >= 0 ? steps.value[index] : undefined;
-  if (action === 'launchApp' && steps.value.some((step) => step.type === 'launchApp')) {
-    ElMessage.warning('启动 APP 节点只能添加一个');
-    return;
-  }
   if (action === 'clearAppData' && steps.value.some((step) => step.type === 'clearAppData')) {
     ElMessage.warning('清理 App 缓存节点只能添加一个');
     return;
@@ -1279,10 +1277,6 @@ async function addAction(
     ElMessage.warning('清理 App 缓存只能从开始节点添加');
     return;
   }
-  if (action === 'launchApp' && index !== -1 && previousStep?.type !== 'clearAppData') {
-    ElMessage.warning('启动 APP 只能从开始节点或清理 App 缓存后添加');
-    return;
-  }
   if (action === 'runScript') {
     openLinkedScriptDialog(index, branchTarget);
     return;
@@ -1406,11 +1400,31 @@ async function addAction(
     return;
   }
   if (action === 'visualChangeEnd') {
-    const startStep = findOpenVisualChangeStart(steps.value, index, branchTarget);
-    if (!startStep) {
+    const candidates = findOpenVisualChangeStarts(steps.value, index, branchTarget);
+    if (!candidates.length) {
       ElMessage.warning('当前分支没有可对应的检测画面变化开始节点');
       return;
     }
+    let selectedId = candidates.length === 1 ? candidates[0].id : '';
+    if (candidates.length > 1) {
+      selectedId = await new Promise<string>((resolve) => { void ElMessageBox({
+        title: '选择要结束的画面变化检测',
+        showConfirmButton: false,
+        showCancelButton: false,
+        callback: () => resolve(''),
+        message: h(VisualChangeEndPicker, {
+          candidates: candidates.map(step => ({ id: step.id, label: step.visualChange?.pairLabel || step.label, number: steps.value.findIndex(item => item.id === step.id) + 1 })),
+          onSelect: (id: string) => { resolve(id); ElMessageBox.close(); },
+        }),
+      }); });
+      if (!selectedId) return;
+    }
+    // 选择期间流程可能发生变化；插入前重新检查配对，不能使用过期候选。
+    const startStep = findOpenVisualChangeStarts(steps.value, index, branchTarget).find(step => step.id === selectedId);
+    if (!startStep) {
+      ElMessage.warning('该开始节点已结束或不再属于当前路径，请重新选择');
+      return;
+    }
     const inserted = insertStep(createVisualChangeEndStep(startStep), index, branchTarget);
     ElMessage.success(`已添加 ${inserted.label}`);
     return inserted;
@@ -1460,14 +1474,12 @@ async function addAction(
     return;
   }
   if (action === 'launchApp') {
-    const clearStepIndex = steps.value.findIndex((step) => step.type === 'clearAppData');
-    const insertIndex = previousStep?.type === 'clearAppData' ? index : clearStepIndex >= 0 ? clearStepIndex : index;
     return insertStep({
       id: `step_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
       type: 'launchApp',
       label: `启动 APP ${form.appPackage}`,
       value: form.appPackage,
-    }, insertIndex);
+    }, index, branchTarget);
   }
   if (action === 'clearAppData') {
     return insertStep({
@@ -2208,6 +2220,9 @@ watch(
                     <small>{{ script.steps.length }} 步 · {{ formatScriptTime(script.updatedAt) }}</small>
                   </div>
                   <div class="appium-script-list__actions">
+                    <el-tooltip content="历史结果对比" placement="top" :show-after="200"><span class="appium-script-icon">
+                      <el-button size="small" :icon="Clock" aria-label="历史结果对比" @click.stop="historyScript = { id: script.id, name: script.name }" />
+                    </span></el-tooltip>
                     <el-tooltip content="加载" placement="top" :show-after="200"><span class="appium-script-icon">
                       <el-button size="small" :icon="Document" aria-label="加载" @click.stop="loadScript(script)" />
                     </span></el-tooltip>
@@ -2258,6 +2273,7 @@ watch(
       </el-card>
     </RecorderWorkspace>
 
+    <RunHistoryDialog v-if="historyScript" :script-id="historyScript.id" :script-name="historyScript.name" @close="historyScript = null" />
     <NewScriptDialog
       v-if="newScriptDialogVisible"
       :script-name="form.name"

package/src/appium-recorder/RunHistoryDialog.vue

@@ -0,0 +1,153 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue';
+import { Delete, Refresh } from '@element-plus/icons-vue';
+import { ElMessage, ElMessageBox } from 'element-plus';
+import { historyStatistics, type RunSummary, type RunDetail } from './run-history';
+
+const props = defineProps<{ scriptId: string; scriptName: string }>();
+const emit = defineEmits<{ close: [] }>();
+const runs = ref<RunSummary[]>([]);
+const selected = ref<RunSummary[]>([]);
+const details = ref<RunDetail[]>([]);
+const loading = ref(false);
+const comparing = ref(false);
+const version = ref('');
+const device = ref('');
+const error = ref('');
+const nodeKey = ref('');
+const logQuery = ref('');
+const base = `/api/appium-recorder/scripts/${encodeURIComponent(props.scriptId)}/history`;
+const labels = { passed: '通过', failed: '失败', stopped: '已终止' };
+const versions = computed(() => [...new Set(runs.value.map(run => run.appVersion || '未知'))]);
+const devices = computed(() => [...new Set(runs.value.map(run => run.deviceId))]);
+const filtered = computed(() => runs.value.filter(run => (!version.value || (run.appVersion || '未知') === version.value) && (!device.value || run.deviceId === device.value)));
+const stats = computed(() => historyStatistics(filtered.value));
+const trend = computed(() => [...filtered.value].sort((a, b) => a.startedAt.localeCompare(b.startedAt)));
+const maxDuration = computed(() => Math.max(1, ...trend.value.map(run => run.durationMs)));
+const points = computed(() => trend.value.map((run, index) => `${20 + index * 760 / Math.max(1, trend.value.length - 1)},${130 - run.durationMs / maxDuration.value * 110}`).join(' '));
+const comparisonNodes = computed(() => [...new Map(details.value.flatMap(run => run.nodes.map(node => [node.key, node] as const))).values()]);
+const time = (value: string) => new Date(value).toLocaleString('zh-CN', { hour12: false });
+const seconds = (value: number) => `${(value / 1000).toFixed(2)}s`;
+
+async function request<T>(url: string, method = 'GET'): Promise<T> {
+  const response = await fetch(url, { method });
+  if (!response.ok) throw new Error('历史结果请求失败');
+  return response.json();
+}
+async function load() {
+  loading.value = true; error.value = '';
+  try { runs.value = await request<RunSummary[]>(base); selected.value = []; }
+  catch (cause) { error.value = String(cause); }
+  finally { loading.value = false; }
+}
+async function compare() {
+  comparing.value = true;
+  try {
+    details.value = await Promise.all([...selected.value].sort((a, b) => a.startedAt.localeCompare(b.startedAt)).map(run => request<RunDetail>(`${base}/${encodeURIComponent(run.id)}`)));
+    nodeKey.value = '';
+  } catch (cause) { ElMessage.error(String(cause)); }
+  finally { comparing.value = false; }
+}
+async function remove() {
+  try { await ElMessageBox.confirm(`删除选中的 ${selected.value.length} 条历史及截图、日志快照？原始报告文件不受影响。`, '删除历史结果', { type: 'warning', confirmButtonText: '确定', cancelButtonText: '取消' }); }
+  catch { return; }
+  loading.value = true;
+  try {
+    for (const run of selected.value) await request(`${base}/${encodeURIComponent(run.id)}`, 'DELETE');
+    details.value = [];
+    await load();
+  } catch (cause) { ElMessage.error(String(cause)); await load(); }
+  finally { loading.value = false; }
+}
+function nodeDuration(run: RunDetail) {
+  const matches = run.nodes.filter(node => node.key === nodeKey.value);
+  if (!matches.length) return '未执行';
+  if (matches.some(node => node.durationMs === null)) return '耗时不完整';
+  return seconds(matches.reduce((sum, node) => sum + (node.durationMs || 0), 0));
+}
+onMounted(load);
+</script>
+
+<template>
+  <el-dialog :model-value="true" :title="`${scriptName} · 历史结果对比`" width="min(1200px, 96vw)" align-center append-to-body @closed="emit('close')">
+    <div v-loading="loading" class="run-history">
+      <div class="history-toolbar">
+        <el-select v-model="version" clearable placeholder="全部应用版本" aria-label="应用版本"><el-option v-for="item in versions" :key="item" :value="item" /></el-select>
+        <el-select v-model="device" clearable placeholder="全部设备" aria-label="设备"><el-option v-for="item in devices" :key="item" :value="item" /></el-select>
+        <el-tooltip content="刷新历史"><el-button :icon="Refresh" aria-label="刷新历史" @click="load" /></el-tooltip>
+        <el-button :disabled="selected.length !== 2" :loading="comparing" @click="compare">对比两次运行</el-button>
+        <el-tooltip content="删除选中历史"><el-button :icon="Delete" type="danger" plain :disabled="!selected.length" aria-label="删除选中历史" @click="remove" /></el-tooltip>
+      </div>
+      <el-alert v-if="error" :title="error" type="error" :closable="false" />
+      <el-empty v-else-if="!runs.length && !loading" description="暂无历史结果，后续运行会自动记录" />
+      <template v-else>
+        <p>{{ filtered.length }} 次运行 · 通过率 {{ stats.passRate === null ? '—' : `${(stats.passRate * 100).toFixed(1)}%` }}（不含手动终止）</p>
+        <h3>耗时趋势</h3>
+        <svg class="history-trend" viewBox="0 0 800 160" role="img" aria-label="按时间从早到晚的运行耗时趋势">
+          <path d="M20 10V130H790" fill="none" stroke="#a0a8ad" />
+          <polyline :points="points" fill="none" stroke="#168a75" stroke-width="2" />
+          <circle v-for="(run, index) in trend" :key="run.id" :cx="20 + index * 760 / Math.max(1, trend.length - 1)" :cy="130 - run.durationMs / maxDuration * 110" r="4" :fill="run.status === 'failed' ? '#d14343' : '#168a75'">
+            <title>{{ time(run.startedAt) }} · {{ seconds(run.durationMs) }} · {{ run.appVersion || '未知版本' }}</title>
+          </circle>
+          <text x="24" y="14">{{ seconds(maxDuration) }}</text><text x="20" y="153">{{ trend[0] ? time(trend[0].startedAt) : '' }}</text><text x="780" y="153" text-anchor="end">{{ trend.length > 1 ? time(trend[trend.length - 1].startedAt) : '' }}</text>
+        </svg>
+        <el-table :data="filtered" row-key="id" max-height="270" @selection-change="selected = $event">
+          <el-table-column type="selection" width="42" />
+          <el-table-column label="运行时间" min-width="180"><template #default="{ row }">{{ time(row.startedAt) }}</template></el-table-column>
+          <el-table-column prop="appVersion" label="应用版本" min-width="140"><template #default="{ row }">{{ row.appVersion || '未知' }}</template></el-table-column>
+          <el-table-column prop="deviceId" label="设备" min-width="140" />
+          <el-table-column label="结果" width="85"><template #default="{ row }">{{ labels[row.status as keyof typeof labels] }}</template></el-table-column>
+          <el-table-column label="耗时" width="100"><template #default="{ row }">{{ seconds(row.durationMs) }}</template></el-table-column>
+        </el-table>
+        <h3>失败节点分布</h3>
+        <el-table :data="stats.failures" max-height="220" empty-text="暂无节点失败记录">
+          <el-table-column prop="label" label="节点" min-width="220" />
+          <el-table-column label="失败 / 到达次数" width="145"><template #default="{ row }">{{ row.failures }} / {{ row.runs }}</template></el-table-column>
+          <el-table-column label="观察结果" width="130"><template #default="{ row }">{{ row.runs < 2 ? '样本不足' : row.failures === row.runs ? '持续失败' : '偶发失败' }}</template></el-table-column>
+          <el-table-column label="首次失败 / 版本" min-width="190"><template #default="{ row }">{{ time(row.firstFailure) }} · {{ row.version || '未知' }}</template></el-table-column>
+        </el-table>
+      </template>
+      <section v-if="details.length === 2" class="history-comparison">
+        <h3>运行对比 · 总耗时差 {{ seconds(details[1].durationMs - details[0].durationMs) }}</h3>
+        <el-alert v-if="details[0].deviceId !== details[1].deviceId || details[0].appPackage !== details[1].appPackage" title="两次运行的设备或应用不同，耗时差不能直接归因于版本变化" type="warning" :closable="false" />
+        <el-select v-model="nodeKey" clearable filterable placeholder="全部节点截图" aria-label="对比节点"><el-option v-for="node in comparisonNodes" :key="node.key" :label="node.label" :value="node.key" /></el-select>
+        <div class="comparison-columns">
+          <section v-for="run in details" :key="run.id">
+            <h4>{{ time(run.startedAt) }} · {{ labels[run.status] }}</h4>
+            <p>{{ run.appVersion || '未知版本' }} · {{ run.deviceId }} · {{ seconds(run.durationMs) }}</p>
+            <p v-if="nodeKey">节点累计耗时（含截图开销）：{{ nodeDuration(run) }}</p>
+            <p v-if="!run.frames.some(frame => !nodeKey || frame.key === nodeKey)">未捕获到对应截图</p>
+            <div class="history-frames">
+              <figure v-for="(frame, index) in run.frames.filter(frame => !nodeKey || frame.key === nodeKey)" :key="index">
+                <figcaption>{{ frame.label }} · {{ frame.phase === 'before' ? '执行前' : frame.phase === 'after' ? '执行后' : frame.phase }} · {{ time(frame.capturedAt) }}</figcaption>
+                <el-image :src="frame.imageUrl" :preview-src-list="[frame.imageUrl]" preview-teleported fit="contain" loading="lazy" />
+              </figure>
+            </div>
+            <h4>节点结果</h4><ul><li v-for="(node, index) in run.nodes.filter(node => !nodeKey || node.key === nodeKey)" :key="index">{{ node.label }} · {{ node.failed ? '失败' : '完成' }} · {{ node.durationMs === null ? '耗时未知' : seconds(node.durationMs) }}</li></ul>
+            <h4>关键日志 / 完整日志</h4><el-input v-model="logQuery" clearable placeholder="日志关键字，如 stageLog" aria-label="日志关键字" /><pre>{{ logQuery ? run.output.split('\n').filter(line => line.toLowerCase().includes(logQuery.toLowerCase())).join('\n') || '无匹配日志' : run.output }}</pre>
+          </section>
+        </div>
+      </section>
+    </div>
+  </el-dialog>
+</template>
+
+<style scoped>
+.run-history { max-height: 78vh; overflow: auto; }
+.history-toolbar { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
+.history-toolbar .el-select { width: 190px; }
+.history-trend { width: 100%; height: 160px; background: #f3faf7; }
+.history-trend text { font-size: 12px; fill: #52615b; }
+h3 { font-size: 15px; margin: 18px 0 10px; }
+h4 { font-size: 14px; margin: 12px 0 8px; }
+.history-comparison > .el-select { width: 100%; }
+.comparison-columns { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: 20px; }
+.comparison-columns section { min-width: 0; overflow-wrap: anywhere; }
+.history-frames { max-height: 360px; overflow: auto; display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 8px; }
+figure { margin: 0; }
+figcaption { font-size: 12px; }
+.el-image { width: 100%; height: 150px; }
+pre { white-space: pre-wrap; overflow-wrap: anywhere; max-height: 280px; overflow: auto; background: #f1f5f4; padding: 10px; font-size: 12px; }
+ul { max-height: 160px; overflow: auto; padding-left: 20px; }
+@media (max-width: 650px) { .comparison-columns { grid-template-columns: minmax(0, 1fr); } }
+</style>

package/src/appium-recorder/components/NestedConditionBranches.vue

@@ -99,6 +99,7 @@ const actionGroups: Array<{ title: string; actions: Array<{ type: InsertAction;
   {
     title: '设备操作',
     actions: [
+      { type: 'launchApp', label: '启动 App' },
       { type: 'keyBack', label: '系统返回' },
       { type: 'keyHome', label: 'Home 键' },
       { type: 'openGallery', label: '启动相册' },
@@ -123,8 +124,8 @@ const actionGroups: Array<{ title: string; actions: Array<{ type: InsertAction;
       { type: 'assertText', label: '断言文本' },
       { type: 'waitDisappear', label: '等待元素消失' },
       { type: 'waitActivity', label: '等待 Activity' },
-      { type: 'visualChangeStart', label: '检测画面变化开始节点' },
-      { type: 'visualChangeEnd', label: '检测画面变化结束节点' },
+      { type: 'visualChangeStart', label: '检测画面变化开始' },
+      { type: 'visualChangeEnd', label: '检测画面变化结束' },
     ],
   },
   {

package/src/appium-recorder/components/RecordedSteps.vue

@@ -116,10 +116,9 @@ const insertActionGroups: FlowActionGroup[] = [
 
 const mainActionGroups = insertActionGroups.map((group) => ({
   ...group,
-  actions: group.actions.filter((action) => action.type !== 'launchApp' && action.type !== 'clearAppData'),
+  actions: group.actions.filter((action) => action.type !== 'clearAppData'),
 }));
 const startActionGroups = insertActionGroups;
-const hasLaunchAppStep = computed(() => props.steps.some((step) => step.type === 'launchApp'));
 const hasClearAppDataStep = computed(() => props.steps.some((step) => step.type === 'clearAppData'));
 
 function isDescendantStep(descendantIndex: number, ancestorIndex: number) {
@@ -247,8 +246,7 @@ function isInsertActionDisabled(action: InsertAction) {
 }
 
 function isStartActionDisabled(action: InsertAction) {
-  return (action === 'launchApp' && hasLaunchAppStep.value)
-    || (action === 'clearAppData' && hasClearAppDataStep.value)
+  return (action === 'clearAppData' && hasClearAppDataStep.value)
     || isInsertActionDisabled(action);
 }
 

package/src/appium-recorder/components/VisualChangeEndPicker.vue

@@ -0,0 +1,21 @@
+<script setup lang="ts">
+defineProps<{ candidates: { id: string; label: string; number: number }[] }>();
+const emit = defineEmits<{ select: [id: string] }>();
+</script>
+
+<template>
+  <div class="visual-end-picker" aria-label="可结束的画面变化检测">
+    <button v-for="item in candidates" :key="item.id" type="button" @click="emit('select', item.id)">
+      <strong>{{ item.label }}</strong>
+      <span>开始节点 #{{ item.number }}</span>
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.visual-end-picker { display: grid; gap: 4px; max-height: 320px; overflow: auto; }
+.visual-end-picker button { display: flex; flex-wrap: wrap; justify-content: space-between; gap: 6px 16px; width: 100%; padding: 10px 12px; border: 0; border-radius: 4px; background: transparent; color: var(--el-text-color-primary); font: inherit; text-align: left; cursor: pointer; }
+.visual-end-picker button:hover, .visual-end-picker button:focus-visible { background: var(--el-fill-color-light); outline: 2px solid var(--el-color-primary); outline-offset: -2px; }
+.visual-end-picker strong { font-size: 14px; overflow-wrap: anywhere; }
+.visual-end-picker span { font-size: 12px; color: var(--el-text-color-secondary); }
+</style>

package/src/appium-recorder/flow-graph.ts

@@ -361,11 +361,6 @@ export function buildFlowGraph(
   ) => {
     const id = insertNodeId(afterIndex, branch, condition?.step.id);
     const isStartInsert = afterIndex < 0 && !branch;
-    const previousStep = afterIndex >= 0 ? steps[afterIndex] : undefined;
-    const canLaunchAfterClearAppData = !isStartInsert
-      && !branch
-      && previousStep?.type === 'clearAppData'
-      && !steps.some((step) => step.type === 'launchApp');
     addNode({
       id,
       type: 'flow-node',
@@ -381,9 +376,7 @@ export function buildFlowGraph(
         kind: 'insert',
         actionGroups: isStartInsert
           ? options.startActionGroups
-          : canLaunchAfterClearAppData
-            ? withLaunchAppAction(options.mainActionGroups)
-            : options.mainActionGroups,
+          : withLaunchAppAction(options.mainActionGroups),
         afterIndex,
         branch,
         branchLabel: branch && condition ? flowBranchLabel(condition.step, branch) : undefined,

package/src/appium-recorder/run-history.ts

@@ -0,0 +1,50 @@
+export type HistoryNode = {
+  key: string;
+  label: string;
+  failed: boolean;
+  durationMs: number | null;
+};
+
+export type RunSummary = {
+  id: string;
+  scriptId: string;
+  scriptName: string;
+  appPackage: string;
+  appVersion: string;
+  deviceId: string;
+  startedAt: string;
+  durationMs: number;
+  status: 'passed' | 'failed' | 'stopped';
+  nodes: HistoryNode[];
+};
+
+export type RunDetail = RunSummary & {
+  output: string;
+  frames: { key: string; label: string; phase: string; capturedAt: string; imageUrl: string }[];
+};
+
+// 分母只计算实际到达该节点的运行；未执行的分支不能当作通过。
+export function historyStatistics(runs: RunSummary[]) {
+  const completed = runs.filter(run => run.status !== 'stopped');
+  const nodes = new Map<string, { key: string; label: string; runs: number; failures: number; firstFailure: string; version: string }>();
+  for (const run of [...completed].sort((a, b) => a.startedAt.localeCompare(b.startedAt))) {
+    const unique = new Map<string, HistoryNode>();
+    for (const node of run.nodes) {
+      const prior = unique.get(node.key);
+      unique.set(node.key, { ...node, failed: node.failed || Boolean(prior?.failed) });
+    }
+    for (const node of unique.values()) {
+      const item = nodes.get(node.key) || { key: node.key, label: node.label, runs: 0, failures: 0, firstFailure: '', version: '' };
+      item.runs++;
+      if (node.failed) {
+        item.failures++;
+        if (!item.firstFailure) { item.firstFailure = run.startedAt; item.version = run.appVersion; }
+      }
+      nodes.set(node.key, item);
+    }
+  }
+  return {
+    passRate: completed.length ? completed.filter(run => run.status === 'passed').length / completed.length : null,
+    failures: [...nodes.values()].filter(node => node.failures).sort((a, b) => b.failures - a.failures),
+  };
+}

package/src/appium-recorder/visual-change-pairs.ts

@@ -93,10 +93,6 @@ export function branchPathForInsert(
     : [];
 }
 
-function sameBranchPath(left: string[], right: string[]) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-
 function branchPathContains(parent: string[], child: string[]) {
   return parent.length <= child.length && parent.every((value, index) => value === child[index]);
 }
@@ -118,19 +114,21 @@ function isEndForStart(endStep: AppiumRecordedStep, startStep: AppiumRecordedSte
   );
 }
 
-export function findOpenVisualChangeStart(
+export function findOpenVisualChangeStarts(
   steps: AppiumRecordedStep[],
   index?: number,
   branchTarget?: VisualChangeBranchTarget,
 ) {
   const insertPath = branchPathForInsert(steps, index, branchTarget);
   const insertIndex = typeof index === 'number' ? index : steps.length - 1;
-  // A start marker may be closed once per concrete branch path. This allows a
-  // root start before a condition to have independent yes/no end markers, while
-  // preventing a yes-branch start from pairing with a no-branch end.
+  // 祖先或子分支中的结束节点可能与新节点在同一路径执行，不能重复关闭。
+  // 互斥的兄弟分支不包含彼此，仍允许分别结束同一个开始节点。
   const hasEndInInsertBranch = (startStep: AppiumRecordedStep) => steps.some((step) => (
     isEndForStart(step, startStep)
-    && sameBranchPath(branchPathForStep(steps, step), insertPath)
+    && (
+      branchPathContains(branchPathForStep(steps, step), insertPath)
+      || branchPathContains(insertPath, branchPathForStep(steps, step))
+    )
   ));
 
   return steps
@@ -143,5 +141,13 @@ export function findOpenVisualChangeStart(
     ))
     .sort((left, right) => (
       right.path.length - left.path.length || right.stepIndex - left.stepIndex
-    ))[0]?.step;
+    )).map(({ step }) => step);
+}
+
+export function findOpenVisualChangeStart(
+  steps: AppiumRecordedStep[],
+  index?: number,
+  branchTarget?: VisualChangeBranchTarget,
+) {
+  return findOpenVisualChangeStarts(steps, index, branchTarget)[0];
 }