coderouter-cli 2.9.3__py3-none-any.whl → 2.9.4__py3-none-any.whl

coderouter/ingress/launcher_routes.py

@@ -40,8 +40,23 @@ from typing import Any
 import httpx
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import HTMLResponse
-from pydantic import BaseModel
-
+from pydantic import BaseModel, Field
+
+from coderouter.launcher_devices import (
+    DeviceSelection,
+    SweepPlan,
+    SweepState,
+    SweepStep,
+    build_auto_sweep_configs,
+    build_sweep_steps,
+    detect_llama_devices,
+    group_by_backend,
+    is_port_free,
+    load_latest_results,
+    render_bench_command,
+    selectable_devices,
+    suggest_tensor_split,
+)
 from coderouter.launcher_speculative import resolve_speculative
 from coderouter.logging import get_logger
 
@@ -512,6 +527,7 @@ def _build_cmd(
     extra_args: str,
     binary: str | None = None,
     spec_tokens: list[str] | None = None,
+    device_args: list[str] | None = None,
 ) -> list[str]:
     """Build the CLI command list for the given backend and options.
 
@@ -525,11 +541,22 @@ def _build_cmd(
     the profile / extra args. They are trusted (the launcher, not the
     caller, produced them) so they bypass the model-override guard even
     though they may contain ``--model-draft``.
+
+    ``device_args`` are pre-resolved llama.cpp device-selection flags
+    (``--device`` / ``--tensor-split``) produced by
+    :meth:`coderouter.launcher_devices.DeviceSelection.to_cli_args`. They
+    are inserted right after the port args and BEFORE ``spec_tokens`` for
+    llama.cpp only. When ``None``/empty the argv is byte-for-byte identical
+    to the pre-feature output (後方互換の核心 — 未選択なら ``--device`` を
+    一切足さない). They are launcher-produced (trusted) so they bypass the
+    model-override guard, and never apply to vllm/mlx (device 非対応)。
     """
     exe = _resolve_binary(backend, binary)
 
     if backend == "llama.cpp":
         cmd: list[str] = [exe, "-m", model_path, "--port", str(port)]
+        if device_args:
+            cmd.extend(device_args)
         if spec_tokens:
             cmd.extend(spec_tokens)
     elif backend == "vllm":
@@ -972,6 +999,11 @@ class StartRequest(BaseModel):
     # or "off" (never emit speculative flags).
     draft_model_path: str | None = None
     mtp_mode: str = "auto"
+    # デバイス選択(llama.cpp のみ)。既定は空 → ``DeviceSelection.to_cli_args``
+    # が ``[]`` を返し、``_build_cmd`` の argv は現行と 1 バイトも変わらない
+    # (既存 Web クライアント/テスト完全不変)。設計 §4.1。
+    device_ids: list[str] = Field(default_factory=list)
+    tensor_split: list[float] = Field(default_factory=list)
 
 
 # ---------------------------------------------------------------------------
