diff --git a/.env.example b/.env.example
index 2cce48c..3888cbc 100644
--- a/.env.example
+++ b/.env.example
@@ -62,6 +62,10 @@ OCR_API_KEY=
 ADB_HOST=127.0.0.1
 ADB_PORT=5037
 # ADB_DEVICE_SERIAL=
+# 自动发现本机模拟器，并重连通过网页连接过的 TCP 设备；不扫描局域网。
+ARTEMIS_ADB_AUTO_CONNECT=true
+ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS=10
+ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS=5
 ARTEMIS_KEEP_DEVICE_AWAKE=true
 ARTEMIS_HIERARCHY_BACKEND=auto
 ARTEMIS_HELPER_AUTO_INSTALL=true
diff --git a/AGENTS.md b/AGENTS.md
index 5680781..fb1f206 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -27,7 +27,7 @@
 | 核心类型检查 | `uv run pyright --project pyright-core.json` |
 | 源码打包 | `uv run --no-sync python scripts/package_source.py` |
 
-Windows 首次安装使用 `start.bat`，国内镜像使用 `start-cn.bat`。开发中需要保留当前源码时传入 `-SkipUpdate`，避免启动脚本拉取远端更新。
+Windows 首次安装使用 `start.bat`，国内镜像使用 `start-cn.bat`。启动只提示源码更新；升级使用 `update.bat` / `update-cn.bat`，会终止本项目运行进程。开发中可传入 `-SkipUpdate` 跳过更新提示。
 
 ## Key Paths
 
@@ -58,6 +58,7 @@ Windows 首次安装使用 `start.bat`，国内镜像使用 `start-cn.bat`。开
 - 新增可调参数集中进入配置层，并更新环境示例、网页/MCP 入口和必要文档，避免散落硬编码。
 - MCP 工具增删时同步工具注册、CLI 安装白名单、测试、Skill 和能力文档。
 - Windows PowerShell 启动脚本保持兼容 Windows PowerShell 5.1，避免编码导致解析失败。升级只做 Git 快进，保护已有配置和本地修改。
+- `update*.bat` 保持精简的 ASCII 入口；升级程序及其辅助脚本先复制到项目外执行。更新后通过新版 `start.ps1 -PrepareOnly -SkipUpdate` 同步环境，保留此内部调用约定，避免继续运行旧版安装函数。
 - 前端遵循现有简体中文文案与视觉样式；不直接编辑构建产物。
 
 ## Definition of Done
diff --git a/README.md b/README.md
index 0fadcd9..025267a 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ cd Artemis-Eapil
 ```powershell
 .\start-cn.bat -SetupOnly   # 准备环境并安装/更新 Codex MCP
 .\start.bat -Port 8001      # 指定端口
-.\start.bat -SkipUpdate     # 跳过 Git 源码更新检查
+.\start.bat -SkipUpdate     # 跳过源码更新提示
 .\start.bat -SkipMcpSync    # MCP 配置异常时，仅启动网页
 ```
 
@@ -39,7 +39,7 @@ cd Artemis-Eapil
 
 ### macOS / Linux
 
-克隆仓库后在项目目录执行 `./start.sh`。国内镜像入口和启动时自动更新目前由 Windows 脚本提供。
+克隆仓库后在项目目录执行 `./start.sh`。国内镜像入口和独立升级脚本目前由 Windows 提供。
 
 ## 配置与使用
 
@@ -72,9 +72,11 @@ uv run artemis mcp --install codex
 
 ## 更新与排错
 
-Windows 用户再次运行一键脚本时，会先检查 Git 上游；即使 `start.bat` 或 `start-cn.bat` 本身被更新，也会重新启动新版脚本，再检查项目依赖、前端构建并同步 Codex MCP。源码只做快进更新。本地修改、分支分叉或网络认证失败时保留本地版本；有任务执行或排队时停止更新启动。Codex 配置同步失败会明确停止启动，可使用 `-SkipMcpSync` 仅启动网页。更新后需在 Codex 中重新加载 MCP。
+启动脚本只检查并提示源码更新，不自动拉取。升级运行 **`.\update.bat`**，国内网络运行 **`.\update-cn.bat`**；支持 `-Help`。升级会终止当前项目的 ARTEMIS 服务、MCP 和任务进程，然后快进更新源码，同步依赖、网页构建及 Codex MCP。升级程序先复制到项目外运行，避免更新正在执行的脚本；其他项目、Codex 本身、模拟器和共享 ADB 服务不会被终止。完成后重新启动 ARTEMIS，并在 Codex 中重载 MCP。
 
-1.1.1 及更新版本的发布 ZIP 含浅层 Git 工作树，解压后再次运行一键脚本即可检查更新。1.1.0 及更早 ZIP 不含 Git 信息，无法自行拉取；需要下载新版源码包重新解压一次，之后即可自动更新。遇到启动或设备问题，在项目目录运行 `uv run artemis doctor`。
+本地修改、分支分叉或网络认证失败会停止升级，保留现有文件；`.env`、密钥和历史资料不会清空。启动/升级中的依赖或 MCP 同步失败会明确报错，修复后可重新执行；仅启动网页时可用 `-SkipMcpSync`。
+
+1.1.1 及更新版本的发布 ZIP 含浅层 Git 工作树；包含独立升级入口的新版源码包可直接用上述脚本升级。1.1.0 及更早 ZIP 不含 Git 信息，需改用 Git 克隆或新版源码包。遇到启动或设备问题，在项目目录运行 `uv run artemis doctor`。
 
 更多说明：[批量任务与报告](docs/automation-workspace.md) · [AI 接入](docs/ai-automation.md) · [开发协作指南](AGENTS.md)
 
diff --git a/apps/admin_console/routers/tasks.py b/apps/admin_console/routers/tasks.py
index 3818dfe..d1f928d 100644
--- a/apps/admin_console/routers/tasks.py
+++ b/apps/admin_console/routers/tasks.py
@@ -274,7 +274,12 @@ async def get_run_defaults():
 async def list_devices():
     """List all connected Android devices with their busy / idle status."""
     devices = await device_pool.list_devices_async()
-    return {"devices": [d.to_dict() for d in devices]}
+    from artemis.runtime.adb_discovery import adb_device_discovery
+
+    return {
+        "devices": [d.to_dict() for d in devices],
+        "automatic_connections": adb_device_discovery.results.copy(),
+    }
 
 
 @router.post("/api/stop")
diff --git a/apps/admin_console/services/model_settings_service.py b/apps/admin_console/services/model_settings_service.py
index a94ada3..87369e4 100644
--- a/apps/admin_console/services/model_settings_service.py
+++ b/apps/admin_console/services/model_settings_service.py
@@ -166,6 +166,13 @@ def persist_environment(values: dict[str, str]) -> None:
 
 
 class CapabilitySettings(BaseModel):
+    adb_auto_connect: bool = Field(default_factory=lambda: settings.ARTEMIS_ADB_AUTO_CONNECT)
+    adb_discovery_interval_seconds: float = Field(
+        default_factory=lambda: settings.ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS, ge=1, le=300
+    )
+    adb_discovery_timeout_seconds: float = Field(
+        default_factory=lambda: settings.ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS, gt=0, le=30
+    )
     video_enabled: bool = False
     recording_enabled: bool = False
     outputter_enabled: bool = True
