@mcpeak/cli 0.14.1 → 0.15.0

package/dist/{src-CsQbffCA.cjs → src-B_7lzRQz.cjs}

@@ -1,9 +1,9 @@
 let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_os = require("node:os");
 let node_path = require("node:path");
 let _mcpeak_runner = require("@mcpeak/runner");
-let node_fs = require("node:fs");
 let node_child_process = require("node:child_process");
 let _mcpeak_core = require("@mcpeak/core");
 let node_url = require("node:url");
@@ -11,13 +11,16 @@ let node_readline_promises = require("node:readline/promises");
 let node_util = require("node:util");
 let _mcpeak_generate = require("@mcpeak/generate");
 //#region ../audit/package.json
-var version$2 = "0.3.1";
+var version$3 = "0.3.1";
 //#endregion
 //#region ../optimize/package.json
-var version$1 = "0.2.2";
+var version$2 = "0.2.2";
+//#endregion
+//#region ../perf/package.json
+var version$1 = "0.1.0";
 //#endregion
 //#region package.json
-var version = "0.14.1";
+var version = "0.15.0";
 //#endregion
 //#region src/audit-sandbox-target.ts
 /**
@@ -738,6 +741,41 @@ stdio 서버를 띄울 때 GITHUB_TOKEN 같은 흔한 비밀 이름에 가짜
 --sandbox 없이는 도구 정의의 문형과 프로토콜 표면만 봅니다. 바꿔 말한 지시와 서버 코드의 실제
 행위는 보지 못하므로 발견 0 이 안전하다는 뜻은 아닙니다. --sandbox 는 한 번의 실행에서 관측된
 행위만 봅니다. 판정은 이 컴퓨터 안에서만 하고 도구 정의를 외부로 보내지 않습니다.`;
+const PERF_USAGE = "사용법: mcpeak perf <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] [--env <NAME> ...]) [--repeat <n>] [--interval-ms <ms>] [--tool <name> ...] [--baseline <path> [--update-baseline]] [--threshold-pct <n>] [--threshold-ms <n>] [--json]";
+/**
+* perf 옵션 설명. 설계 §8.4 의 옵션 표를 옮긴 것이다. 사용법 한 줄로는 기준선 판정의 허용치가
+* 무엇에 걸리는지, 간격 기본값 0 이 무슨 뜻인지 알 수 없다. 둘 다 결과를 잘못 읽게 하는 값이다.
+* 원격 옵션 설명(`REMOTE_TARGET_OPTIONS`)은 넣지 않는다. perf 는 그 옵션을 거절한다.
+*/
+const PERF_OPTIONS = `옵션:
+  -- <executable> [args...]
+                        \`--\` 뒤는 전부 서버를 띄울 명령입니다. 첫 토큰이 실행 파일,
+                        나머지가 그 인자입니다. \`--command\`/\`--arg\` 와 같은 일을 하며
+                        함께 쓸 수 없습니다
+  --repeat <n>          케이스당 호출 수입니다. 기본값은 5 입니다. 1 이상 100 이하 정수
+  --interval-ms <ms>    호출 사이 대기입니다. 기본값은 0 입니다. 0 이상 60000 이하 정수.
+                        리포트 설정 줄에 표시됩니다
+  --tool <name>         그 도구의 케이스만 잽니다. 반복할 수 있습니다
+  --baseline <path>     기준 파일입니다. 있으면 비교하고, --update-baseline 과 함께면
+                        씁니다
+  --update-baseline     측정 결과로 기준 파일을 씁니다. 비교하지 않습니다.
+                        --baseline 과 함께 써야 하고 --tool 과는 함께 쓸 수 없습니다
+  --threshold-pct <n>   서버 안 p50 회귀의 비율 허용치입니다. 기본값은 50 입니다.
+                        0 이상 1000 이하 정수
+  --threshold-ms <n>    서버 안 p50 회귀의 절대 허용치입니다. 기본값은 20 입니다.
+                        0 이상 60000 이하 정수. 기준의 (1 + 비율/100)배에 이 값을 더한
+                        것을 넘으면 회귀입니다
+  --json                리포트 대신 결과 JSON 하나를 stdout 에 냅니다
+${ENV_FORWARD_OPTION}
+
+측정 대상은 명세의 callTool 케이스 중 거절(isError: true)을 기대하지 않는 것입니다. 서버 프로세스
+안에 관측 코드를 실어야 하므로 --url 과 --header-env 는 받지 않습니다.
+
+--interval-ms 기본값 0 은 서버의 레이트리미터 대기가 서버 안 시간으로 보일 수 있다는 뜻입니다.
+어떤 양수도 그 서버의 한도를 아는 척하는 값이라 기본을 0 으로 두고 설정 줄에 적습니다.
+
+종료 코드는 측정 완료 0, 기준선 회귀 2, 사용 오류·연결 실패·명세 오류·기준 파일 오류 1 입니다.
+진단은 종료 코드를 바꾸지 않습니다.`;
 const GLOBAL_HELP = `MCPeak — MCP 서버 테스트 프레임워크
 
 사용법: mcpeak <명령> [옵션]
@@ -749,6 +787,7 @@ const GLOBAL_HELP = `MCPeak — MCP 서버 테스트 프레임워크
   repair    실패한 test 실행의 번들로 서버 코드의 원인 후보를 제안받습니다.
   optimize  기능을 바꾸지 않고 MCP 서버의 도구 정의를 줄인 오버레이를 만듭니다.
   audit     MCP 서버를 쓰기 전에 도구 정의와 프로토콜의 보안 위험을 점검합니다.
+  perf      도구 호출 지연을 외부 대기와 서버 안 시간으로 나누고 회귀를 잡습니다.
 
 옵션:
   -h, --help  도움말을 표시합니다.
@@ -767,13 +806,20 @@ const GLOBAL_HELP = `MCPeak — MCP 서버 테스트 프레임워크
 * "어떤 명령이 있나" 를 모르는 상태다. 특정 서브커맨드의 플래그 목록을 붙이면 사용자가
 * 묻지도 않은 명령의 사용법 200 자를 읽고 나서야 목록에 닿는다.
 */
-const commandDiscovery = "사용 가능한 명령: test, generate, repair, optimize, audit. 전체 도움말: mcpeak --help";
+const commandDiscovery = "사용 가능한 명령: test, generate, repair, optimize, audit, perf. 전체 도움말: mcpeak --help";
 const TEST_USAGE_HINT = `${TEST_USAGE} ${commandDiscovery}`;
 const GENERATE_USAGE_HINT = `${GENERATE_USAGE} ${commandDiscovery}`;
 const REPAIR_USAGE_HINT = `${REPAIR_USAGE} ${commandDiscovery}`;
 const OPTIMIZE_USAGE_HINT = `${OPTIMIZE_USAGE} ${commandDiscovery}`;
 const AUDIT_USAGE_HINT = `${AUDIT_USAGE} ${commandDiscovery}`;
+const PERF_USAGE_HINT = `${PERF_USAGE} ${commandDiscovery}`;
 function commandHelp(command) {
+	if (command === "perf") return `perf — 도구 호출 지연을 외부 대기와 서버 안 시간으로 나누고 회귀를 잡습니다.
+
+${PERF_USAGE}
+
+${PERF_OPTIONS}
+`;
 	if (command === "test") return `test — JSON 테스트 명세로 MCP 서버를 실행하고 검증합니다.
 
 ${TEST_USAGE}