@@ -1116,6 +1148,7 @@ async def spawn_process(
     mtp_mode: str = "auto",
     swap_managed: bool = False,
     swap_model: str | None = None,
+    device_args: list[str] | None = None,
 ) -> ManagedProcess:
     """Build argv, spawn the child process, and arm readiness/log tailing.
 
@@ -1164,6 +1197,7 @@ async def spawn_process(
     cmd = _build_cmd(
         backend, model_path, port, options, extra_args,
         binary=configured_binary, spec_tokens=spec_tokens,
+        device_args=device_args,
     )
 
     # Speculative flags qualify for the one-shot startup-crash fallback only
@@ -1178,6 +1212,7 @@ async def spawn_process(
             fallback_cmd = _build_cmd(
                 backend, model_path, port, options, extra_args,
                 binary=configured_binary, spec_tokens=None,
+                device_args=device_args,
             )
         except ValueError:
             # A failure to rebuild the non-spec command simply disables the
@@ -1288,12 +1323,20 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
     _require_launcher_token(request)
     cfg = request.app.state.config
     launcher_cfg = getattr(cfg, "launcher", None)
+    # デバイス選択 → CLI 断片(llama.cpp のみ・選択された場合のみ)。未指定なら
+    # None を渡し、既存の argv と完全一致(後方互換)。
+    device_args: list[str] | None = None
+    if req.backend == "llama.cpp" and req.device_ids:
+        device_args = DeviceSelection(
+            device_ids=list(req.device_ids), tensor_split=list(req.tensor_split)
+        ).to_cli_args()
     try:
         proc = await spawn_process(
             request.app, launcher_cfg,
             name=req.name, backend=req.backend, model_path=req.model_path,
             port=req.port, options=req.options, extra_args=req.extra_args,
             draft_model_path=req.draft_model_path, mtp_mode=req.mtp_mode,
+            device_args=device_args,
         )
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
@@ -1387,6 +1430,408 @@ async def api_suggest(request: Request, model_path: str = "",
     }
 
 
+# ---------------------------------------------------------------------------
+# デバイス検出 + ベンチスイープ(設計 §4.4 / §4.5)
+# ---------------------------------------------------------------------------
+
+
+def _configured_binary_for(launcher_cfg: Any, backend: str) -> str | None:
+    """launcher.backends[backend].binary を取り出す(未設定なら None)。"""
+    if launcher_cfg and getattr(launcher_cfg, "backends", None):
+        bc = launcher_cfg.backends.get(backend)
+        if bc and bc.binary:
+            return bc.binary
+    return None
+
+
+@router.get("/api/launcher/devices")
+async def api_devices(
+    request: Request, backend: str = "llama.cpp", refresh: int = 0
+) -> dict[str, Any]:
+    """``{binary} --list-devices`` を実行してデバイス一覧を返す(設計 §4.4)。
+
+    ``?refresh=1`` で検出キャッシュを無視して再取得する。検出失敗
+    (``ok=false``)時は空リスト + error を返し、UI は手入力へフォールバック
+    する。
+
+    レスポンス:
+      - ``devices``: 検出した全デバイス(表示用。``BLAS: Accelerate`` 等の
+        ``total_mib==0`` デバイスも情報として含む)。
+      - ``suggested_tensor_split``: **バックエンド別**の VRAM 比提案。
+        ``{"CUDA": [0.57, 0.43], "Vulkan": [...]}`` の形。同一バックエンドに
+        selectable(``total_mib>0``)が 2 枚以上あるものだけを含む。実機で
+        CUDA+Vulkan が同一物理 GPU を重複列挙する/BLAS が 0 MiB で並ぶため、
+        跨バックエンド・0 MiB 込みのフラット提案は不正になるのを避ける。
+      - ``auto_configs``: スイープ構成候補(``build_auto_sweep_configs``)を
+        JSON 化。``[{"label", "device_ids", "tensor_split"}]``。構成生成ロジック
+        をサーバ側に一本化し、フロントはこれを使う。
+    """
+    cfg = request.app.state.config
+    launcher_cfg = getattr(cfg, "launcher", None)
+    configured = _configured_binary_for(launcher_cfg, backend)
+    binary = _resolve_binary(backend, configured)
+    # --list-devices はブロッキング subprocess → イベントループを止めない。
+    probe = await asyncio.to_thread(
+        detect_llama_devices, binary, use_cache=(refresh == 0)
+    )
+    # selectable(total_mib>0)だけをバックエンドごとに束ね、2 枚以上のときのみ
+    # tensor-split を提案。跨バックエンド混成・BLAS(0 MiB)は除外される。
+    per_backend_split: dict[str, list[float]] = {}
+    if probe.ok:
+        for backend_prefix, members in group_by_backend(
+            selectable_devices(probe.devices)
+        ).items():
+            if len(members) >= 2:
+                per_backend_split[backend_prefix] = suggest_tensor_split(members)
+    auto_configs = [
+        {
+            "label": label,
+            "device_ids": sel.device_ids,
+            "tensor_split": sel.tensor_split,
+        }
+        for label, sel in build_auto_sweep_configs(probe.devices)
+    ]
+    return {
+        **probe.as_dict(),
+        "suggested_tensor_split": per_backend_split,
+        "auto_configs": auto_configs,
+    }
+
+
+class SweepConfigItem(BaseModel):
+    """スイープの 1 デバイス構成(ラベル + 選択デバイス)。"""
+
+    label: str
+    device_ids: list[str] = Field(default_factory=list)
+    tensor_split: list[float] = Field(default_factory=list)
+
+
+class SweepRequest(BaseModel):
+    """``POST /api/launcher/sweep/start`` のリクエストボディ(設計 §4.4)。"""
+
+    backend: str = "llama.cpp"
+    model_path: str
+    port: int = Field(ge=1024, le=65535)
+    options: dict[str, Any] = Field(default_factory=dict)
+    extra_args: str = ""
+    configs: list[SweepConfigItem] = Field(default_factory=list)
+    bench_command: str | None = None  # None なら launcher.bench 既定
+    runs: int | None = None
+    results_dir: str | None = None
+
+
+class _SweepRunner:
+    """デバイス構成を順に「起動→readiness→外部ベンチ→停止→次」で回す。
+
+    既存の :func:`spawn_process` / :func:`stop_process` / ``proc.ready``
+    (asyncio.Event)を再利用する薄い asyncio ランナー。同時に 1 スイープ
+    のみ(``app.state.launcher_sweep``、swap と同じ排他方針)。ポートは
+    スイープ専用に 1 本を構成間で使い回す(各 step は ``stop_process`` が
+    プロセス終了=ポート解放まで待ってから次へ進む)。
+    """
+
+    def __init__(
+        self,
+        app: Any,
+        launcher_cfg: Any,
+        plan: SweepPlan,
+        *,
+        runs: int | None,
+        readiness_timeout_s: float,
+    ) -> None:
+        self.app = app
+        self.launcher_cfg = launcher_cfg
+        self.plan = plan
+        self.runs = runs
+        self.readiness_timeout_s = readiness_timeout_s
+        self.sweep_id = uuid.uuid4().hex[:8]
+        self.running = False
+        self.current_index = -1
+        self.log_tail: deque[str] = deque(maxlen=1000)
+        self._abort = asyncio.Event()
+        self._task: asyncio.Task[Any] | None = None
+
+    # -- lifecycle -----------------------------------------------------------
+
+    def start(self) -> None:
+        self.running = True
+        self._task = asyncio.create_task(self._run())
+        _background_tasks.add(self._task)
+        self._task.add_done_callback(_background_tasks.discard)
+
+    def abort(self) -> None:
+        self._abort.set()
+
+    def status(self) -> dict[str, Any]:
+        return {
+            "sweep_id": self.sweep_id,
+            "running": self.running,
+            "current_index": self.current_index,
+            "steps": [s.as_dict() for s in self.plan.steps],
+        }
+
+    # -- internals -----------------------------------------------------------
+
+    async def _run(self) -> None:
+        try:
+            for i, step in enumerate(self.plan.steps):
+                self.current_index = i
+                if self._abort.is_set():
+                    step.state = SweepState.ABORTED
+                    self.log_tail.append(f"[sweep] {step.label}: aborted (skipped)")
+                    continue
+                await self._run_one(step)
+        finally:
+            self.current_index = -1
+            self.running = False
+            self.log_tail.append("[sweep] finished")
+
+    async def _await_ready(self, mp: ManagedProcess) -> str:
+        """ready / abort / timeout のいずれかまで待つ。
+
+        ``proc.ready`` の待機に abort を絡めることで、readiness 待ち中でも
+        中断要求に即応する(単に ``wait_for`` するだけだと timeout まで
+        止まらない)。
+        """
+        ready_wait = asyncio.ensure_future(mp.ready.wait())
+        abort_wait = asyncio.ensure_future(self._abort.wait())
+        try:
+            done, _pending = await asyncio.wait(
+                {ready_wait, abort_wait},
+                timeout=self.readiness_timeout_s,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+        finally:
+            for t in (ready_wait, abort_wait):
+                if not t.done():
+                    t.cancel()
+        if abort_wait in done:
+            return "aborted"
+        if ready_wait in done:
+            return "ready"
+        return "timeout"
+
+    async def _safe_stop(self, proc_id: str) -> None:
+        # stop_process は SIGTERM→5s→SIGKILL でポート解放まで待つ。次構成の
+        # 起動前に確実に空ける。失敗しても握りつぶす(スイープを止めない)。
+        with contextlib.suppress(Exception):
+            await stop_process(self.app, proc_id)
+
+    async def _run_one(self, step: SweepStep) -> None:
+        step.state = SweepState.STARTING
+        self.log_tail.append(f"[sweep] {step.label}: starting")
+        device_args = step.selection.to_cli_args() or None
+        try:
+            mp = await spawn_process(
+                self.app,
+                self.launcher_cfg,
+                name=f"sweep-{step.label}",
+                backend=self.plan.backend,
+                model_path=self.plan.model_path,
+                port=self.plan.port,
+                options=self.plan.options,
+                extra_args=self.plan.extra_args,
+                mtp_mode="off",
+                device_args=device_args,
+            )
+        except Exception as exc:  # spawn 自体が失敗 → FAILED(次構成へ継続)
+            step.state = SweepState.FAILED
+            step.error = f"spawn failed: {exc}"
+            self.log_tail.append(f"[sweep] {step.label}: spawn failed: {exc}")
+            return
+
+        outcome = await self._await_ready(mp)
+        if outcome == "aborted":
+            step.state = SweepState.ABORTED
+            self.log_tail.append(f"[sweep] {step.label}: aborted during startup")
+            await self._safe_stop(mp.id)
+            return
+        if outcome == "timeout":
+            step.state = SweepState.FAILED
+            step.error = "readiness timeout"
+            self.log_tail.append(f"[sweep] {step.label}: readiness timeout")
+            await self._safe_stop(mp.id)
+            return
+        if mp.status != "running":
+            step.state = SweepState.FAILED
+            step.error = f"status={mp.status}"
+            self.log_tail.append(
+                f"[sweep] {step.label}: not running (status={mp.status})"
+            )
+            await self._safe_stop(mp.id)
+            return
+
+        if self._abort.is_set():
+            step.state = SweepState.ABORTED
+            self.log_tail.append(f"[sweep] {step.label}: aborted before bench")
+            await self._safe_stop(mp.id)
+            return
+
+        # ── 外部ベンチ実行 ──
+        step.state = SweepState.BENCHING
+        step.started_at = time.time()
+        self.log_tail.append(f"[sweep] {step.label}: benching")
+        argv = render_bench_command(
+            self.plan.bench_cmd_template,
+            port=self.plan.port,
+            config_label=step.label,
+            results_dir=self.plan.results_dir,
+            runs=self.runs,
+        )
+        env = {
+            **os.environ,
+            "OPENAI_BASE_URL": f"http://localhost:{self.plan.port}/v1",
+        }
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *argv,
+                env=env,
+                cwd=self.plan.results_dir or None,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                limit=_LOG_STREAM_LIMIT,
+            )
+        except (FileNotFoundError, OSError) as exc:
+            # bench 起動自体が例外 → FAILED(exit code とは別扱い、設計 §2.4)
+            step.state = SweepState.FAILED
+            step.error = f"bench spawn failed: {exc}"
+            step.ended_at = time.time()
+            self.log_tail.append(f"[sweep] {step.label}: bench spawn failed: {exc}")
+            await self._safe_stop(mp.id)
+            return
+
+        if proc.stdout is not None:
+            async for raw in proc.stdout:
+                self.log_tail.append(raw.decode("utf-8", "replace").rstrip())
+        await proc.wait()
+        step.bench_exit_code = proc.returncode
+        step.ended_at = time.time()
+        self.log_tail.append(
+            f"[sweep] {step.label}: bench exit code {proc.returncode}"
+        )
+        # results 解析(results_dir 指定時のみ)。非ゼロ exit でも比較のため
+        # DONE 扱い(失敗ではなく exit code で判別、設計 §2.4)。
+        if self.plan.results_dir:
+            step.results_path, step.summary = await asyncio.to_thread(
+                load_latest_results, self.plan.results_dir, since=step.started_at
+            )
+        step.state = SweepState.DONE
+        await self._safe_stop(mp.id)
+
+
+def _bench_defaults(launcher_cfg: Any) -> tuple[str, int, str | None, float]:
+    """launcher.bench(あれば)からベンチ既定を取り出す。無ければハードコード。"""
+    default_template = "llmbench run --model local-openai --runs {runs}"
+    default_runs = 5
+    default_results_dir: str | None = None
+    default_readiness = _DEFAULT_READINESS_TIMEOUT_S
+    bench_cfg = getattr(launcher_cfg, "bench", None) if launcher_cfg else None
+    if bench_cfg is not None:
+        default_template = bench_cfg.command_template
+        default_runs = bench_cfg.runs
+        default_results_dir = bench_cfg.results_dir
+        default_readiness = bench_cfg.readiness_timeout_s
+    return default_template, default_runs, default_results_dir, default_readiness
+
+
+@router.post("/api/launcher/sweep/start")
+async def api_sweep_start(req: SweepRequest, request: Request) -> dict[str, Any]:
+    """ベンチスイープを開始する(設計 §4.4 / §4.5)。書き込み系 → token 必須。"""
+    _require_launcher_token(request)
+    app = request.app
+
+    existing = getattr(app.state, "launcher_sweep", None)
+    if existing is not None and existing.running:
+        raise HTTPException(status_code=409, detail="A sweep is already running.")
+    if not req.configs:
+        raise HTTPException(status_code=400, detail="configs must not be empty.")
+
+    cfg = app.state.config
+    launcher_cfg = getattr(cfg, "launcher", None)
+    default_template, default_runs, default_results_dir, default_readiness = (
+        _bench_defaults(launcher_cfg)
+    )
+    bench_command = req.bench_command or default_template
+    runs = req.runs if req.runs is not None else default_runs
+    results_dir = req.results_dir if req.results_dir is not None else default_results_dir
+
+    # ポート競合: registry の使用中ポート照合 + best-effort な空きチェック。
+    reg = _registry_for_app(app)
+    for p in reg.all():
+        if p.port == req.port and p.status in ("running", "loading", "starting"):
+            raise HTTPException(
+                status_code=400,
+                detail=f"Port {req.port} is in use by process {p.name!r}.",
+            )
+    if not is_port_free(req.port):
+        raise HTTPException(
+            status_code=400, detail=f"Port {req.port} is not free."
+        )
+
+    labeled = [
+        (
+            item.label,
+            DeviceSelection(
+                device_ids=list(item.device_ids),
+                tensor_split=list(item.tensor_split),
+            ),
+        )
+        for item in req.configs
+    ]
+    steps = build_sweep_steps(labeled)
+    plan = SweepPlan(
+        steps=steps,
+        model_path=req.model_path,
+        backend=req.backend,
+        port=req.port,
+        bench_cmd_template=bench_command,
+        results_dir=results_dir,
+        options=req.options,
+        extra_args=req.extra_args,
+    )
+    runner = _SweepRunner(
+        app, launcher_cfg, plan, runs=runs, readiness_timeout_s=default_readiness
+    )
+    app.state.launcher_sweep = runner
+    runner.start()
+    return {"sweep_id": runner.sweep_id, "steps": [s.as_dict() for s in steps]}
+
+
+@router.get("/api/launcher/sweep/status")
+async def api_sweep_status(request: Request) -> dict[str, Any]:
+    """現在(または直近)のスイープ状態を返す。読み取り系 → 認証なし。"""
+    runner = getattr(request.app.state, "launcher_sweep", None)
+    if runner is None:
+        return {
+            "sweep_id": None,
+            "running": False,
+            "current_index": -1,
+            "steps": [],
+        }
+    return runner.status()
+
+
+@router.post("/api/launcher/sweep/abort")
+async def api_sweep_abort(request: Request) -> dict[str, Any]:
+    """進行中スイープに中断要求を出す(設計 §4.4)。書き込み系 → token 必須。"""
+    _require_launcher_token(request)
+    runner = getattr(request.app.state, "launcher_sweep", None)
+    if runner is None:
+        raise HTTPException(status_code=404, detail="No sweep to abort.")
+    runner.abort()
+    return {"aborted": True}
+
+
+@router.get("/api/launcher/sweep/logs")
+async def api_sweep_logs(request: Request, n: int = 200) -> dict[str, Any]:
+    """スイープの進行ログ末尾 N 行。読み取り系 → 認証なし。"""
+    runner = getattr(request.app.state, "launcher_sweep", None)
+    if runner is None:
+        return {"logs": [], "total": 0}
+    tail = list(runner.log_tail)
+    return {"logs": tail[-n:], "total": len(tail)}
+
+
 # ---------------------------------------------------------------------------
 # HTML UI
 # ---------------------------------------------------------------------------
@@ -1525,6 +1970,22 @@ _LAUNCHER_HTML = r"""<!doctype html>
         <input id="f-extra" type="text" placeholder="-ngl 99 --threads 8" />
       </div>
 