@@ -206,6 +213,9 @@ def get_capability_settings() -> CapabilitySettings:
 
 def save_capability_settings(update: CapabilitySettings) -> CapabilitySettings:
     values = {
+        "ARTEMIS_ADB_AUTO_CONNECT": update.adb_auto_connect,
+        "ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS": update.adb_discovery_interval_seconds,
+        "ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS": update.adb_discovery_timeout_seconds,
         "ARTEMIS_VIDEO_ENABLED": update.video_enabled,
         "ARTEMIS_RECORDING_ENABLED": update.recording_enabled,
         "ARTEMIS_OUTPUTTER_ENABLED": update.outputter_enabled,
diff --git a/apps/showcase_ui/package-lock.json b/apps/showcase_ui/package-lock.json
index 9627517..8a6feeb 100644
--- a/apps/showcase_ui/package-lock.json
+++ b/apps/showcase_ui/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "artemis-showcase-ui",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "artemis-showcase-ui",
-      "version": "1.3.3",
+      "version": "1.4.0",
       "dependencies": {
         "@angular/cdk": "^22.1.5",
         "@angular/common": "^22.1.4",
diff --git a/apps/showcase_ui/package.json b/apps/showcase_ui/package.json
index 663b896..a2eae17 100644
--- a/apps/showcase_ui/package.json
+++ b/apps/showcase_ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "artemis-showcase-ui",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "scripts": {
     "ng": "ng",
     "start": "ng serve --proxy-config proxy.conf.json",
diff --git a/apps/showcase_ui/src/app/components/model-settings/capability-settings.component.ts b/apps/showcase_ui/src/app/components/model-settings/capability-settings.component.ts
index 652b012..e6b676e 100644
--- a/apps/showcase_ui/src/app/components/model-settings/capability-settings.component.ts
+++ b/apps/showcase_ui/src/app/components/model-settings/capability-settings.component.ts
@@ -4,6 +4,9 @@ import { HttpClient } from '@angular/common/http';
 import { finalize } from 'rxjs';
 
 interface Capabilities {
+  adb_auto_connect: boolean;
+  adb_discovery_interval_seconds: number;
+  adb_discovery_timeout_seconds: number;
   video_enabled: boolean;
   recording_enabled: boolean;
   outputter_enabled: boolean;
@@ -24,6 +27,8 @@ interface Capabilities {
     <section aria-label="功能开关">
       <h3>功能开关</h3>
       <p>按需启用，保存后对新任务生效。</p>
+      <label><input type="checkbox" role="switch" [(ngModel)]="config.adb_auto_connect" [disabled]="busy() || loading() || !loaded()" />
+        <span>自动连接设备<small>刷新设备时发现本机常见模拟器，并重连手动连接过的 TCP 设备；重启 ADB 后也会重连。不扫描局域网，不自动选择任务设备。保存后立即生效。</small></span></label>
       <label><input type="checkbox" role="switch" [(ngModel)]="config.video_enabled" [disabled]="busy() || loading() || !loaded()" />
         <span>视频分析<small>允许智能体分析任务画面。运行期间会临时录制，完成后不保留录像（除非开启录屏）。</small></span></label>
       <label><input type="checkbox" role="switch" [(ngModel)]="config.recording_enabled" [disabled]="busy() || loading() || !loaded()" />
@@ -44,6 +49,8 @@ interface Capabilities {
           <label>ADB 命令超时（秒）<input type="number" min="1" max="60" [(ngModel)]="config.device_command_timeout_seconds" [disabled]="busy() || !loaded()" /></label>
           <label>连续动作失败次数<input type="number" min="1" max="10" step="1" [(ngModel)]="config.action_failure_attempts" [disabled]="busy() || !loaded()" /><small>先重新观察，再让兜底模型处理当前步骤。</small></label>
           <label>任务收尾超时（秒）<input type="number" min="1" max="300" [(ngModel)]="config.worker_cleanup_timeout_seconds" [disabled]="busy() || !loaded()" /><small>已有最终结果但进程未退出时，回收进程以释放队列。</small></label>
+          <label>设备自动发现间隔（秒）<input type="number" min="1" max="300" [(ngModel)]="config.adb_discovery_interval_seconds" [disabled]="busy() || !loaded()" /></label>
+          <label>每轮自动连接预算（秒）<input type="number" min="1" max="30" [(ngModel)]="config.adb_discovery_timeout_seconds" [disabled]="busy() || !loaded()" /></label>
         </div>
       </details>
       <button type="button" (click)="save()" [disabled]="busy() || loading() || !loaded() || !valid()">{{ busy() ? '正在保存…' : '保存功能设置' }}</button>
@@ -67,7 +74,7 @@ interface Capabilities {
 export class CapabilitySettingsComponent implements OnInit {
   changed = output<Capabilities>();
   private http = inject(HttpClient);
-  config: Capabilities = { video_enabled: false, recording_enabled: false, outputter_enabled: true, step_summarizer_enabled: true, screenshot_limit_enabled: true, screenshot_max_long_edge: 2048, task_timeout_seconds: 1800, observation_timeout_seconds: 60, observation_max_attempts: 3, device_command_timeout_seconds: 10, action_failure_attempts: 3, worker_cleanup_timeout_seconds: 30 };
+  config: Capabilities = { adb_auto_connect: true, adb_discovery_interval_seconds: 10, adb_discovery_timeout_seconds: 5, video_enabled: false, recording_enabled: false, outputter_enabled: true, step_summarizer_enabled: true, screenshot_limit_enabled: true, screenshot_max_long_edge: 2048, task_timeout_seconds: 1800, observation_timeout_seconds: 60, observation_max_attempts: 3, device_command_timeout_seconds: 10, action_failure_attempts: 3, worker_cleanup_timeout_seconds: 30 };
   busy = signal(false); loading = signal(true); loaded = signal(false); message = signal(''); error = signal('');
   ngOnInit(): void {
     this.http.get<Capabilities>('/api/system/capability-settings').pipe(finalize(() => this.loading.set(false))).subscribe({
@@ -89,6 +96,8 @@ export class CapabilitySettingsComponent implements OnInit {
       && Number.isInteger(c.observation_max_attempts) && c.observation_max_attempts >= 1 && c.observation_max_attempts <= 5
       && c.device_command_timeout_seconds > 0 && c.device_command_timeout_seconds <= 60
       && Number.isInteger(c.action_failure_attempts) && c.action_failure_attempts >= 1 && c.action_failure_attempts <= 10
-      && c.worker_cleanup_timeout_seconds > 0 && c.worker_cleanup_timeout_seconds <= 300;
+      && c.worker_cleanup_timeout_seconds > 0 && c.worker_cleanup_timeout_seconds <= 300
+      && c.adb_discovery_interval_seconds >= 1 && c.adb_discovery_interval_seconds <= 300
+      && c.adb_discovery_timeout_seconds > 0 && c.adb_discovery_timeout_seconds <= 30;
   }
 }
diff --git a/apps/showcase_ui/src/app/components/model-settings/model-settings.component.spec.ts b/apps/showcase_ui/src/app/components/model-settings/model-settings.component.spec.ts
index b743769..abd313f 100644
--- a/apps/showcase_ui/src/app/components/model-settings/model-settings.component.spec.ts
+++ b/apps/showcase_ui/src/app/components/model-settings/model-settings.component.spec.ts
@@ -138,7 +138,7 @@ describe('持久化模型与功能设置', () => {
   });
 
   it('录屏与视频分析独立保存，重新打开后保留各自状态', () => {
-    const capabilities = { video_enabled: true, recording_enabled: false, outputter_enabled: true, step_summarizer_enabled: false, screenshot_limit_enabled: true, screenshot_max_long_edge: 2048, task_timeout_seconds: 1800, observation_timeout_seconds: 60, observation_max_attempts: 3, device_command_timeout_seconds: 10, action_failure_attempts: 3, worker_cleanup_timeout_seconds: 30 };
+    const capabilities = { adb_auto_connect: true, adb_discovery_interval_seconds: 10, adb_discovery_timeout_seconds: 5, video_enabled: true, recording_enabled: false, outputter_enabled: true, step_summarizer_enabled: false, screenshot_limit_enabled: true, screenshot_max_long_edge: 2048, task_timeout_seconds: 1800, observation_timeout_seconds: 60, observation_max_attempts: 3, device_command_timeout_seconds: 10, action_failure_attempts: 3, worker_cleanup_timeout_seconds: 30 };
     const fixture = TestBed.createComponent(CapabilitySettingsComponent);
     fixture.detectChanges();
     http.expectOne('/api/system/capability-settings').flush(capabilities);
@@ -162,7 +162,7 @@ describe('持久化模型与功能设置', () => {
   });
 
   it('执行保护默认折叠，修改时限可保存且拒绝无效数值', async () => {
-    const capabilities = { video_enabled: false, recording_enabled: false, outputter_enabled: true, step_summarizer_enabled: true, screenshot_limit_enabled: true, screenshot_max_long_edge: 2048, task_timeout_seconds: 1800, observation_timeout_seconds: 60, observation_max_attempts: 3, device_command_timeout_seconds: 10, action_failure_attempts: 3, worker_cleanup_timeout_seconds: 30 };
+    const capabilities = { adb_auto_connect: true, adb_discovery_interval_seconds: 10, adb_discovery_timeout_seconds: 5, video_enabled: false, recording_enabled: false, outputter_enabled: true, step_summarizer_enabled: true, screenshot_limit_enabled: true, screenshot_max_long_edge: 2048, task_timeout_seconds: 1800, observation_timeout_seconds: 60, observation_max_attempts: 3, device_command_timeout_seconds: 10, action_failure_attempts: 3, worker_cleanup_timeout_seconds: 30 };
     const fixture = TestBed.createComponent(CapabilitySettingsComponent);
     fixture.detectChanges();
     http.expectOne('/api/system/capability-settings').flush(capabilities);
@@ -190,4 +190,26 @@ describe('持久化模型与功能设置', () => {
     fixture.componentInstance.save();
     http.expectNone('/api/system/capability-settings');
   });
+
+  it('自动连接默认开启，可独立关闭并保存发现预算', () => {
+    const fixture = TestBed.createComponent(CapabilitySettingsComponent);
+    const capabilities = { ...fixture.componentInstance.config };
+    fixture.detectChanges();
+    http.expectOne('/api/system/capability-settings').flush(capabilities);
+    fixture.detectChanges();
+    const root: HTMLElement = fixture.nativeElement;
+    expect(root.textContent).toContain('自动连接设备');
+    expect(fixture.componentInstance.config.adb_auto_connect).toBeTrue();
+    fixture.componentInstance.config.adb_auto_connect = false;
+    fixture.componentInstance.config.adb_discovery_timeout_seconds = 8;
+    fixture.componentInstance.save();
+    const request = http.expectOne('/api/system/capability-settings');
+    expect(request.request.body.adb_auto_connect).toBeFalse();
+    expect(request.request.body.adb_discovery_timeout_seconds).toBe(8);
+    expect(request.request.body.recording_enabled).toBeFalse();
+    request.flush(request.request.body);
+    fixture.componentInstance.config.adb_discovery_timeout_seconds = 0;
+    fixture.componentInstance.save();
+    http.expectNone('/api/system/capability-settings');
+  });
 });
diff --git a/apps/showcase_ui/src/app/pages/home/home.component.ts b/apps/showcase_ui/src/app/pages/home/home.component.ts
index 6667d1e..ff427f3 100644
--- a/apps/showcase_ui/src/app/pages/home/home.component.ts
+++ b/apps/showcase_ui/src/app/pages/home/home.component.ts
@@ -20,7 +20,7 @@ import { Component, signal, computed, inject, OnInit, OnDestroy, ChangeDetection
 import { FormsModule } from '@angular/forms';
 import { Router } from '@angular/router';
 import { AgentService } from '../../services/agent.service';
-import { SystemService } from '../../services/system.service';
+import { SystemService, formatAdbRestartFeedback } from '../../services/system.service';
 import {
   AdbServerConnectionResult,
   AdbServerDevice,
@@ -548,10 +548,8 @@ export class HomeComponent implements OnInit, OnDestroy {
     this.adbRestartFeedback.set(null);
     this.systemService.restartAdb().subscribe({
       next: (res) => {
-        this.adbRestartFeedback.set(
-          res?.restart_result?.skipped ? "设备已刷新 ✓" : "ADB 已刷新 ✓"
-        );
-        setTimeout(() => this.adbRestartFeedback.set(null), 2500);
+        this.adbRestartFeedback.set(formatAdbRestartFeedback(res?.restart_result));
+        setTimeout(() => this.adbRestartFeedback.set(null), 6000);
       },
       error: () => {
         this.adbRestartFeedback.set("重启失败");
diff --git a/apps/showcase_ui/src/app/services/system.service.spec.ts b/apps/showcase_ui/src/app/services/system.service.spec.ts
index bd2c6d5..36fd0c5 100644
--- a/apps/showcase_ui/src/app/services/system.service.spec.ts
+++ b/apps/showcase_ui/src/app/services/system.service.spec.ts
@@ -3,7 +3,23 @@ import { HttpTestingController, provideHttpClientTesting } from '@angular/common
 import { TestBed } from '@angular/core/testing';
 
 import { SystemReadinessReport } from '../core/models/system.model';
-import { SystemService } from './system.service';
+import { SystemService, formatAdbRestartFeedback } from './system.service';
+
+describe('ADB restart feedback', () => {
+  it('区分已连接与正在连接，不把等待就绪显示为失败', () => {
+    const message = formatAdbRestartFeedback({ success: true, automatic_connections: [{ success: true }, { success: false, pending: true }] });
+    expect(message).toContain('已连接 1 台设备');
+    expect(message).toContain('1 台设备连接中');
+    expect(message).not.toContain('失败');
+  });
+  it('显示连接失败数量，提示查看诊断', () => {
+    expect(formatAdbRestartFeedback({ success: true, automatic_connections: [{ success: false }] })).toContain('1 项连接失败，请查看诊断');
+  });
+  it('服务器重启失败不会显示成功，远程端点明确显示仅刷新', () => {
+    expect(formatAdbRestartFeedback({ success: false, message: '端口被占用' })).toBe('端口被占用');
+    expect(formatAdbRestartFeedback({ success: true, skipped: true })).toBe('设备已刷新 ✓');
+  });
+});
 
 describe('SystemService readiness polling', () => {
   let service: SystemService;
diff --git a/apps/showcase_ui/src/app/services/system.service.ts b/apps/showcase_ui/src/app/services/system.service.ts
index 2d8cf54..8d48646 100644
--- a/apps/showcase_ui/src/app/services/system.service.ts
+++ b/apps/showcase_ui/src/app/services/system.service.ts
@@ -27,6 +27,19 @@ import {
   EmulatorLaunchStage
 } from '../core/models/system.model';
 
+export function formatAdbRestartFeedback(result?: {
+  success?: boolean; skipped?: boolean; message?: string;
+  automatic_connections?: { success?: boolean; pending?: boolean }[];
+}): string {
+  if (!result?.success) return result?.message || '重启失败';
+  if (result.skipped) return '设备已刷新 ✓';
+  const connections = result.automatic_connections ?? [];
+  const connected = connections.filter(item => item.success).length;
+  const pending = connections.filter(item => item.pending).length;
+  const failed = connections.filter(item => !item.success && !item.pending).length;
+  return `ADB 已重启${connected ? `，已连接 ${connected} 台设备` : ''}${pending ? `，${pending} 台设备连接中，将自动重试` : ''}${failed ? `，${failed} 项连接失败，请查看诊断` : ' ✓'}`;
+}
+
 @Injectable({
   providedIn: 'root'
 })
diff --git a/artemis/config/settings.py b/artemis/config/settings.py
index f1670ab..bca3abb 100644
--- a/artemis/config/settings.py
+++ b/artemis/config/settings.py
@@ -134,6 +134,9 @@ class Settings(BaseSettings):
     ADB_HOST: str | None = Field(default=DEFAULT_ADB_HOST)
     ADB_PORT: int | None = Field(default=DEFAULT_ADB_PORT)
     ADB_DEVICE_SERIAL: str | None = None
+    ARTEMIS_ADB_AUTO_CONNECT: bool = True
+    ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS: float = Field(default=10, ge=1, le=300)
+    ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS: float = Field(default=5, gt=0, le=30)
     # UI hierarchy backend: "auto" = Accessibility Helper with UIAutomator2
     # fallback, "helper" = helper only, "uiautomator" = UIAutomator2 only.
     ARTEMIS_HIERARCHY_BACKEND: str = Field(default="auto")
diff --git a/artemis/core/diagnostics/engine.py b/artemis/core/diagnostics/engine.py
index 39ca963..c1f22b7 100644
--- a/artemis/core/diagnostics/engine.py
+++ b/artemis/core/diagnostics/engine.py
@@ -21,6 +21,7 @@ import time
 from typing import Any
 
 from artemis.core.diagnostics.adb_server_connection import adb_server_connection
+from artemis.runtime.adb_discovery import adb_device_discovery
 from artemis.core.diagnostics.probes.adb_probe import AdbDeviceProbe
 from artemis.core.diagnostics.probes.base import BaseProbe
 from artemis.core.diagnostics.probes.credentials_probe import (
@@ -353,7 +354,12 @@ class ReadinessEngine:
                 }
 
         logger.info("[ReadinessEngine] Restarting ADB server...")
-        return await asyncio.to_thread(_restart_sync)
+        result = await asyncio.to_thread(_restart_sync)
+        if result.get("success"):
+            result["automatic_connections"] = await asyncio.to_thread(
+                adb_device_discovery.refresh, adb_path, force=True
+            )
+        return result
 
     async def launch_emulator(self, avd_name: str) -> dict[str, Any]:
         """Launch an Android emulator by AVD name in the background and track its lifecycle."""
@@ -417,8 +423,10 @@ class ReadinessEngine:
                 )
                 output = (res.stdout + "\n" + res.stderr).strip()
                 success = "connected to" in output.lower() and "failed" not in output.lower()
+                remembered = adb_device_discovery.remember(target) if success else False
                 return {
                     "success": success,
+                    "remembered": remembered,
                     "target": target,
                     "output": output,
                     "message": f"Connected to {target}" if success else output,
diff --git a/artemis/core/diagnostics/probes/adb_probe.py b/artemis/core/diagnostics/probes/adb_probe.py
index 4abd928..2ffce04 100644
--- a/artemis/core/diagnostics/probes/adb_probe.py
+++ b/artemis/core/diagnostics/probes/adb_probe.py
@@ -33,6 +33,7 @@ from artemis.core.diagnostics.schema import (
 )
 from artemis.platform import OSType, platform
 from artemis.toolchain import toolchain
+from artemis.runtime.adb_discovery import adb_device_discovery
 from artemis.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -477,6 +478,7 @@ class AdbDeviceProbe(BaseProbe):
     async def _parse_adb_devices(self, adb_path: str) -> list[DeviceInfo]:
         """Execute `adb devices -l` and extract structured device metadata."""
         devices: list[DeviceInfo] = []
+        await asyncio.to_thread(adb_device_discovery.refresh, adb_path)
         try:
             proc = await asyncio.create_subprocess_exec(
                 adb_path,
@@ -668,6 +670,7 @@ class AdbDeviceProbe(BaseProbe):
             "installed": True,
             "adb_path": adb_path,
             "adb_version": adb_ver,
+            "automatic_connections": adb_device_discovery.results.copy(),
             "adb_keys": key_status.to_dict(),
             "emulator_path": emulator_path,
             "is_emulator_in_path": is_emu_in_path,
diff --git a/artemis/runtime/adb_discovery.py b/artemis/runtime/adb_discovery.py
new file mode 100644
index 0000000..a074f40
--- /dev/null
+++ b/artemis/runtime/adb_discovery.py
@@ -0,0 +1,285 @@
+"""Bounded TCP device discovery shared by the console, CLI and MCP.
+
+USB and Android SDK emulators are discovered by ADB itself. Third-party
+emulators expose TCP adbd listeners; only listeners owned by known emulator
+processes are probed. Explicitly connected TCP devices are remembered separately.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import socket
+import struct
+import subprocess
+import tempfile
+import threading
+import time
+
+import psutil
+
+from artemis.config import settings
+from artemis.config.paths import get_app_dir
+from artemis.runtime.adb_endpoint import AdbSession, current_adb_endpoint
+from artemis.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def _canonical_target(target: str) -> str:
+    host, separator, port = target.rpartition(":")
+    if separator and host.lower() in {"localhost", "127.0.0.1"}:
+        return f"127.0.0.1:{port}"
+    return target
+
+
+def emulator_listeners() -> list[list[str]]:
+    """Return listener groups, one per running emulator (never scan a network)."""
+    owners = set()
+    for process in psutil.process_iter(["pid", "name", "exe"]):
+        info = process.info
+        name = str(info.get("name") or "").lower().removesuffix(".exe")
+        path = str(info.get("exe") or "").lower()
+        known = name in {
+            "mumunxdevice",
+            "nemuheadless",
+            "mumuheadless",
+            "ldvboxheadless",
+            "noxvmhandle",
+            "memuheadless",
+            "hd-player",
+        }
+        vendor_vm = name == "vboxheadless" and any(
+            vendor in path for vendor in ("mumu", "nemu", "ldplayer", "leidian", "nox", "memu")
+        )
+        if known or vendor_vm:
+            owners.add(info["pid"])
+    if not owners:
+        return []
+    groups: dict[int, set[int]] = {}
+    for connection in psutil.net_connections(kind="tcp"):
+        address = connection.laddr
+        pid = connection.pid
+        if (
+            pid is not None
+            and pid in owners
+            and address
+            and connection.status == psutil.CONN_LISTEN
+            and address.ip in {"127.0.0.1", "0.0.0.0"}
+        ):
+            groups.setdefault(pid, set()).add(address.port)
+    # Prefer current MuMu ports over its compatibility aliases (same adbd).
+    return [
+        [f"127.0.0.1:{port}" for port in sorted(ports, key=lambda p: (p in {5555, 7555}, p))]
+        for ports in groups.values()
+    ]
+
+
+def is_adbd(target: str, timeout: float) -> bool:
+    """Confirm an ADB CNXN/AUTH header before giving a local port to adb connect."""
+    host, port = target.rsplit(":", 1)
+    payload = b"host::\x00"
+    command = int.from_bytes(b"CNXN", "little")
+    packet = struct.pack(
+        "<6I", command, 0x01000000, 4096, len(payload), sum(payload), command ^ 0xFFFFFFFF
+    )
+    try:
+        with socket.create_connection((host, int(port)), timeout=timeout) as stream:
+            stream.sendall(packet + payload)
+            header = b""
+            deadline = time.monotonic() + timeout
+            while len(header) < 24:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return False
+                stream.settimeout(remaining)
+                chunk = stream.recv(24 - len(header))
+                if not chunk:
+                    return False
+                header += chunk
+            kind, _, _, length, _, magic = struct.unpack("<6I", header)
+            return (
+                kind.to_bytes(4, "little") in {b"CNXN", b"AUTH"}
+                and magic == kind ^ 0xFFFFFFFF
+                and length <= 1048576
+            )
+    except (OSError, ValueError):
+        return False
+
+
+class AdbDeviceDiscovery:
+    """Coalesce discovery and reconnect only missing transports, with a total budget."""
+
+    def __init__(self):
+        self._gate = threading.Lock()
+        self._last_scan = float("-inf")
+        self.results: list[dict[str, object]] = []
+        self._cursor = 0
+
+    @staticmethod
+    def _directory() -> Path:
+        return get_app_dir() / "adb-devices"
+
+    def remember(self, target: str) -> bool:
+        """Save an explicitly connected device, without credentials or shared-list races."""
+        directory = self._directory()
+        temporary = None
+        try:
+            directory.mkdir(parents=True, exist_ok=True)
+            destination = directory / (hashlib.sha256(target.encode()).hexdigest() + ".json")
+            fd, temporary = tempfile.mkstemp(dir=directory, prefix=".device-")
+            with os.fdopen(fd, "w", encoding="utf-8") as stream:
+                json.dump({"target": target}, stream)
+            os.replace(temporary, destination)
+            return True
+        except OSError as exc:
+            logger.warning(f"Cannot remember ADB device {target}: {exc}")
+            return False
+        finally:
+            if temporary:
+                Path(temporary).unlink(missing_ok=True)
+
+    def _remembered(self) -> list[str]:
+        targets = []
+        for path in self._directory().glob("*.json"):
+            try:
+                target = json.loads(path.read_text(encoding="utf-8"))["target"]
+                host, port = target.rsplit(":", 1)
+                if host and 0 < int(port) < 65536:
+                    targets.append(target)
+            except (OSError, ValueError, KeyError, TypeError, AttributeError) as exc:
+                logger.warning(f"Invalid remembered ADB device {path.name}: {exc}")
+        return targets
+
+    def refresh(self, adb_path: str, *, force: bool = False) -> list[dict[str, object]]:
+        if not settings.ARTEMIS_ADB_AUTO_CONNECT or not current_adb_endpoint().is_local_default:
+            self.results = []
+            return []
+        if not self._gate.acquire(blocking=False):
+            return self.results.copy()
+        try:
+            if (
+                not force
+                and time.monotonic() - self._last_scan
+                < settings.ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS
+            ):
+                return self.results.copy()
+            self._last_scan = time.monotonic()
+            self.results = []
+            self._refresh(adb_path)
+        except (OSError, psutil.Error, ValueError, subprocess.SubprocessError) as exc:
+            logger.warning(f"ADB automatic discovery unavailable: {exc}")
+            self.results.append({"success": False, "message": str(exc)})
+        finally:
+            self._gate.release()
+        return self.results.copy()
+
+    def _refresh(self, adb_path: str) -> None:
+        session = AdbSession(current_adb_endpoint(), adb_path=adb_path)
+        deadline = time.monotonic() + settings.ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS
+        devices = session.run(
+            ["devices"],
+            capture_output=True,
+            text=True,
+            timeout=max(deadline - time.monotonic(), 0.01),
+        )
+        if devices.returncode:
+            return
+        ready = {
+            _canonical_target(parts[0])
+            for line in devices.stdout.splitlines()
+            if len(parts := line.split()) >= 2 and parts[1] in {"device", "unauthorized"}
+        }
+        try:
+            groups = emulator_listeners()
+        except (OSError, psutil.Error) as exc:
+            # Missing process-inspection permissions must not stop reconnection
+            # of explicitly configured phones or make device enumeration fail.
+            groups = []
+            logger.warning(f"Cannot inspect local emulator listeners: {exc}")
+            self.results.append({"success": False, "message": str(exc)})
+        remembered = self._remembered()
+        targets = [(group, True) for group in groups] + [([target], False) for target in remembered]
+        # Resume at a different group if a slow/offline peer exhausts the budget.
+        # Large multi-instance installations must not starve later devices.
+        count = len(targets)
+        start = self._cursor % count if count else 0
+        for offset in range(count):
+            index = (start + offset) % count
+            candidates, probe = targets[index]
+            self._cursor = (index + 1) % count
+            if any(_canonical_target(target) in ready for target in candidates):
+                continue
+            for target in candidates:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return
+                if probe and not is_adbd(target, min(remaining, 0.3)):
+                    continue
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return
+                try:
+                    result = session.run(
+                        ["connect", target],
+                        capture_output=True,
+                        text=True,
+                        timeout=min(remaining, 2),
+                    )
+                except subprocess.TimeoutExpired:
+                    self.results.append(
+                        {"target": target, "success": False, "message": "ADB 连接超时"}
+                    )
+                    continue
+                output = (result.stdout + result.stderr).strip()
+                success = (
+                    result.returncode == 0
+                    and "connected to" in output.lower()
+                    and "failed" not in output.lower()
+                )
+                state = self._wait_for_transport(session, target, deadline) if success else None
+                pending = success and state is None
+                if success and state is None:
+                    success = False
+                    output = f"{output}；已发起连接，等待设备就绪，下次刷新会重试"
+                self.results.append(
+                    {
+                        "target": target,
+                        "success": success,
+                        "state": state,
+                        "pending": pending,
+                        "message": output,
+                    }
+                )
+                if success:
+                    logger.info(f"ADB 自动连接：{target} — {output}")
+                    ready.add(_canonical_target(target))
+                    break
+                if pending:
+                    logger.info(f"ADB 设备连接中：{target} — {output}")
+                    break  # Do not create a second alias while the first transport is settling.
+                logger.warning(f"ADB 自动连接失败：{target} — {output}")
+
+    @staticmethod
+    def _wait_for_transport(session: AdbSession, target: str, deadline: float) -> str | None:
+        """adb connect can return before its transport appears in adb devices."""
+        while (remaining := deadline - time.monotonic()) > 0:
+            try:
+                result = session.run(["devices"], capture_output=True, text=True, timeout=remaining)
+            except subprocess.TimeoutExpired:
+                return None
+            for line in result.stdout.splitlines():
+                parts = line.split()
+                if (
+                    len(parts) >= 2
+                    and _canonical_target(parts[0]) == _canonical_target(target)
+                    and parts[1] in {"device", "unauthorized"}
+                ):
+                    return parts[1]
+            time.sleep(min(0.1, max(deadline - time.monotonic(), 0)))
+        return None
+
+
+adb_device_discovery = AdbDeviceDiscovery()
diff --git a/artemis/runtime/device_pool.py b/artemis/runtime/device_pool.py
index 37472ff..3a0cbfa 100644
--- a/artemis/runtime/device_pool.py
+++ b/artemis/runtime/device_pool.py
@@ -26,6 +26,7 @@ import time
 from typing import Any
 
 from artemis.runtime.adb_endpoint import AdbSession, current_adb_endpoint
+from artemis.runtime.adb_discovery import adb_device_discovery
 from artemis.runtime.device_lock import DeviceExecutionLock
 from artemis.toolchain import toolchain
 from artemis.utils.logger import get_logger
@@ -108,6 +109,7 @@ class DevicePool:
         adb = self._resolve_adb()
         if not adb:
             return None
+        adb_device_discovery.refresh(adb)
         try:
             res = subprocess.run(
                 [adb, "devices", "-l"],
@@ -132,6 +134,7 @@ class DevicePool:
         adb = self._resolve_adb()
         if not adb:
             return None
+        await asyncio.to_thread(adb_device_discovery.refresh, adb)
         proc = None
         try:
             proc = await asyncio.create_subprocess_exec(
diff --git a/docs/ai-automation.md b/docs/ai-automation.md
index 6188530..48705cd 100644
--- a/docs/ai-automation.md
+++ b/docs/ai-automation.md
@@ -32,9 +32,9 @@
 
 新增工具通过统一后台服务运行，与网页共享配置、队列、历史和报告；不另外启动独立调度器。`ARTEMIS_STANDALONE` 模式不支持这些工作区工具。
 
-Windows 已安装用户再次运行 `start.bat` / `start-cn.bat` 时会检查当前分支的 Git 上游，仅做快进更新；拉取后重新加载新版启动脚本。1.1.1 及更新版本的发布 ZIP 是精简的 Git 工作树，解压后也能在后续运行时检查更新。1.1.0 及更早 ZIP 缺少 `.git`，需手动下载新版源码包一次。没有 Git、网络/认证失败、有本地修改或分支分叉时保留现有源码并给出提示，不重置或覆盖。`-SkipUpdate` 可跳过源码更新检查。
+Windows 启动入口 `start.bat` / `start-cn.bat` 只检查并提示源码更新，`-SkipUpdate` 跳过提示。独立升级入口为 `update.bat` / `update-cn.bat`：先把升级程序复制到项目外的临时目录，检查本地修改，再终止本项目的 ARTEMIS 服务、MCP 和任务进程；之后仅做 Git 快进更新，并用新版启动程序准备环境，完成后由用户重新启动。其他项目、Codex、模拟器和共享 ADB 不受影响；运行中的任务会被中断，不会作为成功任务处理。1.1.1 及更新版本的发布 ZIP 含 Git 工作树，旧版无 `.git` 的 ZIP 需改用新版包或 Git 克隆。没有 Git、网络/认证失败、有本地修改或分支分叉时升级失败并保留现有源码，不重置或覆盖。
 
-Python 每次按 `uv.lock` 检查并同步缺失/变化的依赖；前端依据源码、资源及包锁文件指纹决定是否重新执行 `npm ci` 和构建，成功后才记录指纹。国内镜像选项继续生效。检测到正在执行/排队的任务时，自动更新启动会停止，让原任务继续。
+Python 按 `uv.lock` 同步缺失/变化的依赖；前端依据源码、资源及包锁指纹决定是否执行 `npm ci` 和构建，成功后才记录指纹。国内升级入口继续使用镜像配置。升级与启动的环境准备互斥；升级失败不会自动启动服务或回滚用户配置，处理错误后可重试。
 
 MCP 同步仅检查 `$CODEX_HOME/config.toml`；未设置或为空时使用当前用户的 `~/.codex/config.toml`。日志会显示实际路径，以及新装、更新、已是最新、未检测到或自定义跳过的结果。检测到目录但缺少 ARTEMIS 条目时安装当前源码的标准配置；已有标准配置即使指向旧解压目录，也会更新解释器、项目目录、环境路径和工具清单。保留用户额外环境变量、禁用状态及其他服务；自定义启动包装器保持原样并提示。其他客户端的配置和规则文件不读取、不修改，其格式错误不会阻止启动。Codex 配置无法安全解析时停止启动，原文件不被覆盖；可使用 `-SkipMcpSync` 仅启动网页。首次修改保留备份。同步后需在 Codex 中重新加载 MCP 或重启 Codex，脚本无法替宿主重启已加载的 MCP 进程。
 
diff --git a/docs/automation-workspace.md b/docs/automation-workspace.md
index 5901d7a..602f9b2 100644
--- a/docs/automation-workspace.md
+++ b/docs/automation-workspace.md
@@ -34,6 +34,10 @@
 
 ## 环境配置
 
+设备刷新、启动和重启 ADB 后会自动连接本机运行中的 MuMu、雷电、夜神、逍遥及蓝叠等常见模拟器：读取进程拥有的监听端口，验证 ADB 协议后连接，不扫描局域网。同一模拟器的兼容端口不重复连接，已有在线或等待授权的连接保持不动。USB 手机和 Android SDK 模拟器由 ADB 原生发现。其他模拟器或无线手机可在首页“无线 ADB”中填写实际地址和端口；成功后地址保存在本机应用数据目录的 `adb-devices` 中，后续自动重连。Android 无线调试须先完成配对和授权，端口变化后需要重新连接；自动连接不会绕过授权。
+
+“功能配置”提供“自动连接设备”开关，默认开启；每轮连接预算默认 5 秒，发现间隔默认 10 秒，避免离线设备拖住刷新。对应环境变量为 `ARTEMIS_ADB_AUTO_CONNECT`、`ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS`、`ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS`。MCP `mobile_config(section="capabilities")` 可配置 `adb_auto_connect`、`adb_discovery_timeout_seconds`、`adb_discovery_interval_seconds`；`mobile_workspace` 的设备列表和 `mobile_diagnose` 返回自动连接结果。使用远程或转发 ADB 服务时不发现本机端口。连接设备不等于选择任务设备，多个设备时仍需明确选择。
+
 `.env` 可配置 `ARTEMIS_TASK_TIMEOUT_SECONDS`（单任务总执行时限，默认 1800 秒）、`ARTEMIS_IMPORT_MAX_ROWS`（默认 1000 行）和 `ARTEMIS_IMPORT_MAX_BYTES`（默认 10 MiB）。修改后重启服务。网页的单批次超时设置优先于环境默认值，每行 JSON 的 `timeout_seconds` 优先于批次。单任务、批次和 MCP 均受总执行时限保护，不计排队和用户暂停时间；即使执行进程卡住，也由父进程终止并保存失败原因。
 
 守护服务通过轻量状态接口探测，`ARTEMIS_DAEMON_PROBE_TIMEOUT_SECONDS` 默认 2 秒。短暂超时且端口仍被存活的原服务占用时复用原服务，不重复启动；未知进程占用端口时明确拒绝覆盖。
diff --git a/mcp_server/tools/automation.py b/mcp_server/tools/automation.py
index e81950b..e22fc39 100644
--- a/mcp_server/tools/automation.py
+++ b/mcp_server/tools/automation.py
@@ -27,6 +27,9 @@ MODEL_FIELDS = {
     "reasoning_effort",
 }
 CAPABILITY_FIELDS = {
+    "adb_auto_connect",
+    "adb_discovery_interval_seconds",
+    "adb_discovery_timeout_seconds",
     "video_enabled",
     "recording_enabled",
     "outputter_enabled",
@@ -147,7 +150,8 @@ async def mobile_config(
     step_summarizer_enabled, screenshot_limit_enabled, task_timeout_seconds (default 1800),
     observation_timeout_seconds (60), observation_max_attempts (3),
     device_command_timeout_seconds (10), action_failure_attempts (3),
-    worker_cleanup_timeout_seconds (30).
+    worker_cleanup_timeout_seconds (30), adb_auto_connect (true),
+    adb_discovery_interval_seconds (10), adb_discovery_timeout_seconds (5).
     reports: formats=['docx','xlsx'] (at least one).
     API keys are never accepted or returned: use the Web UI or .env for credentials.
     Saving settings does not change an already running task. Flash/Pro are execution
diff --git a/mcp_server/tools/diagnose.py b/mcp_server/tools/diagnose.py
index 7b4f762..0e049fc 100644
--- a/mcp_server/tools/diagnose.py
+++ b/mcp_server/tools/diagnose.py
@@ -115,6 +115,8 @@ def _render_check(result: ProbeResult) -> dict[str, Any]:
         "summary": result.summary,
     }
     if result.status is ProbeStatus.PASS:
+        if result.id == "android_adb" and result.metadata.get("automatic_connections"):
+            check["automatic_connections"] = _scrub(result.metadata["automatic_connections"])
         return check
     check["category"] = result.category.value
     check["detail"] = result.description
diff --git a/pyproject.toml b/pyproject.toml
index 16c2652..e114c72 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -14,7 +14,7 @@
 
 [project]
 name = "artemis"
-version = "1.3.3"
+version = "1.4.0"
 description = "Autonomous AI Assistant for Mobile Automation"
 
 authors = [
diff --git a/scripts/installation_lock.ps1 b/scripts/installation_lock.ps1
new file mode 100644
index 0000000..c143229
--- /dev/null
+++ b/scripts/installation_lock.ps1
@@ -0,0 +1,20 @@
+# Shared preparation/upgrade mutex. ASCII for Windows PowerShell 5.1.
+function Enter-ArtemisInstallationLock {
+    param([string]$ProjectRoot)
+    $normalized = [IO.Path]::GetFullPath($ProjectRoot).TrimEnd('\').ToLowerInvariant()
+    $hash = [Security.Cryptography.SHA256]::Create()
+    try { $digest = [BitConverter]::ToString($hash.ComputeHash([Text.Encoding]::UTF8.GetBytes($normalized))).Replace('-', '') }
+    finally { $hash.Dispose() }
+    $mutex = New-Object Threading.Mutex($false, "Local\ArtemisInstallation-$digest")
+    try {
+        try { $entered = $mutex.WaitOne(0) }
+        catch [Threading.AbandonedMutexException] { $entered = $true }
+        if (-not $entered) { throw 'Another startup preparation or upgrade is running. Please wait and retry.' }
+        return $mutex
+    } catch { $mutex.Dispose(); throw }
+}
+
+function Exit-ArtemisInstallationLock {
+    param($Mutex)
+    if ($null -ne $Mutex) { $Mutex.ReleaseMutex(); $Mutex.Dispose() }
+}
diff --git a/scripts/start.ps1 b/scripts/start.ps1
index 14e585c..1259347 100644
--- a/scripts/start.ps1
+++ b/scripts/start.ps1
@@ -17,8 +17,10 @@ param(
     [int]$Port = 8000,
     [switch]$NoOpen = $false,
     [switch]$SetupOnly = $false,
+    [switch]$PrepareOnly = $false,
     [switch]$SkipUpdate = $false,
     [switch]$SkipMcpSync = $false,
+    [switch]$Help = $false,
     [ValidateSet('Official', 'China')][string]$Mirror
 )
 
@@ -31,6 +33,35 @@ function Get-LaunchText {
     return $English
 }
 
+# Keep UTF-8 Chinese text in this BOM-encoded script, never in CMD batch files.
+# CMD can misparse multibyte batch lines when an archive/editor converts CRLF to LF.
+if ($Help) {
+    Write-Host (Get-LaunchText 'Usage: start.bat [options]' '用法：start-cn.bat [选项]')
+    Write-Host ''
+    Write-Host (Get-LaunchText '  -SetupOnly    Prepare the environment without launching the UI' '  -SetupOnly    安装或检查环境，不启动网页')
+    Write-Host (Get-LaunchText '  -Port 8001    Use the specified port (default: 8000)' '  -Port 8001    使用指定端口，默认 8000')
+    Write-Host (Get-LaunchText '  -NoOpen       Do not open the browser automatically' '  -NoOpen       启动服务后不自动打开浏览器')
+    Write-Host (Get-LaunchText '  -SkipUpdate   Skip the source update notification' '  -SkipUpdate   跳过源码更新提示（启动不会拉取源码）')
+    Write-Host (Get-LaunchText '  -SkipMcpSync  Skip Codex MCP installation and updates' '  -SkipMcpSync  仅启动网页，跳过 Codex MCP 安装和更新')
+    Write-Host (Get-LaunchText '  -Mirror China Use China download mirrors' '  -Mirror China 使用国内下载镜像')
+    Write-Host (Get-LaunchText '  -Help         Show this help' '  -Help         显示本说明')
+    Write-Host ''
+    Write-Host (Get-LaunchText 'Download sources: config\downloads.json' '国内镜像设置：config\downloads.json')
+    Write-Host (Get-LaunchText 'First launch requires Internet access. Upgrade with update.bat; startup only checks for updates.' '首次运行需联网；启动仅提示源码更新，升级请运行 update-cn.bat。')
+    exit 0
+}
+Write-Host '======================================================'
+if ($env:ARTEMIS_LAUNCH_LANG -eq 'zh-CN' -and $Mirror -eq 'China') {
+    Write-Host '  ARTEMIS 中文启动 - 使用国内镜像'
+    Write-Host '======================================================'
+    Write-Host '正在检查已有环境、更新提示及依赖；首次启动可能需要下载组件。'
+    Write-Host '镜像地址和下载超时可在 config\downloads.json 中调整。'
+} else {
+    Write-Host (Get-LaunchText '      Artemis Autonomous Mobile Agent UI' '      ARTEMIS 手机自动化测试')
+    Write-Host '======================================================'
+}
+Write-Host ''
+
 # Ensure modern TLS protocols are enabled for downloads (GitHub releases, nodejs.org, Google repositories)
 try {
     [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor [System.Net.SecurityProtocolType]::Tls12
@@ -40,28 +71,18 @@ $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
 $RootDir = Split-Path -Parent $ScriptDir
 Set-Location $RootDir
 
-# Existing installations check source BEFORE importing bootstrap helpers.
+# Startup never mutates source; upgrades run from a staged, independent process.
+. (Join-Path $ScriptDir 'installation_lock.ps1')
+$installationLock = $null
+if ($env:ARTEMIS_UPGRADE_CHILD -ne '1') {
+    try { $installationLock = Enter-ArtemisInstallationLock -ProjectRoot $RootDir }
+    catch { Write-Host (Get-LaunchText "[ERROR] $_" '[错误] 另一个环境准备或升级正在运行，请稍后重试。') -ForegroundColor Red; exit 1 }
+}
 $existingPython = Join-Path $RootDir '.venv\Scripts\python.exe'
 if ((-not $SkipUpdate) -and (Test-Path -LiteralPath $existingPython)) {
-    & $existingPython (Join-Path $ScriptDir 'update_installation.py') source --port $Port
-    $updateExit = $LASTEXITCODE
-    if ($updateExit -eq 20) { exit 1 }
-    if ($updateExit -eq 10) {
-        # Reparse the freshly updated launcher; do not continue running stale functions.
-        $reloadArgs = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', (Join-Path $ScriptDir 'start.ps1'), '-Port', $Port, '-SkipUpdate')
-        if ($NoOpen) { $reloadArgs += '-NoOpen' }
-        if ($SetupOnly) { $reloadArgs += '-SetupOnly' }
-        if ($SkipMcpSync) { $reloadArgs += '-SkipMcpSync' }
-        if ($Mirror) { $reloadArgs += @('-Mirror', $Mirror) }
-        & powershell.exe @reloadArgs
-        exit $LASTEXITCODE
-    }
-    if ($updateExit -ne 0) {
-        Write-Host (Get-LaunchText '   [ERROR] Source update check failed. Resolve the error above, or use -SkipUpdate for local startup.' '   [错误] 源码更新检查失败。请处理上方错误；要运行当前源码可传入 -SkipUpdate。') -ForegroundColor Red
-        exit 1
-    }
+    & $existingPython (Join-Path $ScriptDir 'update_installation.py') source-check
+    # Network/authentication failures are warnings, never a reason to prevent startup.
 }
-
 . (Join-Path $ScriptDir 'download_config.ps1')
 try {
     Initialize-ArtemisDownloads -ProjectRoot $RootDir -Mode $Mirror
@@ -376,7 +397,7 @@ if (-not $SkipMcpSync) {
 } else {
     Write-Host (Get-LaunchText '   [SKIP] MCP synchronization was skipped.' '   [跳过] 已跳过 MCP 同步。') -ForegroundColor Yellow
 }
-if ($SetupOnly) {
+if ($SetupOnly -and -not $PrepareOnly) {
     Write-Host (Get-LaunchText '   [OK] Setup complete. Run start.bat to launch Artemis.' '   [完成] 环境已准备好。运行 start-cn.bat 启动 ARTEMIS。') -ForegroundColor Green
     exit 0
 }
@@ -431,7 +452,7 @@ if ($missingCore.Count -gt 0) {
 }
 
 # Ensure local ADB daemon is warm & listening so probes do not hit 'Connection refused'
-Start-LocalAdbServer
+if (-not $PrepareOnly) { Start-LocalAdbServer }
 
 # 6. Check and build Showcase UI if not already compiled
 $ShowcaseIndex = "$RootDir\apps\showcase_ui\dist\frontend\browser\index.html"
@@ -523,9 +544,15 @@ if ($frontendChanged -or ((-not (Test-Path $ShowcaseIndex)) -and (-not (Test-Pat
 
 # MCP clients were refreshed after Python dependency sync above.
 
+Exit-ArtemisInstallationLock -Mutex $installationLock
+$installationLock = $null
+if ($PrepareOnly) {
+    Write-Host (Get-LaunchText '[OK] Python, frontend and Codex MCP preparation complete.' '[完成] Python、网页构建和 Codex MCP 已准备好。') -ForegroundColor Green
+    exit 0
+}
 # 8. Launch unified Showcase UI & open browser
 # Ensure local ADB daemon is warm & listening
-Start-LocalAdbServer
+if (-not $PrepareOnly) { Start-LocalAdbServer }
 
 # Launch via `python -m artemis` (not the `artemis.exe` console-script shim) so the
 # long-running server never locks .venv\Scripts\artemis.exe against `uv sync` reinstalls.
diff --git a/scripts/update_installation.py b/scripts/update_installation.py
index 0db6d7e..2fc94fe 100644
--- a/scripts/update_installation.py
+++ b/scripts/update_installation.py
@@ -13,7 +13,6 @@ import subprocess
 import sys
 import tempfile
 import tomllib
-import urllib.request
 from urllib.parse import urlsplit
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -42,34 +41,16 @@ def git(root: Path, *args: str, timeout: int = 15) -> str:
     return result.stdout.strip()
 
 
-def update_source(root: Path, port: int = 8000) -> int:
-    """Return 10 after a fast-forward (caller reloads launcher); never overwrite local work."""
-    try:
-        opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
-        with opener.open(f"http://127.0.0.1:{port}/api/status", timeout=2) as response:
-            status = json.load(response)
-        if (
-            status.get("active_tasks")
-            or status.get("queue")
-            or (status.get("status") == "running" and status.get("pid"))
-        ):
-            print(
-                launch_text(
-                    "[WAIT] Tasks are active. Finish/stop them before updating dependencies or restarting.",
-                    "[等待] 有任务正在执行或排队。请先处理任务，再更新依赖或重启。",
-                )
-            )
-            return 20
-    except (OSError, ValueError):
-        pass
+def update_source(root: Path, *, check_only: bool = False) -> int:
+    """Return 10 for an available/applied fast-forward, 1 on failure; preserve local work."""
     if not shutil.which("git"):
         print(
             launch_text(
-                "[SKIP] Git is not installed. Continuing with local source; install Git for automatic source updates.",
-                "[跳过] 未安装 Git，继续使用当前源码；安装 Git 后可自动检查更新。",
+                "[ERROR] Install Git before upgrading; local source is preserved.",
+                "[提示] 未安装 Git，无法升级；当前源码保持不变。",
             )
         )
-        return 0
+        return 1
     if not (root / ".git").exists():
         print(
             launch_text(
@@ -77,8 +58,16 @@ def update_source(root: Path, port: int = 8000) -> int:
                 "[跳过] 旧版源码包不含 Git 信息。请使用新版源码包或 Git 克隆；当前文件保持不变。",
             )
         )
-        return 0
+        return 1
     try:
+        if not check_only and git(root, "status", "--porcelain"):
+            print(
+                launch_text(
+                    "[ERROR] Local changes exist; commit or back up first.",
+                    "[错误] 发现本地修改；请先提交或备份后再升级。",
+                )
+            )
+            return 1
         branch = git(root, "symbolic-ref", "--quiet", "--short", "HEAD")
         remote = git(root, "config", "--get", f"branch.{branch}.remote")
         merge_ref = git(root, "config", "--get", f"branch.{branch}.merge")
@@ -98,45 +87,53 @@ def update_source(root: Path, port: int = 8000) -> int:
                 "[检查] 正在检查当前分支的远程更新...",
             )
         )
-        git(root, "fetch", "--no-tags", remote, merge_ref, timeout=45)
+        git(root, "fetch", "--no-tags", remote, merge_ref, timeout=5 if check_only else 45)
         target = git(root, "rev-parse", "FETCH_HEAD")
         current = git(root, "rev-parse", "HEAD")
         if current == target:
             print(launch_text("[OK] Source is up to date.", "[完成] 源码已是最新版。"))
             return 0
+        if check_only:
+            print(
+                launch_text(
+                    "[UPDATE] A different upstream revision is available. Run update.bat (update-cn.bat for China mirrors).",
+                    "[更新] 远程版本有变化；请运行 update-cn.bat 或 update.bat 升级。",
+                )
+            )
+            return 10
         if git(root, "status", "--porcelain"):
             print(
                 launch_text(
-                    "[SKIP] Upstream differs, but local changes exist. Commit/back up your work before updating; continuing locally.",
-                    "[跳过] 发现本地修改；请先提交或备份。此次继续使用本地源码。",
+                    "[ERROR] Local changes appeared during the check. Upgrade stopped; files preserved.",
+                    "[错误] 检查期间出现本地修改；已停止升级，保留现有文件。",
                 )
             )
-            return 0
+            return 1
         ancestor = git(root, "merge-base", "HEAD", target)
         if ancestor != current:
             print(
                 launch_text(
-                    "[SKIP] Local branch is ahead or diverged. No automatic merge/rebase; continuing locally.",
-                    "[跳过] 本地分支领先或分叉，不自动合并；继续使用本地源码。",
+                    "[ERROR] Local branch is ahead or diverged. Upgrade stopped; no merge/rebase performed.",
+                    "[错误] 本地分支领先或分叉；已停止升级，不自动合并。",
                 )
             )
-            return 0
+            return 1
         git(root, "merge", "--ff-only", target, timeout=30)
         print(
             launch_text(
-                f"[UPDATED] Source {current[:12]} -> {target[:12]}. Reloading launcher and checking dependencies.",
-                f"[已更新] 源码 {current[:12]} -> {target[:12]}，重新载入启动脚本并检查依赖。",
+                f"[UPDATED] Source {current[:12]} -> {target[:12]}. Preparing the updated installation.",
+                f"[已更新] 源码 {current[:12]} -> {target[:12]}，准备同步新版环境。",
             )
         )
         return 10
-    except (RuntimeError, subprocess.TimeoutExpired) as exc:
+    except (OSError, RuntimeError, subprocess.TimeoutExpired) as exc:
         print(
             launch_text(
-                f"[WARN] {exc if isinstance(exc, RuntimeError) else 'Git update timed out.'} Continuing with local source.",
-                "[提示] Git 更新失败或超时；请检查网络、凭据和仓库状态。继续使用当前源码。",
+                f"[WARN] {exc if isinstance(exc, RuntimeError) else 'Git check failed or timed out.'} Local source is preserved.",
+                "[提示] Git 检查/更新失败或超时；请检查网络、凭据和仓库状态。当前源码保持不变。",
             )
         )
-        return 0
+        return 1
 
 
 def _atomic_write(path: Path, text: str) -> None:
@@ -406,12 +403,13 @@ def frontend_fingerprint(root: Path) -> str:
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("action", choices=["source", "mcp", "frontend-check", "frontend-mark"])
+    parser.add_argument(
+        "action", choices=["source", "source-check", "mcp", "frontend-check", "frontend-mark"]
+    )
     parser.add_argument("--root", type=Path, default=ROOT)
-    parser.add_argument("--port", type=int, default=8000)
     args = parser.parse_args()
-    if args.action == "source":
-        sys.exit(update_source(args.root, args.port))
+    if args.action in {"source", "source-check"}:
+        sys.exit(update_source(args.root, check_only=args.action == "source-check"))
     elif args.action == "mcp":
         sys.exit(refresh_mcp(args.root))
     else:
diff --git a/scripts/upgrade.ps1 b/scripts/upgrade.ps1
new file mode 100644
index 0000000..5d12311
--- /dev/null
+++ b/scripts/upgrade.ps1
@@ -0,0 +1,84 @@
+[CmdletBinding()]
+param(
+    [string]$ProjectRoot,
+    [ValidateSet('Official', 'China')][string]$Mirror,
+    [switch]$Help,
+    [switch]$Staged
+)
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object Text.UTF8Encoding($false)
+$env:PYTHONUTF8 = '1'
+$env:PYTHONIOENCODING = 'utf-8'
+if ($Help) {
+    Write-Host '用法：update.bat 或 update-cn.bat [-Help]'
+    Write-Host '升级会终止本项目的 ARTEMIS 服务、MCP 和任务进程；保留配置、密钥与历史资料。'
+    Write-Host '随后快进更新源码，同步依赖、网页构建和 Codex MCP；完成后请重新启动并重载 MCP。'
+    exit 0
+}
+if (-not $ProjectRoot) { $ProjectRoot = Split-Path $PSScriptRoot -Parent }
+$ProjectRoot = (Resolve-Path -LiteralPath $ProjectRoot).Path
+. (Join-Path $PSScriptRoot 'installation_lock.ps1')
+
+if (-not $Staged) {
+    $lock = $null
+    $stage = $null
+    $stageCreated = $false
+    $code = 1
+    try {
+        $lock = Enter-ArtemisInstallationLock -ProjectRoot $ProjectRoot
+        # Every program used before the merge is frozen outside the checkout.
+        $stage = Join-Path ([IO.Path]::GetTempPath()) ('artemis-upgrade-' + [Guid]::NewGuid().ToString('N'))
+        $fullStage = [IO.Path]::GetFullPath($stage)
+        $rootPrefix = [IO.Path]::GetFullPath($ProjectRoot).TrimEnd('\') + '\'
+        if ($fullStage.StartsWith($rootPrefix, [StringComparison]::OrdinalIgnoreCase)) { throw 'TEMP must be outside the project directory.' }
+        New-Item -ItemType Directory -Path $stage | Out-Null
+        $stageCreated = $true
+        foreach ($name in @('upgrade.ps1', 'installation_lock.ps1', 'upgrade_processes.ps1', 'update_installation.py')) {
+            Copy-Item -LiteralPath (Join-Path $PSScriptRoot $name) -Destination (Join-Path $stage $name)
+        }
+        $forward = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', (Join-Path $stage 'upgrade.ps1'), '-Staged', '-ProjectRoot', $ProjectRoot)
+        if ($Mirror) { $forward += @('-Mirror', $Mirror) }
+        & powershell.exe @forward
+        $code = $LASTEXITCODE
+    } catch {
+        Write-Host "[升级失败] $_" -ForegroundColor Red
+    } finally {
+        # Only remove the unique, validated staging directory created above.
+        if ($stageCreated -and (Test-Path -LiteralPath $stage)) { Remove-Item -LiteralPath $stage -Recurse -Force }
+        Exit-ArtemisInstallationLock -Mutex $lock
+    }
+    exit $code
+}
+
+try {
+    Set-Location -LiteralPath $PSScriptRoot
+    $python = Join-Path $ProjectRoot '.venv\Scripts\python.exe'
+    if (-not (Test-Path -LiteralPath $python)) { throw '尚未安装项目 Python 环境；请先运行 start.bat 或 start-cn.bat。' }
+    if (-not (Get-Command git -ErrorAction SilentlyContinue)) { throw '未安装 Git，无法升级。' }
+    if (-not (Test-Path -LiteralPath (Join-Path $ProjectRoot '.git'))) { throw '此目录不含 Git 信息；请改用 Git 克隆或新版发布源码包。' }
+    # Refuse dirty checkouts before terminating the user's running processes.
+    $localChanges = & git -C $ProjectRoot status --porcelain 2>$null
+    if ($LASTEXITCODE -ne 0) { throw '无法检查 Git 工作区。' }
+    if ($localChanges) { throw '发现本地修改；请先提交或备份，未终止任何任务。' }
+    Write-Host '======================================================'
+    Write-Host 'ARTEMIS 独立升级：将终止当前项目的服务、MCP 及任务。' -ForegroundColor Yellow
+    . (Join-Path $PSScriptRoot 'upgrade_processes.ps1')
+    Stop-ArtemisUpgradeProcesses -ProjectRoot $ProjectRoot
+    & $python (Join-Path $PSScriptRoot 'update_installation.py') source --root $ProjectRoot
+    if ($LASTEXITCODE -notin @(0, 10)) { throw '源码升级未完成；配置和历史资料已保留。' }
+    Stop-ArtemisUpgradeProcesses -ProjectRoot $ProjectRoot
+    # Load the new launcher only AFTER the frozen Git updater has exited.
+    $prepare = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', (Join-Path $ProjectRoot 'scripts\start.ps1'), '-PrepareOnly', '-SkipUpdate', '-NoOpen')
+    if ($Mirror) { $prepare += @('-Mirror', $Mirror) }
+    $previousChild = $env:ARTEMIS_UPGRADE_CHILD
+    $env:ARTEMIS_UPGRADE_CHILD = '1'
+    try { & powershell.exe @prepare; $prepareCode = $LASTEXITCODE }
+    finally { $env:ARTEMIS_UPGRADE_CHILD = $previousChild }
+    if ($prepareCode -ne 0) { throw '新版源码已保留，但环境同步失败；请处理上方错误后重新运行升级脚本。' }
+    Write-Host '[升级完成] 源码、依赖、网页及 Codex MCP 已检查并同步。' -ForegroundColor Green
+    Write-Host '[下一步] 运行启动脚本，并在 Codex 中重载 MCP 或重启 Codex。'
+    exit 0
+} catch {
+    Write-Host "[升级失败] $_" -ForegroundColor Red
+    exit 1
+}
diff --git a/scripts/upgrade_processes.ps1 b/scripts/upgrade_processes.ps1
new file mode 100644
index 0000000..71dcb7a
--- /dev/null
+++ b/scripts/upgrade_processes.ps1
@@ -0,0 +1,65 @@
+# Process ownership is determined by checkout paths, never by a port or name alone.
+function Get-ArtemisUpgradeProcesses {
+    param([string]$ProjectRoot, [object[]]$Processes, [int[]]$ProtectedIds = @())
+    $root = [IO.Path]::GetFullPath($ProjectRoot).TrimEnd('\') + '\'
+    $venv = $root + '.venv\'
+    $selected = @{}
+    foreach ($process in $Processes) {
+        if ($ProtectedIds -contains [int]$process.ProcessId) { continue }
+        $executable = [string]$process.ExecutablePath
+        $command = [string]$process.CommandLine
+        $python = $process.Name -match '^(python(w)?|artemis(-admin)?)\.exe$'
+        $inVenv = $executable.StartsWith($venv, [StringComparison]::OrdinalIgnoreCase)
+        $explicitRoot = $command.Replace('/', '\').IndexOf($root, [StringComparison]::OrdinalIgnoreCase) -ge 0
+        $entrypoint = $command -match '(?i)(?:-m\s+(?:artemis(?:\s|\.|$)|apps\.admin_console(?:\.|\s)|mcp_server(?:\.|\s|$))|[\\/]artemis(?:\.exe|[\\/]__main__\.py)|[\\/]mcp_server[\\/])'
+        if (($python -and $inVenv) -or ($explicitRoot -and $entrypoint -and ($python -or $process.Name -eq 'uv.exe'))) {
+            $selected[[int]$process.ProcessId] = $process
+        }
+    }
+    do {
+        $added = $false
+        foreach ($process in $Processes) {
+            $id = [int]$process.ProcessId
+            if ($selected.ContainsKey($id) -or $ProtectedIds -contains $id) { continue }
+            # Shared device services and desktop applications can outlive a task.
+            if ($process.Name -match '^(adb|codex|chrome|msedge|firefox|emulator|MuMu.*|Nemu.*|Nox.*|MEmu.*|LdVBox.*|HD-Player)\.exe$') { continue }
+            if ($selected.ContainsKey([int]$process.ParentProcessId)) {
+                $selected[$id] = $process
+                $added = $true
+            }
+        }
+    } while ($added)
+    return @($selected.Values)
+}
+
+function Stop-ArtemisUpgradeProcesses {
+    param([string]$ProjectRoot)
+    $snapshot = @(Get-CimInstance Win32_Process -ErrorAction Stop)
+    $protected = @($PID)
+    $parentId = $PID
+    do {
+        $parent = $snapshot | Where-Object { [int]$_.ProcessId -eq $parentId } | Select-Object -First 1
+        $parentId = if ($parent) { [int]$parent.ParentProcessId } else { 0 }
+        if ($parentId -and $protected -notcontains $parentId) { $protected += $parentId } else { break }
+    } while ($true)
+    $deadline = [DateTime]::UtcNow.AddSeconds(10)
+    do {
+        $targets = @(Get-ArtemisUpgradeProcesses -ProjectRoot $ProjectRoot -Processes $snapshot -ProtectedIds $protected)
+        if (-not $targets.Count) { return }
+        foreach ($target in $targets) {
+            $id = [int]$target.ProcessId
+            $current = Get-CimInstance Win32_Process -Filter "ProcessId = $id" -ErrorAction Stop
+            if (-not $current -or $current.CreationDate -ne $target.CreationDate) { continue }
+            Write-Host "[STOP] ARTEMIS PID $id ($($target.Name))"
+            try { Stop-Process -Id $id -Force -ErrorAction Stop }
+            catch {
+                if (Get-CimInstance Win32_Process -Filter "ProcessId = $id" -ErrorAction Stop) { throw }
+            }
+        }
+        Start-Sleep -Milliseconds 200
+        $snapshot = @(Get-CimInstance Win32_Process -ErrorAction Stop)
+    } while ([DateTime]::UtcNow -lt $deadline)
+    if (@(Get-ArtemisUpgradeProcesses -ProjectRoot $ProjectRoot -Processes $snapshot -ProtectedIds $protected).Count) {
+        throw 'ARTEMIS processes are still running. Source/dependency updates were not started.'
+    }
+}
diff --git a/skills/artemis-automation/SKILL.md b/skills/artemis-automation/SKILL.md
index 2a3a9ed..2d20157 100644
--- a/skills/artemis-automation/SKILL.md
+++ b/skills/artemis-automation/SKILL.md
@@ -7,6 +7,8 @@ description: 使用 ARTEMIS MCP 在 Android 真机或模拟器上完成自然语
 
 当前仅提供 Codex MCP 配置安装与更新：`uv run artemis mcp --install codex`；模板使用 `uv run artemis mcp --generate-config codex` 查看。启动日志会打印实际 Codex 配置路径，更新后重载 MCP。
 
+Windows 启动脚本只提示源码更新。升级使用 `update.bat`（国内镜像 `update-cn.bat`），会终止该项目的 ARTEMIS 服务、MCP 和运行任务；仅在用户授权升级或终止任务后执行，先告知任务将中断。升级会同步依赖、网页及 Codex MCP，保留配置和历史；完成后启动 ARTEMIS 并重载 Codex MCP。不要通过启动脚本拉取源码或强行覆盖本地修改。
+
 使用项目提供的 MCP 工具操作 Android。报告由 ARTEMIS 自己生成，不要求宿主 AI 具备 Codex 私有工具、Word 或 Excel 插件。该 Skill 不提供桌面/浏览器自动化，也不提供历史动作脚本回放。
 
 ## 从需求到执行
@@ -28,6 +30,8 @@ description: 使用 ARTEMIS MCP 在 Android 真机或模拟器上完成自然语
 
 ## 配置和恢复边界
 
+- 本机常见模拟器在设备刷新、启动及重启 ADB 后自动发现并连接，不必猜固定端口。USB 与 Android SDK 模拟器由 ADB 原生发现。首次连接其他 TCP 设备/无线手机时，在网页“无线 ADB”填写实际地址和端口，成功后程序保存地址并自动重连；无线调试的配对和授权仍由用户完成，端口变化后需重新连接。远程/转发 ADB 不执行本机发现。用 `mobile_workspace` 或 `mobile_diagnose` 检查自动连接结果；多设备时仍先确认用户要测试哪台。默认开关及扫描预算可由 `mobile_config(section="capabilities")` 的 `adb_auto_connect`、`adb_discovery_interval_seconds`（10）、`adb_discovery_timeout_seconds`（5）配置，修改全局默认需要用户授权。
+
 - `mobile_config` 读取非敏感设置。只有用户明确要求保存或修改默认配置时，才传 `changes` 与 `persist_defaults=true`；这些设置影响后续任务，不能为一次临时需求擅自改变以后所有任务。
 - 模型名称支持预设 `gpt-5.6-luna`、`gpt-6-luna`、`mimo-v2.6-flash`、`mimo-v2.6-pro` 和自定义名称，取决于用户配置的 Responses 网关。思考强度最高支持 `max`，默认 `high`、单次请求 300 秒、失败后最多重试 5 次；普通错误每次等待 10 秒，429 每次等待 60 秒。首选模型连续 3 次未形成有效工具调用时，当前步骤改用 `gpt-6-luna`（high），兜底最多再尝试 3 次；下一步恢复首选模型。默认关闭视频分析与录屏。不根据模型名称猜测网关能力。
 - 强度选 `default` 表示不发送该参数，和 `none`（显式要求关闭）不同。接口拒绝强度参数时明确呈现失败，先询问用户是否改用 `default`，不能静默降级或换模型。
diff --git a/start-cn.bat b/start-cn.bat
index f1560b1..450d86d 100644
--- a/start-cn.bat
+++ b/start-cn.bat
@@ -2,32 +2,16 @@
 chcp 65001 >nul 2>&1
 setlocal DisableDelayedExpansion
 set "ARTEMIS_LAUNCH_LANG=zh-CN"
-title ARTEMIS 国内镜像启动
+title ARTEMIS
 
 if /i "%~1"=="-Help" goto help
 if /i "%~1"=="--help" goto help
 
-echo ======================================================
-echo   ARTEMIS 中文启动 - 使用国内镜像
-echo ======================================================
-echo 正在检查已有环境、项目更新及依赖；首次启动可能需要下载组件。
-echo 镜像地址和下载超时可在 config\downloads.json 中调整。
-echo.
 call "%~dp0start.bat" -Mirror China %*
 set "ARTEMIS_CN_EXIT_CODE=%ERRORLEVEL%"
-if not "%ARTEMIS_CN_EXIT_CODE%"=="0" echo 启动未完成；请查看上方错误信息，并检查网络或镜像设置。
 endlocal & exit /b %ARTEMIS_CN_EXIT_CODE%
 
 :help
-echo 用法：start-cn.bat [选项]
-echo.
-echo   -SetupOnly    安装或检查环境，不启动网页
-echo   -Port 8001    使用指定端口，默认 8000
-echo   -NoOpen       启动服务后不自动打开浏览器
-echo   -SkipUpdate   跳过 Git 源码更新检查
-echo   -SkipMcpSync  仅启动网页，跳过 Codex MCP 安装和更新
-echo   -Help         显示本说明
-echo.
-echo 国内镜像设置：config\downloads.json
-echo 首次运行需联网；后续运行会检查源码、依赖，并同步 Codex MCP 配置。
-endlocal & exit /b 0
+call "%~dp0start.bat" -Mirror China -Help
+set "ARTEMIS_CN_EXIT_CODE=%ERRORLEVEL%"
+endlocal & exit /b %ARTEMIS_CN_EXIT_CODE%
diff --git a/start.bat b/start.bat
index 980bbdd..3068810 100644
--- a/start.bat
+++ b/start.bat
@@ -15,15 +15,10 @@ rem limitations under the License.
 
 chcp 65001 >nul 2>&1
 setlocal DisableDelayedExpansion
-if /i "%ARTEMIS_LAUNCH_LANG%"=="zh-CN" (title ARTEMIS 手机自动化测试) else (title Artemis Mobile Agent UI)
+title ARTEMIS
 
 pushd "%~dp0" || exit /b 1
 
-echo ======================================================
-if /i "%ARTEMIS_LAUNCH_LANG%"=="zh-CN" (echo       ARTEMIS 手机自动化测试) else (echo       Artemis Autonomous Mobile Agent UI)
-echo ======================================================
-echo.
-
 rem First run installs uv/Python/.venv; later runs check Git, dependencies and Codex MCP.
 rem Use -SkipUpdate to skip the Git source check and run local code.
 rem Use start.bat -SetupOnly to prepare Python without launching the UI.
@@ -33,7 +28,7 @@ set "ARTEMIS_EXIT_CODE=%ERRORLEVEL%"
 
 if not "%ARTEMIS_EXIT_CODE%"=="0" (
     echo.
-    if /i "%ARTEMIS_LAUNCH_LANG%"=="zh-CN" (echo ARTEMIS 启动失败，请查看上方详细信息。) else (echo An error occurred while starting Artemis.)
+    echo ARTEMIS startup failed. Please see the details above.
     if not defined ARTEMIS_NO_PAUSE pause
 )
 popd
diff --git a/tests/conftest.py b/tests/conftest.py
index b99e8d4..5d4b91d 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -26,6 +26,20 @@ import pytest
 from artemis.drivers.mock.mock_driver import MockDeviceDriver
 
 
+@pytest.fixture(autouse=True)
+def no_host_adb_discovery(monkeypatch, request):
+    """Deterministic tests must never connect to host emulators or remembered phones."""
+    from artemis.runtime.adb_discovery import adb_device_discovery
+
+    if any(
+        request.node.get_closest_marker(name)
+        for name in ("android", "integration", "e2e", "manual")
+    ):
+        return
+    monkeypatch.setattr(adb_device_discovery, "refresh", lambda *args, **kwargs: [])
+    monkeypatch.setattr(adb_device_discovery, "remember", lambda *args: True)
+
+
 @pytest.fixture
 def mock_driver():
     """Provide an isolated mock mobile driver."""
diff --git a/tests/unit/core/test_adb_server_connection.py b/tests/unit/core/test_adb_server_connection.py
index 8eee17d..17fa228 100644
--- a/tests/unit/core/test_adb_server_connection.py
+++ b/tests/unit/core/test_adb_server_connection.py
@@ -310,6 +310,67 @@ async def test_remote_endpoint_blocks_local_wireless_connection(monkeypatch):
     assert "Switch to local ADB" in result["message"]
 
 
+@pytest.mark.asyncio
+async def test_restart_reconnects_tcp_devices_after_server_started(monkeypatch):
+    from artemis.runtime.adb_discovery import adb_device_discovery
+
+    monkeypatch.setattr(
+        adb_server_connection, "current_endpoint", lambda: AdbServerEndpoint("127.0.0.1", 5037)
+    )
+    monkeypatch.setattr(
+        "artemis.core.diagnostics.adb_keys.inspect_adb_keys",
+        lambda: type("Keys", (), {"is_corrupted": False})(),
+    )
+    events = []
+
+    def run(args, **kwargs):
+        events.append(args[-1])
+        return subprocess.CompletedProcess(args, 0, "", "")
+
+    def reconnect(*args, **kwargs):
+        events.append("reconnect")
+        assert kwargs["force"] is True
+        return [{"target": "127.0.0.1:16384", "success": True}]
+
+    monkeypatch.setattr(subprocess, "run", run)
+    monkeypatch.setattr(adb_device_discovery, "refresh", reconnect)
+    result = await ReadinessEngine().restart_adb_server()
+    assert events == ["kill-server", "start-server", "reconnect"]
+    assert result["automatic_connections"][0]["success"] is True
+
+
+@pytest.mark.asyncio
+async def test_manual_tcp_connection_remembers_success_only(monkeypatch):
+    from unittest.mock import Mock
+    from artemis.runtime.adb_discovery import adb_device_discovery
+
+    monkeypatch.setattr(
+        adb_server_connection, "current_endpoint", lambda: AdbServerEndpoint("127.0.0.1", 5037)
+    )
+    remember = Mock(return_value=True)
+    monkeypatch.setattr(adb_device_discovery, "remember", remember)
+    monkeypatch.setattr(
+        subprocess,
+        "run",
+        lambda args, **kwargs: subprocess.CompletedProcess(
+            args, 0, "connected to 192.0.2.10:5555", ""
+        ),
+    )
+    result = await ReadinessEngine().connect_wireless_adb("192.0.2.10", 5555)
+    assert result["remembered"] is True
+    remember.assert_called_once_with("192.0.2.10:5555")
+    remember.reset_mock()
+    monkeypatch.setattr(
+        subprocess,
+        "run",
+        lambda args, **kwargs: subprocess.CompletedProcess(args, 1, "", "connection refused"),
+    )
+    result = await ReadinessEngine().connect_wireless_adb("192.0.2.11", 5555)
+    assert result["success"] is False
+    assert result["remembered"] is False
+    remember.assert_not_called()
+
+
 @pytest.mark.asyncio
 async def test_remote_endpoint_blocks_local_emulator_launch(monkeypatch):
     monkeypatch.setattr(
diff --git a/tests/unit/runtime/test_adb_discovery.py b/tests/unit/runtime/test_adb_discovery.py
new file mode 100644
index 0000000..16c385a
--- /dev/null
+++ b/tests/unit/runtime/test_adb_discovery.py
@@ -0,0 +1,290 @@
+"""TCP discovery tests never touch real processes, ports, devices or user state."""
+
+import importlib
+import json
+import struct
+import subprocess
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+from artemis.config import settings
+from artemis.runtime.adb_endpoint import AdbEndpoint
+
+module = importlib.import_module("artemis.runtime.adb_discovery")
+
+
+@pytest.fixture
+def discovery(tmp_path, monkeypatch):
+    instance = module.AdbDeviceDiscovery()
+    monkeypatch.setattr(instance, "_directory", lambda: tmp_path)
+    monkeypatch.setattr(module, "emulator_listeners", lambda: [])
+    monkeypatch.setattr(
+        module, "current_adb_endpoint", lambda: AdbEndpoint.create("127.0.0.1", 5037)
+    )
+    monkeypatch.setattr(settings, "ARTEMIS_ADB_AUTO_CONNECT", True)
+    monkeypatch.setattr(settings, "ARTEMIS_ADB_DISCOVERY_TIMEOUT_SECONDS", 5)
+    monkeypatch.setattr(settings, "ARTEMIS_ADB_DISCOVERY_INTERVAL_SECONDS", 10)
+    return instance
+
+
+def fake_adb(monkeypatch, *, ready="", failures=()):
+    calls = []
+    connected = []
+
+    def run(self, arguments, **kwargs):
+        calls.append(arguments)
+        assert 0 < kwargs["timeout"] <= 5
+        if arguments == ["devices"]:
+            return subprocess.CompletedProcess(
+                arguments,
+                0,
+                "List of devices attached\n"
+                + ready
+                + "".join(f"{target} device\n" for target in connected),
+                "",
+            )
+        target = arguments[1]
+        if target in failures:
+            raise subprocess.TimeoutExpired(arguments, kwargs["timeout"])
+        connected.append(target)
+        return subprocess.CompletedProcess(arguments, 0, f"connected to {target}", "")
+
+    monkeypatch.setattr(module.AdbSession, "run", run)
+    return calls
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "MuMuNxDevice.exe",
+        "NemuHeadless.exe",
+        "LdVBoxHeadless.exe",
+        "NoxVMHandle.exe",
+        "MEmuHeadless.exe",
+        "HD-Player.exe",
+    ],
+)
+def test_supported_emulator_listener_ownership(monkeypatch, name):
+    monkeypatch.setattr(
+        module.psutil,
+        "process_iter",
+        lambda attrs: [
+            SimpleNamespace(info={"pid": 4, "name": name, "exe": "vendor.exe"}),
+            SimpleNamespace(info={"pid": 5, "name": "other.exe"}),
+        ],
+    )
+    monkeypatch.setattr(
+        module.psutil,
+        "net_connections",
+        lambda kind: [
+            SimpleNamespace(pid=pid, status="LISTEN", laddr=SimpleNamespace(ip=ip, port=port))
+            for pid, ip, port in [
+                (4, "0.0.0.0", 16384),
+                (4, "127.0.0.1", 7555),
+                (4, "192.0.2.1", 5555),
+                (5, "0.0.0.0", 16385),
+            ]
+        ],
+    )
+    assert module.emulator_listeners() == [["127.0.0.1:16384", "127.0.0.1:7555"]]
+
+
+def test_generic_virtualbox_is_not_an_android_emulator(monkeypatch):
+    monkeypatch.setattr(
+        module.psutil,
+        "process_iter",
+        lambda attrs: [
+            SimpleNamespace(
+                info={"pid": 4, "name": "VBoxHeadless.exe", "exe": "VirtualBox/VBoxHeadless.exe"}
+            )
+        ],
+    )
+    monkeypatch.setattr(
+        module.psutil,
+        "net_connections",
+        lambda kind: pytest.fail("No known emulator; do not scan listeners"),
+    )
+    assert module.emulator_listeners() == []
+
+
+@pytest.mark.parametrize("kind,valid", [(b"CNXN", True), (b"AUTH", True), (b"HTTP", False)])
+def test_adbd_protocol_handles_fragmented_headers(monkeypatch, kind, valid):
+    command = int.from_bytes(kind, "little")
+    header = struct.pack("<6I", command, 1, 4096, 0, 0, command ^ 0xFFFFFFFF)
+    stream = Mock()
+    stream.__enter__ = Mock(return_value=stream)
+    stream.__exit__ = Mock(return_value=False)
+    stream.recv.side_effect = [header[:8], header[8:]]
+    monkeypatch.setattr(module.socket, "create_connection", lambda *args, **kwargs: stream)
+    assert module.is_adbd("127.0.0.1:16384", 0.3) is valid
+    assert stream.sendall.call_args.args[0][:4] == b"CNXN"
+
+
+def test_discovery_connects_new_instance_without_duplicate_aliases(discovery, monkeypatch):
+    calls = fake_adb(monkeypatch)
+    monkeypatch.setattr(
+        module,
+        "emulator_listeners",
+        lambda: [["127.0.0.1:16384", "127.0.0.1:7555"], ["127.0.0.1:16416"]],
+    )
+    monkeypatch.setattr(module, "is_adbd", lambda *args: True)
+    results = discovery.refresh("adb")
+    assert [r["target"] for r in results] == ["127.0.0.1:16384", "127.0.0.1:16416"]
+    discovery.refresh("adb")
+    assert len(calls) == 5  # cached: no subprocesses on repeated polling
+    discovery.refresh("adb", force=True)
+    assert len(calls) == 6  # force enumerates; connected instances are not reconnected
+
+
+def test_ready_and_unauthorized_emulators_are_not_probed(discovery, monkeypatch):
+    calls = fake_adb(monkeypatch, ready="127.0.0.1:7555 device\n127.0.0.1:16416 unauthorized\n")
+    monkeypatch.setattr(
+        module,
+        "emulator_listeners",
+        lambda: [["127.0.0.1:16384", "127.0.0.1:7555"], ["127.0.0.1:16416"]],
+    )
+    monkeypatch.setattr(
+        module, "is_adbd", lambda *args: pytest.fail("Do not touch an existing transport")
+    )
+    assert discovery.refresh("adb") == []
+    assert calls == [["devices"]]
+
+
+def test_non_adb_port_is_not_connected(discovery, monkeypatch):
+    calls = fake_adb(monkeypatch)
+    monkeypatch.setattr(
+        module, "emulator_listeners", lambda: [["127.0.0.1:23579", "127.0.0.1:16384"]]
+    )
+    monkeypatch.setattr(module, "is_adbd", lambda target, timeout: target.endswith(":16384"))
+    assert discovery.refresh("adb")[0]["success"] is True
+    assert calls == [["devices"], ["connect", "127.0.0.1:16384"], ["devices"]]
+
+
+@pytest.mark.parametrize("port", [5038, 5040])
+def test_forwarded_adb_never_discovers_local_devices(discovery, monkeypatch, port):
+    monkeypatch.setattr(
+        module, "current_adb_endpoint", lambda: AdbEndpoint.create("127.0.0.1", port)
+    )
+    monkeypatch.setattr(
+        module.AdbSession,
+        "run",
+        lambda *args, **kwargs: pytest.fail("Remote endpoint must stay untouched"),
+    )
+    assert discovery.refresh("adb", force=True) == []
+
+
+def test_disabled_discovery_and_concurrent_call_do_not_connect(discovery, monkeypatch):
+    monkeypatch.setattr(settings, "ARTEMIS_ADB_AUTO_CONNECT", False)
+    monkeypatch.setattr(
+        module.AdbSession, "run", lambda *args, **kwargs: pytest.fail("Must not spawn")
+    )
+    assert discovery.refresh("adb") == []
+    monkeypatch.setattr(settings, "ARTEMIS_ADB_AUTO_CONNECT", True)
+    with discovery._gate:
+        assert discovery.refresh("adb") == []
+
+
+def test_remembered_phone_survives_process_restart_and_offline_peer(
+    discovery, monkeypatch, tmp_path
+):
+    assert discovery.remember("192.0.2.10:5555")
+    assert discovery.remember("192.0.2.11:5555")
+    second = module.AdbDeviceDiscovery()
+    monkeypatch.setattr(second, "_directory", lambda: tmp_path)
+    calls = fake_adb(monkeypatch, failures={"192.0.2.10:5555"})
+    results = second.refresh("adb")
+    assert len(results) == 2
+    assert any(r["success"] and r["target"] == "192.0.2.11:5555" for r in results)
+    assert len(calls) == 4
+
+
+def test_total_budget_stops_unlimited_connection_attempts(discovery, monkeypatch):
+    clock = [0.0]
+    monkeypatch.setattr(module.time, "monotonic", lambda: clock[0])
+    monkeypatch.setattr(
+        module, "emulator_listeners", lambda: [[f"127.0.0.1:{16384 + i}"] for i in range(100)]
+    )
+
+    def probe(*args):
+        clock[0] += 1
+        return True
+
+    monkeypatch.setattr(module, "is_adbd", probe)
+    calls = fake_adb(monkeypatch)
+    discovery.refresh("adb")
+    assert len(calls) == 9  # listing plus four connects/readiness checks within 5s
+
+
+def test_corrupt_persistence_and_missing_process_permissions_are_nonfatal(
+    discovery, monkeypatch, tmp_path
+):
+    (tmp_path / "broken.json").write_text(json.dumps({"target": "bad"}))
+    assert discovery._remembered() == []
+    fake_adb(monkeypatch)
+    monkeypatch.setattr(
+        module, "emulator_listeners", Mock(side_effect=module.psutil.AccessDenied())
+    )
+    assert discovery.refresh("adb")[0]["success"] is False
+
+
+def test_listener_permission_failure_still_reconnects_saved_phone(discovery, monkeypatch):
+    assert discovery.remember("192.0.2.10:5555")
+    fake_adb(monkeypatch)
+    monkeypatch.setattr(
+        module, "emulator_listeners", Mock(side_effect=module.psutil.AccessDenied())
+    )
+    results = discovery.refresh("adb")
+    assert results[-1]["target"] == "192.0.2.10:5555"
+    assert results[-1]["success"] is True
+
+
+def test_localhost_alias_does_not_create_duplicate_transport(discovery, monkeypatch):
+    assert discovery.remember("localhost:16384")
+    calls = fake_adb(monkeypatch, ready="127.0.0.1:16384 device\n")
+    assert discovery.refresh("adb") == []
+    assert calls == [["devices"]]
+
+
+def test_connect_waits_until_transport_is_visible(monkeypatch):
+    clock = [0.0]
+    monkeypatch.setattr(module.time, "monotonic", lambda: clock[0])
+    monkeypatch.setattr(
+        module.time, "sleep", lambda seconds: clock.__setitem__(0, clock[0] + seconds)
+    )
+    responses = iter(
+        ["List of devices attached\n", "127.0.0.1:16384 offline\n", "127.0.0.1:16384 device\n"]
+    )
+    session = Mock()
+    session.run.side_effect = lambda *args, **kwargs: subprocess.CompletedProcess(
+        [], 0, next(responses), ""
+    )
+    assert module.AdbDeviceDiscovery._wait_for_transport(session, "localhost:16384", 1) == "device"
+    assert session.run.call_count == 3
+
+
+def test_transport_settling_is_bounded(monkeypatch):
+    clock = [0.0]
+    monkeypatch.setattr(module.time, "monotonic", lambda: clock[0])
+    monkeypatch.setattr(
+        module.time, "sleep", lambda seconds: clock.__setitem__(0, clock[0] + seconds)
+    )
+    session = Mock()
+    session.run.return_value = subprocess.CompletedProcess([], 0, "List of devices attached\n", "")
+    assert module.AdbDeviceDiscovery._wait_for_transport(session, "127.0.0.1:16384", 0.2) is None
+    assert clock[0] == 0.2
+
+
+def test_pending_transport_is_not_reported_as_failed_or_connected(discovery, monkeypatch):
+    fake_adb(monkeypatch)
+    monkeypatch.setattr(
+        module, "emulator_listeners", lambda: [["127.0.0.1:16384", "127.0.0.1:7555"]]
+    )
+    monkeypatch.setattr(module, "is_adbd", lambda *args: True)
+    monkeypatch.setattr(discovery, "_wait_for_transport", lambda *args: None)
+    results = discovery.refresh("adb")
+    assert len(results) == 1
+    assert results[0]["pending"] is True
+    assert results[0]["success"] is False
+    assert "等待设备就绪" in results[0]["message"]
diff --git a/tests/unit/test_batch_launchers.py b/tests/unit/test_batch_launchers.py
new file mode 100644
index 0000000..43e73ab
--- /dev/null
+++ b/tests/unit/test_batch_launchers.py
@@ -0,0 +1,106 @@
+"""Exercise CMD parsing and Windows PowerShell 5.1 without installing anything."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+pytestmark = pytest.mark.skipif(
+    not shutil.which("cmd.exe") or not shutil.which("powershell.exe"),
+    reason="Windows CMD and Windows PowerShell required",
+)
+
+
+def copy_launchers(root: Path, newline: bytes) -> None:
+    root.mkdir()
+    (root / "scripts").mkdir()
+    for name in ("start.bat", "start-cn.bat"):
+        content = (ROOT / name).read_bytes().replace(b"\r\n", b"\n")
+        # ASCII batch wrappers remain safe even if a zip/editor changes EOLs.
+        content.decode("ascii")
+        (root / name).write_bytes(content.replace(b"\n", newline))
+
+
+@pytest.mark.parametrize("newline", [b"\r\n", b"\n"])
+@pytest.mark.parametrize("exit_code", [0, 7])
+def test_launch_forwards_options_and_exit_code_without_cmd_garbling(tmp_path, newline, exit_code):
+    root = tmp_path / "source with spaces"
+    copy_launchers(root, newline)
+    (root / "scripts" / "start.ps1").write_text(
+        """param([string]$Mirror, [int]$Port, [switch]$NoOpen, [switch]$SkipUpdate, [switch]$SkipMcpSync)
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+Write-Host '镜像地址和下载超时可在 config\\downloads.json 中调整。'
+Write-Host ('ARGS=' + (@{mirror=$Mirror;port=$Port;no_open=[bool]$NoOpen;skip_update=[bool]$SkipUpdate;skip_mcp=[bool]$SkipMcpSync;language=$env:ARTEMIS_LAUNCH_LANG} | ConvertTo-Json -Compress))
+exit ([int]$env:LAUNCH_TEST_EXIT)
+""",
+        encoding="utf-8-sig",
+    )
+    result = subprocess.run(
+        [
+            "cmd.exe",
+            "/d",
+            "/c",
+            "start-cn.bat",
+            "-Port",
+            "8123",
+            "-NoOpen",
+            "-SkipUpdate",
+            "-SkipMcpSync",
+        ],
+        cwd=root,
+        env={**os.environ, "ARTEMIS_NO_PAUSE": "1", "LAUNCH_TEST_EXIT": str(exit_code)},
+        capture_output=True,
+        encoding="utf-8",
+        timeout=15,
+    )
+    assert result.returncode == exit_code, result.stdout + result.stderr
+    assert result.stderr == ""
+    assert "镜像地址和下载超时可在" in result.stdout
+    args = json.loads(
+        next(
+            line.removeprefix("ARGS=")
+            for line in result.stdout.splitlines()
+            if line.startswith("ARGS=")
+        )
+    )
+    assert args == {
+        "mirror": "China",
+        "port": 8123,
+        "no_open": True,
+        "skip_update": True,
+        "skip_mcp": True,
+        "language": "zh-CN",
+    }
+
+
+@pytest.mark.parametrize("newline", [b"\r\n", b"\n"])
+@pytest.mark.parametrize("help_flag", ["-Help", "--help"])
+def test_actual_chinese_help_has_no_encoding_error_or_bootstrap(tmp_path, newline, help_flag):
+    root = tmp_path / "source with spaces"
+    copy_launchers(root, newline)
+    shutil.copyfile(ROOT / "scripts" / "start.ps1", root / "scripts" / "start.ps1")
+    assert (root / "scripts" / "start.ps1").read_bytes().startswith(b"\xef\xbb\xbf")
+    result = subprocess.run(
+        ["cmd.exe", "/d", "/c", "start-cn.bat", help_flag],
+        cwd=root,
+        capture_output=True,
+        encoding="utf-8",
+        timeout=15,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert result.stderr == ""
+    assert "用法：start-cn.bat [选项]" in result.stdout
+    assert "仅启动网页，跳过 Codex MCP" in result.stdout
+    assert "国内镜像设置：config\\downloads.json" in result.stdout
+    assert "�" not in result.stdout
+    assert not (root / ".venv").exists()
+
+
+def test_batch_files_are_ascii_and_powershell_text_has_bom():
+    for name in ("start.bat", "start-cn.bat"):
+        (ROOT / name).read_bytes().decode("ascii")
+    assert (ROOT / "scripts" / "start.ps1").read_bytes().startswith(b"\xef\xbb\xbf")
diff --git a/tests/unit/test_installation_update.py b/tests/unit/test_installation_update.py
index c306d2f..af9bc8c 100644
--- a/tests/unit/test_installation_update.py
+++ b/tests/unit/test_installation_update.py
@@ -53,18 +53,18 @@ def repos(tmp_path):
 
 def test_fast_forward_update_preserves_env_and_is_repeatable(repos):
     installed, author = repos
-    assert update.update_source(installed, port=1) == 10
+    assert update.update_source(installed) == 10
     assert (installed / "source.txt").read_text() == "version2"
     assert (installed / ".env").read_text() == "secret stays local"
     assert git(installed, "rev-parse", "HEAD") == git(author, "rev-parse", "HEAD")
-    assert update.update_source(installed, port=1) == 0
+    assert update.update_source(installed) == 0
 
 
 def test_dirty_checkout_is_preserved(repos):
     installed, _ = repos
     before = git(installed, "rev-parse", "HEAD")
     (installed / "source.txt").write_text("user edits")
-    assert update.update_source(installed, port=1) == 0
+    assert update.update_source(installed) == 1
     assert git(installed, "rev-parse", "HEAD") == before
     assert (installed / "source.txt").read_text() == "user edits"
 
@@ -77,16 +77,32 @@ def test_diverged_checkout_is_not_merged(repos):
     git(installed, "add", "local.txt")
     git(installed, "commit", "-m", "local")
     before = git(installed, "rev-parse", "HEAD")
-    assert update.update_source(installed, port=1) == 0
+    assert update.update_source(installed) == 1
     assert git(installed, "rev-parse", "HEAD") == before
 
 
-def test_zip_install_continues_without_git_mutation(tmp_path, capsys):
-    assert update.update_source(tmp_path, port=1) == 0
+def test_zip_install_fails_without_git_mutation(tmp_path, capsys):
+    assert update.update_source(tmp_path) == 1
     assert not (tmp_path / ".git").exists()
     assert "Git" in capsys.readouterr().out
 
 
+def test_startup_check_reports_update_without_changing_source(repos):
+    installed, _ = repos
+    before = git(installed, "rev-parse", "HEAD")
+    assert update.update_source(installed, check_only=True) == 10
+    assert git(installed, "rev-parse", "HEAD") == before
+    assert (installed / "source.txt").read_text() == "version1"
+
+
+def test_update_fetch_failure_is_not_reported_as_success(repos):
+    installed, _ = repos
+    before = git(installed, "rev-parse", "HEAD")
+    git(installed, "remote", "set-url", "origin", str(installed / "missing-upstream"))
+    assert update.update_source(installed) == 1
+    assert git(installed, "rev-parse", "HEAD") == before
+
+
 def test_codex_refresh_preserves_credentials_restrictions_and_other_settings(tmp_path):
     root = tmp_path / "project"
     path = tmp_path / "config.toml"
diff --git a/tests/unit/test_source_archive.py b/tests/unit/test_source_archive.py
index 967b923..d3b6230 100644
--- a/tests/unit/test_source_archive.py
+++ b/tests/unit/test_source_archive.py
@@ -112,7 +112,7 @@ def test_unpacked_archive_fast_forwards(repository, tmp_path):
     git(root, "push", "test-upstream", "main")
     from scripts.update_installation import update_source
 
-    assert update_source(extracted, port=1) == 10
+    assert update_source(extracted) == 10
     assert (extracted / "start.bat").read_text() == "updated"
     assert git(extracted, "status", "--porcelain") == ""
 
diff --git a/tests/unit/test_windows_bootstrap.py b/tests/unit/test_windows_bootstrap.py
index 37511de..51ef121 100644
--- a/tests/unit/test_windows_bootstrap.py
+++ b/tests/unit/test_windows_bootstrap.py
@@ -153,12 +153,22 @@ def test_chinese_batch_prints_complete_lines_and_preserves_exit_code(tmp_path, e
     root = tmp_path / "source with spaces!"
     root.mkdir()
     shutil.copy2(ROOT / "start-cn.bat", root / "start-cn.bat")
-    (root / "start.bat").write_bytes(
-        f'@echo off\r\nif not "%~1"=="-Mirror" exit /b 19\r\n'
-        f'if not "%~2"=="China" exit /b 20\r\nexit /b {exit_code}\r\n'.encode("ascii")
+    shutil.copy2(ROOT / "start.bat", root / "start.bat")
+    (root / "scripts").mkdir()
+    # Exercise the real Chinese banner/help prologue, stopping before installs,
+    # update checks or downloads. Chinese now belongs to PowerShell, not CMD.
+    prologue = (
+        (ROOT / "scripts/start.ps1")
+        .read_text(encoding="utf-8-sig")
+        .split("# Ensure modern TLS", 1)[0]
+    )
+    (root / "scripts/start.ps1").write_text(
+        prologue + f"\nif ($Mirror -ne 'China') {{ exit 20 }}\nexit {exit_code}\n",
+        encoding="utf-8-sig",
     )
     result = subprocess.run(
         ["cmd.exe", "/d", "/c", "call", str(root / "start-cn.bat")],
+        env={**os.environ, "ARTEMIS_NO_PAUSE": "1"},
         capture_output=True,
         timeout=15,
     )
diff --git a/tests/unit/test_windows_upgrade.py b/tests/unit/test_windows_upgrade.py
new file mode 100644
index 0000000..8e93e1d
--- /dev/null
+++ b/tests/unit/test_windows_upgrade.py
@@ -0,0 +1,357 @@
+"""Verify frozen upgrades and process ownership in disposable Windows installations."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+pytestmark = pytest.mark.skipif(
+    sys.platform != "win32" or not shutil.which("powershell.exe") or not shutil.which("uv"),
+    reason="Windows PowerShell and uv required",
+)
+
+
+def powershell(script, *, env=None, cwd=None):
+    return subprocess.run(
+        ["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", str(script)],
+        cwd=cwd,
+        env={**os.environ, **(env or {})},
+        capture_output=True,
+        encoding="utf-8",
+        timeout=45,
+    )
+
+
+def git(root, *args):
+    return (
+        subprocess.run(["git", "-C", str(root), *args], capture_output=True, check=True, timeout=15)
+        .stdout.decode()
+        .strip()
+    )
+
+
+def make_venv(root):
+    subprocess.run(
+        ["uv", "venv", "--offline", "--python", sys.executable, str(root / ".venv")],
+        check=True,
+        capture_output=True,
+        timeout=30,
+    )
+    return root / ".venv/Scripts/python.exe"
+
+
+def test_process_selection_is_scoped_and_includes_descendants(tmp_path):
+    root = tmp_path / "project"
+
+    def process(pid, executable, command, name="python.exe", parent=0):
+        return dict(
+            ProcessId=pid,
+            ParentProcessId=parent,
+            ExecutablePath=executable,
+            CommandLine=command,
+            Name=name,
+        )
+
+    processes = [
+        process(10, str(root / ".venv/Scripts/python.exe"), "python -m artemis ui"),
+        process(11, "C:\\Python\\python.exe", "python -m multiprocessing.spawn", parent=10),
+        process(12, "C:\\tools\\ffmpeg.exe", "ffmpeg recording", "ffmpeg.exe", parent=11),
+        process(13, "C:\\tools\\adb.exe", "adb server", "adb.exe", parent=10),
+        process(14, "C:\\apps\\codex.exe", "codex", "codex.exe", parent=10),
+        process(
+            20,
+            str(root.with_name("project-other") / ".venv/Scripts/python.exe"),
+            "python -m artemis ui",
+        ),
+        process(21, "C:\\Python\\python.exe", "python -m artemis ui"),
+        process(22, "C:\\Python\\python.exe", f'python "{root}/mcp_server/__main__.py"'),
+        process(23, "C:\\Python\\python.exe", f'python "{root}/unrelated.py"'),
+        process(24, str(root / ".venv/Scripts/python.exe"), "protected updater"),
+        process(25, "C:\\tools\\emulator.exe", "emulator", "emulator.exe", parent=10),
+    ]
+    fixture = tmp_path / "processes.json"
+    fixture.write_text(json.dumps(processes), encoding="utf-8")
+    script = tmp_path / "select.ps1"
+    script.write_text(
+        "[Console]::OutputEncoding = New-Object Text.UTF8Encoding($false)\n"
+        f". '{ROOT / 'scripts/upgrade_processes.ps1'}'\n"
+        "$snapshot = Get-Content -Raw -LiteralPath $env:PROCESS_FIXTURE | ConvertFrom-Json\n"
+        "$ids = @(Get-ArtemisUpgradeProcesses -ProjectRoot $env:PROJECT_ROOT -Processes $snapshot -ProtectedIds @(24) | ForEach-Object { [int]$_.ProcessId } | Sort-Object)\n"
+        "ConvertTo-Json -InputObject $ids -Compress\n",
+        encoding="ascii",
+    )
+    result = powershell(script, env={"PROCESS_FIXTURE": str(fixture), "PROJECT_ROOT": str(root)})
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert json.loads(result.stdout) == [10, 11, 12, 22]
+
+
+def test_real_project_process_tree_stops_but_unrelated_process_survives(tmp_path):
+    import psutil
+
+    root = tmp_path / "project with spaces!"
+    root.mkdir()
+    python = make_venv(root)
+    pid_file = root / "child.pid"
+    sleeper = root / "sleeper.py"
+    sleeper.write_text(
+        "import pathlib, subprocess, sys, time\n"
+        "child = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)'])\n"
+        "pathlib.Path(sys.argv[1]).write_text(str(child.pid))\n"
+        "time.sleep(60)\n",
+        encoding="ascii",
+    )
+    project = subprocess.Popen([str(python), str(sleeper), str(pid_file)])
+    unrelated = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(60)"])
+    child_pid = None
+    try:
+        for _ in range(100):
+            if pid_file.exists():
+                child_pid = int(pid_file.read_text())
+                break
+            time.sleep(0.05)
+        assert child_pid is not None
+        script = tmp_path / "stop.ps1"
+        script.write_text(
+            "$ErrorActionPreference = 'Stop'\n"
+            f". '{ROOT / 'scripts/upgrade_processes.ps1'}'\n"
+            "Stop-ArtemisUpgradeProcesses -ProjectRoot $env:PROJECT_ROOT\n",
+            encoding="ascii",
+        )
+        result = powershell(script, env={"PROJECT_ROOT": str(root)})
+        assert result.returncode == 0, result.stdout + result.stderr
+        project.wait(timeout=5)
+        assert unrelated.poll() is None
+        assert not psutil.pid_exists(child_pid)
+    finally:
+        for process in (project, unrelated):
+            if process.poll() is None:
+                process.kill()
+            process.wait(timeout=5)
+        if child_pid and psutil.pid_exists(child_pid):
+            psutil.Process(child_pid).kill()
+
+
+@pytest.mark.parametrize("prepare_exit", [0, 7])
+def test_frozen_upgrade_survives_launcher_replacement_and_reports_setup_failure(
+    tmp_path, prepare_exit
+):
+    if not shutil.which("git"):
+        pytest.skip("Git required")
+    author = tmp_path / "author"
+    (author / "scripts").mkdir(parents=True)
+    for name in (
+        "upgrade.ps1",
+        "upgrade_processes.ps1",
+        "installation_lock.ps1",
+        "update_installation.py",
+    ):
+        shutil.copyfile(ROOT / "scripts" / name, author / "scripts" / name)
+    for name in ("update.bat", "update-cn.bat"):
+        shutil.copyfile(ROOT / name, author / name)
+    (author / ".gitignore").write_text(".env\n.venv/\nprepared.txt\n")
+    (author / "scripts/start.ps1").write_text("exit 23\n", encoding="ascii")
+    git(author, "init", "-b", "main")
+    git(author, "config", "user.name", "Fixture")
+    git(author, "config", "user.email", "fixture@example.test")
+    git(author, "add", ".")
+    git(author, "commit", "-m", "old version")
+    installed = tmp_path / "installed with spaces!"
+    git(tmp_path, "clone", "-b", "main", str(author), str(installed))
+    make_venv(installed)
+    (installed / ".env").write_text("secret stays local")
+    # A running file AND both BAT wrappers are replaced during the merge.
+    (author / "scripts/upgrade.ps1").write_text("throw 'new updater must not run in this turn'\n")
+    (author / "scripts/upgrade_processes.ps1").write_text(
+        "throw 'new process helper must not run'\n"
+    )
+    (author / "update.bat").write_text("@echo off\nexit /b 33\n")
+    (author / "update-cn.bat").write_text("@echo off\nexit /b 34\n")
+    (author / "scripts/start.ps1").write_text(
+        "param([switch]$PrepareOnly, [switch]$SkipUpdate, [switch]$NoOpen, [string]$Mirror)\n"
+        "if (-not ($PrepareOnly -and $SkipUpdate -and $NoOpen) -or $Mirror -ne 'China' -or $env:ARTEMIS_UPGRADE_CHILD -ne '1') { exit 35 }\n"
+        "Set-Content -LiteralPath (Join-Path (Split-Path $PSScriptRoot -Parent) 'prepared.txt') -Value 'new version prepared'\n"
+        f"exit {prepare_exit}\n",
+        encoding="ascii",
+    )
+    git(author, "add", ".")
+    git(author, "commit", "-m", "new version")
+    result = subprocess.run(
+        ["cmd.exe", "/d", "/c", "update-cn.bat"],
+        cwd=installed,
+        capture_output=True,
+        encoding="utf-8",
+        timeout=45,
+    )
+    assert result.returncode == (0 if prepare_exit == 0 else 1), result.stdout + result.stderr
+    assert result.stderr == ""
+    assert (installed / "prepared.txt").read_text().strip() == "new version prepared"
+    assert git(installed, "rev-parse", "HEAD") == git(author, "rev-parse", "HEAD")
+    assert (installed / ".env").read_text() == "secret stays local"
+    assert ("升级完成" in result.stdout) == (prepare_exit == 0)
+    assert "new updater must not run" not in result.stdout
+
+
+@pytest.mark.parametrize("name", ["update.bat", "update-cn.bat"])
+@pytest.mark.parametrize("help_flag", ["-Help", "--help"])
+def test_upgrade_help_is_safe_and_wrappers_are_ascii(name, help_flag):
+    (ROOT / name).read_bytes().decode("ascii")
+    result = subprocess.run(
+        ["cmd.exe", "/d", "/c", name, help_flag],
+        cwd=ROOT,
+        capture_output=True,
+        encoding="utf-8",
+        timeout=15,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert result.stderr == ""
+    assert "升级会终止本项目" in result.stdout
+
+
+def test_installation_lock_blocks_same_checkout_and_recovers_after_owner_crash(tmp_path):
+    holder_script = tmp_path / "holder.ps1"
+    holder_script.write_text(
+        f". '{ROOT / 'scripts/installation_lock.ps1'}'\n"
+        "$lock = Enter-ArtemisInstallationLock -ProjectRoot $env:PROJECT_ROOT\n"
+        "Set-Content -LiteralPath $env:READY_FILE -Value 'ready'\n"
+        "Start-Sleep -Seconds 60\n",
+        encoding="ascii",
+    )
+    ready = tmp_path / "ready.txt"
+    root = tmp_path / "project"
+    holder = subprocess.Popen(
+        ["powershell.exe", "-NoProfile", "-File", str(holder_script)],
+        env={**os.environ, "PROJECT_ROOT": str(root), "READY_FILE": str(ready)},
+    )
+    contender = tmp_path / "contender.ps1"
+    contender.write_text(
+        f". '{ROOT / 'scripts/installation_lock.ps1'}'\n"
+        "try {\n"
+        "  $lock = Enter-ArtemisInstallationLock -ProjectRoot $env:PROJECT_ROOT\n"
+        "  Exit-ArtemisInstallationLock -Mutex $lock\n"
+        "  exit 0\n"
+        "} catch { Write-Host 'LOCK_BUSY'; exit 37 }\n",
+        encoding="ascii",
+    )
+    try:
+        for _ in range(100):
+            if ready.exists():
+                break
+            time.sleep(0.05)
+        assert ready.exists()
+        blocked = powershell(contender, env={"PROJECT_ROOT": str(root)})
+        assert blocked.returncode == 37, blocked.stdout + blocked.stderr
+        assert (
+            powershell(contender, env={"PROJECT_ROOT": str(root.with_name("other"))}).returncode
+            == 0
+        )
+        holder.kill()
+        holder.wait(timeout=5)
+        assert powershell(contender, env={"PROJECT_ROOT": str(root)}).returncode == 0
+    finally:
+        if holder.poll() is None:
+            holder.kill()
+        holder.wait(timeout=5)
+
+
+def test_actual_preparation_build_checks_run_without_launching_ui_or_adb(tmp_path):
+    root = tmp_path / "prepared project"
+    (root / "scripts").mkdir(parents=True)
+    for name in ("start.ps1", "installation_lock.ps1"):
+        shutil.copyfile(ROOT / "scripts" / name, root / "scripts" / name)
+    (root / "scripts/download_config.ps1").write_text(
+        "function Initialize-ArtemisDownloads { $script:ArtemisDownloads = @{mode='Official'} }\n",
+        encoding="ascii",
+    )
+    (root / "scripts/bootstrap_python.ps1").write_text(
+        "function Initialize-ArtemisPython { return $env:TEST_PYTHON }\n", encoding="ascii"
+    )
+    (root / "scripts/update_installation.py").write_text(
+        "import pathlib, sys\n"
+        "root = pathlib.Path(__file__).parent.parent\n"
+        "with (root / 'checks.txt').open('a') as f: f.write(sys.argv[1] + '\\n')\n"
+        "sys.exit(0)\n",
+        encoding="ascii",
+    )
+    (root / ".env").write_text("keep credentials")
+    index = root / "apps/showcase_ui/dist/frontend/browser/index.html"
+    index.parent.mkdir(parents=True)
+    index.write_text("built frontend")
+    tools = root / "stub-tools"
+    tools.mkdir()
+    for name in ("adb", "scrcpy", "ffmpeg"):
+        (tools / f"{name}.cmd").write_text("@echo off\nexit /b 91\n")
+    result = subprocess.run(
+        [
+            "powershell.exe",
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            str(root / "scripts/start.ps1"),
+            "-PrepareOnly",
+            "-SkipUpdate",
+            "-NoOpen",
+        ],
+        env={
+            **os.environ,
+            "TEST_PYTHON": sys.executable,
+            "PATH": str(tools) + os.pathsep + os.environ["PATH"],
+        },
+        capture_output=True,
+        encoding="utf-8",
+        timeout=15,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert (root / "checks.txt").read_text().splitlines() == ["mcp", "frontend-check"]
+    assert "Launching Artemis" not in result.stdout
+    assert "ADB" not in result.stderr
+    assert (root / ".env").read_text() == "keep credentials"
+
+
+def test_dirty_checkout_refuses_upgrade_before_stopping_processes(tmp_path):
+    if not shutil.which("git"):
+        pytest.skip("Git required")
+    root = tmp_path / "dirty installation"
+    (root / "scripts").mkdir(parents=True)
+    for name in (
+        "upgrade.ps1",
+        "upgrade_processes.ps1",
+        "installation_lock.ps1",
+        "update_installation.py",
+    ):
+        shutil.copyfile(ROOT / "scripts" / name, root / "scripts" / name)
+    (root / ".gitignore").write_text(".venv/\n")
+    source = root / "user.txt"
+    source.write_text("original")
+    git(root, "init", "-b", "main")
+    git(root, "config", "user.name", "Fixture")
+    git(root, "config", "user.email", "fixture@example.test")
+    git(root, "add", ".")
+    git(root, "commit", "-m", "initial")
+    python = make_venv(root)
+    source.write_text("user changes")
+    worker = subprocess.Popen([str(python), "-c", "import time; time.sleep(60)"])
+    try:
+        result = powershell(root / "scripts/upgrade.ps1")
+        assert result.returncode == 1, result.stdout + result.stderr
+        assert "发现本地修改" in result.stdout
+        assert "[STOP]" not in result.stdout
+        assert worker.poll() is None
+        assert source.read_text() == "user changes"
+    finally:
+        # Windows venv redirectors can have a second interpreter process.
+        import psutil
+
+        if worker.poll() is None:
+            children = psutil.Process(worker.pid).children(recursive=True)
+            worker.kill()
+            for child in children:
+                if child.is_running():
+                    child.kill()
+        worker.wait(timeout=5)
diff --git a/update-cn.bat b/update-cn.bat
new file mode 100644
index 0000000..0637499
--- /dev/null
+++ b/update-cn.bat
@@ -0,0 +1,8 @@
+@echo off
+chcp 65001 >nul 2>&1
+setlocal DisableDelayedExpansion
+set "ARTEMIS_LAUNCH_LANG=zh-CN"
+if /i "%~1"=="--help" goto help
+call "%~dp0update.bat" -Mirror China %* & call exit /b %%ERRORLEVEL%%
+:help
+call "%~dp0update.bat" -Mirror China -Help & call exit /b %%ERRORLEVEL%%
diff --git a/update.bat b/update.bat
new file mode 100644
index 0000000..04d9794
--- /dev/null
+++ b/update.bat
@@ -0,0 +1,7 @@
+@echo off
+chcp 65001 >nul 2>&1
+setlocal DisableDelayedExpansion
+if /i "%~1"=="--help" goto help
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0scripts\upgrade.ps1" %* & call exit /b %%ERRORLEVEL%%
+:help
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0scripts\upgrade.ps1" -Help & call exit /b %%ERRORLEVEL%%
diff --git a/uv.lock b/uv.lock
index 4e3a258..71c15c8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -206,7 +206,7 @@ wheels = [
 
 [[package]]
 name = "artemis"
-version = "1.3.3"
+version = "1.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "adbutils" },