@ait-co/devtools 0.1.122 → 0.1.124

package/dist/debug-server-IVaJ9vHH.js

@@ -1,4278 +0,0 @@
-#!/usr/bin/env node
-import { $ as buildDeepLinkAttachUrl, A as isDebugToolName, B as readServerLock, C as getDiagnostics, D as getSdkCallHistory, E as getOperationalEnvironment, F as listPages, G as logWarn, H as isRelayEnv, I as measureSafeArea, J as pageCrashError, K as classifyToolError, L as takeScreenshot, M as listConsoleMessages, N as listExceptions, O as getToolAvailability, P as listNetworkRequests, Q as tierRejectionError, R as takeSnapshot, S as filterToolsByEnvironment, T as getMockState, U as logError, V as deriveEnvironment, W as logInfo, X as relayDisconnectError, Y as pageMissingError, Z as sdkAbsentError, _ as BOOTSTRAP_TOOL_NAMES, b as callSdk, et as buildLauncherAttachUrl, f as generateAttachToken, g as startTunnelHealthProbe, h as startQuickTunnel, j as isToolAvailableIn, k as isAitToolName, l as prepareAttach, m as printAttachBanner, nt as startParentWatcher, p as makeTunnelStatus, q as mcpError, s as isSandboxPageFresh, t as RELAY_SANDBOX_STALE_PAGE_MS, tt as startMaxAgeWatchdog, u as renderAndMaybeWait, v as DEBUG_TOOL_DEFINITIONS, w as getDomDocument, x as evaluate, y as InMemoryDiagnosticsCollector, z as acquireLock } from "./attach-orchestrator-BYMCSPjf.js";
-import { i as generateTotp, n as assertRelayAuthConfigured, r as buildRelayVerifyAuth } from "./totp-0bvlo9Yb.js";
-import { n as injectGlobals, t as injectDebugIndicator } from "./cell-SKNUQTr8.js";
-import { t as startQrHttpServer } from "./qr-http-server-gHBd-z7T.js";
-import { n as loadRelaySecretReadOnly } from "./relay-secret-store-CtK1eqoV.js";
-import { createRequire } from "node:module";
-import { accessSync, existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { platform } from "node:os";
-import * as path$1 from "node:path";
-import path, { isAbsolute, resolve } from "node:path";
-import { parseArgs } from "node:util";
-import * as fs from "node:fs/promises";
-import { glob, mkdir, writeFile } from "node:fs/promises";
-import { EventEmitter } from "node:events";
-import { WebSocket, WebSocketServer } from "ws";
-import { createServer } from "node:http";
-import { spawn } from "node:child_process";
-import net from "node:net";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
-//#region src/in-app/gate.ts
-/**
-* The host suffix the Toss app uses to serve dogfood / private mini-apps.
-*
-* A `intoss-private://` (dogfood) entry maps to a host such as
-* `aitc-sdk-example.private-apps.tossmini.com`. A production `intoss://`
-* entry is served from `*.apps.tossmini.com` — the `.private-apps.` segment
-* is absent. Confirmed live over CDP for mini-app 31146; the exact production
-* host is to be re-confirmed once 31146 passes review (spec open question 2).
-*/
-const PRIVATE_APPS_HOST_SUFFIX = ".private-apps.tossmini.com";
-/**
-* The host suffix Cloudflare quick-tunnels serve from — the env 2 (PWA) entry.
-* See {@link isTrycloudflareHost} for why this host kind bypasses Layer B1.
-*/
-const TRYCLOUDFLARE_HOST_SUFFIX = ".trycloudflare.com";
-/**
-* Returns whether `hostname` is a `*.private-apps.tossmini.com` subdomain —
-* the host the Toss app reserves for dogfood / private mini-app entries.
-*
-* The match is an exact suffix check, not a substring `.includes()`: a
-* substring test would also accept an attacker-controlled host like
-* `private-apps.tossmini.com.evil.example`, which ends in `.example`, not in
-* `.tossmini.com`. Requiring the string to END with the suffix closes that.
-* The leading `.` in the suffix also forces a real subdomain label, so a
-* bare `private-apps.tossmini.com` (no mini-app subdomain) does not match.
-*/
-function isPrivateAppsHost(hostname) {
-	return hostname.endsWith(PRIVATE_APPS_HOST_SUFFIX);
-}
-/**
-* The host suffix Cloudflare quick-tunnels use — the env 2 (PWA) entry.
-*
-* Env 2 serves the local Vite dev server through a `*.trycloudflare.com` quick
-* tunnel (`src/unplugin/tunnel.ts`). It has no Toss app, no `intoss-private://`
-* scheme, and — critically — no production runtime: the SDK is the devtools
-* mock, and the page is the developer's own dev build. The Layer B1 safety net
-* (which stops a dogfood build that lands on a Toss *production* host from
-* attaching) has nothing to protect against here, because env 2 has no
-* production host. So a trycloudflare host is allowed past B1 — but ONLY past
-* B1: the remaining layers (C1 opt-in, C2 relay, C3 TOTP) still apply, so a
-* leaked tunnel URL is still blocked by TOTP exactly as on the Toss path.
-*
-* The match is the same exact-suffix `endsWith` check as
-* {@link isPrivateAppsHost} — never a substring `.includes()`, which would
-* accept an attacker-controlled `evil.trycloudflare.com.example.com`. The
-* leading `.` forces a real subdomain label, so a bare `trycloudflare.com`
-* (no tunnel subdomain) does not match.
-*/
-function isTrycloudflareHost(hostname) {
-	return hostname.endsWith(TRYCLOUDFLARE_HOST_SUFFIX);
-}
-/**
-* Returns true when the hostname is a localhost/loopback address.
-* Allowed: `localhost`, `127.x.x.x` (full RFC 5735 loopback block), `[::1]`,
-* `0.0.0.0`, `*.localhost`.
-*
-* Security note: `hostname.startsWith('127.')` is intentionally NOT used —
-* that pattern would accept `127.evil.com`, which starts with "127." but is an
-* attacker-controlled hostname, not a loopback address. Instead, the 127/8
-* loopback block is matched with a strict numeric-quad regex so only valid
-* dotted-decimal IPv4 in the 127.x.x.x range pass (#665 작업 A fix).
-*/
-function isLocalhostHost(hostname) {
-	if (hostname === "localhost" || hostname === "0.0.0.0") return true;
-	if (hostname === "[::1]") return true;
-	if (/^127\.\d+\.\d+\.\d+$/.test(hostname)) return true;
-	if (hostname.endsWith(".localhost")) return true;
-	return false;
-}
-/**
-* Positive-allowlist kill-switch (#665): returns true when the hostname is a
-* known debug-allowed host. The debug surface is ONLY active on:
-*   - localhost / loopback (env 1 desktop dev)
-*   - *.trycloudflare.com (env 2 PWA tunnel)
-*   - *.private-apps.tossmini.com (env 3 dog-food)
-*
-* Any other host (including apps.tossmini.com — the former env 4 LIVE host)
-* is silently blocked. This is a positive allowlist — unlisted hosts never
-* had debug surface regardless, but this function makes it explicit and
-* auditable in a single place.
-*
-* SECRET-HANDLING: the hostname value MUST NOT be logged or included in any
-* error reason string — only benign labels ('host not in allowlist') are safe.
-*/
-function isDebugAllowedHost(hostname) {
-	return isLocalhostHost(hostname) || isTrycloudflareHost(hostname) || isPrivateAppsHost(hostname);
-}
-//#endregion
-//#region src/test-runner/discover.ts
-/**
-* Test-file discovery shared by the `devtools-test` CLI and the `run_tests`
-* MCP tool, so both expand glob patterns with identical semantics.
-*
-* Uses Node's built-in `fs/promises` `glob` (Node 22+) — no extra dependency,
-* which keeps the MCP daemon install graph lean (a plain glob lib would land in
-* the `npx … devtools-mcp` path for no benefit).
-*
-* Pure Node IO only (`node:fs/promises` + `node:path`) — react-free, so it is
-* safe to import from the MCP daemon graph.
-*/
-/**
-* Expands `patterns` (globs or plain paths) into a sorted, de-duplicated list of
-* ABSOLUTE test file paths, resolved relative to `cwd`.
-*
-* A plain (non-glob) path passes through when it matches a real file; a glob
-* expands against `cwd`. Absolute matches are kept as-is; relative matches are
-* resolved against `cwd`. `bundleTestFile` requires an absolute path, so the
-* absolute output feeds it directly.
-*
-* @param patterns Glob patterns or file paths (e.g. `['src/**\/*.ait.test.ts']`).
-* @param cwd      Base directory for relative patterns/results.
-* @returns Sorted, de-duplicated absolute file paths. Empty when nothing matches.
-*/
-async function discoverTestFiles(patterns, cwd) {
-	const out = /* @__PURE__ */ new Set();
-	for await (const match of glob(patterns, { cwd })) out.add(isAbsolute(match) ? match : resolve(cwd, match));
-	return [...out].sort();
-}
-//#endregion
-//#region src/test-runner/relay-factory.ts
-/**
-* Builds a {@link RelayConnectionFactory} that opens a standalone env3 relay
-* connection.
-*
-* `open()` performs the full attach lifecycle and BLOCKS for tens of seconds (up
-* to `timeoutMs`) while a human scans the rendered QR with their phone — there
-* is no way around the manual scan for env3. It resolves with the live
-* `CdpConnection` once a matching page attaches; `close()` tears the relay
-* family down.
-*
-* The factory holds the booted relay family in a closure so `close()` can stop
-* it. A second `open()` on the same factory boots a fresh family (the previous
-* one should have been `close()`d first).
-*/
-function createRelayConnectionFactory(opts) {
-	const projectRoot = opts.projectRoot ?? process.cwd();
-	const timeoutMs = opts.timeoutMs ?? 6e5;
-	const headless = opts.headless === true;
-	let family;
-	let qrServer;
-	return {
-		async open() {
-			const { prepareAttach, renderAndMaybeWait, mintAttachUrl } = await import("./attach-orchestrator-LOjvsE9R.js");
-			const { injectDebugIndicator, injectGlobals } = await import("./cell-Bfbke0cT.js");
-			const { loadRelaySecretReadOnly } = await import("./relay-secret-store-BIM_0y18.js");
-			const { bootRelayFamily, buildRelayVerifyAuth } = await Promise.resolve().then(() => debug_server_exports);
-			await loadRelaySecretReadOnly({ projectRoot });
-			const booted = await bootRelayFamily({ verifyAuth: buildRelayVerifyAuth() });
-			family = booted;
-			let lastAttachParts;
-			const attachDeps = {
-				getTunnelStatus: booted.getTunnelStatus ?? (() => ({
-					up: false,
-					wssUrl: null
-				})),
-				getTotpSecret: () => process.env.AIT_DEBUG_TOTP_SECRET,
-				qrHttpServer: void 0,
-				onAttachUrlBuilt: void 0,
-				canOpenBrowser: () => !headless
-			};
-			try {
-				const { startQrHttpServer } = await import("./qr-http-server-BpcDt-cp.js");
-				const getDashboardState = () => ({
-					tunnel: attachDeps.getTunnelStatus(),
-					pages: null,
-					attachUrl: lastAttachParts ? mintAttachUrl(attachDeps, lastAttachParts) : null,
-					mode: "relay-dev"
-				});
-				qrServer = await startQrHttpServer(getDashboardState);
-				attachDeps.qrHttpServer = qrServer;
-				attachDeps.onAttachUrlBuilt = (parts) => {
-					lastAttachParts = parts;
-					qrServer?.notifyStateChange();
-				};
-				process.stderr.write(`devtools-test: QR dashboard: http://127.0.0.1:${qrServer.port}/\n`);
-			} catch {}
-			const prep = await prepareAttach(attachDeps, "relay-dev", { scheme_url: opts.schemeUrl }, booted.connection);
-			if (!prep.ok) {
-				booted.stop();
-				family = void 0;
-				throw new Error("createRelayConnectionFactory: attach preparation failed — check the scheme_url and that the relay tunnel is up");
-			}
-			const waitResult = await renderAndMaybeWait(attachDeps, prep, true, timeoutMs, booted.connection);
-			if (waitResult.isError) {
-				booted.stop();
-				family = void 0;
-				const timeoutSec = Math.round(timeoutMs / 1e3);
-				throw new Error(`createRelayConnectionFactory: attach timed out after ${timeoutSec}s — phone did not scan the QR within the timeout`);
-			}
-			const qrChunks = waitResult.content.filter((c) => c.type === "text").map((c) => c.text);
-			opts.onQrContent(qrChunks);
-			await injectDebugIndicator(booted.connection);
-			if (opts.cell !== void 0) await injectGlobals(booted.connection, { __AIT_CELL__: opts.cell });
-			await booted.connection.enableDomains();
-			return booted.connection;
-		},
-		async close(_connection) {
-			family?.stop();
-			family = void 0;
-			await qrServer?.close();
-			qrServer = void 0;
-		}
-	};
-}
-//#endregion
-//#region src/test-runner/bundle.ts
-/**
-* esbuild-based bundler for user test files.
-*
-* Bundles a single test file into a self-contained IIFE string that can be
-* injected into a WebView via `Runtime.evaluate`. The bundle includes the
-* test runtime (`runtime.ts`), which provides `describe/it/test/expect` and
-* the `runTestModule(factory)` entry point.
-*
-* ## How the wiring works
-*
-* The bundle exposes two exports on `globalThis.__testBundle`:
-*   - `runTestModule` — the runtime's entry function.
-*   - `__userFactory`  — an async function whose body is the user's top-level
-*     test registration code (describe/it/test calls).
-*
-* The Node-side RPC (`rpc.ts`) calls:
-*   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
-*
-* `runTestModule` then installs `describe/it/test/expect` as globals, invokes
-* the factory (which registers all tests), runs them, and returns a `RunReport`.
-*
-* ## Why a factory wrapper is needed
-*
-* Naively adding the runtime to `entryPoints` and bundling the user file would
-* fail for two reasons:
-*   1. `describe/it/test/expect` from the runtime are module-local in the IIFE
-*      scope. The user's top-level `describe(...)` calls expect them as globals —
-*      they are not globals until `runTestModule` installs them.
-*   2. Even with globals pre-installed, the user file runs at IIFE-evaluation
-*      time, before the RPC layer calls `runTestModule` to reset state and start
-*      the test clock.
-*
-* The factory approach solves both: the user's registration code is deferred
-* into a function that `runTestModule` calls AFTER installing the globals.
-*
-* ## Factory extraction algorithm
-*
-* The `userFactoryPlugin` reads the user file and splits lines into:
-*   - **top-level**: `import …` and re-export lines — kept at module scope
-*     (the only valid position for static `import` in ESM).
-*   - **body**: all other statements — moved into the body of the exported
-*     `__userFactory` async function.
-*
-* esbuild processes the re-generated module, following each static import
-* through the normal dependency graph (including the SDK-redirect plugin).
-*
-* ## SDK redirect
-*
-* Imports of `@apps-in-toss/web-framework` (and sub-paths) are intercepted via
-* the `sdkRedirectPlugin` and replaced with a virtual `window.__sdk` proxy that
-* `src/in-app/auto.ts` installs at runtime. This works for both 2.x and 3.x SDK.
-*
-* SECRET-HANDLING: the returned bundle code is caller-managed; never log it.
-*/
-/** The SDK package name that mini-app test code imports from. */
-const SDK_PACKAGE = "@apps-in-toss/web-framework";
-/**
-* Names the runtime installs as globals before invoking the user factory.
-* The `vitest` virtual module re-exports each as a lazy getter that reads from
-* `globalThis` at access time. Keep in sync with the globals installed in
-* `runtime.ts#runTestModule`.
-*/
-const VITEST_GLOBAL_NAMES = [
-	"describe",
-	"it",
-	"test",
-	"expect",
-	"beforeAll",
-	"afterAll",
-	"beforeEach",
-	"afterEach",
-	"vi"
-];
-/**
-* Matches the bare SDK package and any sub-path import
-* (`@apps-in-toss/web-framework`, `@apps-in-toss/web-framework/foo`).
-* Built from {@link SDK_PACKAGE} so the package name has a single source.
-*/
-const SDK_IMPORT_FILTER = new RegExp(`^${SDK_PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
-/**
-* esbuild plugin that intercepts SDK imports and redirects them to the
-* `window.__sdk` proxy that `src/in-app/auto.ts` installs at runtime.
-*
-* Strategy: for every import of `@apps-in-toss/web-framework` (or sub-paths),
-* esbuild resolves it to a virtual module that re-exports all named exports
-* via `window.__sdk[name]`. This avoids bundling the real SDK (which may not
-* be available in the test environment) while still making named imports work.
-*
-* If `window.__sdk` is absent (non-dog-food build), every access throws a
-* descriptive error rather than returning `undefined` silently.
-*/
-function sdkRedirectPlugin() {
-	return {
-		name: "sdk-redirect",
-		setup(build) {
-			build.onResolve({ filter: SDK_IMPORT_FILTER }, (args) => ({
-				path: args.path,
-				namespace: "sdk-redirect"
-			}));
-			build.onLoad({
-				filter: /.*/,
-				namespace: "sdk-redirect"
-			}, () => ({
-				contents: `
-var __proxy = (typeof window !== 'undefined' && window.__sdk)
-  ? window.__sdk
-  : new Proxy({}, {
-      get: function(_t, p) {
-        throw new Error('window.__sdk is not installed — run in a dog-food build. Missing: ' + String(p));
-      }
-    });
-module.exports = __proxy;
-`,
-				loader: "js"
-			}));
-		}
-	};
-}
-/**
-* esbuild plugin that intercepts `import … from 'vitest'` and replaces it with
-* a virtual module that delegates every named import to `globalThis` at ACCESS
-* time (not at bundle-evaluation time).
-*
-* The runtime installs `describe/it/test/expect/beforeAll/afterAll/beforeEach/
-* afterEach/vi` as globals inside `runTestModule`, which runs AFTER the bundle
-* IIFE is evaluated. A value-copy redirect (`export var describe =
-* globalThis.describe`) would therefore capture `undefined` at evaluation time
-* and the user's `describe(...)` calls would be no-ops — registering zero tests.
-*
-* The fix defers the lookup to call time using per-name **getter** exports.
-* We emit a CommonJS module that:
-*   1. sets `__esModule = true` so esbuild's `__toESM` interop maps each named
-*      import directly to a property access on the module (NOT wrapped under a
-*      `default` shim — which is what happens for a bare Proxy whose own-keys
-*      are empty, leaving every named import `undefined`);
-*   2. defines each global name as a getter that reads `globalThis[name]` on
-*      every access. So `import { describe } from 'vitest'` compiles to
-*      `import_vitest.describe`, whose getter returns the real `describe` only
-*      when the factory calls it — after `runTestModule` installs the globals.
-*
-* A plain `module.exports = new Proxy(...)` does NOT work here: esbuild routes
-* the virtual module through `__toESM`, which enumerates own-keys (none on an
-* empty Proxy target) and therefore exposes zero named exports. Explicit getter
-* properties give `__toESM` real keys to map while keeping access lazy.
-*/
-function vitestRedirectPlugin() {
-	return {
-		name: "vitest-redirect",
-		setup(build) {
-			build.onResolve({ filter: /^vitest$/ }, () => ({
-				path: "vitest",
-				namespace: "vitest-redirect"
-			}));
-			build.onLoad({
-				filter: /^vitest$/,
-				namespace: "vitest-redirect"
-			}, () => {
-				return {
-					contents: `Object.defineProperty(exports, '__esModule', { value: true });\n${VITEST_GLOBAL_NAMES.map((name) => `Object.defineProperty(exports, ${JSON.stringify(name)}, { enumerable: true, get: function() { return globalThis[${JSON.stringify(name)}]; } });`).join("\n")}\n`,
-					loader: "js"
-				};
-			});
-		}
-	};
-}
-/**
-* esbuild plugin that transforms the user test file into a module that exports
-* an async `__userFactory` function. The factory defers the user's top-level
-* test registration code (describe/it/test calls) so it only runs when
-* `runTestModule(__userFactory)` explicitly invokes it — AFTER the runtime has
-* installed describe/it/test/expect as globals.
-*
-* Algorithm:
-*   - Import declarations and re-export statements are kept at module top-level
-*     (the only valid ESM position for static `import`). A statement that spans
-*     multiple lines — e.g. a named import with one member per line:
-*       import {
-*         appLogin,
-*         getAnonymousKey,
-*       } from '@apps-in-toss/web-framework';
-*     is tracked as a single block: every line from the opening `import {` /
-*     `export {` through the closing `from '…'` (or side-effect `'…'`) line is
-*     kept together at top-level. This prevents the member lines and the
-*     closing `} from '…'` line from leaking into the factory body, which would
-*     leave an unterminated `import {` at module scope (the #678 env3 failure:
-*     esbuild threw `Expected "as" but found "{"` on multi-line SDK imports).
-*   - All other lines (describe/it/test calls, local declarations, etc.) are
-*     moved into the body of the exported async factory function.
-*
-* This preserves SDK import resolution (the sdk-redirect plugin processes
-* top-level imports normally) while deferring test registration to the factory.
-*/
-function userFactoryPlugin(absPath) {
-	const NAMESPACE = "user-test-factory";
-	return {
-		name: "user-test-factory",
-		setup(build) {
-			build.onResolve({ filter: /^user-test-factory$/ }, () => ({
-				path: absPath,
-				namespace: NAMESPACE
-			}));
-			build.onLoad({
-				filter: /.*/,
-				namespace: NAMESPACE
-			}, async (args) => {
-				const lines = (await fs.readFile(args.path, "utf8")).split("\n");
-				const topLevelLines = [];
-				const bodyLines = [];
-				const EXPORT_DECLARATION_RE = /^(export\s+)(default\s+|async\s+function\s+|function\s+|class\s+|const\s+|let\s+|var\s+)/;
-				const isImportStart = (trimmed) => trimmed.startsWith("import ") || trimmed.startsWith("import{") || trimmed.startsWith("import'") || trimmed.startsWith("import\"");
-				const endsStatement = (trimmed) => /['"]\s*;?\s*$/.test(trimmed.replace(/\/\/.*$/, "").trimEnd());
-				let inImportBlock = false;
-				for (const line of lines) {
-					const trimmed = line.trimStart();
-					const indent = line.slice(0, line.length - trimmed.length);
-					if (inImportBlock) {
-						topLevelLines.push(line);
-						if (endsStatement(trimmed)) inImportBlock = false;
-						continue;
-					}
-					if (isImportStart(trimmed)) {
-						topLevelLines.push(line);
-						if (!endsStatement(trimmed)) inImportBlock = true;
-					} else if (trimmed.startsWith("export ")) if (trimmed.match(EXPORT_DECLARATION_RE)) bodyLines.push(indent + trimmed.slice(7));
-					else {
-						topLevelLines.push(line);
-						if (/\bfrom\b/.test(trimmed) ? !endsStatement(trimmed) : trimmed.endsWith("{")) inImportBlock = true;
-					}
-					else bodyLines.push(line);
-				}
-				return {
-					contents: [
-						...topLevelLines,
-						"",
-						"// biome-ignore lint: generated factory wrapper",
-						"export default async function __userFactory(): Promise<void> {",
-						...bodyLines.map((l) => `  ${l}`),
-						"}"
-					].join("\n"),
-					loader: "ts",
-					resolveDir: path$1.dirname(absPath)
-				};
-			});
-		}
-	};
-}
-/**
-* Returns the absolute filesystem path to the test-runner runtime module
-* (dist/test-runner/runtime.js — a fully self-contained page-side bundle).
-*
-* Rolldown code-splitting duplicates this bundling logic into shared chunks
-* emitted at ARBITRARY dist depths: the `devtools-test` CLI pulls it from
-* dist/test-runner/bundle.js (dir = dist/test-runner/), while the `devtools-mcp`
-* daemon (dist/mcp/cli.js) pulls it through a ROOT chunk
-* (dist/debug-server-<hash>.js, dir = dist/). A fixed `..`-hop candidate list
-* is therefore wrong from at least one chunk — the live #697 regression.
-*
-* This resolves WITHOUT assuming chunk depth: from `import.meta.url`'s dir it
-* probes the co-located `runtime.js` and the nested `test-runner/runtime.js`,
-* then ascends one directory at a time (bounded) repeating both probes. The
-* nested probe catches dist/test-runner/runtime.js from the dist/ root level no
-* matter which depth the chunk was hoisted to (root, dist/mcp/, or a future
-* relocation). The build always emits dist/test-runner/runtime.js (tsdown entry
-* `'test-runner/runtime'`; guarded by scripts/check-test-runner-dist.sh).
-*
-* An ABSOLUTE path is returned deliberately: esbuild loads it as a literal file
-* read, bypassing Node module resolution entirely, so this works identically in
-* the npx-daemon context (its own dist tree) and the consumer-CLI context
-* (the mini-app's installed @ait-co/devtools dist) — neither needs the package
-* to be node-resolvable from the caller.
-*/
-function getRuntimePath() {
-	const startDir = path$1.dirname(fileURLToPath(import.meta.url));
-	const RELATIVE_PROBES = [
-		["runtime.js"],
-		["test-runner", "runtime.js"],
-		["runtime.ts"],
-		["test-runner", "runtime.ts"]
-	];
-	let dir = startDir;
-	for (let i = 0; i < 12; i++) {
-		for (const segs of RELATIVE_PROBES) {
-			const candidate = path$1.join(dir, ...segs);
-			try {
-				accessSync(candidate);
-				return candidate;
-			} catch {}
-		}
-		const parent = path$1.dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return path$1.join(startDir, "runtime.js");
-}
-/**
-* Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.
-*
-* The IIFE installs `window.__testBundle` (or the custom `globalName`) with:
-*   - `runTestModule` — the runtime entry (from `runtime.ts`).
-*   - `__userFactory` — an async function wrapping the user's test registration
-*     code so it runs AFTER `runTestModule` installs the globals.
-*
-* Callers (rpc.ts) invoke:
-*   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
-*
-* @param absPath - Absolute path to the user test file.
-* @param opts    - Optional bundling overrides.
-*/
-async function bundleTestFile(absPath, opts) {
-	const globalName = opts?.globalName ?? "__testBundle";
-	const extraExternals = opts?.extraExternals ?? [];
-	const esbuild = await import("esbuild");
-	const runtimePath = getRuntimePath();
-	const wrapperContent = [
-		`import { runTestModule } from ${JSON.stringify(runtimePath)};`,
-		`import __userFactory from "user-test-factory";`,
-		`export { runTestModule, __userFactory };`
-	].join("\n");
-	const result = await esbuild.build({
-		stdin: {
-			contents: wrapperContent,
-			loader: "ts",
-			resolveDir: path$1.dirname(absPath)
-		},
-		bundle: true,
-		format: "iife",
-		globalName,
-		platform: "browser",
-		target: "es2022",
-		write: false,
-		plugins: [
-			userFactoryPlugin(absPath),
-			vitestRedirectPlugin(),
-			sdkRedirectPlugin()
-		],
-		external: extraExternals,
-		treeShaking: true,
-		footer: { js: `globalThis[${JSON.stringify(globalName)}] = ${globalName};` }
-	});
-	const warnings = result.warnings.map((w) => `${path$1.relative(process.cwd(), w.location?.file ?? "")}:${w.location?.line ?? "?"}: ${w.text}`);
-	const outputFile = result.outputFiles?.[0];
-	if (!outputFile) throw new Error("bundleTestFile: esbuild produced no output — check entryPoints");
-	return {
-		code: outputFile.text,
-		warnings
-	};
-}
-//#endregion
-//#region src/test-runner/capture.ts
-/** The exact console-line prefix sdk-example's `flushCapture` emits. */
-const CAPTURE_PREFIX = "__AIT_CAPTURE__ ";
-/**
-* Parses raw console line texts into {@link AitCaptureLine}s.
-*
-* Filtering rules (each independently drops a line — never throws):
-*   - the line text must `startsWith(CAPTURE_PREFIX)` exactly (allowlist);
-*   - there must be a non-empty category token (up to the next space);
-*   - the remaining payload must be valid JSON (`JSON.parse` succeeds).
-*
-* Lines that fail any rule (wss/scheme noise, truncated, broken JSON) are
-* silently discarded — capture harvesting is best-effort and must never fail a
-* run or leak a malformed/secret-bearing line.
-*
-* @param raw - Console line objects (only `.text` is read).
-* @returns The captured lines, in input order.
-*/
-function parseCaptureLines(raw) {
-	const out = [];
-	for (const { text } of raw) {
-		if (!text.startsWith(CAPTURE_PREFIX)) continue;
-		const body = text.slice(16);
-		const spaceIdx = body.indexOf(" ");
-		if (spaceIdx === -1) continue;
-		const category = body.slice(0, spaceIdx);
-		const json = body.slice(spaceIdx + 1);
-		if (category === "" || json === "") continue;
-		try {
-			JSON.parse(json);
-		} catch {
-			continue;
-		}
-		out.push({
-			category,
-			json
-		});
-	}
-	return out;
-}
-//#endregion
-//#region src/test-runner/rpc.ts
-/** Maximum milliseconds to wait for a single evaluate round-trip. */
-const DEFAULT_TIMEOUT_MS = 3e4;
-/**
-* Wraps bundle code in a self-executing IIFE that:
-*   1. Evaluates the bundle (registering describe/it/test).
-*   2. Calls `__testBundle.runTestModule(...)` — the entry the runtime exports.
-*   3. Returns a JSON-serialised `RunReport` string.
-*
-* The double-serialisation (RunReport → JSON string → returnByValue string)
-* is intentional: CDP `returnByValue` reliably transports strings; deeply
-* nested objects can lose fidelity across the Chii relay.
-*
-* SECRET-HANDLING: `bundleCode` MUST NOT be logged by callers.
-*/
-function buildRunTestsExpression(bundleCode) {
-	return `(async () => {  try { ${bundleCode} } catch(e) {    return JSON.stringify({ok:false,error:'bundle-eval: ' + String(e && e.message || e)});  }  if (typeof globalThis.__testBundle !== 'object' || typeof globalThis.__testBundle.runTestModule !== 'function' || typeof globalThis.__testBundle.__userFactory !== 'function') {    return JSON.stringify({ok:false,error:'bundle-missing-export: __testBundle.runTestModule or __userFactory is not a function'});  }  try {    const report = await globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory);    return JSON.stringify({ok:true,value:report});  } catch(e) {    return JSON.stringify({ok:false,error:'test-run: ' + String(e && e.message || e)});  }})()`;
-}
-/**
-* Parses the raw CDP `returnByValue` result from a `buildRunTestsExpression`
-* evaluate call into a typed `RpcRunResult`.
-*
-* Throws only on parse failure — an `ok:false` envelope is a normal result.
-*
-* SECRET-HANDLING: `rawValue` is not included in error messages.
-*/
-function parseRunTestsResult(rawValue) {
-	if (typeof rawValue !== "string") throw new Error(`rpc.parseRunTestsResult: unexpected return type "${typeof rawValue}" — expected JSON string`);
-	let parsed;
-	try {
-		parsed = JSON.parse(rawValue);
-	} catch {
-		throw new Error("rpc.parseRunTestsResult: bridge returned non-JSON string");
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("rpc.parseRunTestsResult: parsed result is not an object");
-	const obj = parsed;
-	if (obj.ok === true) return {
-		ok: true,
-		report: obj.value
-	};
-	if (obj.ok === false) return {
-		ok: false,
-		error: typeof obj.error === "string" ? obj.error : String(obj.error)
-	};
-	throw new Error("rpc.parseRunTestsResult: result missing \"ok\" field");
-}
-/**
-* Injects `bundleCode` into the attached page and awaits test execution.
-*
-* Uses `Runtime.evaluate` with `awaitPromise: true` to wait for the
-* async IIFE to settle.  The 30-second CDP command timeout covers even
-* long-running test suites; split into smaller files if you hit it.
-*
-* @param connection   - Active CDP connection (relay or local).
-* @param bundleCode   - IIFE bundle string from `bundleTestFile`.
-* @param timeoutMs    - Override the default 30 s timeout.
-*
-* SECRET-HANDLING: `bundleCode` and the raw CDP result value are never logged.
-*/
-async function injectAndRunBundle(connection, bundleCode, timeoutMs = DEFAULT_TIMEOUT_MS) {
-	const expression = buildRunTestsExpression(bundleCode);
-	const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`rpc: evaluate timed out after ${timeoutMs}ms`)), timeoutMs));
-	const evalPromise = connection.send("Runtime.evaluate", {
-		expression,
-		returnByValue: true,
-		awaitPromise: true
-	});
-	const cdpResult = await Promise.race([evalPromise, timeoutPromise]);
-	if (cdpResult.exceptionDetails) {
-		const msg = cdpResult.exceptionDetails.exception?.description ?? cdpResult.exceptionDetails.text ?? "Runtime.evaluate threw an exception";
-		throw new Error(`rpc.injectAndRunBundle: ${msg}`);
-	}
-	return parseRunTestsResult(cdpResult.result.value);
-}
-//#endregion
-//#region src/test-runner/relay-worker.ts
-/**
-* Runs all `files` sequentially over the given CDP `connection`.
-*
-* For each file:
-*   1. Bundle with esbuild (includes SDK shim + runtime).
-*   2. Inject into the attached page via `Runtime.evaluate`.
-*   3. Await the `RunReport` JSON response.
-*   4. Accumulate results.
-*
-* Returns a `RelayRunReport` with per-file results and flattened totals.
-*
-* This function does NOT open or manage the relay connection — the caller
-* is responsible for attaching and closing it.
-*
-* TODO (#645): implement the Vitest `PoolRunnerInitializer` interface here
-* so that `runTestFilesOverRelay` can be used as a Vitest pool entry.
-*
-* @param connection - Active CDP connection (relay or local kind).
-* @param files      - Absolute paths to test files, run in order.
-* @param opts       - Optional per-run overrides.
-*/
-async function runTestFilesOverRelay(connection, files, opts) {
-	const wallStart = Date.now();
-	const startedAt = new Date(wallStart).toISOString();
-	const fileResults = [];
-	let domainsEnabled = false;
-	try {
-		await connection.enableDomains();
-		domainsEnabled = true;
-	} catch (e) {
-		process.stderr.write(`relay-worker: enableDomains() failed before run — console capture may be empty (${e instanceof Error ? e.message : String(e)})\n`);
-	}
-	const collectCaptures = opts?.collectCaptures === true;
-	const liveConsole = [];
-	let unsubscribeConsole;
-	if (collectCaptures && domainsEnabled) unsubscribeConsole = connection.on("Runtime.consoleAPICalled", (event) => {
-		liveConsole.push(event);
-	});
-	try {
-		for (const file of files) {
-			let fileEntry;
-			try {
-				const { code } = await bundleTestFile(file, opts?.bundleOptions);
-				const rpcResult = await injectAndRunBundle(connection, code, opts?.timeoutMs);
-				if (rpcResult.ok) fileEntry = {
-					file,
-					result: rpcResult.report
-				};
-				else fileEntry = {
-					file,
-					result: { error: rpcResult.error }
-				};
-			} catch (e) {
-				fileEntry = {
-					file,
-					result: { error: e instanceof Error ? e.message : String(e) }
-				};
-			}
-			fileResults.push(fileEntry);
-		}
-	} finally {
-		unsubscribeConsole?.();
-	}
-	const captures = collectCaptures ? parseCaptureLines(liveConsole.map((e) => ({ text: renderConsoleLineText(e) }))) : [];
-	const totals = fileResults.reduce((acc, { result }) => {
-		if ("error" in result) {
-			acc.failed += 1;
-			acc.total += 1;
-		} else {
-			acc.passed += result.passed;
-			acc.failed += result.failed;
-			acc.skipped += result.skipped;
-			acc.total += result.passed + result.failed + result.skipped;
-		}
-		return acc;
-	}, {
-		passed: 0,
-		failed: 0,
-		skipped: 0,
-		total: 0
-	});
-	return {
-		startedAt,
-		duration: Date.now() - wallStart,
-		files: fileResults,
-		totals,
-		captures
-	};
-}
-/**
-* Renders one `Runtime.consoleAPICalled` event to a single line of text, the
-* same way `tools.ts#normalizeConsoleMessage` does (args rendered + space-
-* joined). Inlined here (≈8 lines) so this module avoids importing `tools.ts`,
-* which would drag the heavy MCP/Node graph (server-lock, parent-watcher, …)
-* onto the test-runner entry.
-*
-* SECRET-HANDLING: this only stringifies console args; the caller's
-* allowlist-prefix parser then discards everything that is not a genuine
-* `__AIT_CAPTURE__` line.
-*/
-function renderConsoleLineText(event) {
-	return event.args.map((arg) => {
-		if (arg.value !== void 0) {
-			if (typeof arg.value === "string") return arg.value;
-			try {
-				return JSON.stringify(arg.value);
-			} catch {
-				return String(arg.value);
-			}
-		}
-		if (arg.description !== void 0) return arg.description;
-		if (arg.className !== void 0) return arg.className;
-		return arg.subtype ?? arg.type;
-	}).join(" ");
-}
-//#endregion
-//#region src/test-runner/report.ts
-/**
-* Runner-agnostic report serialisation for env3 test runs (devtools#696).
-*
-* Both env3 execution paths — the Vitest custom pool (`pool.ts`) and the
-* standalone `devtools-test` CLI (`cli.ts`) — call the same core
-* `runTestFilesOverRelay` and so produce the same {@link RelayRunReport}. This
-* module is the single, runner-neutral place that turns that in-memory report
-* into a stable on-disk artifact so a 2.x run and a 3.0 run can be diffed
-* cell-by-cell after the fact.
-*
-* The serialised schema is deliberately MINIMAL and secret-free:
-*
-*   - file paths are stored RELATIVE to `projectRoot` (no absolute `/Users/...`
-*     leakage — see {@link RunnerAgnosticReport.files});
-*   - the cell metadata (sdkLine/platform) is baked INTO the body, not only the
-*     filename, so a moved artifact never loses its provenance;
-*   - NO relay wss / scheme / TOTP / relayUrl fields exist in the schema at all
-*     (enforced by the type + this comment) — error strings are the matcher
-*     message only, inherited from rpc.ts which already strips expression/value.
-*
-* react-free — depends only on the type-level `RelayRunReport` and `node:fs` /
-* `node:path`. Safe to bundle without pulling the chii/cloudflared graph.
-*/
-/**
-* Converts an absolute (or already-relative) file path to a projectRoot-relative
-* one. `path.relative` returns `''` when the paths are equal — guard that to the
-* basename so the field is never empty.
-*
-* SECRET-HANDLING: this is the single choke point that strips absolute project
-* paths from the artifact.
-*/
-function relativise(projectRoot, file) {
-	const rel = path.relative(projectRoot, file);
-	if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return path.basename(file);
-	return rel;
-}
-/**
-* Serialises a {@link RelayRunReport} into the runner-agnostic, secret-free
-* on-disk shape. Pure — no IO; testable with a plain report + meta.
-*
-* @param report - The core relay run report.
-* @param meta   - Cell axes + projectRoot (projectRoot is consumed, not stored).
-*/
-function serializeRelayReport(report, meta) {
-	return {
-		cell: {
-			sdkLine: meta.sdkLine,
-			platform: meta.platform
-		},
-		startedAt: report.startedAt,
-		duration: report.duration,
-		totals: report.totals,
-		files: report.files.map((f) => {
-			const file = relativise(meta.projectRoot, f.file);
-			if ("error" in f.result) return {
-				file,
-				error: f.result.error
-			};
-			return {
-				file,
-				duration: f.result.duration,
-				passed: f.result.passed,
-				failed: f.result.failed,
-				skipped: f.result.skipped,
-				tests: f.result.tests
-			};
-		})
-	};
-}
-/**
-* Writes the serialised report to `<dir>/<sdkLine>.<platform>.json`, creating
-* `dir` if needed. Returns the absolute path written.
-*
-* The cell-suffixed filename keeps 2.x and 3.0 (and per-platform) runs as
-* distinct artifacts in the same directory; the same cell metadata is also baked
-* into the body so a renamed/moved file still carries its provenance.
-*
-* SECRET-HANDLING: the written body contains no relay/secret fields (the schema
-* has none). `dir`/`projectRoot` are local filesystem paths, never logged here.
-*
-* @param report - The core relay run report.
-* @param dir    - Output directory (created recursively if missing).
-* @param meta   - Cell axes + projectRoot.
-* @returns The absolute path of the written file.
-*/
-async function writeReportArtifact(report, dir, meta) {
-	const serialised = serializeRelayReport(report, meta);
-	await mkdir(dir, { recursive: true });
-	const outFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.json`);
-	await writeFile(outFile, `${JSON.stringify(serialised, null, 2)}\n`, "utf8");
-	return outFile;
-}
-/**
-* Writes harvested `__AIT_CAPTURE__` lines to per-category files under `dir`,
-* named `<category>.<sdkLine>.<platform>.json` — the SAME convention
-* sdk-example's env1 `flushCapture` uses on the filesystem, so env1 and env3
-* capture artifacts line up for diffing.
-*
-* Each line's `json` payload is an opaque JSON array of capture records. Lines
-* sharing a category are concatenated into one array, in harvest order.
-*
-* SECRET-HANDLING: only allowlist-prefixed capture lines reach here (the parser
-* dropped wss/scheme noise); the `json` payload is written verbatim but is a
-* capture record array, not a relay/secret.
-*
-* @param captures - Parsed capture lines (from `RelayRunReport.captures`).
-* @param dir      - Output directory (created recursively if missing).
-* @param cell     - Cell axes for the filename suffix.
-* @returns The absolute paths written (one per category), in category order.
-*/
-async function writeCaptureArtifacts(captures, dir, cell) {
-	if (captures.length === 0) return [];
-	const byCategory = /* @__PURE__ */ new Map();
-	for (const { category, json } of captures) {
-		let merged = byCategory.get(category);
-		if (!merged) {
-			merged = [];
-			byCategory.set(category, merged);
-		}
-		const parsed = JSON.parse(json);
-		if (Array.isArray(parsed)) merged.push(...parsed);
-		else merged.push(parsed);
-	}
-	await mkdir(dir, { recursive: true });
-	const written = [];
-	for (const [category, records] of byCategory) {
-		const outFile = path.join(dir, `${category}.${cell.sdkLine}.${cell.platform}.json`);
-		await writeFile(outFile, `${JSON.stringify(records, null, 2)}\n`, "utf8");
-		written.push(outFile);
-	}
-	return written;
-}
-//#endregion
-//#region src/test-runner/cli.ts
-/**
-* `devtools-test` CLI.
-*
-* Shares test-file discovery with the `run_tests` MCP tool (`discoverTestFiles`)
-* and exposes `runWithConnection` — the pure run core that bundles, injects, and
-* collects each file over a CDP connection. The CLI's `main()` performs a
-* standalone relay attach (boot relay → QR → phone scan → cell inject → run).
-*
-* NOTE: no shebang in this source file — the tsdown entry's `banner` option
-* injects `#!/usr/bin/env node` into the compiled output (same pattern as
-* `src/mcp/cli.ts`).
-*/
-const USAGE = `
-devtools-test — run mini-app tests on a real device WebView over the CDP relay
-
-USAGE
-  devtools-test <glob> [<glob> ...] [options]
-
-OPTIONS
-  --scheme-url <url>      intoss-private:// URL from \`ait deploy --scheme-only\`
-                          (required for standalone relay attach / env3)
-  --timeout <ms>          Per-file evaluate timeout in ms (default: 30000)
-  --cell-sdk-line <line>  SDK line to inject as __AIT_CELL__.sdkLine (2.x|3.x)
-  --cell-platform <plat>  Platform to inject as __AIT_CELL__.platform
-                          (mock|ios|android, default: AIT_CELL_PLATFORM env)
-  --report-dir <dir>      Persist a runner-agnostic report + captures to <dir>
-                          (report: <sdkLine>.<platform>.json; captures:
-                          <dir>/.ait-capture/<category>.<sdkLine>.<platform>.json).
-                          Omitted = nothing saved. Enables console capture.
-  --no-qr-stdout          Suppress the QR/attach block on stdout (auto-on for
-                          non-interactive stdout / CI / AIT_NO_QR_STDOUT)
-  --headless              Disable browser auto-open (text QR only)
-  --project-root <dir>    Project root for .ait_relay secret lookup
-                          (default: current working directory)
-  --help, -h              Show this help message
-
-DESCRIPTION
-  Boots a Chii relay + cloudflared tunnel, renders a QR code, waits for a real
-  device to scan and attach, injects the cell globals (__AIT_CELL__), bundles
-  each matched test file with esbuild (SDK imports redirected to window.__sdk),
-  injects the bundle into the attached WebView via Runtime.evaluate, and prints
-  a summary.
-
-  With --report-dir, also harvests __AIT_CAPTURE__ console lines and writes a
-  runner-agnostic report + per-category capture files so 2.x↔3.0 runs can be
-  compared offline.
-
-  The test files run against the live relay connection started by this process;
-  no separate MCP daemon is required.
-
-EXAMPLE
-  devtools-test 'src/**/*.ait.test.ts' \\
-    --scheme-url "intoss-private://..." \\
-    --cell-sdk-line 3.x \\
-    --cell-platform ios \\
-    --report-dir .ait-report \\
-    --timeout 60000
-
-`.trimStart();
-/**
-* Runs `files` over `connection` and returns the aggregate report.
-* This pure function is the testable core of the CLI (and is what the
-* `run_tests` MCP tool calls against the daemon's attached connection); it is
-* separate from `main()` so tests can call it without spawning a subprocess.
-*/
-async function runWithConnection(connection, files, opts) {
-	const report = await runTestFilesOverRelay(connection, files, opts);
-	if (opts?.printSummary) {
-		const { totals } = report;
-		process.stdout.write(`\ndevtools-test: ${totals.passed} passed, ${totals.failed} failed, ${totals.skipped} skipped (${report.duration}ms)\n`);
-	}
-	return report;
-}
-/**
-* Decides whether to suppress the QR/attach block on stdout.
-*
-* Suppress when EITHER the user passed `--no-qr-stdout`, OR stdout is not a TTY
-* / `CI` is set / `AIT_NO_QR_STDOUT` is set (non-interactive — a captured stdout
-* must not leak the relay wss + TOTP `at=` code that the QR block encodes). The
-* suppression is whole-chunk: `attachUrl` AND `relayUrl` ride in the same block.
-*
-* Exported for unit testing.
-*/
-function shouldSuppressQr(noQrFlag) {
-	return noQrFlag || !process.stdout.isTTY || process.env.CI !== void 0 || process.env.AIT_NO_QR_STDOUT !== void 0;
-}
-/**
-* CLI entry point.
-*
-* Performs a standalone relay attach → run lifecycle, sharing the attach
-* assembly with the Vitest pool via `createRelayConnectionFactory` (single
-* source — no drift):
-*
-* 1. Parse args: globs, --timeout, --cell-sdk-line, --cell-platform,
-*    --scheme-url (required for env3), --report-dir, --no-qr-stdout,
-*    --headless, --project-root.
-* 2. Discover test files; exit 1 if none.
-* 3. factory.open() — boot relay → render QR (suppressed on non-interactive
-*    stdout) → wait for phone → inject cell → enableDomains. Returns the conn.
-* 4. runWithConnection(conn, files, { timeoutMs, collectCaptures, printSummary }).
-* 5. With --report-dir: write the runner-agnostic report + capture files.
-* 6. factory.close(); process.exitCode = failed > 0 ? 1 : 0.
-*
-* The CLI is not a daemon — no lock, router, SSE, or tools_list is needed.
-* Attach timeout exits with code 1; test failures exit with code 1.
-*
-* SECRET-HANDLING: scheme_url / relay wssUrl / TOTP codes are never written to
-* stdout/stderr directly. The QR block (which encodes the TOTP `at=` code) is
-* printed only when stdout is interactive AND not suppressed.
-*/
-async function main(argv = process.argv.slice(2)) {
-	let parsed;
-	try {
-		parsed = parseArgs({
-			args: argv,
-			options: {
-				help: {
-					type: "boolean",
-					short: "h"
-				},
-				timeout: { type: "string" },
-				"scheme-url": { type: "string" },
-				"cell-sdk-line": { type: "string" },
-				"cell-platform": { type: "string" },
-				"report-dir": { type: "string" },
-				"no-qr-stdout": { type: "boolean" },
-				headless: { type: "boolean" },
-				"project-root": { type: "string" }
-			},
-			allowPositionals: true
-		});
-	} catch (e) {
-		process.stderr.write(`devtools-test: ${e instanceof Error ? e.message : String(e)}\n`);
-		process.exitCode = 1;
-		return;
-	}
-	if (parsed.values.help || argv.length === 0) {
-		process.stdout.write(USAGE);
-		return;
-	}
-	const vals = parsed.values;
-	const rawTimeout = typeof vals.timeout === "string" ? vals.timeout : void 0;
-	const timeoutMs = rawTimeout !== void 0 ? parseInt(rawTimeout, 10) : 3e4;
-	if (Number.isNaN(timeoutMs) || timeoutMs <= 0) {
-		process.stderr.write(`devtools-test: --timeout must be a positive integer\n`);
-		process.exitCode = 1;
-		return;
-	}
-	const schemeUrl = typeof vals["scheme-url"] === "string" ? vals["scheme-url"] : "";
-	if (schemeUrl === "") {
-		process.stderr.write("devtools-test: --scheme-url is required for standalone relay attach.\n  Pass the intoss-private:// URL from `ait deploy --scheme-only`.\n");
-		process.exitCode = 1;
-		return;
-	}
-	const headless = vals.headless === true;
-	const projectRoot = typeof vals["project-root"] === "string" ? vals["project-root"] : process.cwd();
-	const reportDir = typeof vals["report-dir"] === "string" ? vals["report-dir"] : void 0;
-	const suppressQr = shouldSuppressQr(vals["no-qr-stdout"] === true);
-	const cellSdkLine = typeof vals["cell-sdk-line"] === "string" ? vals["cell-sdk-line"] : void 0;
-	const cellPlatform = typeof vals["cell-platform"] === "string" ? vals["cell-platform"] : process.env.AIT_CELL_PLATFORM;
-	const hasCell = cellSdkLine !== void 0 || cellPlatform !== void 0;
-	const cell = {
-		sdkLine: cellSdkLine ?? "2.x",
-		platform: cellPlatform ?? "mock"
-	};
-	const globs = parsed.positionals;
-	if (globs.length === 0) {
-		process.stderr.write(`devtools-test: at least one glob pattern is required\n`);
-		process.stdout.write(USAGE);
-		process.exitCode = 1;
-		return;
-	}
-	const files = await discoverTestFiles(globs, process.cwd());
-	if (files.length === 0) {
-		process.stderr.write(`devtools-test: no test files matched ${globs.join(", ")}\n`);
-		process.exitCode = 1;
-		return;
-	}
-	process.stderr.write(`devtools-test: found ${files.length} test file(s)\n`);
-	if (hasCell) process.stderr.write(`devtools-test: injecting __AIT_CELL__ = ${JSON.stringify(cell)}\n`);
-	const factory = createRelayConnectionFactory({
-		schemeUrl,
-		projectRoot,
-		timeoutMs,
-		headless,
-		cell: hasCell ? cell : void 0,
-		onQrContent: (chunks) => {
-			if (suppressQr) {
-				process.stdout.write("QR suppressed (non-interactive)\n");
-				return;
-			}
-			for (const chunk of chunks) process.stdout.write(`${chunk}\n`);
-		}
-	});
-	let connection;
-	try {
-		connection = await factory.open();
-	} catch (e) {
-		process.stderr.write(`devtools-test: ${e instanceof Error ? e.message : String(e)}\n`);
-		process.exitCode = 1;
-		return;
-	}
-	let exitCode = 0;
-	try {
-		const report = await runWithConnection(connection, files, {
-			timeoutMs,
-			printSummary: true,
-			collectCaptures: reportDir !== void 0
-		});
-		if (reportDir !== void 0) try {
-			const reportPath = await writeReportArtifact(report, reportDir, {
-				sdkLine: cell.sdkLine,
-				platform: cell.platform,
-				projectRoot
-			});
-			process.stderr.write(`devtools-test: wrote report ${reportPath}\n`);
-			const capturePaths = await writeCaptureArtifacts(report.captures, `${reportDir}/.ait-capture`, cell);
-			if (capturePaths.length > 0) process.stderr.write(`devtools-test: wrote ${capturePaths.length} capture file(s)\n`);
-		} catch (e) {
-			process.stderr.write(`devtools-test: failed to write report artifacts: ${e instanceof Error ? e.message : String(e)}\n`);
-		}
-		exitCode = report.totals.failed > 0 ? 1 : 0;
-	} finally {
-		await factory.close(connection);
-		process.exitCode = exitCode;
-	}
-}
-if (import.meta.url === new URL(process.argv[1], "file://").href) main().catch((e) => {
-	process.stderr.write(`devtools-test: unexpected error: ${e instanceof Error ? e.message : String(e)}\n`);
-	process.exitCode = 1;
-});
-//#endregion
-//#region src/mcp/ait-chii-source.ts
-function isObject$2(value) {
-	return typeof value === "object" && value !== null;
-}
-/** Narrows an `AIT.getSdkCallHistory` response, tolerating a missing array. */
-function asSdkCallHistory(raw) {
-	if (isObject$2(raw) && Array.isArray(raw.calls)) return { calls: raw.calls };
-	return { calls: [] };
-}
-/** Narrows an `AIT.getMockState` response to an opaque record. */
-function asMockState(raw) {
-	return isObject$2(raw) ? raw : {};
-}
-/** Narrows an `AIT.getOperationalEnvironment` response. */
-function asOperationalEnvironment(raw) {
-	return {
-		environment: isObject$2(raw) && typeof raw.environment === "string" ? raw.environment : "unknown",
-		sdkVersion: isObject$2(raw) && typeof raw.sdkVersion === "string" ? raw.sdkVersion : null
-	};
-}
-var ChiiAitSource = class {
-	constructor(sender) {
-		this.sender = sender;
-	}
-	async get(method) {
-		const raw = await this.sender.sendCommand(method);
-		switch (method) {
-			case "AIT.getSdkCallHistory": return asSdkCallHistory(raw);
-			case "AIT.getMockState": return asMockState(raw);
-			case "AIT.getOperationalEnvironment": return asOperationalEnvironment(raw);
-			default: throw new Error(`Unknown AIT method: ${String(method)}`);
-		}
-	}
-};
-//#endregion
-//#region src/shared/relay-auth-close.ts
-/**
-* Shared constants for the relay's named TOTP-auth rejection (issue #478).
-*
-* Before #478 the relay rejected an unauthenticated WebSocket upgrade with a
-* raw `HTTP/1.1 401` + `socket.destroy()`. A handshake aborted that way is
-* indistinguishable from a network failure on the browser side — the
-* WebSocket only ever sees close code 1006, so the phone (env-2 launcher PWA)
-* could not tell "stale TOTP code" apart from "tunnel down" and stayed
-* silent. The fix is accept-then-close: complete the handshake, then close
-* with an application close code that NAMES the rejection.
-*
-* Three parties share this contract:
-*   - `src/mcp/chii-relay.ts` (Node) sends the close frame / HTTP error body;
-*   - `src/in-app/attach.ts` (browser) observes relay-bound WebSockets and
-*     surfaces the code to the launcher shell;
-*   - `src/mcp/chii-connection.ts` (Node daemon client) recognises the code
-*     as an auth failure on its own `/client` dial (defensive — #439's fresh
-*     code mint means it should not normally hit this).
-*
-* This module is intentionally dependency-free (no Node, no DOM) so it is
-* safe to import from both the browser in-app bundle and the MCP daemon
-* bundle.
-*
-* SECRET-HANDLING: these are fixed enum values. The close reason / error body
-* must never grow to carry a secret, a TOTP code, or a host.
-*/
-/**
-* WebSocket close code sent by the relay when TOTP auth is rejected.
-*
-* 4000–4999 is the application-reserved range (RFC 6455 §7.4.2); 4401 mirrors
-* HTTP 401 so it reads as "unauthorized" at a glance.
-*/
-const RELAY_AUTH_REJECT_CLOSE_CODE = 4401;
-/**
-* Close reason string accompanying {@link RELAY_AUTH_REJECT_CLOSE_CODE}, and
-* the `error` value of the relay's HTTP 401 JSON body. Enum string only —
-* never interpolated with request data.
-*/
-const RELAY_AUTH_REJECT_REASON = "totp-rejected";
-//#endregion
-//#region src/mcp/chii-connection.ts
-/**
-* Production `CdpConnection` backed by the local Chii relay.
-*
-* Topology (debug mode):
-*   phone target.js  --WS-->  Chii relay :9100  <--WS--  this connection
-*
-* The phone connects to the relay as a `target`; this module connects as a
-* `client` (the role a CDP frontend would take) so CDP events the page emits
-* (`Runtime.consoleAPICalled`, `Network.*`) flow back here. We buffer recent
-* events in ring buffers the tool layer reads via `getBufferedEvents`.
-*
-* Node-only: imports `ws`. Never bundled into the browser/in-app entries.
-*
-* Attach reliability (#281):
-*   `refreshTargets()` emits an internal 'target:attached' event whenever a
-*   new target is added to the relay. `waitForFirstTarget()` awaits that event
-*   (with a polling-interval fallback) so `start_attach`'s attach wait
-*   resolves deterministically rather than racing between polling rounds.
-*/
-/** Max events retained per domain ring buffer. */
-const DEFAULT_BUFFER_SIZE$1 = 500;
-function isObject$1(value) {
-	return typeof value === "object" && value !== null;
-}
-function parseInbound$1(raw) {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return null;
-	}
-	if (!isObject$1(parsed)) return null;
-	const message = {};
-	if (typeof parsed.id === "number") message.id = parsed.id;
-	if (typeof parsed.method === "string") message.method = parsed.method;
-	if ("params" in parsed) message.params = parsed.params;
-	if ("result" in parsed) message.result = parsed.result;
-	if (isObject$1(parsed.error) && typeof parsed.error.message === "string") message.error = { message: parsed.error.message };
-	return message;
-}
-const PHASE_1_EVENTS$1 = [
-	"Runtime.consoleAPICalled",
-	"Network.requestWillBeSent",
-	"Network.responseReceived"
-];
-/**
-* Ring buffer size for `Runtime.exceptionThrown`.
-*
-* Exceptions are rarer than console messages but each is heavier (stack
-* trace). 50 is generous enough to cover a crash scenario while keeping
-* memory bounded.
-*
-* **Lifecycle note**: the exception buffer intentionally survives `replaced` /
-* `crashed` / `destroyed` lifecycle events — it is NOT cleared on target
-* transitions. Rationale: an exception fired just before a crash is exactly
-* the signal we want to preserve for root-cause analysis. The buffer
-* represents "exceptions seen in this MCP session", not "exceptions in the
-* current page".
-*/
-const EXCEPTION_BUFFER_SIZE = 50;
-/** Default per-command timeout if neither option nor env var is set. */
-const DEFAULT_COMMAND_TIMEOUT_MS = 3e4;
-/**
-* Production CDP connection. Polls the relay for the first attached target,
-* opens a client websocket to it, enables Phase 1 domains, and buffers events.
-*/
-var ChiiCdpConnection = class {
-	/** Authoritative connection kind (issue #348) — relay-backed. */
-	kind = "relay";
-	relayBaseUrl;
-	bufferSize;
-	commandTimeoutMs;
-	totpSecret;
-	emitter = new EventEmitter();
-	buffers = /* @__PURE__ */ new Map();
-	targets = /* @__PURE__ */ new Map();
-	ws = null;
-	connectionState = "idle";
-	nextCommandId = 1;
-	/**
-	* The single active target id under the single-attach model.
-	* Updated by `refreshTargets()` whenever a non-null target is present.
-	* Used to detect a new (different) target attach and evict the previous one.
-	*/
-	activeTargetId = null;
-	/** In-flight enableDomains() promise — concurrent callers share it. */
-	enablingPromise = null;
-	/** Pending request→response commands keyed by CDP message id. */
-	pending = /* @__PURE__ */ new Map();
-	/**
-	* Timestamp (ms since epoch) of the most recent crash/destroy/detach event,
-	* or `null` if no crash has been detected since the last `enableDomains()`.
-	*/
-	lastCrashDetectedAt = null;
-	/**
-	* Per-target last-seen timestamp (ms since epoch). Updated on any inbound
-	* CDP message carrying data from a target. Keyed by target id.
-	*/
-	targetLastSeenAt = /* @__PURE__ */ new Map();
-	/** Active heartbeat interval handle (only when `AIT_CDP_HEARTBEAT_MS` is set). */
-	heartbeatHandle = null;
-	/** Lifecycle event listeners (crash / destroyed / detached). */
-	lifecycleListeners = [];
-	constructor(options) {
-		this.relayBaseUrl = options.relayBaseUrl.replace(/\/$/, "");
-		this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER_SIZE$1;
-		this.totpSecret = options.totpSecret;
-		const envMs = process.env.AIT_CDP_COMMAND_TIMEOUT_MS ? Number(process.env.AIT_CDP_COMMAND_TIMEOUT_MS) : void 0;
-		this.commandTimeoutMs = (envMs !== void 0 && Number.isFinite(envMs) && envMs > 0 ? envMs : void 0) ?? options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
-		for (const event of PHASE_1_EVENTS$1) this.buffers.set(event, []);
-		this.buffers.set("Runtime.exceptionThrown", []);
-		this.emitter.setMaxListeners(0);
-	}
-	/** Refresh the attached-target list from the relay's `GET /targets`. */
-	async refreshTargets() {
-		let targetsUrl = `${this.relayBaseUrl}/targets`;
-		if (this.totpSecret) {
-			const code = generateTotp(this.totpSecret);
-			targetsUrl += `?at=${encodeURIComponent(code)}`;
-		}
-		const res = await fetch(targetsUrl);
-		if (!res.ok) throw new Error(`Chii relay /targets returned HTTP ${res.status} ${res.statusText}`);
-		const body = await res.json();
-		const list = isObject$1(body) && Array.isArray(body.targets) ? body.targets : [];
-		let newestTargetId = null;
-		for (const item of list) {
-			if (!isObject$1(item) || typeof item.id !== "string") continue;
-			newestTargetId = item.id;
-		}
-		if (newestTargetId !== null && this.activeTargetId !== null && newestTargetId !== this.activeTargetId) {
-			const prevId = this.activeTargetId;
-			logInfo("page.detached", { prevTargetId: prevId });
-			this.evictTarget(prevId);
-		}
-		this.targets.clear();
-		for (const item of list) {
-			if (!isObject$1(item) || typeof item.id !== "string") continue;
-			if (item.id !== newestTargetId) continue;
-			this.targets.set(item.id, {
-				id: item.id,
-				title: typeof item.title === "string" ? item.title : "",
-				url: typeof item.url === "string" ? item.url : ""
-			});
-		}
-		if (newestTargetId !== null) this.activeTargetId = newestTargetId;
-		else this.activeTargetId = null;
-		const result = [...this.targets.values()];
-		if (newestTargetId !== null) this.emitter.emit("target:attached", result);
-		return result;
-	}
-	listTargets() {
-		return [...this.targets.values()];
-	}
-	/**
-	* Waits until at least one target matching `filterFn` is attached, then
-	* resolves with the full target list at that moment.
-	*
-	* Resolution happens on whichever comes first:
-	*   (a) a `'target:attached'` event from `refreshTargets()` (triggered by
-	*       the /targets poll finding a new target), OR
-	*   (b) a `'target:attached'` event from `handleMessage()` (triggered by
-	*       the first inbound CDP message from a target — confirms the relay
-	*       websocket has data from the phone, not just a target entry in the map).
-	*
-	* This dual-signal approach eliminates the polling race that previously
-	* caused `wait_for_attach` to resolve before the first CDP message arrived.
-	*
-	* Falls back to checking `listTargets()` every `pollIntervalMs` in case the
-	* EventEmitter is missed (defensive belt-and-suspenders).
-	*
-	* @param filterFn  - Predicate that the returned targets must satisfy.
-	* @param timeoutMs - Reject after this many ms (default 90 000).
-	* @param pollIntervalMs - Fallback poll interval (default 500ms).
-	*/
-	waitForFirstTarget(filterFn, timeoutMs = 9e4, pollIntervalMs = 500) {
-		const current = this.listTargets();
-		if (filterFn(current)) return Promise.resolve(current);
-		return new Promise((resolve, reject) => {
-			let settled = false;
-			let pollHandle = null;
-			const settle = (targets) => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timeoutHandle);
-				if (pollHandle !== null) {
-					clearInterval(pollHandle);
-					pollHandle = null;
-				}
-				this.emitter.off("target:attached", onAttach);
-				resolve(targets);
-			};
-			const onAttach = (targets) => {
-				if (filterFn(targets)) settle(targets);
-			};
-			const timeoutHandle = setTimeout(() => {
-				if (settled) return;
-				settled = true;
-				if (pollHandle !== null) {
-					clearInterval(pollHandle);
-					pollHandle = null;
-				}
-				this.emitter.off("target:attached", onAttach);
-				reject(/* @__PURE__ */ new Error(`waitForFirstTarget: 타임아웃 (${timeoutMs}ms) — 폰이 relay에 attach되지 않았습니다.`));
-			}, timeoutMs);
-			this.emitter.on("target:attached", onAttach);
-			pollHandle = setInterval(() => {
-				this.refreshTargets().then((targets) => {
-					if (filterFn(targets)) settle(targets);
-				}, () => {});
-			}, pollIntervalMs);
-		});
-	}
-	/**
-	* Timestamp (ms since epoch) of the most recent crash/destroy/detach event
-	* detected since the last `enableDomains()` call, or `null` if none.
-	*/
-	getLastCrashDetectedAt() {
-		return this.lastCrashDetectedAt;
-	}
-	/**
-	* Last-seen timestamp (ms since epoch) for a given target id, or `null` if
-	* the target is unknown / no message has been received from it yet.
-	*/
-	getTargetLastSeenAt(targetId) {
-		return this.targetLastSeenAt.get(targetId) ?? null;
-	}
-	/** Subscribe to target lifecycle events (crash / destroyed / detached). */
-	onLifecycle(listener) {
-		this.lifecycleListeners.push(listener);
-		return () => {
-			const idx = this.lifecycleListeners.indexOf(listener);
-			if (idx !== -1) this.lifecycleListeners.splice(idx, 1);
-		};
-	}
-	/**
-	* Connect a client websocket to the first attached target and enable Phase 1
-	* domains. Resolves once the socket is open and enable commands are sent.
-	*/
-	async enableDomains() {
-		if (this.ws && this.ws.readyState === WebSocket.OPEN) return;
-		if (this.enablingPromise) return this.enablingPromise;
-		this.enablingPromise = this._doEnableDomains().finally(() => {
-			this.enablingPromise = null;
-		});
-		return this.enablingPromise;
-	}
-	async _doEnableDomains() {
-		const target = (await this.refreshTargets())[0];
-		if (!target) throw new Error("No mini-app page attached to the Chii relay yet.");
-		let clientUrl = `${this.relayBaseUrl.replace(/^http/, "ws")}/client/${`devtools-mcp-${Date.now()}`}?target=${encodeURIComponent(target.id)}`;
-		if (this.totpSecret) {
-			const code = generateTotp(this.totpSecret);
-			clientUrl += `&at=${encodeURIComponent(code)}`;
-		}
-		const ws = new WebSocket(clientUrl);
-		this.ws = ws;
-		await new Promise((resolve, reject) => {
-			ws.once("open", () => resolve());
-			ws.once("error", (err) => reject(err));
-			ws.once("close", (code) => {
-				if (code === 4401) reject(/* @__PURE__ */ new Error("relay 인증(TOTP)이 거부됐습니다 (close 4401). 코드가 만료됐을 수 있습니다 — 재연결 시 새 코드가 발급됩니다."));
-			});
-		});
-		this.lastCrashDetectedAt = null;
-		this.targetLastSeenAt.clear();
-		this.connectionState = "connected";
-		ws.on("message", (data) => this.handleMessage(data.toString()));
-		ws.on("close", (code) => this.handleDisconnect(code === 4401 ? "relay 인증(TOTP)이 거부돼 연결이 종료됐습니다 (close 4401)" : "relay WebSocket 연결이 끊겼습니다"));
-		ws.on("error", (err) => this.handleDisconnect(`relay WebSocket 오류: ${err.message}`));
-		this.sendFireAndForget("Runtime.enable");
-		this.sendFireAndForget("Network.enable");
-		this.sendFireAndForget("DOM.enable");
-		this.sendFireAndForget("Page.enable");
-		this.sendFireAndForget("Inspector.enable");
-		this.sendFireAndForget("Target.setDiscoverTargets", { discover: true });
-		this.startHeartbeat(target.id);
-	}
-	/** Fire-and-forget CDP message (used for `*.enable`, no result awaited). */
-	sendFireAndForget(method, params = {}) {
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-		const id = this.nextCommandId++;
-		this.ws.send(JSON.stringify({
-			id,
-			method,
-			params
-		}));
-	}
-	/**
-	* Issue a CDP command and resolve with its result (Phase 2). Rejects on a CDP
-	* error frame or when no websocket is open (no page attached yet).
-	*/
-	send(method, params) {
-		return this.sendCommand(method, params ?? {});
-	}
-	/**
-	* Issue an arbitrary request→response command over the relay and resolve with
-	* its raw result. Both the typed CDP {@link send} and the AIT domain (Phase 3
-	* `AIT.*` methods, forwarded over the same Chii channel) build on this.
-	*
-	* Rejects immediately if the connection is disconnected (fail-fast — no
-	* auto-reconnect). Caller should re-run `list_pages` or `enableDomains` to
-	* reattach.
-	*
-	* Times out after `commandTimeoutMs` (default 30s, env
-	* `AIT_CDP_COMMAND_TIMEOUT_MS`). On timeout the pending entry is cleaned up
-	* and the promise rejects with a descriptive Korean error.
-	*/
-	sendCommand(method, params = {}) {
-		if (this.connectionState === "disconnected") return Promise.reject(/* @__PURE__ */ new Error(`relay에 연결되어 있지 않습니다 (${method}). list_pages로 attach 상태를 확인하고 enableDomains()로 재연결하세요.`));
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return Promise.reject(/* @__PURE__ */ new Error("No mini-app page attached to the Chii relay yet. Call enableDomains() first."));
-		const id = this.nextCommandId++;
-		const ws = this.ws;
-		const timeoutMs = this.commandTimeoutMs;
-		return new Promise((resolve, reject) => {
-			const handle = setTimeout(() => {
-				this.pending.delete(id);
-				reject(/* @__PURE__ */ new Error(`CDP 명령이 타임아웃됐습니다 (${method}, ${timeoutMs}ms). 폰 측 토스 앱이 백그라운드로 내려갔거나 미니앱이 unload됐을 수 있습니다. list_pages로 attach 상태를 확인하세요.`));
-			}, timeoutMs);
-			this.pending.set(id, {
-				resolve: (v) => {
-					clearTimeout(handle);
-					resolve(v);
-				},
-				reject: (e) => {
-					clearTimeout(handle);
-					reject(e);
-				}
-			});
-			ws.send(JSON.stringify({
-				id,
-				method,
-				params
-			}));
-		});
-	}
-	/**
-	* Called on WebSocket `close` or `error` after a successful connection.
-	* Rejects all pending commands and marks the connection as disconnected so
-	* subsequent `sendCommand` calls fail fast (no auto-reconnect).
-	*/
-	handleDisconnect(reason) {
-		if (this.connectionState === "disconnected") return;
-		this.connectionState = "disconnected";
-		this.ws = null;
-		this.stopHeartbeat();
-		const err = /* @__PURE__ */ new Error(`${reason}. list_pages로 attach 상태를 확인하고 enableDomains()로 재연결하세요.`);
-		for (const waiter of this.pending.values()) waiter.reject(err);
-		this.pending.clear();
-	}
-	/**
-	* Evict a previously active target under the single-attach model.
-	* Rejects pending commands with a 'replaced-by-new-attach' reason and emits
-	* a 'replaced' lifecycle event. Does NOT clear all targets — only the specific
-	* targetId. The caller is responsible for rebuilding the targets map afterwards.
-	*
-	* The error message uses 'replaced-by-new-attach' so test assertions can match it.
-	*/
-	evictTarget(targetId) {
-		const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.targets.delete(targetId);
-		this.targetLastSeenAt.delete(targetId);
-		const err = /* @__PURE__ */ new Error(`[ait-debug] replaced-by-new-attach — 이전 page 세션이 새 attach로 교체됐습니다 (targetId=${targetId}). list_pages로 현재 attach 상태를 확인하세요.`);
-		for (const waiter of this.pending.values()) waiter.reject(err);
-		this.pending.clear();
-		const event = {
-			kind: "replaced",
-			targetId,
-			detectedAt
-		};
-		for (const listener of this.lifecycleListeners) try {
-			listener(event);
-		} catch {}
-	}
-	/**
-	* Handle a page-level crash or target destruction event.
-	* Removes the target from the in-memory map, rejects all pending commands,
-	* and emits a lifecycle event.
-	*
-	* @param kind - Event kind: 'crashed' | 'destroyed' | 'detached'
-	* @param targetId - The target ID from the event params (may be null for
-	*   Inspector.targetCrashed which has no targetId in the params).
-	*/
-	handleTargetGone(kind, targetId) {
-		const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.lastCrashDetectedAt = Date.now();
-		if (targetId !== null) {
-			this.targets.delete(targetId);
-			this.targetLastSeenAt.delete(targetId);
-			if (this.activeTargetId === targetId) this.activeTargetId = null;
-		} else {
-			this.targets.clear();
-			this.targetLastSeenAt.clear();
-			this.activeTargetId = null;
-		}
-		const err = /* @__PURE__ */ new Error(`[ait-debug] ${kind === "crashed" ? "page crash (Inspector.targetCrashed)" : kind === "destroyed" ? "target 종료 (Target.targetDestroyed)" : "target detach (Target.detachedFromTarget)"} 감지됨 — relay에서 제거됐습니다. 새 attach가 필요합니다 (list_pages로 확인 → enableDomains()로 재연결).`);
-		for (const waiter of this.pending.values()) waiter.reject(err);
-		this.pending.clear();
-		const event = {
-			kind,
-			targetId,
-			detectedAt
-		};
-		for (const listener of this.lifecycleListeners) try {
-			listener(event);
-		} catch {}
-	}
-	/**
-	* Start the optional CDP heartbeat loop.
-	*
-	* When `AIT_CDP_HEARTBEAT_MS` is set to a positive integer, every interval
-	* we send `Runtime.evaluate({expression: '1'})` to each active target. If
-	* the command times out (2 s hard deadline) or errors, we treat the target
-	* as dead and call `handleTargetGone`.
-	*
-	* This is a zombie-detector fallback: cloudflared keeps-alive the tunnel ws
-	* even when the phone app has crashed, so the ws-level disconnect (#252) won't
-	* fire. The heartbeat catches this gap.
-	*
-	* Default: OFF. Only activates when `AIT_CDP_HEARTBEAT_MS` is set.
-	*/
-	startHeartbeat(initialTargetId) {
-		this.stopHeartbeat();
-		const envMs = process.env.AIT_CDP_HEARTBEAT_MS ? Number(process.env.AIT_CDP_HEARTBEAT_MS) : void 0;
-		if (envMs === void 0 || !Number.isFinite(envMs) || envMs <= 0) return;
-		const PING_TIMEOUT_MS = 2e3;
-		this.heartbeatHandle = setInterval(() => {
-			const targetIds = this.targets.size > 0 ? [...this.targets.keys()] : [initialTargetId];
-			for (const targetId of targetIds) {
-				const pingPromise = this.sendCommand("Runtime.evaluate", {
-					expression: "1",
-					returnByValue: true,
-					timeout: PING_TIMEOUT_MS
-				});
-				const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("heartbeat timeout")), PING_TIMEOUT_MS + 500));
-				Promise.race([pingPromise, timeoutPromise]).catch(() => {
-					if (this.targets.has(targetId)) this.handleTargetGone("destroyed", targetId);
-				});
-			}
-		}, envMs);
-	}
-	stopHeartbeat() {
-		if (this.heartbeatHandle !== null) {
-			clearInterval(this.heartbeatHandle);
-			this.heartbeatHandle = null;
-		}
-	}
-	handleMessage(raw) {
-		const message = parseInbound$1(raw);
-		if (!message) return;
-		if (typeof message.id === "number" && this.pending.has(message.id)) {
-			const waiter = this.pending.get(message.id);
-			this.pending.delete(message.id);
-			if (waiter) if (message.error) waiter.reject(new Error(message.error.message));
-			else waiter.resolve(message.result);
-			return;
-		}
-		const now = Date.now();
-		let firstMessageSeen = false;
-		for (const targetId of this.targets.keys()) {
-			if (!this.targetLastSeenAt.has(targetId)) firstMessageSeen = true;
-			this.targetLastSeenAt.set(targetId, now);
-		}
-		if (firstMessageSeen && this.targets.size > 0) this.emitter.emit("target:attached", [...this.targets.values()]);
-		if (typeof message.method !== "string") return;
-		if (message.method === "Inspector.targetCrashed") {
-			this.handleTargetGone("crashed", null);
-			return;
-		}
-		if (message.method === "Target.targetDestroyed") {
-			const targetId = isObject$1(message.params) && typeof message.params.targetId === "string" ? message.params.targetId : null;
-			this.handleTargetGone("destroyed", targetId);
-			return;
-		}
-		if (message.method === "Target.detachedFromTarget") {
-			const targetId = isObject$1(message.params) && typeof message.params.targetId === "string" ? message.params.targetId : null;
-			this.handleTargetGone("detached", targetId);
-			return;
-		}
-		if (!this.buffers.has(message.method)) return;
-		const event = message.method;
-		const buffer = this.buffers.get(event);
-		if (!buffer) return;
-		buffer.push(message.params);
-		const cap = event === "Runtime.exceptionThrown" ? EXCEPTION_BUFFER_SIZE : this.bufferSize;
-		if (buffer.length > cap) buffer.shift();
-		this.emitter.emit(event, message.params);
-	}
-	getBufferedEvents(event) {
-		return this.buffers.get(event) ?? [];
-	}
-	on(event, listener) {
-		this.emitter.on(event, listener);
-		return () => this.emitter.off(event, listener);
-	}
-	/** Close the relay client websocket and reject any in-flight commands. */
-	close() {
-		const ws = this.ws;
-		this.stopHeartbeat();
-		this.handleDisconnect("Chii relay connection closed");
-		ws?.close();
-	}
-};
-//#endregion
-//#region src/mcp/chii-relay.ts
-/**
-* Boots the local Chii relay server.
-*
-* Chii (liriliri/chii) is a chobitsu-based CDP relay that lets non-Chrome
-* WebViews (iOS WKWebView / Android WebView — i.e. the Toss app) expose CDP.
-* The relay accepts a `target` websocket from the phone's injected `target.js`
-* and `client` websockets from CDP frontends (our MCP connection).
-*
-* Node-only: `chii` pulls in Koa + ws. Never bundled into the browser/in-app
-* entries.
-*
-* TOTP auth (relay-side, authoritative gate):
-*   When `verifyAuth` is provided, this module gates both inbound surfaces:
-*
-*   - HTTP 'request': a listener registered BEFORE `chii.start({server})`.
-*     Node's `http.Server` calls listeners in registration order; the first
-*     to call `res.end()` wins. Invalid auth → 401 + CORS header + a tiny
-*     JSON body (`{"error":"totp-rejected"}`) so a cross-origin script
-*     `fetch()` probe can READ the status (issue #478). Valid auth → return
-*     without side-effect (chii's Koa handler serves it).
-*
-*   - WS 'upgrade': after `chii.start()` has registered chii's own upgrade
-*     listener, we take over the upgrade chain (remove chii's listeners,
-*     re-dispatch manually). Invalid auth → accept-then-close: complete the
-*     handshake via a `noServer` WebSocketServer, then immediately close
-*     with code 4401 reason 'totp-rejected' (issue #478). A raw 401 +
-*     `socket.destroy()` only ever surfaced as close code 1006 in the
-*     browser — indistinguishable from a tunnel failure, which left the
-*     env-2 phone UI silent. The explicit dispatch (not listener ordering)
-*     is what keeps chii away from rejected sockets: accept-then-close
-*     leaves the socket alive, so an order-based early-return would let
-*     chii's later listener complete a SECOND handshake on the same socket
-*     — an auth bypass. Valid auth → forward to chii's captured listeners.
-*
-* TOTP code transports (issue #466) — two equivalent ways to carry the code:
-*   1. Query param `at=<code>` — used by the daemon-side `/client` connection
-*      (`chii-connection.ts` appends it; it holds the secret).
-*   2. Path prefix `/at/<code>/…` — used by the phone-side target. Chii's
-*      stock `target.js` derives its WS endpoint from the script `src`
-*      (`scriptEl.src.replace('target.js','')`), so the only way for the
-*      phone to carry a code is to embed it in the script URL path. The
-*      in-app attach injects `https://<host>/at/<code>/target.js`; both the
-*      script fetch and the derived `wss://<host>/at/<code>/target/<id>` WS
-*      dial then carry the prefix. The listeners below rewrite the prefix
-*      into the query form (`rewriteAtPathPrefix`) and MUTATE `req.url`
-*      before chii's own handlers (registered later) parse it — chii only
-*      ever sees the stripped URL.
-*
-* Threat model: "URL leak" — someone obtains the tunnel URL (Slack paste, QR
-*   screenshot, shoulder-surfing) but does not have the shared TOTP secret.
-*   Rotating 6-digit code makes the URL stale after 30 s.
-*   A determined attacker who extracts the secret from the dogfood bundle can
-*   still compute valid codes; that is out of scope (see umbrella CLAUDE.md §4).
-*
-* SECRET-HANDLING: The secret value and computed TOTP codes MUST NOT appear
-*   in any log, error message, or process output. `verifyAuth` is a black-box
-*   predicate from the caller's perspective; this module only forwards pass/fail.
-*/
-const require$1 = createRequire(import.meta.url);
-/**
-* WS keepalive ping interval (ms).
-*
-* Cloudflare proxied connections are dropped after ~100 s of no traffic.
-* 45 s comfortably fits inside that window and lets both the phone-target leg
-* and the daemon-client leg survive idle CDP sessions.
-*/
-const DEFAULT_KEEPALIVE_INTERVAL_MS = 45e3;
-/**
-* Loads chii's internal WebSocketServer class and returns it together with a
-* flag indicating whether the real class was found.
-*
-* Returns `null` if the internal path is not resolvable (future chii release
-* changes the layout) — callers skip keepalive gracefully.
-*/
-function tryLoadChiiWssClass() {
-	try {
-		const mod = require$1("chii/server/lib/WebSocketServer");
-		if (typeof mod === "function") return mod;
-	} catch {}
-	return null;
-}
-/**
-* Calls `chii.start()` and returns the chii `WebSocketServer` instance that
-* was constructed during the call.
-*
-* How: `chii/server/index.js`'s `start()` creates `new WebSocketServer()`
-* where `WebSocketServer` is captured from `require('./lib/WebSocketServer')`
-* at module load time. The class reference is stable, so we can temporarily
-* patch `ChiiWssClass.prototype.start` — which runs *on the instance* —
-* to record `this` before the original `start` runs.
-*
-* The patch is installed before `chii.start()` and removed (via `finally`)
-* immediately after, so concurrent `startChiiRelay` calls nest correctly: each
-* call's patch overrides the previous in the prototype chain for the duration
-* of its own `chii.start()` call, restoring the prior descriptor on exit.
-*
-* If `ChiiWssClass` is null (internal path changed in a future chii release),
-* `chii.start()` runs unpatched and the function returns null — callers skip
-* keepalive gracefully without affecting relay correctness.
-*/
-async function startChiiWithCapture(chii, startOptions, ChiiWssClass) {
-	if (ChiiWssClass === null) {
-		await chii.start(startOptions);
-		return null;
-	}
-	let captured = null;
-	const proto = ChiiWssClass.prototype;
-	const originalStart = proto.start;
-	proto.start = function(server) {
-		captured = this;
-		return originalStart.call(this, server);
-	};
-	try {
-		await chii.start(startOptions);
-	} finally {
-		proto.start = originalStart;
-	}
-	return captured;
-}
-function loadChiiServer() {
-	const mod = require$1("chii");
-	if (typeof mod === "object" && mod !== null && "start" in mod && typeof mod.start === "function") return mod;
-	throw new Error("chii server module did not expose start()");
-}
-/**
-* Rewrites a `/at/<code>/…` path-prefixed request URL into the equivalent
-* query-based form, e.g.:
-*
-*   `/at/123456/target.js`        → `/target.js?at=123456`
-*   `/at/123456/target/x?url=u`   → `/target/x?url=u&at=123456`
-*   `/at/123456/`                 → `/?at=123456`
-*
-* Returns `null` when the URL does not carry the prefix (including an empty
-* code segment) — callers fall back to the unmodified URL and the existing
-* query-based auth path.
-*
-* Pure string surgery — this function knows nothing about secrets or code
-* validity; verification stays inside the caller-provided `verifyAuth`
-* predicate (which parses the query). The raw path segment is appended
-* verbatim to the query: both path segments and query values are
-* percent-decoded exactly once by their consumers, so no re-encoding is
-* needed (TOTP codes are 6 digits and never percent-encoded in practice).
-*/
-function rewriteAtPathPrefix(rawUrl) {
-	const match = /^\/at\/([^/?]+)(\/[^?]*)?(\?.*)?$/.exec(rawUrl);
-	if (match === null) return null;
-	const code = match[1];
-	const path = match[2] === void 0 || match[2] === "" ? "/" : match[2];
-	const query = match[3] ?? "";
-	return `${path}${query}${query === "" ? "?" : "&"}at=${code}`;
-}
-/**
-* Starts the Chii relay and resolves once listening.
-*
-* Default port is 0 (OS-assigned). With port 0 the OS picks a free ephemeral
-* port on every start, so a stale cloudflared orphan holding any particular
-* port cannot cause EADDRINUSE. The resolved `ChiiRelay.port` and `baseUrl`
-* always reflect the actual bound port.
-*
-* chii.start() is called with `server` (our pre-created httpServer) BEFORE
-* httpServer.listen(). This is intentional: chii attaches its Koa handler and
-* WS upgrade listener to the server object, but the actual TCP bind is
-* performed by our httpServer.listen() call below. The `port`/`domain` values
-* passed to chii.start() are used for display/banner purposes inside chii and
-* do not affect which port the server binds. The connection path (clients
-* connecting to `relay.baseUrl`) always uses the post-listen confirmed port.
-*/
-async function startChiiRelay(options = {}) {
-	const requestedPort = options.port ?? 0;
-	const host = options.host ?? "127.0.0.1";
-	const { verifyAuth, onAuthReject } = options;
-	const keepaliveIntervalMs = options.keepaliveIntervalMs !== void 0 ? options.keepaliveIntervalMs : DEFAULT_KEEPALIVE_INTERVAL_MS;
-	const httpServer = createServer();
-	const notifyAuthReject = (kind) => {
-		if (onAuthReject === void 0) return;
-		try {
-			onAuthReject({ kind });
-		} catch {}
-	};
-	if (verifyAuth) httpServer.on("request", (req, res) => {
-		const rewritten = rewriteAtPathPrefix(req.url ?? "");
-		if (rewritten !== null) {
-			req.url = rewritten;
-			if (!verifyAuth(req)) {
-				res.statusCode = 401;
-				res.setHeader("Access-Control-Allow-Origin", "*");
-				res.setHeader("Content-Type", "application/json");
-				res.end(JSON.stringify({ error: RELAY_AUTH_REJECT_REASON }));
-				notifyAuthReject("http-request");
-			}
-			return;
-		}
-		const pathname = (req.url ?? "").split("?")[0];
-		if (pathname === "/targets" || pathname === "/targets/") {
-			if (!verifyAuth(req)) {
-				res.statusCode = 401;
-				res.setHeader("Access-Control-Allow-Origin", "*");
-				res.setHeader("Content-Type", "application/json");
-				res.end(JSON.stringify({ error: RELAY_AUTH_REJECT_REASON }));
-				notifyAuthReject("http-request");
-				return;
-			}
-			return;
-		}
-	});
-	const chiiWssClass = keepaliveIntervalMs > 0 ? tryLoadChiiWssClass() : null;
-	const capturedChiiWss = await startChiiWithCapture(loadChiiServer(), {
-		server: httpServer,
-		domain: `${host}:${requestedPort}`,
-		port: requestedPort
-	}, chiiWssClass);
-	if (verifyAuth) {
-		const chiiUpgradeListeners = httpServer.listeners("upgrade");
-		httpServer.removeAllListeners("upgrade");
-		const rejectWss = new WebSocketServer({ noServer: true });
-		httpServer.on("upgrade", (req, socket, head) => {
-			const rewritten = rewriteAtPathPrefix(req.url ?? "");
-			if (rewritten !== null) req.url = rewritten;
-			if (!verifyAuth(req)) {
-				rejectWss.handleUpgrade(req, socket, head, (ws) => {
-					ws.close(RELAY_AUTH_REJECT_CLOSE_CODE, RELAY_AUTH_REJECT_REASON);
-				});
-				notifyAuthReject("ws-upgrade");
-				return;
-			}
-			for (const listener of chiiUpgradeListeners) listener(req, socket, head);
-		});
-	}
-	const actualPort = await new Promise((resolve, reject) => {
-		httpServer.once("error", reject);
-		httpServer.listen(requestedPort, host, () => {
-			httpServer.off("error", reject);
-			resolve(httpServer.address().port);
-		});
-	});
-	let keepaliveHandle = null;
-	if (keepaliveIntervalMs > 0 && capturedChiiWss !== null) {
-		const chiiWss = capturedChiiWss;
-		keepaliveHandle = setInterval(() => {
-			for (const client of chiiWss._wss.clients) if (client.readyState === 1) client.ping();
-		}, keepaliveIntervalMs);
-	}
-	return {
-		port: actualPort,
-		baseUrl: `http://${host}:${actualPort}`,
-		close: () => new Promise((resolve) => {
-			if (keepaliveHandle !== null) {
-				clearInterval(keepaliveHandle);
-				keepaliveHandle = null;
-			}
-			httpServer.close(() => resolve());
-		})
-	};
-}
-//#endregion
-//#region src/mcp/devtools-opener.ts
-/**
-* Assembles the Chii self-hosted DevTools inspector URL for a given relay
-* and target.
-*
-* Chii serves its own DevTools frontend at
-* `<relayHttpBaseUrl>/front_end/chii_app.html`. The `ws=` (plain HTTP relay)
-* or `wss=` (HTTPS relay) query parameter is a URL-encoded string of the form
-* `<relay-host>/client/<uuid>?target=<id>&at=<totp>` — the same format used
-* by Chii's own target list page (derived from `chii/public/index.js`).
-*
-* The `at=` TOTP code is minted at call time via `mintTotp()`.  It is valid
-* for ~3 minutes (relay gate accepts ±RELAY_VERIFY_SKEW_STEPS=6 steps =
-* 180–210 s).  The developer must open the returned URL within that window.
-* If the window expires before the browser connects, the relay will reject the
-* WebSocket upgrade with close code 4401.
-*
-* FAIL-CLOSED (issue #509): `mintTotp` is REQUIRED.  When omitted (i.e.
-* `undefined`), this function returns `null` — the caller must treat `null` as
-* "inspector not yet available" and show a waiting hint instead of a broken
-* link. Relay sessions gate every WS upgrade with TOTP (#452), so a URL built
-* without `at=` would be rejected with WS 4401 immediately — there is no
-* non-TOTP relay path in production. Returning `null` surfaces this cleanly as
-* a "TOTP not yet configured" state rather than silently producing a URL that
-* will always fail at the WS handshake.
-*
-* SECRET-HANDLING: `mintTotp` returns a code, not a secret. The code is
-* embedded in the `wss=` parameter (inside the `at=` param) of the returned
-* URL. Callers MUST NOT log the returned URL to stdout (stderr is OK — it is
-* the intended fallback surface for the developer to copy the URL).
-*
-* @param relayHttpBaseUrl - Local HTTP base URL of the Chii relay, e.g.
-*   `http://127.0.0.1:9100`. No trailing slash.
-* @param targetId - Chii target id (from `GET <relay>/targets`).
-* @param mintTotp - Function that returns a fresh 6-digit TOTP code string.
-*   Called at most once. **Required** — when `undefined`, the function returns
-*   `null` (fail-closed: no `at=` param means the relay WS gate rejects the
-*   handshake, so a null result is safer than a URL that always 404s).
-* @param panel - Initial panel. Defaults to `"console"`.
-*
-* @returns The inspector URL string, or `null` when `mintTotp` is absent.
-*
-* @example
-* buildChiiInspectorUrl(
-*   'http://127.0.0.1:9100',
-*   'abc123',
-*   () => generateTotp(secret),
-* )
-* // → 'http://127.0.0.1:9100/front_end/chii_app.html?ws=127.0.0.1%3A9100%2Fclient%2F<uuid>%3Ftarget%3Dabc123%26at%3D<code>'
-*/
-function buildChiiInspectorUrl(relayHttpBaseUrl, targetId, mintTotp, panel = "console") {
-	if (!mintTotp) return null;
-	let relayHost;
-	let wsParamName;
-	try {
-		const parsed = new URL(relayHttpBaseUrl);
-		relayHost = parsed.host;
-		wsParamName = parsed.protocol === "https:" ? "wss" : "ws";
-	} catch {
-		relayHost = relayHttpBaseUrl.replace(/^https?:\/\//i, "");
-		wsParamName = /^https:/i.test(relayHttpBaseUrl) ? "wss" : "ws";
-	}
-	const clientId = `devtools-opener-${Date.now().toString(36)}`;
-	const code = mintTotp();
-	const wsPath = `${relayHost}/client/${clientId}?target=${encodeURIComponent(targetId)}&at=${encodeURIComponent(code)}`;
-	const params = new URLSearchParams({
-		[wsParamName]: wsPath,
-		panel
-	});
-	return `${relayHttpBaseUrl.replace(/\/$/, "")}/front_end/chii_app.html?${params.toString()}`;
-}
-/**
-* Returns `true` when auto-open is **disabled**.
-*
-* Default (env var absent or any value other than `"1"`) is **disabled** —
-* the developer uses the "디버그 툴 열기" button on the /attach or dashboard
-* page instead. Set `AIT_AUTO_DEVTOOLS=1` to restore the old automatic
-* browser-open behaviour on device attach.
-*
-* `AIT_AUTO_DEVTOOLS=0` retains its explicit opt-out meaning for backward
-* compatibility (same effect as absent).
-*/
-function isAutoDevtoolsDisabled() {
-	return process.env.AIT_AUTO_DEVTOOLS !== "1";
-}
-/**
-* Opens the given URL in the OS default browser using a platform-appropriate
-* command. Returns `true` on success.
-*
-* Failures are silent from the caller's perspective — the caller should log
-* the URL to stderr as a fallback before calling this function.
-*/
-function openUrlInBrowser(url) {
-	if (process.env.AIT_AUTO_DEVTOOLS_TEST_SKIP_SPAWN === "1") return false;
-	const { spawnSync } = __require("node:child_process");
-	const platform = process.platform;
-	let candidates;
-	if (platform === "darwin") candidates = [{
-		cmd: "open",
-		args: [url]
-	}];
-	else if (platform === "win32") candidates = [{
-		cmd: "cmd",
-		args: [
-			"/c",
-			"start",
-			"",
-			url
-		]
-	}];
-	else candidates = [
-		{
-			cmd: "xdg-open",
-			args: [url]
-		},
-		{
-			cmd: "sensible-browser",
-			args: [url]
-		},
-		{
-			cmd: "x-www-browser",
-			args: [url]
-		}
-	];
-	for (const { cmd, args } of candidates) try {
-		const result = spawnSync(cmd, args, {
-			encoding: "utf8",
-			timeout: 5e3
-		});
-		if (!result.error && result.status === 0) return true;
-	} catch {}
-	return false;
-}
-/**
-* Manages auto-opening Chrome DevTools on every NEW target attach (issue #530).
-*
-* Create one instance per `runDebugServer` call and pass its `open()` method
-* as the `onAttach` callback to the attach watcher (via `DualConnectionRouter`).
-*
-* The open fires for each NEW `targetId` — subsequent notifications for the
-* same target are de-duplicated. Re-attach with a fresh targetId (e.g. after
-* page reload on the phone) fires a new open. The URL opened is the stable
-* `/inspector` endpoint (issue #530) when `inspectorStableUrl` is provided —
-* it mints a fresh TOTP at click time so there is no expiry race. Falls back to
-* building a direct `front_end/chii_app.html?wss=…` URL when
-* `inspectorStableUrl` is absent.
-*
-* Opt-out and mock-environment guard are checked at call time.
-*/
-var AutoDevtoolsOpener = class {
-	/** Per-target de-dupe set (issue #530 — target-unit guard replaces once-per-daemon). */
-	_openedTargets = /* @__PURE__ */ new Set();
-	/**
-	* Attempts to auto-open Chii DevTools in the developer's browser.
-	*
-	* Opens when:
-	*   - `options.targetId` is a NEW target (not yet in `_openedTargets`).
-	*
-	* No-op when any of the following conditions hold:
-	*   1. `targetId` has already been opened (`_openedTargets` has it).
-	*   2. `AIT_AUTO_DEVTOOLS=0` opt-out is set.
-	*   3. `options.env` is `mock` (env 1 — F12 is already available).
-	*   4. `options.targetId` is null/undefined/empty (no page attached yet).
-	*   5. Neither `inspectorStableUrl` nor `relayHttpBaseUrl` is available.
-	*
-	* When `inspectorStableUrl` is provided (issue #530 stable URL): opens
-	* `http://127.0.0.1:<port>/inspector` directly and writes it to stderr.
-	* The URL contains no tunnel host or TOTP code — safe to log anywhere.
-	*
-	* Legacy path (no `inspectorStableUrl`): builds a direct
-	* `<relay-base>/front_end/chii_app.html?wss=…` URL from `relayHttpBaseUrl`
-	* + `mintTotp`, writes to stderr. TOTP expiry caveat applies (~3 min window).
-	*
-	* SECRET-HANDLING: direct inspector URL (written to stderr) may contain relay
-	* host and TOTP code. Stable URL is secret-free. Neither must go to stdout or
-	* persistent logs.
-	*/
-	open(options) {
-		if (isAutoDevtoolsDisabled()) return;
-		if (options.env === "mock") return;
-		if (!options.targetId) return;
-		const targetId = options.targetId;
-		if (this._openedTargets.has(targetId)) return;
-		if (options.inspectorStableUrl) {
-			this._openedTargets.add(targetId);
-			const stableUrl = options.inspectorStableUrl;
-			process.stderr.write(`[ait-debug] 기기가 연결됐습니다.
-[ait-debug] QR 페이지 또는 대시보드(${stableUrl.replace("/inspector", "")})의 "디버그 툴 열기" 버튼을 눌러 DevTools를 여세요.\n[ait-debug] (AIT_AUTO_DEVTOOLS=1 로 설정하면 연결 시 자동으로 열립니다)
-`);
-			if (!openUrlInBrowser(stableUrl)) process.stderr.write(`[ait-debug] 브라우저 자동 열기 실패 — ${stableUrl} 을 브라우저에서 직접 여세요.\n`);
-			return;
-		}
-		if (!options.relayHttpBaseUrl) return;
-		this._openedTargets.add(targetId);
-		const inspectorUrl = buildChiiInspectorUrl(options.relayHttpBaseUrl, targetId, options.mintTotp);
-		if (inspectorUrl === null) {
-			process.stderr.write("[ait-debug] 기기가 연결됐습니다 — TOTP secret 미설정으로 인스펙터 URL을 생성할 수 없습니다.\n[ait-debug] relay 세션은 AIT_DEBUG_TOTP_SECRET 설정이 필요합니다.\n");
-			return;
-		}
-		process.stderr.write(`[ait-debug] 기기가 연결됐습니다.
-[ait-debug] DevTools URL: ${inspectorUrl}\n[ait-debug] (AIT_AUTO_DEVTOOLS=1 로 설정하면 연결 시 자동으로 열립니다)
-[ait-debug] 주의: URL의 at= 코드는 ~3분 안에서만 유효합니다.
-`);
-		if (!openUrlInBrowser(inspectorUrl)) process.stderr.write("[ait-debug] 브라우저 자동 열기 실패 — 위 URL을 브라우저에서 직접 여세요.\n");
-	}
-	/**
-	* Returns `true` if `open()` has been called for at least one target.
-	* (Replaces the old once-per-session `_opened` flag; kept for interface
-	* compatibility with tests that read `opener.opened`.)
-	*/
-	get opened() {
-		return this._openedTargets.size > 0;
-	}
-	/** Returns the set of target IDs that have already been auto-opened. */
-	get openedTargets() {
-		return this._openedTargets;
-	}
-};
-//#endregion
-//#region src/mcp/envelope.ts
-/**
-* Returns `true` when `AIT_MCP_COMPAT=chrome-devtools` is set, which bypasses
-* envelope wrapping and returns raw payloads (0.1.x back-compat).
-*/
-function isCompatMode() {
-	return process.env.AIT_MCP_COMPAT === "chrome-devtools";
-}
-/**
-* Maps `McpEnvironment` to `EnvelopeEnv`. These are now the same 3-value
-* union (`mock | relay-dev | relay-mobile`; `relay-live` removed in #665),
-* so this is identity — kept as a named export for surface stability if
-* envelope env diverges in the future.
-*/
-function toEnvelopeEnv(env) {
-	return env;
-}
-/**
-* Wraps `data` in a `ToolEnvelope<T>` **unless** compat mode is active, in
-* which case `data` is returned as-is.
-*
-* Use this at every tool call-site in `debug-server.ts` and `server.ts`.
-*
-* @example
-* ```ts
-* return jsonResult(wrapEnvelope(listPages(connection, tunnel), {
-*   tool: 'list_pages',
-*   env: resolveEnvironment(),
-*   attached: connection.listTargets().length > 0,
-* }));
-* ```
-*/
-function wrapEnvelope(data, ctx) {
-	if (isCompatMode()) return data;
-	return {
-		ok: true,
-		data,
-		meta: {
-			tool: ctx.tool,
-			env: toEnvelopeEnv(ctx.env),
-			attached: ctx.attached,
-			contentType: ctx.contentType ?? "json"
-		}
-	};
-}
-//#endregion
-//#region src/mcp/local-connection.ts
-/**
-* Local-browser `CdpConnection` — attaches directly to a Chromium instance
-* started with `--remote-debugging-port=<port>`.
-*
-* Topology (local debug mode, env 1):
-*   Chromium  --CDP WS-->  this connection  <--stdio-->  MCP host
-*
-* The core insight: local Chromium and the phone's Toss WebView both speak
-* Chrome DevTools Protocol. The only difference is the attach strategy — how
-* you reach the CDP endpoint. Here we hit the Chromium DevTools HTTP endpoint
-* (`GET /json`) to discover per-target websocket URLs, then connect directly.
-* The Chii relay (env 2/3) uses `GET /targets` + `/client/<id>?target=<id>`.
-* Every tool (list_console_messages, get_dom_document, take_screenshot, …)
-* reads only the `CdpConnection` interface and works unchanged on both.
-*
-* Node-only: imports `ws`. Never bundled into the browser/in-app entries.
-*/
-/** Max events retained per domain ring buffer. */
-const DEFAULT_BUFFER_SIZE = 500;
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-function parseInbound(raw) {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return null;
-	}
-	if (!isObject(parsed)) return null;
-	const message = {};
-	if (typeof parsed.id === "number") message.id = parsed.id;
-	if (typeof parsed.method === "string") message.method = parsed.method;
-	if ("params" in parsed) message.params = parsed.params;
-	if ("result" in parsed) message.result = parsed.result;
-	if (isObject(parsed.error) && typeof parsed.error.message === "string") message.error = { message: parsed.error.message };
-	return message;
-}
-const PHASE_1_EVENTS = [
-	"Runtime.consoleAPICalled",
-	"Network.requestWillBeSent",
-	"Network.responseReceived"
-];
-/**
-* `CdpConnection` that attaches directly to a local Chromium over its built-in
-* CDP websocket. Mirrors `ChiiCdpConnection`'s buffering/command-routing/event
-* logic — same `parseInbound`, ring-buffer, `pending` map patterns — but the
-* attach strategy differs:
-*
-*   Chii relay: `GET /targets` → open `/client/<id>?target=<id>` WS
-*   Local CDP:  `GET /json`    → open `webSocketDebuggerUrl` per target directly
-*
-* Target selection: first `type === 'page'` target whose URL is not
-* `about:blank`, `about:newtab`, or a devtools:// URL.
-*/
-var LocalCdpConnection = class {
-	/** Authoritative connection kind (issue #348) — local Chromium CDP. */
-	kind = "local";
-	devtoolsHttpUrl;
-	bufferSize;
-	emitter = new EventEmitter();
-	buffers = /* @__PURE__ */ new Map();
-	targets = /* @__PURE__ */ new Map();
-	ws = null;
-	nextCommandId = 1;
-	/** In-flight enableDomains() promise — concurrent callers share it. */
-	enablingPromise = null;
-	/** Pending request→response commands keyed by CDP message id. */
-	pending = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.devtoolsHttpUrl = options.devtoolsHttpUrl.replace(/\/$/, "");
-		this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER_SIZE;
-		for (const event of PHASE_1_EVENTS) this.buffers.set(event, []);
-		this.emitter.setMaxListeners(0);
-	}
-	/**
-	* Fetch the target list from the Chromium DevTools `/json` (or `/json/list`)
-	* endpoint and pick the first non-blank page target.
-	*
-	* Returns the selected target's `webSocketDebuggerUrl` alongside the
-	* normalized `CdpTarget` list (all page targets visible to the server).
-	*/
-	async fetchTargets() {
-		const res = await fetch(`${this.devtoolsHttpUrl}/json`);
-		if (!res.ok) throw new Error(`Chromium DevTools /json returned HTTP ${res.status} ${res.statusText}. Is the browser running with --remote-debugging-port?`);
-		const body = await res.json();
-		const list = Array.isArray(body) ? body : [];
-		this.targets.clear();
-		let selected = null;
-		for (const item of list) {
-			if (!isObject(item) || typeof item.id !== "string") continue;
-			const cdpTarget = {
-				id: item.id,
-				title: typeof item.title === "string" ? item.title : "",
-				url: typeof item.url === "string" ? item.url : ""
-			};
-			this.targets.set(item.id, cdpTarget);
-			if (selected === null && item.type === "page" && typeof item.webSocketDebuggerUrl === "string" && !isBlankOrDevtoolsUrl(item.url)) selected = item;
-		}
-		return {
-			selected,
-			all: [...this.targets.values()]
-		};
-	}
-	listTargets() {
-		return [...this.targets.values()];
-	}
-	/**
-	* Discover the target, open a direct CDP websocket to its
-	* `webSocketDebuggerUrl`, and enable Phase 1+2 domains. Resolves once the
-	* socket is open and domain-enable commands are sent. Idempotent — concurrent
-	* callers share the in-flight promise.
-	*/
-	async enableDomains() {
-		if (this.ws && this.ws.readyState === WebSocket.OPEN) return;
-		if (this.enablingPromise) return this.enablingPromise;
-		this.enablingPromise = this._doEnableDomains().finally(() => {
-			this.enablingPromise = null;
-		});
-		return this.enablingPromise;
-	}
-	async _doEnableDomains() {
-		const { selected } = await this.fetchTargets();
-		if (!selected) throw new Error("No suitable page target found in the local Chromium instance. Ensure the browser has a non-blank page open and was started with --remote-debugging-port matching devtoolsHttpUrl.");
-		const wsUrl = selected.webSocketDebuggerUrl;
-		const ws = new WebSocket(wsUrl);
-		this.ws = ws;
-		await new Promise((resolve, reject) => {
-			ws.once("open", () => resolve());
-			ws.once("error", (err) => reject(err));
-		});
-		ws.on("message", (data) => this.handleMessage(data.toString()));
-		this.sendFireAndForget("Runtime.enable");
-		this.sendFireAndForget("Network.enable");
-		this.sendFireAndForget("DOM.enable");
-		this.sendFireAndForget("Page.enable");
-	}
-	/** Fire-and-forget CDP message (used for `*.enable`, no result awaited). */
-	sendFireAndForget(method, params = {}) {
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-		const id = this.nextCommandId++;
-		this.ws.send(JSON.stringify({
-			id,
-			method,
-			params
-		}));
-	}
-	/**
-	* Issue a CDP command and resolve with its typed result. Rejects on a CDP
-	* error frame or when no websocket is open.
-	*/
-	send(method, params) {
-		return this.sendCommand(method, params ?? {});
-	}
-	/**
-	* Issue an arbitrary request→response command and resolve with its raw
-	* result. Both the typed CDP `send` and any AIT domain commands build on this.
-	*/
-	sendCommand(method, params = {}) {
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return Promise.reject(/* @__PURE__ */ new Error("No local Chromium page attached yet. Call enableDomains() first and ensure the browser is running with --remote-debugging-port."));
-		const id = this.nextCommandId++;
-		const ws = this.ws;
-		return new Promise((resolve, reject) => {
-			this.pending.set(id, {
-				resolve,
-				reject
-			});
-			ws.send(JSON.stringify({
-				id,
-				method,
-				params
-			}));
-		});
-	}
-	handleMessage(raw) {
-		const message = parseInbound(raw);
-		if (!message) return;
-		if (typeof message.id === "number" && this.pending.has(message.id)) {
-			const waiter = this.pending.get(message.id);
-			this.pending.delete(message.id);
-			if (waiter) if (message.error) waiter.reject(new Error(message.error.message));
-			else waiter.resolve(message.result);
-			return;
-		}
-		if (typeof message.method !== "string") return;
-		if (!this.buffers.has(message.method)) return;
-		const event = message.method;
-		const buffer = this.buffers.get(event);
-		if (!buffer) return;
-		buffer.push(message.params);
-		if (buffer.length > this.bufferSize) buffer.shift();
-		this.emitter.emit(event, message.params);
-	}
-	getBufferedEvents(event) {
-		return this.buffers.get(event) ?? [];
-	}
-	on(event, listener) {
-		this.emitter.on(event, listener);
-		return () => this.emitter.off(event, listener);
-	}
-	/** Close the local CDP websocket and reject any in-flight commands. */
-	close() {
-		this.ws?.close();
-		this.ws = null;
-		for (const waiter of this.pending.values()) waiter.reject(/* @__PURE__ */ new Error("Local Chromium CDP connection closed."));
-		this.pending.clear();
-	}
-};
-/** True for URLs that should be skipped when selecting a page target. */
-function isBlankOrDevtoolsUrl(url) {
-	return url === "" || url === "about:blank" || url === "about:newtab" || url.startsWith("devtools://") || url.startsWith("chrome://") || url.startsWith("chrome-extension://");
-}
-//#endregion
-//#region src/mcp/local-launcher.ts
-/**
-* Chromium launcher for the local debug mode (env 1).
-*
-* Launch decision rationale:
-*   - `chrome-launcher` (npm) is purpose-built and finds installed Chrome, but
-*     adds a runtime dependency to the MCP bundle. The repo already has a clear
-*     "external dependency minimization" policy; `chrome-launcher` is not worth
-*     pulling in for what is essentially `spawn(chromeBin, [...flags])`.
-*   - Playwright is a devDependency used for E2E only — pulling `chromium.launch`
-*     into the runtime MCP path would add ~100 MB of bundled Chromium to the
-*     production install and break the "devDep = e2e only" boundary.
-*   - `child_process.spawn` with a platform-aware binary search is the lightest
-*     option: zero new dependencies, portable across macOS/Linux/Windows, and
-*     trivially testable by injecting a `spawnFn`.
-*
-* The launcher finds an installed Chrome/Chromium using a prioritized list of
-* well-known binary paths per platform, then spawns it with:
-*   --remote-debugging-port=<port>
-*   --no-first-run
-*   --no-default-browser-check
-*   <devUrl>
-*
-* `pnpm dev` is started by the user; the MCP only launches the browser pointing
-* at it.
-*
-* Node-only.
-*/
-/**
-* Find an ephemeral free TCP port by briefly binding a server on port 0.
-* Resolves with the OS-assigned port number.
-*/
-function findFreePort() {
-	return new Promise((resolve, reject) => {
-		const server = net.createServer();
-		server.listen(0, "127.0.0.1", () => {
-			const addr = server.address();
-			const port = typeof addr === "object" && addr !== null ? addr.port : null;
-			server.close(() => {
-				if (port === null) reject(/* @__PURE__ */ new Error("Failed to determine free port from net.Server."));
-				else resolve(port);
-			});
-		});
-		server.on("error", reject);
-	});
-}
-/**
-* Returns an ordered list of Chromium/Chrome binary paths to try for the
-* current platform.
-*/
-function candidateChromePaths() {
-	const os = platform();
-	if (os === "darwin") return [
-		"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-		"/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
-		"/Applications/Chromium.app/Contents/MacOS/Chromium",
-		"/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
-	];
-	if (os === "linux") return [
-		"/usr/bin/google-chrome",
-		"/usr/bin/google-chrome-stable",
-		"/usr/bin/chromium",
-		"/usr/bin/chromium-browser",
-		"/usr/local/bin/google-chrome",
-		"/usr/local/bin/chromium",
-		"/snap/bin/chromium"
-	];
-	if (os === "win32") {
-		const programFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
-		const programFilesX86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
-		return [
-			`${programFiles}\\Google\\Chrome\\Application\\chrome.exe`,
-			`${programFilesX86}\\Google\\Chrome\\Application\\chrome.exe`,
-			`${programFiles}\\Chromium\\Application\\chrome.exe`
-		];
-	}
-	return [];
-}
-/** Find the first Chrome/Chromium binary that exists on this machine. */
-function findChromeBinary() {
-	for (const p of candidateChromePaths()) if (existsSync(p)) return p;
-	return null;
-}
-/**
-* Launch a local Chromium instance with CDP remote debugging enabled.
-*
-* The caller is responsible for calling `handle.stop()` when done.
-*
-* @throws if no Chrome/Chromium binary is found on the system.
-*/
-async function launchChromium(options = {}) {
-	const spawnImpl = options.spawnFn ?? spawn;
-	const requestedPort = options.port ?? 0;
-	const port = requestedPort === 0 ? await findFreePort() : requestedPort;
-	const devUrl = options.devUrl ?? process.env.AIT_DEVTOOLS_URL ?? "http://localhost:5173";
-	const binary = findChromeBinary();
-	if (binary === null) throw new Error("No Chrome/Chromium binary found on this system. Install Google Chrome or Chromium and try again. Searched: " + candidateChromePaths().join(", "));
-	const child = spawnImpl(binary, [
-		`--remote-debugging-port=${port}`,
-		"--no-first-run",
-		"--no-default-browser-check",
-		"--user-data-dir=/tmp/ait-devtools-chromium-profile",
-		...options.extraArgs ?? [],
-		devUrl
-	], {
-		stdio: "ignore",
-		detached: false
-	});
-	child.unref();
-	const devtoolsUrl = `http://127.0.0.1:${port}`;
-	process.stderr.write(`[ait-local-debug] Launched Chromium: ${binary}\n[ait-local-debug] CDP endpoint: ${devtoolsUrl}\n[ait-local-debug] Opening: ${devUrl}\n`);
-	return {
-		port,
-		devtoolsUrl,
-		stop() {
-			try {
-				child.kill();
-			} catch {}
-		}
-	};
-}
-//#endregion
-//#region src/mcp/debug-server.ts
-/**
-* @ait-co/devtools debug-mode MCP server (stdio).
-*
-* Lets an AI coding agent attach to a running mini-app (real Toss WebView, or a
-* browser in dev mode) and read its console/network/DOM/screenshot over CDP plus
-* the AIT.* domain, without a human watching a phone. Transport is CDP-via-Chii:
-* a local Chii relay on an OS-assigned port (default 0) exposed through a
-* cloudflared quick tunnel; the phone attaches over the public wss URL.
-*
-*   AI host  --stdio-->  this server  --CDP client WS-->  Chii relay :<OS-port>
-*                                                          ^-- target WS -- phone
-*
-* Port 0 (default): the OS picks a free ephemeral port on every startup.
-* This prevents EADDRINUSE when a stale cloudflared child (orphaned after
-* SIGKILL, PPID 1) still holds a fixed port — which previously caused the MCP
-* handshake to fail with -32000. With port 0 any orphaned cloudflared is
-* harmless; the new relay always gets a fresh port.
-*
-* Best-effort child cleanup: SIGINT/SIGTERM/SIGHUP handlers call shutdown() to
-* stop cloudflared and the relay. uncaughtException/unhandledRejection also
-* call shutdown() before exit. SIGKILL cannot be intercepted by Node, so
-* cloudflared orphans from SIGKILL remain (port 0 makes them harmless). Users
-* can clean up manually: `pkill -f 'cloudflared.*trycloudflare'`.
-*
-* The tool layer reads from an injectable `CdpConnection` (CDP) and `AitSource`
-* (AIT.*), so every tool is unit-testable with a fake (no phone). This module
-* wires the live pieces (relay + tunnel + production connection); the phone
-* roundtrip is fully wired and pending only on-device acceptance.
-*
-* Dynamic tool registration (issue #208):
-* The server advertises `listChanged: true` so MCP clients can subscribe to
-* `notifications/tools/list_changed`. Before any page attaches, only bootstrap
-* tools (`start_attach`, `list_pages`) are listed. Once a target appears,
-* the full attach-dependent tool set is added and a `list_changed` notification
-* is sent — without requiring a session restart. `runDebugServer` and
-* `runLocalDebugServer` start a polling watcher that detects the 0→N target
-* transition and calls `server.sendToolListChanged()`.
-*
-* Note: `src/mcp/server.ts` (dev mode, HTTP mock-state) is NOT subject to this
-* model — it has no attach concept and always exposes the full tool surface.
-*
-* Node-only.
-*/
-var debug_server_exports = /* @__PURE__ */ __exportAll({
-	DualConnectionRouter: () => DualConnectionRouter,
-	MOBILE_RELAY_BASE_URL_MISSING_MESSAGE: () => MOBILE_RELAY_BASE_URL_MISSING_MESSAGE,
-	RELAY_SANDBOX_STALE_PAGE_MS: () => RELAY_SANDBOX_STALE_PAGE_MS,
-	START_ATTACH_REMINT_THRESHOLD_MS: () => START_ATTACH_REMINT_THRESHOLD_MS,
-	START_ATTACH_SEGMENT_MS: () => START_ATTACH_SEGMENT_MS,
-	bootExternalRelayFamily: () => bootExternalRelayFamily,
-	bootLocalFamily: () => bootLocalFamily,
-	bootRelayFamily: () => bootRelayFamily,
-	buildRelayVerifyAuth: () => buildRelayVerifyAuth,
-	connectionHostsAllowed: () => connectionHostsAllowed,
-	createDebugServer: () => createDebugServer,
-	envForMode: () => envForMode,
-	familyKeyForMode: () => familyKeyForMode,
-	isRelayMode: () => isRelayMode,
-	makeSingleConnectionRouter: () => makeSingleConnectionRouter,
-	normalizeStartDebugMode: () => normalizeStartDebugMode,
-	readMobileRelayBaseUrl: () => readMobileRelayBaseUrl,
-	readRelayLocalUrl: () => readRelayLocalUrl,
-	runDebugServer: () => runDebugServer,
-	runLocalDebugServer: () => runLocalDebugServer,
-	runMobileDebugServer: () => runMobileDebugServer,
-	startAttachWatcher: () => startAttachWatcher
-});
-/**
-* Returns `true` when the mode routes to a relay connection (`relay-sandbox` or
-* `relay-staging`). Both surface the Tier B / relay-only tool set.
-*/
-function isRelayMode(mode) {
-	return mode === "relay-sandbox" || mode === "relay-staging";
-}
-/**
-* Maps a `StartDebugMode` to the `McpEnvironment` it routes to (issue #626).
-* Used by `start_attach`'s mode prologue to decide whether a `switchMode` is
-* needed: when the active env already equals `envForMode(mode)`, the switch is
-* skipped (no `tools/list_changed` churn).
-*
-*   - `local-browser`  → `mock`
-*   - `relay-sandbox`  → `relay-mobile` (env 2 external-PWA relay)
-*   - `relay-staging`  → `relay-dev`    (env 3 intoss-private relay)
-*/
-function envForMode(mode) {
-	switch (mode) {
-		case "local-browser": return "mock";
-		case "relay-sandbox": return "relay-mobile";
-		case "relay-staging": return "relay-dev";
-	}
-}
-/**
-* Single-attach guard for `run_tests` (#646). Two concurrent runs injecting
-* into the same single-attach page would interleave `Runtime.evaluate` and
-* corrupt each other's `globalThis.__testBundle`. The model is "reject the
-* second", not "queue" — a module-level flag is process-wide, which matches the
-* single physical attached page (only one target is live at a time). The
-* entry-time `conn` snapshot ensures a run finishes on the connection it started
-* on even if `router.active` flips mid-run.
-*/
-let runTestsInFlight = false;
-/**
-* Builds the debug-mode MCP server around an injected CDP connection + AIT
-* source + tunnel status getter. Pure wiring — does not start a relay or
-* tunnel, which is what makes the tool surface unit-testable.
-*
-* `tools/list` is two-tiered (issue #208):
-*   - bootstrap (always): `start_attach`, `list_pages`
-*   - attach-dependent (after `connection.listTargets().length > 0`): all others
-*
-* `CallTool` is NOT tiered — hidden tools still execute (attach errors surface
-* naturally via `enableDomains`). The tier only controls visibility.
-*/
-function createDebugServer(deps) {
-	const { connection, router: routerDep, aitSource, getTunnelStatus, waitForAttachTimeoutMs = 6e4, qrHttpServer, getEnvironment: getEnvDep, getEnvironmentReason: getEnvReasonDep, diagnosticsCollector: collectorDep, totpSecret, onAttachUrlBuilt, getTunnelChildPid, readLock: readLockDep, stalePageThresholdMs = RELAY_SANDBOX_STALE_PAGE_MS, nowMs = () => Date.now() } = deps;
-	const getTotpSecret = deps.getTotpSecret ?? (() => totpSecret);
-	const readLockFn = readLockDep ?? readServerLock;
-	const router = routerDep ?? makeSingleConnectionRouter(connection);
-	const resolveEnvironment = getEnvDep ?? (() => deriveEnvironment(router.active.kind, router.activeRelayOrigin));
-	const resolveEnvironmentReason = getEnvReasonDep ?? (() => `derived:kind=${router.active.kind},relayOrigin=${router.activeRelayOrigin ?? "none"}`);
-	const collector = collectorDep ?? new InMemoryDiagnosticsCollector();
-	const attachDeps = {
-		getTunnelStatus,
-		getTotpSecret,
-		qrHttpServer,
-		onAttachUrlBuilt,
-		stalePageThresholdMs,
-		nowMs
-	};
-	const server = new Server({
-		name: "ait-debug",
-		version: "0.1.122"
-	}, { capabilities: { tools: { listChanged: true } } });
-	server.setRequestHandler(ListToolsRequestSchema, () => {
-		const conn = router.active;
-		const env = resolveEnvironment();
-		const attached = conn.listTargets().length > 0;
-		const envFiltered = filterToolsByEnvironment(DEBUG_TOOL_DEFINITIONS, env);
-		return { tools: attached ? envFiltered.map((tool) => ({ ...tool })) : envFiltered.filter((tool) => BOOTSTRAP_TOOL_NAMES.has(tool.name)).map((tool) => ({ ...tool })) };
-	});
-	server.setRequestHandler(CallToolRequestSchema, async (request) => {
-		const name = request.params.name;
-		if (!isDebugToolName(name)) return {
-			content: [{
-				type: "text",
-				text: `Unknown tool: ${name}`
-			}],
-			isError: true
-		};
-		const conn = router.active;
-		if (name === "start_debug") {
-			const rawMode = request.params.arguments?.mode;
-			const mode = normalizeStartDebugMode(rawMode);
-			if (mode === null) return mcpError("start_debug: mode가 올바르지 않습니다. 'local-browser' | 'relay-sandbox' | 'relay-staging' 중 하나를 전달하세요. (relay-live / env 4는 #665에서 제거됐습니다.)");
-			const rawProjectRoot = request.params.arguments?.projectRoot;
-			const projectRoot = typeof rawProjectRoot === "string" ? rawProjectRoot : void 0;
-			try {
-				return jsonResult(await router.switchMode(mode, projectRoot));
-			} catch (err) {
-				return errorResult(err, name);
-			}
-		}
-		if (name === "start_attach") {
-			const args = request.params.arguments;
-			let attachConn = conn;
-			const rawMode = args?.mode;
-			if (rawMode !== void 0) {
-				const mode = normalizeStartDebugMode(rawMode);
-				if (mode === null || mode === "local-browser") return mcpError("start_attach: mode가 올바르지 않습니다. 'relay-sandbox' | 'relay-staging' 중 하나를 전달하세요 (local-browser는 QR attach가 없어 start_attach에서 지원하지 않습니다).");
-				const targetEnv = envForMode(mode);
-				if (resolveEnvironment() !== targetEnv) {
-					const rawProjectRoot = args?.projectRoot;
-					const projectRoot = typeof rawProjectRoot === "string" ? rawProjectRoot : void 0;
-					try {
-						await router.switchMode(mode, projectRoot);
-					} catch (err) {
-						return errorResult(err, name);
-					}
-					attachConn = router.active;
-				}
-			}
-			const attachEnv = resolveEnvironment();
-			if (!isRelayEnv(attachEnv)) return mcpError("start_attach: relay 전용 tool입니다 (env 2 / relay-sandbox 또는 env 3 / relay-staging). 현재 환경은 'local-browser'(mock)입니다 — mode 인자로 'relay-sandbox' 또는 'relay-staging'을 전달하거나, 먼저 relay 모드로 전환하세요.");
-			const waitForAttach = true;
-			const rawWaitTimeout = args?.wait_timeout_seconds;
-			const callTimeoutMs = (() => {
-				if (typeof rawWaitTimeout !== "number" || !Number.isFinite(rawWaitTimeout)) return waitForAttachTimeoutMs;
-				if (rawWaitTimeout <= 0) return waitForAttachTimeoutMs;
-				return Math.round(Math.max(1, Math.min(600, rawWaitTimeout))) * 1e3;
-			})();
-			try {
-				const prep = await prepareAttach(attachDeps, attachEnv, args, attachConn);
-				if (!prep.ok) return prep.error;
-				const attachResult = await renderAndMaybeWait(attachDeps, prep, waitForAttach, callTimeoutMs, attachConn);
-				if (!attachResult.isError) await injectDebugIndicator(attachConn);
-				return attachResult;
-			} catch (err) {
-				return errorResult(err, name);
-			}
-		}
-		const env = resolveEnvironment();
-		const envReason = resolveEnvironmentReason();
-		if (!isToolAvailableIn(name, env)) {
-			const requiredEnv = getToolAvailability(name) ?? "unknown";
-			logWarn("tool.error", {
-				tool: name,
-				errorKind: "tier-filter",
-				requiredEnv,
-				currentEnv: env,
-				envReason
-			});
-			return tierRejectionError(name, requiredEnv, env, envReason);
-		}
-		if (isAitToolName(name)) try {
-			await conn.enableDomains();
-			switch (name) {
-				case "AIT.getSdkCallHistory": return jsonResult(await getSdkCallHistory(aitSource));
-				case "AIT.getMockState": return jsonResult(await getMockState(aitSource));
-				case "AIT.getOperationalEnvironment": return jsonResult(await getOperationalEnvironment(aitSource));
-				default: return unknownTool(name);
-			}
-		} catch (err) {
-			return errorResult(err, name);
-		}
-		if (name === "get_debug_status") try {
-			const rawLimit = request.params.arguments?.recent_errors_limit;
-			const recentErrorsLimit = typeof rawLimit === "number" && rawLimit > 0 ? rawLimit : 10;
-			return envelopeResult(await getDiagnostics({
-				tunnel: getTunnelStatus(),
-				connection: conn,
-				env,
-				envReason,
-				collector,
-				readLock: readLockFn,
-				recentErrorsLimit,
-				tunnelChildPid: getTunnelChildPid?.() ?? void 0
-			}), name, env, conn.listTargets().length > 0);
-		} catch (err) {
-			return errorResult(err, name);
-		}
-		try {
-			await conn.enableDomains();
-		} catch (err) {
-			if (name === "list_pages") {
-				try {
-					await conn.refreshTargets?.();
-				} catch {}
-				return envelopeResult(listPages(conn, getTunnelStatus()), name, env, conn.listTargets().length > 0);
-			}
-			return classifyEnableDomainError(err, name);
-		}
-		try {
-			switch (name) {
-				case "list_console_messages": return jsonResult(listConsoleMessages(conn));
-				case "list_exceptions": {
-					const rawLimit = request.params.arguments?.limit;
-					return jsonResult({ exceptions: listExceptions(conn, typeof rawLimit === "number" && rawLimit > 0 ? rawLimit : 50) });
-				}
-				case "list_network_requests": return jsonResult(listNetworkRequests(conn));
-				case "list_pages":
-					try {
-						await conn.refreshTargets?.();
-					} catch {}
-					return envelopeResult(listPages(conn, getTunnelStatus()), name, env, conn.listTargets().length > 0);
-				case "get_dom_document": return jsonResult(await getDomDocument(conn));
-				case "take_snapshot": return jsonResult(await takeSnapshot(conn));
-				case "take_screenshot": {
-					const shot = await takeScreenshot(conn);
-					return { content: [{
-						type: "image",
-						data: shot.data,
-						mimeType: shot.mimeType
-					}] };
-				}
-				case "measure_safe_area": return envelopeResult(await measureSafeArea(conn, env), name, env, conn.listTargets().length > 0);
-				case "evaluate": {
-					const expression = request.params.arguments?.expression;
-					if (typeof expression !== "string" || expression === "") return mcpError("evaluate: expression 인자가 비어 있습니다. 평가할 JavaScript 표현식을 전달하세요.");
-					if (!connectionHostsAllowed(conn)) return mcpError("evaluate: 현재 연결된 페이지는 debug 허용 호스트가 아닙니다 (#665). 허용 호스트: localhost, *.trycloudflare.com, *.private-apps.tossmini.com.");
-					return jsonResult(await evaluate(conn, expression));
-				}
-				case "call_sdk": {
-					const sdkName = request.params.arguments?.name;
-					if (typeof sdkName !== "string" || sdkName === "") return mcpError("call_sdk: name 인자가 비어 있습니다. 호출할 SDK 메서드 이름을 전달하세요.");
-					const rawArgs = request.params.arguments?.args;
-					const sdkArgs = Array.isArray(rawArgs) ? rawArgs : [];
-					if (!connectionHostsAllowed(conn)) return mcpError("call_sdk: 현재 연결된 페이지는 debug 허용 호스트가 아닙니다 (#665). 허용 호스트: localhost, *.trycloudflare.com, *.private-apps.tossmini.com.");
-					const sdkResult = await callSdk(conn, sdkName, sdkArgs);
-					if (!sdkResult.ok && typeof sdkResult.error === "string" && sdkResult.error.startsWith("sdk-absent:")) return sdkAbsentError("call_sdk", conn.kind === "local");
-					return envelopeResult(sdkResult, name, env, conn.listTargets().length > 0);
-				}
-				case "run_tests": {
-					const rawFiles = request.params.arguments?.files;
-					if (!Array.isArray(rawFiles) || rawFiles.length === 0) return mcpError("run_tests: files 인자가 비어 있습니다. 실행할 테스트 파일 glob을 배열로 전달하세요.");
-					const patterns = rawFiles.filter((p) => typeof p === "string" && p !== "");
-					if (patterns.length === 0) return mcpError("run_tests: files 인자에 유효한 문자열 glob이 없습니다.");
-					const rawRoot = request.params.arguments?.projectRoot;
-					const projectRoot = typeof rawRoot === "string" ? rawRoot : process.cwd();
-					const rawTimeout = request.params.arguments?.timeout_ms;
-					const timeoutMs = typeof rawTimeout === "number" && rawTimeout >= 1e3 && rawTimeout <= 6e5 ? rawTimeout : void 0;
-					const runTestPages = conn.listTargets();
-					const connAsAny = conn;
-					const hasLivePage = isSandboxPageFresh(runTestPages, typeof connAsAny.getTargetLastSeenAt === "function" ? (id) => connAsAny.getTargetLastSeenAt(id) : null, nowMs(), stalePageThresholdMs);
-					if (!hasLivePage && isRelayEnv(env)) {
-						const autoAttachArgs = request.params.arguments;
-						const prep = await prepareAttach(attachDeps, env, autoAttachArgs, conn);
-						if (!prep.ok) return prep.error;
-						const autoAttachResult = await renderAndMaybeWait(attachDeps, prep, true, waitForAttachTimeoutMs, conn);
-						if (autoAttachResult.isError) return autoAttachResult;
-						const rawCell = autoAttachArgs?.cell;
-						if (rawCell !== null && typeof rawCell === "object" && !Array.isArray(rawCell)) await injectGlobals(conn, rawCell);
-						if (!connectionHostsAllowed(conn)) return mcpError("run_tests: 연결된 페이지가 debug 허용 호스트가 아닙니다 (#665). 허용 호스트: localhost, *.trycloudflare.com, *.private-apps.tossmini.com.");
-						if (runTestsInFlight) return mcpError("run_tests: 이미 다른 테스트 실행이 진행 중입니다 (single-attach 모델: 페이지는 한 번에 하나의 실행만 처리). 완료 후 다시 시도하세요.");
-						runTestsInFlight = true;
-						try {
-							const files = await discoverTestFiles(patterns, projectRoot);
-							if (files.length === 0) return mcpError(`run_tests: 매칭된 테스트 파일이 없습니다 (patterns: ${patterns.join(", ")}).`);
-							if (conn.listTargets().length === 0) return pageMissingError("run_tests");
-							logInfo("run_tests.start", {
-								fileCount: files.length,
-								autoAttach: true
-							});
-							const report = await runWithConnection(conn, files, {
-								timeoutMs,
-								collectCaptures: true
-							});
-							logInfo("run_tests.done", {
-								passed: report.totals.passed,
-								failed: report.totals.failed,
-								skipped: report.totals.skipped
-							});
-							const runAttached = conn.listTargets().length > 0;
-							return envelopeResult(toRunTestsResult(report), name, env, runAttached);
-						} finally {
-							runTestsInFlight = false;
-						}
-					}
-					if (!hasLivePage) return mcpError("run_tests: 연결된 페이지가 없습니다. mock(로컬) 환경에서는 auto-attach가 지원되지 않습니다. list_pages로 연결 상태를 확인하고 페이지가 붙어 있는지 확인하세요.");
-					if (!connectionHostsAllowed(conn)) return mcpError("run_tests: 현재 연결된 페이지는 debug 허용 호스트가 아닙니다 (#665). 허용 호스트: localhost, *.trycloudflare.com, *.private-apps.tossmini.com.");
-					if (runTestsInFlight) return mcpError("run_tests: 이미 다른 테스트 실행이 진행 중입니다 (single-attach 모델: 페이지는 한 번에 하나의 실행만 처리). 완료 후 다시 시도하세요.");
-					runTestsInFlight = true;
-					try {
-						const files = await discoverTestFiles(patterns, projectRoot);
-						if (files.length === 0) return mcpError(`run_tests: 매칭된 테스트 파일이 없습니다 (patterns: ${patterns.join(", ")}).`);
-						if (conn.listTargets().length === 0) return pageMissingError("run_tests");
-						logInfo("run_tests.start", { fileCount: files.length });
-						const report = await runWithConnection(conn, files, {
-							timeoutMs,
-							collectCaptures: true
-						});
-						logInfo("run_tests.done", {
-							passed: report.totals.passed,
-							failed: report.totals.failed,
-							skipped: report.totals.skipped
-						});
-						const runAttached = conn.listTargets().length > 0;
-						return envelopeResult(toRunTestsResult(report), name, env, runAttached);
-					} finally {
-						runTestsInFlight = false;
-					}
-				}
-				default: return unknownTool(name);
-			}
-		} catch (err) {
-			return errorResult(err, name, conn.kind === "local");
-		}
-	});
-	return server;
-}
-/**
-* Normalizes a raw `start_debug` `mode` argument to a `StartDebugMode`, or
-* `null` when the value is not one of the three accepted modes:
-*   'local-browser' | 'relay-sandbox' | 'relay-staging'
-*
-* Hard rename (issue #398): the older `local`/`mobile`/`staging`/`live` names
-* and their aliases are no longer accepted — pre-1.0, no back-compat.
-* `relay-live` (env 4) removed in #665.
-*/
-function normalizeStartDebugMode(raw) {
-	if (raw === "local-browser" || raw === "relay-sandbox" || raw === "relay-staging") return raw;
-	return null;
-}
-/**
-* Positive-allowlist kill-switch for side-effect MCP tools (#665).
-*
-* Returns `true` when the connection's attached targets are all on allowed
-* debug hosts (localhost / trycloudflare / private-apps). Returns `false` when
-* any target's page URL is on a non-allowed host (e.g. `apps.tossmini.com`).
-*
-* For local connections this always returns `true` — the local Chromium is
-* always on localhost. For relay connections without any pages it returns
-* `true` (no pages = nothing to block; the caller's page-missing guard fires
-* first).
-*
-* SECRET-HANDLING: hostnames are NEVER logged here — only the boolean result
-* is returned to the caller.
-*/
-function connectionHostsAllowed(conn) {
-	if (conn.kind === "local") return true;
-	const pages = conn.listTargets();
-	if (pages.length === 0) return true;
-	return pages.every((p) => {
-		try {
-			return isDebugAllowedHost(new URL(p.url ?? "").hostname);
-		} catch {
-			return false;
-		}
-	});
-}
-/**
-* Builds a trivial `ConnectionRouter` pinned to a single connection (issue
-* #348). Used by `createDebugServer` when no real dual router is injected —
-* every existing single-connection test and the `local`-only / `relay`-only
-* boot path. `switchMode` here cannot lazily boot another family, so it only
-* honors a request that matches the connection's own kind; any cross-family
-* request is rejected with a clear "dynamic switch unavailable in this session"
-* error. `confirm` parameter and `relay-live` gate removed (#665).
-*/
-function makeSingleConnectionRouter(connection) {
-	return {
-		get active() {
-			return connection;
-		},
-		activeRelayOrigin: void 0,
-		switchMode(mode, _projectRoot) {
-			if (mode === "relay-sandbox") return Promise.reject(/* @__PURE__ */ new Error("start_debug: 이 세션은 단일 연결만 보유합니다 — 'relay-sandbox'(환경 2 PWA, 외부 relay)로 동적 전환할 수 없습니다 (dual-connection 데몬에서만 지원). MCP 서버를 relay-sandbox 모드로 재시작하세요."));
-			if (isRelayMode(mode) !== (connection.kind === "relay")) return Promise.reject(/* @__PURE__ */ new Error(`start_debug: 이 세션은 단일 ${connection.kind} 연결만 보유합니다 — '${mode}'로 동적 전환할 수 없습니다 (dual-connection 데몬에서만 지원). MCP 서버를 원하는 모드로 재시작하세요.`));
-			const environment = deriveEnvironment(connection.kind);
-			return Promise.resolve({
-				mode,
-				environment,
-				kind: connection.kind,
-				nextStep: connection.kind === "relay" ? "start_attach로 attach QR 생성 + 폰 attach까지 한 번에 진행하세요." : "list_pages로 로컬 페이지 attach를 확인하세요."
-			});
-		}
-	};
-}
-/**
-* Re-builds an attach URL from stored components with a FRESHLY-minted TOTP code,
-* so the dashboard/`/attach` QR is never an expired bake-in (Defect 1).
-* SECRET-HANDLING: reads AIT_DEBUG_TOTP_SECRET at call time (mirrors tunnel.ts
-* getDashboardState). The minted code rides inside attachUrl's at= param only —
-* never logged. generateTotp() relies on its Date.now() default.
-*/
-function rebuildAttachUrl(parts) {
-	const secret = process.env.AIT_DEBUG_TOTP_SECRET;
-	const code = secret ? generateTotp(secret) : void 0;
-	return parts.kind === "launcher" ? buildLauncherAttachUrl(parts.tunnelHttpUrl, parts.wssUrl, code, {
-		name: parts.appName,
-		...parts.selfdebug ? { selfdebug: true } : {}
-	}) : buildDeepLinkAttachUrl(parts.schemeUrl, parts.wssUrl, code);
-}
-function jsonResult(value) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(value, null, 2)
-	}] };
-}
-/**
-* Wraps `value` in a `ToolEnvelope` (when compat mode is off) and returns it
-* as a text content block. When `AIT_MCP_COMPAT=chrome-devtools` is set the
-* envelope is skipped and the raw value is returned — identical to `jsonResult`.
-*/
-function envelopeResult(value, tool, env, attached) {
-	const wrapped = wrapEnvelope(value, {
-		tool,
-		env,
-		attached
-	});
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(wrapped, null, 2)
-	}] };
-}
-/**
-* Maps a {@link RelayRunReport} to a flat, agent-friendly object for the
-* `run_tests` tool result. SECRET-HANDLING: a RelayRunReport carries only
-* startedAt/duration/totals, per-file `{file, result}`, and capture lines —
-* file paths are surfaced (allowed), relay wss/TOTP URLs never appear in it.
-* No stripping needed; this only reshapes for readability.
-*
-* Captures (#696): the envelope surfaces a COUNT-LEVEL summary only
-* (per-category line counts) — never the line bodies. Capture bodies belong in
-* the on-disk artifact, not the `run_tests` log (keeps the tool result small and
-* avoids dumping large capture arrays into the agent's context).
-*/
-function toRunTestsResult(report) {
-	const captureCounts = {};
-	for (const { category } of report.captures) captureCounts[category] = (captureCounts[category] ?? 0) + 1;
-	return {
-		startedAt: report.startedAt,
-		duration: report.duration,
-		totals: report.totals,
-		files: report.files.map((f) => "error" in f.result ? {
-			file: f.file,
-			error: f.result.error
-		} : {
-			file: f.file,
-			duration: f.result.duration,
-			passed: f.result.passed,
-			failed: f.result.failed,
-			skipped: f.result.skipped,
-			tests: f.result.tests
-		}),
-		captures: captureCounts
-	};
-}
-function unknownTool(name) {
-	return mcpError(`알 수 없는 tool: ${name}`);
-}
-/**
-* enableDomains()가 던진 에러를 4상태로 분류해 적절한 메시지를 반환한다.
-*
-* - "No mini-app page attached" → page 미attach (상태 2)
-* - crash/destroy/replaced 패턴 → page crash (상태 3)
-* - relay disconnect 패턴 → relay 연결 끊김
-* - 그 외 → 원본 메시지 + list_pages 안내
-*/
-function classifyEnableDomainError(err, toolName) {
-	const message = err instanceof Error ? err.message : String(err);
-	if (message.includes("No mini-app page attached") || message.includes("페이지가 attach 안")) return pageMissingError(toolName);
-	if (message.includes("replaced-by-new-attach") || message.includes("targetCrashed") || message.includes("targetDestroyed") || message.includes("detachedFromTarget")) return pageCrashError(toolName);
-	if (message.includes("relay에 연결되어 있지 않습니다") || message.includes("relay WebSocket") || message.includes("Chii relay connection closed")) return relayDisconnectError(toolName);
-	return classifyToolError(err, toolName);
-}
-/**
-* CDP/AIT 명령 실행 중 catch된 에러를 4상태로 분류해 tool 결과로 반환한다.
-* debug-server 내부 try/catch 블록에서 공통으로 사용한다.
-*/
-function errorResult(err, name, isLocal = false) {
-	return classifyToolError(err, name, isLocal);
-}
-/**
-* Starts a polling watcher that detects target-set changes on
-* `connection.listTargets()` and sends a `notifications/tools/list_changed`
-* notification on the given server.
-*
-* The watcher polls every `intervalMs` (default 1 000 ms). On each tick it
-* calls `connection.refreshTargets?.()` first (fix #705-B) so that silent
-* disconnects (no CDP event, phone backgrounded / tunnel quiet) are picked up
-* before the signature is read. If `refreshTargets` throws — e.g. a transient
-* relay error — the tick is skipped entirely to avoid a spurious detach signal.
-*
-* After the refresh, it fires `server.sendToolListChanged()` + `onAttach()`
-* whenever the sorted target-id signature changes AND the new target set is
-* non-empty. This covers:
-*   - 0→N first attach
-*   - 1→1 target replacement (same count, different id — e.g. rescan)
-*   - N→M any change where the result is still non-empty
-*
-* Full detach (→ empty) fires `onDetach()` (fix #705-A) on the exact
-* non-empty→empty edge — i.e. only when the previous signature was non-empty.
-* This lets callers push an immediate "disconnected" SSE update to the
-* dashboard without waiting for the next periodic interval.
-*
-* The interval is **never cleared automatically** — it keeps running until
-* `stop()` is called during shutdown. This ensures that a target replacement
-* after the first attach is always detected.
-*
-* `onAttach` is called on every non-empty signature change (or immediately when
-* already attached). Use this to trigger side-effects such as pushing a fresh
-* SSE state to open dashboard tabs (issue #509). Both callbacks are optional;
-* omitting them preserves the previous behaviour exactly.
-*
-* SECRET-HANDLING: target `id`/`title`/`url` are not written to any log here.
-* Only an attach-detected stderr line is emitted (no target details).
-*
-* @returns `stop` — call this during shutdown to clear the interval.
-*/
-function startAttachWatcher(connection, server, intervalMs = 1e3, onAttach, onDetach) {
-	/** Sorted, comma-joined target-id string — '' means no targets attached. */
-	function signature() {
-		return connection.listTargets().map((t) => t.id).sort().join(",");
-	}
-	let lastSignature = signature();
-	if (lastSignature !== "") {
-		server.sendToolListChanged();
-		onAttach?.();
-	}
-	/** Compare current vs last signature and fire the appropriate callback. */
-	function tick() {
-		const current = signature();
-		if (current !== lastSignature) {
-			const wasNonEmpty = lastSignature !== "";
-			lastSignature = current;
-			if (current !== "") {
-				server.sendToolListChanged();
-				onAttach?.();
-			} else if (wasNonEmpty) onDetach?.();
-		}
-	}
-	const handle = setInterval(() => {
-		if (connection.refreshTargets) connection.refreshTargets().then(() => {
-			tick();
-		}, (_err) => {});
-		else tick();
-	}, intervalMs);
-	return { stop() {
-		clearInterval(handle);
-	} };
-}
-/**
-* Factory that constructs a `ChiiCdpConnection` for the given relay base URL.
-*
-* Introduced as a named seam so PR-2 (dual-connection, #348) can defer
-* construction to first-activation time by moving or replacing this call. Since
-* #396 every family (relay included) is constructed lazily on its first
-* `start_debug`, so this is always called from the lazy boot path.
-*
-* The relay base URL is only available after `startChiiRelay()` resolves, so
-* the factory is called right after that point (same as before this refactor).
-*/
-function createRelayConnection(relayBaseUrl) {
-	return new ChiiCdpConnection({
-		relayBaseUrl,
-		totpSecret: process.env.AIT_DEBUG_TOTP_SECRET
-	});
-}
-/**
-* AIT source that always forwards over the *currently active* connection
-* (issue #348). The single-connection `ChiiAitSource` binds one sender at
-* construction; in the dual-connection daemon the AIT.* domain must follow the
-* active connection across `start_debug` swaps, so this indirection reads
-* `getActive()` on every call.
-*
-* Both `ChiiCdpConnection` and `LocalCdpConnection` expose `sendCommand`, so
-* the active connection is a valid `AitCommandSender`.
-*/
-var RoutingAitSource = class extends ChiiAitSource {
-	constructor(getActive) {
-		super({ sendCommand: (method, params) => getActive().sendCommand(method, params) });
-	}
-};
-/**
-* Boots the local-browser family (issues #348, #356). Launches a Chromium with
-* `--remote-debugging-port` and returns a `LocalCdpConnection` attached to it,
-* plus a `stop()` that kills both.
-*
-* Booted lazily via the dual router's `bootLazyFor('local-browser')` callback,
-* at most once on the first `start_debug({ mode: 'local-browser' })` (all-lazy,
-* #396 — no run function boots a family at startup anymore).
-*/
-async function bootLocalFamily() {
-	const chromium = await launchChromium({
-		port: 0,
-		devUrl: process.env.AIT_DEVTOOLS_URL ?? "http://localhost:5173"
-	});
-	await new Promise((r) => setTimeout(r, 800));
-	const connection = new LocalCdpConnection({ devtoolsHttpUrl: chromium.devtoolsUrl });
-	return {
-		connection,
-		stop() {
-			connection.close();
-			chromium.stop();
-		}
-	};
-}
-/**
-* Boots the relay family (issues #348, #356): starts the Chii relay on an
-* OS-assigned port (with optional TOTP gate), opens a cloudflared quick tunnel
-* to the relay's confirmed port in the background, prints the attach banner,
-* and arms the tunnel health probe. Returns a {@link BootedFamily} whose
-* `getTunnelStatus()` reflects the live tunnel (it flips up once the background
-* tunnel resolves and follows reissues).
-*
-* Booted lazily via the dual router's `bootLazyFor('relay-intoss')` callback
-* (symmetry with {@link bootLocalFamily}), at most once on the first
-* `start_debug({ mode: 'relay-staging' })` (all-lazy, #396 — every relay boot now
-* flows through `switchMode` after the project-local secret load). `relay-live`
-* removed (#665).
-*
-* The relay base URL is only known after `startChiiRelay()` resolves, so the
-* `ChiiCdpConnection` (via {@link createRelayConnection}) is constructed inside
-* this function, after the relay port is confirmed.
-*
-* SECRET-HANDLING: the TOTP secret rides only inside `verifyAuth`; the wssUrl
-* (relay host) is never logged here directly.
-*/
-async function bootRelayFamily(options = {}) {
-	assertRelayAuthConfigured();
-	const relayPort = options.relayPort ?? 0;
-	const totpEnabled = options.verifyAuth !== void 0;
-	const relay = await startChiiRelay({
-		port: relayPort,
-		verifyAuth: options.verifyAuth,
-		onAuthReject: options.onAuthReject
-	});
-	logInfo("server.start", {
-		port: relay.port,
-		totpEnabled
-	});
-	let tunnel = null;
-	let tunnelStatus = makeTunnelStatus(false, null);
-	let tunnelProbe = null;
-	generateAttachToken();
-	startQuickTunnel(relay.port).then((t) => {
-		tunnel = t;
-		tunnelStatus = makeTunnelStatus(true, t.wssUrl);
-		options.onWssUrl?.(t.wssUrl);
-		if (t.childPid !== void 0) options.onTunnelChildPid?.(t.childPid);
-		logInfo("tunnel.up", { totpEnabled });
-		tunnelProbe = startTunnelHealthProbe(t, relay.port, {
-			onReissue: (newTunnel) => {
-				tunnel = newTunnel;
-				tunnelStatus = makeTunnelStatus(true, newTunnel.wssUrl, null, 0);
-				options.onWssUrl?.(newTunnel.wssUrl);
-				if (newTunnel.childPid !== void 0) options.onTunnelChildPid?.(newTunnel.childPid);
-				printAttachBanner({
-					wssUrl: newTunnel.wssUrl,
-					totpEnabled
-				}).then(() => {
-					logInfo("tunnel.up", {
-						totpEnabled,
-						reissued: true
-					});
-				});
-			},
-			onPermanentDrop: (droppedAt) => {
-				tunnelStatus = makeTunnelStatus(false, null, droppedAt, 3);
-				logError("tunnel.down", { msg: `tunnel permanently dropped (${droppedAt}). Restart: npx @ait-co/devtools devtools-mcp` });
-				options.onTunnelDown?.();
-			}
-		});
-		return printAttachBanner({
-			wssUrl: t.wssUrl,
-			totpEnabled
-		});
-	}, (err) => {
-		logError("tunnel.down", { msg: `Failed to open cloudflared quick tunnel: ${err instanceof Error ? err.message : String(err)}. The relay is up locally; attach over the public URL is unavailable until the tunnel starts.` });
-	});
-	const connection = createRelayConnection(relay.baseUrl);
-	return {
-		connection,
-		relayOrigin: "intoss-webview",
-		relayHttpUrl: relay.baseUrl,
-		getTunnelStatus: () => tunnelStatus,
-		stop() {
-			tunnelProbe?.stop();
-			tunnel?.stop();
-			connection.close();
-			relay.close();
-		}
-	};
-}
-/**
-* Boots the EXTERNAL relay family for env 2 (real-device PWA, issue #378).
-*
-* Unlike {@link bootRelayFamily}, this does NOT start a relay or a tunnel —
-* the unplugin (`tunnel: { cdp: true }`) already brought up a Chii relay for
-* the env-2 PWA and exposed its public base URL via `AIT_RELAY_BASE_URL`. Here
-* the MCP only opens a CDP client (`createRelayConnection`) against that
-* external relay. The relay's lifecycle is owned by the unplugin, so `stop()`
-* closes ONLY the CDP client — it must never tear down the relay or a tunnel
-* we did not start.
-*
-* `getTunnelStatus()` reports `up: true` with a `wssUrl` derived from
-* `relayBaseUrl` (http→ws, https→wss) so the `start_attach` gate
-* (`up: true && wssUrl !== null`) is satisfied even though we never opened a
-* cloudflared tunnel ourselves.
-*
-* SECRET-HANDLING: `relayBaseUrl` carries the relay host (same sensitivity as a
-* wss URL) — it is NEVER logged here. The caller validates presence and passes
-* the value straight to the CDP client.
-*/
-/**
-* Attempts to read the local loopback HTTP base URL of the env-2 Chii relay
-* (issue #530). Resolution order:
-*   1. `AIT_RELAY_LOCAL_URL` env var, if set and non-empty.
-*   2. `relayLocalUrl` from the `.ait_urls` file, if `projectRoot` is given.
-*   3. `undefined` — caller falls back to the tunnel base (existing behavior).
-*
-* This is a best-effort read — never throws. The returned value is a plain
-* `http://127.0.0.1:<port>` loopback URL; no secret exposure.
-*/
-async function readRelayLocalUrl(env = process.env, projectRoot) {
-	const envValue = (env.AIT_RELAY_LOCAL_URL ?? "").trim();
-	if (envValue !== "") return envValue;
-	if (projectRoot !== void 0) try {
-		const { readRelayUrls } = await import("./relay-url-store-D3H067u0.js");
-		const stored = await readRelayUrls({ projectRoot });
-		if (stored?.relayLocalUrl) return stored.relayLocalUrl;
-	} catch {}
-}
-async function bootExternalRelayFamily(relayBaseUrl, relayLocalUrl) {
-	assertRelayAuthConfigured();
-	const connection = createRelayConnection(relayBaseUrl);
-	const tunnelStatus = makeTunnelStatus(true, relayBaseUrl.replace(/^http/, "ws"));
-	return {
-		connection,
-		relayOrigin: "external-pwa",
-		relayHttpUrl: relayBaseUrl,
-		relayLocalHttpUrl: relayLocalUrl,
-		getTunnelStatus: () => tunnelStatus,
-		stop() {
-			connection.close();
-		}
-	};
-}
-/**
-* Maps a `StartDebugMode` to the {@link FamilyKey} that serves it (issue #378).
-*   local-browser → 'local-browser'; relay-sandbox → 'relay-sandbox';
-*   relay-staging → 'relay-intoss' (the intoss-private relay slot).
-*   `relay-live` removed (#665).
-*/
-function familyKeyForMode(mode) {
-	switch (mode) {
-		case "local-browser": return "local-browser";
-		case "relay-sandbox": return "relay-sandbox";
-		case "relay-staging": return "relay-intoss";
-	}
-}
-/** The error thrown / surfaced when entering `mobile` without AIT_RELAY_BASE_URL. */
-const MOBILE_RELAY_BASE_URL_MISSING_MESSAGE = "start_debug(mobile): AIT_RELAY_BASE_URL이 설정되지 않았습니다. dev 서버가 tunnel:{cdp:true}로 기동 중이면 .ait_urls 파일이 자동 생성돼 있어야 합니다. 자동 발견이 되지 않을 경우 relay base URL을 AIT_RELAY_BASE_URL 환경변수로 직접 전달하세요. 환경 2(실기기 PWA) 진입은 외부 relay base가 필요합니다.";
-/**
-* Reads the env-2 relay base URL for the `mobile` boot site (issue #378, #424).
-*
-* Resolution order (env wins — file is the fallback):
-*   1. `env.AIT_RELAY_BASE_URL` set and non-empty → return it (operator override).
-*   2. `projectRoot` given → read `<nearest package.json dir>/.ait_urls`;
-*      if `relayBaseUrl` is present → return it (auto-discovered from dev server).
-*   3. Neither → throw {@link MOBILE_RELAY_BASE_URL_MISSING_MESSAGE}.
-*
-* SECRET-HANDLING: `AIT_RELAY_BASE_URL` and the file-discovered value carry the
-* relay host. On the missing path the thrown message names the env var and notes
-* that the dev server auto-publishes it — it NEVER echoes any URL value. The
-* present value is returned to the caller (the CDP client) but never logged.
-*/
-async function readMobileRelayBaseUrl(env = process.env, projectRoot) {
-	const raw = env.AIT_RELAY_BASE_URL;
-	const envValue = typeof raw === "string" ? raw.trim() : "";
-	if (envValue !== "") return envValue;
-	if (projectRoot !== void 0) {
-		const { readRelayUrls } = await import("./relay-url-store-D3H067u0.js");
-		const stored = await readRelayUrls({ projectRoot });
-		if (stored?.relayBaseUrl !== void 0) return stored.relayBaseUrl;
-	}
-	throw new Error(MOBILE_RELAY_BASE_URL_MISSING_MESSAGE);
-}
-/**
-* Sentinel connection returned by {@link DualConnectionRouter.active} before the
-* first `start_debug` boots a family (all-lazy, issue #396). It satisfies the
-* full {@link CdpConnection} interface but holds nothing: `listTargets()` is
-* empty, every command rejects with a clear "call start_debug first" message,
-* and all event/teardown members are safe no-ops. Callers that read tools before
-* any switchMode therefore get an honest empty/down state instead of an NPE.
-*/
-const NULL_CDP_CONNECTION = {
-	kind: "local",
-	enableDomains: () => Promise.resolve(),
-	listTargets: () => [],
-	getBufferedEvents: () => [],
-	on: () => () => {},
-	send: () => Promise.reject(/* @__PURE__ */ new Error("no family booted yet — call start_debug first")),
-	close: () => {}
-};
-/**
-* Production `ConnectionRouter` (issues #348, #356, #378 — DUAL-CONNECTION-COEXIST).
-*
-* Holds a keyed set of lazily-booted families ({@link FamilyKey} →
-* `BootedFamily`, issue #378) with NO family active at startup (issue #396); the
-* first `start_debug` boots and activates one. Plus an `active` pointer and the
-* single attach watcher armed on the active connection. The router is
-* **direction-neutral** (#356): any family can be the first one booted, so a
-* `--target=local` session can hot-switch into relay (and vice versa) without
-* restarting the MCP server.
-*
-* Why a KEYED map and not a single lazy slot (#378): `relay-sandbox` (env-2
-* external relay) and `relay-staging` (intoss relay) are BOTH `kind: 'relay'`.
-* A single "opposite-kind" slot could not warm-keep both at once — they would
-* collide. The three `FamilyKey`s (`local-browser` / `relay-intoss` /
-* `relay-sandbox`) give each its own warm slot. `relay-live` (env 4) removed
-* (#665) — `relay-intoss` slot now maps only to `relay-staging`.
-*
-* Why all-lazy (#396): the relay TOTP secret now lives in a project-local
-* `.ait_relay` file loaded read-only by `switchMode` BEFORE a relay family boots.
-* Booting any family eagerly at startup would bypass that load. With NO eager
-* boot every relay boot flows through `switchMode → loadRelaySecretReadOnly`, so
-* the secret is always populated before `assertRelayAuthConfigured()` /
-* `buildRelayVerifyAuth()` run at the boot site.
-*
-* `switchMode`:
-*   1. rejects re-entrant swaps (`swapInFlight`);
-*   2. resolves the requested mode's `FamilyKey`:
-*      `lazyFamilies.get(key) ?? (boot via bootLazyFor(key), store)`;
-*   3. flips `active` (the MCP `Server` never re-handshakes — it reads through
-*      `active` per request);
-*   4. stops the old attach watcher and re-arms one on the new connection
-*      (the watcher self-clears, so re-arm is mandatory);
-*   5. emits `tools/list_changed`.
-*
-* Inactive infra is left WARM — teardown happens only at process exit (the
-* unified shutdown in the run functions), which is what keeps a phone attach
-* alive across a local→relay→local round trip.
-*/
-var DualConnectionRouter = class {
-	deps;
-	/** Families, booted lazily and warm-kept per {@link FamilyKey} (#378, #396). */
-	lazyFamilies = /* @__PURE__ */ new Map();
-	/** `null` until the first `start_debug` boots a family (all-lazy, #396). */
-	activeFamily = null;
-	server = null;
-	attachWatcher = null;
-	swapInFlight = false;
-	constructor(deps) {
-		this.deps = deps;
-	}
-	get active() {
-		return this.activeFamily ? this.activeFamily.connection : NULL_CDP_CONNECTION;
-	}
-	/** Relay origin of the currently-active family (issue #378). */
-	get activeRelayOrigin() {
-		return this.activeFamily?.relayOrigin;
-	}
-	/**
-	* HTTP base URL of the Chii relay to use for inspector URL assembly (#503,
-	* #530). Prefers the LOCAL loopback base (`relayLocalHttpUrl`) when available
-	* so front_end page load + client WS do not traverse a cloudflare tunnel —
-	* falls back to `relayHttpUrl` (the tunnel base for env-2, loopback for env-3/4)
-	* when not set. Returns `undefined` when no relay family is active.
-	*
-	* SECRET-HANDLING: when relayLocalHttpUrl is absent this falls back to
-	* relayHttpUrl which may carry the tunnel host — callers must not log it.
-	*/
-	get activeRelayHttpUrl() {
-		if (!this.activeFamily) return void 0;
-		return this.activeFamily.relayLocalHttpUrl ?? this.activeFamily.relayHttpUrl;
-	}
-	/** Every booted family (for unified shutdown). All families are lazy (#396). */
-	bootedFamilies() {
-		return [...this.lazyFamilies.values()];
-	}
-	/**
-	* Live tunnel status of the active relay family (issues #356, #378). Reads
-	* the ACTIVE family's tunnel when it has one (so `relay-sandbox` surfaces the
-	* external relay wss and `relay-staging` the intoss relay wss); otherwise
-	* falls back to the first booted family that has a tunnel. Returns "down"
-	* until any relay family is booted (any session before the first relay
-	* start_debug) — the correct signal for `start_attach` (no tunnel yet).
-	*/
-	relayTunnelStatus() {
-		if (this.activeFamily?.getTunnelStatus) return this.activeFamily.getTunnelStatus();
-		for (const family of this.bootedFamilies()) if (family.getTunnelStatus) return family.getTunnelStatus();
-		return {
-			up: false,
-			wssUrl: null
-		};
-	}
-	/**
-	* Binds the MCP `Server`; the attach watcher is armed by the first
-	* `start_debug` since no family is active at startup (all-lazy, #396). Called
-	* once after `createDebugServer` + `connect`.
-	*/
-	start(server) {
-		this.server = server;
-		this.armWatcher();
-	}
-	/** Stops the current attach watcher (for shutdown). */
-	stopWatcher() {
-		this.attachWatcher?.stop();
-		this.attachWatcher = null;
-	}
-	/** Arms a fresh attach watcher on the current active connection. */
-	armWatcher() {
-		const server = this.server;
-		if (!server) return;
-		const activeFamily = this.activeFamily;
-		if (!activeFamily) return;
-		this.attachWatcher = startAttachWatcher(activeFamily.connection, server, this.deps.attachWatcherIntervalMs ?? 1e3, () => {
-			this.deps.diagnosticsCollector.recordAttach();
-			this.deps.onPageAttach?.();
-			if (activeFamily.connection.kind === "relay") {
-				const firstTarget = activeFamily.connection.listTargets()[0];
-				const env = deriveEnvironment(activeFamily.connection.kind, activeFamily.relayOrigin);
-				const inspectorStableUrl = this.deps.getInspectorStableUrl?.() ?? null;
-				this.deps.devtoolsOpener.open({
-					inspectorStableUrl,
-					relayHttpBaseUrl: activeFamily.relayHttpUrl,
-					targetId: firstTarget?.id,
-					mintTotp: process.env.AIT_DEBUG_TOTP_SECRET ? () => generateTotp(process.env.AIT_DEBUG_TOTP_SECRET) : void 0,
-					env
-				});
-			}
-		}, () => {
-			this.deps.onPageDetach?.();
-		});
-	}
-	/**
-	* Resolves the `BootedFamily` for `key`: the warm family if already booted,
-	* otherwise boots it via `bootLazyFor(key, projectRoot)` and stores it (once
-	* per key). Since #396 every family is lazy, so this is the single boot path
-	* for all three keys.
-	*
-	* `projectRoot` is forwarded to `bootLazyFor` so `relay-sandbox` boot can
-	* fall back to `.ait_urls` file discovery (#424) when `AIT_RELAY_BASE_URL` is
-	* not set in the environment.
-	*
-	* **Relay-sandbox stale-URL rebuild (issue #610):** when the `relay-sandbox`
-	* family is already warm, reads the current relay URL via
-	* `deps.readSandboxRelayUrl` and compares it against the cached
-	* `relayHttpUrl`. If they differ (dev server was restarted → new tunnel),
-	* the stale family is torn down, evicted from the map, and a fresh one is
-	* booted. If they match, or if the URL cannot be read, the warm family is
-	* reused (fail-open — no unnecessary teardown on transient read errors).
-	*
-	* SECRET-HANDLING: fresh and cached relay URLs carry the tunnel host. The
-	* comparison result (same/different) is the only thing surfaced — URLs are
-	* never logged.
-	*/
-	async familyFor(key, projectRoot) {
-		const warm = this.lazyFamilies.get(key);
-		if (warm) {
-			if (key === "relay-sandbox" && this.deps.readSandboxRelayUrl !== void 0) {
-				let freshUrl = null;
-				try {
-					freshUrl = await this.deps.readSandboxRelayUrl(projectRoot);
-				} catch {
-					freshUrl = null;
-				}
-				if (freshUrl !== null && freshUrl !== warm.relayHttpUrl) {
-					warm.stop();
-					this.lazyFamilies.delete(key);
-					const booted = await this.deps.bootLazyFor(key, projectRoot);
-					this.lazyFamilies.set(key, booted);
-					return booted;
-				}
-			}
-			return warm;
-		}
-		const booted = await this.deps.bootLazyFor(key, projectRoot);
-		this.lazyFamilies.set(key, booted);
-		return booted;
-	}
-	async switchMode(mode, projectRoot) {
-		if (this.swapInFlight) throw new Error("start_debug: 이전 전환이 아직 진행 중입니다 — 잠시 후 다시 호출하세요.");
-		this.swapInFlight = true;
-		try {
-			if (isRelayMode(mode)) await loadRelaySecretReadOnly({ projectRoot });
-			const target = await this.familyFor(familyKeyForMode(mode), projectRoot);
-			this.activeFamily = target;
-			this.stopWatcher();
-			this.armWatcher();
-			this.server?.sendToolListChanged();
-			const wantRelay = isRelayMode(mode);
-			return {
-				mode,
-				environment: deriveEnvironment(target.connection.kind, target.relayOrigin),
-				kind: target.connection.kind,
-				nextStep: wantRelay ? "start_attach로 attach QR 생성 + 폰 attach까지 한 번에 진행하세요 (relay 세션)." : "list_pages로 로컬 Chromium 페이지 attach를 확인하세요."
-			};
-		} finally {
-			this.swapInFlight = false;
-		}
-	}
-};
-/**
-* Boots the live debug stack and serves it over stdio:
-*   1. start the Chii relay on an OS-assigned port (with TOTP auth if
-*      AIT_DEBUG_TOTP_SECRET is set),
-*   2. open a cloudflared quick tunnel to the relay's confirmed port,
-*   3. print relay URL + attach instructions,
-*   4. expose the debug tools backed by a `ChiiCdpConnection` + `ChiiAitSource`.
-*/
-async function runDebugServer(options = {}) {
-	const lockHandle = acquireLock({ force: options.force ?? false });
-	const devtoolsOpener = new AutoDevtoolsOpener();
-	const diagnosticsCollector = new InMemoryDiagnosticsCollector();
-	let activeTunnelChildPid = null;
-	const router = new DualConnectionRouter({
-		bootLazyFor: async (key, projectRoot) => key === "relay-sandbox" ? bootExternalRelayFamily(await readMobileRelayBaseUrl(process.env, projectRoot), await readRelayLocalUrl(process.env, projectRoot)) : key === "local-browser" ? bootLocalFamily() : bootRelayFamily({
-			relayPort: options.relayPort,
-			verifyAuth: buildRelayVerifyAuth(),
-			onWssUrl: (wssUrl) => {
-				lockHandle.updateWssUrl(wssUrl);
-				qrServer?.notifyStateChange();
-			},
-			onTunnelChildPid: (pid) => {
-				activeTunnelChildPid = pid;
-				lockHandle.updateTunnelChildPid(pid);
-			},
-			onAuthReject: () => diagnosticsCollector.recordAuthReject(),
-			onTunnelDown: () => qrServer?.notifyStateChange()
-		}),
-		diagnosticsCollector,
-		devtoolsOpener,
-		onPageAttach: () => qrServer?.notifyStateChange(),
-		onPageDetach: () => qrServer?.notifyStateChange(),
-		getInspectorStableUrl: () => qrServer?.inspectorStableUrl ?? null,
-		readSandboxRelayUrl: (pr) => readMobileRelayBaseUrl(process.env, pr).catch(() => null)
-	});
-	const aitSource = new RoutingAitSource(() => {
-		return router.active;
-	});
-	let lastAttachParts = null;
-	const getDashboardState = () => {
-		const targets = router.active.listTargets();
-		const inspectorUrl = qrServer?.inspectorStableUrl ?? null;
-		return {
-			tunnel: {
-				up: router.relayTunnelStatus().up,
-				wssUrl: router.relayTunnelStatus().wssUrl
-			},
-			pages: targets.map((t) => ({
-				id: t.id,
-				url: t.url
-			})),
-			attachUrl: lastAttachParts ? rebuildAttachUrl(lastAttachParts) : null,
-			inspectorUrl,
-			mode: deriveEnvironment(router.active.kind, router.activeRelayOrigin)
-		};
-	};
-	const getDirectInspectorUrl = () => {
-		const relayHttpUrl = router.activeRelayHttpUrl;
-		if (!relayHttpUrl) return {
-			ok: false,
-			reason: "relayDown"
-		};
-		const targets = router.active.listTargets();
-		if (targets.length === 0) return {
-			ok: false,
-			reason: "noTarget"
-		};
-		const totpSecret = process.env.AIT_DEBUG_TOTP_SECRET;
-		if (!totpSecret) return {
-			ok: false,
-			reason: "totpUnavailable"
-		};
-		const url = buildChiiInspectorUrl(relayHttpUrl, targets[0].id, () => generateTotp(totpSecret, Date.now()));
-		if (url === null) return {
-			ok: false,
-			reason: "totpUnavailable"
-		};
-		return {
-			ok: true,
-			url
-		};
-	};
-	let qrServer;
-	try {
-		qrServer = await startQrHttpServer(getDashboardState, { getDirectInspectorUrl });
-	} catch (err) {
-		logWarn("server.start", { msg: `QR HTTP 서버 시작 실패 (text QR fallback 사용): ${err instanceof Error ? err.message : String(err)}` });
-	}
-	const TOTP_REFRESH_INTERVAL_MS = 2e4;
-	let totpRefreshHandle = null;
-	totpRefreshHandle = setInterval(() => {
-		if (lastAttachParts !== null) qrServer?.notifyStateChange();
-	}, TOTP_REFRESH_INTERVAL_MS);
-	totpRefreshHandle.unref();
-	const server = createDebugServer({
-		connection: router.active,
-		router,
-		aitSource,
-		getTunnelStatus: () => router.relayTunnelStatus(),
-		getTunnelChildPid: () => activeTunnelChildPid,
-		get qrHttpServer() {
-			return qrServer;
-		},
-		diagnosticsCollector,
-		getTotpSecret: () => process.env.AIT_DEBUG_TOTP_SECRET,
-		onAttachUrlBuilt: (parts) => {
-			lastAttachParts = parts;
-			qrServer?.notifyStateChange();
-		}
-	});
-	const transport = new StdioServerTransport();
-	let closed = false;
-	let parentWatcher = null;
-	let maxAgeWatchdog = null;
-	const shutdown = () => {
-		if (closed) return;
-		closed = true;
-		parentWatcher?.stop();
-		maxAgeWatchdog?.stop();
-		if (totpRefreshHandle) clearInterval(totpRefreshHandle);
-		router.stopWatcher();
-		for (const family of router.bootedFamilies()) family.stop();
-		server.close();
-		qrServer?.close();
-		lockHandle.release();
-	};
-	process.once("SIGINT", shutdown);
-	process.once("SIGTERM", shutdown);
-	process.once("SIGHUP", shutdown);
-	process.on("exit", () => {
-		if (!closed) {
-			closed = true;
-			parentWatcher?.stop();
-			maxAgeWatchdog?.stop();
-			if (totpRefreshHandle) clearInterval(totpRefreshHandle);
-			router.stopWatcher();
-			for (const family of router.bootedFamilies()) family.stop();
-			lockHandle.release();
-		}
-	});
-	process.on("uncaughtException", (err) => {
-		logError("tool.error", {
-			msg: `uncaughtException: ${String(err)}`,
-			errorKind: "uncaught"
-		});
-		shutdown();
-		process.exit(1);
-	});
-	process.on("unhandledRejection", (reason) => {
-		logError("tool.error", {
-			msg: `unhandledRejection: ${String(reason)}`,
-			errorKind: "unhandled-rejection"
-		});
-		shutdown();
-		process.exit(1);
-	});
-	await server.connect(transport);
-	router.start(server);
-	if (process.env.AIT_DEBUG_NO_PARENT_WATCH !== "1") {
-		parentWatcher = startParentWatcher(() => {
-			shutdown();
-			process.exit(0);
-		}, { intervalMs: 5e3 });
-		process.stdin.once("end", () => {
-			shutdown();
-			process.exit(0);
-		});
-		process.stdin.once("close", () => {
-			shutdown();
-			process.exit(0);
-		});
-	}
-	if (process.env.AIT_DEBUG_NO_MAX_AGE !== "1") maxAgeWatchdog = startMaxAgeWatchdog(() => {
-		process.stderr.write("[ait-debug] max-age watchdog: daemon lifetime exceeded — shutting down for a fresh start.\n");
-		shutdown();
-		process.exit(0);
-	}, { maxAgeMs: process.env.AIT_DEBUG_MAX_AGE_MS ? Number.parseInt(process.env.AIT_DEBUG_MAX_AGE_MS, 10) || void 0 : void 0 });
-}
-/**
-* Serves the debug stack over stdio with the local browser as the default
-* target. Since #396 NOTHING boots at startup — every family (including the
-* local Chromium) is lazy-booted on its first `start_debug`:
-*   1. `start_debug({ mode: 'local-browser' })` launches a local Chromium with
-*      `--remote-debugging-port=<port>` and attaches a `LocalCdpConnection`;
-*   2. the intoss/external relay families lazy-boot on the first
-*      `start_debug({ mode: 'relay-staging' | 'relay-sandbox' })` (#665: relay-live removed);
-*   3. all of this runs through the SAME direction-neutral
-*      `DualConnectionRouter` that `runDebugServer` uses (issue #356).
-*
-* Symmetry with `runDebugServer` (#356): starting with `--target=local` no
-* longer pins a single-connection router. A `--target=local` session can
-* hot-switch into relay (env 1 → env 3) without restarting the MCP server,
-* closing the asymmetry where only the default (relay-target) entry point had
-* bidirectional hot-switch. The intended fidelity-ladder flow — "validate in
-* env 1 (local), then env 3 (intoss-private) in ONE session, no restart" — now
-* works from either entry point.
-*
-* `start_attach` (relay-specific) stays effectively hidden / non-applicable
-* until the relay family is booted: before the first relay switch the env
-* derives to `mock` and `relayTunnelStatus()` reports "down", so the tool fails
-* with a clear "tunnel not up" message. After a relay switch the relay tunnel
-* is live and the tool works.
-*
-* The AIT.* tools (`AIT.getSdkCallHistory`, `AIT.getMockState`,
-* `AIT.getOperationalEnvironment`) ride the *active* connection's CDP channel
-* via `RoutingAitSource`, so they follow `start_debug` swaps.
-*/
-async function runLocalDebugServer(options = {}) {
-	const lockHandle = acquireLock({ force: options.force ?? false });
-	const cdpPort = options.cdpPort ?? 0;
-	const devUrl = options.devUrl ?? process.env.AIT_DEVTOOLS_URL ?? "http://localhost:5173";
-	const bootLocalFamilyForEntry = async () => {
-		const chromium = await launchChromium({
-			port: cdpPort,
-			devUrl
-		});
-		await new Promise((r) => setTimeout(r, 800));
-		const localConnection = new LocalCdpConnection({ devtoolsHttpUrl: chromium.devtoolsUrl });
-		return {
-			connection: localConnection,
-			stop() {
-				localConnection.close();
-				chromium.stop();
-			}
-		};
-	};
-	const devtoolsOpener = new AutoDevtoolsOpener();
-	const diagnosticsCollector = new InMemoryDiagnosticsCollector();
-	let activeTunnelChildPid = null;
-	const router = new DualConnectionRouter({
-		bootLazyFor: async (key, projectRoot) => key === "relay-sandbox" ? bootExternalRelayFamily(await readMobileRelayBaseUrl(process.env, projectRoot), await readRelayLocalUrl(process.env, projectRoot)) : key === "local-browser" ? bootLocalFamilyForEntry() : bootRelayFamily({
-			verifyAuth: buildRelayVerifyAuth(),
-			onWssUrl: (wssUrl) => {
-				lockHandle.updateWssUrl(wssUrl);
-				qrServer?.notifyStateChange();
-			},
-			onTunnelChildPid: (pid) => {
-				activeTunnelChildPid = pid;
-				lockHandle.updateTunnelChildPid(pid);
-			},
-			onAuthReject: () => diagnosticsCollector.recordAuthReject(),
-			onTunnelDown: () => qrServer?.notifyStateChange()
-		}),
-		diagnosticsCollector,
-		devtoolsOpener,
-		onPageAttach: () => qrServer?.notifyStateChange(),
-		onPageDetach: () => qrServer?.notifyStateChange(),
-		getInspectorStableUrl: () => qrServer?.inspectorStableUrl ?? null,
-		readSandboxRelayUrl: (pr) => readMobileRelayBaseUrl(process.env, pr).catch(() => null)
-	});
-	const aitSource = new RoutingAitSource(() => {
-		return router.active;
-	});
-	let lastAttachParts = null;
-	const getDashboardState = () => {
-		const targets = router.active.listTargets();
-		const inspectorUrl = qrServer?.inspectorStableUrl ?? null;
-		return {
-			tunnel: {
-				up: router.relayTunnelStatus().up,
-				wssUrl: router.relayTunnelStatus().wssUrl
-			},
-			pages: targets.map((t) => ({
-				id: t.id,
-				url: t.url
-			})),
-			attachUrl: lastAttachParts ? rebuildAttachUrl(lastAttachParts) : null,
-			inspectorUrl
-		};
-	};
-	const getDirectInspectorUrl = () => {
-		const relayHttpUrl = router.activeRelayHttpUrl;
-		if (!relayHttpUrl) return {
-			ok: false,
-			reason: "relayDown"
-		};
-		const targets = router.active.listTargets();
-		if (targets.length === 0) return {
-			ok: false,
-			reason: "noTarget"
-		};
-		const totpSecret = process.env.AIT_DEBUG_TOTP_SECRET;
-		if (!totpSecret) return {
-			ok: false,
-			reason: "totpUnavailable"
-		};
-		const url = buildChiiInspectorUrl(relayHttpUrl, targets[0].id, () => generateTotp(totpSecret, Date.now()));
-		if (url === null) return {
-			ok: false,
-			reason: "totpUnavailable"
-		};
-		return {
-			ok: true,
-			url
-		};
-	};
-	let qrServer;
-	try {
-		qrServer = await startQrHttpServer(getDashboardState, { getDirectInspectorUrl });
-	} catch (err) {
-		logWarn("server.start", { msg: `QR HTTP 서버 시작 실패 (text QR fallback 사용): ${err instanceof Error ? err.message : String(err)}` });
-	}
-	const TOTP_REFRESH_INTERVAL_MS = 2e4;
-	let totpRefreshHandle = null;
-	totpRefreshHandle = setInterval(() => {
-		if (lastAttachParts !== null) qrServer?.notifyStateChange();
-	}, TOTP_REFRESH_INTERVAL_MS);
-	totpRefreshHandle.unref();
-	const server = createDebugServer({
-		connection: router.active,
-		router,
-		aitSource,
-		getTunnelStatus: () => router.relayTunnelStatus(),
-		getTunnelChildPid: () => activeTunnelChildPid,
-		get qrHttpServer() {
-			return qrServer;
-		},
-		diagnosticsCollector,
-		getTotpSecret: () => process.env.AIT_DEBUG_TOTP_SECRET,
-		onAttachUrlBuilt: (parts) => {
-			lastAttachParts = parts;
-			qrServer?.notifyStateChange();
-		}
-	});
-	const transport = new StdioServerTransport();
-	let closed = false;
-	let parentWatcher = null;
-	let maxAgeWatchdog = null;
-	const shutdown = () => {
-		if (closed) return;
-		closed = true;
-		parentWatcher?.stop();
-		maxAgeWatchdog?.stop();
-		if (totpRefreshHandle) clearInterval(totpRefreshHandle);
-		router.stopWatcher();
-		for (const family of router.bootedFamilies()) family.stop();
-		server.close();
-		qrServer?.close();
-		lockHandle.release();
-	};
-	process.once("SIGINT", shutdown);
-	process.once("SIGTERM", shutdown);
-	process.once("SIGHUP", shutdown);
-	process.on("exit", () => {
-		if (!closed) {
-			closed = true;
-			parentWatcher?.stop();
-			maxAgeWatchdog?.stop();
-			if (totpRefreshHandle) clearInterval(totpRefreshHandle);
-			router.stopWatcher();
-			for (const family of router.bootedFamilies()) family.stop();
-			lockHandle.release();
-		}
-	});
-	process.on("uncaughtException", (err) => {
-		logError("tool.error", {
-			msg: `uncaughtException: ${String(err)}`,
-			errorKind: "uncaught",
-			mode: "local-browser"
-		});
-		shutdown();
-		process.exit(1);
-	});
-	process.on("unhandledRejection", (reason) => {
-		logError("tool.error", {
-			msg: `unhandledRejection: ${String(reason)}`,
-			errorKind: "unhandled-rejection",
-			mode: "local-browser"
-		});
-		shutdown();
-		process.exit(1);
-	});
-	await server.connect(transport);
-	router.start(server);
-	if (process.env.AIT_DEBUG_NO_PARENT_WATCH !== "1") {
-		parentWatcher = startParentWatcher(() => {
-			shutdown();
-			process.exit(0);
-		}, { intervalMs: 5e3 });
-		process.stdin.once("end", () => {
-			shutdown();
-			process.exit(0);
-		});
-		process.stdin.once("close", () => {
-			shutdown();
-			process.exit(0);
-		});
-	}
-	if (process.env.AIT_DEBUG_NO_MAX_AGE !== "1") maxAgeWatchdog = startMaxAgeWatchdog(() => {
-		process.stderr.write("[ait-debug] max-age watchdog: daemon lifetime exceeded — shutting down for a fresh start.\n");
-		shutdown();
-		process.exit(0);
-	}, { maxAgeMs: process.env.AIT_DEBUG_MAX_AGE_MS ? Number.parseInt(process.env.AIT_DEBUG_MAX_AGE_MS, 10) || void 0 : void 0 });
-}
-/**
-* Serves the env-2 (real-device PWA) debug stack over stdio with the external
-* Chii relay as the default target (issue #378). Since #396 NOTHING boots at
-* startup — the external relay family is lazy-booted on the first
-* `start_debug({ mode: 'relay-sandbox' })`.
-*
-* Unlike `runDebugServer` (which starts its own relay + cloudflared tunnel),
-* `runMobileDebugServer` attaches to a relay the unplugin ALREADY brought up
-* (`tunnel: { cdp: true }`) and exposed via `AIT_RELAY_BASE_URL`. The MCP only
-* opens a CDP client against that external relay — it never starts or tears down
-* a relay or a tunnel it did not own (see {@link bootExternalRelayFamily}).
-*
-* Symmetry with `runDebugServer` / `runLocalDebugServer` (#356, #378, #396): all
-* three families are lazy-booted — the env-2 external relay on the first
-* `start_debug({ mode: 'relay-sandbox' })`, the local family on `local-browser`,
-* the intoss relay on `relay-staging` (#665: relay-live removed) — so a
-* `--target=mobile` session can hot-switch without a restart. The active env
-* derives to `relay-mobile` (external-PWA origin).
-*
-* SECRET-HANDLING: `AIT_RELAY_BASE_URL` is read once here via
-* {@link readMobileRelayBaseUrl}; when unset it throws
-* {@link MOBILE_RELAY_BASE_URL_MISSING_MESSAGE} — a message that names the env
-* var and how to obtain it, never echoing any URL value. The error propagates to
-* the bin entry's fatal handler (the missing-URL path prints the guidance, not a
-* value). The present value is passed straight to the CDP client, never logged.
-*/
-async function runMobileDebugServer(options = {}) {
-	const relayBaseUrl = await readMobileRelayBaseUrl(process.env, options.projectRoot ?? process.cwd());
-	const lockHandle = acquireLock({ force: options.force ?? false });
-	const devtoolsOpener = new AutoDevtoolsOpener();
-	const diagnosticsCollector = new InMemoryDiagnosticsCollector();
-	let activeTunnelChildPid = null;
-	const router = new DualConnectionRouter({
-		bootLazyFor: async (key) => key === "relay-sandbox" ? bootExternalRelayFamily(relayBaseUrl, await readRelayLocalUrl(process.env, options.projectRoot ?? process.cwd())) : key === "local-browser" ? bootLocalFamily() : bootRelayFamily({
-			verifyAuth: buildRelayVerifyAuth(),
-			onWssUrl: (wssUrl) => {
-				lockHandle.updateWssUrl(wssUrl);
-				qrServer?.notifyStateChange();
-			},
-			onTunnelChildPid: (pid) => {
-				activeTunnelChildPid = pid;
-				lockHandle.updateTunnelChildPid(pid);
-			},
-			onAuthReject: () => diagnosticsCollector.recordAuthReject(),
-			onTunnelDown: () => qrServer?.notifyStateChange()
-		}),
-		diagnosticsCollector,
-		devtoolsOpener,
-		onPageAttach: () => qrServer?.notifyStateChange(),
-		onPageDetach: () => qrServer?.notifyStateChange(),
-		getInspectorStableUrl: () => qrServer?.inspectorStableUrl ?? null,
-		readSandboxRelayUrl: (pr) => readMobileRelayBaseUrl(process.env, pr ?? options.projectRoot ?? process.cwd()).catch(() => null)
-	});
-	const aitSource = new RoutingAitSource(() => {
-		return router.active;
-	});
-	let lastAttachParts = null;
-	const getDashboardState = () => {
-		const targets = router.active.listTargets();
-		const inspectorUrl = qrServer?.inspectorStableUrl ?? null;
-		return {
-			tunnel: {
-				up: router.relayTunnelStatus().up,
-				wssUrl: router.relayTunnelStatus().wssUrl
-			},
-			pages: targets.map((t) => ({
-				id: t.id,
-				url: t.url
-			})),
-			attachUrl: lastAttachParts ? rebuildAttachUrl(lastAttachParts) : null,
-			inspectorUrl
-		};
-	};
-	const getDirectInspectorUrl = () => {
-		const relayHttpUrl = router.activeRelayHttpUrl;
-		if (!relayHttpUrl) return {
-			ok: false,
-			reason: "relayDown"
-		};
-		const targets = router.active.listTargets();
-		if (targets.length === 0) return {
-			ok: false,
-			reason: "noTarget"
-		};
-		const totpSecret = process.env.AIT_DEBUG_TOTP_SECRET;
-		if (!totpSecret) return {
-			ok: false,
-			reason: "totpUnavailable"
-		};
-		const url = buildChiiInspectorUrl(relayHttpUrl, targets[0].id, () => generateTotp(totpSecret, Date.now()));
-		if (url === null) return {
-			ok: false,
-			reason: "totpUnavailable"
-		};
-		return {
-			ok: true,
-			url
-		};
-	};
-	let qrServer;
-	try {
-		qrServer = await startQrHttpServer(getDashboardState, { getDirectInspectorUrl });
-	} catch (err) {
-		logWarn("server.start", { msg: `QR HTTP 서버 시작 실패 (text QR fallback 사용): ${err instanceof Error ? err.message : String(err)}` });
-	}
-	const TOTP_REFRESH_INTERVAL_MS = 2e4;
-	let totpRefreshHandle = null;
-	totpRefreshHandle = setInterval(() => {
-		if (lastAttachParts !== null) qrServer?.notifyStateChange();
-	}, TOTP_REFRESH_INTERVAL_MS);
-	totpRefreshHandle.unref();
-	const server = createDebugServer({
-		connection: router.active,
-		router,
-		aitSource,
-		getTunnelStatus: () => router.relayTunnelStatus(),
-		getTunnelChildPid: () => activeTunnelChildPid,
-		get qrHttpServer() {
-			return qrServer;
-		},
-		diagnosticsCollector,
-		getTotpSecret: () => process.env.AIT_DEBUG_TOTP_SECRET,
-		onAttachUrlBuilt: (parts) => {
-			lastAttachParts = parts;
-			qrServer?.notifyStateChange();
-		}
-	});
-	const transport = new StdioServerTransport();
-	let closed = false;
-	let parentWatcher = null;
-	let maxAgeWatchdog = null;
-	const shutdown = () => {
-		if (closed) return;
-		closed = true;
-		parentWatcher?.stop();
-		maxAgeWatchdog?.stop();
-		if (totpRefreshHandle) clearInterval(totpRefreshHandle);
-		router.stopWatcher();
-		for (const family of router.bootedFamilies()) family.stop();
-		server.close();
-		qrServer?.close();
-		lockHandle.release();
-	};
-	process.once("SIGINT", shutdown);
-	process.once("SIGTERM", shutdown);
-	process.once("SIGHUP", shutdown);
-	process.on("exit", () => {
-		if (!closed) {
-			closed = true;
-			parentWatcher?.stop();
-			maxAgeWatchdog?.stop();
-			if (totpRefreshHandle) clearInterval(totpRefreshHandle);
-			router.stopWatcher();
-			for (const family of router.bootedFamilies()) family.stop();
-			lockHandle.release();
-		}
-	});
-	process.on("uncaughtException", (err) => {
-		logError("tool.error", {
-			msg: `uncaughtException: ${String(err)}`,
-			errorKind: "uncaught",
-			mode: "relay-sandbox"
-		});
-		shutdown();
-		process.exit(1);
-	});
-	process.on("unhandledRejection", (reason) => {
-		logError("tool.error", {
-			msg: `unhandledRejection: ${String(reason)}`,
-			errorKind: "unhandled-rejection",
-			mode: "relay-sandbox"
-		});
-		shutdown();
-		process.exit(1);
-	});
-	await server.connect(transport);
-	router.start(server);
-	if (process.env.AIT_DEBUG_NO_PARENT_WATCH !== "1") {
-		parentWatcher = startParentWatcher(() => {
-			shutdown();
-			process.exit(0);
-		}, { intervalMs: 5e3 });
-		process.stdin.once("end", () => {
-			shutdown();
-			process.exit(0);
-		});
-		process.stdin.once("close", () => {
-			shutdown();
-			process.exit(0);
-		});
-	}
-	if (process.env.AIT_DEBUG_NO_MAX_AGE !== "1") maxAgeWatchdog = startMaxAgeWatchdog(() => {
-		process.stderr.write("[ait-debug] max-age watchdog: daemon lifetime exceeded — shutting down for a fresh start.\n");
-		shutdown();
-		process.exit(0);
-	}, { maxAgeMs: process.env.AIT_DEBUG_MAX_AGE_MS ? Number.parseInt(process.env.AIT_DEBUG_MAX_AGE_MS, 10) || void 0 : void 0 });
-}
-//#endregion
-export { wrapEnvelope as a, runMobileDebugServer as i, runDebugServer as n, runLocalDebugServer as r, debug_server_exports as t };
-
-//# sourceMappingURL=debug-server-IVaJ9vHH.js.map