+      <!-- デバイス選択 (llama.cpp のみ) -->
+      <div id="device-block" class="hidden">
+        <div class="flex items-center justify-between mb-1">
+          <label class="block text-xs text-slate-400">デバイス (llama.cpp)</label>
+          <button onclick="fetchDevices(true)" class="btn-sm btn-slate">🔍 検出</button>
+        </div>
+        <div id="device-list" class="text-xs text-slate-400 space-y-1 bg-slate-800/40 rounded p-2">
+          <span class="text-slate-600">「🔍 検出」で --list-devices を実行</span>
+        </div>
+        <div id="tsplit-row" class="mt-2 hidden">
+          <label class="block text-xs text-slate-400 mb-1">tensor-split (複数選択時・自動提案は上書き可)</label>
+          <input id="f-tsplit" type="text" placeholder="0.57,0.43" oninput="markTsplitManual()" />
+          <div id="tsplit-note" class="mt-1 text-xs text-yellow-400 hidden"></div>
+        </div>
+      </div>
+
       <button id="btn-launch" onclick="launchProcess()" class="btn-primary w-full mt-1">
         ▶ 起動
       </button>
@@ -1555,6 +2016,67 @@ _LAUNCHER_HTML = r"""<!doctype html>
     </div>
   </section>
 
+  <!-- Row 2.5: Bench sweep -->
+  <section class="bg-slate-900/60 border border-slate-800 rounded-lg p-4">
+    <div class="flex items-center justify-between mb-3">
+      <h2 class="text-sm font-semibold uppercase tracking-wider text-slate-400">📊 Bench Sweep</h2>
+      <div class="flex gap-2">
+        <button id="sweep-start" onclick="startSweep()" class="btn-sm btn-indigo">▶ 開始</button>
+        <button id="sweep-abort" onclick="abortSweep()" class="btn-sm btn-red">■ 中断</button>
+      </div>
+    </div>
+    <p class="text-xs text-slate-500 mb-2">
+      起動フォームの「モデルパス」を使用。各構成を 起動→readiness→ベンチ→停止 で順に回します。
+      構成は「デバイス検出」後に候補が自動生成されます (単一デバイス環境では tensor-split 構成は出ません)。
+    </p>
+    <div class="grid grid-cols-1 md:grid-cols-2 gap-3">
+      <div>
+        <label class="block text-xs text-slate-400 mb-1">構成候補</label>
+        <div id="sweep-configs" class="text-xs text-slate-400 space-y-1 bg-slate-800/40 rounded p-2 max-h-40 overflow-y-auto">
+          <span class="text-slate-600">先に「🔍 検出」でデバイスを取得してください</span>
+        </div>
+      </div>
+      <div class="space-y-2">
+        <div>
+          <label class="block text-xs text-slate-400 mb-1">ポート (スイープ専用・構成間で共用)</label>
+          <input id="sweep-port" type="number" value="8090" min="1024" max="65535" />
+        </div>
+        <div>
+          <label class="block text-xs text-slate-400 mb-1">ベンチコマンド ({port} {config} {base_url} {results_dir} {runs} を置換)</label>
+          <input id="sweep-cmd" type="text" placeholder="llmbench run --model local-openai --runs {runs}" />
+        </div>
+        <div class="grid grid-cols-2 gap-2">
+          <div>
+            <label class="block text-xs text-slate-400 mb-1">runs</label>
+            <input id="sweep-runs" type="number" value="5" min="1" max="1000" />
+          </div>
+          <div>
+            <label class="block text-xs text-slate-400 mb-1">results_dir (任意)</label>
+            <input id="sweep-results" type="text" placeholder="results/" />
+          </div>
+        </div>
+      </div>
+    </div>
+    <div id="sweep-err" class="text-xs text-red-400 mt-2 hidden"></div>
+    <div class="overflow-x-auto mt-3">
+      <table class="w-full text-sm tabnum">
+        <thead class="text-slate-500 text-left">
+          <tr>
+            <th class="pb-2 font-medium">CONFIG</th>
+            <th class="pb-2 font-medium">DEVICES</th>
+            <th class="pb-2 font-medium">STATE</th>
+            <th class="pb-2 font-medium text-right">EXIT</th>
+            <th class="pb-2 font-medium text-right">tok/s</th>
+            <th class="pb-2 font-medium text-right">ttft(ms)</th>
+          </tr>
+        </thead>
+        <tbody id="sweep-table" class="divide-y divide-slate-800">
+          <tr><td colspan="6" class="py-3 text-slate-500 text-xs">スイープ未実行</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </section>
+
   <!-- Row 3: Log viewer (hidden until a process is selected) -->
   <section id="log-panel" class="bg-slate-900/60 border border-slate-800 rounded-lg p-4 hidden">
     <div class="flex items-center justify-between mb-2">
@@ -1800,6 +2322,7 @@ _LAUNCHER_HTML = r"""<!doctype html>
   window.onBackendChange = () => {
     populateProfileSelect();
     renderBinaryHint();
+    updateDeviceBlock();
   };
 
   // renderProfileArgs は下で const 宣言されるため、宣言前参照(TDZ)を避けて