@@ -2133,14 +2179,14 @@ function resetFailure(error) {
 * 노드 오류의 `code`. 문자열(`ENOENT`)이거나 숫자일 수 있고, 둘 다 아니면 우리가 아는 것이
 * 없다. `junitWriteFailure` 가 쓰던 것을 꺼내 다른 실패 생성기와 함께 쓴다(#276).
 */
-function errnoOf(error) {
+function errnoOf$1(error) {
 	const code = error?.code;
 	return typeof code === "string" || typeof code === "number" ? String(code) : "알 수 없음";
 }
 function junitWriteFailure(path, error) {
 	return {
 		code: "JUNIT_WRITE_FAILED",
-		message: `JUnit XML 파일을 쓰지 못했습니다: ${escapeTerminalText(path)}\n  errno: ${escapeTerminalText(errnoOf(error))}`,
+		message: `JUnit XML 파일을 쓰지 못했습니다: ${escapeTerminalText(path)}\n  errno: ${escapeTerminalText(errnoOf$1(error))}`,
 		hint: dictionary.JUNIT_WRITE_FAILED.hint
 	};
 }
@@ -2151,7 +2197,7 @@ function junitWriteFailure(path, error) {
 function repairBundleWriteFailure(path, error) {
 	return {
 		code: "REPAIR_BUNDLE_WRITE_FAILED",
-		message: `repair 번들 파일을 쓰지 못했습니다: ${escapeTerminalText(path)}\n  errno: ${escapeTerminalText(errnoOf(error))}`,
+		message: `repair 번들 파일을 쓰지 못했습니다: ${escapeTerminalText(path)}\n  errno: ${escapeTerminalText(errnoOf$1(error))}`,
 		hint: dictionary.REPAIR_BUNDLE_WRITE_FAILED.hint
 	};
 }
@@ -2160,9 +2206,9 @@ function repairBundleWriteFailure(path, error) {
 * 없으면 권한을 고친다. 둘을 한 문장으로 묶으면 사용자에게 둘 다 확인하게 만든다(#276).
 * 어느 쪽인지 아는데 안 말할 이유가 없다.
 */
-function suiteReadFailure(path, error) {
+function suiteReadFailure$1(path, error) {
 	const shown = escapeTerminalText(path);
-	const errno = errnoOf(error);
+	const errno = errnoOf$1(error);
 	if (errno === "ENOENT") return {
 		code: "SUITE_READ_FAILED",
 		message: `테스트 명세 파일이 그 경로에 없습니다: ${shown}`,
@@ -2193,7 +2239,7 @@ function suiteReadFailure(path, error) {
 * 인코딩을 아예 언급하지 않는다 — 한 번 꺼내면 그것부터 확인하러 가고, 여기서 할 일은
 * 경로를 고치는 것 하나다.
 */
-function suiteFormatFailure(path) {
+function suiteFormatFailure$1(path) {
 	const ext = (0, node_path.extname)(path);
 	return {
 		code: "SUITE_FORMAT_UNSUPPORTED",
@@ -2326,12 +2372,12 @@ async function runCliCore(argv, dependencies, childEnv) {
 			...dictionary.CLI_INTERNAL_ERROR
 		});
 	}
-	if ((0, node_path.extname)(input.suitePath).toLowerCase() !== ".json") return writeFailure(dependencies, suiteFormatFailure(input.suitePath));
+	if ((0, node_path.extname)(input.suitePath).toLowerCase() !== ".json") return writeFailure(dependencies, suiteFormatFailure$1(input.suitePath));
 	let bytes;
 	try {
 		bytes = await dependencies.readFile(input.suitePath);
 	} catch (error) {
-		return writeFailure(dependencies, suiteReadFailure(input.suitePath, error));
+		return writeFailure(dependencies, suiteReadFailure$1(input.suitePath, error));
 	}
 	let decoded;
 	try {
@@ -3205,18 +3251,18 @@ function externalModeOf(argv) {
 //#endregion
 //#region src/audit-command.ts
 /** 서버 연결 stderr 진단의 줄 수. `test` 의 `--stderr-lines` 기본값과 같다. */
-const STDERR_LINES$1 = 20;
+const STDERR_LINES$2 = 20;
 const PROBE_POLICIES = [
 	"readonly",
 	"none",
 	"all"
 ];
-var UsageError$3 = class extends Error {};
+var UsageError$4 = class extends Error {};
 /**
 * `test` 는 받지만 `audit` 에는 뜻이 없는 옵션. `parseTestCommand` 에 넘기기 전에 여기서
 * 거절한다. 넘기면 조용히 통과하거나 "test 옵션" 이라는 남의 이름으로 거절된다.
 */
-const TEST_ONLY_OPTIONS$1 = /* @__PURE__ */ new Set([
+const TEST_ONLY_OPTIONS$2 = /* @__PURE__ */ new Set([
 	"--junit",
 	"--repair-bundle",
 	"--determinism",
@@ -3226,7 +3272,7 @@ const TEST_ONLY_OPTIONS$1 = /* @__PURE__ */ new Set([
 	"--record-session"
 ]);
 /** 대상 옵션 중 값을 다음 토큰으로 받는 것. 그 값이 `--json` 처럼 생겨도 옵션으로 읽지 않는다. */
-const TARGET_VALUE_OPTIONS$1 = /* @__PURE__ */ new Set([
+const TARGET_VALUE_OPTIONS$2 = /* @__PURE__ */ new Set([
 	"--command",
 	"--arg",
 	"--env",
@@ -3296,57 +3342,57 @@ function parseAuditCommand(argv) {
 		}
 		const name = token.startsWith("--") && token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
 		if (name === "--probe") {
-			if (probe !== void 0) throw new UsageError$3("`--probe`은 한 번만 사용할 수 있습니다.");
+			if (probe !== void 0) throw new UsageError$4("`--probe`은 한 번만 사용할 수 있습니다.");
 			const value = token === "--probe" ? argv[++index] : token.slice(8);
-			if (!PROBE_POLICIES.includes(value)) throw new UsageError$3("--probe 값은 readonly, none, all 중 하나입니다.");
+			if (!PROBE_POLICIES.includes(value)) throw new UsageError$4("--probe 값은 readonly, none, all 중 하나입니다.");
 			probe = value;
 			continue;
 		}
 		if (name === "--baseline") {
-			if (baselinePath !== void 0) throw new UsageError$3("`--baseline`은 한 번만 사용할 수 있습니다.");
+			if (baselinePath !== void 0) throw new UsageError$4("`--baseline`은 한 번만 사용할 수 있습니다.");
 			const value = token === "--baseline" ? argv[++index] : token.slice(11);
-			if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$3("`--baseline` 옵션 값이 필요합니다.");
+			if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$4("`--baseline` 옵션 값이 필요합니다.");
 			baselinePath = value;
 			continue;
 		}
 		if (FLAG_OPTIONS.includes(name)) {
 			const flag = name;
-			if (token !== name) throw new UsageError$3(`\`${name}\`은 값을 받지 않습니다.`);
-			if (flags[flag]) throw new UsageError$3(`\`${name}\`은 한 번만 사용할 수 있습니다.`);
+			if (token !== name) throw new UsageError$4(`\`${name}\`은 값을 받지 않습니다.`);
+			if (flags[flag]) throw new UsageError$4(`\`${name}\`은 한 번만 사용할 수 있습니다.`);
 			flags[flag] = true;
 			continue;
 		}
 		if (SANDBOX_PATH_OPTIONS.includes(name)) {
 			const option = name;
-			if (paths[option] !== void 0) throw new UsageError$3(`\`${name}\`은 한 번만 사용할 수 있습니다.`);
+			if (paths[option] !== void 0) throw new UsageError$4(`\`${name}\`은 한 번만 사용할 수 있습니다.`);
 			const value = token === name ? argv[++index] : token.slice(name.length + 1);
-			if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$3(`\`${name}\` 옵션 값이 필요합니다.`);
+			if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$4(`\`${name}\` 옵션 값이 필요합니다.`);
 			paths[option] = value;
 			continue;
 		}
 		if (name === "--allow-host") {
 			const value = token === name ? argv[++index] : token.slice(name.length + 1);
-			if (value === void 0 || token === name && value.startsWith("--")) throw new UsageError$3("`--allow-host` 옵션 값이 필요합니다.");
-			if (value.length > 253 || !HOSTNAME.test(value)) throw new UsageError$3(`--allow-host 값은 호스트 이름이어야 합니다(예: api.example.com): '${escapeTerminalText$2(value)}'`);
+			if (value === void 0 || token === name && value.startsWith("--")) throw new UsageError$4("`--allow-host` 옵션 값이 필요합니다.");
+			if (value.length > 253 || !HOSTNAME.test(value)) throw new UsageError$4(`--allow-host 값은 호스트 이름이어야 합니다(예: api.example.com): '${escapeTerminalText$2(value)}'`);
 			allowHosts.push(value);
 			continue;
 		}
 		if (name === "--url") usesUrl = true;
-		if (TEST_ONLY_OPTIONS$1.has(name) || token.startsWith("-") && !TARGET_VALUE_OPTIONS$1.has(name)) throw new UsageError$3(`지원하지 않는 audit 옵션 '${escapeTerminalText$2(name)}'입니다.`);
+		if (TEST_ONLY_OPTIONS$2.has(name) || token.startsWith("-") && !TARGET_VALUE_OPTIONS$2.has(name)) throw new UsageError$4(`지원하지 않는 audit 옵션 '${escapeTerminalText$2(name)}'입니다.`);
 		targetArgv.push(token);
-		if (TARGET_VALUE_OPTIONS$1.has(token) && index + 1 < argv.length) targetArgv.push(argv[++index]);
+		if (TARGET_VALUE_OPTIONS$2.has(token) && index + 1 < argv.length) targetArgv.push(argv[++index]);
 	}
 	const updateBaseline = flags["--update-baseline"];
 	const json = flags["--json"];
-	if (updateBaseline && baselinePath === void 0) throw new UsageError$3("--update-baseline 은 --baseline 과 함께 써야 합니다.");
+	if (updateBaseline && baselinePath === void 0) throw new UsageError$4("--update-baseline 은 --baseline 과 함께 써야 합니다.");
 	const sandbox = parseSandbox(flags, paths, allowHosts, usesUrl);
 	let target;
 	try {
 		target = parseTestCommand([PLACEHOLDER_SUITE$1, ...targetArgv]).target;
 	} catch (error) {
-		const message = usageMessageOf$1(error);
+		const message = usageMessageOf$2(error);
 		if (message === void 0) throw error;
-		throw new UsageError$3(message);
+		throw new UsageError$4(message);
 	}
 	return Object.freeze({
 		target,
@@ -3363,13 +3409,13 @@ function parseSandbox(flags, paths, allowHosts, usesUrl) {
 	if (!flags["--sandbox"]) {
 		const given = (option) => option === "--allow-host" ? allowHosts.length > 0 : option === "--compare-host" ? flags[option] : paths[option] !== void 0;
 		const orphan = SANDBOX_ONLY_OPTIONS.find(given);
-		if (orphan !== void 0) throw new UsageError$3(`${orphan} 은 --sandbox 와 함께 써야 합니다.`);
+		if (orphan !== void 0) throw new UsageError$4(`${orphan} 은 --sandbox 와 함께 써야 합니다.`);
 		return;
 	}
-	if (usesUrl) throw new UsageError$3("--sandbox 는 --url 과 함께 쓸 수 없습니다. 격리는 프로세스를 띄우는 대상(--, --command)에만 적용됩니다.");
+	if (usesUrl) throw new UsageError$4("--sandbox 는 --url 과 함께 쓸 수 없습니다. 격리는 프로세스를 띄우는 대상(--, --command)에만 적용됩니다.");
 	const record = paths["--sandbox-session"];
 	const replay = paths["--sandbox-replay"];
-	if (record !== void 0 && replay !== void 0) throw new UsageError$3("--sandbox-session 과 --sandbox-replay 는 함께 쓸 수 없습니다. 녹화와 재생은 따로 실행하세요.");
+	if (record !== void 0 && replay !== void 0) throw new UsageError$4("--sandbox-session 과 --sandbox-replay 는 함께 쓸 수 없습니다. 녹화와 재생은 따로 실행하세요.");
 	const session = record !== void 0 ? {
 		mode: "record",
 		path: record
@@ -3386,14 +3432,14 @@ function parseSandbox(flags, paths, allowHosts, usesUrl) {
 	};
 }
 /** `parseTestCommand` 가 던진 사용 오류의 문장. 그 오류 클래스는 export 되지 않아 모양으로 본다. */
-function usageMessageOf$1(error) {
+function usageMessageOf$2(error) {
 	if (typeof error !== "object" || error === null || !("failure" in error)) return void 0;
 	const failure = error.failure;
 	if (typeof failure !== "object" || failure === null) return void 0;
 	const { code, message } = failure;
 	return code === "CLI_USAGE" && typeof message === "string" ? message : void 0;
 }
-function usageFailure$1(deps, message) {
+function usageFailure$2(deps, message) {
 	deps.writeStderr(`오류 [CLI_USAGE]: ${message}\n해결: ${AUDIT_USAGE_HINT}\n`);
 	return 1;
 }
@@ -3450,13 +3496,13 @@ async function runAuditCommand(argv, deps) {
 	try {
 		input = parseAuditCommand(argv[0] === "audit" ? argv.slice(1) : argv);
 	} catch (error) {
-		if (!(error instanceof UsageError$3)) throw error;
-		return usageFailure$1(deps, error.message);
+		if (!(error instanceof UsageError$4)) throw error;
+		return usageFailure$2(deps, error.message);
 	}
 	try {
 		await preflight(input.target, deps.readEnv);
 	} catch (error) {
-		if (error instanceof ConnectTargetError) return usageFailure$1(deps, error.message);
+		if (error instanceof ConnectTargetError) return usageFailure$2(deps, error.message);
 		throw error;
 	}
 	const forwardedEnv = {};
@@ -3513,7 +3559,7 @@ async function runAuditCommand(argv, deps) {
 	try {
 		sandbox = await sandboxOptions(input, deps);
 	} catch (error) {
-		if (error instanceof SandboxTargetError) return usageFailure$1(deps, error.message);
+		if (error instanceof SandboxTargetError) return usageFailure$2(deps, error.message);
 		throw error;
 	}
 	let report;
@@ -3546,14 +3592,14 @@ async function runAuditCommand(argv, deps) {
 	} catch (error) {
 		const kept = cleanupFailureReport(error);
 		if (kept === void 0) return writeAuditFailure(deps, input.target, error, connectError, runnerConnectFailed);
-		writeReport(deps, input, kept);
+		writeReport$1(deps, input, kept);
 		deps.writeStderr(`${escapeLines(error.message)}\n`);
 		return 1;
 	}
-	writeReport(deps, input, report);
+	writeReport$1(deps, input, report);
 	return report.exitCode;
 }
-function writeReport(deps, input, report) {
+function writeReport$1(deps, input, report) {
 	deps.writeStdout(input.json ? `${JSON.stringify(report, null, 2)}\n` : escapeLines(deps.renderReport(report)));
 }
 /**
@@ -3625,7 +3671,7 @@ function writeAuditFailure(deps, target, error, connectError, runnerConnectFaile
 `);
 		return 1;
 	}
-	const core = coreErrorOf$1(error);
+	const core = coreErrorOf$2(error);
 	const cause = core?.message ?? (error instanceof Error ? error.message : String(error));
 	const hint = core?.hint ?? "mcpeak test 로 같은 서버가 tools/list 에 답하는지 먼저 확인하세요.";
 	deps.writeStderr(`오류 [AUDIT_FAILED]: 서버에 붙은 뒤 점검 도중 실패했습니다: ${escapeTerminalText$2(describeTarget(target))}\n→ ${escapeTerminalText$2(cause.split("\n")[0] ?? "")}\n해결: ${escapeTerminalText$2(hint)}\n`);
@@ -3645,20 +3691,20 @@ function errorCode(error) {
 }
 /** core 오류가 들고 온 진단 블록. `test`·`optimize` 의 연결 실패와 같은 규칙이다. */
 function writeDiagnostics(deps, error) {
-	const core = coreErrorOf$1(error);
+	const core = coreErrorOf$2(error);
 	const processBlock = processDiagnostics(core?.diagnostics);
 	if (processBlock !== void 0 && hasDiagnosticContent(processBlock)) {
-		const block = renderProcessDiagnostics(processBlock, { maxLines: STDERR_LINES$1 });
+		const block = renderProcessDiagnostics(processBlock, { maxLines: STDERR_LINES$2 });
 		if (block !== "") deps.writeStderr(`\n${block}`);
 	}
 	const remote = httpDiagnostics(core?.diagnostics);
 	if (remote !== void 0) deps.writeStderr(`\n${renderHttpDiagnostics(remote)}`);
 }
 /** `McpClientError` 를 AggregateError 안까지 찾는다. 연결 정리 실패가 겹치면 그렇게 감싸인다. */
-function coreErrorOf$1(error) {
+function coreErrorOf$2(error) {
 	if (error instanceof AggregateError) {
 		for (const nested of error.errors) {
-			const found = coreErrorOf$1(nested);
+			const found = coreErrorOf$2(nested);
 			if (found !== void 0) return found;
 		}
 		return;
@@ -4797,7 +4843,7 @@ function selectRepairTargets(options) {
 }
 //#endregion
 //#region src/generate-command.ts
-var UsageError$2 = class extends Error {};
+var UsageError$3 = class extends Error {};
 /**
 * 출력 경로에 이미 파일이 있어 저장을 멈춘 경우. 다른 I/O 실패와 사용자 조치가 다르므로
 * 타입으로 갈라 둔다. 뭉뚱그리면 "저장하지 못했습니다"만 남아 어떤 파일이 왜 막았는지 모른다.
@@ -4918,11 +4964,11 @@ const removedGenerateOptions = /* @__PURE__ */ new Set(["--cassette", "--record"
 const removedGenerateOptionMessage = (option) => `\`${option}\` generate 옵션은 Tool 카세트와 함께 제거되었습니다(ADR-0059). 시험 실행은 서버를 직접 호출합니다. 서버의 외부 HTTP 호출을 녹화하려면 \`mcpeak test <suite.json> --command <executable> --record-session <path>\`를, 재생하려면 \`mcpeak test <suite.json> --command <executable> --session <path>\`를 사용하세요. 서버를 대신하려면 \`mcpeak test <suite.json> --command mcpeak-mock --arg <mock.json>\`을 사용하세요.`;
 function optionValue$1(argv, index, option) {
 	const item = argv[index];
-	if (item === void 0) throw new UsageError$2(`\`${option}\` 옵션 값이 필요합니다.`);
+	if (item === void 0) throw new UsageError$3(`\`${option}\` 옵션 값이 필요합니다.`);
 	const equals = item.indexOf("=");
 	if (equals > 0) return [item.slice(equals + 1), index];
 	const value = argv[index + 1];
-	if (value === void 0 || option !== "--arg" && value.startsWith("--")) throw new UsageError$2(`\`${option}\` 옵션 값이 필요합니다.`);
+	if (value === void 0 || option !== "--arg" && value.startsWith("--")) throw new UsageError$3(`\`${option}\` 옵션 값이 필요합니다.`);
 	return [value, index + 1];
 }
 /**
@@ -4953,21 +4999,21 @@ function parseGenerateCommand(argv) {
 		* `--arg` 가 값 검사에 두던 특수분기가 이 경로에는 필요 없다.
 		*/
 		if (item === "--") {
-			if (values.has("--command")) throw new UsageError$2("`--command` 와 `--` 를 함께 쓸 수 없습니다.\n→ 둘 다 서버를 띄울 명령을 정하므로 대상이 둘이 됩니다.\n→ `--` 뒤에는 실행 파일과 인자를 그대로 적습니다.");
-			if (args.length > 0) throw new UsageError$2("`--arg` 와 `--` 를 함께 쓸 수 없습니다.\n→ `--arg` 로 준 값이 `--` 뒤의 인자 앞에 끼어듭니다.\n→ `--` 를 쓰면 인자도 그 뒤에 모두 적습니다.");
+			if (values.has("--command")) throw new UsageError$3("`--command` 와 `--` 를 함께 쓸 수 없습니다.\n→ 둘 다 서버를 띄울 명령을 정하므로 대상이 둘이 됩니다.\n→ `--` 뒤에는 실행 파일과 인자를 그대로 적습니다.");
+			if (args.length > 0) throw new UsageError$3("`--arg` 와 `--` 를 함께 쓸 수 없습니다.\n→ `--arg` 로 준 값이 `--` 뒤의 인자 앞에 끼어듭니다.\n→ `--` 를 쓰면 인자도 그 뒤에 모두 적습니다.");
 			const rest = argv.slice(index + 1);
 			const executable = rest[0];
-			if (executable === void 0 || executable === "") throw new UsageError$2("`--` 뒤에 실행할 명령이 없습니다.\n→ `-- <executable> [args...]` 처럼 첫 토큰에 실행 파일을 적으세요.");
+			if (executable === void 0 || executable === "") throw new UsageError$3("`--` 뒤에 실행할 명령이 없습니다.\n→ `-- <executable> [args...]` 처럼 첫 토큰에 실행 파일을 적으세요.");
 			values.set("--command", executable);
 			args.push(...rest.slice(1));
 			break;
 		}
 		const option = item.includes("=") ? item.slice(0, item.indexOf("=")) : item;
-		if (!option.startsWith("--")) throw new UsageError$2(`추가 위치 인자 '${item}'는 허용되지 않습니다.`);
-		if (removedGenerateOptions.has(option)) throw new UsageError$2(removedGenerateOptionMessage(option));
-		if (!optionNames$1.has(option)) throw new UsageError$2(`지원하지 않는 generate 옵션 '${option}'입니다.`);
+		if (!option.startsWith("--")) throw new UsageError$3(`추가 위치 인자 '${item}'는 허용되지 않습니다.`);
+		if (removedGenerateOptions.has(option)) throw new UsageError$3(removedGenerateOptionMessage(option));
+		if (!optionNames$1.has(option)) throw new UsageError$3(`지원하지 않는 generate 옵션 '${option}'입니다.`);
 		if (flagNames$1.has(option)) {
-			if (item !== option || flags.has(option)) throw new UsageError$2(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
+			if (item !== option || flags.has(option)) throw new UsageError$3(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
 			flags.add(option);
 			continue;
 		}
@@ -4979,57 +5025,57 @@ function parseGenerateCommand(argv) {
 		}
 		if (option === "--header-env") {
 			const parsed = parseHeaderEnvOption(value);
-			if (!parsed.ok) throw new UsageError$2(parsed.message);
+			if (!parsed.ok) throw new UsageError$3(parsed.message);
 			const rejected = headerEnv.add(parsed.value.header, parsed.value.envName);
-			if (rejected !== void 0) throw new UsageError$2(rejected);
+			if (rejected !== void 0) throw new UsageError$3(rejected);
 			continue;
 		}
 		if (option === "--env") {
 			const parsed = parseEnvForwardOption(value);
-			if (!parsed.ok) throw new UsageError$2(parsed.message);
+			if (!parsed.ok) throw new UsageError$3(parsed.message);
 			const rejected = envForward.add(parsed.value);
-			if (rejected !== void 0) throw new UsageError$2(rejected);
+			if (rejected !== void 0) throw new UsageError$3(rejected);
 			continue;
 		}
-		if (values.has(option)) throw new UsageError$2(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
+		if (values.has(option)) throw new UsageError$3(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
 		values.set(option, value);
 	}
 	const out = values.get("--out");
-	if (out === void 0) throw new UsageError$2("`--out` 옵션이 필요합니다.");
+	if (out === void 0) throw new UsageError$3("`--out` 옵션이 필요합니다.");
 	const derived = deriveSuiteName(out);
 	for (const option of ["--suite-id", "--name"]) {
 		if (values.get(option) !== void 0) continue;
-		if (derived === void 0) throw new UsageError$2(`\`${option}\` 옵션이 필요합니다.\n→ \`--out\` 파일명에서 이름을 뽑을 수 없어 직접 지정해야 합니다.`);
+		if (derived === void 0) throw new UsageError$3(`\`${option}\` 옵션이 필요합니다.\n→ \`--out\` 파일명에서 이름을 뽑을 수 없어 직접 지정해야 합니다.`);
 		values.set(option, derived);
 	}
 	const command = values.get("--command");
 	const rawUrl = values.get("--url");
-	if (command !== void 0 && rawUrl !== void 0) throw new UsageError$2("`--command` 와 `--url` 은 함께 쓸 수 없습니다.\n→ `--command` 는 서버를 프로세스로 띄우고, `--url` 은 이미 떠 있는 원격 서버에 붙습니다.\n→ 둘 중 무엇에서 명세를 뽑을지 하나만 고르세요.");
-	if (command === void 0 && rawUrl === void 0) throw new UsageError$2("`--command` 또는 `--url` 옵션이 필요합니다.");
-	if (rawUrl !== void 0 && args.length > 0) throw new UsageError$2("`--arg` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--arg` 는 우리가 띄우는 프로세스에 넘길 인자입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
-	if (rawUrl !== void 0 && envForward.snapshot().length > 0) throw new UsageError$2("`--env` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--env` 는 우리가 띄우는 프로세스의 환경에 넣을 변수입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
-	if (command !== void 0 && !headerEnv.isEmpty()) throw new UsageError$2("`--header-env` 는 `--url` 과 함께만 쓸 수 있습니다.\n→ 헤더는 HTTP 요청에 실립니다. `--command` 로 띄운 서버와는 stdio 로 이야기합니다.");
+	if (command !== void 0 && rawUrl !== void 0) throw new UsageError$3("`--command` 와 `--url` 은 함께 쓸 수 없습니다.\n→ `--command` 는 서버를 프로세스로 띄우고, `--url` 은 이미 떠 있는 원격 서버에 붙습니다.\n→ 둘 중 무엇에서 명세를 뽑을지 하나만 고르세요.");
+	if (command === void 0 && rawUrl === void 0) throw new UsageError$3("`--command` 또는 `--url` 옵션이 필요합니다.");
+	if (rawUrl !== void 0 && args.length > 0) throw new UsageError$3("`--arg` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--arg` 는 우리가 띄우는 프로세스에 넘길 인자입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
+	if (rawUrl !== void 0 && envForward.snapshot().length > 0) throw new UsageError$3("`--env` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--env` 는 우리가 띄우는 프로세스의 환경에 넣을 변수입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
+	if (command !== void 0 && !headerEnv.isEmpty()) throw new UsageError$3("`--header-env` 는 `--url` 과 함께만 쓸 수 있습니다.\n→ 헤더는 HTTP 요청에 실립니다. `--command` 로 띄운 서버와는 stdio 로 이야기합니다.");
 	const url = (() => {
 		if (rawUrl === void 0) return void 0;
 		const parsed = parseUrlOption(rawUrl);
-		if (!parsed.ok) throw new UsageError$2(parsed.message);
+		if (!parsed.ok) throw new UsageError$3(parsed.message);
 		return parsed.value;
 	})();
 	const outPath = values.get("--out");
-	if (!outPath.toLowerCase().endsWith(".json")) throw new UsageError$2("`--out`은 .json 파일이어야 합니다.");
+	if (!outPath.toLowerCase().endsWith(".json")) throw new UsageError$3("`--out`은 .json 파일이어야 합니다.");
 	const rawProvider = values.get("--provider");
-	if (rawProvider !== void 0 && rawProvider !== "codex" && rawProvider !== "claude") throw new UsageError$2("`--provider`는 codex 또는 claude여야 합니다.");
-	if (values.has("--model") && rawProvider === void 0) throw new UsageError$2("`--model`은 `--provider`와 함께만 사용할 수 있습니다.");
+	if (rawProvider !== void 0 && rawProvider !== "codex" && rawProvider !== "claude") throw new UsageError$3("`--provider`는 codex 또는 claude여야 합니다.");
+	if (values.has("--model") && rawProvider === void 0) throw new UsageError$3("`--model`은 `--provider`와 함께만 사용할 수 있습니다.");
 	const dryRun = !flags.has("--no-dry-run");
 	const repair = !flags.has("--no-repair");
-	if (!dryRun && !repair) throw new UsageError$2("`--no-dry-run`과 `--no-repair`는 함께 사용할 수 없습니다.");
+	if (!dryRun && !repair) throw new UsageError$3("`--no-dry-run`과 `--no-repair`는 함께 사용할 수 없습니다.");
 	const diagnoseRejections = flags.has("--diagnose-rejections");
-	if (diagnoseRejections && !dryRun) throw new UsageError$2("`--diagnose-rejections`는 `--no-dry-run`과 함께 사용할 수 없습니다. 시험 실행이 없으면 확인할 거절이 없습니다.");
+	if (diagnoseRejections && !dryRun) throw new UsageError$3("`--diagnose-rejections`는 `--no-dry-run`과 함께 사용할 수 없습니다. 시험 실행이 없으면 확인할 거절이 없습니다.");
 	const resetCmd = values.get("--reset-cmd");
-	if (!dryRun && resetCmd !== void 0) throw new UsageError$2("`--no-dry-run`과 `--reset-cmd`는 함께 사용할 수 없습니다.");
-	if (resetCmd !== void 0 && resetCmd.trim() === "") throw new UsageError$2("`--reset-cmd` 옵션 값이 필요합니다.");
+	if (!dryRun && resetCmd !== void 0) throw new UsageError$3("`--no-dry-run`과 `--reset-cmd`는 함께 사용할 수 없습니다.");
+	if (resetCmd !== void 0 && resetCmd.trim() === "") throw new UsageError$3("`--reset-cmd` 옵션 값이 필요합니다.");
 	const fixturesPath = values.get("--fixtures");
-	if (fixturesPath !== void 0 && fixturesPath.trim() === "") throw new UsageError$2("`--fixtures` 옵션 값이 필요합니다.");
+	if (fixturesPath !== void 0 && fixturesPath.trim() === "") throw new UsageError$3("`--fixtures` 옵션 값이 필요합니다.");
 	return Object.freeze({
 		suiteId: values.get("--suite-id"),
 		name: values.get("--name"),
@@ -6702,7 +6748,7 @@ async function runGenerateCommand(argv, deps) {
 	try {
 		input = parseGenerateCommand(argv[0] === "generate" ? argv.slice(1) : argv);
 	} catch (error) {
-		const message = error instanceof UsageError$2 ? error.message : "generate 입력을 해석할 수 없습니다.";
+		const message = error instanceof UsageError$3 ? error.message : "generate 입력을 해석할 수 없습니다.";
 		deps.writeStderr(`오류 [CLI_USAGE]: ${message}\n해결: ${GENERATE_USAGE_HINT}\n`);
 		return 1;
 	}
@@ -6896,7 +6942,7 @@ function nodeReviewIO(input = process.stdin, output = process.stdout) {
 //#endregion
 //#region src/optimize-command.ts
 /** 서버 연결 stderr 진단의 줄 수. `test` 의 `--stderr-lines` 기본값과 같다. */
-const STDERR_LINES = 20;
+const STDERR_LINES$1 = 20;
 /** 오버레이가 기록하는 tools 외 능력(§5.1 `otherCapabilities`). 이 밖의 키는 프록시와 무관하다. */
 const OTHER_CAPABILITIES = [
 	"completions",
@@ -6904,7 +6950,7 @@ const OTHER_CAPABILITIES = [
 	"prompts",
 	"resources"
 ];
-var UsageError$1 = class extends Error {
+var UsageError$2 = class extends Error {
 	hint;
 	constructor(message, hint = OPTIMIZE_USAGE_HINT) {
 		super(message);
@@ -6915,7 +6961,7 @@ var UsageError$1 = class extends Error {
 * `test` 는 받지만 `optimize` 에는 뜻이 없는 옵션. `parseTestCommand` 에 넘기기 전에 여기서
 * 거절한다. 넘기면 조용히 통과하거나 "test 옵션" 이라는 남의 이름으로 거절된다.
 */
-const TEST_ONLY_OPTIONS = /* @__PURE__ */ new Set([
+const TEST_ONLY_OPTIONS$1 = /* @__PURE__ */ new Set([
 	"--junit",
 	"--repair-bundle",
 	"--determinism",
@@ -6925,7 +6971,7 @@ const TEST_ONLY_OPTIONS = /* @__PURE__ */ new Set([
 	"--record-session"
 ]);
 /** 대상 옵션 중 값을 다음 토큰으로 받는 것. 그 값이 `--junit` 처럼 생겨도 옵션으로 읽지 않는다. */
-const TARGET_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+const TARGET_VALUE_OPTIONS$1 = /* @__PURE__ */ new Set([
 	"--command",
 	"--arg",
 	"--env",
@@ -6946,31 +6992,31 @@ function parseOptimizeCommand(argv) {
 		}
 		const name = token.startsWith("--") && token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
 		if (name === "--out") {
-			if (outPath !== void 0) throw new UsageError$1("`--out`은 한 번만 사용할 수 있습니다.");
+			if (outPath !== void 0) throw new UsageError$2("`--out`은 한 번만 사용할 수 있습니다.");
 			const value = token === "--out" ? argv[++index] : token.slice(6);
-			if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$1("`--out` 옵션 값이 필요합니다.");
+			if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$2("`--out` 옵션 값이 필요합니다.");
 			outPath = value;
 			continue;
 		}
 		if (name === "--json") {
-			if (token !== "--json") throw new UsageError$1("`--json`은 값을 받지 않습니다.");
-			if (json) throw new UsageError$1("`--json`은 한 번만 사용할 수 있습니다.");
+			if (token !== "--json") throw new UsageError$2("`--json`은 값을 받지 않습니다.");
+			if (json) throw new UsageError$2("`--json`은 한 번만 사용할 수 있습니다.");
 			json = true;
 			continue;
 		}
-		if (TEST_ONLY_OPTIONS.has(name)) throw new UsageError$1(`지원하지 않는 optimize 옵션 '${escapeTerminalText$2(name)}'입니다.`);
-		if (token.startsWith("-") && !TARGET_VALUE_OPTIONS.has(name)) throw new UsageError$1(`지원하지 않는 optimize 옵션 '${escapeTerminalText$2(name)}'입니다.`);
+		if (TEST_ONLY_OPTIONS$1.has(name)) throw new UsageError$2(`지원하지 않는 optimize 옵션 '${escapeTerminalText$2(name)}'입니다.`);
+		if (token.startsWith("-") && !TARGET_VALUE_OPTIONS$1.has(name)) throw new UsageError$2(`지원하지 않는 optimize 옵션 '${escapeTerminalText$2(name)}'입니다.`);
 		targetArgv.push(token);
-		if (TARGET_VALUE_OPTIONS.has(token) && index + 1 < argv.length) targetArgv.push(argv[++index]);
+		if (TARGET_VALUE_OPTIONS$1.has(token) && index + 1 < argv.length) targetArgv.push(argv[++index]);
 	}
-	if (outPath === void 0) throw new UsageError$1("--out <overlay.json> 이 필요합니다. 오버레이를 어디에 쓸지 이 도구는 정하지 않습니다.", "mcpeak optimize --out ./server.optimize.json -- <서버 명령>");
+	if (outPath === void 0) throw new UsageError$2("--out <overlay.json> 이 필요합니다. 오버레이를 어디에 쓸지 이 도구는 정하지 않습니다.", "mcpeak optimize --out ./server.optimize.json -- <서버 명령>");
 	let target;
 	try {
 		target = parseTestCommand([PLACEHOLDER_SUITE, ...targetArgv]).target;
 	} catch (error) {
-		const message = usageMessageOf(error);
+		const message = usageMessageOf$1(error);
 		if (message === void 0) throw error;
-		throw new UsageError$1(message);
+		throw new UsageError$2(message);
 	}
 	return Object.freeze({
 		outPath,
@@ -6979,14 +7025,14 @@ function parseOptimizeCommand(argv) {
 	});
 }
 /** `parseTestCommand` 가 던진 사용 오류의 문장. 그 오류 클래스는 export 되지 않아 모양으로 본다. */
-function usageMessageOf(error) {
+function usageMessageOf$1(error) {
 	if (typeof error !== "object" || error === null || !("failure" in error)) return void 0;
 	const failure = error.failure;
 	if (typeof failure !== "object" || failure === null) return void 0;
 	const { code, message } = failure;
 	return code === "CLI_USAGE" && typeof message === "string" ? message : void 0;
 }
-function usageFailure(deps, message, hint) {
+function usageFailure$1(deps, message, hint) {
 	deps.writeStderr(`오류 [CLI_USAGE]: ${message}\n해결: ${hint}\n`);
 	return 1;
 }
@@ -6995,8 +7041,8 @@ async function runOptimizeCommand(argv, deps) {
 	try {
 		input = parseOptimizeCommand(argv[0] === "optimize" ? argv.slice(1) : argv);
 	} catch (error) {
-		if (!(error instanceof UsageError$1)) throw error;
-		return usageFailure(deps, error.message, error.hint);
+		if (!(error instanceof UsageError$2)) throw error;
+		return usageFailure$1(deps, error.message, error.hint);
 	}
 	let serverInfo;
 	const capture = (connection) => {
@@ -7015,8 +7061,8 @@ async function runOptimizeCommand(argv, deps) {
 			...deps.readEnv === void 0 ? {} : { readEnv: deps.readEnv }
 		});
 	} catch (error) {
-		if (error instanceof ConnectTargetError) return usageFailure(deps, error.message, OPTIMIZE_USAGE_HINT);
-		return writeCoreFailure(deps, "MCP_CONNECTION_FAILED", void 0, error, {
+		if (error instanceof ConnectTargetError) return usageFailure$1(deps, error.message, OPTIMIZE_USAGE_HINT);
+		return writeCoreFailure$1(deps, "MCP_CONNECTION_FAILED", void 0, error, {
 			message: "MCP 서버 연결에 실패했습니다.",
 			hint: "command 실행 가능 여부와 MCP 서버 설정을 확인하세요."
 		});
@@ -7025,13 +7071,13 @@ async function runOptimizeCommand(argv, deps) {
 	try {
 		tools = await connection.client.listTools();
 	} catch (error) {
-		await closeQuietly(connection);
-		return writeCoreFailure(deps, "MCP_LIST_TOOLS_FAILED", `서버의 tools/list 를 읽지 못했습니다: ${escapeTerminalText$2(describeTarget(input.target))}`, error, {
+		await closeQuietly$1(connection);
+		return writeCoreFailure$1(deps, "MCP_LIST_TOOLS_FAILED", `서버의 tools/list 를 읽지 못했습니다: ${escapeTerminalText$2(describeTarget(input.target))}`, error, {
 			message: "서버가 tools/list 요청에 답하지 않았습니다.",
 			hint: "서버가 tools 능력을 광고하는지 확인하세요."
 		});
 	}
-	await closeQuietly(connection);
+	await closeQuietly$1(connection);
 	const info = serverInfo;
 	const optimizeInput = {
 		tools,
@@ -7068,6 +7114,566 @@ function isOptimizeError(error, code) {
 * 꼬리 또는 HTTP 엔드포인트). 연결 실패를 사용자가 가장 먼저 보는 명령이 이것일 수 있어서
 * 진단을 빼지 않는다. `test-command.ts` 의 연결 실패 분기와 같은 규칙이다.
 */
+function writeCoreFailure$1(deps, code, lead, error, fallback) {
+	const core = coreErrorOf$1(error);
+	const message = core === void 0 ? fallback.message : escapeTerminalText$2(core.message);
+	const hint = core === void 0 ? fallback.hint : escapeTerminalText$2(core.hint);
+	const head = core === void 0 ? code : `${code}/${escapeTerminalText$2(core.code)}`;
+	deps.writeStderr(`오류 [${head}]: ${lead === void 0 ? message : `${lead}\n→ ${message}`}\n해결: ${hint}\n`);
+	const processBlock = processDiagnostics(core?.diagnostics);
+	if (processBlock !== void 0 && hasDiagnosticContent(processBlock)) {
+		const block = renderProcessDiagnostics(processBlock, { maxLines: STDERR_LINES$1 });
+		if (block !== "") deps.writeStderr(`\n${block}`);
+	}
+	const remote = httpDiagnostics(core?.diagnostics);
+	if (remote !== void 0) deps.writeStderr(`\n${renderHttpDiagnostics(remote)}`);
+	return 1;
+}
+/** `McpClientError` 를 AggregateError 안까지 찾는다. 연결 정리 실패가 겹치면 그렇게 감싸인다. */
+function coreErrorOf$1(error) {
+	if (error instanceof AggregateError) {
+		for (const nested of error.errors) {
+			const found = coreErrorOf$1(nested);
+			if (found !== void 0) return found;
+		}
+		return;
+	}
+	if (typeof error === "object" && error !== null && error.name === "McpClientError") {
+		const { code, message, hint, diagnostics } = error;
+		if (typeof code === "string" && typeof message === "string" && typeof hint === "string") return {
+			code,
+			message,
+			hint,
+			diagnostics
+		};
+	}
+}
+/**
+* 도구 목록을 읽은 뒤의 종료. 실패해도 결과를 버리지 않는다. 정상 종료가 안 되면 강제로
+* 끝내 자식이 남지 않게 하고, 그것도 안 되면 더 할 수 있는 일이 없다.
+*/
+async function closeQuietly$1(connection) {
+	try {
+		await connection.close();
+	} catch {
+		await connection.forceClose().catch(() => {});
+	}
+}
+//#endregion
+//#region src/perf-command.ts
+/**
+* `mcpeak perf` 서브커맨드. 명세의 callTool 케이스를 실제 입력으로 반복 호출해 응답 시간을 외부
+* HTTP 대기와 서버 안 시간으로 나누고, 기준선이 있으면 회귀를 판정한다(설계 §3, §7, §8.4~§8.6).
+*
+* 대상 옵션의 해석은 `test` 의 `parseTestCommand` 를 쓴다. 다만 `--url`·`--header-env` 는 다른
+* 어떤 검사보다 먼저 거절한다. 측정은 서버 프로세스 안에 관측 코드를 실어야 하는데 우리가 띄우지
+* 않은 프로세스에는 실을 수 없기 때문이다.
+*
+* 명세 오류와 연결 실패 문장은 `test-command.ts`·`optimize-command.ts` 의 비공개 함수가 만든다.
+* 그 파일은 다른 서브커맨드의 것이라 export 를 위해 고치지 않고 같은 문장을 여기서 만든다.
+* 어긋나면 perf-command.test.ts 의 동등성 테스트가 잡는다(설계 §8.5).
+*
+* `@mcpeak/perf` 를 값으로 import 하지 않는다. 정적으로 import 하면 `test` 경로가 그 패키지를
+* 함께 로드한다. 의존성 주입 형태는 `optimize-command.ts` 를 따른다.
+*/
+/** 서버 연결 stderr 진단의 줄 수. `test` 의 `--stderr-lines` 기본값과 같다. */
+const STDERR_LINES = 20;
+/** 케이스에도 명세에도 타임아웃이 없을 때. `runner` 실행기와 같은 값이다(설계 §3.2 5항). */
+const DEFAULT_TIMEOUT_MS = 1e4;
+/** 추적 디렉터리 접두(설계 §8.6). */
+const TRACE_DIR_PREFIX = "mcpeak-perf-";
+const NO_OBSERVATION_HINT = "→ Node 서버인지, NODE_OPTIONS 가 서버까지 전달되는지 확인하세요.";
+var UsageError$1 = class extends Error {
+	hint;
+	constructor(message, hint = PERF_USAGE_HINT) {
+		super(message);
+		this.hint = hint;
+	}
+};
+/** 원격 대상 거절. 해결 줄이 사용법 전체가 아니라 바로 쓸 수 있는 명령 모양이다(설계 §8.5). */
+var RemoteTargetError = class extends Error {};
+/** `test` 는 받지만 perf 에는 뜻이 없는 옵션. 넘기면 "test 옵션" 이라는 남의 이름으로 거절된다. */
+const TEST_ONLY_OPTIONS = /* @__PURE__ */ new Set([
+	"--junit",
+	"--repair-bundle",
+	"--determinism",
+	"--reset-cmd",
+	"--stderr-lines",
+	"--session",
+	"--record-session"
+]);
+/** 대상 옵션 중 값을 다음 토큰으로 받는 것. 그 값이 `--junit` 처럼 생겨도 옵션으로 읽지 않는다. */
+const TARGET_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+	"--command",
+	"--arg",
+	"--env"
+]);
+const REMOTE_OPTIONS = /* @__PURE__ */ new Set(["--url", "--header-env"]);
+/** 값을 받는 숫자 옵션과 범위(설계 §8.4). */
+const NUMBER_OPTIONS = {
+	"--repeat": {
+		min: 1,
+		max: 100,
+		fallback: 5
+	},
+	"--interval-ms": {
+		min: 0,
+		max: 6e4,
+		fallback: 0
+	},
+	"--threshold-pct": {
+		min: 0,
+		max: 1e3,
+		fallback: 50
+	},
+	"--threshold-ms": {
+		min: 0,
+		max: 6e4,
+		fallback: 20
+	}
+};
+const isNumberOption = (name) => name in NUMBER_OPTIONS;
+function optionName(token) {
+	return token.startsWith("--") && token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+}
+function parsePerfCommand(argv) {
+	const separator = argv.indexOf("--");
+	if ((separator === -1 ? argv : argv.slice(0, separator)).some((token) => REMOTE_OPTIONS.has(optionName(token)))) throw new RemoteTargetError();
+	const numbers = /* @__PURE__ */ new Map();
+	const tools = [];
+	let baselinePath;
+	let updateBaseline = false;
+	let json = false;
+	const positionals = [];
+	const targetArgv = [];
+	const readValue = (token, name, index) => {
+		const value = token === name ? argv[index + 1] : token.slice(`${name}=`.length);
+		if (value === void 0 || value.trim() === "" || value.startsWith("--")) throw new UsageError$1(`\`${name}\` 옵션 값이 필요합니다.`);
+		return {
+			value,
+			next: token === name ? index + 1 : index
+		};
+	};
+	const once = (name, seen) => {
+		if (seen) throw new UsageError$1(`\`${name}\`은 한 번만 사용할 수 있습니다.`);
+	};
+	const flag = (token, name) => {
+		if (token !== name) throw new UsageError$1(`\`${name}\`은 값을 받지 않습니다.`);
+	};
+	for (let index = 0; index < argv.length; index++) {
+		const token = argv[index];
+		if (token === "--") {
+			targetArgv.push(...argv.slice(index));
+			break;
+		}
+		const name = optionName(token);
+		if (isNumberOption(name)) {
+			once(name, numbers.has(name));
+			const { value, next } = readValue(token, name, index);
+			index = next;
+			const { min, max } = NUMBER_OPTIONS[name];
+			const parsed = /^\d+$/.test(value) ? Number(value) : NaN;
+			if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) throw new UsageError$1(`\`${name}\` 는 ${min} 이상 ${max} 이하의 정수여야 합니다. 받은 값: '${escapeTerminalText$2(value)}'`);
+			numbers.set(name, parsed);
+			continue;
+		}
+		if (name === "--tool") {
+			const { value, next } = readValue(token, name, index);
+			index = next;
+			tools.push(value);
+			continue;
+		}
+		if (name === "--baseline") {
+			once(name, baselinePath !== void 0);
+			const { value, next } = readValue(token, name, index);
+			index = next;
+			baselinePath = value;
+			continue;
+		}
+		if (name === "--update-baseline") {
+			flag(token, name);
+			once(name, updateBaseline);
+			updateBaseline = true;
+			continue;
+		}
+		if (name === "--json") {
+			flag(token, name);
+			once(name, json);
+			json = true;
+			continue;
+		}
+		if (TEST_ONLY_OPTIONS.has(name) || token.startsWith("-") && !TARGET_VALUE_OPTIONS.has(name)) throw new UsageError$1(`지원하지 않는 perf 옵션 '${escapeTerminalText$2(name)}'입니다.`);
+		if (!token.startsWith("-")) {
+			positionals.push(token);
+			continue;
+		}
+		targetArgv.push(token);
+		if (TARGET_VALUE_OPTIONS.has(token) && index + 1 < argv.length) targetArgv.push(argv[++index]);
+	}
+	if (updateBaseline && baselinePath === void 0) throw new UsageError$1("--update-baseline 은 --baseline <path> 와 함께 써야 합니다.");
+	if (updateBaseline && tools.length > 0) throw new UsageError$1("--update-baseline 은 --tool 과 함께 쓸 수 없습니다. 기준은 명세 전체로 갱신합니다.");
+	const [suitePath, ...rest] = positionals;
+	let target;
+	try {
+		target = parseTestCommand([
+			suitePath ?? "",
+			...rest,
+			...targetArgv
+		]).target;
+	} catch (error) {
+		const message = usageMessageOf(error);
+		if (message === void 0) throw error;
+		throw new UsageError$1(message);
+	}
+	const number = (name) => numbers.get(name) ?? NUMBER_OPTIONS[name].fallback;
+	return Object.freeze({
+		suitePath,
+		target,
+		repeat: number("--repeat"),
+		intervalMs: number("--interval-ms"),
+		tools: Object.freeze([...tools]),
+		...baselinePath === void 0 ? {} : { baselinePath },
+		updateBaseline,
+		thresholdPct: number("--threshold-pct"),
+		thresholdMs: number("--threshold-ms"),
+		json
+	});
+}
+/** `parseTestCommand` 가 던진 사용 오류의 문장. 그 오류 클래스는 export 되지 않아 모양으로 본다. */
+function usageMessageOf(error) {
+	if (typeof error !== "object" || error === null || !("failure" in error)) return void 0;
+	const failure = error.failure;
+	if (typeof failure !== "object" || failure === null) return void 0;
+	const { code, message } = failure;
+	return code === "CLI_USAGE" && typeof message === "string" ? message : void 0;
+}
+function usageFailure(deps, message, hint) {
+	deps.writeStderr(`오류 [CLI_USAGE]: ${message}\n해결: ${hint}\n`);
+	return 1;
+}
+function writeSuiteFailure(deps, failure) {
+	let text = `오류 [${escapeTerminalText$2(failure.code)}]: ${failure.message}\n해결: ${failure.hint}`;
+	for (const issue of failure.issues ?? []) text += `\n- [${escapeTerminalText$2(issue.code)}] ${escapeTerminalText$2(issue.path)}: ${escapeTerminalText$2(issue.message)}\n  해결: ${escapeTerminalText$2(issue.hint)}`;
+	deps.writeStderr(`${text}\n`);
+	return 1;
+}
+function errnoOf(error) {
+	const code = error?.code;
+	return typeof code === "string" || typeof code === "number" ? String(code) : "알 수 없음";
+}
+function suiteReadFailure(path, error) {
+	const shown = escapeTerminalText$2(path);
+	const errno = errnoOf(error);
+	if (errno === "ENOENT") return {
+		code: "SUITE_READ_FAILED",
+		message: `테스트 명세 파일이 그 경로에 없습니다: ${shown}`,
+		hint: "경로와 파일 이름을 확인하세요. 상대 경로는 명령을 실행한 디렉터리 기준입니다."
+	};
+	if (errno === "EACCES" || errno === "EPERM") return {
+		code: "SUITE_READ_FAILED",
+		message: `테스트 명세 파일을 읽을 권한이 없습니다: ${shown}`,
+		hint: "그 파일의 읽기 권한을 확인하세요. 경로 자체는 찾았습니다."
+	};
+	if (errno === "EISDIR") return {
+		code: "SUITE_READ_FAILED",
+		message: `그 경로는 파일이 아니라 디렉터리입니다: ${shown}`,
+		hint: "스위트 JSON 파일의 경로를 주세요."
+	};
+	return {
+		code: "SUITE_READ_FAILED",
+		message: `테스트 명세 파일을 읽지 못했습니다: ${shown}\n  errno: ${escapeTerminalText$2(errno)}`,
+		hint: "명세 경로와 읽기 권한을 확인하세요."
+	};
+}
+function suiteFormatFailure(path) {
+	const ext = (0, node_path.extname)(path);
+	return {
+		code: "SUITE_FORMAT_UNSUPPORTED",
+		message: ext === "" ? `테스트 명세는 .json 파일이어야 합니다. 준 경로에 확장자가 없습니다: ${escapeTerminalText$2(path)}` : `테스트 명세는 .json 파일이어야 합니다. 준 확장자: ${escapeTerminalText$2(ext)}\n  경로: ${escapeTerminalText$2(path)}`,
+		hint: "경로가 .json 으로 끝나는지 확인하세요. 이 단계는 파일을 열지 않고 확장자만 봅니다."
+	};
+}
+const INTERNAL_FAILURE = {
+	code: "CLI_INTERNAL_ERROR",
+	message: "예상하지 못한 CLI 내부 오류가 발생했습니다.",
+	hint: "다시 실행한 뒤 재현 정보와 함께 이슈를 보고하세요."
+};
+/** 명세를 읽고 검증한다. 순서와 문장은 test 와 같다(설계 §3.2 1항, §8.5). */
+async function loadSuite(path, deps) {
+	if ((0, node_path.extname)(path).toLowerCase() !== ".json") return suiteFormatFailure(path);
+	let bytes;
+	try {
+		bytes = await deps.readFile(path);
+	} catch (error) {
+		return suiteReadFailure(path, error);
+	}
+	let decoded;
+	try {
+		decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		return {
+			code: "SUITE_ENCODING_INVALID",
+			message: `테스트 명세 파일이 유효한 UTF-8이 아닙니다: ${escapeTerminalText$2(path)}`,
+			hint: "명세를 UTF-8 JSON으로 다시 저장하세요."
+		};
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(decoded);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return {
+			code: "SUITE_JSON_INVALID",
+			message: `테스트 명세의 JSON 문법이 유효하지 않습니다: ${escapeTerminalText$2(path)}\n  ${escapeTerminalText$2(reason)}`,
+			hint: "JSON 문법과 쉼표, 따옴표를 확인하세요."
+		};
+	}
+	let validated;
+	try {
+		validated = deps.validateSuite(parsed);
+	} catch {
+		return INTERNAL_FAILURE;
+	}
+	if (!validated.valid) return {
+		code: "SUITE_VALIDATION_FAILED",
+		message: "MCP 테스트 명세가 유효하지 않습니다.",
+		hint: "아래 명세 오류를 모두 수정하세요.",
+		issues: validated.issues
+	};
+	return validated.value;
+}
+/**
+* 측정 대상은 callTool 케이스 중 `{ type: "isError", expected: true }` 단언이 없는 것이다. 거절을
+* 기대하는 케이스는 거절 경로의 시간이라 뺀다(설계 §3.1). 타임아웃 우선순위는 runner 실행기와 같다.
+*/
+function planOf(suite, input) {
+	const calls = [];
+	for (const spec of suite.cases) {
+		if (spec.operation.type !== "callTool") continue;
+		const operation = spec.operation;
+		if (spec.assertions.some((a) => a.type === "isError" && a.expected === true)) continue;
+		if (input.tools.length > 0 && !input.tools.includes(operation.tool)) continue;
+		calls.push({
+			caseId: spec.id,
+			tool: operation.tool,
+			input: operation.input,
+			timeoutMs: spec.timeoutMs ?? suite.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS
+		});
+	}
+	return {
+		calls,
+		repeat: input.repeat,
+		intervalMs: input.intervalMs
+	};
+}
+function isPerfError(error) {
+	return error instanceof Error && error.name === "PerfError" && typeof error.code === "string";
+}
+/**
+* 기준 파일을 측정 전에 읽는다. 측정을 다 하고 나서 기준 파일 오타로 결과를 버리지 않기 위해서다
+* (설계 §8.5). 없음은 CLI 가 `ENOENT` 로 판정한다.
+*/
+async function loadBaseline(path, deps) {
+	const invalid = (reason) => `오류 [PERF_BASELINE_INVALID]: 기준 파일을 읽을 수 없습니다: ${escapeTerminalText$2(path)} (${reason})\n→ mcpeak perf 가 쓴 파일인지 확인하고, 아니면 --update-baseline 으로 다시 만드세요.
+`;
+	let bytes;
+	try {
+		bytes = await deps.readFile(path);
+	} catch (error) {
+		if (errnoOf(error) === "ENOENT") return `오류 [PERF_BASELINE_MISSING]: 기준 파일이 없습니다: ${escapeTerminalText$2(path)}\n→ 처음이면 --update-baseline 을 함께 주어 기준을 만드세요.
+`;
+		return invalid(escapeTerminalText$2(errnoOf(error)));
+	}
+	try {
+		return deps.perf.parseBaseline(new TextDecoder("utf-8").decode(bytes));
+	} catch (error) {
+		if (isPerfError(error)) return invalid(escapeTerminalText$2(error.message));
+		throw error;
+	}
+}
+async function runPerfCommand(argv, deps) {
+	let input;
+	try {
+		input = parsePerfCommand(argv[0] === "perf" ? argv.slice(1) : argv);
+	} catch (error) {
+		if (error instanceof RemoteTargetError) {
+			deps.writeStderr("오류 [CLI_USAGE]: perf 는 원격(Streamable HTTP) 서버를 지원하지 않습니다.\n→ 측정은 서버 프로세스 안에 관측 코드를 실어야 하는데, 우리가 띄우지 않은 프로세스에는 실을 수 없습니다.\n해결: mcpeak perf <suite.json> -- <서버 명령>\n");
+			return 1;
+		}
+		if (!(error instanceof UsageError$1)) throw error;
+		return usageFailure(deps, error.message, error.hint);
+	}
+	const suite = await loadSuite(input.suitePath, deps);
+	if ("code" in suite) return writeSuiteFailure(deps, suite);
+	const plan = planOf(suite, input);
+	if (plan.calls.length === 0) {
+		if (input.tools.length > 0) return usageFailure(deps, `--tool ${input.tools.map(escapeTerminalText$2).join(", ")} 에 해당하는 측정 케이스가 없습니다.`, "명세의 operation.tool 값과 --tool 값을 맞추세요.");
+		return usageFailure(deps, "측정할 케이스가 없습니다. 명세의 callTool 케이스 중 거절(isError: true)을 기대하지 않는 것이 없습니다.", "mcpeak generate 로 성공 케이스를 만들거나 명세를 확인하세요.");
+	}
+	let baseline;
+	if (input.baselinePath !== void 0 && !input.updateBaseline) {
+		const loaded = await loadBaseline(input.baselinePath, deps);
+		if (typeof loaded === "string") {
+			deps.writeStderr(loaded);
+			return 1;
+		}
+		if (input.tools.length > 0) {
+			const planned = new Set(plan.calls.map((call) => call.caseId));
+			baseline = {
+				...loaded,
+				cases: loaded.cases.filter((row) => planned.has(row.id))
+			};
+		} else baseline = loaded;
+	}
+	const traceDir = await deps.makeTempDir((0, node_path.join)((0, node_os.tmpdir)(), TRACE_DIR_PREFIX));
+	const session = {};
+	let detachSignals;
+	const detach = () => {
+		detachSignals?.();
+		detachSignals = void 0;
+	};
+	detachSignals = deps.onSignal(async (signal) => {
+		if (session.interrupted === void 0) {
+			session.interrupted = signal;
+			const connection = session.connection;
+			if (connection !== void 0) await closeQuietly(connection);
+		}
+		try {
+			deps.removeDirSync(traceDir);
+		} catch {}
+		detach();
+		deps.killSelf(signal);
+	});
+	try {
+		return await measureAndReport(input, plan, baseline, traceDir, deps, session);
+	} finally {
+		detach();
+		await deps.removeDir(traceDir);
+	}
+}
+/** 셸이 신호 종료에 보는 값(128 + 신호 번호). 실제로는 재발신이 먼저 프로세스를 끝낸다. */
+const SIGNAL_EXIT_CODES = {
+	SIGINT: 130,
+	SIGTERM: 143,
+	SIGHUP: 129
+};
+async function measureAndReport(input, plan, baseline, traceDir, deps, session) {
+	const env = deps.perf.childEnvironment({
+		traceDir,
+		existingNodeOptions: deps.readEnv("NODE_OPTIONS")
+	});
+	const connectStart = deps.now();
+	let connection;
+	try {
+		connection = await openConnection(input.target, {
+			connectStdio: deps.connectStdio,
+			readEnv: deps.readEnv
+		}, { env });
+	} catch (error) {
+		if (error instanceof ConnectTargetError) return usageFailure(deps, error.message, PERF_USAGE_HINT);
+		return writeCoreFailure(deps, "MCP_CONNECTION_FAILED", void 0, error, {
+			message: "MCP 서버 연결에 실패했습니다.",
+			hint: "command 실행 가능 여부와 MCP 서버 설정을 확인하세요."
+		});
+	}
+	const connectEnd = deps.now();
+	session.connection = connection;
+	let tools;
+	const listStart = deps.now();
+	try {
+		tools = await connection.client.listTools();
+	} catch (error) {
+		session.connection = void 0;
+		await closeQuietly(connection);
+		return writeCoreFailure(deps, "MCP_LIST_TOOLS_FAILED", `서버의 tools/list 를 읽지 못했습니다: ${escapeTerminalText$2(describeTarget(input.target))}`, error, {
+			message: "서버가 tools/list 요청에 답하지 않았습니다.",
+			hint: "서버가 tools 능력을 광고하는지 확인하세요."
+		});
+	}
+	const listEnd = deps.now();
+	deps.writeStderr(`측정: 케이스 ${plan.calls.length}개 × ${plan.repeat}회\n`);
+	let measurements;
+	try {
+		measurements = await deps.perf.measure({
+			client: connection.client,
+			availableTools: new Set(tools.map((tool) => tool.name)),
+			plan,
+			now: deps.now,
+			sleep: deps.sleep,
+			onProgress: (done, total) => {
+				if (session.interrupted !== void 0) return;
+				const index = Math.floor((done - 1) / plan.repeat);
+				const iteration = (done - 1) % plan.repeat + 1;
+				deps.writeStderr(`측정 중 ${done}/${total} · ${escapeTerminalText$2(plan.calls[index]?.caseId ?? "")} (${iteration}/${plan.repeat}회)\n`);
+			}
+		});
+	} finally {
+		session.connection = void 0;
+		await closeQuietly(connection);
+	}
+	if (session.interrupted !== void 0) return SIGNAL_EXIT_CODES[session.interrupted];
+	deps.writeStderr(`측정 완료: 호출 ${measurements.length}회\n`);
+	let entries;
+	try {
+		({entries} = await deps.perf.readTrace(traceDir));
+	} catch (error) {
+		if (session.interrupted !== void 0) return SIGNAL_EXIT_CODES[session.interrupted];
+		throw error;
+	}
+	if (session.interrupted !== void 0) return SIGNAL_EXIT_CODES[session.interrupted];
+	let report = deps.perf.analyze({
+		plan,
+		measurements,
+		trace: entries,
+		coldStart: {
+			connectMs: Math.round(connectEnd - connectStart),
+			listToolsMs: Math.round(listEnd - listStart)
+		},
+		server: {
+			command: describeTarget(input.target),
+			toolCount: tools.length
+		},
+		generatorVersion: deps.generatorVersion
+	});
+	const observed = report.settings.observation === "preload";
+	if (input.baselinePath !== void 0 && input.updateBaseline) {
+		if (!observed) return unavailable(deps, report, input, "기준 파일을 쓰지 않았습니다.");
+		try {
+			await deps.writeFile(input.baselinePath, `${JSON.stringify(deps.perf.toBaseline(report), null, 2)}\n`);
+		} catch (error) {
+			writeReport(deps, report, input);
+			const code = errnoOf(error);
+			deps.writeStderr(`오류 [PERF_BASELINE_WRITE_FAILED]: 기준 파일을 쓰지 못했습니다 (${escapeTerminalText$2(code)}). 경로: ${escapeTerminalText$2(input.baselinePath)}\n해결: --baseline 경로의 디렉터리가 있는지와 쓰기 권한을 확인하세요.
+`);
+			return 1;
+		}
+	} else if (input.baselinePath !== void 0 && baseline !== void 0) {
+		if (!observed) return unavailable(deps, report, input, "기준선과 비교하지 않았습니다.");
+		report = deps.perf.compareBaseline(report, baseline, {
+			path: input.baselinePath,
+			thresholdPct: input.thresholdPct,
+			thresholdMs: input.thresholdMs
+		});
+	}
+	writeReport(deps, report, input);
+	return report.exitCode;
+}
+function writeReport(deps, report, input) {
+	deps.writeStdout(input.json ? `${JSON.stringify(report, null, 2)}\n` : deps.perf.renderReport(report));
+}
+/**
+* 관측이 없어 기준선을 쓰거나 비교할 수 없다(설계 §8.5, 계획 E9). 잰 응답 시간은 버리지 않고
+* 리포트를 먼저 낸 뒤 종료 코드 1 로 끝낸다.
+*/
+function unavailable(deps, report, input, what) {
+	writeReport(deps, report, input);
+	deps.writeStderr(`오류 [PERF_BASELINE_UNAVAILABLE]: 외부 호출을 관측하지 못해 ${what}\n${NO_OBSERVATION_HINT}\n`);
+	return 1;
+}
+/**
+* core 오류를 optimize 와 같은 모양으로 낸다: 한 줄 머리, 해결 줄, 그리고 진단 블록. 문장은
+* optimize-command.ts 의 같은 이름 함수와 같아야 한다(설계 §8.5).
+*/
 function writeCoreFailure(deps, code, lead, error, fallback) {
 	const core = coreErrorOf(error);
 	const message = core === void 0 ? fallback.message : escapeTerminalText$2(core.message);
@@ -7102,10 +7708,7 @@ function coreErrorOf(error) {
 		};
 	}
 }
-/**
-* 도구 목록을 읽은 뒤의 종료. 실패해도 결과를 버리지 않는다. 정상 종료가 안 되면 강제로
-* 끝내 자식이 남지 않게 하고, 그것도 안 되면 더 할 수 있는 일이 없다.
-*/
+/** 정상 종료가 안 되면 강제로 끝내 자식이 남지 않게 한다. 그것도 안 되면 더 할 수 있는 일이 없다. */
 async function closeQuietly(connection) {
 	try {
 		await connection.close();
@@ -7330,7 +7933,8 @@ const COMMANDS = [
 	"record",
 	"mock",
 	"optimize",
-	"audit"
+	"audit",
+	"perf"
 ];
 const unavailableDependencies = {
 	readFile: async () => {
@@ -7404,7 +8008,7 @@ function nodeOptimizeDependencies(core, optimize) {
 		readEnv: (name) => process.env[name],
 		optimize: optimize.optimize,
 		renderReport: optimize.renderReport,
-		generatorVersion: version$1,
+		generatorVersion: version$2,
 		writeFile: (path, text) => (0, node_fs_promises.writeFile)(path, text, "utf8"),
 		writeStdout: (text) => void process.stdout.write(text),
 		writeStderr: (text) => void process.stderr.write(text)
@@ -7430,7 +8034,7 @@ function nodeAuditDependencies(core, audit) {
 		writeFile: (path, text) => (0, node_fs_promises.writeFile)(path, text, "utf8"),
 		audit: audit.audit,
 		renderReport: audit.renderReport,
-		generatorVersion: version$2,
+		generatorVersion: version$3,
 		writeStdout: (text) => void process.stdout.write(text),
 		writeStderr: (text) => void process.stderr.write(text),
 		fetch: globalThis.fetch,
@@ -7450,13 +8054,73 @@ function nodeAuditDependencies(core, audit) {
 		}
 	};
 }
+/**
+* `perf` 실행 의존성. `nodeOptimizeDependencies` 와 같은 이유로 함수로 뺀다. 주입 자체를 테스트가
+* 단언할 수 있어야 빠뜨린 배선이 초록으로 남지 않는다(설계 §8.6).
+*
+* `now` 는 `performance.timeOrigin + performance.now()` 다. 자식 프리로드가 같은 시계로 요청
+* 시각을 적으므로 이 시계여야 호출 창과 요청이 한 축에 놓인다(설계 §2.1). `sleep` 은 signal 이
+* abort 되면 타이머만 해제하고 끝나지 않는다. 남은 타이머가 CLI 종료를 늦추지 않게 하기 위해서다.
+* `generatorVersion` 은 리포트의 `generator` 가 `@mcpeak/perf` 이므로 그 패키지의 버전이고, 읽는
+* 방식은 optimize 와 같다.
+*/
+function nodePerfDependencies(core, runner, perf) {
+	return {
+		connectStdio: core.connectStdio,
+		readEnv: (name) => process.env[name],
+		readFile: (path) => (0, node_fs_promises.readFile)(path),
+		writeFile: (path, text) => (0, node_fs_promises.writeFile)(path, text, "utf8"),
+		makeTempDir: (prefix) => (0, node_fs_promises.mkdtemp)(prefix),
+		removeDir: (path) => (0, node_fs_promises.rm)(path, {
+			recursive: true,
+			force: true
+		}),
+		removeDirSync: (path) => (0, node_fs.rmSync)(path, {
+			recursive: true,
+			force: true
+		}),
+		onSignal: (handler) => {
+			const listener = (signal) => void handler(signal);
+			process.on("SIGINT", listener);
+			process.on("SIGTERM", listener);
+			process.on("SIGHUP", listener);
+			return () => {
+				process.off("SIGINT", listener);
+				process.off("SIGTERM", listener);
+				process.off("SIGHUP", listener);
+			};
+		},
+		killSelf: (signal) => void process.kill(process.pid, signal),
+		now: () => performance.timeOrigin + performance.now(),
+		sleep: (ms, signal) => new Promise((resolve) => {
+			if (signal?.aborted === true) return;
+			const timer = setTimeout(resolve, ms);
+			signal?.addEventListener("abort", () => clearTimeout(timer), { once: true });
+		}),
+		validateSuite: runner.validateMcpSuite,
+		perf: {
+			measure: perf.measure,
+			readTrace: perf.readTrace,
+			analyze: perf.analyze,
+			compareBaseline: perf.compareBaseline,
+			toBaseline: perf.toBaseline,
+			parseBaseline: perf.parseBaseline,
+			renderReport: perf.renderReport,
+			childEnvironment: perf.childEnvironment
+		},
+		generatorVersion: version$1,
+		writeStdout: (text) => void process.stdout.write(text),
+		writeStderr: (text) => void process.stderr.write(text)
+	};
+}
 /** `mcpeak help <이름>` 으로 볼 수 있는 명령. 위 두 갈래가 같은 목록을 봐야 한다. */
 const HELP_TOPICS = [
 	"test",
 	"generate",
 	"repair",
 	"optimize",
-	"audit"
+	"audit",
+	"perf"
 ];
 const isHelpTopic = (value) => HELP_TOPICS.includes(value);
 async function run(argv) {
@@ -7593,6 +8257,22 @@ async function run(argv) {
 		}
 		return runAuditCommand(argv, nodeAuditDependencies(core, audit));
 	}
+	if (argv[0] === "perf") {
+		let core;
+		let runner;
+		let perf;
+		try {
+			[core, runner, perf] = await Promise.all([
+				import("@mcpeak/core"),
+				import("@mcpeak/runner"),
+				import("@mcpeak/perf")
+			]);
+		} catch {
+			process.stderr.write("오류 [PERF_RUNTIME_UNAVAILABLE]: @mcpeak/perf 를 로드하지 못했습니다.\n해결: 의존성을 설치한 뒤 다시 실행하세요.\n");
+			return 1;
+		}
+		return runPerfCommand(argv, nodePerfDependencies(core, runner, perf));
+	}
 	if (argv[0] !== "test") return runCli(argv, unavailableDependencies);
 	try {
 		if (!parseTestCommand(argv.slice(1)).suitePath.toLowerCase().endsWith(".json")) return runCli(argv, unavailableDependencies);
@@ -7653,6 +8333,12 @@ Object.defineProperty(exports, "nodeOptimizeDependencies", {
 		return nodeOptimizeDependencies;
 	}
 });
+Object.defineProperty(exports, "nodePerfDependencies", {
+	enumerable: true,
+	get: function() {
+		return nodePerfDependencies;
+	}
+});
 Object.defineProperty(exports, "nodeRepairDependencies", {
 	enumerable: true,
 	get: function() {
@@ -7719,6 +8405,12 @@ Object.defineProperty(exports, "runOptimizeCommand", {
 		return runOptimizeCommand;
 	}
 });
+Object.defineProperty(exports, "runPerfCommand", {
+	enumerable: true,
+	get: function() {
+		return runPerfCommand;
+	}
+});
 Object.defineProperty(exports, "runRepairCommand", {
 	enumerable: true,
 	get: function() {