@mcpeak/cli 0.9.0 → 0.11.0

package/dist/{test-command-CsJfojut.mjs → test-command-DEp9hrfH.mjs}

@@ -1,63 +1,360 @@
 import { access, link, open, readFile, unlink } from "node:fs/promises";
 import { basename, dirname, extname, join } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { REDACTED, RunnerPayloadLimitError, canonicalJson, checkAssertionSubstance, checkDeterminism, checkInputContract, describeDeterminismDifference, describeSpecFinding, renderReport, runSuite, suiteFingerprint } from "@mcpeak/runner";
-import { REDACTED as REDACTED$1, cassetteClient, loadCassette, matchKey, saveCassette } from "@mcpeak/record";
+import { MAX_VALUE_STRING_CHARS, REDACTED, RunnerPayloadLimitError, canonicalJson, checkAssertionSubstance, checkDeterminism, checkInputContract, describeDeterminismDifference, describeSpecFinding, renderReport, runSuite, suiteFingerprint } from "@mcpeak/runner";
 import { spawn } from "node:child_process";
 import { CommandParseError, tokenizeCommand } from "@mcpeak/core";
+import { existsSync } from "node:fs";
 //#region package.json
-var version = "0.9.0";
+var version = "0.11.0";
 //#endregion
-//#region src/cassette-wiring.ts
-/**
-* 카세트가 없으면 새로 녹화하고, 있으면 재생하며 빠진 것만 녹화한다. `--record` 는 있는 파일을
-* 무시한다. `replay` 는 쓰지 않는다. 새 케이스가 추가되는 것이 이 경로의 정상 흐름인데
-* `replay` 는 미스에서 실패한다. 설계 문서 §5.2.
-*/
-const resolveMode = (cassette, forceRecord) => forceRecord || cassette === null ? "record" : "auto";
-async function wireCassette(options) {
-	const { inner, path, forceRecord } = options;
-	if (path === void 0) return {
-		client: inner,
-		flush: async () => {},
-		warnings: []
-	};
-	const io = options.io ?? {
-		load: loadCassette,
-		save: saveCassette
-	};
-	const cassette = await io.load(path);
-	const warnings = [];
-	let snapshot;
-	const mode = resolveMode(cassette, forceRecord);
-	const recorder = cassetteClient(inner, {
-		cassette,
-		mode,
-		cassettePath: path,
-		onFlush: async (value) => {
-			snapshot = value;
-		},
-		onWarning: (message) => {
-			warnings.push(message);
+//#region src/repair-render.ts
+/**
+* 터미널 제어 문자를 무해한 토큰으로 바꾼다.
+*
+* `packages/cli/src/test-command.ts` 의 `escapeTerminalText` 와 같은 계열이다. 그 함수를
+* import 하지 않고 사본을 두는 근거는 ADR-0013 이고 `process-diagnostics.ts` 의 선례와 같다.
+* 이 모듈이 찍는 문자열은 **외부 provider 가 준 산문**이라 원문 보존보다 화면 무해성이 앞선다.
+*
+* TAB(0x09)도 이스케이프한다. `process-diagnostics.ts` 사본만 TAB 을 남기는데 그것은 서버
+* stderr 의 스택트레이스 들여쓰기를 보존하기 위해서다. AI 산문에는 보존할 들여쓰기가 없고,
+* 우리가 만든 라벨 정렬을 TAB 이 흔들면 화면이 어긋난다.
+*/
+const escapeTerminalText$2 = (value) => Array.from(value, (character) => {
+	const codePoint = character.codePointAt(0) ?? 0;
+	return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 8232 || codePoint === 8233 ? `\\u${codePoint.toString(16).padStart(4, "0")}` : character;
+}).join("");
+/** 코드 포인트 단위로 자른다. 서로게이트 쌍(이모지)의 중간이 끊기지 않는다. */
+function clampDisplay(text, limit) {
+	const points = [...text];
+	return points.length <= limit ? text : `${points.slice(0, limit).join("")}…`;
+}
+/**
+* 경계 문장 둘. **모든 경로에서** 찍는다. `unsure` 여도, 진단이 잘 나와도 찍는다.
+* 이것이 없으면 사용자가 멀쩡한 서버 코드를 판다. 억제 조건을 만들지 않는다. 설계서 §6.3.
+*/
+const REPAIR_BOUNDARY_LINES = "※ AI 제안입니다. 파일을 고치지 않았고 명세도 그대로입니다.\n※ 명세 쪽이 틀렸다고 판단되면 `mcpeak generate` 로 다시 승인받으세요.\n";
+/** 비대화형에서 `--yes` 없이 부른 경우. 물어볼 수 없는 곳에서 조용히 보내지 않는다. */
+const REPAIR_CONFIRM_REQUIRED_LINE = "오류 [REPAIR_CONFIRM_REQUIRED]: 확인을 받을 수 없는 환경입니다. 전송 내용을 보여줄 수 없어 보내지 않았습니다.\n해결: 내용을 확인했다면 `--yes` 를 붙여 다시 실행하세요.\n";
+/** 사용자가 `n` 을 답한 경로. 실패가 아니라 의도한 종료다. */
+const REPAIR_CANCELLED_LINE = "전송하지 않았습니다.\n";
+const APPROVAL_LABEL = {
+	matched: "승인 지문 일치",
+	mismatched: "승인 지문 불일치",
+	absent: "승인 지문 없음"
+};
+/**
+* 지문이 승인 상태가 아닐 때 결과 맨 위에 붙는 블록. 결과가 `unsure` 여도 붙는다. 설계서 §6.5.
+* `matched` 면 빈 문자열이다.
+*/
+function renderApprovalNotice(approval) {
+	if (approval === "matched") return "";
+	if (approval === "mismatched") return "⚠ 이 명세는 승인 상태가 아닙니다 (지문 불일치).\n  실패 원인이 서버가 아니라 명세일 수 있습니다. 아래 제안은 그 전제로 받았습니다.\n\n";
+	return "⚠ 이 명세는 승인 지문이 없습니다.\n  실제 서버로 검증된 적이 없는 명세일 수 있습니다. 아래 제안은 그 전제로 받았습니다.\n\n";
+}
+/** KB 표기. 소수 한 자리다. 바이트 그대로 찍으면 큰 수를 눈으로 못 읽는다. */
+function kilobytes(bytes) {
+	return `${(bytes / 1024).toFixed(1)} KB`;
+}
+/**
+* 전송 확인 화면(설계서 §6.1). 질문 줄은 붙이지 않는다. 그것은 `ReviewIO.confirm` 이 찍는다.
+*/
+function renderRepairConfirm(view) {
+	const scope = view.omittedFailures === 0 ? `실패 ${view.totalFailures}건 중 ${view.sentFailures}건` : `실패 ${view.totalFailures}건 중 ${view.sentFailures}건 (--max-cases ${view.maxCases}, ${view.omittedFailures}건 제외)`;
+	let stderrLine;
+	if (!view.includeStderr) stderrLine = "(전송하지 않음)";
+	else if (view.stderr === void 0 || view.stderr === "") stderrLine = "없음";
+	else {
+		const lines = view.stderr.split("\n");
+		if (lines[lines.length - 1] === "") lines.pop();
+		stderrLine = `${lines.length}줄 ${kilobytes(Buffer.byteLength(view.stderr, "utf8"))} (--no-stderr 로 제외할 수 있습니다)`;
+	}
+	return [
+		"repair 요청을 보냅니다.\n",
+		"\n",
+		`  provider   ${view.providerId} (${escapeTerminalText$2(view.model)})\n`,
+		`  대상       ${scope}\n`,
+		`  명세 상태  ${APPROVAL_LABEL[view.approval]}\n`,
+		`  stderr     ${stderrLine}\n`,
+		`  전송 크기  ${kilobytes(view.requestBytes)}\n`,
+		"\n",
+		"※ 위 내용이 외부 provider 로 전송됩니다.\n",
+		"※ stderr 는 서버가 자유롭게 쓰는 텍스트라 경로·토큰·데이터가 섞일 수 있습니다.\n"
+	].join("");
+}
+function discardedTotal(discarded) {
+	return discarded.unknownCase + discarded.specTarget + discarded.unsureCauses;
+}
+function renderDiscardReasons(discarded) {
+	const reasons = [];
+	if (discarded.unknownCase > 0) reasons.push(`요청에 없는 케이스를 가리킨 제안 ${discarded.unknownCase}건`);
+	if (discarded.specTarget > 0) reasons.push(`승인된 명세를 고치라는 제안 ${discarded.specTarget}건`);
+	if (discarded.unsureCauses > 0) reasons.push(`판단 불가 응답에 함께 온 원인 후보 ${discarded.unsureCauses}건`);
+	return reasons;
+}
+function renderDiscardActions(discarded) {
+	const actions = [];
+	if (discarded.specTarget > 0) actions.push("  → 명세가 실제로 틀렸다고 보시면 `mcpeak generate` 로 다시 승인받으세요.\n", "    승인된 명세를 고치라는 제안은 그 전에는 화면에 올리지 않습니다.\n");
+	if (discarded.unknownCase > 0 || discarded.unsureCauses > 0) actions.push("  → 같은 번들로 한 번 더 물어보세요. 같은 입력에도 답은 달라집니다.\n");
+	return actions;
+}
+/**
+* 제안이 전부 폐기돼 남은 항목이 0 인 경우의 문안.
+*
+* 사용자가 알아야 할 것은 셋이다. AI 가 답을 냈다는 사실, 우리가 왜 버렸는지, 다음에 무엇을
+* 할 수 있는지. generate 가 보존한 사유별 개수로 관련 있는 행동만 안내한다.
+*/
+function renderAllDiscarded(discarded) {
+	const parts = [
+		`AI 가 원인 후보 ${discardedTotal(discarded)}건을 냈지만 전부 검증에서 제외했습니다.\n`,
+		"판단 근거가 없어서가 아니라 답을 그대로 쓸 수 없어서입니다.\n",
+		"\n"
+	];
+	for (const reason of renderDiscardReasons(discarded)) parts.push(`  제외 사유  ${reason}\n`);
+	parts.push("\n", ...renderDiscardActions(discarded));
+	return parts.join("");
+}
+/** 케이스 머리줄. 툴이 없는 케이스(listTools)는 괄호를 안 찍는다. */
+function caseHeading(caseId, tool) {
+	const id = escapeTerminalText$2(caseId);
+	return tool === void 0 ? `${id}\n` : `${id}  (${escapeTerminalText$2(tool)})\n`;
+}
+/**
+* 결과 화면(설계서 §6.2·§6.4·§6.5).
+*
+* 문안은 CLI 가 소유한다. AI 는 필드만 채운다. 라벨·들여쓰기·순서·경계 문장은 전부 우리 것이다.
+* 케이스 순서는 **번들 순서**다. AI 응답 순서로 정렬하지 않는다. 같은 실행을 두 번 볼 때 화면이
+* 달라지면 안 된다.
+*/
+function renderRepairResult(options) {
+	const parts = [
+		`── 서버 수정 방향 (${options.providerId} / ${escapeTerminalText$2(options.model)}) ──\n`,
+		"\n",
+		renderApprovalNotice(options.bundle.spec.approval)
+	];
+	if (options.result.status === "unsure") {
+		/**
+		* `unsure` 는 두 가지 다른 일이다. 하나로 뭉치면 화면이 거짓말을 한다.
+		*
+		* `discarded` 합계가 0 이면 provider 가 실제로 판단을 못 한 것이고, 그때만 "근거가 부족" 이
+		* 사실이다. 합계가 0 보다 크면 **답은 왔는데 우리가 경계 밖이라 버린 것**이다.
+		* 그 경로에 "근거가 부족" 을 찍으면 사용자는 번들에 정보를 더 담아야 한다고 읽는다.
+		* 실제로 그 화면을 보고 "구현이 실패한 것 아니냐" 는 질문이 나왔다.
+		*/
+		if (discardedTotal(options.result.discarded) > 0) parts.push(renderAllDiscarded(options.result.discarded));
+		else parts.push("판단 근거가 부족해 원인 후보를 제시하지 못했습니다.\n");
+		if (options.result.shortfall !== "") {
+			const [first, ...rest] = escapeTerminalText$2(clampDisplay(options.result.shortfall, 500)).split("\n");
+			parts.push("\n", `  → ${first}\n`);
+			for (const line of rest) parts.push(`    ${line}\n`);
 		}
+	} else {
+		const byCase = /* @__PURE__ */ new Map();
+		for (const cause of options.result.causes) {
+			const list = byCase.get(cause.caseId) ?? [];
+			list.push(cause);
+			byCase.set(cause.caseId, list);
+		}
+		let first = true;
+		for (const failure of options.bundle.failures) {
+			const causes = byCase.get(failure.caseId);
+			if (causes === void 0) continue;
+			for (const cause of causes) {
+				if (!first) parts.push("\n");
+				first = false;
+				parts.push(caseHeading(failure.caseId, failure.tool));
+				parts.push(`  원인 후보  ${escapeTerminalText$2(cause.summary)}\n`);
+				if (cause.location !== "") parts.push(`  확인할 곳  ${escapeTerminalText$2(cause.location)}\n`);
+				if (cause.evidence !== "") parts.push(`  근거       ${escapeTerminalText$2(cause.evidence)}\n`);
+				if (cause.target === "spec" && options.bundle.spec.approval !== "matched") parts.push("  분류       명세 쪽 원인으로 봄\n");
+			}
+		}
+	}
+	if (discardedTotal(options.result.discarded) > 0 && options.result.status !== "unsure") {
+		parts.push("\n");
+		for (const reason of renderDiscardReasons(options.result.discarded)) parts.push(`※ ${reason}이 검증에서 제외됐습니다.\n`);
+		parts.push("\n", ...renderDiscardActions(options.result.discarded));
+	}
+	parts.push("\n", REPAIR_BOUNDARY_LINES);
+	return parts.join("");
+}
+/** provider 실패 안내. 닫힌 enum 만 화면에 오고 raw stdout·stderr 는 오지 않는다. */
+function renderRepairProviderFailure(failure) {
+	if (failure.reason === "unknownOption") {
+		const option = failure.option === void 0 ? "" : ` 옵션: ${failure.option}`;
+		return `오류 [REPAIR_PROVIDER_OPTION]: 설치된 ${failure.providerId} 가 우리가 넘긴 옵션을 모릅니다.${option}\n  → 설치도 인증도 원인이 아닙니다. CLI 가 뜨기도 전에 옵션 해석에서 멈췄습니다.\n해결: \`${failure.providerId} --version\` 으로 버전을 확인하고 최신 버전으로 올리세요. 파일은 하나도 바뀌지 않았습니다.\n`;
+	}
+	const reason = failure.reason === void 0 ? "" : ` (${failure.reason})`;
+	return `오류 [REPAIR_PROVIDER_FAILED]: ${failure.providerId} 에게 진단을 받지 못했습니다. 코드: ${failure.code}${reason}\n해결: \`${failure.providerId} --version\` 으로 설치와 인증을 확인한 뒤 다시 실행하세요. 파일은 하나도 바뀌지 않았습니다.\n`;
+}
+/** 응답이 계약을 못 지킨 경우. 우리가 버렸다는 사실을 말한다. */
+const REPAIR_INVALID_RESULT_LINE = "오류 [REPAIR_RESULT_INVALID]: provider 응답이 진단 형식을 지키지 않아 버렸습니다.\n해결: 같은 번들로 다시 실행하거나 다른 `--model` 로 시도하세요. 파일은 하나도 바뀌지 않았습니다.\n";
+/**
+* 응답이 `maxResultBytes` 를 넘어 거절된 경우. 형식이 틀린 것과 다르다. 답은 형식을 지켰지만
+* 우리가 정한 상한 밖이라 받지 않은 것이고, 사용자가 할 일도 다르다. 같은 문장을 쓰면
+* "다른 모델로 시도하세요" 라는 엉뚱한 안내를 하게 된다.
+*/
+const REPAIR_RESULT_LIMIT_LINE = "오류 [REPAIR_RESULT_LIMIT_EXCEEDED]: provider 응답이 허용 크기를 넘어 받지 않았습니다.\n해결: `--max-cases` 로 한 번에 묻는 실패 수를 줄여 다시 실행하세요. 파일은 하나도 바뀌지 않았습니다.\n";
+/** 승인 검사에 걸린 경우. 사용자가 본 것과 나가는 것이 달라졌다는 뜻이다. */
+const REPAIR_APPROVAL_INVALIDATED_LINE = "오류 [REPAIR_APPROVAL_INVALIDATED]: 확인한 내용과 보내려는 내용이 달라 전송을 멈췄습니다.\n해결: 같은 번들로 다시 실행하세요. 파일은 하나도 바뀌지 않았습니다.\n";
+//#endregion
+//#region src/connect-target.ts
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const err = (message) => ({
+	ok: false,
+	message
+});
+/** RFC 9110 의 field-name token. `core/src/options.ts` 의 같은 이름 상수와 같은 집합이다. */
+const HTTP_TOKEN_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/**
+* POSIX 환경변수 이름. 이 검사가 `--header-env` 를 값이 아니라 **이름** 자리로 못박는다.
+*
+* `--header-env Authorization="Bearer abc123"` 처럼 값을 바로 넣으려는 시도가 공백과 따옴표
+* 때문에 여기서 걸린다. 걸리지 않으면 우리가 막으려던 그 노출(`ps` · 셸 히스토리)이 그대로
+* 일어나므로, 이 정규식은 편의가 아니라 이 옵션의 안전 근거다.
+*/
+const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** 되짚어 준 값 하나의 표시 상한. `process-diagnostics.ts` 의 `MAX_LINE_CHARACTERS` 와 같다. */
+const MAX_ECHOED_CHARACTERS = 200;
+/**
+* 오류 문장에 되짚어 넣는 **사용자 입력**을 무해하게 만든다.
+*
+* 값 단위로만 건다. 문장 전체에 걸면 우리가 쓴 개행(`\n→ …`)까지 이스케이프되어 안내가 한 줄로
+* 뭉개진다 — #289 가 정확히 그 결함이었다.
+*
+* 거는 이유는 `format()` 이 더 이상 `failure.message` 를 통째로 이스케이프하지 않기 때문이다.
+* `mcpeak test s.json --url $'\e[2J…'` 처럼 ANSI 를 실은 인자가 그대로 터미널에 닿을 수 있다.
+*/
+function echoValue(value) {
+	const escaped = escapeTerminalText$2(value);
+	return escaped.length <= MAX_ECHOED_CHARACTERS ? escaped : `${escaped.slice(0, MAX_ECHOED_CHARACTERS)}…`;
+}
+/**
+* 비밀값을 셸 히스토리에 남기지 않고 환경변수에 넣는 방법. 안내 문장이 되풀이해 쓴다.
+*
+* **`MCP_TOKEN='Bearer …' mcpeak …` 를 예시로 쓰지 않는다.** 그 한 줄은 환경변수를 쓰긴 하지만
+* 명령 자체가 히스토리 파일에 토큰째로 남아, 이 옵션이 막으려던 노출의 절반을 그대로 만든다.
+* 우리가 권하는 예시가 우리 근거를 깎으면 안 된다.
+*/
+const SECRET_INPUT_HINT = "값은 셸 히스토리에 남지 않게 넣으세요. 예: `read -rs MCP_TOKEN; export MCP_TOKEN`";
+/**
+* `--url` 값을 검증한다.
+*
+* 스킴을 http·https 로 제한한다. `file:` 이나 `ws:` 를 넘기면 `core` 의 SDK 안쪽에서
+* 엉뚱한 문장으로 실패하고, 그 문장은 우리가 고칠 수 없는 자리에서 나온다.
+*/
+function parseUrlOption(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		return err(`\`--url\` 값이 올바른 URL 이 아닙니다: '${echoValue(raw)}'\n→ 스킴을 포함한 절대 URL 이어야 합니다. 예: https://mcp.example.com/v1`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return err(`\`--url\` 은 http 또는 https 만 받습니다. 받은 스킴: '${echoValue(url.protocol.replace(":", ""))}'\n→ Streamable HTTP MCP 서버의 엔드포인트를 넘기세요.`);
+	if (url.username !== "" || url.password !== "") return err("`--url` 에 자격증명을 넣지 마세요.\n→ URL 에 넣은 자격증명은 셸 히스토리와 `ps` 목록에 그대로 남습니다.\n→ 인증이 필요하면 `--header-env <헤더이름>=<환경변수이름>` 을 쓰세요.");
+	return ok(url.toString());
+}
+/**
+* `--header-env` 한 건을 파싱한다. 형식은 `<헤더이름>=<환경변수이름>` 이다.
+*
+* 값을 읽지 않는다. 이 함수는 argv 만 본다.
+*/
+function parseHeaderEnvOption(raw) {
+	const separator = raw.indexOf("=");
+	if (separator <= 0) return err(`\`--header-env\` 값의 형식이 올바르지 않습니다: '${echoValue(raw)}'\n→ \`<헤더이름>=<환경변수이름>\` 형식이어야 합니다. 예: --header-env Authorization=MCP_TOKEN`);
+	const header = raw.slice(0, separator);
+	const envName = raw.slice(separator + 1);
+	if (!HTTP_TOKEN_PATTERN.test(header)) return err(`\`--header-env\` 의 헤더 이름에 쓸 수 없는 문자가 있습니다: '${echoValue(header)}'\n→ 헤더 이름은 공백 없는 토큰이어야 합니다. 예: Authorization, X-Api-Key`);
+	if (!ENV_NAME_PATTERN.test(envName)) return err(`\`--header-env\` 의 '${echoValue(header)}' 자리에 환경변수 **이름**이 아닌 값이 온 것 같습니다: '${echoValue(envName)}'\n→ 이 옵션은 헤더 값을 직접 받지 않습니다. 값을 argv 에 실으면 \`ps\` 목록과 셸 히스토리에 남습니다.
+→ 값은 환경변수에 넣고 그 이름만 넘기세요. ${SECRET_INPUT_HINT}`);
+	return ok({
+		header,
+		envName
 	});
-	const client = {
-		listTools: () => recorder.listTools(),
-		callTool: (name, args) => recorder.callTool(name, args),
-		close: () => inner.close()
-	};
-	const flush = async () => {
-		await recorder.close();
-		if (snapshot === void 0) return;
-		await io.save(path, snapshot);
+}
+function createHeaderEnvCollector() {
+	/** 소문자 이름 → 처음 쓴 표기. */
+	const seen = /* @__PURE__ */ new Map();
+	/**
+	* null 프로토타입으로 만든다. 평범한 `{}` 에 `values["__proto__"] = …` 를 하면 값이 조용히
+	* 사라진다(프로토타입 설정으로 해석되고 문자열이라 무시된다). `__proto__` · `constructor` ·
+	* `toString` 은 모두 RFC 9110 토큰을 통과하는 유효한 헤더 이름이다.
+	*/
+	const values = Object.create(null);
+	return {
+		add(header, envName) {
+			const first = seen.get(header.toLowerCase());
+			if (first === header) return `\`--header-env\` 의 '${echoValue(header)}' 헤더가 두 번 지정됐습니다.`;
+			if (first !== void 0) return `\`--header-env\` 의 '${echoValue(header)}' 는 앞서 지정한 '${echoValue(first)}' 와 같은 헤더입니다.\n→ HTTP 헤더 이름은 대소문자를 구분하지 않습니다. 둘 중 하나만 남기세요.`;
+			seen.set(header.toLowerCase(), header);
+			values[header] = envName;
+		},
+		isEmpty: () => seen.size === 0,
+		snapshot: () => Object.freeze({ ...values })
 	};
+}
+/** 대상을 사람이 읽는 한 조각으로 만든다. 오류 문장이 무엇에 붙으려 했는지 말할 때 쓴다. */
+function describeTarget(target) {
+	return target.transport === "stdio" ? [target.command, ...target.args].join(" ") : target.url;
+}
+/** `openConnection` 이 연결 전에 멈춘 경우. 서브커맨드가 자기 오류 코드로 옮긴다. */
+var ConnectTargetError = class extends Error {};
+/**
+* 대상을 열어 `CliConnection` 을 돌려준다. `core` 가 던지는 `McpClientError` 는 그대로
+* 통과시킨다 — 그 오류의 진단과 문장이 기존 실패 경로가 기대하는 값이다.
+*
+* `env` 는 stdio 전용이다. External 배선이 만든 자식 환경 변수라 띄울 프로세스가 있어야
+* 뜻이 있고, 파서가 `--url` 과 External 세션 옵션의 동시 사용을 이미 막는다.
+*/
+async function openConnection(target, dependencies, options) {
+	if (target.transport === "stdio") return await dependencies.connectStdio({
+		command: target.command,
+		args: target.args,
+		...options?.env === void 0 ? {} : { env: options.env }
+	});
+	const connectHttp = dependencies.connectHttp;
+	if (connectHttp === void 0) throw new ConnectTargetError("이 진입점은 원격(Streamable HTTP) 서버를 지원하지 않습니다.\n→ `--url` 대신 `--command` 로 서버를 직접 띄우세요.");
+	const headers = resolveHeaders(target.headerEnv, dependencies.readEnv);
+	if (!headers.ok) throw new ConnectTargetError(headers.message);
+	const connection = await connectHttp({
+		url: target.url,
+		...Object.keys(headers.value).length === 0 ? {} : { headers: headers.value }
+	});
 	return {
-		client,
-		mode,
-		flush,
-		warnings
+		client: connection.client,
+		getDiagnostics: () => connection.getDiagnostics(),
+		close: () => connection.close(),
+		forceClose: () => connection.close()
 	};
 }
+/**
+* 환경변수에서 헤더 값을 읽는다.
+*
+* **실패 문장에 값을 싣지 않는다.** 환경변수 이름만 말한다. 값이 비었다는 사실을 알리려다
+* 값을 화면에 찍으면 이 옵션이 존재하는 이유가 없어진다.
+*/
+function resolveHeaders(headerEnv, readEnv) {
+	const entries = Object.entries(headerEnv);
+	if (entries.length === 0) return ok({});
+	if (readEnv === void 0) return err("이 진입점은 `--header-env` 를 지원하지 않습니다 (환경변수를 읽을 수 없습니다).\n→ 인증이 필요 없는 엔드포인트인지 확인하거나 터미널에서 `mcpeak` 을 직접 실행하세요.");
+	/**
+	* **null 프로토타입으로 만든다.** 평범한 `{}` 에 `headers["__proto__"] = …` 를 하면 값이
+	* 조용히 사라진다(프로토타입 설정으로 해석되고 문자열이라 무시된다). `__proto__` 는 RFC 9110
+	* 토큰을 통과하는 유효한 헤더 이름이므로, 그대로 두면 사용자가 지정한 헤더가 아무 말 없이
+	* 빠진 채 요청이 나간다.
+	*/
+	const headers = Object.create(null);
+	for (const [header, envName] of entries) {
+		const value = readEnv(envName);
+		if (value === void 0 || value === "") return err(`환경변수 '${echoValue(envName)}' 이 비어 있어 '${echoValue(header)}' 헤더를 만들 수 없습니다.\n→ ${SECRET_INPUT_HINT}`);
+		if (/[\r\n\0]/.test(value)) return err(`환경변수 '${echoValue(envName)}' 의 값에 개행이나 NUL 이 들어 있어 '${echoValue(header)}' 헤더로 쓸 수 없습니다.\n→ 값 끝의 줄바꿈이 흔한 원인입니다. 값을 확인하고 다시 실행하세요.`);
+		headers[header] = value;
+	}
+	return ok(headers);
+}
 //#endregion
 //#region src/dry-run.ts
 /** 보고서가 상한을 넘긴 경우의 안내. 케이스 수 말고는 사용자가 손댈 수 있는 것이 없다. */
@@ -93,32 +390,53 @@ const caseBlocks = (report) => {
 	return report.cases.map((_, index) => (blocks[index] ?? []).join("\n"));
 };
 /**
-* 연결이 끊긴 케이스의 위치를 찾는다. `runSuite` 는 호출이 던져도 멈추지 않고 다음 케이스로
-* 가므로, 서버가 죽으면 남은 케이스가 전부 같은 오류로 채워진다. 첫 번째만 사실이고 나머지는
-* 그 결과다. 그래서 첫 지점에서 자른다.
+* 연결 상실 사유별 문장. `runner` 의 `reporter.ts`·`junit.ts` 가 쓰는 어휘를 그대로 따른다.
+* 같은 죽음을 `test` 에서 볼 때와 `generate` 에서 볼 때 다른 낱말로 부르면 두 번 배우게 된다.
 */
-const firstConnectionLoss = (report) => {
-	for (const [index, result] of report.cases.entries()) {
-		const diagnostic = result.operation.diagnostic;
-		if (result.operation.status === "failed" && diagnostic?.code === "OPERATION_FAILED") return {
-			index,
-			message: diagnostic.message
-		};
-	}
+const CONNECTION_LOST_TEXT = {
+	processExited: "서버 프로세스가 종료됐습니다",
+	transportFailed: "서버와의 연결이 끊겼습니다",
+	httpSessionLost: "서버가 세션을 잃었습니다"
 };
 /**
-* 러너가 케이스를 다 돌기 전에 멈춘 경우를 찾는다. `stopReason` 이 그 사실을 말한다.
+* 종료 코드·시그널 괄호. 둘 다 관측하지 못했으면 괄호를 만들지 않는다. `(없음)` 은 관측하지
+* 못한 것을 관측했다고 말하는 것이다. reporter.ts 의 같은 이름 함수와 같은 규칙이다.
+*/
+const exitParens = (stop) => {
+	const parts = [];
+	if (stop.exitCode !== void 0) parts.push(`종료 코드 ${stop.exitCode}`);
+	if (stop.signal !== void 0) parts.push(`시그널 ${escapeTerminalText$2(stop.signal)}`);
+	return parts.length === 0 ? "" : ` (${parts.join(", ")})`;
+};
+/**
+* 러너가 케이스를 다 돌기 전에 멈춘 경우의 중단 사유. `stopReason` 이 그 사실을 말한다.
 *
 * 이것을 읽지 않으면 실행되지도 않은 `notRun` 케이스가 실패 목록에 섞여 분류 화면으로 간다.
 * 사용자가 그것을 `서버 결함` 으로 고르면 서버에 보낸 적도 없는 호출이 회귀 테스트가 된다.
+*
+* **연결이 끝났는지를 여기서 짐작하지 않는다.** 러너가 core 의 오류 코드로 판정해 넘겨준
+* `connectionLost` 만 연결 상실이다(#279 · ADR-0073). 예전에는 이 파일이 진단 코드가
+* `OPERATION_FAILED` 인 첫 케이스를 연결 끊김으로 읽었는데, 그 코드는 서버가 살아서 낸 평범한
+* 툴 오류에도 붙는다. 그래서 툴 하나가 오류를 내면 멀쩡히 돌아간 뒤 케이스의 판정까지 버리고
+* "연결이 끊겼습니다" 라고 말했다.
 */
-const stopDetail = (report) => {
+const abortedFromStop = (report) => {
 	const stop = report.stopReason;
 	if (stop === void 0) return void 0;
-	const name = report.cases.find((result) => result.spec.id === stop.caseId)?.spec.name;
+	const nameOf = (caseId) => escapeTerminalText$2(report.cases.find((result) => result.spec.id === caseId)?.spec.name ?? caseId);
 	const suffix = "남은 케이스는 실행되지 않았습니다.";
-	if (stop.type === "timeout") return `케이스 '${name ?? stop.caseId}' 가 제한 시간 안에 끝나지 않았습니다. ${suffix}`;
-	return name === void 0 ? `실행이 중단됐습니다. ${suffix}` : `케이스 '${name}' 에서 실행이 중단됐습니다. ${suffix}`;
+	if (stop.type === "connectionLost") return {
+		reason: "connectionLost",
+		detail: `케이스 '${nameOf(stop.caseId)}' 에서 ${CONNECTION_LOST_TEXT[stop.cause]}${exitParens(stop)}. ${suffix}`
+	};
+	if (stop.type === "timeout") return {
+		reason: "stopped",
+		detail: `케이스 '${nameOf(stop.caseId)}' 가 제한 시간 안에 끝나지 않았습니다. ${suffix}`
+	};
+	return {
+		reason: "stopped",
+		detail: stop.caseId === void 0 ? `실행이 중단됐습니다. ${suffix}` : `케이스 '${nameOf(stop.caseId)}' 에서 실행이 중단됐습니다. ${suffix}`
+	};
 };
 const toResult = (report) => {
 	const blocks = caseBlocks(report);
@@ -130,21 +448,10 @@ const toResult = (report) => {
 		rejectionBasis: result.rejectionBasis,
 		...result.rejectionBody === void 0 ? {} : { rejectionBody: result.rejectionBody }
 	}));
-	const lost = firstConnectionLoss(report);
-	if (lost !== void 0) return {
-		outcomes: outcomes.slice(0, lost.index + 1),
-		aborted: {
-			reason: "connectionLost",
-			detail: lost.message
-		}
-	};
-	const stopped = stopDetail(report);
-	if (stopped !== void 0) return {
+	const aborted = abortedFromStop(report);
+	if (aborted !== void 0) return {
 		outcomes: outcomes.filter((outcome) => outcome.status !== "notRun"),
-		aborted: {
-			reason: "stopped",
-			detail: stopped
-		}
+		aborted
 	};
 	return { outcomes };
 };
@@ -320,35 +627,96 @@ const FINDING_GROUP = {
 };
 //#endregion
 //#region src/help.ts
-const TEST_USAGE = "사용법: mcpeak test <suite.json> --command <executable> [--arg <value> ...] [--determinism] [--reset-cmd <command>] [--json] [--junit <path>] [--repair-bundle <path>] [--stderr-lines <N>]";
+/**
+* 원격(Streamable HTTP) 대상 옵션. `test` 와 `generate` 가 같은 문장을 쓴다 — 같은 사람이
+* 두 커맨드를 잇달아 쓰는데 설명이 다르면 그 차이를 기능으로 읽는다(#137).
+*
+* `--header-env` 가 값을 직접 받지 않는 이유를 여기서 말한다. 이유를 모르면 이 옵션은 그냥
+* 번거로운 `--header` 로 보이고, 사용자는 우회로를 찾다가 우리가 막으려던 그 노출을 만든다.
+*/
+const REMOTE_TARGET_OPTIONS = `  --url <URL>           이미 떠 있는 Streamable HTTP MCP 서버에 붙습니다. \`--command\` 및
+                        \`--arg\` 와 함께 쓸 수 없고, 띄울 프로세스가 없으므로 stdio
+                        전용 옵션도 받지 않습니다. 어느 옵션이 그런지는 함께 썼을 때
+                        오류 문장이 말합니다
+  --header-env <헤더이름>=<환경변수이름>
+                        요청 헤더를 환경변수에서 읽어 붙입니다. 값을 직접 받지 않는
+                        이유는 명령줄에 쓴 토큰이 \`ps\` 목록과 셸 히스토리에 그대로
+                        남기 때문입니다. 값을 넣을 때도 히스토리에 남기지 마세요:
+                          read -rs MCP_TOKEN; export MCP_TOKEN
+                          mcpeak … --header-env Authorization=MCP_TOKEN`;
+const TEST_USAGE = "사용법: mcpeak test <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] | --url <URL> [--header-env <헤더이름>=<환경변수이름> ...]) [--determinism] [--reset-cmd <command>] [--json] [--junit <path>] [--repair-bundle <path>] [--stderr-lines <N>] [--session <path> | --record-session <path>]";
 /**
 * 시험 실행 옵션 설명. `--determinism` 은 툴을 2회 호출하므로 부작용이 있는 서버에서 모르고
 * 쓰면 사고가 난다. 그 경고가 사용법 한 줄에는 들어가지 않는다.
 */
 const TEST_OPTIONS = `옵션:
+  -- <executable> [args...]
+                        \`--\` 뒤는 전부 서버를 띄울 명령입니다. 첫 토큰이 실행 파일,
+                        나머지가 그 인자입니다. \`--command\`/\`--arg\` 와 같은 일을 하며
+                        함께 쓸 수 없습니다
   --determinism         스위트를 2회 실행해 결과가 같은지 확인합니다. 툴을 2회
                         호출하므로 부작용이 있는 서버에서는 샌드박스에서 쓰세요.
                         --reset-cmd 와 함께 쓰면 결정론성 확인이 되고, 없으면
-                        "2회 결과가 같았다" 까지만 확인합니다
+                        "2회 결과가 같았다" 까지만 확인합니다.
+                        비차단 진단입니다 — 차이를 찾아도 종료 코드는 시험 판정
+                        그대로이며 이 진단만으로 1 이 되지 않습니다. CI 를 막으려면
+                        --json 의 determinism 키를 보세요.
+                        차이 지점의 양쪽 값을 화면에 싣습니다. \`token\`·\`apiKey\` 같은
+                        이름의 자리는 가려지지만, 서버가 결과를 JSON 문자열로 만들어
+                        text 블록 하나에 실으면 그 안의 비밀값은 이름이 없어
+                        가려지지 않습니다. 실행마다 비밀값을 새로 발급하는 서버라면
+                        출력을 CI 로그에 남기기 전에 확인하세요
   --reset-cmd <command> 각 시험 실행 전에 이 명령을 한 번 실행합니다. 셸을 거치지
-                        않으므로 파이프나 && 는 쓸 수 없습니다`;
-const GENERATE_USAGE = "사용법: mcpeak generate --suite-id <id> --name <name> --out <suite.json> --command <executable> [--arg <value> ...] [--baseline-only] [--provider <codex|claude>] [--model <model>] [--no-dry-run] [--cassette <path>] [--record] [--reset-cmd <command>] [--no-repair] [--force]";
+                        않으므로 파이프나 && 는 쓸 수 없습니다
+${REMOTE_TARGET_OPTIONS}
+  --record-session <path>
+                        서버가 \`globalThis.fetch\` 로 밖에 부른 HTTP 호출만 녹화합니다.
+                        서버는 실제로 실행됩니다. \`node:http\`·\`node:https\` 같은 범위 밖 호출은
+                        잡히지 않아 실제 네트워크로 나갈 수 있습니다
+  --session <path>      녹화한 외부 호출을 재생합니다. 서버는 실제로 실행되지만 외부
+                        API 호출은 \`globalThis.fetch\` 범위 안에서만 가로챕니다.
+                        범위 밖 호출은 실제 네트워크로 나갈 수 있으며, 범위 밖 호출이
+                        의심되는 경우 종료 때 알립니다
+
+두 세션 옵션은 서로, 그리고 \`--determinism\` 과 함께 쓸 수 없습니다. \`--determinism\` 은 서버에
+2회 연결하는데 세션은 연결 하나에 묶여 있어, 2회차가 같은 세션을 쓰면 반복 호출 순번이
+어긋나고 새 세션을 쓰면 비교 기준이 갈라집니다.
+
+세션 파일에는 외부 API 응답이 저장되므로 .gitignore 를 확인하세요. \`token\`·\`apiKey\` 같은
+이름의 값은 저장 전에 가려집니다. 다만 **본문에 실린 URL 은 가려지지 않습니다** — 이름으로
+판정할 수 없는 자리라서입니다. 녹화가 끝나면 그런 URL 이 몇 건 남았는지 알려 주며, 경로 자체가
+자격증명인 endpoint(Slack·Discord webhook 등)를 녹화했다면 커밋 전에 내용을 확인하세요.
+
+런타임에 따라 세션 옵션을 쓴 실행에서 \`ExperimentalWarning: SQLite is an experimental
+feature\` 가 stderr 에 한 줄 찍힙니다(실측: Node 22.18.0 에서 나오고 24.16.0 에서는 안 납니다).
+\`node:sqlite\` 를 처음 로드할 때 한 번 나오므로 실행당 한 줄이며, 세션 옵션이 없는 실행에는
+붙지 않습니다. Node 가 그 모듈을 아직 실험적으로 표시한다는 뜻이고, **저장된 녹화는 표준
+SQLite 파일이라 영향받지 않습니다.**`;
+const GENERATE_USAGE = "사용법: mcpeak generate --out <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] | --url <URL> [--header-env <헤더이름>=<환경변수이름> ...]) [--suite-id <id>] [--name <name>] [--baseline-only] [--provider <codex|claude>] [--model <model>] [--no-dry-run] [--reset-cmd <command>] [--no-repair] [--force]";
 /**
-* 시험 실행 옵션 설명. 사용법 한 줄로는 `--cassette` 가 무엇을 파일로 남기는지, `--reset-cmd`
-* 가 셸을 거치지 않는다는 제약을 알 수 없다. 둘 다 모르고 쓰면 사고가 나는 값이다.
+* 시험 실행 옵션 설명. 사용법 한 줄로는 `--reset-cmd` 가 셸을 거치지 않는다는 제약을 알 수
+* 없다. 모르고 쓰면 사고가 나는 값이다.
 */
 const GENERATE_DRY_RUN_OPTIONS = `옵션:
+  -- <executable> [args...]
+                        \`--\` 뒤는 전부 서버를 띄울 명령입니다. 첫 토큰이 실행 파일,
+                        나머지가 그 인자입니다. \`--command\`/\`--arg\` 와 같은 일을 하며
+                        함께 쓸 수 없습니다
+  --suite-id <id>       생략하면 \`--out\` 파일명에서 뽑습니다 (contract.suite.json → contract)
+  --name <name>         생략하면 \`--suite-id\` 와 같은 방식으로 뽑습니다
+  --out <suite.json>    저장 경로입니다. **파일명이 승인 지문에 들어갑니다** — id·name 을
+                        생략해 파일명에서 뽑았다면, 파일명을 바꿔 다시 생성할 때 지문이
+                        달라져 재승인이 뜹니다. 고정하려면 --suite-id 와 --name 을
+                        직접 지정하세요
   --no-dry-run          승인 전 시험 실행을 건너뜁니다. 케이스가 실제 서버에서 확인되지
                         않은 채 저장됩니다
-  --cassette <path>     서버 응답을 녹화·재생합니다. 반복 실행에서 서버를 다시 부르지
-                        않습니다. 응답 전문이 저장되므로 .gitignore 를 확인하세요
-  --record              카세트를 처음부터 다시 녹화합니다 (--cassette 필요)
   --reset-cmd <command> 시험 실행 전에 이 명령을 한 번 실행합니다. 셸을 거치지 않으므로
                         파이프나 && 는 쓸 수 없습니다
   --no-repair           시험 실행이 실패해도 입력값을 고쳐 다시 시도하지 않습니다.
                         실패가 곧바로 분류 화면으로 갑니다
   --force               \`--out\` 경로에 파일이 있으면 지우고 새로 씁니다. 기본은 저장을
-                        멈추는 것입니다`;
+                        멈추는 것입니다
+${REMOTE_TARGET_OPTIONS}`;
 const REPAIR_USAGE = "사용법: mcpeak repair <bundle.json> --provider <codex|claude> --model <model> [--max-cases <N>] [--no-stderr] [--yes]";
 /**
 * repair 옵션 설명. 사용법 한 줄로는 `--no-stderr` 가 무엇을 빼는지, `--yes` 가 무엇을 건너뛰는지
@@ -361,49 +729,7 @@ const REPAIR_OPTIONS = `옵션:
   --no-stderr        서버 stderr 를 전송에서 뺍니다. stderr 는 서버가 자유롭게 쓰는
                      텍스트라 경로·토큰·데이터가 섞일 수 있습니다
   --yes              전송 확인 화면을 건너뜁니다. 비대화형 환경에서 필요합니다`;
-const REPLAY_USAGE = "사용법: mcpeak replay <suite.json> --cassette <path>";
-/**
-* 재생이 무엇을 하지 않는지가 이 명령의 핵심이다. 서버를 안 띄운다는 것과, 마스킹된 값에서는
-* 판정이 실제와 갈릴 수 있다는 것을 한 줄 사용법으로는 알 수 없다. ADR-0028.
-*/
-const REPLAY_OPTIONS = `옵션:
-  --cassette <path>  재생할 카세트 파일입니다. 필수입니다.
-
-replay 는 MCP 서버를 실행하지 않고 카세트에 녹화된 응답만 돌려줍니다. 카세트에 없는 호출을
-만나면 실패합니다. 녹화는 \`mcpeak generate --cassette <path> --record\` 로 합니다.
-
-카세트는 저장할 때 \`token\`·\`apiKey\` 같은 이름의 값을 가립니다. 그 자리의 판정은 실제 서버와
-다를 수 있어 재생 시 경고합니다.`;
-const VERIFY_USAGE = "사용법: mcpeak verify <cassette.json> --command <executable> [--arg <value> ...]";
-/**
-* `verify` 가 무엇을 **하지 않는지**가 이 명령의 핵심이다. 서버를 부르지만 카세트를 고치지
-* 않는다. `--record` 와 헷갈리면 사용자는 지우려던 적이 없는 파일을 지운다.
-*
-* 다만 "읽기 전용" 을 그 한 마디로 끝내면 안 된다. 읽기 전용인 것은 **카세트 파일**이고,
-* 서버 쪽으로는 녹화된 요청을 전부 다시 부른다. 메일 발송·결제·파일 쓰기 툴이 카세트에
-* 들어 있으면 그 부작용이 실제로 다시 일어난다. `--determinism` 이 툴을 2회 부른다는
-* 경고와 같은 성격이라 같은 자리에 적는다.
-*/
-const VERIFY_OPTIONS = `옵션:
-  --command <executable>  MCP 서버 실행 파일입니다. 필수입니다.
-  --arg <value>           서버에 넘길 인자입니다. 여러 번 쓸 수 있습니다.
-
-verify 는 카세트에 녹화된 요청을 실서버에 다시 보내 응답이 아직 같은지 확인합니다.
-**카세트를 고치지도 저장하지도 않습니다.**
-
-읽기 전용인 것은 카세트 파일입니다. 서버 쪽은 녹화된 요청을 **전부 다시 호출**하므로,
-메일 발송·결제·파일 쓰기 같은 툴이 카세트에 있으면 그 부작용이 실제로 다시 일어납니다.
-부작용이 있는 서버에서는 샌드박스에서 쓰세요.
-
-auto 모드(\`--record\` 없는 실행)는 카세트에 있는 요청이면 서버를 부르지 않으므로, 서버
-응답이 바뀌어도 알아채지 못합니다. 이 명령이 그 드리프트를 확인하는 비파괴 경로입니다.
-
-카세트는 저장할 때 \`token\`·\`apiKey\` 같은 이름의 값을 가립니다. 그 값이 **요청 인자**에
-있었다면 원래 요청을 복원할 수 없어 "확인불가" 로 보고합니다. 응답 쪽 비밀값은 양쪽 모두
-마스킹해 비교하므로, 비밀값 자체만 바뀐 경우는 감지되지 않습니다.
-
-불일치나 호출 실패가 하나라도 있으면 종료 코드 1 입니다. 확인불가는 실패로 보지 않습니다.`;
-const GLOBAL_HELP = `OhMyMCP — MCP 서버 테스트 프레임워크
+const GLOBAL_HELP = `MCPeak — MCP 서버 테스트 프레임워크
 
 사용법: mcpeak <명령> [옵션]
         mcpeak help [명령]
@@ -412,8 +738,6 @@ const GLOBAL_HELP = `OhMyMCP — MCP 서버 테스트 프레임워크
   test      JSON 테스트 명세로 MCP 서버를 실행하고 검증합니다.
   generate  MCP 서버의 툴 스키마에서 테스트 명세를 생성합니다.
   repair    실패한 test 실행의 번들로 서버 코드의 원인 후보를 제안받습니다.
-  replay    녹화된 카세트로 서버 없이 테스트 명세를 재생합니다.
-  verify    카세트가 아직 실서버 응답과 맞는지 확인합니다 (카세트를 고치지 않음).
 
 옵션:
   -h, --help  도움말을 표시합니다.
@@ -423,19 +747,20 @@ const GLOBAL_HELP = `OhMyMCP — MCP 서버 테스트 프레임워크
   mcpeak help <명령>
   mcpeak <명령> --help
 `;
-const commandDiscovery = "사용 가능한 명령: test, generate, repair, replay, verify. 전체 도움말: mcpeak --help";
+/**
+* 여러 실패 안내가 이 문구를 그대로 되풀이한다. `export` 하는 이유는 `test-command.ts` 의
+* `COMMAND_NOT_IMPLEMENTED` 안내가 한때 이 목록을 손으로 베껴 적었다가 `replay` 제거(ADR-0059)
+* 뒤에도 낡은 채 남았기 때문이다(#289). 정본을 하나만 두면 같은 일이 되풀이되지 않는다.
+*
+* **여기에 어느 서브커맨드의 사용법도 붙이지 않는다.** 오타는 "어느 옵션을 쓰나" 가 아니라
+* "어떤 명령이 있나" 를 모르는 상태다. 특정 서브커맨드의 플래그 목록을 붙이면 사용자가
+* 묻지도 않은 명령의 사용법 200 자를 읽고 나서야 목록에 닿는다.
+*/
+const commandDiscovery = "사용 가능한 명령: test, generate, repair. 전체 도움말: mcpeak --help";
 const TEST_USAGE_HINT = `${TEST_USAGE} ${commandDiscovery}`;
 const GENERATE_USAGE_HINT = `${GENERATE_USAGE} ${commandDiscovery}`;
 const REPAIR_USAGE_HINT = `${REPAIR_USAGE} ${commandDiscovery}`;
-const REPLAY_USAGE_HINT = `${REPLAY_USAGE} ${commandDiscovery}`;
-const VERIFY_USAGE_HINT = `${VERIFY_USAGE} ${commandDiscovery}`;
 function commandHelp(command) {
-	if (command === "verify") return `verify — 카세트가 아직 실서버 응답과 맞는지 확인합니다.
-
-${VERIFY_USAGE}
-
-${VERIFY_OPTIONS}
-`;
 	if (command === "test") return `test — JSON 테스트 명세로 MCP 서버를 실행하고 검증합니다.
 
 ${TEST_USAGE}
@@ -447,12 +772,6 @@ ${TEST_OPTIONS}
 ${REPAIR_USAGE}
 
 ${REPAIR_OPTIONS}
-`;
-	if (command === "replay") return `replay — 녹화된 카세트로 서버 없이 테스트 명세를 재생합니다.
-
-${REPLAY_USAGE}
-
-${REPLAY_OPTIONS}
 `;
 	return `generate — MCP 서버의 툴 스키마에서 테스트 명세를 생성합니다.
 
@@ -462,6 +781,76 @@ ${GENERATE_DRY_RUN_OPTIONS}
 `;
 }
 //#endregion
+//#region src/http-diagnostics.ts
+/**
+* core 의 HTTP 진단인지 구조와 값의 범위로 확인한다.
+*
+* stdio 진단은 `url` 이 없으므로 여기서 `undefined` 로 떨어진다. 반대로 HTTP 진단은
+* `stderr` 가 없어 `processDiagnostics` 에서 떨어진다. 두 가드가 서로를 배제하는 것이
+* 이 쌍의 요점이다 — 한쪽 블록이 다른 쪽 transport 의 값을 그리면 화면이 거짓말을 한다.
+*/
+function httpDiagnostics(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	if (!("url" in value) || typeof value.url !== "string" || value.url === "") return void 0;
+	if (!("status" in value) || !(value.status === null || typeof value.status === "number" && Number.isInteger(value.status) && value.status >= 0)) return void 0;
+	if (!("statusText" in value) || !(value.statusText === null || typeof value.statusText === "string")) return void 0;
+	if (!("sessionId" in value) || !(value.sessionId === null || typeof value.sessionId === "string")) return void 0;
+	return value;
+}
+/**
+* 터미널 제어 문자를 무해한 문자열로 바꾼다.
+*
+* `process-diagnostics.ts` 의 `escapeTokens` 와 같은 계열이되 **TAB 도 이스케이프한다.**
+* 그쪽이 TAB 을 살려 두는 이유는 서버 stderr 의 스택 트레이스 들여쓰기였는데, 여기서
+* 그리는 값은 URL 과 상태 문구와 세션 ID 다. 셋 다 TAB 이 들어갈 자리가 아니다.
+*
+* 사본을 두는 근거는 `process-diagnostics.ts` 와 같다(ADR-0013).
+*/
+function escapeTerminalText$1(value) {
+	return Array.from(value, (character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 8232 || codePoint === 8233 ? `\\u${codePoint.toString(16).padStart(4, "0")}` : character;
+	}).join("");
+}
+/**
+* 값 하나가 지나치게 길 때 자른다. URL 은 사용자가 준 값이고 세션 ID 는 서버가 준 값이라
+* 둘 다 길이에 상한이 없다. `process-diagnostics.ts` 의 `MAX_LINE_CHARACTERS` 와 같은 값이다.
+*/
+const MAX_VALUE_CHARACTERS = 1e3;
+function clamp(value) {
+	const escaped = escapeTerminalText$1(value);
+	if (escaped.length <= MAX_VALUE_CHARACTERS) return escaped;
+	return `${escaped.slice(0, MAX_VALUE_CHARACTERS)} …(${escaped.length - MAX_VALUE_CHARACTERS}자 생략)`;
+}
+/**
+* 블록에 담을 내용이 있는지 판정한다. `process-diagnostics.ts` 의 `hasDiagnosticContent` 와
+* 같은 자리에 쓴다.
+*
+* **`status !== null` 이 곧 "실패를 관측했다" 이다.** core 의 `HttpConnectionState` 는 상태
+* 코드를 실패 경로(`toConnectError` · `operationFailureKind`)에서만 채운다. 성공한 실행은
+* 끝까지 null 이므로, 이 판정 없이 그리면 초록불 뒤에 매번 빈 진단 블록이 붙는다.
+*
+* 연결 자체가 실패한 경로는 이 판정을 거치지 않는다. 그때는 상태 코드가 없어도(DNS 실패,
+* 연결 거부) **어느 엔드포인트에 붙으려다 실패했는지**가 정보이고, HTTP 진단에는 stderr 처럼
+* 비어 있을 수 있는 본문이 없어 "정보량 0인 블록" 이 나올 수가 없다.
+*/
+function hasHttpDiagnosticContent(diagnostics) {
+	return diagnostics.status !== null;
+}
+/**
+* 진단 블록을 만든다. 빈 문자열이 아니면 항상 개행으로 끝난다.
+*
+* 상태 코드가 없을 때 `(없음)` 이라고 쓰지 않는다. stdio 의 `종료 코드: 없음` 은 "아직 안
+* 죽었다" 라는 사실이지만, HTTP 에서 상태 코드가 없는 것은 **응답에 닿지 못했다**는 뜻이라
+* 뜻이 정반대다. 같은 문구를 쓰면 읽는 사람이 서버가 200 을 줬다고 읽는다.
+*/
+function renderHttpDiagnostics(diagnostics) {
+	const status = diagnostics.status === null ? "응답에 닿지 못했습니다" : diagnostics.statusText === null ? String(diagnostics.status) : `${diagnostics.status} ${clamp(diagnostics.statusText)}`;
+	const sessionId = diagnostics.sessionId === null ? "발급하지 않음 (stateless)" : clamp(diagnostics.sessionId);
+	return `원격 서버 진단
+  엔드포인트: ${clamp(diagnostics.url)}\n  HTTP 상태: ${status}\n  세션 ID: ${sessionId}\n`;
+}
+//#endregion
 //#region src/input-repair.ts
 /** 케이스 머리글 들여쓰기. 분류 화면(§8.3)과 같은 값이라 번호가 이어 읽힌다. */
 const HEAD = "  ";
@@ -473,8 +862,20 @@ const BODY = "      ";
 * `RepairTarget` 이 `detail` 을 나르지 않아 여기서 다시 적는다.
 */
 const FAILURE_LINE = `${BODY}isError  정상 응답을 기대했지만 오류 응답을 받았습니다.`;
-const PROPOSED_LEAD = `${BODY}입력값이 거절된 것으로 보입니다. 서버 응답에서 값을 찾았습니다.`;
+/**
+* 제안값의 출처를 말한다. `propose` 는 provider 가 있을 때만 배선되므로 여기 오는 값은
+* **항상 provider 가 만든 것**이다 — 그런데 전에는 서버에 귀속했다(#286).
+* 표기를 못 받은 경우에도 서버라고 말하지 않는다.
+*/
+const proposedLead = (by) => `${BODY}입력값이 거절된 것으로 보입니다. ${by === void 0 ? "AI 가" : `${by} 가`} 서버 응답을 보고 제안한 값입니다.`;
 const MANUAL_LEAD = `${BODY}입력값이 거절된 것으로 보입니다. 서버 응답에 쓸 만한 값이 없어 직접 받습니다.`;
+/**
+* 전송을 거절한 갈래. **`MANUAL_LEAD` 를 쓰면 안 된다** — 서버 응답은 있었고 보내지 않기로
+* 한 것뿐인데 "쓸 만한 값이 없다" 는 거짓 사유가 된다(#286).
+*/
+/** `propose` 가 아예 없는 경우. 요청조차 하지 않았으니 근거 부재와 같다. */
+const UNAVAILABLE_OUTCOME = { kind: "unavailable" };
+const DECLINED_LEAD = `${BODY}입력값이 거절된 것으로 보입니다. AI 전송을 거절했으므로 값을 직접 받습니다.`;
 const RERUN_LINE = `${BODY}▸ 다시 실행 중... 1건`;
 const PASSED_LINE = `${BODY}✓ 통과`;
 const EXHAUSTED_LINE = `${BODY}✗ 여전히 실패합니다. 입력값 문제가 아닐 수 있습니다.`;
@@ -590,8 +991,9 @@ async function repairInputs(options) {
 			const shared = options.targets.slice(index).filter((other) => other.tool === target.tool && field in other.input).length;
 			options.io.write(`${BODY}같은 값을 ${target.tool}.${field} 를 쓰는 케이스 ${shared}건에 함께 적용합니다.\n`);
 		}
-		const proposed = askable.length === 0 ? void 0 : await options.propose?.(target);
-		if (askable.length > 0) options.io.write(proposed === void 0 ? `${MANUAL_LEAD}\n` : `${PROPOSED_LEAD}\n`);
+		const outcome = askable.length === 0 ? void 0 : await options.propose?.(target) ?? UNAVAILABLE_OUTCOME;
+		const proposed = outcome?.kind === "proposed" ? outcome.input : void 0;
+		if (askable.length > 0) options.io.write(`${outcome?.kind === "proposed" ? proposedLead(options.proposedBy) : outcome?.kind === "declined" ? DECLINED_LEAD : MANUAL_LEAD}\n`);
 		const first = await askRound(options.io, target, {
 			current: target.input,
 			proposed,
@@ -833,6 +1235,18 @@ function dropSkippedTools(suite, skips) {
 }
 //#endregion
 //#region src/process-diagnostics.ts
+/**
+* core 의 stdio 프로세스 진단인지 구조와 값의 범위로 확인한다.
+* 일부 필드만 있거나 프로세스 상태로 표현할 수 없는 값은 렌더하지 않는다.
+*/
+function processDiagnostics(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	if (!("stderr" in value) || typeof value.stderr !== "string") return void 0;
+	if (!("stderrTruncated" in value) || typeof value.stderrTruncated !== "boolean") return void 0;
+	if (!("exitCode" in value) || !(value.exitCode === null || typeof value.exitCode === "number" && Number.isInteger(value.exitCode))) return void 0;
+	if (!("signal" in value) || !(value.signal === null || typeof value.signal === "string" && value.signal.length > 0)) return void 0;
+	return value;
+}
 /** TAB. 이 모듈만 이스케이프 대상에서 빼는 문자다. 아래 escapeTokens 주석에 근거가 있다. */
 const TAB = 9;
 /**
@@ -1017,229 +1431,45 @@ function acceptProposal(options) {
 	if (same(beforeInput, afterInput)) return void 0;
 	return afterInput;
 }
-/**
-* 교정안을 provider 에게 요청한다. 실패는 전부 `undefined` 로 접는다. 교정은 선택이지
-* 전제가 아니라서, 여기서 던지면 교정 실패가 시험 실행을 통째로 죽인다.
-*/
+const UNAVAILABLE = { kind: "unavailable" };
 async function proposeRepair(options) {
-	if (options.target.serverMessage === "") return void 0;
-	const before = options.session.approvedDraft.suite;
-	try {
-		const preview = options.prepare({
-			mode: "revise",
-			instruction: buildInstruction(options.target),
-			baseline: options.session.baseline.suite,
-			candidate: before,
-			tools: options.tools,
-			providerId: options.provider.id,
-			model: options.provider.model ?? "",
-			redaction: options.redaction
-		});
-		if (!hasServerMessage(preview.request.instruction)) return void 0;
-		const result = await options.dispatch({
-			provider: options.provider,
-			preview,
-			approval: {
-				approved: true,
-				fingerprint: preview.fingerprint
-			}
-		});
-		if (result.status !== "preview") return void 0;
-		return acceptProposal({
-			target: options.target,
-			before,
-			after: result.preview.result.suite
-		});
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region src/repair-render.ts
-/**
-* 터미널 제어 문자를 무해한 토큰으로 바꾼다.
-*
-* `packages/cli/src/test-command.ts` 의 `escapeTerminalText` 와 같은 계열이다. 그 함수를
-* import 하지 않고 사본을 두는 근거는 ADR-0013 이고 `process-diagnostics.ts` 의 선례와 같다.
-* 이 모듈이 찍는 문자열은 **외부 provider 가 준 산문**이라 원문 보존보다 화면 무해성이 앞선다.
-*
-* TAB(0x09)도 이스케이프한다. `process-diagnostics.ts` 사본만 TAB 을 남기는데 그것은 서버
-* stderr 의 스택트레이스 들여쓰기를 보존하기 위해서다. AI 산문에는 보존할 들여쓰기가 없고,
-* 우리가 만든 라벨 정렬을 TAB 이 흔들면 화면이 어긋난다.
-*/
-const escapeTerminalText$1 = (value) => Array.from(value, (character) => {
-	const codePoint = character.codePointAt(0) ?? 0;
-	return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 8232 || codePoint === 8233 ? `\\u${codePoint.toString(16).padStart(4, "0")}` : character;
-}).join("");
-/** 코드 포인트 단위로 자른다. 서로게이트 쌍(이모지)의 중간이 끊기지 않는다. */
-function clampDisplay(text, limit) {
-	const points = [...text];
-	return points.length <= limit ? text : `${points.slice(0, limit).join("")}…`;
-}
-/**
-* 경계 문장 둘. **모든 경로에서** 찍는다. `unsure` 여도, 진단이 잘 나와도 찍는다.
-* 이것이 없으면 사용자가 멀쩡한 서버 코드를 판다. 억제 조건을 만들지 않는다. 설계서 §6.3.
-*/
-const REPAIR_BOUNDARY_LINES = "※ AI 제안입니다. 파일을 고치지 않았고 명세도 그대로입니다.\n※ 명세 쪽이 틀렸다고 판단되면 `mcpeak generate` 로 다시 승인받으세요.\n";
-/** 비대화형에서 `--yes` 없이 부른 경우. 물어볼 수 없는 곳에서 조용히 보내지 않는다. */
-const REPAIR_CONFIRM_REQUIRED_LINE = "오류 [REPAIR_CONFIRM_REQUIRED]: 확인을 받을 수 없는 환경입니다. 전송 내용을 보여줄 수 없어 보내지 않았습니다.\n해결: 내용을 확인했다면 `--yes` 를 붙여 다시 실행하세요.\n";
-/** 사용자가 `n` 을 답한 경로. 실패가 아니라 의도한 종료다. */
-const REPAIR_CANCELLED_LINE = "전송하지 않았습니다.\n";
-const APPROVAL_LABEL = {
-	matched: "승인 지문 일치",
-	mismatched: "승인 지문 불일치",
-	absent: "승인 지문 없음"
-};
-/**
-* 지문이 승인 상태가 아닐 때 결과 맨 위에 붙는 블록. 결과가 `unsure` 여도 붙는다. 설계서 §6.5.
-* `matched` 면 빈 문자열이다.
-*/
-function renderApprovalNotice(approval) {
-	if (approval === "matched") return "";
-	if (approval === "mismatched") return "⚠ 이 명세는 승인 상태가 아닙니다 (지문 불일치).\n  실패 원인이 서버가 아니라 명세일 수 있습니다. 아래 제안은 그 전제로 받았습니다.\n\n";
-	return "⚠ 이 명세는 승인 지문이 없습니다.\n  실제 서버로 검증된 적이 없는 명세일 수 있습니다. 아래 제안은 그 전제로 받았습니다.\n\n";
-}
-/** KB 표기. 소수 한 자리다. 바이트 그대로 찍으면 큰 수를 눈으로 못 읽는다. */
-function kilobytes(bytes) {
-	return `${(bytes / 1024).toFixed(1)} KB`;
-}
-/**
-* 전송 확인 화면(설계서 §6.1). 질문 줄은 붙이지 않는다. 그것은 `ReviewIO.confirm` 이 찍는다.
-*/
-function renderRepairConfirm(view) {
-	const scope = view.omittedFailures === 0 ? `실패 ${view.totalFailures}건 중 ${view.sentFailures}건` : `실패 ${view.totalFailures}건 중 ${view.sentFailures}건 (--max-cases ${view.maxCases}, ${view.omittedFailures}건 제외)`;
-	let stderrLine;
-	if (!view.includeStderr) stderrLine = "(전송하지 않음)";
-	else if (view.stderr === void 0 || view.stderr === "") stderrLine = "없음";
-	else {
-		const lines = view.stderr.split("\n");
-		if (lines[lines.length - 1] === "") lines.pop();
-		stderrLine = `${lines.length}줄 ${kilobytes(Buffer.byteLength(view.stderr, "utf8"))} (--no-stderr 로 제외할 수 있습니다)`;
-	}
-	return [
-		"repair 요청을 보냅니다.\n",
-		"\n",
-		`  provider   ${view.providerId} (${escapeTerminalText$1(view.model)})\n`,
-		`  대상       ${scope}\n`,
-		`  명세 상태  ${APPROVAL_LABEL[view.approval]}\n`,
-		`  stderr     ${stderrLine}\n`,
-		`  전송 크기  ${kilobytes(view.requestBytes)}\n`,
-		"\n",
-		"※ 위 내용이 외부 provider 로 전송됩니다.\n",
-		"※ stderr 는 서버가 자유롭게 쓰는 텍스트라 경로·토큰·데이터가 섞일 수 있습니다.\n"
-	].join("");
-}
-function discardedTotal(discarded) {
-	return discarded.unknownCase + discarded.specTarget + discarded.unsureCauses;
-}
-function renderDiscardReasons(discarded) {
-	const reasons = [];
-	if (discarded.unknownCase > 0) reasons.push(`요청에 없는 케이스를 가리킨 제안 ${discarded.unknownCase}건`);
-	if (discarded.specTarget > 0) reasons.push(`승인된 명세를 고치라는 제안 ${discarded.specTarget}건`);
-	if (discarded.unsureCauses > 0) reasons.push(`판단 불가 응답에 함께 온 원인 후보 ${discarded.unsureCauses}건`);
-	return reasons;
-}
-function renderDiscardActions(discarded) {
-	const actions = [];
-	if (discarded.specTarget > 0) actions.push("  → 명세가 실제로 틀렸다고 보시면 `mcpeak generate` 로 다시 승인받으세요.\n", "    승인된 명세를 고치라는 제안은 그 전에는 화면에 올리지 않습니다.\n");
-	if (discarded.unknownCase > 0 || discarded.unsureCauses > 0) actions.push("  → 같은 번들로 한 번 더 물어보세요. 같은 입력에도 답은 달라집니다.\n");
-	return actions;
-}
-/**
-* 제안이 전부 폐기돼 남은 항목이 0 인 경우의 문안.
-*
-* 사용자가 알아야 할 것은 셋이다. AI 가 답을 냈다는 사실, 우리가 왜 버렸는지, 다음에 무엇을
-* 할 수 있는지. generate 가 보존한 사유별 개수로 관련 있는 행동만 안내한다.
-*/
-function renderAllDiscarded(discarded) {
-	const parts = [
-		`AI 가 원인 후보 ${discardedTotal(discarded)}건을 냈지만 전부 검증에서 제외했습니다.\n`,
-		"판단 근거가 없어서가 아니라 답을 그대로 쓸 수 없어서입니다.\n",
-		"\n"
-	];
-	for (const reason of renderDiscardReasons(discarded)) parts.push(`  제외 사유  ${reason}\n`);
-	parts.push("\n", ...renderDiscardActions(discarded));
-	return parts.join("");
-}
-/** 케이스 머리줄. 툴이 없는 케이스(listTools)는 괄호를 안 찍는다. */
-function caseHeading(caseId, tool) {
-	const id = escapeTerminalText$1(caseId);
-	return tool === void 0 ? `${id}\n` : `${id}  (${escapeTerminalText$1(tool)})\n`;
-}
-/**
-* 결과 화면(설계서 §6.2·§6.4·§6.5).
-*
-* 문안은 CLI 가 소유한다. AI 는 필드만 채운다. 라벨·들여쓰기·순서·경계 문장은 전부 우리 것이다.
-* 케이스 순서는 **번들 순서**다. AI 응답 순서로 정렬하지 않는다. 같은 실행을 두 번 볼 때 화면이
-* 달라지면 안 된다.
-*/
-function renderRepairResult(options) {
-	const parts = [
-		`── 서버 수정 방향 (${options.providerId} / ${escapeTerminalText$1(options.model)}) ──\n`,
-		"\n",
-		renderApprovalNotice(options.bundle.spec.approval)
-	];
-	if (options.result.status === "unsure") {
-		/**
-		* `unsure` 는 두 가지 다른 일이다. 하나로 뭉치면 화면이 거짓말을 한다.
-		*
-		* `discarded` 합계가 0 이면 provider 가 실제로 판단을 못 한 것이고, 그때만 "근거가 부족" 이
-		* 사실이다. 합계가 0 보다 크면 **답은 왔는데 우리가 경계 밖이라 버린 것**이다.
-		* 그 경로에 "근거가 부족" 을 찍으면 사용자는 번들에 정보를 더 담아야 한다고 읽는다.
-		* 실제로 그 화면을 보고 "구현이 실패한 것 아니냐" 는 질문이 나왔다.
-		*/
-		if (discardedTotal(options.result.discarded) > 0) parts.push(renderAllDiscarded(options.result.discarded));
-		else parts.push("판단 근거가 부족해 원인 후보를 제시하지 못했습니다.\n");
-		if (options.result.shortfall !== "") {
-			const [first, ...rest] = escapeTerminalText$1(clampDisplay(options.result.shortfall, 500)).split("\n");
-			parts.push("\n", `  → ${first}\n`);
-			for (const line of rest) parts.push(`    ${line}\n`);
-		}
-	} else {
-		const byCase = /* @__PURE__ */ new Map();
-		for (const cause of options.result.causes) {
-			const list = byCase.get(cause.caseId) ?? [];
-			list.push(cause);
-			byCase.set(cause.caseId, list);
-		}
-		let first = true;
-		for (const failure of options.bundle.failures) {
-			const causes = byCase.get(failure.caseId);
-			if (causes === void 0) continue;
-			for (const cause of causes) {
-				if (!first) parts.push("\n");
-				first = false;
-				parts.push(caseHeading(failure.caseId, failure.tool));
-				parts.push(`  원인 후보  ${escapeTerminalText$1(cause.summary)}\n`);
-				if (cause.location !== "") parts.push(`  확인할 곳  ${escapeTerminalText$1(cause.location)}\n`);
-				if (cause.evidence !== "") parts.push(`  근거       ${escapeTerminalText$1(cause.evidence)}\n`);
-				if (cause.target === "spec" && options.bundle.spec.approval !== "matched") parts.push("  분류       명세 쪽 원인으로 봄\n");
+	if (options.target.serverMessage === "") return UNAVAILABLE;
+	const before = options.session.approvedDraft.suite;
+	try {
+		const preview = options.prepare({
+			mode: "revise",
+			instruction: buildInstruction(options.target),
+			baseline: options.session.baseline.suite,
+			candidate: before,
+			tools: options.tools,
+			providerId: options.provider.id,
+			model: options.provider.model ?? "",
+			redaction: options.redaction
+		});
+		if (!hasServerMessage(preview.request.instruction)) return UNAVAILABLE;
+		if (!await options.confirm(preview)) return { kind: "declined" };
+		const result = await options.dispatch({
+			provider: options.provider,
+			preview,
+			approval: {
+				approved: true,
+				fingerprint: preview.fingerprint
 			}
-		}
-	}
-	if (discardedTotal(options.result.discarded) > 0 && options.result.status !== "unsure") {
-		parts.push("\n");
-		for (const reason of renderDiscardReasons(options.result.discarded)) parts.push(`※ ${reason}이 검증에서 제외됐습니다.\n`);
-		parts.push("\n", ...renderDiscardActions(options.result.discarded));
+		});
+		if (result.status !== "preview") return UNAVAILABLE;
+		const input = acceptProposal({
+			target: options.target,
+			before,
+			after: result.preview.result.suite
+		});
+		return input === void 0 ? UNAVAILABLE : {
+			kind: "proposed",
+			input
+		};
+	} catch {
+		return UNAVAILABLE;
 	}
-	parts.push("\n", REPAIR_BOUNDARY_LINES);
-	return parts.join("");
-}
-/** provider 실패 안내. 닫힌 enum 만 화면에 오고 raw stdout·stderr 는 오지 않는다. */
-function renderRepairProviderFailure(failure) {
-	const reason = failure.reason === void 0 ? "" : ` (${failure.reason})`;
-	return `오류 [REPAIR_PROVIDER_FAILED]: ${failure.providerId} 에게 진단을 받지 못했습니다. 코드: ${failure.code}${reason}\n해결: \`${failure.providerId} --version\` 으로 설치와 인증을 확인한 뒤 다시 실행하세요. 파일은 하나도 바뀌지 않았습니다.\n`;
 }
-/** 응답이 계약을 못 지킨 경우. 우리가 버렸다는 사실을 말한다. */
-const REPAIR_INVALID_RESULT_LINE = "오류 [REPAIR_RESULT_INVALID]: provider 응답이 진단 형식을 지키지 않아 버렸습니다.\n해결: 같은 번들로 다시 실행하거나 다른 `--model` 로 시도하세요. 파일은 하나도 바뀌지 않았습니다.\n";
-/**
-* 응답이 `maxResultBytes` 를 넘어 거절된 경우. 형식이 틀린 것과 다르다. 답은 형식을 지켰지만
-* 우리가 정한 상한 밖이라 받지 않은 것이고, 사용자가 할 일도 다르다. 같은 문장을 쓰면
-* "다른 모델로 시도하세요" 라는 엉뚱한 안내를 하게 된다.
-*/
-const REPAIR_RESULT_LIMIT_LINE = "오류 [REPAIR_RESULT_LIMIT_EXCEEDED]: provider 응답이 허용 크기를 넘어 받지 않았습니다.\n해결: `--max-cases` 로 한 번에 묻는 실패 수를 줄여 다시 실행하세요. 파일은 하나도 바뀌지 않았습니다.\n";
-/** 승인 검사에 걸린 경우. 사용자가 본 것과 나가는 것이 달라졌다는 뜻이다. */
-const REPAIR_APPROVAL_INVALIDATED_LINE = "오류 [REPAIR_APPROVAL_INVALIDATED]: 확인한 내용과 보내려는 내용이 달라 전송을 멈췄습니다.\n해결: 같은 번들로 다시 실행하세요. 파일은 하나도 바뀌지 않았습니다.\n";
 //#endregion
 //#region src/repair-target.ts
 /** `renderReport` 가 케이스 본문 줄에 쓰는 들여쓰기. dry-run.ts 의 INDENT 와 같은 값이다. */
@@ -1527,12 +1757,12 @@ const optionNames$1 = /* @__PURE__ */ new Set([
 	"--out",
 	"--command",
 	"--arg",
+	"--url",
+	"--header-env",
 	"--baseline-only",
 	"--provider",
 	"--model",
 	"--no-dry-run",
-	"--cassette",
-	"--record",
 	"--reset-cmd",
 	"--no-repair",
 	"--force"
@@ -1541,10 +1771,11 @@ const optionNames$1 = /* @__PURE__ */ new Set([
 const flagNames$1 = /* @__PURE__ */ new Set([
 	"--baseline-only",
 	"--no-dry-run",
-	"--record",
 	"--no-repair",
 	"--force"
 ]);
+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$1(`\`${option}\` 옵션 값이 필요합니다.`);
@@ -1554,15 +1785,45 @@ function optionValue$1(argv, index, option) {
 	if (value === void 0 || option !== "--arg" && value.startsWith("--")) throw new UsageError$1(`\`${option}\` 옵션 값이 필요합니다.`);
 	return [value, index + 1];
 }
+/**
+* `--out` 에서 스위트 id·name 을 유도한다. `contract.suite.json` → `contract`(#242).
+* 명시한 값이 있으면 그쪽이 이긴다. 뽑을 이름이 없으면 `undefined` 를 주고 호출 측이 요구한다.
+*
+* **파일명이 승인 지문에 들어간다.** `suiteFingerprint` 가 `approval` 만 빼고 전부 해시하므로
+* (`packages/runner/src/fingerprint.ts`) 출력 파일명을 바꿔 다시 생성하면 지문이 달라져
+* 재승인이 뜬다. 그 사실을 `--out` 도움말이 말한다. ADR-0073.
+*/
+const deriveSuiteName = (out) => {
+	const strip = (value, suffix) => value.toLowerCase().endsWith(suffix) ? value.slice(0, -suffix.length) : value;
+	const derived = strip(strip(basename(out), ".json"), ".suite");
+	return derived === "" ? void 0 : derived;
+};
 function parseGenerateCommand(argv) {
 	const values = /* @__PURE__ */ new Map();
 	const args = [];
 	const flags = /* @__PURE__ */ new Set();
+	const headerEnv = createHeaderEnvCollector();
 	for (let index = 0; index < argv.length; index++) {
 		const item = argv[index];
 		if (item === void 0) continue;
+		/**
+		* `--` 뒤는 전부 서버를 띄울 명령이다. npm · cargo · docker 가 쓰는 관례다(#242).
+		* 첫 토큰이 실행 파일, 나머지가 그 인자다. **뒤에 오는 것을 해석하지 않으므로**
+		* `--arg` 가 값 검사에 두던 특수분기가 이 경로에는 필요 없다.
+		*/
+		if (item === "--") {
+			if (values.has("--command")) throw new UsageError$1("`--command` 와 `--` 를 함께 쓸 수 없습니다.\n→ 둘 다 서버를 띄울 명령을 정하므로 대상이 둘이 됩니다.\n→ `--` 뒤에는 실행 파일과 인자를 그대로 적습니다.");
+			if (args.length > 0) throw new UsageError$1("`--arg` 와 `--` 를 함께 쓸 수 없습니다.\n→ `--arg` 로 준 값이 `--` 뒤의 인자 앞에 끼어듭니다.\n→ `--` 를 쓰면 인자도 그 뒤에 모두 적습니다.");
+			const rest = argv.slice(index + 1);
+			const executable = rest[0];
+			if (executable === void 0 || executable === "") throw new UsageError$1("`--` 뒤에 실행할 명령이 없습니다.\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$1(`추가 위치 인자 '${item}'는 허용되지 않습니다.`);
+		if (removedGenerateOptions.has(option)) throw new UsageError$1(removedGenerateOptionMessage(option));
 		if (!optionNames$1.has(option)) throw new UsageError$1(`지원하지 않는 generate 옵션 '${option}'입니다.`);
 		if (flagNames$1.has(option)) {
 			if (item !== option || flags.has(option)) throw new UsageError$1(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
@@ -1575,15 +1836,36 @@ function parseGenerateCommand(argv) {
 			args.push(value);
 			continue;
 		}
+		if (option === "--header-env") {
+			const parsed = parseHeaderEnvOption(value);
+			if (!parsed.ok) throw new UsageError$1(parsed.message);
+			const rejected = headerEnv.add(parsed.value.header, parsed.value.envName);
+			if (rejected !== void 0) throw new UsageError$1(rejected);
+			continue;
+		}
 		if (values.has(option)) throw new UsageError$1(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
 		values.set(option, value);
 	}
-	for (const option of [
-		"--suite-id",
-		"--name",
-		"--out",
-		"--command"
-	]) if (values.get(option) === void 0) throw new UsageError$1(`\`${option}\` 옵션이 필요합니다.`);
+	const out = values.get("--out");
+	if (out === void 0) throw new UsageError$1("`--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$1(`\`${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$1("`--command` 와 `--url` 은 함께 쓸 수 없습니다.\n→ `--command` 는 서버를 프로세스로 띄우고, `--url` 은 이미 떠 있는 원격 서버에 붙습니다.\n→ 둘 중 무엇에서 명세를 뽑을지 하나만 고르세요.");
+	if (command === void 0 && rawUrl === void 0) throw new UsageError$1("`--command` 또는 `--url` 옵션이 필요합니다.");
+	if (rawUrl !== void 0 && args.length > 0) throw new UsageError$1("`--arg` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--arg` 는 우리가 띄우는 프로세스에 넘길 인자입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
+	if (command !== void 0 && !headerEnv.isEmpty()) throw new UsageError$1("`--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$1(parsed.message);
+		return parsed.value;
+	})();
 	const outPath = values.get("--out");
 	if (!outPath.toLowerCase().endsWith(".json")) throw new UsageError$1("`--out`은 .json 파일이어야 합니다.");
 	const rawProvider = values.get("--provider");
@@ -1592,24 +1874,26 @@ function parseGenerateCommand(argv) {
 	const dryRun = !flags.has("--no-dry-run");
 	const repair = !flags.has("--no-repair");
 	if (!dryRun && !repair) throw new UsageError$1("`--no-dry-run`과 `--no-repair`는 함께 사용할 수 없습니다.");
-	const cassettePath = values.get("--cassette");
 	const resetCmd = values.get("--reset-cmd");
-	if (!dryRun && cassettePath !== void 0) throw new UsageError$1("`--no-dry-run`과 `--cassette`는 함께 사용할 수 없습니다.");
 	if (!dryRun && resetCmd !== void 0) throw new UsageError$1("`--no-dry-run`과 `--reset-cmd`는 함께 사용할 수 없습니다.");
-	if (flags.has("--record") && cassettePath === void 0) throw new UsageError$1("`--record`는 `--cassette`와 함께만 사용할 수 있습니다.");
 	if (resetCmd !== void 0 && resetCmd.trim() === "") throw new UsageError$1("`--reset-cmd` 옵션 값이 필요합니다.");
 	return Object.freeze({
 		suiteId: values.get("--suite-id"),
 		name: values.get("--name"),
 		outPath,
-		command: values.get("--command"),
-		args: Object.freeze(args),
+		target: url === void 0 ? Object.freeze({
+			transport: "stdio",
+			command,
+			args: Object.freeze(args)
+		}) : Object.freeze({
+			transport: "http",
+			url,
+			headerEnv: headerEnv.snapshot()
+		}),
 		baselineOnly: flags.has("--baseline-only"),
 		provider: rawProvider,
 		model: values.get("--model"),
 		dryRun,
-		cassettePath,
-		forceRecord: flags.has("--record"),
 		force: flags.has("--force"),
 		resetCmd,
 		repair
@@ -1679,8 +1963,12 @@ async function saveSuite(input, suite, fingerprint, deps, approvals = []) {
 	}
 }
 const defaultModel = (provider) => provider === "codex" ? "gpt-5.6-luna" : "haiku";
-function showRequest(io, preview) {
-	io.write(`Provider: ${preview.providerId}\nModel: ${preview.model}\nPayload: ${preview.byteLength} bytes\nResult limit: ${preview.maxResultBytes} bytes\nTimeout: ${preview.providerTimeoutMs}ms\nFingerprint: ${preview.fingerprint}\n전송 데이터: 사용자 요청, baseline suite, current candidate, 툴 이름·설명·inputSchema\n`);
+/**
+* 전송 승인 화면. **통로마다 보내는 것이 다르므로 목록을 받는다**(#286) — 입력값 교정은
+* 실패한 케이스의 서버 응답 원문까지 싣는데, 기본 문구로 덮으면 화면이 사실보다 적게 말한다.
+*/
+function showRequest(io, preview, data = "사용자 요청, baseline suite, current candidate, 툴 이름·설명·inputSchema") {
+	io.write(`Provider: ${preview.providerId}\nModel: ${preview.model}\nPayload: ${preview.byteLength} bytes\nResult limit: ${preview.maxResultBytes} bytes\nTimeout: ${preview.providerTimeoutMs}ms\nFingerprint: ${preview.fingerprint}\n전송 데이터: ${data}\n`);
 }
 const MAX_DIFF_BODY_LINES = 40;
 /**
@@ -1727,6 +2015,35 @@ function diffBody(change) {
 		default: return changedLeaves(change.before, change.after);
 	}
 }
+/** `show` 의 입력 JSON 한 줄 상한. 넘으면 자른다. 전체는 저장 후 파일에서 본다. */
+const MAX_SHOW_INPUT_CHARS = 80;
+/**
+* 검토 메뉴 `show`. 지금 승인된 명세를 케이스당 한 줄로 요약한다. 검토 메뉴는 diff(바뀐 값)만
+* 보여 주므로 AI 가 만든 케이스가 무엇인지 저장 전에는 볼 곳이 없었다. 전문 JSON 은 케이스
+* 8건이면 100줄이 넘어 로그를 덮는다. 한 줄 요약이 화면에 맞는다.
+*/
+function renderSuiteSummary(options) {
+	const { suite } = options;
+	const width = String(suite.cases.length).length;
+	const lines = suite.cases.map((testCase, index) => {
+		const number = String(index + 1).padStart(width, " ");
+		const operation = testCase.operation.type === "listTools" ? "listTools" : `callTool ${testCase.operation.tool} ${truncate(JSON.stringify(testCase.operation.input), MAX_SHOW_INPUT_CHARS)}`;
+		const assertions = testCase.assertions.map((assertion) => assertion.type === "toolExists" ? `toolExists ${assertion.tool}` : assertion.type === "isError" ? `isError=${assertion.expected}` : assertion.type).join(", ");
+		return `  ${number}. ${testCase.id}  ${operation}  → ${assertions}`;
+	});
+	const header = `현재 명세: ${suite.name} (id ${suite.id}) · 케이스 ${suite.cases.length}건 · revision ${options.revision}`;
+	const footer = `저장하면 이 내용이 ${options.outPath} 에 쓰입니다.`;
+	const pending = options.pendingCandidate ? "  → 미반영 AI 후보가 있습니다. 위 목록에는 안 들어 있습니다. apply-all 또는 select 로 반영하세요." : "";
+	return `${[
+		header,
+		...lines,
+		footer,
+		...pending === "" ? [] : [pending]
+	].map(escapeTerminalText$2).join("\n")}\n`;
+}
+function truncate(text, max) {
+	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
 function showDiff(io, preview) {
 	if (preview.changes.length === 0) {
 		io.write("AI가 제안한 변경이 없습니다.\n  → 원하는 케이스를 `AI 요청:`에 구체적으로 적어 다시 물어보세요.\n  → 지금 상태로 저장하려면 save를 고르세요.\n");
@@ -1822,6 +2139,7 @@ function exitMessage(failure, model) {
 		case "rateLimited": return `오류 [GENERATE_PROVIDER_RATE_LIMIT]: ${id}가 요청 한도를 초과했습니다.\n해결: 잠시 뒤 다시 요청하세요. 반복되면 도구 수를 줄여 payload를 줄이세요.\n`;
 		case "badRequest": return `오류 [GENERATE_PROVIDER_REQUEST]: ${id}가 요청을 거절했습니다. 모델: ${model}\n해결: 두 가지를 확인하세요.\n  1. 모델 이름이 이 계정에서 쓸 수 있는지. ${id} 기본값은 ${fallback}입니다.\n  2. provider가 전송 schema를 받아들이는지. 반복되면 다른 provider로 시도하세요.\n`;
 		case "serverError": return `오류 [GENERATE_PROVIDER_SERVER]: ${id} 쪽 서버 오류입니다.\n해결: 잠시 뒤 다시 요청하세요. 계속되면 provider 상태 페이지를 확인하세요.\n`;
+		case "unknownOption": return `오류 [GENERATE_PROVIDER_OPTION]: 설치된 ${id}가 우리가 넘긴 옵션을 모릅니다.${failure.option === void 0 ? "" : ` 옵션: ${failure.option}`}\n  → 로그인도 모델도 원인이 아닙니다. CLI가 뜨기도 전에 옵션 해석에서 멈췄습니다.\n해결: \`${id} --version\` 으로 버전을 확인하고 최신 버전으로 올리세요.\n`;
 		default: return `오류 [GENERATE_PROVIDER_EXIT]: ${id}가 종료했습니다. ${failure.exitCode === void 0 ? "" : `종료 코드: ${failure.exitCode}, `}모델: ${model}\n해결: \`${authCommand(id)}\` 명령으로 로그인 상태를 확인하고, 모델 이름이 맞는지 확인하세요.\n`;
 	}
 }
@@ -1864,13 +2182,16 @@ const failureHeading = (index, caseName) => `  [${index + 1}] ${caseName}\n`;
 * 문장은 건드리지 않는다. dry-run-review.ts 의 같은 처리와 규칙이 같다.
 */
 const detailBlock = (detail) => detail === "" ? "" : `${detail.split("\n").map((line) => `  ${line}`).join("\n")}\n`;
-/** 시험 실행 고지(§8.1). 카세트와 초기화는 값이 있을 때만 줄이 나간다. */
+/** 시험 실행 고지(§8.1). 초기화는 값이 있을 때만 줄이 나간다. */
 function writeDryRunNotice(io, notice) {
 	io.write(`시험 실행: 케이스 ${notice.caseCount}개를 실제 서버에 보냅니다.\n`);
 	io.write(`  대상: ${notice.target}\n`);
-	if (notice.cassette !== void 0) io.write(`  카세트: ${notice.cassette.path} (${notice.cassette.fresh ? "신규 녹화" : "재생"})\n`);
 	if (notice.resetCmd !== void 0) io.write(`  초기화: ${notice.resetCmd}\n`);
-	if (notice.repair) io.write("  실패한 케이스는 값을 고쳐 최대 2회까지 다시 호출합니다.\n");
+	if (notice.repair) {
+		io.write("  실패한 케이스는 값을 고쳐 최대 2회까지 다시 호출합니다.\n");
+		if (notice.repairProvider !== void 0) io.write(`  값 제안에 ${notice.repairProvider} 를 씁니다 — 실패한 케이스의 명세와 서버 응답을 보냅니다.\n    전송 전에 매번 승인 화면을 보여주며, 거절하면 직접 입력합니다.
+`);
+	}
 	io.write("\n이 실행은 서버 상태를 바꿀 수 있습니다. 입력 검증이 없는 서버라면 외부 API 호출도\n그대로 나갑니다.\n");
 }
 /** 시험 실행 결과(§8.2). 0건인 종류는 찍지 않는다. */
@@ -1901,13 +2222,13 @@ function writeDryRunResult(io, result) {
 function writeRejectionUnverified(io, result) {
 	const unverified = result.outcomes.filter((outcome) => outcome.rejectionBasis === "unverified");
 	if (unverified.length === 0) return;
-	const ids = unverified.map((outcome) => escapeTerminalText$1(outcome.caseId));
+	const ids = unverified.map((outcome) => escapeTerminalText$2(outcome.caseId));
 	const column = Math.max(...ids.map((id) => Array.from(id).length));
 	io.write(`\n거절 근거 미확인 ${unverified.length}건\n`);
 	for (const [index, outcome] of unverified.entries()) {
 		const id = ids[index] ?? "";
 		const pad = " ".repeat(Math.max(0, column - Array.from(id).length));
-		const body = outcome.rejectionBody === void 0 ? "(본문 없음)" : escapeTerminalText$1(outcome.rejectionBody);
+		const body = outcome.rejectionBody === void 0 ? "(본문 없음)" : escapeTerminalText$2(outcome.rejectionBody);
 		io.write(`  → ${id}${pad}   응답: ${body}\n`);
 	}
 	io.write("  이 응답이 서버의 정상 거절인지 내부 오류인지 확인하지 못했습니다.\n\n");
@@ -1928,13 +2249,13 @@ const VERDICT_LABEL = {
 */
 function writeRejectionDiagnosis(io, requested, results) {
 	io.write(`\n거절 근거 미확인 ${requested}건에 대해 AI 진단을 요청했습니다.\n\n`);
-	const ids = results.map((item) => escapeTerminalText$1(item.caseId));
+	const ids = results.map((item) => escapeTerminalText$2(item.caseId));
 	const column = Math.max(0, ...ids.map((id) => Array.from(id).length));
 	for (const [index, item] of results.entries()) {
 		const id = ids[index] ?? "";
 		const pad = " ".repeat(Math.max(0, column - Array.from(id).length));
 		io.write(`  ${id}${pad}   ${VERDICT_LABEL[item.verdict]}\n`);
-		io.write(`    → ${escapeTerminalText$1(item.reason)}\n`);
+		io.write(`    → ${escapeTerminalText$2(item.reason)}\n`);
 	}
 	io.write("\n이 진단은 참고입니다. 케이스 판정과 저장 여부를 바꾸지 않습니다.\n\n");
 }
@@ -2066,31 +2387,28 @@ function writeDryRunAborted(io, result, totalCases, diagnostics) {
 	const progress = `${result.outcomes.length}/${totalCases}`;
 	io.write(aborted.reason === "connectionLost" ? `✗ 시험 실행을 마치지 못했습니다. ${progress} 케이스에서 연결이 끊겼습니다.\n` : aborted.reason === "stopped" ? `✗ 시험 실행을 마치지 못했습니다. ${progress} 케이스에서 멈췄습니다.\n` : "✗ 시험 실행을 마치지 못했습니다.\n");
 	io.write(`  → ${aborted.detail}\n`);
-	if (diagnostics !== void 0 && hasDiagnosticContent(diagnostics)) {
-		const block = renderProcessDiagnostics(diagnostics, { maxLines: DRY_RUN_STDERR_LINES });
+	const local = processDiagnostics(diagnostics);
+	if (local !== void 0 && hasDiagnosticContent(local)) {
+		const block = renderProcessDiagnostics(local, { maxLines: DRY_RUN_STDERR_LINES });
 		if (block !== "") io.write(`\n${block}`);
 	}
+	/**
+	* 원격 대상. 내용 판정을 걸지 않는다 — 이 함수는 위에서 `aborted === undefined` 면 이미
+	* 돌아갔으므로 **중단된 실행에서만** 여기 닿는다. 그 자리에서는 상태 코드가 없어도 어느
+	* 엔드포인트에서 끊겼는지가 정보다. `test` 의 연결 실패 경로와 같은 규칙이다.
+	*/
+	const remote = httpDiagnostics(diagnostics);
+	if (remote !== void 0) io.write(`\n${renderHttpDiagnostics(remote)}`);
 	io.write("\n저장하지 않았습니다. 서버를 고친 뒤 다시 save 를 고르세요.\n");
 }
-/**
-* 분류가 저장을 막았을 때의 안내(§8.3). 마지막 줄은 **실제 카세트 모드**로 갈린다.
-*
-* 재생은 `auto` 에서만 일어난다. 신규 녹화(`record`)는 회차마다 전량을 다시 서버로 보내므로
-* "나머지는 카세트에서 재생됩니다" 가 거짓이 된다. 그래서 경로 유무가 아니라 `wireCassette`
-* 가 정한 모드를 받는다.
-*/
-function writeReviewBlocked(io, specErrors, caseCount, cassetteMode) {
+/** 분류가 저장을 막았을 때의 안내(§8.3). */
+function writeReviewBlocked(io, specErrors, caseCount) {
 	io.write("\n");
 	if (specErrors > 0) {
 		io.write(`  명세 오류 ${specErrors}건이 있어 저장할 수 없습니다.\n`);
 		io.write("  → 검토 메뉴의 revise 또는 edit 으로 고친 뒤 다시 save 를 고르세요.\n");
 	} else io.write("  분류하지 않은 케이스가 있어 저장할 수 없습니다.\n");
-	if (cassetteMode === "auto") {
-		io.write("  → 고친 케이스만 서버에 다시 나갑니다. 나머지는 카세트에서 재생됩니다.\n");
-		return;
-	}
 	io.write(`  → 다시 save 를 고르면 케이스 ${caseCount}개가 모두 서버에 다시 나갑니다.\n`);
-	io.write(cassetteMode === void 0 ? "    반복 비용이 부담되면 --cassette 를 쓰세요.\n" : "    신규 녹화 중이라 이번 세션에서는 재생하지 않습니다.\n");
 }
 /** 초기화 명령 실패 안내. stderr 은 마지막 3줄만 보여준다. 설계 문서 §6. */
 function writeResetFailure(io, error) {
@@ -2114,14 +2432,11 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 	let preferred = input.provider;
 	let model = input.model;
 	/**
-	* 카세트 배선은 검토 세션에 하나뿐이고 `save` 를 여러 번 골라도 같은 것을 쓴다. 시도마다 새로
-	* 만들면 저장이 막힌 첫 시도의 녹화가 통째로 버려지고, "고친 케이스만 서버에 다시 나갑니다"
-	* (§8.3)가 거짓이 된다. flush 는 저장에 성공한 뒤 한 번만 부른다.
+	* 진단 읽기가 판정을 바꾸면 안 된다. getDiagnostics 가 던지면 삼킨다.
+	*
+	* 좁히지 않고 원값을 넘긴다. 여기서 `processDiagnostics` 로 좁히면 원격 대상의 진단이
+	* 버려져, 시험 실행이 중단됐을 때 엔드포인트도 상태 코드도 화면에 닿지 못한다(#137).
 	*/
-	let cassette;
-	/** 이미 화면에 낸 카세트 경고 수. 배선이 세션당 하나라 경고도 누적된다. 회차마다 새것만 낸다. */
-	let printedWarnings = 0;
-	/** 진단 읽기가 판정을 바꾸면 안 된다. getDiagnostics 가 던지면 삼킨다. */
 	const diagnostics = () => {
 		try {
 			return connection.getDiagnostics();
@@ -2132,6 +2447,7 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 	try {
 		while (true) {
 			const action = await io.choose("검토 메뉴", [
+				"show",
 				"codex",
 				"claude",
 				"apply-all",
@@ -2142,6 +2458,18 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 				"cancel"
 			]);
 			if (action === "cancel") return 0;
+			if (action === "show") {
+				io.write(renderSuiteSummary({
+					suite: session.approvedDraft.suite,
+					revision: session.approvedDraft.revision,
+					outPath: input.outPath,
+					pendingCandidate: candidate !== void 0 && makeDiff({
+						session,
+						candidate
+					}).changes.length > 0
+				}));
+				continue;
+			}
 			if (action === "save") {
 				const dryRunSuite = session.approvedDraft.suite;
 				const caseCount = dryRunSuite.cases.length;
@@ -2154,16 +2482,13 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 `);
 					if (!await io.confirm("   계속할까요?")) continue;
 				} else {
-					const path = input.cassettePath;
+					const repairProvider = preferred === void 0 ? void 0 : deps.providers?.[preferred]?.(model ?? defaultModel(preferred));
 					writeDryRunNotice(io, {
 						caseCount,
-						target: [input.command, ...input.args].join(" "),
-						...path === void 0 ? {} : { cassette: {
-							path,
-							fresh: cassette === void 0 ? input.forceRecord || !await deps.exists(path) : cassette.mode === "record"
-						} },
+						target: describeTarget(input.target),
 						resetCmd: input.resetCmd,
-						repair: input.repair
+						repair: input.repair,
+						repairProvider: repairProvider === void 0 ? void 0 : `${repairProvider.id}(${repairProvider.model ?? ""})`
 					});
 					if (!await io.confirm("계속할까요?")) continue;
 					if (input.resetCmd !== void 0) {
@@ -2176,19 +2501,11 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 						}
 						io.write(`▸ 초기화: ${input.resetCmd}\n`);
 					}
-					if (cassette === void 0) cassette = await wireCassette({
-						inner: connection.client,
-						path: input.cassettePath,
-						forceRecord: input.forceRecord,
-						io: deps.cassetteIo
-					});
 					io.write(`▸ 시험 실행 중... ${caseCount}/${caseCount}\n`);
 					const result = await runDryRun({
-						client: cassette.client,
+						client: connection.client,
 						suite: dryRunSuite
 					});
-					for (const warning of cassette.warnings.slice(printedWarnings)) io.write(`${warning}\n`);
-					printedWarnings = cassette.warnings.length;
 					if (result.aborted !== void 0) {
 						writeDryRunAborted(io, result, caseCount, diagnostics());
 						continue;
@@ -2204,8 +2521,6 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 						provider: preferred === void 0 ? void 0 : deps.rejectionProviders?.[preferred]?.(model ?? defaultModel(preferred)),
 						model: model ?? (preferred === void 0 ? "" : defaultModel(preferred))
 					});
-					const repairProvider = preferred === void 0 ? void 0 : deps.providers?.[preferred]?.(model ?? defaultModel(preferred));
-					const wired = cassette;
 					const targets = input.repair ? selectRepairTargets({
 						suite: dryRunSuite,
 						outcomes: result.outcomes,
@@ -2219,6 +2534,7 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 							suite: dryRunSuite,
 							targets,
 							tools,
+							proposedBy: repairProvider === void 0 ? void 0 : `${repairProvider.id}(${repairProvider.model ?? ""})`,
 							rerun: async (caseId, value) => {
 								const spec = dryRunSuite.cases.find((item) => item.id === caseId);
 								if (spec === void 0 || !isCallTool(spec)) return {
@@ -2226,7 +2542,7 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 									detail: ""
 								};
 								const one = await runDryRun({
-									client: wired.client,
+									client: connection.client,
 									suite: {
 										...dryRunSuite,
 										cases: [{
@@ -2254,7 +2570,11 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 								tools,
 								provider: repairProvider,
 								prepare,
-								dispatch
+								dispatch,
+								confirm: async (preview) => {
+									showRequest(io, preview, "실패한 케이스의 명세와 서버 응답 원문, baseline suite, current candidate, 툴 이름·설명·inputSchema");
+									return await io.confirm("이 요청을 전송할까요?");
+								}
 							})
 						});
 						const repaired = new Map(repairs.filter((item) => item.repaired && item.input !== void 0).map((item) => [item.caseId, item.input]));
@@ -2297,11 +2617,9 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 							} : outcome)
 						};
 					}
-					for (const warning of cassette.warnings.slice(printedWarnings)) io.write(`${warning}\n`);
-					printedWarnings = cassette.warnings.length;
 					const review = await reviewDryRun(io, effective, attempts);
 					if (!review.cleared) {
-						writeReviewBlocked(io, review.specErrors.length, caseCount, cassette.mode);
+						writeReviewBlocked(io, review.specErrors.length, caseCount);
 						continue;
 					}
 					approvals = review.approvals;
@@ -2324,17 +2642,6 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 				try {
 					const finalSuite = deps.getAuthoringExecutionSuite(final.snapshot);
 					await saveSuite(input, finalSuite, final.snapshot.fingerprint, deps, approvals);
-					let cassetteSaved = false;
-					try {
-						await cassette?.flush();
-						cassetteSaved = true;
-					} catch {
-						io.write("⚠ 카세트를 저장하지 못했습니다. 명세는 저장됐습니다.\n");
-					}
-					if (cassetteSaved && cassette !== void 0) {
-						for (const warning of cassette.warnings.slice(printedWarnings)) io.write(`${warning}\n`);
-						printedWarnings = cassette.warnings.length;
-					}
 					const skippedIndexes = new Set(skippedTools.map((tool) => tool.index));
 					reportCoverageSafely(deps, () => deps.computeCoverage?.({
 						suite: finalSuite,
@@ -2595,10 +2902,16 @@ function renderPreFillSummary(options) {
 /**
 * 케이스 수 고지. 임계 아래면 빈 문자열이다.
 * 생성을 막지 않는다. 이미 존재하는 상한을 사용자에게 보이게 하는 것이 목적이다.
+*
+* 임계는 케이스당 600바이트 **추정** 위에 있다(#92). 생성 시점에는 응답 크기를 모르니 개수로
+* 볼 수밖에 없고, 그래서 문안이 추정임을 밝히고 실제 판정은 `test` 실행(runner 의 `payload`
+* 고지)이 한다고 적는다. 추정을 확정처럼 적으면 응답이 작은 서버의 사용자가 경고를 무시하는
+* 법을 배운다.
 */
 function renderCaseCountNotice(caseCount) {
 	if (caseCount < CASE_COUNT_WARNING_THRESHOLD) return "";
-	return `→ 케이스 ${caseCount}개를 만들었습니다. runner 보고서 상한(1MB)에 가까워 test 실행이\n  RunnerPayloadLimitError 로 실패할 수 있습니다.
+	return `→ 케이스 ${caseCount}개를 만들었습니다. runner 보고서 상한(1MB)에 가까워 test 실행이\n  RunnerPayloadLimitError 로 실패할 수 있습니다. 케이스당 600바이트로 잡은 추정이라
+  실제 벽은 서버 응답 크기에 따라 다릅니다. test 실행이 실제 크기로 다시 알립니다.
 → 툴을 나눠 여러 명세 파일로 생성하면 피할 수 있습니다.
 `;
 }
@@ -2733,9 +3046,10 @@ async function runGenerateCommand(argv, deps) {
 	*/
 	let review;
 	try {
-		connection = await deps.connect({
-			command: input.command,
-			args: input.args
+		connection = await openConnection(input.target, {
+			connectStdio: deps.connect,
+			...deps.connectHttp === void 0 ? {} : { connectHttp: deps.connectHttp },
+			...deps.readEnv === void 0 ? {} : { readEnv: deps.readEnv }
 		});
 		const active = connection;
 		const tools = await active.client.listTools();
@@ -2789,12 +3103,29 @@ async function runGenerateCommand(argv, deps) {
 		}
 	} catch (error) {
 		if (connection !== void 0) await connection.forceClose().catch(() => void 0);
+		if (isReviewInputClosed(error)) {
+			deps.reviewIO?.close?.();
+			deps.writeStdout("입력이 종료되어 검토를 취소했습니다. 저장하지 않았습니다.\n");
+			return 0;
+		}
+		if (error instanceof ConnectTargetError) {
+			deps.writeStderr(`오류 [CLI_USAGE]: ${error.message}\n해결: ${GENERATE_USAGE_HINT}\n`);
+			return 1;
+		}
 		if (error instanceof OutputExistsError) outputExistsFailure(deps, error.path);
 		else if (error instanceof OutputReplaceError) outputReplaceFailure(deps, error.path, error.code);
 		else if (error instanceof LinkUnsupportedError) linkUnsupportedFailure(deps, error.path, error.code);
 		else if (deps.GenerateTestsError !== void 0 && error instanceof deps.GenerateTestsError) generateTestsFailure(deps, error);
-		else if (isCoreClientError(error)) deps.writeStderr(`오류 [GENERATE_CONNECT_FAILED/${error.code}]: ${error.message}\n해결: ${error.hint}\n`);
-		else deps.writeStderr("오류 [GENERATE_FAILED]: baseline suite를 생성하거나 저장하지 못했습니다.\n해결: MCP 서버와 출력 경로를 확인한 뒤 다시 실행하세요.\n");
+		else if (isCoreClientError(error)) {
+			deps.writeStderr(`오류 [GENERATE_CONNECT_FAILED/${error.code}]: ${error.message}\n해결: ${error.hint}\n`);
+			const diagnostics = processDiagnostics(error.diagnostics);
+			if (diagnostics !== void 0 && hasDiagnosticContent(diagnostics)) {
+				const block = renderProcessDiagnostics(diagnostics, { maxLines: DRY_RUN_STDERR_LINES });
+				if (block !== "") deps.writeStderr(`\n${block}`);
+			}
+			const remote = httpDiagnostics(error.diagnostics);
+			if (remote !== void 0) deps.writeStderr(`\n${renderHttpDiagnostics(remote)}`);
+		} else deps.writeStderr("오류 [GENERATE_FAILED]: baseline suite를 생성하거나 저장하지 못했습니다.\n해결: MCP 서버와 출력 경로를 확인한 뒤 다시 실행하세요.\n");
 		return 1;
 	}
 	try {
@@ -2914,12 +3245,12 @@ function shouldShowSpecApproval(result, allPassed) {
 	return allPassed ? result.state === "mismatched" : true;
 }
 /** 반환은 개행으로 끝난다. 호출자가 앞에 빈 줄을 붙인다. 설계 문서 §7.2. */
-function renderSpecApproval(result) {
+function renderSpecApproval(result, allPassed) {
 	if (result.state === "matched") return `명세: 승인 시점과 동일 (${short(result.fingerprint)})\n`;
 	if (result.state === "absent") return "명세: 승인 지문이 없습니다 (미고정)\n  → mcpeak generate 로 승인한 명세가 아니거나 승인 이전 버전으로 만든 파일입니다.\n";
-	return `명세: 승인 시점 이후 변경됨
-  → 승인 ${short(result.approvedFingerprint ?? "")}   현재 ${short(result.fingerprint)}\n  → 실패 원인에서 명세 변경을 배제할 수 없습니다. 명세 diff 를 먼저 확인하세요.
-`;
+	const outcome = allPassed ? "  → 승인받지 않은 현재 명세로 모든 테스트가 통과했습니다.\n" : "  → 실패 원인에서 명세 변경을 배제할 수 없습니다.\n";
+	return `명세: 현재 명세와 저장된 approval.fingerprint가 불일치함
+  → 승인 ${short(result.approvedFingerprint ?? "")}   현재 ${short(result.fingerprint)}\n` + outcome + "  → 지문만으로는 변경 내용을 알 수 없습니다. 버전 관리에서 명세를 비교하세요.\n  → 의도한 변경이면 같은 설정으로 mcpeak generate 를 다시 실행하고 --force 로 재승인하세요.\n";
 }
 /** 번들에 적는 CLI 식별자. `mcpeak --version` 이 찍는 것과 같은 출처를 쓴다. */
 const REPAIR_BUNDLE_GENERATED_BY = `mcpeak ${version}`;
@@ -3188,7 +3519,7 @@ async function runRepairCommand(argv, deps) {
 	try {
 		text = await deps.readFile(input.bundlePath);
 	} catch {
-		deps.writeStderr(`오류 [REPAIR_BUNDLE_READ_FAILED]: repair 번들 파일을 읽지 못했습니다. 경로: ${escapeTerminalText$1(input.bundlePath)}\n해결: 경로와 읽기 권한을 확인하세요. 번들은 \`mcpeak test --repair-bundle <path>\` 가 만듭니다.\n`);
+		deps.writeStderr(`오류 [REPAIR_BUNDLE_READ_FAILED]: repair 번들 파일을 읽지 못했습니다. 경로: ${escapeTerminalText$2(input.bundlePath)}\n해결: 경로와 읽기 권한을 확인하세요. 번들은 \`mcpeak test --repair-bundle <path>\` 가 만듭니다.\n`);
 		return 1;
 	}
 	const read = readRepairBundle(text);
@@ -3280,330 +3611,6 @@ async function runRepairCommand(argv, deps) {
 	return 0;
 }
 //#endregion
-//#region src/replay-command.ts
-/**
-* 런타임 모듈을 못 불러 fallback 의존성이 쓰일 때 던진다.
-*
-* 타입을 따로 두는 이유는 이 실패가 **명세·카세트 문제와 구분돼야** 하기 때문이다. 그냥
-* 던지면 `validateSuite` 자리에서 `CLI_INTERNAL_ERROR` 로 잡혀 "다시 실행한 뒤 재현 정보와
-* 함께 이슈를 보고하세요" 가 나간다. 사용자는 자기 설치 문제로 버그 리포트를 쓰게 된다.
-* `repair` 가 `REPAIR_RUNTIME_UNAVAILABLE` 로 이미 가르고 있는 것과 같은 처리다.
-*/
-var ReplayRuntimeUnavailableError = class extends Error {
-	constructor() {
-		super("replay 실행에 필요한 모듈을 로드하지 못했습니다.");
-		this.name = "ReplayRuntimeUnavailableError";
-	}
-};
-/**
-* 명세 로드 실패 문안은 `test-command.ts` 의 `dictionary` 와 같은 값이다. 두 커맨드가 같은
-* 파일을 같은 이유로 거절하므로 문장이 갈리면 안 된다. 지금 복제인 것은 그 표가 module-private
-* 이기 때문이고, 공용 모듈로 빼는 것은 `test` 서브커맨드 소유자와 합의가 필요한 별도 작업이다.
-*/
-const dictionary$1 = {
-	REPLAY_RUNTIME_UNAVAILABLE: {
-		message: "replay 에 필요한 @mcpeak/runner · @mcpeak/record 를 로드하지 못했습니다.",
-		hint: "의존성을 설치한 뒤 다시 실행하세요. 명세나 카세트 파일의 문제가 아닙니다."
-	},
-	SUITE_FORMAT_UNSUPPORTED: {
-		message: "테스트 명세 형식을 지원하지 않습니다.",
-		hint: "UTF-8로 저장한 .json 명세 파일을 사용하세요."
-	},
-	SUITE_READ_FAILED: {
-		message: "테스트 명세 파일을 읽지 못했습니다.",
-		hint: "명세 경로와 읽기 권한을 확인하세요."
-	},
-	SUITE_ENCODING_INVALID: {
-		message: "테스트 명세 파일이 유효한 UTF-8이 아닙니다.",
-		hint: "명세를 UTF-8 JSON으로 다시 저장하세요."
-	},
-	SUITE_JSON_INVALID: {
-		message: "테스트 명세의 JSON 문법이 유효하지 않습니다.",
-		hint: "JSON 문법과 쉼표, 따옴표를 확인하세요."
-	},
-	SUITE_VALIDATION_FAILED: {
-		message: "MCP 테스트 명세가 유효하지 않습니다.",
-		hint: "아래 명세 오류를 모두 수정하세요."
-	},
-	CLI_INTERNAL_ERROR: {
-		message: "예상하지 못한 CLI 내부 오류가 발생했습니다.",
-		hint: "다시 실행한 뒤 재현 정보와 함께 이슈를 보고하세요."
-	},
-	CASSETTE_NOT_FOUND: {
-		message: "카세트 파일이 없습니다.",
-		hint: "`mcpeak generate --cassette <path> --record` 로 먼저 녹화하세요."
-	},
-	CASSETTE_READ_FAILED: {
-		message: "카세트를 읽지 못했습니다.",
-		hint: "카세트 파일이 손상되지 않았는지 확인하고, 필요하면 --record 로 다시 녹화하세요."
-	},
-	CASSETTE_INCOMPLETE: {
-		message: "카세트에 이 명세의 응답이 모두 들어 있지 않습니다.",
-		hint: "명세를 고쳤다면 `mcpeak generate --cassette <path> --record` 로 다시 녹화하세요."
-	},
-	RUNNER_EXECUTION_FAILED: {
-		message: "Runner 실행을 시작하지 못했습니다.",
-		hint: "테스트 명세와 카세트가 같은 서버에서 나온 것인지 확인하세요."
-	},
-	RUNNER_FINALIZATION_FAILED: {
-		message: "Runner 실행을 마치지 못했습니다.",
-		hint: "카세트에 필요한 응답이 모두 들어 있는지 확인하세요."
-	}
-};
-var ReplayCommandError = class extends Error {
-	failure;
-	constructor(failure) {
-		super(failure.message);
-		this.failure = failure;
-	}
-};
-const usage = (message) => {
-	throw new ReplayCommandError({
-		code: "CLI_USAGE",
-		message,
-		hint: REPLAY_USAGE_HINT
-	});
-};
-/** replay 에서 의미가 없는 옵션. 조용히 무시하지 않고 거절한다. ADR-0028. */
-const SERVER_ONLY_OPTIONS = /* @__PURE__ */ new Set([
-	"--command",
-	"--arg",
-	"--stderr-lines"
-]);
-function parseReplayCommand(argv) {
-	let suitePath;
-	let cassettePath;
-	for (let index = 0; index < argv.length; index++) {
-		const token = argv[index] ?? "";
-		const [name] = token.startsWith("--") ? token.split("=", 1) : [token];
-		if (SERVER_ONLY_OPTIONS.has(name ?? "")) usage(`replay 는 서버를 띄우지 않습니다. ${name} 는 test 명령에서 쓰세요.`);
-		if (token === "--cassette" || token.startsWith("--cassette=")) {
-			const value = token.startsWith("--cassette=") ? token.slice(11) : argv[++index];
-			if (value === void 0 || value === "") usage("--cassette 에 카세트 파일 경로가 필요합니다.");
-			cassettePath = value;
-			continue;
-		}
-		if (token.startsWith("--")) usage(`알 수 없는 옵션입니다: ${token}`);
-		if (suitePath !== void 0) usage(`테스트 명세는 하나만 받습니다: ${token}`);
-		suitePath = token;
-	}
-	if (suitePath === void 0 || suitePath === "") usage("테스트 명세 JSON 경로가 필요합니다.");
-	if (cassettePath === void 0) usage("--cassette 에 재생할 카세트 파일 경로가 필요합니다.");
-	return Object.freeze({
-		suitePath,
-		cassettePath
-	});
-}
-/**
-* 실서버 자리를 채우는 오프라인 클라이언트. replay 모드의 `cassetteClient` 는 `listTools` 와
-* `callTool` 을 가로채므로 이 둘은 도달 불가다. 조용히 빈 값을 돌려주면 모드가 새어도 화면이
-* 정상처럼 보이므로 던진다. ADR-0028.
-*/
-const offlineClient = {
-	async listTools() {
-		throw new Error("replay 는 MCP 서버를 호출하지 않습니다.");
-	},
-	async callTool() {
-		throw new Error("replay 는 MCP 서버를 호출하지 않습니다.");
-	},
-	async close() {}
-};
-/**
-* 카세트가 이 명세를 덮는지 실행 전에 확인한다.
-*
-* 재생 중에 나는 미스는 `record` 가 어느 필드가 다른지까지 적어 주지만, 그 문장이 화면까지
-* 오지 못한다. `runner` 가 호출 실패를 `OPERATION_FAILED` 로 감싸면서 "MCP 서버 프로세스와
-* 연결 상태를 확인하세요" 로 바꾸기 때문이다. replay 에는 확인할 서버가 없으므로 그 안내는
-* 사용자를 없는 곳으로 보낸다. 그래서 시작 전에 우리가 말한다.
-*/
-function missingFromCassette(suite, cassette) {
-	const keys = new Set(cassette.interactions.map((interaction) => interaction.key));
-	const missing = [];
-	for (const testCase of suite.cases) {
-		if (testCase.operation.type === "listTools") {
-			if (cassette.tools === void 0) missing.push(`${testCase.id}: listTools 응답`);
-			continue;
-		}
-		const { tool, input } = testCase.operation;
-		if (!keys.has(matchKey(tool, input))) missing.push(`${testCase.id}: ${tool}(${JSON.stringify(input)})`);
-	}
-	return missing;
-}
-/** 경고 한 줄이 화면을 덮지 않도록 상한을 둔다. */
-const MAX_REDACTED_PATHS = 5;
-/**
-* 마스킹된 값의 JSON 경로를 모은다. 판정이 읽는 자리는 `response.content` 하나이므로 거기만 본다.
-* 값이 JSON 문자열이면 그 안까지 들어간다 — 카세트가 문자열 본문도 구조화해 마스킹하기 때문이다.
-*/
-function redactedPaths(cassette) {
-	const paths = [];
-	let total = 0;
-	const add = (path) => {
-		total++;
-		if (paths.length < MAX_REDACTED_PATHS) paths.push(path);
-	};
-	const visit = (value, path) => {
-		if (typeof value === "string") {
-			if (value === REDACTED$1) add(path);
-			else if (value.includes(REDACTED$1)) try {
-				visit(JSON.parse(value), path);
-			} catch {
-				add(path);
-			}
-			return;
-		}
-		if (Array.isArray(value)) {
-			for (const [index, item] of value.entries()) visit(item, `${path}[${index}]`);
-			return;
-		}
-		if (typeof value === "object" && value !== null) for (const [key, item] of Object.entries(value)) visit(item, `${path}.${key}`);
-	};
-	for (const [index, interaction] of cassette.interactions.entries()) visit(interaction.response.content, `interactions[${index}].response.content`);
-	return {
-		paths,
-		total
-	};
-}
-const detail = (error) => error instanceof Error && error.message !== "" ? `\n${error.message}` : "";
-/** 런타임 미가용이면 그 코드를, 아니면 `undefined`. 호출부가 자기 기본 코드를 고른다. */
-const runtimeCode = (error) => error instanceof ReplayRuntimeUnavailableError ? "REPLAY_RUNTIME_UNAVAILABLE" : void 0;
-const format$1 = (failure) => {
-	const issues = (failure.issues ?? []).map((issue) => `\n- [${issue.code}] ${issue.path}: ${issue.message}`);
-	return `오류 [${failure.code}]: ${failure.message}${issues.join("")}\n해결: ${failure.hint}\n`;
-};
-const writeFailure$1 = (dependencies, failure) => {
-	dependencies.writeStderr(format$1(failure));
-	return 1;
-};
-async function runReplayCommand(argv, dependencies) {
-	let input;
-	try {
-		input = parseReplayCommand(argv);
-	} catch (error) {
-		if (error instanceof ReplayCommandError) return writeFailure$1(dependencies, error.failure);
-		throw error;
-	}
-	if (!input.suitePath.toLowerCase().endsWith(".json")) return writeFailure$1(dependencies, {
-		code: "SUITE_FORMAT_UNSUPPORTED",
-		...dictionary$1.SUITE_FORMAT_UNSUPPORTED
-	});
-	let bytes;
-	try {
-		bytes = await dependencies.readFile(input.suitePath);
-	} catch {
-		return writeFailure$1(dependencies, {
-			code: "SUITE_READ_FAILED",
-			...dictionary$1.SUITE_READ_FAILED
-		});
-	}
-	let text;
-	try {
-		text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-	} catch {
-		return writeFailure$1(dependencies, {
-			code: "SUITE_ENCODING_INVALID",
-			...dictionary$1.SUITE_ENCODING_INVALID
-		});
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch {
-		return writeFailure$1(dependencies, {
-			code: "SUITE_JSON_INVALID",
-			...dictionary$1.SUITE_JSON_INVALID
-		});
-	}
-	let validated;
-	try {
-		validated = dependencies.validateSuite(parsed);
-	} catch (error) {
-		const code = runtimeCode(error) ?? "CLI_INTERNAL_ERROR";
-		return writeFailure$1(dependencies, {
-			code,
-			...dictionary$1[code]
-		});
-	}
-	if (!validated.valid) return writeFailure$1(dependencies, {
-		code: "SUITE_VALIDATION_FAILED",
-		...dictionary$1.SUITE_VALIDATION_FAILED,
-		issues: validated.issues
-	});
-	let cassette;
-	try {
-		cassette = await dependencies.loadCassette(input.cassettePath);
-	} catch (error) {
-		const runtime = runtimeCode(error);
-		return writeFailure$1(dependencies, runtime === void 0 ? {
-			code: "CASSETTE_READ_FAILED",
-			message: `${dictionary$1.CASSETTE_READ_FAILED.message}${detail(error)}`,
-			hint: dictionary$1.CASSETTE_READ_FAILED.hint
-		} : {
-			code: runtime,
-			...dictionary$1[runtime]
-		});
-	}
-	if (cassette === null) return writeFailure$1(dependencies, {
-		code: "CASSETTE_NOT_FOUND",
-		message: `카세트 파일이 없습니다: ${input.cassettePath}`,
-		hint: dictionary$1.CASSETTE_NOT_FOUND.hint
-	});
-	const missing = missingFromCassette(validated.value, cassette);
-	if (missing.length > 0) return writeFailure$1(dependencies, {
-		code: "CASSETTE_INCOMPLETE",
-		message: [`카세트에 없는 케이스가 ${missing.length}개 있습니다: ${input.cassettePath}`, ...missing.map((item) => `  ${item}`)].join("\n"),
-		hint: dictionary$1.CASSETTE_INCOMPLETE.hint
-	});
-	/**
-	* 마스킹된 값은 판정을 바꿀 수 있다. 거부하지 않고 알린다 — 대부분의 카세트는 마스킹 대상이
-	* 없어 재생이 라이브와 정확히 일치한다. ADR-0028.
-	*/
-	const redacted = redactedPaths(cassette);
-	if (redacted.total > 0) dependencies.writeStderr([
-		"→ 카세트에 마스킹된 값이 있습니다. 이 자리의 판정은 실제 서버와 다를 수 있습니다.",
-		...redacted.paths.map((path) => `  ${path}`),
-		...redacted.total > redacted.paths.length ? [`  → 마스킹된 경로 ${redacted.total}개 중 ${redacted.paths.length}개만 표시합니다.`] : [],
-		"  → 이 케이스의 결과를 근거로 쓰기 전에 test 명령으로 한 번 확인하세요.",
-		""
-	].join("\n"));
-	const client = cassetteClient(offlineClient, {
-		cassette,
-		mode: "replay",
-		cassettePath: input.cassettePath
-	});
-	let execution;
-	try {
-		execution = dependencies.startRunner({
-			client,
-			suite: validated.value
-		});
-	} catch {
-		return writeFailure$1(dependencies, {
-			code: "RUNNER_EXECUTION_FAILED",
-			...dictionary$1.RUNNER_EXECUTION_FAILED
-		});
-	}
-	let report;
-	try {
-		report = await dependencies.finalize({
-			execution,
-			shutdown: {
-				client,
-				close: () => client.close(),
-				forceClose: () => client.close()
-			}
-		});
-	} catch (error) {
-		return writeFailure$1(dependencies, {
-			code: "RUNNER_FINALIZATION_FAILED",
-			message: `${dictionary$1.RUNNER_FINALIZATION_FAILED.message}${detail(error)}`,
-			hint: dictionary$1.RUNNER_FINALIZATION_FAILED.hint
-		});
-	}
-	dependencies.writeStdout(dependencies.renderReport(report, { color: dependencies.colorEnabled }));
-	return report.status === "passed" ? 0 : 1;
-}
-//#endregion
 //#region src/determinism-capture.ts
 /**
 * 관찰용 평문 사본. `checkDeterminism` 은 `canonicalJson` 으로 비교하는데 그것은 undefined
@@ -3689,6 +3696,68 @@ function createDeterminismCapture(inner) {
 	};
 }
 //#endregion
+//#region src/external-wiring.ts
+/**
+* `@mcpeak/record/external` 은 **세션 옵션을 실제로 쓸 때만** 불러온다.
+*
+* 정적 import 로 두면 `node:sqlite` 가 CLI 를 띄우는 것만으로 로드되고, Node 22.x 는 그때
+* `ExperimentalWarning: SQLite is an experimental feature` 를 stderr 에 찍는다. 세션을 쓰지도
+* 않은 `mcpeak test` 실행마다 그 줄이 붙는다 — 터미널 출력이 곧 UI 인 도구에서 그냥 손해다.
+* (실제로 `dist-cli-e2e` 의 "stderr 가 비어 있다" 단언이 이걸 잡았다.)
+*
+* 지연 로딩이면 경고를 보는 사람은 External 을 직접 켠 사용자뿐이다. 그 경고를 아예 지울지는
+* ADR-0054 가 남겨 둔 별도 결정이며, 라이브러리가 아니라 CLI 가 정할 몫이다.
+*/
+const loadExternal = () => import("@mcpeak/record/external");
+/** 세션 파일 하나가 세션 하나이므로 식별자를 사용자에게 묻지 않는다. */
+const SESSION_ID = "default";
+/**
+* 재생할 세션 파일이 없을 때. **Store 를 열기 전에 던진다** — `node:sqlite` 의 `DatabaseSync`
+* 는 없는 경로를 만들어 버리므로, 열고 나서 판정하면 오타 한 번에 빈 DB 가 디스크에 남는다.
+* 그러면 두 번째 실행부터는 "파일이 없다" 가 거짓이 되어 진단이 또 어긋난다(#260).
+*/
+var SessionFileMissingError = class extends Error {
+	path;
+	name = "SessionFileMissingError";
+	constructor(path) {
+		super(`세션 파일이 없습니다: ${path}`);
+		this.path = path;
+	}
+};
+async function startExternalWiring(options) {
+	if (options.mode === "replay" && !existsSync(options.sessionPath)) throw new SessionFileMissingError(options.sessionPath);
+	const { createSqliteSessionStore, startExternalCoordinator } = await loadExternal();
+	const store = createSqliteSessionStore({
+		path: options.sessionPath,
+		readOnly: options.mode === "replay"
+	});
+	let handle;
+	try {
+		handle = options.mode === "record" ? await startExternalCoordinator({
+			mode: "record",
+			sessionId: SESSION_ID,
+			store,
+			...options.existingNodeOptions === void 0 ? {} : { existingNodeOptions: options.existingNodeOptions }
+		}) : await startExternalCoordinator({
+			mode: "replay",
+			sourceSessionId: SESSION_ID,
+			store,
+			...options.existingNodeOptions === void 0 ? {} : { existingNodeOptions: options.existingNodeOptions }
+		});
+	} catch (error) {
+		store.close();
+		throw error;
+	}
+	let settled;
+	return {
+		env: handle.childEnvironment,
+		finish(status) {
+			settled ??= handle.finish(status).finally(() => store.close());
+			return settled;
+		}
+	};
+}
+//#endregion
 //#region src/test-command.ts
 /** --stderr-lines 기본값. 설계 문서 §6. */
 const DEFAULT_STDERR_LINES = 20;
@@ -3725,6 +3794,11 @@ const dictionary = {
 		message: "Runner 실행 또는 MCP 서버 종료에 실패했습니다.",
 		hint: "서버 응답과 종료 상태를 확인하세요."
 	},
+	/** 문장은 `payloadLimitFailure` 가 실제 크기로 만든다. 여기는 타입을 채우는 자리다. */
+	RUNNER_PAYLOAD_LIMIT_EXCEEDED: {
+		message: "보고서 또는 케이스가 runner 상한을 넘었습니다.",
+		hint: "케이스나 응답의 크기를 줄이세요."
+	},
 	JUNIT_WRITE_FAILED: {
 		message: "JUnit XML 파일을 쓰지 못했습니다.",
 		hint: "`--junit` 경로의 디렉터리가 존재하는지와 쓰기 권한을 확인하세요."
@@ -3737,6 +3811,10 @@ const dictionary = {
 		message: "초기화 명령이 실패했습니다.",
 		hint: "`--reset-cmd` 명령이 단독으로 성공하는지 확인한 뒤 다시 실행하세요."
 	},
+	EXTERNAL_SESSION_FAILED: {
+		message: "External 세션 처리에 실패했습니다.",
+		hint: "세션 파일 경로의 디렉터리가 있는지와 쓰기 권한을 확인하세요."
+	},
 	CLI_INTERNAL_ERROR: {
 		message: "예상하지 못한 CLI 내부 오류가 발생했습니다.",
 		hint: "다시 실행한 뒤 재현 정보와 함께 이슈를 보고하세요."
@@ -3756,19 +3834,66 @@ const fail = (message) => {
 		hint: TEST_USAGE_HINT
 	});
 };
+/**
+* `--name value` 와 `--name=value` 두 형태에서 값을 꺼낸다.
+*
+* 값이 `--` 로 시작하면 거절한다. `--session --json` 처럼 값을 빠뜨리면 다음 옵션이 경로로
+* 먹히고, 그러면 "그런 파일이 없습니다" 라는 엉뚱한 곳에서 실패한다.
+*/
+const readOptionValue = (argv, token, name, index) => {
+	let value;
+	let next = index;
+	if (token === name) {
+		const candidate = argv[++next];
+		if (candidate === void 0) throw new CliCommandError({
+			code: "CLI_USAGE",
+			message: `\`${name}\` 옵션 값이 필요합니다.`,
+			hint: TEST_USAGE_HINT
+		});
+		value = candidate;
+	} else value = token.slice(`${name}=`.length);
+	if (value.trim() === "" || value.startsWith("--")) fail(`\`${name}\` 옵션 값이 필요합니다.`);
+	return {
+		value,
+		index: next
+	};
+};
 function parseTestCommand(argv) {
 	const suitePath = argv[0] ?? "";
 	if (suitePath === "") fail("테스트 명세 JSON 경로가 필요합니다.");
 	let command;
+	let url;
 	let json = false;
 	let junitPath;
 	let repairBundlePath;
 	let determinism = false;
 	let resetCmd;
 	let stderrLines;
+	let sessionPath;
+	let recordSessionPath;
 	const args = [];
+	const headerEnv = createHeaderEnvCollector();
 	for (let index = 1; index < argv.length; index += 1) {
 		const token = argv[index] ?? "";
+		/**
+		* `--` 뒤는 전부 서버를 띄울 명령이다. npm · cargo · docker 가 쓰는 관례라 설명이
+		* 필요 없고, 무엇보다 **뒤에 오는 것을 우리가 해석하지 않는다** — `--arg --port` 처럼
+		* 옵션처럼 생긴 값에 특수분기를 두지 않아도 된다(#242).
+		*
+		* 첫 토큰이 실행 파일, 나머지가 그 인자다. `--command` 와 함께 쓸 수 없다 — 대상이
+		* 둘이 되면 어느 쪽을 띄울지 화면이 말할 수 없다.
+		*/
+		if (token === "--") {
+			if (command !== void 0) fail("`--command` 와 `--` 를 함께 쓸 수 없습니다.\n→ 둘 다 서버를 띄울 명령을 정하므로 대상이 둘이 됩니다.\n→ `--` 뒤에는 실행 파일과 인자를 그대로 적습니다.");
+			if (args.length > 0) fail("`--arg` 와 `--` 를 함께 쓸 수 없습니다.\n→ `--arg` 로 준 값이 `--` 뒤의 인자 앞에 끼어듭니다.\n→ `--` 를 쓰면 인자도 그 뒤에 모두 적습니다.");
+			const rest = argv.slice(index + 1);
+			const executable = rest[0];
+			if (executable === void 0 || executable === "") fail("`--` 뒤에 실행할 명령이 없습니다.\n→ `-- <executable> [args...]` 처럼 첫 토큰에 실행 파일을 적으세요.");
+			command = executable;
+			args.push(...rest.slice(1));
+			index = argv.length;
+			continue;
+		}
 		if (token === "--command" || token.startsWith("--command=")) {
 			if (command !== void 0) fail("`--command`는 한 번만 사용할 수 있습니다.");
 			let value;
@@ -3784,6 +3909,22 @@ function parseTestCommand(argv) {
 			if (value === "") fail("`--command` 옵션 값이 필요합니다.");
 			if (value.startsWith("--")) fail("`--command` 옵션 값이 필요합니다.");
 			command = value;
+		} else if (token === "--url" || token.startsWith("--url=")) {
+			if (url !== void 0) fail("`--url`은 한 번만 사용할 수 있습니다.");
+			const read = readOptionValue(argv, token, "--url", index);
+			index = read.index;
+			const parsed = parseUrlOption(read.value);
+			if (!parsed.ok) fail(parsed.message);
+			else url = parsed.value;
+		} else if (token === "--header-env" || token.startsWith("--header-env=")) {
+			const read = readOptionValue(argv, token, "--header-env", index);
+			index = read.index;
+			const parsed = parseHeaderEnvOption(read.value);
+			if (!parsed.ok) fail(parsed.message);
+			else {
+				const rejected = headerEnv.add(parsed.value.header, parsed.value.envName);
+				if (rejected !== void 0) fail(rejected);
+			}
 		} else if (token === "--arg" || token.startsWith("--arg=")) {
 			let value;
 			if (token === "--arg") {
@@ -3859,27 +4000,53 @@ function parseTestCommand(argv) {
 			const parsedLines = Number.parseInt(value, 10);
 			if (!Number.isSafeInteger(parsedLines)) fail("`--stderr-lines` 값은 0 이상의 정수여야 합니다.");
 			stderrLines = parsedLines;
+		} else if (token === "--session" || token.startsWith("--session=")) {
+			if (sessionPath !== void 0) fail("`--session`은 한 번만 사용할 수 있습니다.");
+			const read = readOptionValue(argv, token, "--session", index);
+			sessionPath = read.value;
+			index = read.index;
+		} else if (token === "--record-session" || token.startsWith("--record-session=")) {
+			if (recordSessionPath !== void 0) fail("`--record-session`은 한 번만 사용할 수 있습니다.");
+			const read = readOptionValue(argv, token, "--record-session", index);
+			recordSessionPath = read.value;
+			index = read.index;
 		} else if (token === "--json") {
 			if (json) fail("`--json`은 한 번만 사용할 수 있습니다.");
 			json = true;
 		} else if (token.startsWith("--json=")) fail("`--json`은 값을 받지 않습니다.");
-		else if (token.startsWith("-")) fail(`지원하지 않는 test 옵션 '${token}'입니다.`);
-		else fail(`추가 위치 인자 '${token}'는 허용되지 않습니다.`);
+		else if (token.startsWith("-")) fail(`지원하지 않는 test 옵션 '${escapeTerminalText(token)}'입니다.`);
+		else fail(`추가 위치 인자 '${escapeTerminalText(token)}'는 허용되지 않습니다.`);
 	}
-	if (command === void 0) throw new CliCommandError({
+	if (command !== void 0 && url !== void 0) fail("`--command` 와 `--url` 은 함께 쓸 수 없습니다.\n→ `--command` 는 서버를 프로세스로 띄우고, `--url` 은 이미 떠 있는 원격 서버에 붙습니다.\n→ 둘 중 무엇을 검사할지 하나만 고르세요.");
+	if (command === void 0 && url === void 0) throw new CliCommandError({
 		code: "CLI_USAGE",
-		message: "`--command` 옵션이 필요합니다.",
+		message: "`--command` 또는 `--url` 옵션이 필요합니다.",
 		hint: TEST_USAGE_HINT
 	});
+	if (url !== void 0 && args.length > 0) fail("`--arg` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--arg` 는 우리가 띄우는 프로세스에 넘길 인자입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
+	if (command !== void 0 && !headerEnv.isEmpty()) fail("`--header-env` 는 `--url` 과 함께만 쓸 수 있습니다.\n→ 헤더는 HTTP 요청에 실립니다. `--command` 로 띄운 서버와는 stdio 로 이야기합니다.");
+	if (url !== void 0 && stderrLines !== void 0) fail("`--stderr-lines` 는 `--url` 과 함께 쓸 수 없습니다.\n→ 이 옵션은 우리가 띄운 프로세스의 stderr 를 보여줍니다. 원격 서버에는 그 프로세스가 없습니다.\n→ 원격 서버 실패는 엔드포인트와 HTTP 상태로 진단합니다. 그 블록은 항상 나옵니다.");
+	if (url !== void 0 && (sessionPath !== void 0 || recordSessionPath !== void 0)) fail("External 세션 옵션은 `--url` 과 함께 쓸 수 없습니다.\n→ External 배선은 우리가 띄운 자식 프로세스의 환경변수로 들어갑니다.\n→ 원격 서버는 우리가 띄우지 않으므로 그 주입 지점이 없습니다.");
+	if (sessionPath !== void 0 && recordSessionPath !== void 0) fail("`--session`과 `--record-session`은 함께 쓸 수 없습니다. 재생과 녹화 중 하나만 고르세요.");
+	if (determinism && (sessionPath !== void 0 || recordSessionPath !== void 0)) fail("`--determinism`은 External 세션 옵션과 함께 쓸 수 없습니다.\n→ `--determinism`은 서버에 2회 연결하지만 External 세션은 연결 하나에 묶여 있습니다.\n→ 2회차가 같은 세션을 쓰면 반복 호출 순번이 어긋나고, 새 세션을 쓰면 비교 기준이 갈라집니다.");
 	return Object.freeze({
 		suitePath,
-		command,
-		args: Object.freeze(args),
+		target: url === void 0 ? Object.freeze({
+			transport: "stdio",
+			command,
+			args: Object.freeze(args)
+		}) : Object.freeze({
+			transport: "http",
+			url,
+			headerEnv: headerEnv.snapshot()
+		}),
 		json,
 		junitPath,
 		repairBundlePath,
 		determinism,
 		resetCmd,
+		sessionPath,
+		recordSessionPath,
 		stderrLines: stderrLines ?? DEFAULT_STDERR_LINES
 	});
 }
@@ -3909,8 +4076,77 @@ const FINDING_GROUP_ORDER = [
 	"rejectionIntent",
 	"skipped"
 ];
+const WORD_CHARACTER = /[\p{L}\p{N}_]/u;
+const SAME_UNICODE_CASE_FOLDED_CHARACTER = /^(.)\1$/iu;
+/** 두 유니코드 코드 포인트가 정규식의 `/iu` 대소문자 규칙에서 같은지 판정한다. */
+const sameUnicodeCaseFoldedCharacter = (left, right) => SAME_UNICODE_CASE_FOLDED_CHARACTER.test(left + right);
+/** limit 를 넘기기 전에 순회를 멈춰 신뢰하지 않는 진단 문자열의 메모리 사용을 제한한다. */
+const codePointsWithinLimit = (value, limit) => {
+	const points = [];
+	for (const point of value) {
+		if (points.length === limit) return void 0;
+		points.push(point);
+	}
+	return points;
+};
+/**
+* 진단 문장에서 독립된 marker 를 찾는다. runner 가 보장하는 진단 문자열 길이를 넘으면
+* 임의로 자른 경계에서 오탐하지 않도록 중복이 아니라고 보수적으로 판정한다.
+*/
+const containsWholeDiagnosticMarker = (note, marker) => {
+	if (marker === "") return false;
+	const notePoints = codePointsWithinLimit(note, MAX_VALUE_STRING_CHARS);
+	if (notePoints === void 0) return false;
+	const markerPoints = codePointsWithinLimit(marker, notePoints.length);
+	if (markerPoints === void 0) return false;
+	for (let start = 0; start <= notePoints.length - markerPoints.length; start += 1) {
+		if (!markerPoints.every((point, offset) => sameUnicodeCaseFoldedCharacter(notePoints[start + offset] ?? "", point))) continue;
+		const before = notePoints[start - 1];
+		const after = notePoints[start + markerPoints.length];
+		if ((before === void 0 || !WORD_CHARACTER.test(before)) && (after === void 0 || !WORD_CHARACTER.test(after))) return true;
+	}
+	return false;
+};
+/**
+* 서버 응답 본문이 이미 타입 위반을 설명했는지 보수적으로 판정한다(#350).
+*
+* 응답 문장을 자연어로 해석하려 들면 "city 문자열을 숫자로 바꾸세요" 같은 다른 사실까지
+* 같은 말로 오인할 수 있다. 그래서 TYPE_MISMATCH 에서 구조적으로 아는 세 표식, 즉 필드명과
+* 기대 타입, 실제 타입(또는 실제 입력값)이 한 줄에 모두 있을 때만 참고 finding 을 접는다.
+* 하나라도 없으면 서버가 충분히 설명했다고 단정하지 않고 기존 참고를 남긴다.
+*
+* 다른 finding 은 같은 사실인지 판별할 표식이 부족하다. 예를 들어 REQUIRED_MISSING 은 필드명
+* 하나만 같아도 되므로 여기서 함께 억제하면 조용한 서버에서 유일한 단서를 잃을 수 있다.
+* 이 보수적 억제 범위와 검토한 대안은 ADR-0077에 기록한다.
+*/
+const responseRepeatsTypeMismatch = (finding, item) => {
+	if (finding.code !== "TYPE_MISMATCH") return false;
+	const expected = finding.expected;
+	const actualType = finding.actual;
+	if (typeof expected !== "string" || typeof actualType !== "string") return false;
+	if (item.spec.operation.type !== "callTool" || !finding.path.startsWith("input.")) return false;
+	const field = finding.path.slice(6);
+	if (field === "") return false;
+	const notes = [...item.operation.diagnostic?.notes ?? [], ...item.assertions.flatMap((assertion) => assertion.diagnostic?.notes ?? [])];
+	const actualValue = item.spec.operation.input[field];
+	const actualValueText = actualValue === void 0 ? void 0 : typeof actualValue === "string" ? actualValue : JSON.stringify(actualValue);
+	return notes.some((note) => containsWholeDiagnosticMarker(note, field) && containsWholeDiagnosticMarker(note, expected) && (containsWholeDiagnosticMarker(note, actualType) || actualValueText !== void 0 && containsWholeDiagnosticMarker(note, actualValueText)));
+};
 /** 결정론성 결과 블록의 머리글. 설계 문서 §8. */
 const DETERMINISM_HEADING = "결정론성 확인";
+/**
+* 종료 코드 고지. `--determinism` 은 **비차단 진단**이다 — 차이를 찾아도 종료 코드는 1회차
+* 판정 그대로 0 이다(설계 문서 §서론 "비차단 진단. status·종료 코드·`RunnerReport` 불변",
+* ADR-0018). 오탐이 CI 를 막으면 안 된다는 것이 그 설계의 이유다.
+*
+* **동작은 바꾸지 않는다.** 그 사실이 화면 어디에도 없어서, CI 는 초록인데 서버가 비결정이라는
+* 것을 아무도 모르는 자리가 있었다(#292). 고치는 것은 고지뿐이다.
+*
+* 뒤에 붙는 "어디를 보라" 는 갈래마다 다르다. `--json` 의 `determinism` 키는 **비교까지 갔을
+* 때만** 만들어지므로(위 §JSON 조립), 비교를 못 한 갈래에서 그 키를 가리키면 없는 것을
+* 가리키는 안내가 된다.
+*/
+const EXIT_CODE_NOTICE = "→ 이 진단은 종료 코드에 반영되지 않습니다.";
 /** `(12/12)` 와 `(12/12, 제외 2: 실행되지 않은 케이스)`. 설계 문서 §8. */
 const determinismCounts = (result) => result.skipped === 0 ? `(${result.compared}/${result.compared})` : `(${result.compared}/${result.compared}, 제외 ${result.skipped}: 실행되지 않은 케이스)`;
 /**
@@ -3923,6 +4159,7 @@ function renderDeterminism(outcome, options) {
 	if (outcome.kind === "incomplete") {
 		const head = `${DETERMINISM_HEADING}\n→ 2회차 실행이 완주하지 못해 비교할 수 없습니다. (사유: ${escapeTerminalText(outcome.reason)})\n→ 1회차는 완주했으므로, 서버가 반복 실행 자체에 취약할 수 있습니다
   (이전 실행이 남긴 상태·잠금·포트 점유 등).
+${EXIT_CODE_NOTICE} --json 에서는 determinism 키가 만들어지지 않아\n  이 안내가 stderr 로만 나갑니다.
 `;
 		if (options.stderrLines === 0 || outcome.diagnostics === void 0 || !hasDiagnosticContent(outcome.diagnostics)) return head;
 		const block = renderProcessDiagnostics(outcome.diagnostics, { maxLines: options.stderrLines });
@@ -3935,37 +4172,143 @@ function renderDeterminism(outcome, options) {
 `;
 	const suffix = result.skipped === 0 ? "" : ` (제외 ${result.skipped}: 실행되지 않은 케이스)`;
 	const blocks = result.differences.map((difference) => describeDeterminismDifference(difference, { stateRestored: options.stateRestored })).join("\n\n");
-	return `${DETERMINISM_HEADING}\n→ ${result.differences.length}/${result.compared} 케이스에서 2회 실행 결과가 다릅니다.${suffix}\n\n${blocks}\n`;
+	return `${DETERMINISM_HEADING}\n→ ${result.differences.length}/${result.compared} 케이스에서 2회 실행 결과가 다릅니다.${suffix}\n\n${blocks}\n${EXIT_CODE_NOTICE} CI 를 막으려면 --json 의 determinism 키를 보세요.\n`;
 }
-/** 초기화 명령 실패 안내. 한 줄로 유지한다. hint 의 개행은 format 이 이스케이프한다. */
+/**
+* 초기화 명령 실패 안내.
+*
+* 진단(종료 코드·stderr 꼬리)과 다음 행동(hint)을 한 줄에 눌러 담지 않는다(#289). 예전에는
+* 그 둘을 이어 붙이며 경계를 두지 않아 `... ENOENT 명령이 단독으로 성공하는지 ...` 처럼
+* `ENOENT` 가 `명령` 을 수식하는 말로 읽혔다. 진단은 `message` 에 줄을 나눠 담고, `hint` 는
+* 다음에 할 일 한 문장만 남긴다 — `format()` 이 이제 개행을 이스케이프하지 않으므로
+* (`--reset-cmd` 명령이 단독으로) 그대로 구조가 유지된다.
+*
+* `error.command`·stderr 꼬리는 사용자가 지정한 명령과 그 명령이 만든 출력이라, 우리 문장이
+* 아닌 값이 섞이는 자리다. 화면을 깨뜨릴 제어 문자가 실려도 그대로 나가지 않도록 이스케이프한다.
+*/
 function resetFailure(error) {
 	const exit = error.exitCode === null ? "없음" : String(error.exitCode);
 	const tail = error.stderr.split("\n").filter(Boolean).slice(-3).join(" | ");
-	const stderr = tail === "" ? "" : ` stderr 마지막 3줄: ${tail}`;
+	const stderrLine = tail === "" ? "" : `\n  stderr 마지막 3줄: ${escapeTerminalText(tail)}`;
 	return {
 		code: "RESET_COMMAND_FAILED",
-		message: `초기화 명령이 실패했습니다: ${error.command}`,
-		hint: `종료 코드: ${exit}.${stderr} 명령이 단독으로 성공하는지 확인한 뒤 다시 실행하세요.`
+		message: `초기화 명령이 실패했습니다: ${escapeTerminalText(error.command)}\n  종료 코드: ${exit}${stderrLine}`,
+		hint: "`--reset-cmd` 명령이 단독으로 성공하는지 확인한 뒤 다시 실행하세요."
+	};
+}
+/** JUnit 파일 쓰기 실패에 사용자가 지정한 경로와 운영체제 오류 코드를 남긴다(#294). */
+/**
+* 노드 오류의 `code`. 문자열(`ENOENT`)이거나 숫자일 수 있고, 둘 다 아니면 우리가 아는 것이
+* 없다. `junitWriteFailure` 가 쓰던 것을 꺼내 다른 실패 생성기와 함께 쓴다(#276).
+*/
+function errnoOf(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))}`,
+		hint: dictionary.JUNIT_WRITE_FAILED.hint
+	};
+}
+/**
+* `--repair-bundle` 쓰기 실패. 짝인 `junitWriteFailure` 와 같은 모양이어야 한다 — 같은 실행에서
+* 둘 다 실패할 수 있고, 그때 한쪽만 경로를 싣고 있으면 사용자가 어느 파일이 없는지 알 수 없다.
+*/
+function repairBundleWriteFailure(path, error) {
+	return {
+		code: "REPAIR_BUNDLE_WRITE_FAILED",
+		message: `repair 번들 파일을 쓰지 못했습니다: ${escapeTerminalText(path)}\n  errno: ${escapeTerminalText(errnoOf(error))}`,
+		hint: dictionary.REPAIR_BUNDLE_WRITE_FAILED.hint
+	};
+}
+/**
+* 명세 읽기 실패. **errno 별로 다음 행동이 다르다** — 파일이 없으면 경로를 고치고, 권한이
+* 없으면 권한을 고친다. 둘을 한 문장으로 묶으면 사용자에게 둘 다 확인하게 만든다(#276).
+* 어느 쪽인지 아는데 안 말할 이유가 없다.
+*/
+function suiteReadFailure(path, error) {
+	const shown = escapeTerminalText(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(errno)}`,
+		hint: dictionary.SUITE_READ_FAILED.hint
+	};
+}
+/**
+* 확장자 검사 실패. **인코딩 얘기를 하지 않는다.**
+*
+* 이 갈래는 `extname(path) !== ".json"` 하나로만 온다. 그런데 안내가 "UTF-8로 저장한 .json
+* 명세 파일을 사용하세요" 라고 해서, 이미 UTF-8 JSON 인 사용자는 따라 해도 안 풀렸다.
+* 인코딩은 **바로 다음 단계가 따로 검사한다**(`SUITE_ENCODING_INVALID`). 그래서 이 안내는
+* 인코딩을 아예 언급하지 않는다 — 한 번 꺼내면 그것부터 확인하러 가고, 여기서 할 일은
+* 경로를 고치는 것 하나다.
+*/
+function suiteFormatFailure(path) {
+	const ext = extname(path);
+	return {
+		code: "SUITE_FORMAT_UNSUPPORTED",
+		message: ext === "" ? `테스트 명세는 .json 파일이어야 합니다. 준 경로에 확장자가 없습니다: ${escapeTerminalText(path)}` : `테스트 명세는 .json 파일이어야 합니다. 준 확장자: ${escapeTerminalText(ext)}\n  경로: ${escapeTerminalText(path)}`,
+		hint: "경로가 .json 으로 끝나는지 확인하세요. 이 단계는 파일을 열지 않고 확장자만 봅니다."
+	};
+}
+function suiteEncodingFailure(path) {
+	return {
+		code: "SUITE_ENCODING_INVALID",
+		message: `테스트 명세 파일이 유효한 UTF-8이 아닙니다: ${escapeTerminalText(path)}`,
+		hint: dictionary.SUITE_ENCODING_INVALID.hint
+	};
+}
+/**
+* JSON 문법 실패. **파서가 준 문장을 그대로 통과시킨다.** 위치 표기는 런타임마다 다르다 —
+* `at position 7 (line 1 column 8)` 을 주는 경우도 있고 깨진 자리의 스니펫만 주는 경우도 있다
+* (Node 25 실측). 우리가 형식을 고정하면 어느 한쪽에서 거짓이 되므로, 그 문장을 옮기고
+* 경로만 우리가 더한다. 파서 문장에는 사용자 파일 내용 조각이 섞이므로 이스케이프한다.
+*/
+function suiteJsonFailure(path, error) {
+	const reason = error instanceof Error ? error.message : String(error);
+	return {
+		code: "SUITE_JSON_INVALID",
+		message: `테스트 명세의 JSON 문법이 유효하지 않습니다: ${escapeTerminalText(path)}\n  ${escapeTerminalText(reason)}`,
+		hint: dictionary.SUITE_JSON_INVALID.hint
 	};
 }
+/**
+* `message`·`hint` 는 **여기서 이스케이프하지 않는다**(#289). 그 필드는 우리가 여러 줄로
+* 공들여 쓴 안내와, 자식 프로세스·경로처럼 신뢰 못 할 값이 섞여 있다 — 어느 부분이 우리 글이고
+* 어느 부분이 남의 값인지는 필드를 다 만든 뒤인 여기서는 구분할 수 없다. 그래서 이스케이프는
+* **만드는 자리에서, 신뢰 못 할 값에만** 건다(`resetFailure`·`externalOpenFailure`·옵션 파싱의
+* `escapeTerminalText(token)` 호출들). 우리가 쓴 리터럴 개행은 그 자리를 거치지 않으므로
+* 구조를 유지한 채 여기까지 그대로 온다.
+*
+* `code`·`issue.*` 는 계속 통째로 건다. `code` 는 항상 우리 열거형이라 무해하고, `issue.*` 는
+* `validateSuite` 가 주는 데이터 레코드라 우리가 개행을 심을 자리가 아니다 — 한 줄 필드에
+* 통째로 걸어도 잃을 구조가 없다.
+*/
 function format(failure) {
 	const code = failure.coreCode === void 0 ? failure.code : `${failure.code}/${failure.coreCode}`;
-	let result = `오류 [${escapeTerminalText(code)}]: ${escapeTerminalText(failure.message)}\n해결: ${escapeTerminalText(failure.hint)}`;
+	let result = `오류 [${escapeTerminalText(code)}]: ${failure.message}\n해결: ${failure.hint}`;
 	for (const issue of failure.issues ?? []) result += `\n- [${escapeTerminalText(issue.code)}] ${escapeTerminalText(issue.path)}: ${escapeTerminalText(issue.message)}\n  해결: ${escapeTerminalText(issue.hint)}`;
 	return `${result}\n`;
 }
-/**
-* core 의 McpProcessDiagnostics 인지 구조로 확인한다. core 를 import 하지 않는다.
-* 하나라도 어긋나면 undefined 다. 설계 문서 §4.3.1.
-*/
-function processDiagnostics(value) {
-	if (typeof value !== "object" || value === null) return void 0;
-	if (!("stderr" in value) || typeof value.stderr !== "string") return void 0;
-	if (!("stderrTruncated" in value) || typeof value.stderrTruncated !== "boolean") return void 0;
-	if (!("exitCode" in value) || !(typeof value.exitCode === "number" || value.exitCode === null)) return void 0;
-	if (!("signal" in value) || !(typeof value.signal === "string" || value.signal === null)) return void 0;
-	return value;
-}
+/** AggregateError 내부까지 내려가 core 오류와 검증된 진단을 꺼낸다. */
 function coreError(error) {
 	const seen = /* @__PURE__ */ new Set();
 	const visit = (value) => {
@@ -3974,7 +4317,8 @@ function coreError(error) {
 			code: value.code,
 			message: value.message,
 			hint: value.hint,
-			diagnostics: processDiagnostics("diagnostics" in value ? value.diagnostics : void 0)
+			diagnostics: processDiagnostics("diagnostics" in value ? value.diagnostics : void 0),
+			httpDiagnostics: httpDiagnostics("diagnostics" in value ? value.diagnostics : void 0)
 		});
 		if (typeof value !== "object" || value === null || seen.has(value)) return void 0;
 		seen.add(value);
@@ -3985,30 +4329,60 @@ function coreError(error) {
 	};
 	return visit(error);
 }
+/**
+* 보고서·케이스 상한 초과(#92). 서버 문제가 아니라 우리 상한이라 일반 종료 실패와 갈라야 한다.
+* 같은 문장으로 접으면 사용자는 서버 응답과 종료 상태를 확인하러 가서 아무것도 못 찾는다.
+*
+* 케이스 초과에 "케이스 수를 줄이라" 고 하면 안 된다. 넘긴 것은 그 케이스 하나이고 나머지를
+* 지워도 같은 오류가 그대로 난다. `dry-run.ts` 의 안내와 같은 구분이다.
+*/
+function payloadLimitFailure(error) {
+	const kb = (bytes) => `${Math.round(bytes / 1024)}KB`;
+	if (error.scope === "report") return {
+		code: "RUNNER_PAYLOAD_LIMIT_EXCEEDED",
+		message: `보고서가 ${kb(error.actualBytes)} 로 상한 ${kb(error.limitBytes)} 를 넘었습니다. 상한은 올릴 수 없습니다.`,
+		hint: "툴을 나눠 여러 명세 파일로 만드세요. 응답이 큰 툴은 케이스 수를 줄이세요."
+	};
+	return {
+		code: "RUNNER_PAYLOAD_LIMIT_EXCEEDED",
+		message: `${error.caseId === void 0 ? "케이스" : `케이스 '${escapeTerminalText(error.caseId)}'`} 이 ${kb(error.actualBytes)} 로 상한 ${kb(error.limitBytes)} 를 넘었습니다. 상한은 올릴 수 없습니다.`,
+		hint: "그 케이스의 이름·입력·단언을 줄이세요. 다른 케이스를 지워도 같은 오류가 납니다."
+	};
+}
 function writeFailure(dependencies, failure) {
 	dependencies.writeStderr(format(failure));
 	return 1;
 }
-async function runCli(argv, dependencies) {
+async function runCliCore(argv, dependencies, childEnv) {
 	if (argv.length === 0) return writeFailure(dependencies, {
 		code: "CLI_USAGE",
 		message: "실행할 CLI 명령이 없습니다.",
-		hint: TEST_USAGE_HINT
+		hint: commandDiscovery
 	});
 	if (argv[0] !== "test") {
+		if (argv[0] === "verify") return writeFailure(dependencies, {
+			code: "CLI_USAGE",
+			message: "`mcpeak verify` 는 제거되었습니다. Tool 카세트와 함께 걷어냅니다(ADR-0059).",
+			hint: "카세트 드리프트 확인이 목적이었다면 `mcpeak test` 로 실서버를 직접 검증하세요. 외부 API 호출을 막는 것이 목적이었다면 `mcpeak test <suite.json> --command <executable> --record-session <path>` 로 먼저 녹화한 뒤 `--session <path>` 로 재생하세요. 두 옵션은 함께 쓸 수 없습니다."
+		});
+		if (argv[0] === "replay") return writeFailure(dependencies, {
+			code: "CLI_USAGE",
+			message: "`mcpeak replay` 는 제거되었습니다. Tool 카세트와 함께 걷어냅니다(ADR-0059).",
+			hint: "서버를 띄우지 않고 저장된 응답으로 스위트를 돌리는 것이 목적이었다면 `mcpeak-mock` 으로 서버를 대신하세요. 외부 API 호출만 막는 것이 목적이었다면 `mcpeak test <suite.json> --command <executable> --record-session <path>` 로 먼저 녹화한 뒤 `--session <path>` 로 재생하세요."
+		});
 		if ([
 			"generate",
 			"record",
 			"mock"
 		].includes(argv[0] ?? "")) return writeFailure(dependencies, {
 			code: "COMMAND_NOT_IMPLEMENTED",
-			message: `'${argv[0]}' 명령은 아직 구현되지 않았습니다.`,
-			hint: "현재는 test 명령만 사용할 수 있습니다."
+			message: `'${escapeTerminalText(argv[0] ?? "")}' 명령은 아직 구현되지 않았습니다.`,
+			hint: commandDiscovery
 		});
 		return writeFailure(dependencies, {
 			code: "CLI_USAGE",
-			message: `알 수 없는 CLI 명령 '${argv[0]}'입니다.`,
-			hint: TEST_USAGE_HINT
+			message: `알 수 없는 CLI 명령 '${escapeTerminalText(argv[0] ?? "")}'입니다.`,
+			hint: commandDiscovery
 		});
 	}
 	let input;
@@ -4020,36 +4394,24 @@ async function runCli(argv, dependencies) {
 			...dictionary.CLI_INTERNAL_ERROR
 		});
 	}
-	if (extname(input.suitePath).toLowerCase() !== ".json") return writeFailure(dependencies, {
-		code: "SUITE_FORMAT_UNSUPPORTED",
-		...dictionary.SUITE_FORMAT_UNSUPPORTED
-	});
+	if (extname(input.suitePath).toLowerCase() !== ".json") return writeFailure(dependencies, suiteFormatFailure(input.suitePath));
 	let bytes;
 	try {
 		bytes = await dependencies.readFile(input.suitePath);
-	} catch {
-		return writeFailure(dependencies, {
-			code: "SUITE_READ_FAILED",
-			...dictionary.SUITE_READ_FAILED
-		});
+	} catch (error) {
+		return writeFailure(dependencies, suiteReadFailure(input.suitePath, error));
 	}
 	let decoded;
 	try {
 		decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
 	} catch {
-		return writeFailure(dependencies, {
-			code: "SUITE_ENCODING_INVALID",
-			...dictionary.SUITE_ENCODING_INVALID
-		});
+		return writeFailure(dependencies, suiteEncodingFailure(input.suitePath));
 	}
 	let parsed;
 	try {
 		parsed = JSON.parse(decoded);
-	} catch {
-		return writeFailure(dependencies, {
-			code: "SUITE_JSON_INVALID",
-			...dictionary.SUITE_JSON_INVALID
-		});
+	} catch (error) {
+		return writeFailure(dependencies, suiteJsonFailure(input.suitePath, error));
 	}
 	let validated;
 	try {
@@ -4084,21 +4446,32 @@ async function runCli(argv, dependencies) {
 			...dictionary.CLI_INTERNAL_ERROR
 		});
 	}
+	/**
+	* 두 transport 의 연결 주입점을 한 묶음으로 만든다. `--determinism` 의 2회차도 같은 것을
+	* 쓴다 — 회차마다 다른 대상에 붙으면 비교가 뜻을 잃는다.
+	*/
+	const connectDependencies = {
+		connectStdio: dependencies.connect,
+		...dependencies.connectHttp === void 0 ? {} : { connectHttp: dependencies.connectHttp },
+		...dependencies.readEnv === void 0 ? {} : { readEnv: dependencies.readEnv }
+	};
 	let connection;
 	try {
-		connection = await dependencies.connect({
-			command: input.command,
-			args: input.args
-		});
+		connection = await openConnection(input.target, connectDependencies, childEnv === void 0 ? void 0 : { env: childEnv });
 	} catch (error) {
+		if (error instanceof ConnectTargetError) return writeFailure(dependencies, {
+			code: "CLI_USAGE",
+			message: error.message,
+			hint: TEST_USAGE_HINT
+		});
 		const core = coreError(error);
 		const failed = writeFailure(dependencies, core === void 0 ? {
 			code: "MCP_CONNECTION_FAILED",
 			...dictionary.MCP_CONNECTION_FAILED
 		} : {
 			code: "MCP_CONNECTION_FAILED",
-			message: core.message,
-			hint: core.hint,
+			message: escapeTerminalText(core.message),
+			hint: escapeTerminalText(core.hint),
 			coreCode: core.code
 		});
 		const diagnostics = core?.diagnostics;
@@ -4106,14 +4479,30 @@ async function runCli(argv, dependencies) {
 			const block = renderProcessDiagnostics(diagnostics, { maxLines: input.stderrLines });
 			if (block !== "") dependencies.writeStderr(`\n${block}`);
 		}
+		/**
+		* 원격 대상의 진단. `--stderr-lines` 로 억제하지 않는다 — 파서가 그 옵션과 `--url` 의
+		* 동시 사용을 막으므로 값이 항상 기본값이라 조건이 뜻을 잃는다.
+		*
+		* 내용 판정(`hasHttpDiagnosticContent`)도 걸지 않는다. 연결이 실패한 자리에서는 상태
+		* 코드가 없어도(DNS 실패, 연결 거부) **어느 엔드포인트에 붙으려다 실패했는지**가 정보다.
+		*/
+		const remote = core?.httpDiagnostics;
+		if (remote !== void 0) dependencies.writeStderr(`\n${renderHttpDiagnostics(remote)}`);
 		return failed;
 	}
 	/** 진단 출력 실패가 판정을 바꾸면 안 된다. getDiagnostics 가 던지면 삼킨다. §4.3.1. */
 	const snapshotDiagnostics = () => {
 		try {
-			return { value: connection.getDiagnostics() };
+			const raw = connection.getDiagnostics();
+			return {
+				value: processDiagnostics(raw),
+				remote: httpDiagnostics(raw)
+			};
 		} catch {
-			return { value: void 0 };
+			return {
+				value: void 0,
+				remote: void 0
+			};
 		}
 	};
 	/**
@@ -4123,8 +4512,21 @@ async function runCli(argv, dependencies) {
 	* 않기 위해서다(설계 문서 §4.3).
 	*/
 	const writeDiagnostics = (snapshot) => {
+		const taken = snapshot ?? snapshotDiagnostics();
+		/**
+		* 원격 대상. `--stderr-lines` 로 억제하지 않는다 — stdio 전용 옵션이고 파서가 `--url`
+		* 과의 동시 사용을 막으므로 여기서는 조건이 뜻을 잃는다.
+		*
+		* 다만 내용 판정은 **건다.** 연결 실패 경로와 달리 여기는 실행이 끝난 뒤라, core 가
+		* 상태 코드를 채우지 않은 성공한 실행에서도 불린다. 판정 없이 그리면 초록불 뒤에 매번
+		* 빈 진단 블록이 붙는다.
+		*/
+		if (taken.remote !== void 0) {
+			if (hasHttpDiagnosticContent(taken.remote)) dependencies.writeStderr(`\n${renderHttpDiagnostics(taken.remote)}`);
+			return;
+		}
 		if (input.stderrLines === 0) return;
-		const diagnostics = (snapshot ?? snapshotDiagnostics()).value;
+		const diagnostics = taken.value;
 		if (diagnostics === void 0) return;
 		if (!hasDiagnosticContent(diagnostics)) return;
 		const block = renderProcessDiagnostics(diagnostics, { maxLines: input.stderrLines });
@@ -4188,8 +4590,8 @@ async function runCli(argv, dependencies) {
 			execution,
 			shutdown
 		});
-	} catch {
-		const failed = writeFailure(dependencies, {
+	} catch (error) {
+		const failed = writeFailure(dependencies, error instanceof RunnerPayloadLimitError ? payloadLimitFailure(error) : {
 			code: "RUNNER_FINALIZATION_FAILED",
 			...dictionary.RUNNER_FINALIZATION_FAILED
 		});
@@ -4202,6 +4604,7 @@ async function runCli(argv, dependencies) {
 	* 있는데, 그때 사용자가 `--junit` 으로 명시적으로 요청한 산출물까지 함께 잃을 이유가 없다.
 	* `--junit` 을 주지 않으면 이 블록을 통째로 건너뛰므로 기존 순서와 동일하다. ADR-0019.
 	*/
+	let deferredJunitFailure;
 	if (input.junitPath !== void 0) {
 		let xml;
 		try {
@@ -4214,11 +4617,8 @@ async function runCli(argv, dependencies) {
 		}
 		try {
 			await dependencies.writeFile(input.junitPath, xml);
-		} catch {
-			return writeFailure(dependencies, {
-				code: "JUNIT_WRITE_FAILED",
-				...dictionary.JUNIT_WRITE_FAILED
-			});
+		} catch (error) {
+			deferredJunitFailure = junitWriteFailure(input.junitPath, error);
 		}
 	}
 	/**
@@ -4234,7 +4634,7 @@ async function runCli(argv, dependencies) {
 		if (firstCapture === void 0) return void 0;
 		const snapshotOf = (target) => {
 			try {
-				return target.getDiagnostics();
+				return processDiagnostics(target.getDiagnostics());
 			} catch {
 				return;
 			}
@@ -4249,10 +4649,7 @@ async function runCli(argv, dependencies) {
 		}
 		let second;
 		try {
-			second = await dependencies.connect({
-				command: input.command,
-				args: input.args
-			});
+			second = await openConnection(input.target, connectDependencies, childEnv === void 0 ? void 0 : { env: childEnv });
 		} catch (error) {
 			const core = coreError(error);
 			return {
@@ -4326,7 +4723,8 @@ async function runCli(argv, dependencies) {
 	/**
 	* 툴 목록이 비면 입력 계약 대조는 건너뛴다. 목록이 비었을 때 대조하면 모든 케이스가
 	* `TOOL_NOT_DECLARED` 로 걸려 실패 원인과 무관한 줄만 늘어난다. 단언 실질성은 툴이 필요
-	* 없으므로 항상 돈다. 표시는 실패한 케이스에 한한다. 설계 문서 §7.
+	* 없으므로 항상 돈다. 위반 참고는 실패한 케이스에만 표시하지만, 검사를 건너뛴 사실은
+	* 통과 케이스에서도 보존한다. 설계 문서 §7.
 	*
 	* 검사가 던져도 판정과 exit code 는 바뀌지 않아야 하므로 삼킨다. `validated.value` 는 이미
 	* `validateMcpSuite` 를 통과했으니 도달할 일이 없는 경로이고, 도달했다면 그것은 비차단
@@ -4334,14 +4732,18 @@ async function runCli(argv, dependencies) {
 	*/
 	const specFindings = (() => {
 		/**
-		* 실패한 케이스의 버킷을 보고서의 케이스 순서로 먼저 만든다. 두 검사 결과를 이어 붙인
+		* 케이스 버킷을 보고서의 케이스 순서로 먼저 만든다. 두 검사 결과를 이어 붙인
 		* 뒤에 `caseId` 로 묶으면 앞 케이스에 단언 finding 만 있고 뒤 케이스에 입력 계약 finding
 		* 이 있을 때 뒤 케이스가 먼저 들어와 순서가 뒤집힌다. 케이스 사이 순서는 검사 종류가
 		* 아니라 보고서가 정한다. 한 케이스 안의 블록 순서는 `FINDING_GROUP_ORDER` 가 맡는다.
 		* 없는 키를 만들지 않으므로 버킷에 없는 caseId 는 그대로 걸러진다.
 		*/
 		const buckets = /* @__PURE__ */ new Map();
-		for (const item of finalReport.cases) if (item.status !== "passed") buckets.set(item.spec.id, []);
+		const statuses = /* @__PURE__ */ new Map();
+		for (const item of finalReport.cases) {
+			buckets.set(item.spec.id, []);
+			statuses.set(item.spec.id, item.status);
+		}
 		try {
 			const inputContract = dependencies.checkInputContract ?? checkInputContract;
 			const assertionSubstance = dependencies.checkAssertionSubstance ?? checkAssertionSubstance;
@@ -4349,7 +4751,10 @@ async function runCli(argv, dependencies) {
 				suite: validated.value,
 				tools
 			}).findings, ...assertionSubstance(validated.value).findings];
-			for (const finding of found) buckets.get(finding.caseId)?.push(finding);
+			for (const finding of found) {
+				if (statuses.get(finding.caseId) === "passed" && FINDING_GROUP[finding.code] !== "skipped") continue;
+				buckets.get(finding.caseId)?.push(finding);
+			}
 			return [...buckets.values()].flat();
 		} catch {
 			return [];
@@ -4428,18 +4833,18 @@ async function runCli(argv, dependencies) {
 				* `byCase` 에 없어서 이 목록으로 순회해야 빠지지 않는다.
 				*/
 				for (const item of finalReport.cases) {
-					if (item.status === "passed") continue;
 					const caseId = item.spec.id;
-					const list = byCase.get(caseId) ?? [];
+					const allFindings = byCase.get(caseId) ?? [];
+					const list = item.status === "passed" ? allFindings.filter((finding) => FINDING_GROUP[finding.code] === "skipped") : allFindings;
 					for (const group of FINDING_GROUP_ORDER) {
-						const grouped = list.filter((finding) => FINDING_GROUP[finding.code] === group);
+						const grouped = list.filter((finding) => FINDING_GROUP[finding.code] === group && !(group === "inputContract" && responseRepeatsTypeMismatch(finding, item)));
 						if (grouped.length === 0) continue;
 						dependencies.writeStdout(`\n${FINDING_HEADING[group](escapeTerminalText(caseId))}\n${grouped.map((finding) => `  → ${describeSpecFinding(finding)}\n`).join("")}`);
 					}
 					if (serverDefectCases.has(caseId)) dependencies.writeStdout(`\n${SERVER_DEFECT_NOTE_LINE}`);
 				}
 			}
-			if (shouldShowSpecApproval(specApproval, allPassed)) dependencies.writeStdout(`\n${renderSpecApproval(specApproval)}`);
+			if (shouldShowSpecApproval(specApproval, allPassed)) dependencies.writeStdout(`\n${renderSpecApproval(specApproval, allPassed)}`);
 			/**
 			* 결정론성 블록은 보고서 뒤, 다른 블록과 같은 레이아웃 규칙(앞에 빈 줄)을 따른다.
 			* `--determinism` 없이는 한 줄도 찍지 않는다. 설계 문서 §8.
@@ -4470,6 +4875,7 @@ async function runCli(argv, dependencies) {
 	* 상태를 서버 탓으로 적게 된다. `--repair-bundle` 을 주지 않으면 이 블록을 통째로 건너뛰므로
 	* 기존 경로의 출력과 종료 코드가 그대로다. 계획서 완료 조건 2.
 	*/
+	let deferredRepairBundleFailure;
 	if (input.repairBundlePath !== void 0) {
 		const bundle = buildRepairBundle({
 			report: finalReport,
@@ -4480,14 +4886,330 @@ async function runCli(argv, dependencies) {
 		if (bundle === void 0) dependencies.writeStdout(`\n${REPAIR_BUNDLE_EMPTY_LINE}`);
 		else try {
 			await dependencies.writeFile(input.repairBundlePath, serializeRepairBundle(bundle));
-		} catch {
-			return writeFailure(dependencies, {
-				code: "REPAIR_BUNDLE_WRITE_FAILED",
-				...dictionary.REPAIR_BUNDLE_WRITE_FAILED
-			});
+		} catch (error) {
+			deferredRepairBundleFailure = repairBundleWriteFailure(input.repairBundlePath, error);
 		}
 	}
+	for (const failure of [deferredJunitFailure, deferredRepairBundleFailure]) if (failure !== void 0) writeFailure(dependencies, failure);
+	if (deferredJunitFailure !== void 0 || deferredRepairBundleFailure !== void 0) return 1;
 	return allPassed ? 0 : 1;
 }
+/**
+* 재생 원본에서 찾지 못한 호출들을 그린다. `misses` 가 비어 있으면 빈 문자열이다.
+*
+* **MCP 오류 채널을 타지 않는다(#259).** `record` 의 `REPLAY_MISS` 진단은 실패한 툴 호출의
+* MCP 오류 메시지로도 나가는데, 그 채널은 `runner` 가 "테스트 대상 서버가 보낸 텍스트"로
+* 취급해 이스케이프(개행 포함)와 200자 절단을 건다 — 우리 자신이 여러 줄로 공들여 쓴 진단이
+* 서버 텍스트와 똑같이 망가진다. 이 함수는 `record` 가 `finish()` 요약에 구조화해 담아 준
+* 값을 CLI 가 직접 stderr 로 쓴다. `runner` 도 그 이스케이프 규칙도 거치지 않는다.
+*
+* `method`·`url`·`matchKeyPrefix` 는 값 자체는 `record` 가 만들지만 원본은 테스트 대상
+* 서버가 시도한 요청이라, 혹시 모를 제어 문자에 대비해 필드 단위로 이스케이프한다(줄 구조를
+* 만드는 정적 문구는 이스케이프 대상이 아니다 — `process-diagnostics.ts` 와 같은 원칙).
+*/
+function renderReplayMissDiagnostics(misses) {
+	if (misses.length === 0) return "";
+	const body = misses.map((miss) => `  ${escapeTerminalText(miss.method)} ${escapeTerminalText(miss.url)}\n  occurrence ${miss.occurrence} · matchKey ${escapeTerminalText(miss.matchKeyPrefix)}…\n`).join("");
+	return `\nExternal 진단: 재생 원본에서 찾지 못한 호출 ${misses.length}건\n` + body + "→ 이 호출이 녹화된 뒤에 추가되었거나, 요청이 녹화 때와 달라져 다른 matchKey가 되었습니다.\n→ 녹화를 다시 하거나, 요청이 실행마다 달라지는 값을 담고 있는지 확인하세요.\n";
+}
+/**
+* External 세션 요약을 사용자에게 보이는 한 문단으로 옮긴다. `undefined` 는 할 말이 없다는 뜻이다.
+*
+* **순서가 곧 계약이다**(ADR-0057). `consumedCount === 0` 과 `unusedCount > 0` 은 동시에 참일 수
+* 있어서, 조건을 각각 독립적으로 세우면 한 실행에 경고가 두 번 찍힌다. 아래 순서로 먼저 걸리는
+* 하나만 낸다.
+*
+* 갈래를 넷으로 나눈 이유는 **사용자가 다음에 볼 곳이 다르기 때문이다.** 원본이 비어 있는 것
+* (녹화 단계가 아무것도 못 잡았다)과 원본은 찼는데 하나도 안 쓴 것(세션 파일을 잘못 짚었거나
+* 서버의 호출 방식이 바뀌었다)은 같은 `consumedCount === 0` 이지만 원인이 정반대 방향에 있다.
+* 하나로 합치면 [#258](https://github.com/2026-Engineering-Contest/MCPeak/issues/258) 의 실제
+* 경로에서 "녹화된 호출이 재생되지 않았다" 고 말하게 되는데, 그 문장은 녹화가 있었다는 전제를
+* 깔아 사용자를 재생 쪽으로 보낸다. 정작 볼 곳은 그 앞 단계다.
+*
+* 판정만 하고 쓰기는 하지 않는다 — 순수 함수라 배타성 자체를 프로세스 없이 고정할 수 있다.
+*/
+/**
+* External 세션을 열지 못한 실패를 사용자 문장으로 옮긴다(#260, #290).
+*
+* **원인마다 다음에 할 일이 다르므로 갈래마다 다른 문장을 쓴다.** 한때 이 자리가 문장 하나로
+* 모든 실패를 덮었고, 그래서 경로를 잘못 친 사람에게 "완료된 Replay 원본이 아닙니다" 와
+* "쓰기 권한을 확인하세요" 를 동시에 말했다 — 앞은 손상된 세션의 문안이고 뒤는 녹화의 문안이라
+* 재생 실패에는 둘 다 맞지 않았다.
+*
+* **경로를 `message` 에 싣는다.** 세션 id 는 넣지 않는다 — 사용자가 준 적 없는 `"default"`
+* 대신 사용자가 아는 경로를 보여준다.
+*
+* `path`·`detail` 은 우리 문장이 아니다. `path` 는 사용자가 CLI 에 그대로 타이핑한 값이고
+* `detail` 은 record 가 던진 오류의 원문(SQLite 원문을 포함할 수 있다)이라, 둘 다 화면을
+* 깨뜨릴 값이 실릴 수 있어 이스케이프한다(#289) — `message` 안에서 그 부분만 걸고, `format()`
+* 은 이제 필드 전체를 다시 이스케이프하지 않는다.
+*/
+function externalOpenFailure(mode, path, error) {
+	const code = error?.code;
+	const detail = error instanceof Error ? error.message : String(error);
+	const shownPath = escapeTerminalText(path);
+	if (error instanceof SessionFileMissingError) return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: `세션 파일을 찾을 수 없습니다: ${shownPath}`,
+		hint: "경로를 확인하거나, `--record-session <path>` 로 먼저 녹화하세요."
+	};
+	if (code === "SESSION_NOT_FOUND") return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: `세션 파일에 녹화된 외부 호출이 없습니다: ${shownPath}`,
+		hint: "`--record-session` 으로 다시 녹화하세요. 빈 세션으로는 아무 호출도 막지 못합니다."
+	};
+	if (code === "REPLAY_SOURCE_INVALID") return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: `녹화가 완료되지 않은 세션입니다: ${shownPath}`,
+		hint: "녹화 실행이 실패했을 수 있습니다. `--record-session` 으로 다시 녹화하세요."
+	};
+	if (code === "SCHEMA_VERSION_UNSUPPORTED") return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: `이 버전의 mcpeak 이 지원하지 않는 세션 파일입니다: ${shownPath}`,
+		hint: "이 버전의 mcpeak 으로 다시 녹화하세요."
+	};
+	if (code === "SESSION_ALREADY_EXISTS") return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: `세션 파일에 이미 녹화가 있습니다: ${shownPath}`,
+		hint: "기존 녹화를 덮어쓰지 않습니다. 다른 `--record-session` 경로를 쓰거나, 다시 녹화하려면 그 파일을 지우세요."
+	};
+	return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: `External 세션을 열지 못했습니다: ${shownPath} (${escapeTerminalText(detail)})`,
+		hint: mode === "replay" ? "경로가 맞는지와 그 파일을 읽을 수 있는지 확인하세요." : "경로의 디렉터리가 있는지와 쓰기 권한을 확인하세요."
+	};
+}
+/**
+* `wiring.finish()` 가 세션을 닫는 데 실패했을 때(#289). record 의 store `finish()` 는 코드
+* 둘만 던진다 — `SESSION_NOT_RUNNING`(한 줄) 과 `INCOMPLETE_SESSION`(record 가 여러 줄로
+* 쓴, 이미 마스킹된 안전한 진단. `display` 는 ADR-0053 이 마스킹을 보장한다).
+*
+* `INCOMPLETE_SESSION` 은 그대로 둬야 구조가 산다. 그 밖은 한 줄이라 이스케이프해도 잃을
+* 구조가 없고, 어떤 값이 올지 모르는 자리이므로 기본은 이스케이프한다.
+*/
+function externalCloseFailure(error) {
+	const code = error?.code;
+	const detail = error instanceof Error ? error.message : String(error);
+	return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: "External 세션을 닫지 못했습니다.",
+		hint: code === "INCOMPLETE_SESSION" ? detail : escapeTerminalText(detail)
+	};
+}
+/** 같은 단서의 재생 판. 남지 않는 것이 아니라 **실제 네트워크로 나가는** 것이 요점이다. */
+const PARTIAL_REPLAY_NOTE = "  이 수는 어댑터가 잡은 호출만 셉니다. 범위 밖 호출은 재생 중에도 실제 네트워크로 나갑니다.\n";
+/**
+* 재생 중 범위 밖으로 나간 호출을 **사실로** 알린다(ADR-0068).
+*
+* `externalSessionOutcome` 과 축이 다르므로 따로 낸다 — 그쪽은 "무엇을 했는가", 이쪽은 "그
+* 실행이 재현 가능한가" 다. 같은 실행에서 둘 다 나간다(ADR-0062 의 `bodyUrlNotice` 와 같은
+* 이유).
+*
+* **세 갈래를 정확히 구분한다.** `undefined`(못 셌음)에서 침묵하는 것이 핵심이다 — 거기서
+* "0건" 이라고 말하면 이 기능이 없애려던 거짓 안심을 그대로 되살린다. 그 경우의 방어는
+* `PARTIAL_REPLAY_NOTE` 조건절이 계속 맡는다.
+*/
+function outOfScopeNotice(summary) {
+	if (summary.mode !== "replay") return void 0;
+	if (summary.outOfScope === void 0) return void 0;
+	if (summary.outOfScope === 0) return void 0;
+	return `\n경고: 범위 밖 호출 ${summary.outOfScope}건이 실제 네트워크로 나갔습니다.\n→ 이 실행은 재현 가능하지 않습니다. 그 호출의 응답은 녹화본이 아니라 오늘의 것입니다.
+→ 서버가 \`node:http\`·axios 등으로 부른 호출입니다. 재생하려면 \`fetch\` 로 바꾸거나,
+  그 외부 의존을 \`mcpeak mock\` 으로 대신하세요.
+`;
+}
+/**
+* 조건절은 **모를 때만** 단다. 세었으면 개수가 그 자리를 대신한다.
+*
+* 0 건이면 붙일 이유가 없고, **N 건이어도 붙이지 않는다** — `outOfScopeNotice` 가 "N건이 실제
+* 네트워크로 나갔습니다" 를 이미 사실로 말하는데 그 위에 "나갈 수 있습니다" 를 얹으면 같은
+* 말을 두 번 하는 것이고, 조건절이 사실보다 먼저 읽혀 경고를 흐린다. 화면에서 실제로 그렇게
+* 나오는 것을 보고 고쳤다.
+*/
+function replayCaveat(summary) {
+	if (summary.mode === "replay" && summary.outOfScope !== void 0) return "";
+	return PARTIAL_REPLAY_NOTE;
+}
+/**
+* 이 실행이 External 세션으로 **무엇을 했는지** 한 줄로 말한다(ADR-0066).
+*
+* 성공한 실행이 아무 말도 하지 않으면, 사용자가 방금 본 리포트가 실제 네트워크를 탄 결과인지
+* 녹화본을 재생한 결과인지 구분할 방법이 없다. 판정이 같아도 그 판정의 근거는 다른 사실이다.
+*
+* **`externalSessionNotice` 와 정확히 배타다.** 그쪽이 말하는 갈래에서 여기는 침묵한다 — 둘 다
+* 나오면 같은 사실을 두 번 말하고, 둘 다 침묵하면 이 함수를 만든 이유가 그 갈래에서 사라진다.
+* 그 배타성은 이 주석이 아니라 `external-session.test.ts` 의 매트릭스가 지킨다.
+*
+* **`EXTERNAL_SCOPE_NOTE` 전문은 여기서 반복하지 않는다.** 경고 갈래마다 이미 나오고, 정상
+* 경로에서까지 매번 붙이면 그 문장이 읽히지 않게 된다. 대신 아래 한 줄짜리 단서만 붙인다.
+*/
+function externalSessionOutcome(summary, sessionPath) {
+	const shownPath = escapeTerminalText(sessionPath);
+	if (summary.mode === "record") {
+		if (summary.interactionCount === 0) return void 0;
+		if (summary.status !== "completed") return `\n→ 이 실행이 실패해 녹화를 완료하지 않았습니다: ${shownPath}\n  외부 호출 ${summary.interactionCount}건을 잡았지만 재생 원본으로 쓸 수 없습니다.\n→ 실패 원인을 고친 뒤 다시 녹화하세요.
+`;
+		return `\n→ 외부 호출 ${summary.interactionCount}건을 녹화했습니다: ${shownPath}\n  이 수는 어댑터가 잡은 호출만 셉니다. 범위 밖 호출은 세션에 남지 않습니다.
+`;
+	}
+	if (summary.interactionCount === 0) return void 0;
+	if (summary.consumedCount === 0) return void 0;
+	if (summary.unusedCount > 0) return void 0;
+	return `\n→ 녹화된 외부 호출 ${summary.interactionCount}건을 재생했습니다: ${shownPath}${recordedAtSuffix(summary)}\n` + replayCaveat(summary);
+}
+/**
+* 원본을 **언제** 녹화했는지 덧붙인다(ADR-0069). 없으면 아무것도 안 붙인다.
+*
+* **나이가 아니라 시각이다.** "12일 전" 이나 "30일 넘었습니다" 는 지금 시각을 읽어야 하고,
+* 그러면 같은 세션의 같은 재생이 날마다 다른 바이트를 낸다 — 결정론이 이 저장소의 핵심
+* 가치이고 대시보드 e2e 가 SSE 바이트 동일을 단언한다. 낡았는지 판정하는 것은 사람의 몫이다.
+*
+* **`toLocale*` 를 쓰지 않는다.** 기계의 로캘·타임존에 따라 같은 세션이 CI 와 로컬에서 다른
+* 문자열을 낸다. ISO 를 자르고 `UTC` 를 명시한다 — 표기를 안 붙이면 KST 사용자가 자기 시간으로
+* 읽어 9시간을 착각한다. 밀리초는 낡음을 판단하는 데 쓸모가 없어 뺀다.
+*/
+function recordedAtSuffix(summary) {
+	if (summary.mode !== "replay") return "";
+	const recordedAt = summary.recordedAt;
+	if (recordedAt === void 0) return "";
+	const [, date, time] = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(?:\.\d+)?Z$/.exec(recordedAt) ?? [];
+	return ` (${date === void 0 || time === void 0 ? escapeTerminalText(recordedAt) : formatUtc(recordedAt, date, time)} 녹화)`;
+}
+/**
+* 모양이 맞아도 **값이 달력에 없을 수 있다.** `2026-02-30` 은 `NaN` 이 아니라 **3월 2일로
+* 굴러간다**(실측). 그래서 `isNaN` 검사로는 못 잡고 왕복 비교를 해야 한다 — 다시 직렬화한
+* 값이 원래 문자열과 같을 때만 우리가 읽은 대로인 것이다.
+*
+* 파싱은 시계를 읽지 않으므로 결정론에 영향이 없다. 확인에 실패하면 원문을 그대로 보여준다 —
+* 손대지 않는 쪽이 없는 날짜를 그럴듯하게 포장하는 것보다 낫다.
+*
+* **그래서 `recordedAt` 원문을 받는다.** 잘라낸 조각으로 되짚어 만들면 정규식이 허용한 소수
+* 초가 사라져(`2026-02-30T12:00:00.123Z` → `...12:00:00Z`), "원문을 그대로 보여준다" 는 이
+* 함수의 계약이 실패 경로에서만 조용히 깨진다.
+*/
+function formatUtc(recordedAt, date, time) {
+	const iso = `${date}T${time}`;
+	const parsed = /* @__PURE__ */ new Date(`${iso}Z`);
+	if (Number.isNaN(parsed.getTime()) || !parsed.toISOString().startsWith(iso)) return escapeTerminalText(recordedAt);
+	return `${date} ${time} UTC`;
+}
+function externalSessionNotice(summary) {
+	if (summary.mode === "record") {
+		if (summary.interactionCount > 0) return void 0;
+		return "\n알림: 이 실행에서 외부 호출이 하나도 녹화되지 않았습니다.\n→ 서버가 외부 API를 호출했다면 지원 범위를 벗어났는지 확인하세요.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
+	}
+	if (summary.interactionCount === 0) return "\n알림: 이 세션에는 녹화된 외부 호출이 0건입니다. 재생할 것이 없었습니다.\n→ 녹화 실행이 외부 호출을 하나도 잡지 못했다는 뜻입니다. 이 세션은 아무 호출도 막지 못합니다.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
+	if (summary.consumedCount === 0) return "\n알림: 이 실행에서 녹화된 외부 호출이 하나도 재생되지 않았습니다.\n→ 지원 범위 밖의 호출은 실제 네트워크로 나갔을 수 있습니다.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
+	if (summary.unusedCount > 0) return `\n알림: 녹화된 외부 호출 ${summary.interactionCount}건 중 ${summary.unusedCount}건이 이번 실행에서 재생되지 않았습니다.\n→ 서버 코드나 실행 경로가 녹화 때와 달라졌을 수 있습니다.
+→ MCPeak은 서버가 \`globalThis.fetch\`로 부른 것만 잡습니다.
+`;
+}
+/**
+* 세션 본문에 남은 URL 을 알린다(ADR-0062).
+*
+* **`externalSessionNotice` 와 축이 다르므로 따로 낸다.** 그쪽은 "무엇이 녹화·재생됐는가" 를
+* 배타적 갈래 하나로 말하는데, 이 알림은 "그 세션에 무엇이 남았는가" 라서 같은 실행에서 둘 다
+* 나갈 수 있다. 한 함수에 합치면 그쪽의 배타성 계약이 깨진다.
+*
+* **재생에는 나오지 않는다.** 이 판정은 녹화 경로에서만 돌고(ADR-0062), 재생은 이미 있는
+* 파일을 읽을 뿐이라 새로 남는 것이 없다.
+*
+* 개수만 말하고 **URL 도 그 일부도 싣지 않는다.** 알림이 새 유출 경로가 되면 고치려던 것을
+* 그 자리에서 다시 만든다 — ADR-0062 결정 3번이 그 방어이고, `record` 가 지문만 넘기는 것도
+* 같은 이유다. 사용자가 확인할 곳은 세션 파일이지 이 화면이 아니다.
+*/
+function bodyUrlNotice(summary) {
+	if (summary.mode !== "record") return void 0;
+	const counts = summary.bodyUrls;
+	if (counts === void 0) return void 0;
+	const total = counts.echoed + counts.other;
+	if (total === 0) return void 0;
+	const count = (value) => `${value}건${counts.truncated ? " 이상" : ""}`;
+	const lines = [`\n알림: 세션 파일 본문에 URL 이 ${count(total)} 남아 있습니다.`];
+	if (counts.echoed > 0) lines.push(`  되돌아온 경로 ${count(counts.echoed)} — 이 실행의 요청 경로가 본문에 그대로 실렸습니다`);
+	if (counts.other > 0) lines.push(`  그 밖의 URL ${count(counts.other)}`);
+	lines.push("→ 경로 자체가 자격증명인 endpoint(Slack·Discord webhook 등)를 녹화했다면 그 값이 세션 파일에", "  원문으로 들어 있습니다. 이름으로 판정할 수 없는 자리라 마스킹이 닿지 않습니다.", "→ 커밋하기 전에 세션 파일 내용을 확인하세요. 이미 커밋했다면 그 자격증명을 폐기·재발급하세요.");
+	return `${lines.join("\n")}\n`;
+}
+/**
+* `test` 실행에 External Record/Replay 수명주기를 씌운다.
+*
+* Coordinator 를 **먼저 열고 마지막에 닫는다**(ADR-0052). 그 사이에 들어가는 것이 기존 실행
+* 전부라, 성공·실패·예외 어느 경로로 빠져나가도 `finish` 가 불려야 한다. 안 불리면 SQLite
+* 파일 핸들이 남고 Record 세션이 `running` 인 채로 남아 다음 실행이 이어 쓸 수 없다.
+*
+* 세션 옵션이 없으면 배선을 아예 만들지 않는다 — 기존 실행 경로가 한 글자도 달라지지 않는다.
+*/
+async function runCli(argv, dependencies) {
+	const mode = externalModeOf(argv);
+	if (mode === void 0) return runCliCore(argv, dependencies);
+	let wiring;
+	try {
+		wiring = await startExternalWiring({
+			mode: mode.mode,
+			sessionPath: mode.path,
+			existingNodeOptions: process.env.NODE_OPTIONS
+		});
+	} catch (error) {
+		return writeFailure(dependencies, externalOpenFailure(mode.mode, mode.path, error));
+	}
+	let exitCode;
+	try {
+		exitCode = await runCliCore(argv, dependencies, wiring.env);
+	} catch (error) {
+		await wiring.finish("failed").catch(() => void 0);
+		throw error;
+	}
+	try {
+		const summary = await wiring.finish(exitCode === 0 ? "completed" : "failed");
+		const outcome = externalSessionOutcome(summary, mode.path);
+		if (outcome !== void 0) dependencies.writeStderr(outcome);
+		if (summary.mode === "replay") {
+			const missBlock = renderReplayMissDiagnostics(summary.misses);
+			if (missBlock !== "") dependencies.writeStderr(missBlock);
+		}
+		const notice = externalSessionNotice(summary);
+		if (notice !== void 0) dependencies.writeStderr(notice);
+		const leaked = outOfScopeNotice(summary);
+		if (leaked !== void 0) dependencies.writeStderr(leaked);
+		const urls = bodyUrlNotice(summary);
+		if (urls !== void 0) dependencies.writeStderr(urls);
+	} catch (error) {
+		return writeFailure(dependencies, externalCloseFailure(error));
+	}
+	return exitCode;
+}
+/**
+* argv 에서 External 모드를 정한다. **파싱은 `parseTestCommand` 하나만 한다.**
+*
+* 한때 여기서 argv 를 따로 훑었다. 그러면 토큰 소비 규칙이 두 벌이 되고, 두 벌은 갈라진다.
+* 실제로 갈렸다 — `--arg` 는 하이픈으로 시작하는 값을 의도적으로 받으므로
+*
+*     mcpeak test s.json --command node --arg --session=/tmp/x
+*
+* 에서 `parseTestCommand` 는 그 토큰을 **서버 인자**로 소비하는데, 따로 훑는 쪽은 같은 것을
+* replay 지시로 읽었다. 사용자가 요청한 적 없는 세션 파일이 열리고 Bootstrap 이 주입되며,
+* Replay 라 서버의 외부 호출이 전부 실패한다. 원인을 짐작할 방법이 없는 실패다.
+*
+* 파싱 오류는 여기서 삼킨다. 배선은 파싱보다 먼저 서지만 **오류 보고는 기존 경로의 몫**이다.
+* 여기서 던지면 `--session` 이 붙었다는 이유만으로 오류 문구가 달라진다.
+*/
+function externalModeOf(argv) {
+	if (argv[0] !== "test") return void 0;
+	let input;
+	try {
+		input = parseTestCommand(argv.slice(1));
+	} catch {
+		return;
+	}
+	if (input.recordSessionPath !== void 0) return {
+		mode: "record",
+		path: input.recordSessionPath
+	};
+	if (input.sessionPath !== void 0) return {
+		mode: "replay",
+		path: input.sessionPath
+	};
+}
 //#endregion
-export { runReplayCommand as a, nodeGenerateDependencies as c, GLOBAL_HELP as d, VERIFY_USAGE_HINT as f, parseReplayCommand as i, nodeReviewIO as l, version as m, runCli as n, parseRepairCommand as o, commandHelp as p, ReplayRuntimeUnavailableError as r, runRepairCommand as s, parseTestCommand as t, runGenerateCommand as u };
+export { nodeGenerateDependencies as a, GLOBAL_HELP as c, escapeTerminalText$2 as d, version as f, runRepairCommand as i, commandDiscovery as l, runCli as n, nodeReviewIO as o, parseRepairCommand as r, runGenerateCommand as s, parseTestCommand as t, commandHelp as u };