@@ -1830,6 +2353,263 @@ _LAUNCHER_HTML = r"""<!doctype html>
     return p ? p.args : {};
   };
 
+  // ── Devices (llama.cpp) ────────────────────────────────────────────────────
+
+  let _devices = [];        // [{id,name,total_mib,free_mib,total_gb,free_gb}]
+  let _deviceSel = {};      // id -> checked
+  let _deviceOk = false;
+  let _autoConfigs = [];    // サーバ生成のスイープ構成候補
+
+  const isLlama = () => document.getElementById("f-backend").value === "llama.cpp";
+
+  // デバイス id → バックエンド接頭辞(末尾数字を除く)。launcher_devices の
+  // backend_of と同じ規則。"CUDA0"→"CUDA" / "Vulkan2"→"Vulkan" / "MTL0"→"MTL"。
+  const backendOf = (id) => id.replace(/\d+$/, "");
+
+  const updateDeviceBlock = () => {
+    const blk = document.getElementById("device-block");
+    if (isLlama()) blk.classList.remove("hidden");
+    else blk.classList.add("hidden");
+  };
+
+  // VRAM (total) 比の tensor-split を末尾で辻褄合わせして 1.0 にする。
+  const splitByTotal = (devs) => {
+    const total = devs.reduce((a, d) => a + d.total_mib, 0);
+    if (!(total > 0) || devs.length < 2) return [];
+    const s = devs.map(d => Math.round((d.total_mib / total) * 100) / 100);
+    const head = s.slice(0, -1).reduce((a, b) => a + b, 0);
+    s[s.length - 1] = Math.round((1 - head) * 100) / 100;
+    return s;
+  };
+
+  window.fetchDevices = async (force) => {
+    if (!isLlama()) { statusMsg("デバイス選択は llama.cpp のみ"); return; }
+    const backend = document.getElementById("f-backend").value;
+    const url = "/api/launcher/devices?backend=" + encodeURIComponent(backend)
+              + (force ? "&refresh=1" : "");
+    const box = document.getElementById("device-list");
+    box.innerHTML = '<span class="text-slate-600">検出中…</span>';
+    try {
+      const r = await fetch(url);
+      const d = await r.json();
+      _deviceOk = !!d.ok;
+      _devices = d.devices || [];
+      _autoConfigs = d.auto_configs || [];
+      _deviceSel = {};
+      renderDevices(d);
+      buildSweepConfigs();
+    } catch (e) {
+      box.innerHTML = '<span class="text-red-400">検出失敗: ' + esc(e.message) + '</span>';
+    }
+  };
+
+  const renderDevices = (d) => {
+    const box = document.getElementById("device-list");
+    if (!d.ok) {
+      // 検出失敗 → カンマ区切り手入力へフォールバック
+      box.innerHTML =
+        '<div class="text-yellow-400 mb-1">検出失敗: ' + esc(d.error || "不明")
+        + ' — 手入力してください</div>'
+        + '<input id="device-fallback" type="text" placeholder="CUDA0,CUDA1 (カンマ区切り)" />';
+      document.getElementById("tsplit-row").classList.add("hidden");
+      return;
+    }
+    if (!_devices.length) {
+      box.innerHTML = '<span class="text-slate-600">デバイスなし</span>';
+      document.getElementById("tsplit-row").classList.add("hidden");
+      return;
+    }
+    // total_mib==0 (BLAS: Accelerate 等) は GPU オフロード先にできないので
+    // チェックボックスを無効化(表示は残す)。
+    box.innerHTML = _devices.map(dev => {
+      const disabled = !(dev.total_mib > 0);
+      return `<label class="flex items-center gap-2 ${disabled ? "opacity-50" : "cursor-pointer"}">
+        <input type="checkbox" style="width:auto" data-devid="${esc(dev.id)}" ${disabled ? "disabled" : ""} onchange="onDeviceToggle()" />
+        <span class="font-mono text-slate-300">${esc(dev.id)}</span>
+        <span class="text-slate-500 truncate">${esc(dev.name)}</span>
+        <span class="text-slate-500 tabnum ml-auto shrink-0">${disabled ? "— (0 MiB)" : dev.free_gb + "/" + dev.total_gb + " GB"}</span>
+      </label>`;
+    }).join("");
+    updateTsplitVisibility();
+  };
+
+  window.onDeviceToggle = () => {
+    _deviceSel = {};
+    document.querySelectorAll('#device-list input[data-devid]').forEach(cb => {
+      _deviceSel[cb.getAttribute("data-devid")] = cb.checked;
+    });
+    updateTsplitVisibility();
+  };
+
+  const selectedDeviceIds = () => {
+    if (_deviceOk) return _devices.map(d => d.id).filter(id => _deviceSel[id]);
+    const fb = document.getElementById("device-fallback");
+    if (!fb) return [];
+    return fb.value.split(",").map(s => s.trim()).filter(Boolean);
+  };
+
+  // 単一デバイス環境 (総数<=1) or 選択<=1 では tensor-split 欄を隠す (§8.5)。
+  // tensor-split の自動提案はバックエンド単位。跨バックエンド選択時は提案せず
+  // その旨を表示する(手入力は可)。
+  const updateTsplitVisibility = () => {
+    const ids = selectedDeviceIds();
+    const row = document.getElementById("tsplit-row");
+    const note = document.getElementById("tsplit-note");
+    if (_devices.length <= 1 || ids.length <= 1) { row.classList.add("hidden"); return; }
+    row.classList.remove("hidden");
+    const el = document.getElementById("f-tsplit");
+    const backends = new Set(ids.map(backendOf));
+    if (backends.size > 1) {
+      // 跨バックエンド → 自動提案しない(自動値は消す。手入力は保持)。
+      note.textContent = "バックエンド跨ぎのため tensor-split 自動提案なし(手入力可)";
+      note.classList.remove("hidden");
+      if (el.dataset.auto === "1") { el.value = ""; }
+      return;
+    }
+    note.classList.add("hidden");
+    // 同一バックエンド。ユーザーが手入力していれば尊重 (dataset.auto で判別)。
+    if (!el.value.trim() || el.dataset.auto === "1") {
+      const sel = _devices.filter(d => _deviceSel[d.id]);
+      el.value = splitByTotal(sel).join(",");
+      el.dataset.auto = "1";
+    }
+  };
+
+  window.markTsplitManual = () => {
+    document.getElementById("f-tsplit").dataset.auto = "0";
+  };
+
+  // ── Bench sweep ────────────────────────────────────────────────────────────
+
+  let _sweepConfigs = [];   // [{label, device_ids, tensor_split, checked}]
+  let _sweepPollTimer = null;
+
+  // スイープ構成候補はサーバの auto_configs(build_auto_sweep_configs)を使う。
+  // 0 MiB 除外・バックエンド単位のグループ化・跨バックエンド混成の除外は
+  // すべてサーバ側ロジックに一本化されている。
+  const buildSweepConfigs = () => {
+    _sweepConfigs = (_autoConfigs || []).map(c => ({
+      label: c.label,
+      device_ids: c.device_ids || [],
+      tensor_split: c.tensor_split || [],
+      checked: true,
+    }));
+    renderSweepConfigs();
+  };
+
+  const renderSweepConfigs = () => {
+    const box = document.getElementById("sweep-configs");
+    if (!_sweepConfigs.length) {
+      box.innerHTML = '<span class="text-slate-600">先に「🔍 検出」でデバイスを取得してください</span>';
+      return;
+    }
+    box.innerHTML = _sweepConfigs.map((c, i) =>
+      `<label class="flex items-center gap-2 cursor-pointer">
+        <input type="checkbox" style="width:auto" data-cfg="${i}" ${c.checked ? "checked" : ""} onchange="onSweepCfgToggle()" />
+        <span class="text-slate-300">${esc(c.label)}</span>
+        <span class="text-slate-500 font-mono ml-auto">${esc(c.device_ids.join(","))}${c.tensor_split.length ? " · " + c.tensor_split.join(",") : ""}</span>
+      </label>`
+    ).join("");
+  };
+
+  window.onSweepCfgToggle = () => {
+    document.querySelectorAll('#sweep-configs input[data-cfg]').forEach(cb => {
+      _sweepConfigs[parseInt(cb.getAttribute("data-cfg"))].checked = cb.checked;
+    });
+  };
+
+  const showSweepErr = (msg) => {
+    const el = document.getElementById("sweep-err");
+    if (msg) { el.textContent = msg; el.classList.remove("hidden"); }
+    else { el.textContent = ""; el.classList.add("hidden"); }
+  };
+
+  window.startSweep = async () => {
+    showSweepErr("");
+    const model = document.getElementById("f-model").value.trim();
+    if (!model) { showSweepErr("起動フォームでモデルパスを選択してください"); return; }
+    const configs = _sweepConfigs.filter(c => c.checked)
+      .map(c => ({label: c.label, device_ids: c.device_ids, tensor_split: c.tensor_split}));
+    if (!configs.length) { showSweepErr("構成を 1 つ以上選択してください"); return; }
+    const port = parseInt(document.getElementById("sweep-port").value);
+    const cmd = document.getElementById("sweep-cmd").value.trim();
+    const runs = parseInt(document.getElementById("sweep-runs").value);
+    const results = document.getElementById("sweep-results").value.trim();
+    const body = {
+      backend: "llama.cpp", model_path: model, port, configs,
+      bench_command: cmd || null,
+      runs: isNaN(runs) ? null : runs,
+      results_dir: results || null,
+    };
+    try {
+      const r = await fetch("/api/launcher/sweep/start", {
+        method: "POST", headers: authHeaders({"Content-Type": "application/json"}),
+        body: JSON.stringify(body),
+      });
+      const d = await r.json();
+      if (!r.ok) { showSweepErr(d.detail || "スイープ開始失敗"); return; }
+      statusMsg("スイープ開始: " + d.sweep_id);
+      startSweepPolling();
+    } catch (e) { showSweepErr(e.message); }
+  };
+
+  window.abortSweep = async () => {
+    try {
+      const r = await fetch("/api/launcher/sweep/abort", {method: "POST", headers: authHeaders()});
+      if (r.ok) statusMsg("スイープ中断要求"); else statusMsg("中断対象なし", false);
+    } catch (e) { showSweepErr(e.message); }
+  };
+
+  const startSweepPolling = () => {
+    if (_sweepPollTimer) return;
+    _sweepPollTimer = setInterval(pollSweep, POLL_MS);
+    pollSweep();
+  };
+
+  const pollSweep = async () => {
+    try {
+      const r = await fetch("/api/launcher/sweep/status");
+      const d = await r.json();
+      renderSweepSteps(d.steps || []);
+      if (d.running && !_sweepPollTimer) {
+        // リロードでスイープ進行中を検知 → ポーリング再開。
+        _sweepPollTimer = setInterval(pollSweep, POLL_MS);
+      } else if (!d.running && _sweepPollTimer) {
+        clearInterval(_sweepPollTimer); _sweepPollTimer = null;
+      }
+    } catch (_) {}
+  };
+
+  const sweepStateColor = (s) => ({
+    pending: "text-slate-500", starting: "text-yellow-400",
+    benching: "text-indigo-300", done: "text-green-400",
+    failed: "text-red-400", aborted: "text-slate-400"
+  }[s] || "text-slate-400");
+
+  const renderSweepSteps = (steps) => {
+    const tb = document.getElementById("sweep-table");
+    if (!steps.length) {
+      tb.innerHTML = '<tr><td colspan="6" class="py-3 text-slate-500 text-xs">スイープ未実行</td></tr>';
+      return;
+    }
+    tb.innerHTML = steps.map(s => {
+      const sm = s.summary || {};
+      const tok = sm.tokens_per_sec != null ? sm.tokens_per_sec : "—";
+      const ttft = sm.ttft_ms != null ? sm.ttft_ms : "—";
+      const dev = (s.device_ids || []).join(",")
+        + ((s.tensor_split || []).length ? " · " + s.tensor_split.join(",") : "");
+      const exit = s.bench_exit_code != null ? s.bench_exit_code : "—";
+      return `<tr>
+        <td class="py-2 pr-3">${esc(s.label)}</td>
+        <td class="py-2 pr-3 font-mono text-slate-400">${esc(dev)}</td>
+        <td class="py-2 pr-3 ${sweepStateColor(s.state)}">${esc(s.state)}</td>
+        <td class="py-2 pr-3 text-right">${esc(String(exit))}</td>
+        <td class="py-2 pr-3 text-right">${esc(String(tok))}</td>
+        <td class="py-2 pr-3 text-right">${esc(String(ttft))}</td>
+      </tr>`;
+    }).join("");
+  };
+
   // ── Launch ───────────────────────────────────────────────────────────────
 
   window.launchProcess = async () => {
@@ -1846,6 +2626,16 @@ _LAUNCHER_HTML = r"""<!doctype html>
     if (!model) { showLaunchErr("モデルパスを入力してください"); return; }
     if (!port || port < 1024 || port > 65535) { showLaunchErr("ポートは 1024-65535"); return; }
 
+    // デバイス選択 (llama.cpp のみ)。未選択なら空 → サーバ側で --device 不付与。
+    let deviceIds = [], tensorSplit = [];
+    if (backend === "llama.cpp") {
+      deviceIds = selectedDeviceIds();
+      const ts = document.getElementById("f-tsplit").value.trim();
+      if (ts && deviceIds.length > 1) {
+        tensorSplit = ts.split(",").map(x => parseFloat(x)).filter(x => !isNaN(x));
+      }
+    }
+
     const btn = document.getElementById("btn-launch");
     btn.disabled = true;
     btn.textContent = "起動中…";
@@ -1856,7 +2646,8 @@ _LAUNCHER_HTML = r"""<!doctype html>
         headers: authHeaders({"Content-Type": "application/json"}),
         body: JSON.stringify({name, backend, model_path: model, port,
                               options: selectedProfileArgs(), extra_args: extra,
-                              draft_model_path: draft || null, mtp_mode: mtp}),
+                              draft_model_path: draft || null, mtp_mode: mtp,
+                              device_ids: deviceIds, tensor_split: tensorSplit}),
       });
       const d = await res.json();
       if (!res.ok) { showLaunchErr(d.detail || "起動失敗"); return; }
@@ -1986,7 +2777,9 @@ _LAUNCHER_HTML = r"""<!doctype html>
   // ── Init + polling ───────────────────────────────────────────────────────
 
   const init = async () => {
+    updateDeviceBlock();
     await Promise.all([fetchModels(), fetchProfiles(), fetchBackends(), fetchProcesses()]);
+    pollSweep();  // 既存スイープがあれば表示 (running なら以後のポーリングを継続)
   };
 
   const poll = async () => {