@mcpeak/cli 0.9.0

package/dist/test-command-BZ_94UmI.cjs

@@ -0,0 +1,4576 @@
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let node_readline_promises = require("node:readline/promises");
+let _mcpeak_runner = require("@mcpeak/runner");
+let _mcpeak_record = require("@mcpeak/record");
+let node_child_process = require("node:child_process");
+let _mcpeak_core = require("@mcpeak/core");
+//#region package.json
+var version = "0.9.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: _mcpeak_record.loadCassette,
+		save: _mcpeak_record.saveCassette
+	};
+	const cassette = await io.load(path);
+	const warnings = [];
+	let snapshot;
+	const mode = resolveMode(cassette, forceRecord);
+	const recorder = (0, _mcpeak_record.cassetteClient)(inner, {
+		cassette,
+		mode,
+		cassettePath: path,
+		onFlush: async (value) => {
+			snapshot = value;
+		},
+		onWarning: (message) => {
+			warnings.push(message);
+		}
+	});
+	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);
+	};
+	return {
+		client,
+		mode,
+		flush,
+		warnings
+	};
+}
+//#endregion
+//#region src/dry-run.ts
+/** 보고서가 상한을 넘긴 경우의 안내. 케이스 수 말고는 사용자가 손댈 수 있는 것이 없다. */
+const REPORT_LIMIT_DETAIL = "보고서가 1MB 상한을 넘었습니다. 케이스 수를 줄인 뒤 다시 시도하세요.";
+/**
+* 케이스 하나가 상한을 넘긴 경우의 안내. 케이스 수를 줄이라고 하면 안 된다. 넘긴 것은 그
+* 케이스 하나이고, 나머지를 지워도 같은 오류가 그대로 난다.
+*/
+const caseLimitDetail = (caseId) => `케이스${caseId === void 0 ? "" : ` '${caseId}'`} 가 상한을 넘었습니다. 그 케이스의 이름·입력·단언을 줄인 뒤 다시 시도하세요.`;
+/** 툴 이름조차 알 수 없을 때의 안내. `runSuite` 가 통째로 던진 경우다. */
+const CONNECTION_LOST_DETAIL = "MCP 서버 연결이 끊겼습니다.";
+/** `renderReport` 의 진단·단언 줄 들여쓰기. reporter.ts 의 INDENT 와 같은 값이다. */
+const INDENT$1 = "    ";
+/**
+* `renderReport` 출력에서 케이스별 블록을 잘라 낸다. 반환 배열의 순서와 길이는
+* `report.cases` 와 같다.
+*
+* 문장을 다시 만들지 않고 잘라 내기만 하는 것이 요점이다. 케이스 머리글 줄은 버린다.
+* 호출 측이 자기 번호와 이름으로 머리글을 다시 그리기 때문이고, 그대로 두면 같은 이름이
+* 두 줄 나온다.
+*
+* 경계 판정은 들여쓰기다. `renderReport` 는 케이스 본문 줄을 전부 4칸 들여쓰고 머리글만
+* 기호로 시작한다. 메시지 안의 개행은 렌더러가 이미 이스케이프하므로 본문 줄이 임의로
+* 늘어나지 않는다.
+*/
+const caseBlocks = (report) => {
+	const blocks = [];
+	for (const line of (0, _mcpeak_runner.renderReport)(report).split("\n").slice(2)) {
+		if (line === "") break;
+		if (line.startsWith(INDENT$1)) blocks.at(-1)?.push(line);
+		else blocks.push([]);
+	}
+	return report.cases.map((_, index) => (blocks[index] ?? []).join("\n"));
+};
+/**
+* 연결이 끊긴 케이스의 위치를 찾는다. `runSuite` 는 호출이 던져도 멈추지 않고 다음 케이스로
+* 가므로, 서버가 죽으면 남은 케이스가 전부 같은 오류로 채워진다. 첫 번째만 사실이고 나머지는
+* 그 결과다. 그래서 첫 지점에서 자른다.
+*/
+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
+		};
+	}
+};
+/**
+* 러너가 케이스를 다 돌기 전에 멈춘 경우를 찾는다. `stopReason` 이 그 사실을 말한다.
+*
+* 이것을 읽지 않으면 실행되지도 않은 `notRun` 케이스가 실패 목록에 섞여 분류 화면으로 간다.
+* 사용자가 그것을 `서버 결함` 으로 고르면 서버에 보낸 적도 없는 호출이 회귀 테스트가 된다.
+*/
+const stopDetail = (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 suffix = "남은 케이스는 실행되지 않았습니다.";
+	if (stop.type === "timeout") return `케이스 '${name ?? stop.caseId}' 가 제한 시간 안에 끝나지 않았습니다. ${suffix}`;
+	return name === void 0 ? `실행이 중단됐습니다. ${suffix}` : `케이스 '${name}' 에서 실행이 중단됐습니다. ${suffix}`;
+};
+const toResult = (report) => {
+	const blocks = caseBlocks(report);
+	const outcomes = report.cases.map((result, index) => ({
+		caseId: result.spec.id,
+		caseName: result.spec.name,
+		status: result.status,
+		detail: blocks[index] ?? "",
+		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 {
+		outcomes: outcomes.filter((outcome) => outcome.status !== "notRun"),
+		aborted: {
+			reason: "stopped",
+			detail: stopped
+		}
+	};
+	return { outcomes };
+};
+/**
+* 후보 명세 전량을 실행한다. 케이스를 골라내지 않는다. 설계 문서 §4.4 가 근거다.
+* 실행 순서는 `cases` 배열 순서이고 정렬하지 않는다.
+*/
+async function runDryRun(options) {
+	const execution = (0, _mcpeak_runner.runSuite)({
+		client: options.client,
+		suite: options.suite
+	});
+	let report;
+	try {
+		report = await execution.report;
+	} catch (error) {
+		if (error instanceof _mcpeak_runner.RunnerPayloadLimitError) return {
+			outcomes: [],
+			aborted: {
+				reason: "payloadLimit",
+				detail: error.scope === "report" ? REPORT_LIMIT_DETAIL : caseLimitDetail(error.caseId)
+			}
+		};
+		return {
+			outcomes: [],
+			aborted: {
+				reason: "connectionLost",
+				detail: CONNECTION_LOST_DETAIL
+			}
+		};
+	}
+	await execution.drain;
+	return toResult(report);
+}
+//#endregion
+//#region src/dry-run-review.ts
+/** 선택지 한 글자와 화면 문안. 배열 순서가 곧 화면 순서다. */
+const CHOICES = [
+	{
+		key: "s",
+		label: "서버 결함",
+		help: "명세가 옳다. 이 케이스를 회귀 테스트로 남긴다"
+	},
+	{
+		key: "m",
+		label: "명세 오류",
+		help: "추측이 틀렸다. 저장 전에 고친다"
+	},
+	{
+		key: "?",
+		label: "판단 보류",
+		help: "분류를 미룬다. 저장은 막힌다"
+	}
+];
+/** 요약 줄의 항목 순서. 0건인 종류는 빼고 찍는다. */
+const SUMMARY_LABELS = [
+	["s", "서버 결함"],
+	["m", "명세 오류"],
+	["?", "판단 보류"]
+];
+/** 실패 케이스인가. 통과가 아닌 것은 전부 사람의 판단이 필요하다. */
+const isFailure = (outcome) => outcome.status !== "passed";
+const writeSummary = (io, chosen) => {
+	const parts = SUMMARY_LABELS.filter(([key]) => chosen.includes(key)).map(([key, label]) => {
+		return `${label} ${chosen.filter((value) => value === key).length}건`;
+	});
+	io.write(`  분류: ${parts.join(", ")}\n`);
+};
+/**
+* 시도 횟수를 세는 낱말. 교정은 케이스당 최대 2회라서(설계 §4.1) 두 개면 충분하다.
+* 그보다 많이 들어오면 숫자로 적는다. 화면이 조용히 틀린 낱말을 쓰는 것보다 낫다.
+*/
+const COUNT_WORDS = ["한 번", "두 번"];
+const countWord = (count) => COUNT_WORDS[count - 1] ?? `${count}번`;
+/**
+* 교정 시도 이력을 찍는다. 문안은 설계 문서 §8.7 이 전량 고정한다. 이력이 없는 케이스는
+* 이 블록이 통째로 없고 기존 화면 그대로다.
+*
+* 결과를 `오류` 로 고정하는 이유. 이 화면에 닿은 케이스는 교정이 전부 실패한 것이다.
+* 통과한 케이스는 애초에 실패 목록에 없다. §8.7 이 고정한 낱말도 `오류` 하나뿐이다.
+*/
+const writeAttempts = (io, attempts) => {
+	if (attempts.length === 0) return;
+	const width = Math.max(...attempts.map((attempt) => attempt.field.length));
+	io.write(`      입력값을 ${countWord(attempts.length)} 고쳐 봤지만 결과가 같습니다.\n`);
+	for (const attempt of attempts) io.write(`        ${attempt.field.padEnd(width)}: ${JSON.stringify(attempt.value)} → 오류\n`);
+	io.write("\n");
+};
+/**
+* 한 글자를 받는다. 대소문자를 구분하지 않고 앞뒤 공백을 버린다. 아는 글자가 나올 때까지
+* 같은 질문을 다시 묻는다. 기본값으로 넘기지 않는다. 모르는 채로 눌린 엔터가 없는 버그를
+* 회귀 테스트로 굳히면 안 된다.
+*/
+const askChoice = async (io) => {
+	for (const choice of CHOICES) io.write(`      [${choice.key}] ${choice.label}  ${choice.help}\n`);
+	for (;;) {
+		const answer = (await io.input("      선택: ")).trim().toLowerCase();
+		if (CHOICES.some((choice) => choice.key === answer)) return answer;
+	}
+};
+/**
+* 실패 케이스를 분류하고 저장 가능 여부를 판정한다.
+*
+* `cleared` 가 false 면 `approvals` 를 비운다. 반쯤 채워 넘기면 호출 측이 그것을 저장할 여지가
+* 생기고, 그 파일은 사람이 판단하지 않은 판정을 담게 된다.
+*
+* `attempts` 는 입력값 교정을 시도했던 케이스의 이력이다(§8.7). 선택이고, 안 넘기면 화면과
+* 반환값이 지금과 완전히 같다.
+*/
+async function reviewDryRun(io, result, attempts) {
+	const blocked = {
+		cleared: false,
+		approvals: [],
+		specErrors: []
+	};
+	if (result.aborted !== void 0) return blocked;
+	const failures = result.outcomes.filter(isFailure);
+	const passedAll = () => result.outcomes.map((outcome) => ({
+		id: outcome.caseId,
+		status: "passed"
+	}));
+	if (failures.length === 0) return {
+		cleared: true,
+		approvals: passedAll(),
+		specErrors: []
+	};
+	const chosen = [];
+	for (const [index, outcome] of failures.entries()) {
+		io.write(`  [${index + 1}] ${outcome.caseName}\n`);
+		writeAttempts(io, attempts?.get(outcome.caseId) ?? []);
+		chosen.push(await askChoice(io));
+		io.write("\n");
+	}
+	writeSummary(io, chosen);
+	const specErrors = failures.filter((_, index) => chosen[index] === "m").map((outcome) => outcome.caseId);
+	if (chosen.some((value) => value !== "s")) return {
+		...blocked,
+		specErrors
+	};
+	const defects = new Set(failures.map((outcome) => outcome.caseId));
+	return {
+		cleared: true,
+		approvals: result.outcomes.map((outcome) => ({
+			id: outcome.caseId,
+			status: defects.has(outcome.caseId) ? "serverDefect" : "passed"
+		})),
+		specErrors: []
+	};
+}
+//#endregion
+//#region src/finding-group.ts
+/**
+* finding 코드를 검사 종류로 가른다. `Record<SpecFindingCode, …>` 라서 `runner` 가 코드를
+* 늘리면 여기서 타입 오류가 난다. 문자열 배열로 두면 새 코드가 어느 블록에도 못 들어간 채
+* 조용히 사라지고, 이 화면에서 누락은 "위반이 없다" 로 읽히므로 가장 나쁜 실패다.
+*
+* **이 표는 한 벌이다.** `generate` 와 `test` 가 같은 표를 각자 갖고 있던 때는, 새 코드가 왔을 때
+* 두 곳을 채우면서 서로 다른 종류를 고를 수 있었다. 둘 다 `FindingGroup` 의 유효한 값이라
+* 컴파일러도 테스트도 잡지 못하고, 같은 finding 이 화면마다 다른 머리글 아래 뜬다. 그러면 읽는
+* 사람이 멀쩡한 입력을 고치러 간다(이슈 #154).
+*/
+const FINDING_GROUP = {
+	TOOL_NOT_DECLARED: "inputContract",
+	REQUIRED_MISSING: "inputContract",
+	UNDECLARED_FIELD: "inputContract",
+	TYPE_MISMATCH: "inputContract",
+	ENUM_MISMATCH: "inputContract",
+	RANGE_MISMATCH: "inputContract",
+	SCHEMA_NOT_ANALYZABLE: "skipped",
+	REJECTION_WITHOUT_VIOLATION: "rejectionIntent",
+	VACUOUS_MIN_LENGTH: "assertionSubstance",
+	VACUOUS_MIN_ITEMS: "assertionSubstance"
+};
+//#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>]";
+/**
+* 시험 실행 옵션 설명. `--determinism` 은 툴을 2회 호출하므로 부작용이 있는 서버에서 모르고
+* 쓰면 사고가 난다. 그 경고가 사용법 한 줄에는 들어가지 않는다.
+*/
+const TEST_OPTIONS = `옵션:
+  --determinism         스위트를 2회 실행해 결과가 같은지 확인합니다. 툴을 2회
+                        호출하므로 부작용이 있는 서버에서는 샌드박스에서 쓰세요.
+                        --reset-cmd 와 함께 쓰면 결정론성 확인이 되고, 없으면
+                        "2회 결과가 같았다" 까지만 확인합니다
+  --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]";
+/**
+* 시험 실행 옵션 설명. 사용법 한 줄로는 `--cassette` 가 무엇을 파일로 남기는지, `--reset-cmd`
+* 가 셸을 거치지 않는다는 제약을 알 수 없다. 둘 다 모르고 쓰면 사고가 나는 값이다.
+*/
+const GENERATE_DRY_RUN_OPTIONS = `옵션:
+  --no-dry-run          승인 전 시험 실행을 건너뜁니다. 케이스가 실제 서버에서 확인되지
+                        않은 채 저장됩니다
+  --cassette <path>     서버 응답을 녹화·재생합니다. 반복 실행에서 서버를 다시 부르지
+                        않습니다. 응답 전문이 저장되므로 .gitignore 를 확인하세요
+  --record              카세트를 처음부터 다시 녹화합니다 (--cassette 필요)
+  --reset-cmd <command> 시험 실행 전에 이 명령을 한 번 실행합니다. 셸을 거치지 않으므로
+                        파이프나 && 는 쓸 수 없습니다
+  --no-repair           시험 실행이 실패해도 입력값을 고쳐 다시 시도하지 않습니다.
+                        실패가 곧바로 분류 화면으로 갑니다
+  --force               \`--out\` 경로에 파일이 있으면 지우고 새로 씁니다. 기본은 저장을
+                        멈추는 것입니다`;
+const REPAIR_USAGE = "사용법: mcpeak repair <bundle.json> --provider <codex|claude> --model <model> [--max-cases <N>] [--no-stderr] [--yes]";
+/**
+* repair 옵션 설명. 사용법 한 줄로는 `--no-stderr` 가 무엇을 빼는지, `--yes` 가 무엇을 건너뛰는지
+* 알 수 없다. 둘 다 외부 provider 로 나가는 내용을 바꾸는 값이다.
+*/
+const REPAIR_OPTIONS = `옵션:
+  --provider <id>    진단을 물을 AI CLI 입니다. codex 또는 claude. 기본값은 없습니다
+  --model <model>    provider 에 넘길 모델 식별자입니다. 기본값은 없습니다
+  --max-cases <N>    한 번에 보낼 실패 개수 상한입니다. 넘으면 앞에서부터 남깁니다
+  --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 서버 테스트 프레임워크
+
+사용법: mcpeak <명령> [옵션]
+        mcpeak help [명령]
+
+명령:
+  test      JSON 테스트 명세로 MCP 서버를 실행하고 검증합니다.
+  generate  MCP 서버의 툴 스키마에서 테스트 명세를 생성합니다.
+  repair    실패한 test 실행의 번들로 서버 코드의 원인 후보를 제안받습니다.
+  replay    녹화된 카세트로 서버 없이 테스트 명세를 재생합니다.
+  verify    카세트가 아직 실서버 응답과 맞는지 확인합니다 (카세트를 고치지 않음).
+
+옵션:
+  -h, --help  도움말을 표시합니다.
+  --version   버전을 표시합니다.
+
+서브커맨드 도움말:
+  mcpeak help <명령>
+  mcpeak <명령> --help
+`;
+const commandDiscovery = "사용 가능한 명령: test, generate, repair, replay, verify. 전체 도움말: 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}
+
+${TEST_OPTIONS}
+`;
+	if (command === "repair") return `repair — 실패한 test 실행의 번들로 서버 코드의 원인 후보를 제안받습니다.
+
+${REPAIR_USAGE}
+
+${REPAIR_OPTIONS}
+`;
+	if (command === "replay") return `replay — 녹화된 카세트로 서버 없이 테스트 명세를 재생합니다.
+
+${REPLAY_USAGE}
+
+${REPLAY_OPTIONS}
+`;
+	return `generate — MCP 서버의 툴 스키마에서 테스트 명세를 생성합니다.
+
+${GENERATE_USAGE}
+
+${GENERATE_DRY_RUN_OPTIONS}
+`;
+}
+//#endregion
+//#region src/input-repair.ts
+/** 케이스 머리글 들여쓰기. 분류 화면(§8.3)과 같은 값이라 번호가 이어 읽힌다. */
+const HEAD = "  ";
+/** 본문 들여쓰기. 설계 문서 §8.6 의 모든 본문 줄이 이 폭이다. */
+const BODY = "      ";
+/**
+* 교정 대상의 실패 사유는 항상 이 한 줄이다. 대상 판별이 `isError` 단언의 `expected` 가
+* true 가 아닌 실패만 통과시키므로(§4.2), 진단 문장이 이것 말고 나올 수 없다.
+* `RepairTarget` 이 `detail` 을 나르지 않아 여기서 다시 적는다.
+*/
+const FAILURE_LINE = `${BODY}isError  정상 응답을 기대했지만 오류 응답을 받았습니다.`;
+const PROPOSED_LEAD = `${BODY}입력값이 거절된 것으로 보입니다. 서버 응답에서 값을 찾았습니다.`;
+const MANUAL_LEAD = `${BODY}입력값이 거절된 것으로 보입니다. 서버 응답에 쓸 만한 값이 없어 직접 받습니다.`;
+const RERUN_LINE = `${BODY}▸ 다시 실행 중... 1건`;
+const PASSED_LINE = `${BODY}✓ 통과`;
+const EXHAUSTED_LINE = `${BODY}✗ 여전히 실패합니다. 입력값 문제가 아닐 수 있습니다.`;
+/** JSON Schema 가 부르는 타입 이름. 값에서 뽑아 선언과 맞춰 본다. */
+const jsonTypeOf = (value) => {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+};
+/**
+* 선언 타입과 값이 맞는가. 선언이 없으면 검사하지 않는다(§4.5).
+* `integer` 는 `number` 의 부분집합이라 정수 여부까지 본다.
+*/
+const matchesDeclaredType = (declared, value) => {
+	if (declared === void 0) return true;
+	if (declared === "integer") return typeof value === "number" && Number.isInteger(value);
+	if (declared === "number") return typeof value === "number";
+	return jsonTypeOf(value) === declared;
+};
+const plainObject$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* 툴 선언에서 필드의 `type` 을 읽는다. 스키마는 서버가 주는 값이라 `unknown` 이다.
+* 우리가 아는 모양이 아니면 선언이 없는 것으로 본다. 추측해서 되묻으면 사람이 못 넘어간다.
+*/
+const declaredTypeOf = (tools, tool, field) => {
+	const schema = tools.find((candidate) => candidate.name === tool)?.inputSchema;
+	if (!plainObject$2(schema)) return void 0;
+	const properties = schema.properties;
+	if (!plainObject$2(properties)) return void 0;
+	const declared = properties[field];
+	if (!plainObject$2(declared)) return void 0;
+	return typeof declared.type === "string" ? declared.type : void 0;
+};
+/**
+* 사람이 친 글을 값으로 바꾼다. JSON 으로 읽어 보고 안 되면 문자열 그대로 쓴다(§4.5).
+* `서울` 은 문자열, `42` 는 숫자, `{"a":1}` 은 객체가 된다.
+*/
+const parseAnswer = (answer) => {
+	try {
+		return JSON.parse(answer);
+	} catch {
+		return answer;
+	}
+};
+/** §8.6 의 기본값 표시. 문자열은 따옴표 없이 그대로 보여준다. */
+const renderDefault = (value) => typeof value === "string" ? value : JSON.stringify(value);
+/** §8.6.1 의 현재값 표시. 값의 경계가 보여야 해서 JSON 으로 적는다. */
+const renderCurrent = (value) => JSON.stringify(value) ?? "null";
+/** `(tool, 필드명)` 캐시 키. 필드 이름에 점이 있어도 툴 이름과 섞이지 않게 앞을 길이로 가른다. */
+const cacheKey = (tool, field) => `${tool.length}:${tool}.${field}`;
+/**
+* 한 필드를 사람에게 받는다. 선언 타입과 안 맞으면 같은 질문을 다시 한다(§4.5).
+* `proposed` 가 있으면 §8.6 형식, 없으면 §8.6.1 형식이다.
+*/
+const askField = async (io, options) => {
+	const fallback = options.proposed ?? options.current;
+	const declared = options.declared === void 0 ? "" : `${options.declared}, `;
+	const question = options.proposed === void 0 ? `${BODY}${options.field} (${declared}현재 ${renderCurrent(options.current)}): ` : `${BODY}${options.field}: [${renderDefault(options.proposed)}]`;
+	for (;;) {
+		const answer = await io.input(question);
+		if (answer.trim() === "") return fallback;
+		const value = parseAnswer(answer);
+		if (matchesDeclaredType(options.declared, value)) return value;
+	}
+};
+/**
+* 한 회차의 입력값을 만든다. `reuse` 에 값이 있는 필드는 묻지 않고 그대로 쓴다(§4.6).
+* 키 순서는 `current` 의 순서를 그대로 지킨다.
+*/
+const askRound = async (io, target, options) => {
+	const next = {};
+	const asked = [];
+	let unchanged = true;
+	for (const [field, value] of Object.entries(options.current)) {
+		const cached = options.reuse?.get(field);
+		const answered = cached === void 0 ? await askField(io, {
+			field,
+			current: value,
+			proposed: options.proposed?.[field],
+			declared: declaredTypeOf(options.tools, target.tool, field)
+		}) : cached;
+		if (cached === void 0) asked.push(field);
+		next[field] = answered;
+		if (JSON.stringify(answered) !== JSON.stringify(value)) unchanged = false;
+	}
+	return {
+		input: next,
+		asked,
+		unchanged
+	};
+};
+async function repairInputs(options) {
+	const outcomes = [];
+	/**
+	* 사람이 확인했고 재실행까지 통과한 값. `(tool, 필드명)` 하나당 하나다.
+	* 이 호출이 끝나면 사라진다(§4.6).
+	*/
+	const cache = /* @__PURE__ */ new Map();
+	/** §8.6.3 을 이미 찍은 키. 같은 안내를 케이스마다 되풀이하지 않는다. */
+	const announced = /* @__PURE__ */ new Set();
+	for (const [index, target] of options.targets.entries()) {
+		options.io.write(`${HEAD}[${index + 1}] ${target.caseName}\n`);
+		options.io.write(`${FAILURE_LINE}\n`);
+		options.io.write("\n");
+		const attempts = [];
+		const fields = Object.keys(target.input);
+		const reused = fields.filter((field) => cache.has(cacheKey(target.tool, field)));
+		const askable = fields.filter((field) => !cache.has(cacheKey(target.tool, field)));
+		for (const field of reused) {
+			const key = cacheKey(target.tool, field);
+			if (announced.has(key)) continue;
+			announced.add(key);
+			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 first = await askRound(options.io, target, {
+			current: target.input,
+			proposed,
+			reuse: new Map(reused.map((field) => [field, cache.get(cacheKey(target.tool, field))])),
+			tools: options.tools
+		});
+		if (first.unchanged) {
+			outcomes.push({
+				caseId: target.caseId,
+				repaired: false,
+				attempts: []
+			});
+			continue;
+		}
+		options.io.write(`${RERUN_LINE}\n`);
+		const firstVerdict = await options.rerun(target.caseId, first.input);
+		for (const [field, value] of Object.entries(first.input)) attempts.push({
+			field,
+			value,
+			passed: firstVerdict.passed
+		});
+		if (firstVerdict.passed) {
+			for (const field of first.asked) cache.set(cacheKey(target.tool, field), first.input[field]);
+			options.io.write(`${PASSED_LINE}\n`);
+			outcomes.push({
+				caseId: target.caseId,
+				repaired: true,
+				input: first.input,
+				attempts
+			});
+			continue;
+		}
+		if (proposed === void 0) {
+			options.io.write(`${EXHAUSTED_LINE}\n`);
+			outcomes.push({
+				caseId: target.caseId,
+				repaired: false,
+				attempts
+			});
+			continue;
+		}
+		const second = await askRound(options.io, target, {
+			current: first.input,
+			proposed: void 0,
+			tools: options.tools
+		});
+		if (second.unchanged) {
+			options.io.write(`${EXHAUSTED_LINE}\n`);
+			outcomes.push({
+				caseId: target.caseId,
+				repaired: false,
+				attempts
+			});
+			continue;
+		}
+		options.io.write(`${RERUN_LINE}\n`);
+		const secondVerdict = await options.rerun(target.caseId, second.input);
+		for (const [field, value] of Object.entries(second.input)) attempts.push({
+			field,
+			value,
+			passed: secondVerdict.passed
+		});
+		if (secondVerdict.passed) {
+			for (const field of second.asked) cache.set(cacheKey(target.tool, field), second.input[field]);
+			options.io.write(`${PASSED_LINE}\n`);
+			outcomes.push({
+				caseId: target.caseId,
+				repaired: true,
+				input: second.input,
+				attempts
+			});
+			continue;
+		}
+		options.io.write(`${EXHAUSTED_LINE}\n`);
+		outcomes.push({
+			caseId: target.caseId,
+			repaired: false,
+			attempts
+		});
+	}
+	return outcomes;
+}
+//#endregion
+//#region src/pre-fill-wiring.ts
+const plainObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** 케이스 하나에 제안 값들을 얹은 입력. 원본을 바꾸지 않는다. */
+function withProposals(input, proposals) {
+	const next = { ...input };
+	for (const proposal of proposals) next[proposal.field] = proposal.value;
+	return next;
+}
+/** 케이스 id 로 골라 만든 부분 명세. 원본의 케이스 순서를 유지한다. */
+const subsetSuite = (suite, ids, replace) => ({
+	...suite,
+	cases: suite.cases.filter((item) => ids.has(item.id)).map((item) => withInput(item, replace?.get(item.id)))
+});
+/**
+* 케이스의 입력만 바꾼다. `TestCaseSpec` 은 유니온인데 판별자가 `operation.type` 이라
+* 중첩 속성으로는 좁혀지지 않는다. 좁힌 뒤 단언으로 넘긴다.
+*/
+function withInput(item, input) {
+	if (input === void 0 || item.operation.type !== "callTool") return item;
+	const callTool = item;
+	return {
+		...callTool,
+		operation: {
+			...callTool.operation,
+			input
+		}
+	};
+}
+const passedIds = (result) => new Set(result.outcomes.filter((outcome) => outcome.status === "passed").map((item) => item.caseId));
+/**
+* 제안 값을 baseline 값과 나란히 실행해 채택을 정한다.
+*
+* | baseline | AI | 채택 |
+* |---|---|---|
+* | 통과 | 통과 | **baseline** — 결정론적이고 재현 가능한 쪽이 기본값이다 |
+* | 통과 | 실패 | baseline |
+* | 실패 | 통과 | **AI** |
+* | 실패 | 실패 | baseline (분류 화면으로. 사후수리가 이어받는다) |
+*
+* 시험 실행이 중단되면(`aborted`) 그 회차의 판정을 믿지 않고 전부 baseline 을 유지한다.
+* 끊긴 연결에서 나온 "실패" 를 근거로 AI 값을 채택하면 서버가 옳은데 우리가 바꾸는 것이 된다.
+*/
+async function applyPreFill(options) {
+	const { client, baseline, preFill } = options;
+	const run = options.dryRun ?? runDryRun;
+	const byCase = /* @__PURE__ */ new Map();
+	for (const proposal of preFill.accepted) {
+		const list = byCase.get(proposal.caseId) ?? [];
+		list.push({
+			field: proposal.field,
+			value: proposal.value
+		});
+		byCase.set(proposal.caseId, list);
+	}
+	if (byCase.size === 0) return {
+		suite: baseline,
+		cases: [],
+		adopted: 0,
+		notAdopted: 0
+	};
+	const targetIds = /* @__PURE__ */ new Set();
+	const aiInputs = /* @__PURE__ */ new Map();
+	for (const item of baseline.cases) {
+		const proposals = byCase.get(item.id);
+		if (proposals === void 0) continue;
+		if (item.operation.type !== "callTool") continue;
+		const input = item.operation.input;
+		if (!plainObject$1(input)) continue;
+		targetIds.add(item.id);
+		aiInputs.set(item.id, withProposals(input, proposals));
+	}
+	if (targetIds.size === 0) return {
+		suite: baseline,
+		cases: [],
+		adopted: 0,
+		notAdopted: 0
+	};
+	const baselineRun = await run({
+		client,
+		suite: subsetSuite(baseline, targetIds)
+	});
+	const aiRun = await run({
+		client,
+		suite: subsetSuite(baseline, targetIds, aiInputs)
+	});
+	const aborted = baselineRun.aborted !== void 0 || aiRun.aborted !== void 0;
+	const baselinePassed = passedIds(baselineRun);
+	const aiPassed = passedIds(aiRun);
+	const cases = [];
+	const adoptedIds = /* @__PURE__ */ new Set();
+	for (const item of baseline.cases) {
+		if (!targetIds.has(item.id)) continue;
+		const basePass = baselinePassed.has(item.id);
+		const aiPass = aiPassed.has(item.id);
+		const useAi = !aborted && !basePass && aiPass;
+		if (useAi) adoptedIds.add(item.id);
+		cases.push({
+			caseId: item.id,
+			source: useAi ? "ai" : "baseline",
+			needsClassification: !aborted && !basePass && !aiPass
+		});
+	}
+	const adopted = adoptedIds.size;
+	return {
+		suite: adopted === 0 ? baseline : {
+			...baseline,
+			cases: baseline.cases.map((item) => withInput(item, adoptedIds.has(item.id) ? aiInputs.get(item.id) : void 0))
+		},
+		cases,
+		adopted,
+		notAdopted: cases.length - adopted
+	};
+}
+/** 점 표기 경로를 따라 필드 스키마를 찾는다. 못 찾으면 undefined 다. */
+function schemaAt(inputSchema, path) {
+	let current = inputSchema;
+	for (const segment of path.split(".")) {
+		if (!plainObject$1(current)) return void 0;
+		const properties = current.properties;
+		if (typeof properties !== "object" || properties === null) return void 0;
+		current = properties[segment];
+		while (plainObject$1(current) && current.type === "array") current = current.items;
+	}
+	return plainObject$1(current) ? current : void 0;
+}
+/**
+* AI 를 부를 수 없는 경로에서 건너뛸 툴을 고른다.
+*
+* `--baseline-only` 처럼 **애초에 provider 를 안 부르기로 한 경로에서만** 쓴다. provider 가
+* 죽은 경우에는 쓰지 않는다. 그것은 사용자 서버의 문제가 아니라 우리 쪽 사정이고, 그것 때문에
+* 케이스를 잃는 손해가 더 크다.
+*/
+function unknownFormatSkips(tools, provenance) {
+	if (!Array.isArray(provenance)) return [];
+	const declared = /* @__PURE__ */ new Map();
+	for (const tool of tools) if (!declared.has(tool.name)) declared.set(tool.name, tool);
+	const skips = [];
+	for (const item of provenance) for (const field of item.unknownFormatFields) {
+		const format = schemaAt(declared.get(item.tool)?.inputSchema, field)?.format;
+		skips.push({
+			tool: item.tool,
+			field,
+			format: typeof format === "string" ? format : ""
+		});
+	}
+	return skips;
+}
+/** 건너뛸 툴의 케이스를 명세에서 뺀다. 그 축은 커버리지에 미검증으로 남는다. */
+function dropSkippedTools(suite, skips) {
+	if (skips.length === 0) return suite;
+	const dropped = new Set(skips.map((skip) => skip.tool));
+	return {
+		...suite,
+		cases: suite.cases.filter((item) => item.operation.type !== "callTool" || !dropped.has(item.operation.tool))
+	};
+}
+//#endregion
+//#region src/process-diagnostics.ts
+/** TAB. 이 모듈만 이스케이프 대상에서 빼는 문자다. 아래 escapeTokens 주석에 근거가 있다. */
+const TAB = 9;
+/**
+* 터미널 제어 문자를 무해한 문자열로 바꾼다. 문자 하나가 토큰 하나가 된다. 설계 문서 §5.5.
+*
+* `packages/runner/src/reporter.ts` 의 `escapeTerminalText`,
+* `packages/cli/src/test-command.ts` 의 `escapeTerminalText` 와 같은 계열이다. 그 함수들을
+* import 하지 않고 사본을 두는 근거는 ADR-0013 과 같다. (줄 번호로 가리키면 금방 낡으므로
+* 심볼 이름으로 가리킨다.)
+*
+* **다만 이 사본만 TAB(0x09)을 이스케이프하지 않는다.** 다른 두 사본은 우리가 만든 메시지
+* 문자열만 다루므로 TAB 이 들어올 일이 없다. 이 모듈은 서버 stderr 를 그대로 그리는데, Java 의
+* `\tat com.example.Foo.bar(Foo.java:42)` 나 Go 패닉 트레이스의 파일·줄 행이 전부 TAB
+* 들여쓰기다. 그것을 `	` 로 바꾸면 이 기능이 보여주려던 스택 트레이스가 도리어 읽기
+* 어려워진다. TAB 은 커서를 옮길 뿐이라 터미널 주입 벡터가 아니다.
+*
+* 문자열이 아니라 토큰 배열을 돌려주는 이유는 자를 때 이스케이프 시퀀스 중간을 끊지 않기
+* 위해서다. `clampTokens` 를 봐라.
+*/
+function escapeTokens(value) {
+	return Array.from(value, (character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		if (codePoint === TAB) return character;
+		return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 8232 || codePoint === 8233 ? `\\u${codePoint.toString(16).padStart(4, "0")}` : character;
+	});
+}
+/**
+* 우리 종료 절차가 보내는 시그널. `packages/core/src/lifecycle.ts` 가 stdin EOF 뒤
+* `STDIN_CLOSE_GRACE_MS` 가 지나면 SIGTERM 을, 다시 `SIGTERM_GRACE_MS` 뒤에 SIGKILL 을 보낸다.
+* 타이머나 소켓 핸들을 들고 있어 유예 안에 못 끝나는 멀쩡한 서버가 여기 걸린다.
+*/
+const SHUTDOWN_SIGNALS = /* @__PURE__ */ new Set(["SIGTERM", "SIGKILL"]);
+/**
+* 프로세스가 비정상 종료했는지 판정한다.
+* 우리가 보내는 종료 시그널(SIGTERM·SIGKILL)은 그 자체로 비정상이 아니다. 정상 실행에서도
+* 나오므로 그것으로 경보를 울리면 거짓 경보가 된다. SIGSEGV·SIGABRT·SIGBUS 처럼 우리가 보내지
+* 않는 시그널은 그대로 비정상이다.
+* exitCode 가 null 이면 아직 종료하지 않았다는 뜻이므로 비정상이 아니다.
+*
+* 알려진 한계: OOM killer 가 보낸 SIGKILL 을 우리가 보낸 것과 구분하지 못해 놓친다.
+* core 진단에 "우리가 보냈다" 표식이 없어 지금은 구분할 방법이 없다. 거짓 경보를 매 실행마다
+* 내는 쪽보다 이 한 경우를 놓치는 쪽이 낫다고 보고 받아들인다. 설계 문서 §4.3.
+*/
+function isAbnormalExit(diagnostics) {
+	if (diagnostics.signal !== null) return !SHUTDOWN_SIGNALS.has(diagnostics.signal);
+	return diagnostics.exitCode !== null && diagnostics.exitCode !== 0;
+}
+/**
+* 블록에 담을 내용이 있는지 판정한다. 설계 문서 §4.3 의 "진단에 내용이 없으면 쓰지 않는다".
+* stderr 가 비고 비정상 종료도 아니면 남는 것은 `종료 코드: 0  시그널: 없음` 과
+* `stderr: (비어 있음)` 뿐이라 정보량이 0이다.
+*
+* 이 판정을 호출부마다 다시 쓰지 않고 여기 한 곳에 둔다. 억제 규칙이 갈라지면 진단이 가장
+* 필요한 경로에만 조용히 미적용되는 일이 생긴다.
+*/
+function hasDiagnosticContent(diagnostics) {
+	return diagnostics.stderr !== "" || isAbnormalExit(diagnostics);
+}
+/**
+* stderr 를 줄로 나눈다. 설계 문서 §5.4.
+* 개행 하나로 끝나는 경우에 생기는 마지막 빈 줄만 하나 버린다. 그 외의 빈 줄은 정보다.
+*/
+function splitLines(stderr) {
+	const lines = stderr.split(/\r?\n/);
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+/**
+* 한 줄에 표시할 문자 수 상한. 구조화 로거는 크래시마다 수십 KB JSON 을 한 줄로 뱉는다.
+* 줄 수만 제한하면 그 한 줄이 통째로 터미널에 쏟아진다. 1000자면 스택 프레임 한 줄과 긴 경로를
+* 담고도 터미널 몇 줄에 들어간다.
+*/
+const MAX_LINE_CHARACTERS = 1e3;
+/**
+* 상한을 넘는 줄을 자르고 생략한 문자 수를 알린다. 설계 문서 §5.4.
+*
+* **이스케이프 뒤에 자른다.** 이스케이프는 제어문자 하나를 `\uXXXX` 6자로 부풀리므로, 원문
+* 기준으로 자르면 상한이 상한 노릇을 못 한다. 제어문자로 채운 1000자가 6000자가 된다.
+* 그래서 세는 단위도 이스케이프된 문자다.
+*
+* 자르는 지점이 `	` 같은 시퀀스 중간이 되면 안 되므로 문자열이 아니라 토큰 배열을 받는다.
+* 토큰 하나는 원문 문자 하나에 대응하고 절대 쪼개지 않는다.
+*/
+function clampTokens(tokens) {
+	let total = 0;
+	for (const token of tokens) total += token.length;
+	if (total <= MAX_LINE_CHARACTERS) return tokens.join("");
+	let kept = 0;
+	const head = [];
+	for (const token of tokens) {
+		if (kept + token.length > MAX_LINE_CHARACTERS) break;
+		head.push(token);
+		kept += token.length;
+	}
+	return `${head.join("")} …(${total - kept}자 생략)`;
+}
+/**
+* 진단 블록을 만든다. maxLines 가 0 이면 빈 문자열을 반환한다.
+* 빈 문자열이 아니면 항상 개행으로 끝난다.
+*/
+function renderProcessDiagnostics(diagnostics, options) {
+	if (options.maxLines === 0) return "";
+	const head = `서버 프로세스 진단\n  종료 코드: ${diagnostics.exitCode === null ? "없음" : String(diagnostics.exitCode)}  시그널: ${diagnostics.signal === null ? "없음" : diagnostics.signal}\n`;
+	if (diagnostics.stderr === "") return `${head}  stderr: (비어 있음)\n`;
+	const lines = splitLines(diagnostics.stderr);
+	const shown = lines.slice(Math.max(0, lines.length - options.maxLines));
+	const dropped = lines.length - shown.length;
+	const whole = diagnostics.stderrTruncated ? "수집된 전체" : "전체";
+	const notes = [dropped === 0 ? whole : `마지막 ${options.maxLines}줄`];
+	if (dropped > 0) notes.push(`위로 ${dropped}줄 더 있음`);
+	if (diagnostics.stderrTruncated) notes.push("앞부분이 수집 상한으로 잘렸습니다");
+	const body = shown.map((line) => `    ${clampTokens(escapeTokens(line))}\n`).join("");
+	return `${head}  stderr (${notes.join(", ")}):\n${body}`;
+}
+//#endregion
+//#region src/repair-proposal.ts
+/** 요청 문안에서 서버 응답 본문이 시작하는 자리. 치환 뒤 본문이 남았는지 여기서 확인한다. */
+const SERVER_LABEL = "서버 응답: ";
+/** 설계 문서 §4.4 의 문안. 값만 채운다. 문장을 새로 만들지 마라. */
+const buildInstruction = (target) => [
+	"시험 실행에서 아래 케이스가 실패했습니다. 입력값만 고쳐 주세요.",
+	"단언과 케이스 구조는 바꾸지 마세요.",
+	"",
+	`케이스: ${target.caseName} (id: ${target.caseId})`,
+	`툴: ${target.tool}`,
+	`보낸 입력: ${(0, _mcpeak_runner.canonicalJson)(target.input)}`,
+	`${SERVER_LABEL}${target.serverMessage}`
+].join("\n");
+/**
+* 치환을 거친 요청에 서버 응답 본문이 남아 있는가. 본문이 통째로 지워졌으면 보낼 근거가
+* 없으므로 요청하지 않는다(설계 §4.4). 라벨 자체가 사라진 경우도 같다.
+*/
+const hasServerMessage = (instruction) => {
+	const at = instruction.indexOf(SERVER_LABEL);
+	if (at < 0) return false;
+	return instruction.slice(at + 7).split(_mcpeak_runner.REDACTED).join("").trim() !== "";
+};
+/** 깊은 동등 비교. 키 순서에 좌우되지 않도록 정규화 직렬화로 대조한다. */
+const same = (left, right) => (0, _mcpeak_runner.canonicalJson)(left) === (0, _mcpeak_runner.canonicalJson)(right);
+/** 대상 케이스의 입력값. `callTool` 이 아니면 입력이라는 것이 없다. */
+const inputOf = (spec) => spec.operation.type === "callTool" ? spec.operation.input : void 0;
+const toolOf = (spec) => spec.operation.type === "callTool" ? spec.operation.tool : void 0;
+/**
+* 응답의 권한 경계를 검사한다. 허용되는 변경은 **대상 케이스 `operation.input` 안의 값** 하나
+* 뿐이고, 설계 문서 §4.3 의 금지 항목을 하나라도 어기면 제안 전체를 폐기한다. 부분 수용은
+* 하지 않는다. 여기가 뚫리면 AI 가 서버에 맞춰 단언을 무력화하는 경로가 열리고, 그 순간
+* "서버가 틀렸을 가능성" 이 사라져 시험 실행 게이트의 존재 이유가 없어진다.
+*/
+function acceptProposal(options) {
+	const { target, before, after } = options;
+	if (!same({
+		...before,
+		cases: []
+	}, {
+		...after,
+		cases: []
+	})) return void 0;
+	if (after.cases.length !== before.cases.length) return void 0;
+	const index = before.cases.findIndex((spec) => spec.id === target.caseId);
+	if (index < 0) return void 0;
+	for (let position = 0; position < before.cases.length; position++) {
+		if (position === index) continue;
+		if (!same(before.cases[position], after.cases[position])) return void 0;
+	}
+	const beforeCase = before.cases[index];
+	const afterCase = after.cases[index];
+	const beforeTool = toolOf(beforeCase);
+	const afterTool = toolOf(afterCase);
+	if (beforeTool === void 0 || afterTool !== beforeTool) return void 0;
+	if (!same(beforeCase.assertions, afterCase.assertions)) return void 0;
+	if (afterCase.id !== beforeCase.id) return void 0;
+	if (afterCase.name !== beforeCase.name) return void 0;
+	if (afterCase.timeoutMs !== beforeCase.timeoutMs) return void 0;
+	const beforeInput = inputOf(beforeCase);
+	const afterInput = inputOf(afterCase);
+	if (beforeInput === void 0 || afterInput === void 0) return void 0;
+	const beforeKeys = Object.keys(beforeInput);
+	const afterKeys = Object.keys(afterInput);
+	if (beforeKeys.length !== afterKeys.length) return void 0;
+	const known = new Set(beforeKeys);
+	if (afterKeys.some((key) => !known.has(key))) return void 0;
+	if (same(beforeInput, afterInput)) return void 0;
+	return afterInput;
+}
+/**
+* 교정안을 provider 에게 요청한다. 실패는 전부 `undefined` 로 접는다. 교정은 선택이지
+* 전제가 아니라서, 여기서 던지면 교정 실패가 시험 실행을 통째로 죽인다.
+*/
+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 (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) {
+	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 와 같은 값이다. */
+const INDENT = "    ";
+/** 단언 진단의 위반 줄 표시. 이 줄에만 서버가 돌려준 값이 실려 있다. */
+const VIOLATION_MARK = "→ ";
+/** 실패 사유 판정에 쓰는 단언 타입. 이 줄이 있어야 "정상 응답을 기대했는데 오류" 다. */
+const IS_ERROR = "isError";
+/** 케이스 본문 줄에서 들여쓰기를 벗긴다. 들여쓰기가 없는 줄은 본문이 아니다. */
+const bodyLines = (detail) => detail.split("\n").filter((line) => line.startsWith(INDENT)).map((line) => line.slice(4));
+/**
+* 실패 사유가 `isError` 단언인가. 단언 줄은 타입 이름으로 시작하고, 진단 문장과 해결 줄은
+* 그렇지 않다. 통과한 단언은 애초에 그려지지 않으므로 존재 자체가 실패의 근거다.
+*/
+const failedByIsError = (detail) => bodyLines(detail).some((line) => line.startsWith(IS_ERROR));
+/**
+* 서버가 돌려준 오류 본문을 뽑는다. 문장을 새로 만들지 않고 위반 줄을 그대로 옮긴다.
+* `isError` 진단에는 값이 실리지 않으므로 근거가 되는 것은 본문 단언의 위반 줄뿐이다.
+* 뽑을 것이 없으면 빈 문자열이고, 그때 호출 측은 사람 입력으로 간다(§4.4).
+*/
+const serverMessageOf = (detail) => bodyLines(detail).filter((line) => line.startsWith(VIOLATION_MARK)).map((line) => line.slice(2)).join("\n");
+/**
+* 위반 케이스인가. ADR-0022 가 만드는 케이스는 입력을 일부러 어긋나게 만든 것이라
+* 고치면 케이스의 목적이 사라진다. 판별은 `isError` 단언의 `expected` 로 한다.
+*/
+const expectsError = (spec) => spec.assertions.some((assertion) => assertion.type === "isError" && assertion.expected === true);
+const toTarget = (spec, outcome, origins) => {
+	if (outcome.status === "passed") return void 0;
+	if (spec.operation.type !== "callTool") return void 0;
+	if (Object.keys(spec.operation.input).length === 0) return void 0;
+	if (origins.get(outcome.caseId) === "user") return void 0;
+	if (expectsError(spec)) return void 0;
+	if (!failedByIsError(outcome.detail)) return void 0;
+	return {
+		caseId: outcome.caseId,
+		caseName: outcome.caseName,
+		tool: spec.operation.tool,
+		input: spec.operation.input,
+		serverMessage: serverMessageOf(outcome.detail)
+	};
+};
+/**
+* 교정 대상을 고른다. 반환 배열은 `outcomes` 순서다. 정렬하지 않는다.
+* 순서를 바꾸면 화면 번호가 앞선 결과 화면과 어긋난다.
+*/
+function selectRepairTargets(options) {
+	const specs = new Map(options.suite.cases.map((spec) => [spec.id, spec]));
+	const targets = [];
+	for (const outcome of options.outcomes) {
+		const spec = specs.get(outcome.caseId);
+		if (spec === void 0) continue;
+		const target = toTarget(spec, outcome, options.origins);
+		if (target !== void 0) targets.push(target);
+	}
+	return targets;
+}
+//#endregion
+//#region src/reset-hook.ts
+/**
+* 시험 실행 직전에 서버 상태를 되돌리는 초기화 명령을 실행한다. ADR-0023 의 결정을 구현한다.
+*
+* 셸을 거치지 않는다. `;`·`&&`·백틱은 해석되지 않고 그대로 인자가 된다. 실행 파일을 감싼
+* 큰따옴표만 경계로 인식하며 인자의 따옴표는 해석하지 않는다. 공백이 든 인자가 필요하면
+* 사용자가 스크립트 파일을 만들어야 한다. 이 제약은 도움말에 적힌 사양이지 구현 편의가 아니다.
+*/
+/** 초기화 명령의 제한 시간. 설계 문서 §6. */
+const TIMEOUT_MS = 6e4;
+/** 보관하는 stderr 상한. 실패 안내에 쓰는 꼬리만 있으면 되고 그 이상은 화면을 덮는다. */
+const MAX_STDERR_BYTES = 8 * 1024;
+/** 제한 시간 초과일 때 `stderr` 에 넣는 문장. 종료 코드가 없으므로 사유가 여기에만 남는다. */
+const TIMEOUT_STDERR = `타임아웃(60초)`;
+/**
+* 초기화 명령이 정상 종료하지 못한 경우. 시험 실행을 시작하지 않고 저장도 하지 않는 사유가
+* 되므로, 호출 측이 화면에 쓸 수 있도록 명령·종료 코드·stderr 을 그대로 들고 다닌다.
+*
+* `exitCode` 가 `null` 인 경우는 셋이다. 실행 파일이 없거나(ENOENT), 시그널로 죽었거나,
+* 제한 시간을 넘겨 우리가 죽였을 때다.
+*/
+var ResetCommandError = class extends Error {
+	command;
+	exitCode;
+	stderr;
+	constructor(command, exitCode, stderr) {
+		super(`초기화 명령이 실패했습니다: ${command}`);
+		this.command = command;
+		this.exitCode = exitCode;
+		this.stderr = stderr;
+		this.name = "ResetCommandError";
+	}
+};
+/**
+* stderr 의 **마지막** 상한만큼을 모은다. 앞부분을 버리는 것이 요점이다. 화면에 쓰는 것은
+* 마지막 3줄이고, 실패 원인은 출력의 끝에 있다. 앞에서 잘라 보관하면 긴 출력을 내는 명령에서
+* 정작 사유가 담긴 마지막 줄이 사라진다.
+*/
+var StderrTail = class {
+	chunks = [];
+	size = 0;
+	push(chunk) {
+		this.chunks.push(chunk);
+		this.size += chunk.byteLength;
+		while (this.size > MAX_STDERR_BYTES) {
+			const first = this.chunks[0];
+			if (first === void 0) break;
+			const excess = this.size - MAX_STDERR_BYTES;
+			if (first.byteLength <= excess) {
+				this.chunks.shift();
+				this.size -= first.byteLength;
+			} else {
+				this.chunks[0] = first.subarray(excess);
+				this.size -= excess;
+			}
+		}
+	}
+	text() {
+		return Buffer.concat(this.chunks).toString("utf8");
+	}
+};
+/**
+* 초기화 명령을 한 번 실행한다. 재시도하지 않는다.
+*
+* stdout 은 아예 받지 않는다. 성공 경로에서 남의 명령 출력을 우리 화면에 섞지 않기 위함이고,
+* 버퍼 상한에 걸려 멀쩡한 명령이 죽는 일도 없앤다.
+*
+* 빈 문자열이나 공백뿐인 명령은 `ResetCommandError` 가 아니라 `TypeError` 다. 옵션 파싱에서
+* 이미 걸러야 하는 값이고, 여기까지 왔다면 사용자 입력 문제가 아니라 호출 측 결함이다.
+*/
+async function runResetCommand(command) {
+	let tokens;
+	try {
+		tokens = (0, _mcpeak_core.tokenizeCommand)(command);
+	} catch (error) {
+		if (!(error instanceof _mcpeak_core.CommandParseError)) throw error;
+		const reason = {
+			EMPTY_EXECUTABLE: "실행 파일 경로가 비어 있습니다.",
+			UNTERMINATED_EXECUTABLE_QUOTE: "실행 파일을 감싼 큰따옴표가 닫히지 않았습니다.",
+			MISSING_EXECUTABLE_ARGUMENT_SEPARATOR: "실행 파일을 감싼 큰따옴표 뒤에는 공백이 필요합니다."
+		}[error.code];
+		throw new ResetCommandError(command, null, `잘못된 초기화 명령: ${reason}`);
+	}
+	const [file, ...args] = tokens;
+	if (file === void 0) throw new TypeError("초기화 명령이 비어 있습니다.");
+	return new Promise((resolve, reject) => {
+		const stderr = new StderrTail();
+		let timedOut = false;
+		let settled = false;
+		const child = (0, node_child_process.spawn)(file, args, {
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			],
+			shell: false
+		});
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGKILL");
+		}, TIMEOUT_MS);
+		const finish = (settle) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			settle();
+		};
+		child.stderr?.on("data", (chunk) => {
+			stderr.push(chunk);
+		});
+		child.on("error", (error) => {
+			finish(() => {
+				reject(new ResetCommandError(command, null, error.message));
+			});
+		});
+		child.on("close", (code, signal) => {
+			finish(() => {
+				if (timedOut) {
+					reject(new ResetCommandError(command, null, TIMEOUT_STDERR));
+					return;
+				}
+				if (code === 0) {
+					resolve();
+					return;
+				}
+				reject(new ResetCommandError(command, code, stderr.text() || describeSignal(signal)));
+			});
+		});
+	});
+}
+/** stderr 이 비어 있는데 시그널로 죽었으면 그 사실만이라도 남긴다. */
+const describeSignal = (signal) => signal === null ? "" : `시그널 ${signal} 로 종료되었습니다.`;
+//#endregion
+//#region src/generate-command.ts
+var UsageError$1 = class extends Error {};
+/**
+* 출력 경로에 이미 파일이 있어 저장을 멈춘 경우. 다른 I/O 실패와 사용자 조치가 다르므로
+* 타입으로 갈라 둔다. 뭉뚱그리면 "저장하지 못했습니다"만 남아 어떤 파일이 왜 막았는지 모른다.
+*/
+var OutputExistsError = class extends Error {
+	path;
+	constructor(path) {
+		super("output exists");
+		this.path = path;
+	}
+};
+/**
+* 출력 파일 충돌 안내. 경로는 라벨 뒤에 두어 조사가 변수에 붙지 않게 한다.
+*
+* 두 자리에서 같은 코드로 끊는다. 다른 것은 사용자가 무엇을 잃었는지뿐이라 그 한 마디만
+* 갈라 적는다. 선검사는 아직 아무것도 안 했고, 저장 단계는 검토와 시험 실행을 이미 지났다.
+* 설계 문서 §6.
+*/
+function outputExistsFailure(deps, path, stage = "save") {
+	const lost = stage === "start" ? "시작하지" : "저장하지";
+	deps.writeStderr(`오류 [GENERATE_OUTPUT_EXISTS]: 출력 파일이 이미 있어 ${lost} 않았습니다. 경로: ${path}\n해결: 다른 \`--out\` 경로를 지정하거나, 기존 파일을 덮어쓰려면 \`--force\` 를 붙이세요.\n`);
+}
+/**
+* `--force` 인데 기존 출력 파일을 지우지 못한 경우. `ENOENT` 는 원하는 상태와 같으므로
+* 여기 오지 않는다. `GENERATE_FAILED` 로 뭉뚱그리면 사용자가 무엇을 확인해야 할지 모른다.
+*/
+var OutputReplaceError = class extends Error {
+	path;
+	code;
+	constructor(path, code) {
+		super("output replace failed");
+		this.path = path;
+		this.code = code;
+	}
+};
+/**
+* 기존 출력 파일 삭제 실패 안내. 원인을 단정하지 않는다. `--out` 이 디렉터리인지 권한
+* 문제인지 여기서 구분할 수단이 없고, 그것을 알려고 `stat` 을 주입하지 않는다. 설계 문서 §6.
+*/
+function outputReplaceFailure(deps, path, code) {
+	const suffix = code === void 0 ? "" : ` (${code})`;
+	deps.writeStderr(`오류 [GENERATE_OUTPUT_REPLACE_FAILED]: 기존 출력 파일을 지우지 못해 저장하지 않았습니다. 경로: ${path}${suffix}\n해결: 그 경로가 디렉터리이거나 쓰기 권한이 없는지 확인하세요. 다른 \`--out\` 경로를 지정해도 됩니다.\n`);
+}
+/**
+* `generate` 가 이미 만들어 둔 원인을 그대로 보여 준다.
+*
+* `GENERATE_FAILED` 로 뭉개면 사용자는 "MCP 서버와 출력 경로를 확인하세요" 를 보는데,
+* 스키마 거절에서 그건 **틀린 조치다** — 서버도 경로도 멀쩡하다. 실제로 이 결함 때문에
+* 원인을 알아내려고 `generate` 소스를 읽어야 했다 (#136 · `docs/adoption.md` §2.3).
+*/
+function generateTestsFailure(deps, error) {
+	deps.writeStderr(`오류 [${error.code}]: ${error.message} 경로: ${error.path}\n해결: ${error.hint}\n`);
+}
+/**
+* core 의 McpClientError 인지 구조로 확인한다. core 를 import 하지 않는다.
+* `test-command.ts` 의 `coreError` 와 같은 판별인데, 그쪽은 AggregateError 안까지 내려가고
+* 진단을 함께 꺼낸다. 여기 연결 오류는 core 가 직접 던지므로 겉모양 검사로 충분하다.
+*/
+function isCoreClientError(value) {
+	return typeof value === "object" && value !== null && "name" in value && value.name === "McpClientError" && "code" in value && typeof value.code === "string" && "message" in value && typeof value.message === "string" && "hint" in value && typeof value.hint === "string";
+}
+var LinkUnsupportedError = class extends Error {
+	path;
+	code;
+	constructor(path, code) {
+		super("link unsupported");
+		this.path = path;
+		this.code = code;
+	}
+};
+/**
+* hard link 불가 안내. `code`는 위 두 값만 들어오는 닫힌 집합이라 그대로 보여준다.
+* errno 이름은 사용자가 검색할 때 쓰는 단서이고 raw stderr나 인증정보가 아니다.
+* 임의의 오류 문자열을 흘려보내지 않으려고 타입으로 좁혀 뒀다.
+*/
+function linkUnsupportedFailure(deps, path, code) {
+	deps.writeStderr(`오류 [GENERATE_LINK_UNSUPPORTED]: 출력 디렉터리가 hard link를 지원하지 않거나 권한이 없어 저장하지 못했습니다. 경로: ${path} (원인: ${code})\n해결: 로컬 디스크의 다른 디렉터리를 \`--out\`으로 지정한 뒤 다시 저장하세요. 네트워크 마운트(NFS·SMB 일부), FAT/exFAT USB, 컨테이너 바인드 마운트에서 주로 납니다.\n`);
+}
+/** 검토 도중 입력 스트림이 닫혔음을 알리는 sentinel. 사용자 취소와 같은 경로로 처리한다. */
+var ReviewInputClosedError = class extends Error {};
+/**
+* 입력 스트림이 닫혀 발생한 오류인지 판정한다.
+* sentinel 외에 Node readline의 ERR_USE_AFTER_CLOSE도 인정한다. nodeReviewIO가 아닌 ReviewIO
+* 구현이 readline을 직접 감싸도 같은 종료 경로를 타게 하기 위함이다.
+*/
+function isReviewInputClosed(error) {
+	if (error instanceof ReviewInputClosedError) return true;
+	return error?.code === "ERR_USE_AFTER_CLOSE";
+}
+const optionNames$1 = /* @__PURE__ */ new Set([
+	"--suite-id",
+	"--name",
+	"--out",
+	"--command",
+	"--arg",
+	"--baseline-only",
+	"--provider",
+	"--model",
+	"--no-dry-run",
+	"--cassette",
+	"--record",
+	"--reset-cmd",
+	"--no-repair",
+	"--force"
+]);
+/** 값을 받지 않는 옵션. `=` 를 붙여 쓸 수 없고 두 번 쓸 수 없다. */
+const flagNames$1 = /* @__PURE__ */ new Set([
+	"--baseline-only",
+	"--no-dry-run",
+	"--record",
+	"--no-repair",
+	"--force"
+]);
+function optionValue$1(argv, index, option) {
+	const item = argv[index];
+	if (item === void 0) throw new UsageError$1(`\`${option}\` 옵션 값이 필요합니다.`);
+	const equals = item.indexOf("=");
+	if (equals > 0) return [item.slice(equals + 1), index];
+	const value = argv[index + 1];
+	if (value === void 0 || option !== "--arg" && value.startsWith("--")) throw new UsageError$1(`\`${option}\` 옵션 값이 필요합니다.`);
+	return [value, index + 1];
+}
+function parseGenerateCommand(argv) {
+	const values = /* @__PURE__ */ new Map();
+	const args = [];
+	const flags = /* @__PURE__ */ new Set();
+	for (let index = 0; index < argv.length; index++) {
+		const item = argv[index];
+		if (item === void 0) continue;
+		const option = item.includes("=") ? item.slice(0, item.indexOf("=")) : item;
+		if (!option.startsWith("--")) throw new UsageError$1(`추가 위치 인자 '${item}'는 허용되지 않습니다.`);
+		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}\`는 한 번만 사용할 수 있습니다.`);
+			flags.add(option);
+			continue;
+		}
+		const [value, consumed] = optionValue$1(argv, index, option);
+		index = consumed;
+		if (option === "--arg") {
+			args.push(value);
+			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 outPath = values.get("--out");
+	if (!outPath.toLowerCase().endsWith(".json")) throw new UsageError$1("`--out`은 .json 파일이어야 합니다.");
+	const rawProvider = values.get("--provider");
+	if (rawProvider !== void 0 && rawProvider !== "codex" && rawProvider !== "claude") throw new UsageError$1("`--provider`는 codex 또는 claude여야 합니다.");
+	if (values.has("--model") && rawProvider === void 0) throw new UsageError$1("`--model`은 `--provider`와 함께만 사용할 수 있습니다.");
+	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),
+		baselineOnly: flags.has("--baseline-only"),
+		provider: rawProvider,
+		model: values.get("--model"),
+		dryRun,
+		cassettePath,
+		forceRecord: flags.has("--record"),
+		force: flags.has("--force"),
+		resetCmd,
+		repair
+	});
+}
+/**
+* 저장 키 순서는 설계 문서 §3.3이 고정한다. `approval`을 `cases` 앞에 두는 이유는 사람이
+* 파일을 열었을 때 첫 화면에서 보이게 하기 위해서다. 지문 계산은 `canonicalJson`이 키를
+* 정렬하므로 이 순서에 영향받지 않는다. 즉 가독성 결정이지 계약이 아니다.
+*/
+function renderSuite(suite, fingerprint, cases) {
+	const ordered = {
+		schemaVersion: suite.schemaVersion,
+		id: suite.id,
+		name: suite.name,
+		approval: cases.length === 0 ? { fingerprint } : {
+			fingerprint,
+			cases
+		}
+	};
+	if (suite.defaultTimeoutMs !== void 0) ordered.defaultTimeoutMs = suite.defaultTimeoutMs;
+	ordered.cases = suite.cases;
+	return `${JSON.stringify(ordered, null, 2)}\n`;
+}
+let temporarySequence = 0;
+/**
+* 임시 파일 이름은 실행마다 고유해야 한다. 고정 이름이면 같은 디렉터리에서 두 실행이 겹칠 때
+* `openTemp`의 `wx`가 EEXIST로 실패하는데, 그것은 출력 경로 충돌과 전혀 다른 실패다.
+* 저장되는 suite 내용에는 들어가지 않으므로 결정론성 요구와 무관하다.
+*/
+function temporaryPath(outPath) {
+	temporarySequence += 1;
+	return (0, node_path.join)((0, node_path.dirname)(outPath), `.${(0, node_path.basename)(outPath)}.mcpeak.${process.pid}.${temporarySequence}.tmp`);
+}
+async function saveSuite(input, suite, fingerprint, deps, approvals = []) {
+	if (!input.force && await deps.exists(input.outPath)) throw new OutputExistsError(input.outPath);
+	const temporary = temporaryPath(input.outPath);
+	let created = false;
+	try {
+		const handle = await deps.openTemp(temporary);
+		created = true;
+		try {
+			await handle.writeFile(renderSuite(suite, fingerprint, approvals), "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		const bytes = await deps.readFile(temporary);
+		const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+		const validated = deps.validateSuite(parsed);
+		if (!validated.valid || (0, _mcpeak_runner.suiteFingerprint)(validated.value) !== fingerprint || validated.value.approval?.fingerprint !== fingerprint) throw new Error("invalid saved suite");
+		if (input.force) await deps.unlink(input.outPath).catch((error) => {
+			const code = error?.code;
+			if (code === "ENOENT") return;
+			throw new OutputReplaceError(input.outPath, typeof code === "string" ? code : void 0);
+		});
+		try {
+			await deps.link(temporary, input.outPath);
+		} catch (error) {
+			const code = error?.code;
+			if (code === "EEXIST") throw new OutputExistsError(input.outPath);
+			if (code === "EPERM" || code === "ENOTSUP") throw new LinkUnsupportedError(input.outPath, code);
+			throw error;
+		}
+	} finally {
+		if (created) await deps.unlink(temporary).catch(() => void 0);
+	}
+}
+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`);
+}
+const MAX_DIFF_BODY_LINES = 40;
+/**
+* leaf 경로와 JSON 값을 문서 순서(Object.keys 순, 배열 인덱스 순)로 모은다.
+* 정렬하지 않는다. 같은 입력에 항상 같은 출력이 나와야 하고 문서 순서로 그것이 만족된다.
+* 빈 객체와 빈 배열은 그 자체를 leaf로 본다. 그러지 않으면 경로가 조용히 사라진다.
+*/
+function leaves(value, prefix = "") {
+	if (Array.isArray(value)) {
+		if (value.length === 0) return [[prefix, "[]"]];
+		return value.flatMap((item, index) => leaves(item, `${prefix}[${index}]`));
+	}
+	if (value !== null && typeof value === "object") {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return [[prefix, "{}"]];
+		return entries.flatMap(([key, nested]) => leaves(nested, prefix === "" ? key : `${prefix}.${key}`));
+	}
+	return [[prefix, JSON.stringify(value) ?? "undefined"]];
+}
+/** before/after의 leaf를 비교해 다른 경로만 남긴다. 같은 경로의 -와 +는 붙여서 쓴다. */
+function changedLeaves(before, after) {
+	const afterLeaves = leaves(after);
+	const afterByPath = new Map(afterLeaves);
+	const lines = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [path, value] of leaves(before)) {
+		seen.add(path);
+		if (!afterByPath.has(path)) {
+			lines.push(`- ${path}: ${value}`);
+			continue;
+		}
+		const next = afterByPath.get(path);
+		if (next === value) continue;
+		lines.push(`- ${path}: ${value}`, `+ ${path}: ${next}`);
+	}
+	for (const [path, value] of afterLeaves) if (!seen.has(path)) lines.push(`+ ${path}: ${value}`);
+	return lines;
+}
+function diffBody(change) {
+	switch (change.type) {
+		case "addCase": return leaves(change.case).map(([path, value]) => `+ ${path}: ${value}`);
+		case "removeCase": return leaves(change.case).map(([path, value]) => `- ${path}: ${value}`);
+		case "caseOrder": return [`- ${change.before.join(", ")}`, `+ ${change.after.join(", ")}`];
+		default: return changedLeaves(change.before, change.after);
+	}
+}
+function showDiff(io, preview) {
+	if (preview.changes.length === 0) {
+		io.write("AI가 제안한 변경이 없습니다.\n  → 원하는 케이스를 `AI 요청:`에 구체적으로 적어 다시 물어보세요.\n  → 지금 상태로 저장하려면 save를 고르세요.\n");
+		return;
+	}
+	for (const change of preview.changes) {
+		const body = diffBody(change);
+		const shown = body.length > MAX_DIFF_BODY_LINES ? [...body.slice(0, MAX_DIFF_BODY_LINES), `... 이하 ${body.length - MAX_DIFF_BODY_LINES}줄 생략. 전체는 저장 후 JSON을 확인하세요.`] : body;
+		io.write(`${change.id} ${change.type}${"caseId" in change ? ` ${change.caseId}` : ""}\n` + shown.map((line) => `  ${line}\n`).join(""));
+	}
+}
+/**
+* 머리글 하나와 그 아래 케이스별 문장을 찍는다. finding 이 없으면 아무것도 안 찍는다.
+* `byCase` 순회는 `Map` 삽입 순서이고 그것이 곧 `runner` 가 정한 finding 순서다. 정렬하지
+* 않는다. 여기서 다시 정렬하면 같은 명세가 화면마다 다른 순서로 보인다.
+*/
+function writeFindingBlock(io, diff, heading, findings) {
+	if (findings.length === 0) return;
+	const byCase = /* @__PURE__ */ new Map();
+	for (const finding of findings) {
+		const list = byCase.get(finding.caseId) ?? [];
+		list.push(finding);
+		byCase.set(finding.caseId, list);
+	}
+	io.write(`${heading} ${findings.length}건 (선택한 변경 기준)\n`);
+	for (const [caseId, list] of byCase) {
+		const change = diff.changes.find((item) => "caseId" in item && item.caseId === caseId);
+		io.write(`  → ${change?.id ?? ""} ${caseId}\n`);
+		for (const finding of list) io.write(`     ${(0, _mcpeak_runner.describeSpecFinding)(finding)}\n`);
+	}
+}
+/**
+* 선택한 change 의 caseId 집합에 걸린 finding 만 뽑는다. 순서는 재정렬하지 않는다.
+* runner 가 정한 순서가 곧 사양이고, 여기서 다시 정렬하면 화면마다 순서가 갈린다.
+*
+* caseId 가 없는 change 종류(suiteMetadata · caseOrder)는 집합에 아무것도 넣지 않는다.
+* 위반 케이스를 선택에서 뺐으면 경고할 이유가 없다.
+*/
+function findingsForSelection(candidate, preview, selectedChangeIds) {
+	const ids = new Set(selectedChangeIds);
+	const caseIds = new Set(preview.changes.filter((change) => ids.has(change.id) && "caseId" in change).map((change) => change.caseId));
+	return [...candidate.specFindings.inputContract.findings, ...candidate.specFindings.assertionSubstance.findings].filter((finding) => caseIds.has(finding.caseId));
+}
+/**
+* 선택한 변경에 걸린 위반을 두 블록으로 갈라 찍고, 위반이 있으면 재확인을 하나 더 받는다.
+* 반환값이 false 면 적용을 멈추고 메뉴로 돌아간다.
+*
+* 두 검사를 한 머리글 아래 합치지 않는다. `VACUOUS_MIN_LENGTH` 는 입력 문제가 아니라 단언
+* 문제인데 `입력 계약 위반` 아래 붙으면 읽는 사람이 입력을 고치러 간다. 화면에 찍히는 문장이
+* 곧 제품이므로 어디를 고쳐야 하는지가 머리글에서 갈려야 한다.
+*
+* 재확인은 하나만 받는다. 개수는 두 종류의 합이다. 종류마다 확인을 받으면 화면만 길어지고
+* 사용자가 내리는 판단은 여전히 "그래도 적용할까" 하나다.
+*
+* 거부하지 않고 재확인만 받는다. 서버가 inputSchema 를 느슨하게 선언하면 정상 명세도
+* UNDECLARED_FIELD 로 걸리므로, 거부하면 옳은 명세를 저장할 길이 막힌다.
+*/
+async function confirmSpecFindings(io, candidate, diff, selected) {
+	const findings = findingsForSelection(candidate, diff, selected);
+	const grouped = (group) => findings.filter((finding) => FINDING_GROUP[finding.code] === group);
+	const inputContract = grouped("inputContract");
+	const assertionSubstance = grouped("assertionSubstance");
+	const rejectionIntent = grouped("rejectionIntent");
+	const skipped = grouped("skipped").length;
+	writeFindingBlock(io, diff, "입력 계약 위반", inputContract);
+	writeFindingBlock(io, diff, "항상 통과하는 단언", assertionSubstance);
+	writeFindingBlock(io, diff, "거절 근거가 불분명한 케이스", rejectionIntent);
+	if (skipped > 0) io.write(`  → 해석하지 못한 서버 스키마 ${skipped}건은 검사에서 빠졌습니다.\n`);
+	const total = inputContract.length + assertionSubstance.length;
+	if (total === 0) return true;
+	return io.confirm(`위반 ${total}건이 남아 있습니다. 그래도 적용합니까?`);
+}
+function safeFailure(deps, code) {
+	deps.writeStderr(`오류 [GENERATE_${code}]: AI 검토 요청을 완료하지 못했습니다.\n해결: 입력과 provider 상태를 확인한 뒤 메뉴에서 다시 요청하세요.\n`);
+}
+/** provider별 로그인 확인 명령. 두 provider의 명령을 함께 찍으면 사용자가 헛수고한다. */
+const authCommand = (provider) => provider === "codex" ? "codex login status" : "claude /status";
+/**
+* nonZeroExit의 reason별 안내. reason은 nonZeroExit 경로에서만 채워지는 닫힌 enum이며,
+* 값이 없으면 원인을 모르는 것이므로 추측하지 않고 확인할 것을 모두 알려준다.
+*
+* 문구 규칙: 변수 바로 뒤에 조사를 붙이지 않는다. 한국어 조사는 앞말의 받침에 따라 형태가
+* 갈리는데(을/를, 으로/로) 모델 이름과 종료 코드는 어떤 값이 올지 모른다. 어느 쪽으로 고정해도
+* 반드시 틀리는 경우가 생기므로 `모델: {model}`처럼 라벨을 붙이거나 `명령으로`처럼 고정된
+* 명사를 끼워 조사가 앞말에 의존하지 않게 한다.
+*/
+function exitMessage(failure, model) {
+	const id = failure.providerId;
+	const fallback = defaultModel(id);
+	switch (failure.reason) {
+		case "unknownModel": return `오류 [GENERATE_PROVIDER_MODEL]: ${id}가 이 모델을 사용할 수 없습니다. 모델: ${model}\n해결: 모델 이름을 확인하세요. 이 계정에서 쓸 수 없는 모델일 수도 있습니다. ${id} 기본값은 ${fallback}입니다.\n`;
+		case "notAuthenticated": return `오류 [GENERATE_PROVIDER_AUTH]: ${id} 인증이 유효하지 않습니다.\n해결: \`${authCommand(id)}\` 명령으로 로그인 상태를 확인한 뒤 다시 요청하세요.\n`;
+		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`;
+		default: return `오류 [GENERATE_PROVIDER_EXIT]: ${id}가 종료했습니다. ${failure.exitCode === void 0 ? "" : `종료 코드: ${failure.exitCode}, `}모델: ${model}\n해결: \`${authCommand(id)}\` 명령으로 로그인 상태를 확인하고, 모델 이름이 맞는지 확인하세요.\n`;
+	}
+}
+/**
+* provider 실패를 원인별 안내로 분기한다. 사용자 조치가 다르므로 문구를 나눈다.
+* 먼저 failure.code로 갈리고, nonZeroExit은 exitMessage에서 reason으로 한 겹 더 갈린다.
+* failure를 알 수 없는 경로(dispatch 자체가 throw)는 기존 GENERATE_PROVIDER_FAILED를 유지한다.
+*/
+function providerFailure(deps, failure, model) {
+	if (!failure) {
+		safeFailure(deps, "PROVIDER_FAILED");
+		return;
+	}
+	const id = failure.providerId;
+	const message = (() => {
+		switch (failure.code) {
+			case "providerUnavailable": return `오류 [GENERATE_PROVIDER_UNAVAILABLE]: ${id} CLI를 실행할 수 없습니다.\n해결: \`${id} --version\` 명령으로 설치와 PATH를 확인한 뒤 다시 요청하세요.\n`;
+			case "nonZeroExit": return exitMessage(failure, model);
+			case "timedOut": return `오류 [GENERATE_PROVIDER_TIMEOUT]: ${id} 응답이 ${failure.timeoutMs}ms 안에 오지 않았습니다.\n해결: 도구 수를 줄이거나 timeout을 늘려 다시 요청하세요.\n`;
+			case "schemaMismatch": return `오류 [GENERATE_PROVIDER_SCHEMA]: ${id}가 요구한 형식과 다른 결과를 돌려줬습니다.\n해결: 다시 요청하세요. 반복되면 다른 provider로 바꿔 시도하세요.\n`;
+			case "cancelled": return "오류 [GENERATE_PROVIDER_CANCELLED]: AI 검토 요청이 취소됐습니다.\n해결: 메뉴에서 다시 요청하세요.\n";
+			default: return;
+		}
+	})();
+	if (message === void 0) safeFailure(deps, "PROVIDER_FAILED");
+	else deps.writeStderr(message);
+}
+/**
+* 시험 실행 화면이 쓰는 서버 stderr 줄 수. `test` 의 `--stderr-lines` 기본값과 같은 값이다.
+* `generate` 에는 그 옵션이 없으므로 기본값 하나만 둔다.
+*/
+const DRY_RUN_STDERR_LINES = 20;
+/**
+* 실패 케이스 머리글. 결과 화면(§8.2)과 분류 화면(dry-run-review.ts, §8.3)이 **같은 모양**이어야
+* 한다. 두 화면이 같은 케이스를 다르게 부르면 사용자가 둘을 대조하지 못한다.
+*/
+const failureHeading = (index, caseName) => `  [${index + 1}] ${caseName}\n`;
+/**
+* `renderReport` 가 만든 케이스 블록을 이 화면 들여쓰기로 옮긴다. 두 칸을 앞에 붙이기만 하고
+* 문장은 건드리지 않는다. dry-run-review.ts 의 같은 처리와 규칙이 같다.
+*/
+const detailBlock = (detail) => detail === "" ? "" : `${detail.split("\n").map((line) => `  ${line}`).join("\n")}\n`;
+/** 시험 실행 고지(§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");
+	io.write("\n이 실행은 서버 상태를 바꿀 수 있습니다. 입력 검증이 없는 서버라면 외부 API 호출도\n그대로 나갑니다.\n");
+}
+/** 시험 실행 결과(§8.2). 0건인 종류는 찍지 않는다. */
+function writeDryRunResult(io, result) {
+	const failures = result.outcomes.filter((outcome) => outcome.status !== "passed");
+	const passed = result.outcomes.length - failures.length;
+	io.write("\n");
+	if (passed > 0) io.write(`  ✓ 통과 ${passed}건\n`);
+	if (failures.length > 0) io.write(`  ✗ 실패 ${failures.length}건\n`);
+	for (const [index, outcome] of failures.entries()) {
+		io.write("\n");
+		io.write(failureHeading(index, outcome.caseName));
+		io.write(detailBlock(outcome.detail));
+	}
+	if (failures.length > 0) io.write("\n");
+}
+/**
+* 거절 근거 미확인 목록 (#89 · 설계 문서 §5.2). 시험 실행 결과 블록 바로 아래에 붙는다.
+*
+* **이 케이스들은 통과했다.** 목록은 판정도 저장 여부도 바꾸지 않는다. `unverified` 는
+* "거절이 아니다" 가 아니라 "확인하지 못했다" 는 뜻이라, 문장이 실패나 결함이라고 말하지 않고
+* 무엇을 확인하지 못했는지만 적는다. 0건이면 아무것도 안 찍는다.
+*
+* 응답 본문은 `escapeTerminalText` 를 그대로 쓴다. 그 함수가 개행(0x0a)까지 이스케이프하므로
+* 여러 줄 응답이 한 줄이 되고 제어 문자도 함께 무해해진다. 자르기는 `runner` 가 이미 진단 값과
+* 같은 상한에서 했다(`clampObservedText`). 여기서 규칙을 새로 만들지 않는다.
+*/
+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 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);
+		io.write(`  → ${id}${pad}   응답: ${body}\n`);
+	}
+	io.write("  이 응답이 서버의 정상 거절인지 내부 오류인지 확인하지 못했습니다.\n\n");
+}
+/**
+* `verdict` 를 화면 문구로 옮긴다. `Record` 라서 `RejectionVerdict` 가 늘면 여기서 타입 오류가
+* 난다. 문자열 배열로 두면 새 값이 조용히 빠지고, 이 화면에서 누락은 "판단이 없었다" 로 읽힌다.
+*/
+const VERDICT_LABEL = {
+	rejected: "거절로 보임",
+	crashed: "서버 내부 오류로 보임",
+	unsure: "판단 불가"
+};
+/**
+* AI 진단 결과를 찍는다. 문안은 설계 문서 §6.4 가 고정한다.
+*
+* **마지막 줄을 빼면 안 된다.** AI 답변이 판정으로 읽히면 사용자가 초록·빨강을 잘못 해석한다.
+*/
+function writeRejectionDiagnosis(io, requested, results) {
+	io.write(`\n거절 근거 미확인 ${requested}건에 대해 AI 진단을 요청했습니다.\n\n`);
+	const ids = results.map((item) => escapeTerminalText$1(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("\n이 진단은 참고입니다. 케이스 판정과 저장 여부를 바꾸지 않습니다.\n\n");
+}
+/**
+* 확인 못 한 케이스를 AI 에게 물을지 사람에게 묻고, 답을 받으면 화면에 찍는다 (#89 · §6).
+*
+* 아무것도 안 하고 조용히 지나가는 경우가 셋이다. provider 가 없을 때(대다수 사용자),
+* 확인 못 한 케이스가 없을 때, 물어볼 본문이 하나도 없을 때다. 그때는 질문 자체를 안 한다.
+*
+* **본문이 없는 케이스는 진단에서 뺀다.** 호출이 오류로 끝나 응답이 아예 없는 케이스가 있는데
+* (설계 문서 §4.2), 그것을 빈 문자열로 채워 물으면 AI 에게 판단 재료가 없고 지어낸 `verdict`
+* 만 돌아온다. 뺀 사실은 화면에 남긴다 — 몇 건을 왜 못 물었는지가 사용자의 판단 재료다.
+*
+* 실패는 흐름을 끊지 않는다. 안내만 찍고 승인 화면이 이어진다. 진단은 참고이지 전제가 아니다.
+*/
+async function askRejectionDiagnosis(options) {
+	const { io, deps, provider } = options;
+	const prepare = deps.prepareRejectionDiagnosisRequests;
+	const dispatch = deps.dispatchRejectionDiagnosis;
+	if (provider === void 0 || prepare === void 0 || dispatch === void 0) return;
+	const unverified = options.result.outcomes.filter((outcome) => outcome.rejectionBasis === "unverified");
+	if (unverified.length === 0) return;
+	const cases = unverified.flatMap((outcome) => {
+		if (outcome.rejectionBody === void 0) return [];
+		const spec = options.suite.cases.find((item) => item.id === outcome.caseId);
+		if (spec === void 0 || !isCallTool(spec)) return [];
+		const schema = options.tools.find((tool) => tool.name === spec.operation.tool)?.inputSchema;
+		return [{
+			caseId: outcome.caseId,
+			tool: spec.operation.tool,
+			input: spec.operation.input,
+			inputSchema: typeof schema === "object" && schema !== null && !Array.isArray(schema) ? schema : {},
+			responseBody: outcome.rejectionBody,
+			basis: "unverified"
+		}];
+	});
+	const skipped = unverified.length - cases.length;
+	if (cases.length === 0) {
+		io.write(`  응답 본문이 없어 ${skipped}건 전부를 AI 에게 물을 수 없습니다. 진단을 건너뜁니다.\n\n`);
+		return;
+	}
+	if (skipped > 0) io.write(`  응답 본문이 없는 ${skipped}건은 진단에서 제외합니다. AI 에게 줄 근거가 없습니다.\n`);
+	io.write("  ※ 응답 본문은 서버가 자유롭게 쓰는 텍스트라 경로·토큰·데이터가 섞일 수 있습니다.\n    값 치환을 적용하지 않습니다.\n");
+	if (!await io.confirm(`  나머지 ${cases.length}건의 진단을 AI 에게 요청할까요?`)) return;
+	let requests;
+	try {
+		requests = prepare({ cases });
+	} catch (error) {
+		if (!(error instanceof RangeError)) throw error;
+		io.write(`  진단 요청이 크기 상한(256KB)을 넘어 보내지 못했습니다. 미확인 ${cases.length}건의 입력 스키마와 응답을 합친 크기입니다.\n  해결: 툴 수가 적은 명세로 나눠 생성한 뒤 다시 시도하세요. 케이스 판정과 저장에는 영향이 없습니다.
+
+`);
+		return;
+	}
+	const dispatched = await dispatch({
+		provider,
+		requests
+	});
+	if (dispatched.type === "failed") {
+		providerFailure(deps, dispatched.failure, options.model);
+		return;
+	}
+	writeRejectionDiagnosis(io, cases.length, dispatched.results);
+}
+/**
+* 반영 요약(§8.8). 저장 확인 직전에 찍는다. 교정이 0건이면 아무것도 찍지 않는다.
+* 지문이 바뀐 이유가 화면에 남아야 사용자가 나중에 diff 를 보고 놀라지 않는다(§5.4).
+*/
+function writeRepairSummary(io, repairedCases, changes) {
+	if (repairedCases === 0) return;
+	io.write(`  입력값 교정 ${repairedCases}건이 명세에 반영되었습니다.\n`);
+	for (const change of changes) io.write(`    ${change.tool}.${change.field}: ${JSON.stringify(change.before)} → ${JSON.stringify(change.after)}\n`);
+}
+/**
+* 교정 대상 판별에 넘길 provenance. `approvedDraft.provenance` 가 유일한 출처다.
+* 여기서 비면 사용자가 손으로 쓴 케이스까지 교정 대상이 되므로(§4.2 의 기본값이
+* `schemaBaseline` 이다) 세션이 실제로 싣는 값을 그대로 쓴다.
+*/
+const originsOf = (session) => new Map(session.approvedDraft.provenance.map((item) => [item.caseId, item.origin]));
+/**
+* 입력값을 가진 케이스인가. 중첩 필드로는 판별 유니온이 좁혀지지 않아 술어로 뽑는다.
+* 교정은 `callTool` 케이스에만 있다(§4.2).
+*/
+const isCallTool = (spec) => spec.operation.type === "callTool";
+/** 실제로 값이 바뀐 필드만 §8.8 줄로 만든다. 안 바뀐 필드까지 적으면 요약이 사실과 달라진다. */
+const repairApplications = (suite, repaired) => {
+	const changes = [];
+	for (const item of suite.cases) {
+		const input = repaired.get(item.id);
+		if (input === void 0 || !isCallTool(item)) continue;
+		for (const [field, after] of Object.entries(input)) {
+			const before = item.operation.input[field];
+			if (JSON.stringify(before) === JSON.stringify(after)) continue;
+			changes.push({
+				tool: item.operation.tool,
+				field,
+				before,
+				after
+			});
+		}
+	}
+	return changes;
+};
+/** 교정으로 통과한 값을 케이스에 얹은 후보 명세. `cli` 는 이 객체를 만들기만 하고 반영은 §5 의 3단 경로가 한다. */
+const withRepairedInputs = (suite, repaired) => ({
+	...suite,
+	cases: suite.cases.map((item) => {
+		const input = repaired.get(item.id);
+		if (input === void 0 || !isCallTool(item)) return item;
+		return {
+			...item,
+			operation: {
+				...item.operation,
+				input
+			}
+		};
+	})
+});
+/**
+* 시험 실행이 끝까지 못 간 경우(§8.4). stderr 블록은 단계 1 의 `renderProcessDiagnostics` 를
+* 그대로 쓴다. 여기서 새 렌더러를 만들지 않는다.
+*
+* `outcomes.length` 가 곧 "몇 번째에서 끊겼는가" 다. dry-run.ts 가 끊긴 케이스까지 담아 주므로
+* 여기서 더하거나 빼지 않는다.
+*/
+function writeDryRunAborted(io, result, totalCases, diagnostics) {
+	const aborted = result.aborted;
+	if (aborted === void 0) return;
+	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 });
+		if (block !== "") io.write(`\n${block}`);
+	}
+	io.write("\n저장하지 않았습니다. 서버를 고친 뒤 다시 save 를 고르세요.\n");
+}
+/**
+* 분류가 저장을 막았을 때의 안내(§8.3). 마지막 줄은 **실제 카세트 모드**로 갈린다.
+*
+* 재생은 `auto` 에서만 일어난다. 신규 녹화(`record`)는 회차마다 전량을 다시 서버로 보내므로
+* "나머지는 카세트에서 재생됩니다" 가 거짓이 된다. 그래서 경로 유무가 아니라 `wireCassette`
+* 가 정한 모드를 받는다.
+*/
+function writeReviewBlocked(io, specErrors, caseCount, cassetteMode) {
+	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) {
+	const exit = error.exitCode === null ? "없음" : String(error.exitCode);
+	io.write(`✗ 초기화 명령이 실패했습니다. 명령: ${error.command} (종료 코드: ${exit})\n`);
+	for (const line of error.stderr.split("\n").filter(Boolean).slice(-3)) io.write(`  → ${line}\n`);
+	io.write("저장하지 않았습니다. 초기화 명령을 고친 뒤 다시 save 를 고르세요.\n");
+}
+async function runInteractiveReview(input, tools, session, deps, connection, skippedTools = []) {
+	const io = deps.reviewIO;
+	const prepare = deps.prepareAuthoringRequest;
+	const dispatch = deps.dispatchAuthoringRequest;
+	const makeDiff = deps.createAuthoringDiff;
+	const apply = deps.applyAuthoringChanges;
+	const reviewLocal = deps.reviewLocalAuthoringCandidate;
+	if (!io?.interactive || !prepare || !dispatch || !makeDiff || !apply || !reviewLocal) {
+		safeFailure(deps, "INTERACTIVE_REQUIRED");
+		return 1;
+	}
+	let candidate = session.workingCandidate;
+	let preferred = input.provider;
+	let model = input.model;
+	/**
+	* 카세트 배선은 검토 세션에 하나뿐이고 `save` 를 여러 번 골라도 같은 것을 쓴다. 시도마다 새로
+	* 만들면 저장이 막힌 첫 시도의 녹화가 통째로 버려지고, "고친 케이스만 서버에 다시 나갑니다"
+	* (§8.3)가 거짓이 된다. flush 는 저장에 성공한 뒤 한 번만 부른다.
+	*/
+	let cassette;
+	/** 이미 화면에 낸 카세트 경고 수. 배선이 세션당 하나라 경고도 누적된다. 회차마다 새것만 낸다. */
+	let printedWarnings = 0;
+	/** 진단 읽기가 판정을 바꾸면 안 된다. getDiagnostics 가 던지면 삼킨다. */
+	const diagnostics = () => {
+		try {
+			return connection.getDiagnostics();
+		} catch {
+			return;
+		}
+	};
+	try {
+		while (true) {
+			const action = await io.choose("검토 메뉴", [
+				"codex",
+				"claude",
+				"apply-all",
+				"select",
+				"revise",
+				"edit",
+				"save",
+				"cancel"
+			]);
+			if (action === "cancel") return 0;
+			if (action === "save") {
+				const dryRunSuite = session.approvedDraft.suite;
+				const caseCount = dryRunSuite.cases.length;
+				let approvals = [];
+				/** 교정으로 통과한 케이스 수와 바뀐 값. 반영 요약(§8.8)이 쓴다. */
+				let repairedCases = 0;
+				let repairChanges = [];
+				if (!input.dryRun) {
+					io.write(`⚠ 시험 실행을 건너뜁니다. 케이스 ${caseCount}건이 실제 서버에서 확인되지 않은 채 저장됩니다.\n   저장된 명세에 승인 기록(approval.cases)이 남지 않습니다.
+`);
+					if (!await io.confirm("   계속할까요?")) continue;
+				} else {
+					const path = input.cassettePath;
+					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"
+						} },
+						resetCmd: input.resetCmd,
+						repair: input.repair
+					});
+					if (!await io.confirm("계속할까요?")) continue;
+					if (input.resetCmd !== void 0) {
+						try {
+							await runResetCommand(input.resetCmd);
+						} catch (error) {
+							if (!(error instanceof ResetCommandError)) throw error;
+							writeResetFailure(io, error);
+							continue;
+						}
+						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,
+						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;
+					}
+					writeDryRunResult(io, result);
+					writeRejectionUnverified(io, result);
+					await askRejectionDiagnosis({
+						io,
+						deps,
+						result,
+						suite: dryRunSuite,
+						tools,
+						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,
+						origins: originsOf(session)
+					}) : [];
+					let attempts;
+					let effective = result;
+					if (targets.length > 0) {
+						const repairs = await repairInputs({
+							io,
+							suite: dryRunSuite,
+							targets,
+							tools,
+							rerun: async (caseId, value) => {
+								const spec = dryRunSuite.cases.find((item) => item.id === caseId);
+								if (spec === void 0 || !isCallTool(spec)) return {
+									passed: false,
+									detail: ""
+								};
+								const one = await runDryRun({
+									client: wired.client,
+									suite: {
+										...dryRunSuite,
+										cases: [{
+											...spec,
+											operation: {
+												...spec.operation,
+												input: value
+											}
+										}]
+									}
+								});
+								if (one.aborted !== void 0) return {
+									passed: false,
+									detail: ""
+								};
+								const outcome = one.outcomes[0];
+								return {
+									passed: outcome?.status === "passed",
+									detail: outcome?.detail ?? ""
+								};
+							},
+							propose: repairProvider === void 0 ? void 0 : (target) => proposeRepair({
+								target,
+								session,
+								tools,
+								provider: repairProvider,
+								prepare,
+								dispatch
+							})
+						});
+						const repaired = new Map(repairs.filter((item) => item.repaired && item.input !== void 0).map((item) => [item.caseId, item.input]));
+						attempts = new Map(repairs.filter((item) => !item.repaired && item.attempts.length > 0).map((item) => [item.caseId, item.attempts]));
+						if (repaired.size > 0) {
+							repairedCases = repaired.size;
+							repairChanges = repairApplications(dryRunSuite, repaired);
+							const local = reviewLocal({
+								session,
+								candidate: withRepairedInputs(dryRunSuite, repaired),
+								tools
+							});
+							if (local.status !== "preview") {
+								io.write("교정한 값을 명세에 반영하지 못했습니다.\n");
+								continue;
+							}
+							const diff = makeDiff({
+								session,
+								candidate: local.preview
+							});
+							if (!apply({
+								session,
+								preview: diff,
+								selectedChangeIds: diff.changes.map((change) => change.id),
+								approval: {
+									approved: true,
+									fingerprint: diff.candidateFingerprint
+								}
+							}).applied) {
+								io.write("교정한 값을 명세에 반영하지 못했습니다.\n");
+								continue;
+							}
+						}
+						effective = {
+							...result,
+							outcomes: result.outcomes.map((outcome) => repaired.has(outcome.caseId) ? {
+								...outcome,
+								status: "passed",
+								detail: ""
+							} : 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);
+						continue;
+					}
+					approvals = review.approvals;
+				}
+				const fingerprint = session.approvedDraft.suiteFingerprint;
+				io.write(`Final fingerprint: ${fingerprint}\n`);
+				writeRepairSummary(io, repairedCases, repairChanges);
+				if (!await io.confirm("최종 JSON을 저장할까요?")) continue;
+				const final = deps.finalizeAuthoringDraft({
+					session,
+					approval: {
+						approved: true,
+						fingerprint
+					}
+				});
+				if (!final.finalized) {
+					safeFailure(deps, "FINALIZE_FAILED");
+					continue;
+				}
+				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,
+						tools: tools.filter((_tool, index) => !skippedIndexes.has(index))
+					}), finalSuite, skippedTools);
+					return 0;
+				} catch (error) {
+					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 safeFailure(deps, "SAVE_FAILED");
+					continue;
+				}
+			}
+			if (action === "apply-all" || action === "select") {
+				if (!candidate) {
+					io.write("적용할 candidate가 없습니다.\n");
+					continue;
+				}
+				const diff = makeDiff({
+					session,
+					candidate
+				});
+				showDiff(io, diff);
+				const selected = action === "apply-all" ? diff.changes.map((change) => change.id) : (await io.input("적용할 change ID를 쉼표로 입력하세요: ")).split(",").map((id) => id.trim()).filter(Boolean);
+				if (!await confirmSpecFindings(io, candidate, diff, selected)) continue;
+				if (!await io.confirm("선택한 변경을 적용할까요?")) continue;
+				const result = apply({
+					session,
+					preview: diff,
+					selectedChangeIds: selected,
+					approval: {
+						approved: true,
+						fingerprint: diff.candidateFingerprint
+					}
+				});
+				if (!result.applied) io.write(`변경을 적용하지 않았습니다: ${result.reason}\n`);
+				else io.write(`revision ${result.draft.revision}을 승인했습니다.\n`);
+				continue;
+			}
+			if (action === "edit") {
+				const path = await io.input("편집한 JSON 파일 경로: ");
+				try {
+					const result = reviewLocal({
+						session,
+						candidate: JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(await deps.readFile(path))),
+						tools
+					});
+					if (result.status === "preview") {
+						candidate = result.preview;
+						showDiff(io, makeDiff({
+							session,
+							candidate
+						}));
+					} else io.write("편집한 JSON을 candidate로 사용할 수 없습니다.\n");
+				} catch {
+					safeFailure(deps, "LOCAL_JSON_INVALID");
+				}
+				continue;
+			}
+			const providerId = action === "revise" ? preferred : action;
+			if (providerId !== "codex" && providerId !== "claude") {
+				io.write("지원하지 않는 메뉴입니다.\n");
+				continue;
+			}
+			if (action !== "revise" && providerId !== preferred) model = input.provider === providerId ? input.model : void 0;
+			preferred = providerId;
+			model = (model ?? await io.input(`${providerId} model (${defaultModel(providerId)}): `)) || defaultModel(providerId);
+			const provider = deps.providers?.[providerId]?.(model);
+			if (!provider) {
+				io.write(`${providerId} provider를 사용할 수 없습니다.\n`);
+				continue;
+			}
+			const instruction = await io.input(action === "revise" ? "피드백: " : "AI 요청: ");
+			const preview = prepare({
+				mode: action === "revise" ? "revise" : "initial",
+				instruction,
+				baseline: session.baseline.suite,
+				candidate: candidate?.result.suite ?? session.baseline.suite,
+				tools,
+				providerId,
+				model
+			});
+			showRequest(io, preview);
+			if (!await io.confirm("이 요청을 전송할까요?")) continue;
+			let result;
+			try {
+				result = await dispatch({
+					provider,
+					preview,
+					approval: {
+						approved: true,
+						fingerprint: preview.fingerprint
+					},
+					session
+				});
+			} catch {
+				providerFailure(deps, void 0, model);
+				continue;
+			}
+			if (result.status === "preview") {
+				candidate = result.preview;
+				showDiff(io, makeDiff({
+					session,
+					candidate
+				}));
+			} else if (result.status === "questions") io.write(`질문:\n${result.questions.join("\n")}\n`);
+			else if (result.status === "providerFailed") providerFailure(deps, result.failure, model);
+			else io.write("AI 결과를 검토 후보로 사용할 수 없습니다.\n");
+		}
+	} catch (error) {
+		if (!isReviewInputClosed(error)) throw error;
+		deps.writeStdout("입력이 종료되어 검토를 취소했습니다. 저장하지 않았습니다.\n");
+		return 0;
+	} finally {
+		io.close?.();
+	}
+}
+/**
+* 축 종류를 사람 문장으로 바꾼다. `Record<ContractAxisKind, string>` 이라서 `runner` 가 축을
+* 늘리면 여기서 타입 오류가 난다. 문자열 배열로 두면 새 축이 화면에서 조용히 사라지고,
+* **이 화면에서 누락은 "검증했다" 로 읽힌다.** `FINDING_GROUP` 이 같은 이유로 같은 형태다.
+*/
+const AXIS_LABEL = {
+	HAPPY_PATH: "선언을 지킨 입력에 정상 응답",
+	REQUIRED_OMITTED: "필수 필드 누락 거절",
+	TYPE_VIOLATION: "타입 위반 거절",
+	ENUM_VIOLATION: "선언되지 않은 값 거절",
+	RANGE_VIOLATION: "선언된 범위 밖 값 거절"
+};
+/**
+* runner 보고서 상한(1MB)에 닿기 전에 알리는 임계.
+*
+* 케이스당 보고서가 관측 범위에서 300~600 바이트다. 600 으로 계산해도 1500 케이스면 900KB 로
+* DEFAULT_MAX_REPORT_BYTES(1MB) 안에 들어간다. 그보다 크면 사용자가 조치할 시간이 필요하다.
+* 이 상한은 올릴 수 없다(resolvePayloadLimits 가 기본값을 최대치로 쓴다).
+*/
+const CASE_COUNT_WARNING_THRESHOLD = 1500;
+/**
+* 터미널 표시 폭. 한글은 두 칸을 차지하므로 문자 수로 맞추면 열이 어긋난다.
+* 화면 정렬이 목적이므로 코드 포인트 단위로 세고 넓은 글자만 2로 계산한다.
+*/
+function displayWidth(text) {
+	let width = 0;
+	for (const char of text) {
+		const code = char.codePointAt(0) ?? 0;
+		width += code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 ? 2 : 1;
+	}
+	return width;
+}
+/** 표시 폭 기준 오른쪽 공백 채우기. 이미 넓으면 그대로 둔다. */
+function padToWidth(text, width) {
+	const padding = width - displayWidth(text);
+	return padding > 0 ? text + " ".repeat(padding) : text;
+}
+/** 축 하나를 사람이 읽는 문장으로. 필드가 없는 축(HAPPY_PATH)은 종류만 적는다. */
+function axisLabel(kind, field) {
+	return field === null ? AXIS_LABEL[kind] : `${field} 의 ${AXIS_LABEL[kind]}`;
+}
+/** 툴 한 개의 줄과 그 아래 들여쓴 줄들. */
+function coverageToolLines(tool, nameWidth) {
+	const head = `  ${padToWidth(tool.tool, nameWidth)}`;
+	if (!tool.analyzable) return [
+		`${head}해석 불가`,
+		`    → 입력 스키마를 해석하지 못해 이 툴의 축을 세지 못했습니다 (${tool.unanalyzableReason ?? "schema"})`,
+		"    → 이 툴은 커버리지 숫자에 들어가지 않습니다"
+	];
+	const labels = tool.axes.filter((axis) => axis.caseId === null).map((axis) => axisLabel(axis.kind, axis.field));
+	const labelWidth = Math.max(0, ...labels.map(displayWidth)) + 5;
+	const lines = [`${head}${tool.verified}/${tool.total}`];
+	for (const label of labels) lines.push(`    ? ${padToWidth(label, labelWidth)}미검증`);
+	if (tool.unanalyzedFields.length > 0) lines.push(`    → 해석 못 한 필드 ${tool.unanalyzedFields.length}개: ${tool.unanalyzedFields.join(", ")}. 이 필드의 축은 세지 않았습니다`);
+	return lines;
+}
+/**
+* 커버리지 화면. 순수 함수라서 테스트가 문자열을 그대로 비교한다.
+*
+* 전부 검증되면 한 줄이다. 기본 생성이 축을 다 채우므로 그것이 대다수 실행의 모습이고,
+* 거기서 툴 30개를 나열하면 매 실행 30줄이 영구 소음이 된다.
+*
+* `total` 이 0 이면 `verified === total` 이 참이지만 "전부 검증" 이라고 쓰지 않는다. 축을
+* 하나도 세지 못한 것이지 전부 확인한 것이 아니다. 그 화면은 거짓이다.
+*/
+function renderCoverage(coverage) {
+	if (coverage.tools.length === 0) return "";
+	const count = coverage.tools.length;
+	const nothingHidden = coverage.tools.every((tool) => tool.analyzable && tool.unanalyzedFields.length === 0);
+	if (coverage.total > 0 && coverage.verified === coverage.total && nothingHidden) return `커버리지  ${count} tools, ${coverage.total} axes 전부 검증\n`;
+	const nameWidth = Math.max(0, ...coverage.tools.map((tool) => displayWidth(tool.tool))) + 3;
+	const lines = [`커버리지  ${count} tools, ${coverage.verified}/${coverage.total} axes 검증`];
+	for (const tool of coverage.tools) lines.push(...coverageToolLines(tool, nameWidth));
+	if (coverage.tools.some((tool) => tool.axes.some((axis) => axis.kind === "RANGE_VIOLATION" && axis.caseId === null))) lines.push("  → 범위 제약(minimum·maxItems 등)이 이번 버전부터 검증 축에 들어갑니다. 이전보다 숫자가 낮으면 새로 드러난 빈틈입니다");
+	return `${lines.join("\n")}\n`;
+}
+/**
+* 건너뛴 툴 고지. 없으면 빈 문자열이다. 순수 함수라서 테스트가 문자열을 그대로 비교한다.
+*
+* 종전에는 미지원 키워드 하나가 서버 전체를 거절했다(도그푸딩 실측: 공식 서버 7개 중 5개).
+* 이제 그 툴만 건너뛰므로, 건너뛴 사실이 안 보이면 "이 서버의 툴을 전부 검증했다" 로 읽힌다.
+* 커버리지 화면과 같은 이유로 침묵이 거짓말이 되는 자리다.
+*/
+function renderSkippedTools(skipped) {
+	if (skipped.length === 0) return "";
+	const lines = [`건너뜀  ${skipped.length} tools — 지원하지 않는 입력 스키마`];
+	for (const tool of skipped) lines.push(`  ${tool.name}  ${tool.path}: ${tool.message}`);
+	lines.push("  → 이 툴의 케이스는 생성되지 않았습니다. 필요하면 명세에 케이스를 손으로 추가하세요.");
+	return `${lines.join("\n")}\n`;
+}
+/**
+* 사전보완 요청의 전송 전 확인 화면.
+*
+* authoring 화면의 어법을 따르되 **전송 데이터 목록은 사실대로** 적는다. 여기서 나가는 것은
+* suite 전량이 아니라 툴 선언과 baseline 이 넣은 값뿐이다. authoring 문안을 그대로 태우면
+* 사용자가 승인하는 내용과 실제로 나가는 내용이 달라진다.
+*/
+function showPreFillRequest(io, preview) {
+	const { request } = preview;
+	const fields = request.cases.reduce((sum, item) => sum + item.assistFields.length, 0);
+	io.write(`AI 사전보완 요청\nProvider: ${preview.providerId}\nModel: ${preview.model}\nPayload: ${preview.byteLength} bytes\nResult limit: ${preview.maxResultBytes} bytes\nTimeout: ${preview.providerTimeoutMs}ms\nFingerprint: ${preview.fingerprint}\n대상: 툴 ${request.tools.length}개, 케이스 ${request.cases.length}개, 채울 필드 ${fields}개\n전송 데이터: 툴 이름·설명·inputSchema, baseline 이 넣은 값, 그 값의 출처
+받는 것: 값 제안뿐입니다. 케이스를 더하거나 구조를 바꾸지 않습니다.
+`);
+	if (request.omitted.tools > 0) io.write(`⚠ 크기 상한 때문에 툴 ${request.omitted.tools}개를 요청에서 뺐습니다. 그 툴은 baseline 값 그대로 갑니다.\n`);
+}
+/**
+* AI 없이 표 밖 `format` 툴을 건너뛸 때의 고지. 없으면 빈 문자열이다.
+*
+* **"지원하지 않는다" 로 끝내지 않는다.** 그러면 사용자가 할 수 있는 일이 없다. 해결 수단을
+* 같은 고지 안에 적는다. 이 프로젝트에서 실패 메시지는 곧 제품이다(설계서 §3.4).
+*/
+function renderUnknownFormatSkips(skips) {
+	if (skips.length === 0) return "";
+	const lines = [];
+	for (const skip of skips) {
+		lines.push(`경고: 툴 '${skip.tool}' 를 건너뜁니다.`);
+		lines.push(skip.format === "" ? `      '${skip.field}' 의 format 은 AI 없이 채울 수 없습니다.` : `      format '${skip.format}' 은 AI 없이 채울 수 없습니다.`);
+		lines.push("      AI 검토(--baseline-only 없이 실행)를 켜면 생성됩니다.");
+	}
+	return `${lines.join("\n")}\n`;
+}
+/**
+* AI 사전보완 결과 요약. 대상이 없으면 빈 문자열이다.
+*
+* **`버림` 은 사유와 대상을 반드시 적는다.** 개수만 적으면 사용자가 무엇을 잃었는지 모른다
+* (이슈 #120 이 `discarded` 가 개수뿐이라고 지적한 것과 같은 계열이다). 버림이 0건이면 그 줄을
+* 아예 찍지 않는다.
+*/
+function renderPreFillSummary(options) {
+	const { toolCount, proposedToolCount, adopted, notAdopted, discarded } = options;
+	if (proposedToolCount === 0 && discarded.length === 0) return "";
+	const lines = [
+		`AI 사전보완: 툴 ${toolCount}개 중 ${proposedToolCount}개에 값 제안을 받았습니다.`,
+		`  채택 ${adopted} (실제 서버에서 baseline 값이 실패하고 제안 값이 통과)`,
+		`  미채택 ${notAdopted} (baseline 값이 이미 통과)`
+	];
+	for (const item of discarded) lines.push(`  버림 1 (${item.reason}: ${item.caseId}.${item.field})`);
+	return `${lines.join("\n")}\n`;
+}
+/**
+* 케이스 수 고지. 임계 아래면 빈 문자열이다.
+* 생성을 막지 않는다. 이미 존재하는 상한을 사용자에게 보이게 하는 것이 목적이다.
+*/
+function renderCaseCountNotice(caseCount) {
+	if (caseCount < CASE_COUNT_WARNING_THRESHOLD) return "";
+	return `→ 케이스 ${caseCount}개를 만들었습니다. runner 보고서 상한(1MB)에 가까워 test 실행이\n  RunnerPayloadLimitError 로 실패할 수 있습니다.
+→ 툴을 나눠 여러 명세 파일로 생성하면 피할 수 있습니다.
+`;
+}
+/** 커버리지·건너뜀·케이스 수 고지를 stdout 에 찍는다. 전부 빈 문자열이면 아무것도 안 찍는다. */
+function writeCoverageReport(deps, coverage, suite, skippedTools) {
+	if (coverage !== void 0) {
+		const text = renderCoverage(coverage);
+		if (text !== "") deps.writeStdout(text);
+	}
+	const skippedText = renderSkippedTools(skippedTools);
+	if (skippedText !== "") deps.writeStdout(skippedText);
+	const notice = renderCaseCountNotice(suite.cases.length);
+	if (notice !== "") deps.writeStdout(notice);
+}
+/**
+* 커버리지 보고를 저장과 다른 오류 경계에 둔다.
+*
+* 파일을 저장한 **뒤에** 커버리지 계산이나 렌더링이 실패할 수 있다. 그것을 저장 실패로 보고하면
+* 사용자가 저장을 다시 시도하고 이번에는 `OUTPUT_EXISTS` 를 만난다. 저장은 성공했고 부가 정보만
+* 못 만든 것이므로 종료 코드를 바꾸지 않고 경고만 낸다.
+*
+* coverage 를 값이 아니라 thunk 로 받는 이유는 `computeCoverage` 자체가 던지는 경우까지 이 경계
+* 안에 넣기 위해서다.
+*/
+function reportCoverageSafely(deps, coverage, suite, skippedTools = []) {
+	try {
+		writeCoverageReport(deps, coverage(), suite, skippedTools);
+	} catch {
+		deps.writeStderr("경고 [GENERATE_COVERAGE_UNAVAILABLE]: 명세는 저장했지만 커버리지를 계산하지 못했습니다.\n해결: 저장된 명세는 그대로 `mcpeak test` 로 쓸 수 있습니다. 커버리지만 다시 보려면 다른 --out 경로로 generate 를 실행하세요.\n");
+	}
+}
+/**
+* AI 사전보완 한 회차. baseline 의 빈틈만 메운다.
+*
+* **자동이다.** 사용자의 자연어 요구를 받는 authoring 층과 목적이 다르므로 검토 메뉴가 아니라
+* 그 앞에서 한 번 돈다(설계서 §4.2). 사용자에게 묻는 것은 전송 승인 하나뿐이다.
+*
+* **provider 가 죽어도 툴을 건너뛰지 않는다.** provider 실패는 사용자 서버의 문제가 아니라
+* 우리 쪽 사정이고, 그것 때문에 케이스를 잃는 손해가 더 크다. baseline 값으로 진행하고
+* 그 사실을 화면에 적는다.
+*/
+async function runPreFill(input, tools, baseline, deps, client) {
+	const skip = {
+		suite: baseline.suite,
+		preFilledCaseIds: []
+	};
+	const io = deps.reviewIO;
+	const prepare = deps.preparePreFillRequest;
+	const preview = deps.previewPreFillRequest;
+	const dispatch = deps.dispatchPreFillRequest;
+	const providerId = input.provider;
+	if (io === void 0 || !prepare || !preview || !dispatch || providerId === void 0) return skip;
+	const model = input.model ?? defaultModel(providerId);
+	const provider = deps.preFillProviders?.[providerId]?.(model);
+	if (provider === void 0) return skip;
+	const request = prepare({
+		tools,
+		provenance: baseline.provenance,
+		baseline: baseline.suite
+	});
+	if (request === null) return skip;
+	let view;
+	try {
+		view = preview({
+			request,
+			providerId,
+			model
+		});
+	} catch {
+		io.write("⚠ AI 사전보완 요청이 크기 상한을 넘어 건너뜁니다. baseline 값으로 진행합니다.\n");
+		return skip;
+	}
+	showPreFillRequest(io, view);
+	if (!await io.confirm("이 요청을 전송할까요?")) return skip;
+	const dispatched = await dispatch({
+		provider,
+		preview: view,
+		approval: {
+			approved: true,
+			fingerprint: view.fingerprint
+		}
+	});
+	if (dispatched.status !== "proposals") {
+		io.write(`⚠ AI 사전보완을 쓰지 못했습니다 (${dispatched.status}). baseline 값으로 진행합니다.\n`);
+		return skip;
+	}
+	const applied = await applyPreFill({
+		client,
+		baseline: baseline.suite,
+		preFill: dispatched.result
+	});
+	io.write(renderPreFillSummary({
+		toolCount: tools.length,
+		proposedToolCount: request.tools.length,
+		adopted: applied.adopted,
+		notAdopted: applied.notAdopted,
+		discarded: dispatched.result.discarded
+	}));
+	return {
+		suite: applied.suite,
+		preFilledCaseIds: applied.cases.filter((item) => item.source === "ai").map((item) => item.caseId)
+	};
+}
+async function runGenerateCommand(argv, deps) {
+	let input;
+	try {
+		input = parseGenerateCommand(argv[0] === "generate" ? argv.slice(1) : argv);
+	} catch (error) {
+		const message = error instanceof UsageError$1 ? error.message : "generate 입력을 해석할 수 없습니다.";
+		deps.writeStderr(`오류 [CLI_USAGE]: ${message}\n해결: ${GENERATE_USAGE_HINT}\n`);
+		return 1;
+	}
+	try {
+		if (!input.force && await deps.exists(input.outPath)) {
+			outputExistsFailure(deps, input.outPath, "start");
+			return 1;
+		}
+	} catch (error) {
+		const code = error?.code;
+		const suffix = typeof code === "string" ? ` (${code})` : "";
+		deps.writeStderr(`오류 [GENERATE_OUTPUT_CHECK_FAILED]: 출력 경로를 확인하지 못해 시작하지 않았습니다. 경로: ${input.outPath}${suffix}\n해결: 그 경로와 상위 디렉터리의 권한을 확인하세요. 다른 \`--out\` 경로를 지정해도 됩니다.\n`);
+		return 1;
+	}
+	if (!input.baselineOnly && !deps.reviewIO?.interactive) {
+		deps.writeStderr("오류 [GENERATE_INTERACTIVE_REQUIRED]: AI 검토에는 TTY가 필요합니다.\n해결: `--baseline-only`를 지정하거나 대화형 터미널에서 실행하세요.\n");
+		return 1;
+	}
+	let connection;
+	/**
+	* 대화형 검토는 아래 try 밖에서 돌린다. 검토가 던지는 오류를 여기 catch 가 삼키면
+	* `GENERATE_FAILED` 로 뭉개지는데, 그 경로는 원래 호출자에게 그대로 올라가야 한다.
+	*/
+	let review;
+	try {
+		connection = await deps.connect({
+			command: input.command,
+			args: input.args
+		});
+		const active = connection;
+		const tools = await active.client.listTools();
+		if (input.baselineOnly) {
+			await active.close();
+			connection = void 0;
+		}
+		const baseline = deps.createBaselineSuite(tools, {
+			suiteId: input.suiteId,
+			suiteName: input.name
+		});
+		let sessionSuite = baseline.suite;
+		let preFilledCaseIds = [];
+		if (input.baselineOnly) {
+			const skips = unknownFormatSkips(tools, baseline.provenance);
+			if (skips.length > 0) {
+				deps.writeStdout(renderUnknownFormatSkips(skips));
+				sessionSuite = dropSkippedTools(baseline.suite, skips);
+			}
+		} else {
+			const outcome = await runPreFill(input, tools, baseline, deps, active.client);
+			sessionSuite = outcome.suite;
+			preFilledCaseIds = outcome.preFilledCaseIds;
+		}
+		const session = deps.createAuthoringSession(sessionSuite === baseline.suite ? baseline : {
+			...baseline,
+			suite: sessionSuite
+		}, { preFilledCaseIds });
+		if (!input.baselineOnly) {
+			connection = void 0;
+			review = {
+				active,
+				session,
+				tools,
+				skippedTools: baseline.skippedTools
+			};
+		} else {
+			const final = deps.finalizeAuthoringDraft({
+				session,
+				approval: {
+					approved: true,
+					fingerprint: session.approvedDraft.suiteFingerprint
+				}
+			});
+			if (!final.finalized) throw new Error("finalize failed");
+			const finalSuite = deps.getAuthoringExecutionSuite(final.snapshot);
+			await saveSuite(input, finalSuite, final.snapshot.fingerprint, deps);
+			deps.writeStdout(`baseline suite를 저장했습니다: ${input.outPath}\n`);
+			reportCoverageSafely(deps, () => baseline.coverage, finalSuite, baseline.skippedTools);
+			return 0;
+		}
+	} catch (error) {
+		if (connection !== void 0) await connection.forceClose().catch(() => void 0);
+		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");
+		return 1;
+	}
+	try {
+		return await runInteractiveReview(input, review.tools, review.session, deps, review.active, review.skippedTools);
+	} finally {
+		await review.active.close().catch(() => void 0);
+	}
+}
+const nodeGenerateDependencies = () => ({
+	exists: async (path) => (0, node_fs_promises.access)(path).then(() => true).catch(() => false),
+	openTemp: (path) => (0, node_fs_promises.open)(path, "wx"),
+	readFile: node_fs_promises.readFile,
+	link: node_fs_promises.link,
+	unlink: node_fs_promises.unlink,
+	writeStdout: (text) => process.stdout.write(text),
+	writeStderr: (text) => process.stderr.write(text)
+});
+function nodeReviewIO(input = process.stdin, output = process.stdout) {
+	/**
+	* readline은 첫 질문에서 만든다. createInterface는 만드는 즉시 입력 스트림을 참조해
+	* 닫기 전까지 이벤트 루프를 붙잡는다. `--baseline-only`처럼 아무것도 묻지 않는 경로에서
+	* 미리 만들면 실제 TTY에서 프로세스가 종료되지 않는다(파이프로 돌리면 stdin이 끝나
+	* 우연히 종료돼 그동안 드러나지 않았다). 만들지 않으면 닫기를 잊을 여지도 없다.
+	*/
+	let readline;
+	let closed = false;
+	let rejectPending;
+	const ensureReadline = () => {
+		if (readline !== void 0) return readline;
+		const created = (0, node_readline_promises.createInterface)({
+			input,
+			output
+		});
+		created.on("close", () => {
+			closed = true;
+			rejectPending?.();
+		});
+		readline = created;
+		return created;
+	};
+	/**
+	* EOF에는 두 모양이 있고 둘 다 스택 노출이나 무한 대기로 끝난다. 둘 다 sentinel로 바꾼다.
+	* 1) 이미 닫힌 뒤 부르면 Node가 ERR_USE_AFTER_CLOSE를 던진다.
+	* 2) 대기 중에 닫히면 question promise가 영영 settle되지 않는다. close 이벤트와 race시킨다.
+	*/
+	const question = async (prompt) => {
+		if (closed) throw new ReviewInputClosedError();
+		const active = ensureReadline();
+		const closedSignal = new Promise((_, reject) => {
+			rejectPending = () => reject(new ReviewInputClosedError());
+		});
+		try {
+			return await Promise.race([active.question(prompt), closedSignal]);
+		} catch (error) {
+			if (isReviewInputClosed(error)) throw new ReviewInputClosedError();
+			throw error;
+		} finally {
+			rejectPending = void 0;
+		}
+	};
+	return {
+		interactive: Boolean(input.isTTY && output.isTTY),
+		input: (message) => question(message),
+		choose: async (message, choices) => {
+			return (await question(`${message} [${choices.join("/")}]: `)).trim();
+		},
+		confirm: async (message) => (await question(`${message} [y/N] `)).trim().toLowerCase() === "y",
+		write: (text) => {
+			output.write(text);
+		},
+		close: () => readline?.close()
+	};
+}
+//#endregion
+//#region src/spec-approval.ts
+/** 표시용 축약 길이. 64자는 줄을 넘겨 읽히지 않고, 12자면 눈으로 다르다는 것을 알 수 있다. */
+const DISPLAY_LENGTH = 12;
+const short = (value) => `${value.slice(0, DISPLAY_LENGTH)}…`;
+function checkSpecApproval(suite) {
+	const fingerprint = (0, _mcpeak_runner.suiteFingerprint)(suite);
+	const approved = suite.approval?.fingerprint;
+	if (approved === void 0) return {
+		state: "absent",
+		fingerprint
+	};
+	return {
+		state: approved === fingerprint ? "matched" : "mismatched",
+		fingerprint,
+		approvedFingerprint: approved
+	};
+}
+/**
+* 승인 시점 케이스 판정의 조회표. `approval.cases` 가 없으면 빈 표다.
+* 케이스마다 배열을 훑지 않으려고 한 번만 만든다.
+*
+* 실재하지 않는 id 가 들어 있어도 그대로 담는다. 검증이 이미 그것을 통과시켰고(설계 문서 §7.3),
+* 조회하는 쪽은 보고서의 케이스 id 로만 묻기 때문에 여분 항목은 닿지 않는다.
+*/
+function caseApprovalStatuses(suite) {
+	return new Map((suite.approval?.cases ?? []).map((entry) => [entry.id, entry.status]));
+}
+/**
+* `serverDefect` 로 표시된 케이스가 다시 실패했을 때 붙이는 한 줄. 설계 문서 §9.
+* 들여쓰기는 보고서의 케이스 블록과 맞춘다. 개행으로 끝나고 호출자가 앞에 빈 줄을 붙인다.
+*
+* 종료 코드는 바뀌지 않는다. 알려진 결함이어도 실패는 실패이고, 초록으로 만들면 고칠 이유가
+* 사라진다.
+*/
+const SERVER_DEFECT_NOTE_LINE = "    참고: 승인 시점에 서버 결함으로 표시된 케이스입니다. 서버가 아직 고쳐지지 않았습니다.\n";
+/**
+* 표시 여부. 설계 문서 §7.1.
+* 전부 통과일 때는 불일치만 알린다. 매 실행 한 줄은 손으로 명세를 쓰는 사용자에게 영구
+* 소음이고, 그러면 정작 필요할 때 그 줄을 안 읽는다.
+* 전부 통과 + 불일치만 예외인 이유는 승인받지 않은 명세로 초록불이 뜬 상태라서다.
+*/
+function shouldShowSpecApproval(result, allPassed) {
+	return allPassed ? result.state === "mismatched" : true;
+}
+/** 반환은 개행으로 끝난다. 호출자가 앞에 빈 줄을 붙인다. 설계 문서 §7.2. */
+function renderSpecApproval(result) {
+	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 를 먼저 확인하세요.
+`;
+}
+/** 번들에 적는 CLI 식별자. `mcpeak --version` 이 찍는 것과 같은 출처를 쓴다. */
+const REPAIR_BUNDLE_GENERATED_BY = `mcpeak ${version}`;
+/**
+* 케이스 하나의 진단을 순서대로 모은다.
+*
+* `operation.diagnostic` 이 먼저이고 그다음이 `assertions[].diagnostic` 이다. 첫 번째만 담으면
+* 실제 원인이 두 번째에 있을 때 근거가 사라진다. 설계서 §4.2.
+*/
+function diagnosticsOf(item) {
+	const sources = [item.operation.diagnostic, ...item.assertions.map((assertion) => assertion.diagnostic)];
+	const collected = [];
+	for (const source of sources) {
+		if (source === void 0) continue;
+		const diagnostic = {
+			code: source.code,
+			message: source.message
+		};
+		if ("expected" in source) diagnostic.expected = source.expected;
+		if ("actual" in source) diagnostic.actual = source.actual;
+		if (source.notes !== void 0) diagnostic.notes = [...source.notes];
+		collected.push(diagnostic);
+	}
+	return collected;
+}
+/**
+* 실행 결과에서 repair 번들을 만든다.
+*
+* 통과한 케이스는 담지 않는다. 이 파일은 AI 에게 줄 근거 묶음이고 `--json` 보고서와 용도가
+* 다르다. 실패가 하나도 없으면 `undefined` 를 돌려주고, 호출 지점이 파일을 안 만든다.
+* 설계서 §4.2.
+*/
+function buildRepairBundle(options) {
+	const failed = options.report.cases.filter((item) => item.status !== "passed");
+	if (failed.length === 0) return void 0;
+	const approvals = caseApprovalStatuses(options.suite);
+	const failures = failed.map((item) => {
+		const failure = {
+			caseId: item.spec.id,
+			caseName: item.spec.name,
+			status: item.status,
+			diagnostics: diagnosticsOf(item)
+		};
+		if (item.spec.operation.type === "callTool") {
+			failure.tool = item.spec.operation.tool;
+			failure.input = item.spec.operation.input;
+		}
+		const approvedAs = approvals.get(item.spec.id);
+		if (approvedAs !== void 0) failure.approvedAs = approvedAs;
+		return failure;
+	});
+	const spec = {
+		suiteId: options.report.suite.id,
+		suiteName: options.report.suite.name,
+		approval: options.specApproval.state,
+		fingerprint: options.specApproval.fingerprint
+	};
+	if (options.specApproval.approvedFingerprint !== void 0) spec.approvedFingerprint = options.specApproval.approvedFingerprint;
+	const bundle = {
+		bundleVersion: 1,
+		generatedBy: options.cliVersion ?? REPAIR_BUNDLE_GENERATED_BY,
+		spec,
+		failures
+	};
+	/**
+	* 내용이 있을 때만 담는다. 판정은 화면이 쓰는 `hasDiagnosticContent` 와 **같은 함수**다.
+	* 규칙이 갈라지면 화면에는 안 뜨는 것이 번들에는 들어간다. 설계서 §4.2.
+	*/
+	if (options.processDiagnostics !== void 0 && hasDiagnosticContent(options.processDiagnostics)) bundle.process = options.processDiagnostics;
+	return bundle;
+}
+/**
+* 실패가 없어 번들을 안 만들었을 때 화면에 남기는 한 줄. 조용히 넘어가면 사용자는 파일이
+* 없는 이유를 모른다. 개행으로 끝나고 호출자가 앞에 빈 줄을 붙인다.
+*/
+const REPAIR_BUNDLE_EMPTY_LINE = "repair 번들: 실패한 케이스가 없어 파일을 만들지 않았습니다.\n";
+/** 번들 직렬화의 단일 구현. 파일에 쓰는 쪽과 테스트가 같은 형식을 본다. */
+function serializeRepairBundle(bundle) {
+	return `${JSON.stringify(bundle, null, 2)}\n`;
+}
+/**
+* 거절 사유마다 다른 문장을 돌려준다. 무엇이 왜 다른지와 다음에 할 일이 한 줄씩 있어야 한다.
+* "잘못된 파일입니다" 로 뭉치면 사용자는 파일을 다시 만들어야 하는지 경로를 잘못 준 것인지
+* 구분할 수 없다.
+*/
+function describeRepairBundleInvalid(reason) {
+	switch (reason) {
+		case "notJson": return "번들 파일이 JSON 이 아닙니다. `--repair-bundle` 이 만든 파일이 맞는지, 편집 중에 깨지지 않았는지 확인하세요.";
+		case "notObject": return "번들 최상위가 JSON 객체가 아닙니다. 배열이나 문자열이 담긴 다른 파일을 가리키고 있지 않은지 경로를 확인하세요.";
+		case "versionMismatch": return `번들 형식 버전이 이 CLI 가 아는 1 이 아닙니다. 최신 \`mcpeak test --repair-bundle\` 로 다시 만드세요.`;
+		case "missingField": return "번들에 필요한 항목이 없거나 값이 형식과 다릅니다. `spec` 의 `suiteId`·`suiteName`·`approval`, 각 실패의 `caseId`·`caseName`·`status`·`diagnostics`, 각 진단의 `code`·`message` 가 있어야 합니다. `mcpeak test --repair-bundle` 로 다시 만드세요.";
+		case "emptyFailures": return "번들에 실패한 케이스가 없습니다. 진단할 근거가 없으므로 provider 를 부르지 않습니다. 실패가 있는 실행에서 번들을 다시 만드세요.";
+	}
+}
+const plainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* 번들 파일 내용을 읽어 검증한다.
+*
+* 모르는 버전은 거절한다. 앞으로 호환을 흉내 내면 낡은 번들에서 키가 빠졌을 때 조용히
+* 반쪽으로 돈다. 설계서 §4.2.
+*/
+/** 화면과 진단 요청이 실제로 읽는 값들이다. 여기 없는 값은 검사하지 않는다. */
+const APPROVAL_STATES = [
+	"matched",
+	"mismatched",
+	"absent"
+];
+const FAILURE_STATUSES = [
+	"failed",
+	"timedOut",
+	"cancelled",
+	"notRun"
+];
+const APPROVED_AS = ["passed", "serverDefect"];
+const isOneOf = (value, allowed) => typeof value === "string" && allowed.includes(value);
+/**
+* 소비하는 필드가 실제로 있고 형식이 맞는지 본다.
+*
+* 얕게 보면 `caseName` 이나 `status` 가 빠진 JSON 도 통과해 그대로 provider 요청까지 나간다.
+* 사용자는 확인 화면에서 빈 값을 보고도 무엇이 잘못됐는지 모른다. 반대로 우리가 안 읽는 값까지
+* 요구하면 다른 버전이 만든 정상 번들을 거절하게 되므로, 기준은 **읽는 값**이다.
+*/
+function failureShapeValid(failure) {
+	if (!plainObject(failure)) return false;
+	if (typeof failure.caseId !== "string" || failure.caseId === "") return false;
+	if (typeof failure.caseName !== "string") return false;
+	if (!isOneOf(failure.status, FAILURE_STATUSES)) return false;
+	if (failure.tool !== void 0 && typeof failure.tool !== "string") return false;
+	if (failure.approvedAs !== void 0 && !isOneOf(failure.approvedAs, APPROVED_AS)) return false;
+	if (failure.input !== void 0 && !plainObject(failure.input)) return false;
+	if (!Array.isArray(failure.diagnostics)) return false;
+	for (const diagnostic of failure.diagnostics) {
+		if (!plainObject(diagnostic)) return false;
+		if (typeof diagnostic.code !== "string") return false;
+		if (typeof diagnostic.message !== "string") return false;
+		if (diagnostic.notes !== void 0 && !Array.isArray(diagnostic.notes)) return false;
+	}
+	return true;
+}
+function specShapeValid(spec) {
+	if (!plainObject(spec)) return false;
+	if (typeof spec.suiteId !== "string") return false;
+	if (typeof spec.suiteName !== "string") return false;
+	if (!isOneOf(spec.approval, APPROVAL_STATES)) return false;
+	if (typeof spec.fingerprint !== "string") return false;
+	return true;
+}
+function readRepairBundle(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {
+			status: "invalid",
+			reason: "notJson"
+		};
+	}
+	if (!plainObject(parsed)) return {
+		status: "invalid",
+		reason: "notObject"
+	};
+	if (parsed.bundleVersion !== 1) return {
+		status: "invalid",
+		reason: "versionMismatch"
+	};
+	if (!specShapeValid(parsed.spec)) return {
+		status: "invalid",
+		reason: "missingField"
+	};
+	if (!Array.isArray(parsed.failures)) return {
+		status: "invalid",
+		reason: "missingField"
+	};
+	for (const failure of parsed.failures) if (!failureShapeValid(failure)) return {
+		status: "invalid",
+		reason: "missingField"
+	};
+	if (parsed.failures.length === 0) return {
+		status: "invalid",
+		reason: "emptyFailures"
+	};
+	return {
+		status: "ok",
+		bundle: parsed
+	};
+}
+var UsageError = class extends Error {};
+const optionNames = /* @__PURE__ */ new Set([
+	"--provider",
+	"--model",
+	"--max-cases",
+	"--no-stderr",
+	"--yes"
+]);
+/** 값을 받지 않는 옵션. `=` 를 붙여 쓸 수 없고 두 번 쓸 수 없다. */
+const flagNames = /* @__PURE__ */ new Set(["--no-stderr", "--yes"]);
+function optionValue(argv, index, option) {
+	const item = argv[index];
+	const equals = item.indexOf("=");
+	if (equals > 0) return [item.slice(equals + 1), index];
+	const value = argv[index + 1];
+	if (value === void 0 || value.startsWith("--")) throw new UsageError(`\`${option}\` 옵션 값이 필요합니다.`);
+	return [value, index + 1];
+}
+function parseRepairCommand(argv) {
+	let bundlePath;
+	const values = /* @__PURE__ */ new Map();
+	const flags = /* @__PURE__ */ new Set();
+	for (let index = 0; index < argv.length; index++) {
+		const item = argv[index];
+		if (item === void 0) continue;
+		if (!item.startsWith("--")) {
+			if (bundlePath !== void 0) throw new UsageError(`추가 위치 인자 '${item}'는 허용되지 않습니다.`);
+			bundlePath = item;
+			continue;
+		}
+		const option = item.includes("=") ? item.slice(0, item.indexOf("=")) : item;
+		if (!optionNames.has(option)) throw new UsageError(`지원하지 않는 repair 옵션 '${option}'입니다.`);
+		if (flagNames.has(option)) {
+			if (item !== option || flags.has(option)) throw new UsageError(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
+			flags.add(option);
+			continue;
+		}
+		const [value, consumed] = optionValue(argv, index, option);
+		index = consumed;
+		if (value === "") throw new UsageError(`\`${option}\` 옵션 값이 필요합니다.`);
+		if (values.has(option)) throw new UsageError(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
+		values.set(option, value);
+	}
+	if (bundlePath === void 0) throw new UsageError("repair 번들 JSON 경로가 필요합니다.");
+	const rawProvider = values.get("--provider");
+	if (rawProvider === void 0) throw new UsageError("`--provider` 옵션이 필요합니다.");
+	if (rawProvider !== "codex" && rawProvider !== "claude") throw new UsageError("`--provider`는 codex 또는 claude여야 합니다.");
+	const model = values.get("--model");
+	if (model === void 0) throw new UsageError("`--model` 옵션이 필요합니다.");
+	const rawMaxCases = values.get("--max-cases");
+	let maxCases = 10;
+	if (rawMaxCases !== void 0) {
+		if (!/^\d+$/.test(rawMaxCases)) throw new UsageError("`--max-cases` 값은 1 이상의 정수여야 합니다.");
+		maxCases = Number.parseInt(rawMaxCases, 10);
+		if (!Number.isSafeInteger(maxCases) || maxCases < 1) throw new UsageError("`--max-cases` 값은 1 이상의 정수여야 합니다.");
+	}
+	return Object.freeze({
+		bundlePath,
+		providerId: rawProvider,
+		model,
+		yes: flags.has("--yes"),
+		includeStderr: !flags.has("--no-stderr"),
+		maxCases
+	});
+}
+/**
+* `repair` 명령. 번들을 읽고, 전송 내용을 확인받고, provider 에게 진단을 물어 화면에 찍는다.
+* 파일도 명세도 고치지 않는다. 종료 코드는 운영 실패에만 1 이다(설계서 §7.1).
+*/
+async function runRepairCommand(argv, deps) {
+	let input;
+	try {
+		input = parseRepairCommand(argv[0] === "repair" ? argv.slice(1) : argv);
+	} catch (error) {
+		const message = error instanceof UsageError ? error.message : "repair 입력을 해석할 수 없습니다.";
+		deps.writeStderr(`오류 [CLI_USAGE]: ${message}\n해결: ${REPAIR_USAGE_HINT}\n`);
+		return 1;
+	}
+	let text;
+	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`);
+		return 1;
+	}
+	const read = readRepairBundle(text);
+	if (read.status !== "ok") {
+		deps.writeStderr(`오류 [REPAIR_BUNDLE_INVALID]: ${describeRepairBundleInvalid(read.reason)}\n`);
+		return 1;
+	}
+	const bundle = read.bundle;
+	if (deps.diagnosis === void 0) {
+		deps.writeStderr("오류 [REPAIR_RUNTIME_UNAVAILABLE]: 진단 통로를 쓸 수 없습니다.\n해결: 의존성을 설치한 뒤 다시 실행하세요.\n");
+		return 1;
+	}
+	const provider = deps.diagnosis.providers[input.providerId](input.model);
+	const preview = deps.diagnosis.prepare({
+		specApproved: bundle.spec.approval === "matched",
+		suite: {
+			id: bundle.spec.suiteId,
+			name: bundle.spec.suiteName
+		},
+		failures: bundle.failures.map((failure) => ({
+			caseId: failure.caseId,
+			caseName: failure.caseName,
+			...failure.tool === void 0 ? {} : { tool: failure.tool },
+			...failure.input === void 0 ? {} : { input: failure.input },
+			...failure.approvedAs === void 0 ? {} : { approvedAs: failure.approvedAs },
+			diagnostics: failure.diagnostics.map((diagnostic) => ({ ...diagnostic }))
+		})),
+		...bundle.process === void 0 ? {} : { processDiagnostics: bundle.process },
+		tools: [],
+		providerId: input.providerId,
+		model: input.model,
+		maxCases: input.maxCases,
+		includeStderr: input.includeStderr
+	});
+	const confirmView = {
+		providerId: input.providerId,
+		model: input.model,
+		totalFailures: bundle.failures.length,
+		sentFailures: preview.request.failures.length,
+		omittedFailures: preview.omitted.failures,
+		maxCases: input.maxCases,
+		approval: bundle.spec.approval,
+		includeStderr: input.includeStderr,
+		...preview.request.processDiagnostics === void 0 ? {} : { stderr: preview.request.processDiagnostics.stderr },
+		requestBytes: preview.byteLength
+	};
+	if (!input.yes) {
+		if (deps.reviewIO?.interactive !== true) {
+			deps.writeStdout(renderRepairConfirm(confirmView));
+			deps.writeStderr(REPAIR_CONFIRM_REQUIRED_LINE);
+			return 1;
+		}
+		deps.reviewIO.write(renderRepairConfirm(confirmView));
+		if (!await deps.reviewIO.confirm("보내시겠습니까?")) {
+			deps.writeStdout(REPAIR_CANCELLED_LINE);
+			return 0;
+		}
+	}
+	const dispatched = await deps.diagnosis.dispatch({
+		provider,
+		preview,
+		approval: {
+			approved: true,
+			fingerprint: preview.fingerprint
+		}
+	});
+	if (dispatched.status === "providerFailed") {
+		deps.writeStderr(renderRepairProviderFailure(dispatched.failure));
+		return 1;
+	}
+	if (dispatched.status === "invalid") {
+		deps.writeStderr(REPAIR_INVALID_RESULT_LINE);
+		return 1;
+	}
+	if (dispatched.status === "resultLimitExceeded") {
+		deps.writeStderr(REPAIR_RESULT_LIMIT_LINE);
+		return 1;
+	}
+	if (dispatched.status !== "diagnosis") {
+		deps.writeStderr(REPAIR_APPROVAL_INVALIDATED_LINE);
+		return 1;
+	}
+	deps.writeStdout(renderRepairResult({
+		bundle,
+		result: dispatched.result,
+		providerId: input.providerId,
+		model: input.model
+	}));
+	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((0, _mcpeak_record.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 === _mcpeak_record.REDACTED) add(path);
+			else if (value.includes(_mcpeak_record.REDACTED)) 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 = (0, _mcpeak_record.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
+* 필드·비평문 인스턴스·순환 참조를 TypeError 로 거절한다. 캡처 시점에 한 번 통과시켜 두면
+* 비교 단계에서 터지지 않는다. executor 의 `clone` 과 같은 방식이다.
+*
+* 실패하면(순환 참조 등) null 을 돌려주고 호출 측이 캡처를 버린다. 여기서 던지면 부수적
+* 관찰 때문에 1회차 시험 실행이 죽는다.
+*/
+const plainCopy = (value) => {
+	try {
+		return { value: JSON.parse(JSON.stringify(value)) };
+	} catch {
+		return null;
+	}
+};
+function createDeterminismCapture(inner) {
+	const slots = [];
+	let current = -1;
+	const record = (index, response) => {
+		const slot = slots[index];
+		if (slot === void 0 || slot.captured) return;
+		const copied = plainCopy(response);
+		if (copied === null) return;
+		slot.captured = true;
+		slot.response = copied.value;
+	};
+	const onEvent = (event) => {
+		if (event.type === "caseStarted") {
+			current = event.caseIndex;
+			slots[event.caseIndex] = {
+				caseId: event.caseId,
+				caseName: event.case.name,
+				toolName: event.case.operation.type === "callTool" ? event.case.operation.tool : null,
+				status: "notRun",
+				assertionStatuses: [],
+				captured: false
+			};
+		} else if (event.type === "caseCompleted") {
+			const slot = slots[event.caseIndex];
+			if (slot === void 0) return;
+			slot.status = event.result.status;
+			slot.assertionStatuses = event.result.assertions.map((assertion) => assertion.status);
+		} else if (event.type === "suiteCompleted") event.report.cases.forEach((result, index) => {
+			if (slots[index] !== void 0) return;
+			slots[index] = {
+				caseId: result.spec.id,
+				caseName: result.spec.name,
+				toolName: result.spec.operation.type === "callTool" ? result.spec.operation.tool : null,
+				status: result.status,
+				assertionStatuses: result.assertions.map((assertion) => assertion.status),
+				captured: false
+			};
+		});
+	};
+	return {
+		client: {
+			listTools: () => {
+				const at = current;
+				return inner.listTools().then((tools) => {
+					record(at, tools);
+					return tools;
+				});
+			},
+			callTool: (name, args) => {
+				const at = current;
+				return inner.callTool(name, args).then((result) => {
+					record(at, result);
+					return result;
+				});
+			},
+			close: () => inner.close()
+		},
+		onEvent,
+		observations: () => slots.map((slot) => ({
+			caseId: slot.caseId,
+			caseName: slot.caseName,
+			toolName: slot.toolName,
+			status: slot.status,
+			assertionStatuses: slot.assertionStatuses,
+			...slot.captured ? { response: slot.response } : {}
+		}))
+	};
+}
+//#endregion
+//#region src/test-command.ts
+/** --stderr-lines 기본값. 설계 문서 §6. */
+const DEFAULT_STDERR_LINES = 20;
+const dictionary = {
+	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: "아래 명세 오류를 모두 수정하세요."
+	},
+	MCP_CONNECTION_FAILED: {
+		message: "MCP 서버 연결에 실패했습니다.",
+		hint: "command 실행 가능 여부와 stdio MCP 서버 설정을 확인하세요."
+	},
+	RUNNER_EXECUTION_FAILED: {
+		message: "Runner 실행을 시작하지 못했습니다.",
+		hint: "테스트 명세와 Runner 설정을 확인하세요."
+	},
+	RUNNER_FINALIZATION_FAILED: {
+		message: "Runner 실행 또는 MCP 서버 종료에 실패했습니다.",
+		hint: "서버 응답과 종료 상태를 확인하세요."
+	},
+	JUNIT_WRITE_FAILED: {
+		message: "JUnit XML 파일을 쓰지 못했습니다.",
+		hint: "`--junit` 경로의 디렉터리가 존재하는지와 쓰기 권한을 확인하세요."
+	},
+	REPAIR_BUNDLE_WRITE_FAILED: {
+		message: "repair 번들 파일을 쓰지 못했습니다.",
+		hint: "`--repair-bundle` 경로의 디렉터리가 존재하는지와 쓰기 권한을 확인하세요."
+	},
+	RESET_COMMAND_FAILED: {
+		message: "초기화 명령이 실패했습니다.",
+		hint: "`--reset-cmd` 명령이 단독으로 성공하는지 확인한 뒤 다시 실행하세요."
+	},
+	CLI_INTERNAL_ERROR: {
+		message: "예상하지 못한 CLI 내부 오류가 발생했습니다.",
+		hint: "다시 실행한 뒤 재현 정보와 함께 이슈를 보고하세요."
+	}
+};
+var CliCommandError = class extends Error {
+	failure;
+	constructor(failure) {
+		super(failure.message);
+		this.failure = failure;
+	}
+};
+const fail = (message) => {
+	throw new CliCommandError({
+		code: "CLI_USAGE",
+		message,
+		hint: TEST_USAGE_HINT
+	});
+};
+function parseTestCommand(argv) {
+	const suitePath = argv[0] ?? "";
+	if (suitePath === "") fail("테스트 명세 JSON 경로가 필요합니다.");
+	let command;
+	let json = false;
+	let junitPath;
+	let repairBundlePath;
+	let determinism = false;
+	let resetCmd;
+	let stderrLines;
+	const args = [];
+	for (let index = 1; index < argv.length; index += 1) {
+		const token = argv[index] ?? "";
+		if (token === "--command" || token.startsWith("--command=")) {
+			if (command !== void 0) fail("`--command`는 한 번만 사용할 수 있습니다.");
+			let value;
+			if (token === "--command") {
+				const next = argv[++index];
+				if (next === void 0) throw new CliCommandError({
+					code: "CLI_USAGE",
+					message: "`--command` 옵션 값이 필요합니다.",
+					hint: TEST_USAGE_HINT
+				});
+				value = next;
+			} else value = token.slice(10);
+			if (value === "") fail("`--command` 옵션 값이 필요합니다.");
+			if (value.startsWith("--")) fail("`--command` 옵션 값이 필요합니다.");
+			command = value;
+		} else if (token === "--arg" || token.startsWith("--arg=")) {
+			let value;
+			if (token === "--arg") {
+				const next = argv[++index];
+				if (next === void 0) throw new CliCommandError({
+					code: "CLI_USAGE",
+					message: "`--arg` 옵션 값이 필요합니다.",
+					hint: TEST_USAGE_HINT
+				});
+				value = next;
+			} else value = token.slice(6);
+			args.push(value);
+		} else if (token === "--junit" || token.startsWith("--junit=")) {
+			if (junitPath !== void 0) fail("`--junit`은 한 번만 사용할 수 있습니다.");
+			let value;
+			if (token === "--junit") {
+				const next = argv[++index];
+				if (next === void 0) throw new CliCommandError({
+					code: "CLI_USAGE",
+					message: "`--junit` 옵션 값이 필요합니다.",
+					hint: TEST_USAGE_HINT
+				});
+				value = next;
+			} else value = token.slice(8);
+			if (value === "") fail("`--junit` 옵션 값이 필요합니다.");
+			if (value.startsWith("--")) fail("`--junit` 옵션 값이 필요합니다.");
+			junitPath = value;
+		} else if (token === "--repair-bundle" || token.startsWith("--repair-bundle=")) {
+			if (repairBundlePath !== void 0) fail("`--repair-bundle`은 한 번만 사용할 수 있습니다.");
+			let value;
+			if (token === "--repair-bundle") {
+				const next = argv[++index];
+				if (next === void 0) throw new CliCommandError({
+					code: "CLI_USAGE",
+					message: "`--repair-bundle` 옵션 값이 필요합니다.",
+					hint: TEST_USAGE_HINT
+				});
+				value = next;
+			} else value = token.slice(16);
+			if (value === "") fail("`--repair-bundle` 옵션 값이 필요합니다.");
+			if (value.startsWith("--")) fail("`--repair-bundle` 옵션 값이 필요합니다.");
+			repairBundlePath = value;
+		} else if (token === "--reset-cmd" || token.startsWith("--reset-cmd=")) {
+			if (resetCmd !== void 0) fail("`--reset-cmd`는 한 번만 사용할 수 있습니다.");
+			let value;
+			if (token === "--reset-cmd") {
+				const next = argv[++index];
+				if (next === void 0) throw new CliCommandError({
+					code: "CLI_USAGE",
+					message: "`--reset-cmd` 옵션 값이 필요합니다.",
+					hint: TEST_USAGE_HINT
+				});
+				value = next;
+			} else value = token.slice(12);
+			if (value.trim() === "") fail("`--reset-cmd` 옵션 값이 필요합니다.");
+			if (value.startsWith("--")) fail("`--reset-cmd` 옵션 값이 필요합니다.");
+			resetCmd = value;
+		} else if (token === "--determinism") determinism = true;
+		else if (token.startsWith("--determinism=")) fail("`--determinism`은 값을 받지 않습니다.");
+		else if (token === "--stderr-lines" || token.startsWith("--stderr-lines=")) {
+			if (stderrLines !== void 0) fail("`--stderr-lines`는 한 번만 사용할 수 있습니다.");
+			let value;
+			if (token === "--stderr-lines") {
+				const next = argv[++index];
+				if (next === void 0) throw new CliCommandError({
+					code: "CLI_USAGE",
+					message: "`--stderr-lines` 옵션 값이 필요합니다.",
+					hint: TEST_USAGE_HINT
+				});
+				value = next;
+			} else value = token.slice(15);
+			if (!/^\d+$/.test(value)) fail("`--stderr-lines` 값은 0 이상의 정수여야 합니다.");
+			const parsedLines = Number.parseInt(value, 10);
+			if (!Number.isSafeInteger(parsedLines)) fail("`--stderr-lines` 값은 0 이상의 정수여야 합니다.");
+			stderrLines = parsedLines;
+		} 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}'는 허용되지 않습니다.`);
+	}
+	if (command === void 0) throw new CliCommandError({
+		code: "CLI_USAGE",
+		message: "`--command` 옵션이 필요합니다.",
+		hint: TEST_USAGE_HINT
+	});
+	return Object.freeze({
+		suitePath,
+		command,
+		args: Object.freeze(args),
+		json,
+		junitPath,
+		repairBundlePath,
+		determinism,
+		resetCmd,
+		stderrLines: stderrLines ?? DEFAULT_STDERR_LINES
+	});
+}
+const escapeTerminalText = (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("");
+/**
+* 머리글은 검사 종류마다 다르다. `minLength: 0` 은 입력이 아니라 단언의 문제이고,
+* `SCHEMA_NOT_ANALYZABLE` 은 명세가 아니라 서버 스키마를 못 읽었다는 뜻이다. 둘 중 어느
+* 것이든 입력 머리글 아래 붙이면 읽는 사람이 멀쩡한 입력을 고치러 간다. 설계 문서 §7.2.
+*/
+const FINDING_HEADING = {
+	inputContract: (caseId) => `참고: ${caseId} 의 입력이 서버 선언과 다릅니다`,
+	assertionSubstance: (caseId) => `참고: ${caseId} 의 단언은 무엇이 와도 통과합니다`,
+	rejectionIntent: (caseId) => `참고: ${caseId} 는 거절을 기대하지만 선언을 어기지 않습니다`,
+	skipped: (caseId) => `참고: ${caseId} 의 입력 검사를 건너뛰었습니다`
+};
+/**
+* 위반이 먼저, 건너뜀이 맨 뒤다. 위반 사이에서는 입력 계약이 먼저다. 명세를 고칠 때 입력이
+* 먼저 맞아야 단언을 볼 수 있다. 건너뜀이 맨 뒤인 이유는 그것만 있을 때 위에 아무 위반도
+* 없다는 사실이 먼저 읽혀야 하기 때문이다.
+*/
+const FINDING_GROUP_ORDER = [
+	"inputContract",
+	"assertionSubstance",
+	"rejectionIntent",
+	"skipped"
+];
+/** 결정론성 결과 블록의 머리글. 설계 문서 §8. */
+const DETERMINISM_HEADING = "결정론성 확인";
+/** `(12/12)` 와 `(12/12, 제외 2: 실행되지 않은 케이스)`. 설계 문서 §8. */
+const determinismCounts = (result) => result.skipped === 0 ? `(${result.compared}/${result.compared})` : `(${result.compared}/${result.compared}, 제외 ${result.skipped}: 실행되지 않은 케이스)`;
+/**
+* 결정론성 블록 전문. 문구는 설계 문서 §8 이 사양이다. 케이스 블록은 runner 의
+* `describeDeterminismDifference` 가 만들고 여기서 들여쓰기를 덧붙이지 않는다. 그 함수가
+* 이미 앞 공백 2칸을 포함한 블록을 낸다.
+*/
+function renderDeterminism(outcome, options) {
+	if (outcome.kind === "internal") return `${DETERMINISM_HEADING}\n→ 결정론성 비교에서 예상하지 못한 CLI 내부 오류가 발생했습니다. 시험 판정은 1회차 결과 그대로입니다.\n→ 다시 실행한 뒤 재현 정보와 함께 이슈를 보고하세요.\n`;
+	if (outcome.kind === "incomplete") {
+		const head = `${DETERMINISM_HEADING}\n→ 2회차 실행이 완주하지 못해 비교할 수 없습니다. (사유: ${escapeTerminalText(outcome.reason)})\n→ 1회차는 완주했으므로, 서버가 반복 실행 자체에 취약할 수 있습니다
+  (이전 실행이 남긴 상태·잠금·포트 점유 등).
+`;
+		if (options.stderrLines === 0 || outcome.diagnostics === void 0 || !hasDiagnosticContent(outcome.diagnostics)) return head;
+		const block = renderProcessDiagnostics(outcome.diagnostics, { maxLines: options.stderrLines });
+		return block === "" ? head : `${head}${block}`;
+	}
+	const { result } = outcome;
+	if (result.conclusion === "deterministic") return `${DETERMINISM_HEADING}\n→ 같은 초기 상태에서 2회 실행한 결과가 모든 케이스에서 같습니다. ${determinismCounts(result)}\n`;
+	if (result.conclusion === "consistentWithoutReset") return `${DETERMINISM_HEADING}\n→ 2회 실행 결과가 같았습니다. ${determinismCounts(result)}\n→ 단, 실행 사이에 상태를 복원하지 않았으므로 결정론성 확인은 아닙니다.
+  --reset-cmd 로 초기 상태 복원 명령을 지정하면 확인이 됩니다.
+`;
+	const suffix = result.skipped === 0 ? "" : ` (제외 ${result.skipped}: 실행되지 않은 케이스)`;
+	const blocks = result.differences.map((difference) => (0, _mcpeak_runner.describeDeterminismDifference)(difference, { stateRestored: options.stateRestored })).join("\n\n");
+	return `${DETERMINISM_HEADING}\n→ ${result.differences.length}/${result.compared} 케이스에서 2회 실행 결과가 다릅니다.${suffix}\n\n${blocks}\n`;
+}
+/** 초기화 명령 실패 안내. 한 줄로 유지한다. hint 의 개행은 format 이 이스케이프한다. */
+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}`;
+	return {
+		code: "RESET_COMMAND_FAILED",
+		message: `초기화 명령이 실패했습니다: ${error.command}`,
+		hint: `종료 코드: ${exit}.${stderr} 명령이 단독으로 성공하는지 확인한 뒤 다시 실행하세요.`
+	};
+}
+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)}`;
+	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;
+}
+function coreError(error) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (typeof value === "object" && value !== null && "name" in value && value.name === "McpClientError" && "code" in value && typeof value.code === "string" && "message" in value && typeof value.message === "string" && "hint" in value && typeof value.hint === "string") return Object.freeze({
+			name: "McpClientError",
+			code: value.code,
+			message: value.message,
+			hint: value.hint,
+			diagnostics: processDiagnostics("diagnostics" in value ? value.diagnostics : void 0)
+		});
+		if (typeof value !== "object" || value === null || seen.has(value)) return void 0;
+		seen.add(value);
+		if (value instanceof AggregateError) for (const nested of value.errors) {
+			const found = visit(nested);
+			if (found !== void 0) return found;
+		}
+	};
+	return visit(error);
+}
+function writeFailure(dependencies, failure) {
+	dependencies.writeStderr(format(failure));
+	return 1;
+}
+async function runCli(argv, dependencies) {
+	if (argv.length === 0) return writeFailure(dependencies, {
+		code: "CLI_USAGE",
+		message: "실행할 CLI 명령이 없습니다.",
+		hint: TEST_USAGE_HINT
+	});
+	if (argv[0] !== "test") {
+		if ([
+			"generate",
+			"record",
+			"mock"
+		].includes(argv[0] ?? "")) return writeFailure(dependencies, {
+			code: "COMMAND_NOT_IMPLEMENTED",
+			message: `'${argv[0]}' 명령은 아직 구현되지 않았습니다.`,
+			hint: "현재는 test 명령만 사용할 수 있습니다."
+		});
+		return writeFailure(dependencies, {
+			code: "CLI_USAGE",
+			message: `알 수 없는 CLI 명령 '${argv[0]}'입니다.`,
+			hint: TEST_USAGE_HINT
+		});
+	}
+	let input;
+	try {
+		input = parseTestCommand(argv.slice(1));
+	} catch (error) {
+		return error instanceof CliCommandError ? writeFailure(dependencies, error.failure) : writeFailure(dependencies, {
+			code: "CLI_INTERNAL_ERROR",
+			...dictionary.CLI_INTERNAL_ERROR
+		});
+	}
+	if ((0, node_path.extname)(input.suitePath).toLowerCase() !== ".json") return writeFailure(dependencies, {
+		code: "SUITE_FORMAT_UNSUPPORTED",
+		...dictionary.SUITE_FORMAT_UNSUPPORTED
+	});
+	let bytes;
+	try {
+		bytes = await dependencies.readFile(input.suitePath);
+	} catch {
+		return writeFailure(dependencies, {
+			code: "SUITE_READ_FAILED",
+			...dictionary.SUITE_READ_FAILED
+		});
+	}
+	let decoded;
+	try {
+		decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		return writeFailure(dependencies, {
+			code: "SUITE_ENCODING_INVALID",
+			...dictionary.SUITE_ENCODING_INVALID
+		});
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(decoded);
+	} catch {
+		return writeFailure(dependencies, {
+			code: "SUITE_JSON_INVALID",
+			...dictionary.SUITE_JSON_INVALID
+		});
+	}
+	let validated;
+	try {
+		validated = dependencies.validateSuite(parsed);
+	} catch {
+		return writeFailure(dependencies, {
+			code: "CLI_INTERNAL_ERROR",
+			...dictionary.CLI_INTERNAL_ERROR
+		});
+	}
+	if (!validated.valid) return writeFailure(dependencies, {
+		code: "SUITE_VALIDATION_FAILED",
+		...dictionary.SUITE_VALIDATION_FAILED,
+		issues: validated.issues
+	});
+	/**
+	* 지문 대조는 서버 연결 전에 끝낸다. 연결이 실패해도 파일에 대한 사실은 변하지 않는다.
+	* dependencies 에 주입 지점을 두지 않는다. 순수 함수이고 외부 자원을 안 쓰므로, 주입하면
+	* 테스트가 실제 대조 로직을 안 거치게 된다. 설계 문서 §7.
+	*/
+	const specApproval = checkSpecApproval(validated.value);
+	const runReset = dependencies.runResetCommand ?? runResetCommand;
+	/**
+	* 복원은 시험 실행을 **시작하기 전**이다. 실패하면 서버를 띄우지 않는다. 되돌리지 못한
+	* 상태 위에서 돌린 결과는 판정 근거가 될 수 없기 때문이다(설계 문서 §5.2, ADR-0023).
+	*/
+	if (input.resetCmd !== void 0) try {
+		await runReset(input.resetCmd);
+	} catch (error) {
+		return writeFailure(dependencies, error instanceof ResetCommandError ? resetFailure(error) : {
+			code: "CLI_INTERNAL_ERROR",
+			...dictionary.CLI_INTERNAL_ERROR
+		});
+	}
+	let connection;
+	try {
+		connection = await dependencies.connect({
+			command: input.command,
+			args: input.args
+		});
+	} catch (error) {
+		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,
+			coreCode: core.code
+		});
+		const diagnostics = core?.diagnostics;
+		if (input.stderrLines > 0 && diagnostics !== void 0 && hasDiagnosticContent(diagnostics)) {
+			const block = renderProcessDiagnostics(diagnostics, { maxLines: input.stderrLines });
+			if (block !== "") dependencies.writeStderr(`\n${block}`);
+		}
+		return failed;
+	}
+	/** 진단 출력 실패가 판정을 바꾸면 안 된다. getDiagnostics 가 던지면 삼킨다. §4.3.1. */
+	const snapshotDiagnostics = () => {
+		try {
+			return { value: connection.getDiagnostics() };
+		} catch {
+			return { value: void 0 };
+		}
+	};
+	/**
+	* 블록 앞에는 항상 빈 줄을 둔다. 오류 메시지 뒤든 보고서 뒤든 같은 터미널에 이어 나오므로
+	* 경로마다 레이아웃이 달라질 이유가 없다. 설계 문서 §7.
+	* snapshot 을 주면 그 값을 쓴다. 우리가 프로세스를 정리한 뒤의 상태를 서버 탓으로 보고하지
+	* 않기 위해서다(설계 문서 §4.3).
+	*/
+	const writeDiagnostics = (snapshot) => {
+		if (input.stderrLines === 0) return;
+		const diagnostics = (snapshot ?? snapshotDiagnostics()).value;
+		if (diagnostics === void 0) return;
+		if (!hasDiagnosticContent(diagnostics)) return;
+		const block = renderProcessDiagnostics(diagnostics, { maxLines: input.stderrLines });
+		if (block === "") return;
+		dependencies.writeStderr(`\n${block}`);
+	};
+	/**
+	* 비차단 진단용 툴 목록. 실패하면 조용히 빈 배열로 둔다. 로그도 남기지 않는다. 진단이 실행을
+	* 깨뜨리면 안 되고, 실패 원인과 무관한 줄이 보고서에 섞이면 정작 필요한 줄이 안 읽힌다.
+	* 설계 문서 §7.1.
+	*/
+	const tools = await (async () => {
+		try {
+			return await connection.client.listTools();
+		} catch {
+			return [];
+		}
+	})();
+	/**
+	* 캡처 래퍼는 `--determinism` 일 때만 만든다. 플래그가 없으면 기존 경로와 호출·객체가
+	* 완전히 같다. 캡처 비용 0 이 설계 문서 §5.1 의 조건이다.
+	*/
+	const firstCapture = input.determinism ? createDeterminismCapture(connection.client) : void 0;
+	/**
+	* 러너에 넘기는 client 다. **`shutdown.client` 는 반드시 이것과 같은 객체여야 한다.**
+	* `finalizeRunnerExecution` 이 `runSuite` 에 바인딩된 client 와 대조해 다르면 TypeError 를
+	* 던지고(`runner/src/shutdown.ts` 의 `boundClient`), 그러면 종료 절차가 통째로 건너뛰어져
+	* 서버 프로세스가 남는다. 한쪽만 감싸면 정확히 그 일이 난다.
+	*/
+	const firstClient = firstCapture?.client ?? connection.client;
+	const shutdown = {
+		client: firstClient,
+		close: () => connection.close(),
+		forceClose: (_reason) => connection.forceClose()
+	};
+	let execution;
+	try {
+		execution = dependencies.startRunner(firstCapture === void 0 ? {
+			client: firstClient,
+			suite: validated.value
+		} : {
+			client: firstClient,
+			suite: validated.value,
+			onEvent: firstCapture.onEvent
+		});
+	} catch {
+		const snapshot = snapshotDiagnostics();
+		try {
+			await connection.forceClose();
+		} catch {}
+		const failed = writeFailure(dependencies, {
+			code: "RUNNER_EXECUTION_FAILED",
+			...dictionary.RUNNER_EXECUTION_FAILED
+		});
+		writeDiagnostics(snapshot);
+		return failed;
+	}
+	let finalReport;
+	try {
+		finalReport = await dependencies.finalize({
+			execution,
+			shutdown
+		});
+	} catch {
+		const failed = writeFailure(dependencies, {
+			code: "RUNNER_FINALIZATION_FAILED",
+			...dictionary.RUNNER_FINALIZATION_FAILED
+		});
+		writeDiagnostics();
+		return failed;
+	}
+	const allPassed = finalReport.status === "passed";
+	/**
+	* XML 파일을 stdout 보다 **먼저** 쓴다. stdout 은 `| head` 같은 파이프에서 EPIPE 로 깨질 수
+	* 있는데, 그때 사용자가 `--junit` 으로 명시적으로 요청한 산출물까지 함께 잃을 이유가 없다.
+	* `--junit` 을 주지 않으면 이 블록을 통째로 건너뛰므로 기존 순서와 동일하다. ADR-0019.
+	*/
+	if (input.junitPath !== void 0) {
+		let xml;
+		try {
+			xml = dependencies.renderJUnit(finalReport);
+		} catch {
+			return writeFailure(dependencies, {
+				code: "CLI_INTERNAL_ERROR",
+				...dictionary.CLI_INTERNAL_ERROR
+			});
+		}
+		try {
+			await dependencies.writeFile(input.junitPath, xml);
+		} catch {
+			return writeFailure(dependencies, {
+				code: "JUNIT_WRITE_FAILED",
+				...dictionary.JUNIT_WRITE_FAILED
+			});
+		}
+	}
+	/**
+	* 2회차. `--determinism` 일 때만 돈다. **서버 프로세스를 새로 띄운다.** 1회차 연결은 위
+	* `finalize` 의 종료 절차로 이미 닫혔고, 프로세스 내부 상태도 초기화 대상이라 연결을
+	* 재사용하지 않는다(설계 문서 §5.2).
+	*
+	* 이 블록의 실패는 **CLI 오류로 던지지 않는다.** 1회차 판정과 종료 코드는 이미 정해졌고,
+	* 관찰이 실패했다고 시험 판정을 뒤집으면 안 된다. 2회차 문제는 결정론성 블록 안의
+	* 문장으로만 존재한다(설계 문서 §7).
+	*/
+	const determinismOutcome = await (async () => {
+		if (firstCapture === void 0) return void 0;
+		const snapshotOf = (target) => {
+			try {
+				return target.getDiagnostics();
+			} catch {
+				return;
+			}
+		};
+		if (input.resetCmd !== void 0) try {
+			await runReset(input.resetCmd);
+		} catch (error) {
+			return {
+				kind: "incomplete",
+				reason: error instanceof ResetCommandError ? `2회차 전 초기화 명령 실패: ${error.command}` : "2회차 전 초기화 명령 실패"
+			};
+		}
+		let second;
+		try {
+			second = await dependencies.connect({
+				command: input.command,
+				args: input.args
+			});
+		} catch (error) {
+			const core = coreError(error);
+			return {
+				kind: "incomplete",
+				reason: "서버 연결 실패",
+				...core?.diagnostics === void 0 ? {} : { diagnostics: core.diagnostics }
+			};
+		}
+		const secondCapture = createDeterminismCapture(second.client);
+		let secondExecution;
+		try {
+			secondExecution = dependencies.startRunner({
+				client: secondCapture.client,
+				suite: validated.value,
+				onEvent: secondCapture.onEvent
+			});
+		} catch {
+			const snapshot = snapshotOf(second);
+			try {
+				await second.forceClose();
+			} catch {}
+			return {
+				kind: "incomplete",
+				reason: "2회차 실행 시작 실패",
+				...snapshot === void 0 ? {} : { diagnostics: snapshot }
+			};
+		}
+		let secondReport;
+		try {
+			secondReport = await dependencies.finalize({
+				execution: secondExecution,
+				shutdown: {
+					client: secondCapture.client,
+					close: () => second.close(),
+					forceClose: (_reason) => second.forceClose()
+				}
+			});
+		} catch {
+			const snapshot = snapshotOf(second);
+			try {
+				await second.forceClose();
+			} catch {}
+			return {
+				kind: "incomplete",
+				reason: "2회차 실행 또는 서버 종료 실패",
+				...snapshot === void 0 ? {} : { diagnostics: snapshot }
+			};
+		}
+		if (secondReport.status === "aborted") {
+			const snapshot = snapshotOf(second);
+			const stop = secondReport.stopReason;
+			return {
+				kind: "incomplete",
+				reason: stop?.type === "timeout" ? `2회차 케이스 타임아웃 (${stop.caseId})` : stop?.type === "abortSignal" ? "2회차 실행 중단" : "2회차 실행 미완주",
+				...snapshot === void 0 ? {} : { diagnostics: snapshot }
+			};
+		}
+		try {
+			return {
+				kind: "compared",
+				result: (dependencies.checkDeterminism ?? _mcpeak_runner.checkDeterminism)({
+					first: firstCapture.observations(),
+					second: secondCapture.observations(),
+					stateRestored: input.resetCmd !== void 0
+				})
+			};
+		} catch {
+			return { kind: "internal" };
+		}
+	})();
+	/**
+	* 툴 목록이 비면 입력 계약 대조는 건너뛴다. 목록이 비었을 때 대조하면 모든 케이스가
+	* `TOOL_NOT_DECLARED` 로 걸려 실패 원인과 무관한 줄만 늘어난다. 단언 실질성은 툴이 필요
+	* 없으므로 항상 돈다. 표시는 실패한 케이스에 한한다. 설계 문서 §7.
+	*
+	* 검사가 던져도 판정과 exit code 는 바뀌지 않아야 하므로 삼킨다. `validated.value` 는 이미
+	* `validateMcpSuite` 를 통과했으니 도달할 일이 없는 경로이고, 도달했다면 그것은 비차단
+	* 진단의 결함이지 대상 서버의 결함이 아니다.
+	*/
+	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, []);
+		try {
+			const inputContract = dependencies.checkInputContract ?? _mcpeak_runner.checkInputContract;
+			const assertionSubstance = dependencies.checkAssertionSubstance ?? _mcpeak_runner.checkAssertionSubstance;
+			const found = [...tools.length === 0 ? [] : inputContract({
+				suite: validated.value,
+				tools
+			}).findings, ...assertionSubstance(validated.value).findings];
+			for (const finding of found) buckets.get(finding.caseId)?.push(finding);
+			return [...buckets.values()].flat();
+		} catch {
+			return [];
+		}
+	})();
+	/**
+	* 참고 문장을 붙일 케이스. 승인 시점에 `serverDefect` 로 표시했는데 지금 또 실패한 것들이다.
+	* 설계 문서 §9.
+	*
+	* **지문이 일치할 때만 본다.** 명세가 바뀌었으면 승인 시점의 판정이 지금 케이스에 해당하는지
+	* 알 수 없다. 지문이 없으면 `approval.cases` 도 없으므로 이 집합은 비어 있다.
+	* `serverDefect` 케이스가 통과하면 침묵한다. `test` 화면은 실패를 보는 자리다.
+	*/
+	const serverDefectCases = (() => {
+		if (specApproval.state !== "matched") return /* @__PURE__ */ new Set();
+		const statuses = caseApprovalStatuses(validated.value);
+		if (statuses.size === 0) return /* @__PURE__ */ new Set();
+		return new Set(finalReport.cases.filter((item) => item.status !== "passed" && statuses.get(item.spec.id) === "serverDefect").map((item) => item.spec.id));
+	})();
+	try {
+		if (input.json) {
+			/**
+			* `spec` 은 억제 규칙과 무관하게 항상 넣는다. 기계가 읽는 출력에서 키가 조건부로
+			* 사라지면 소비자가 분기를 하나 더 써야 한다. 설계 문서 §7.3.
+			* `approvedFingerprint` 는 absent 일 때 키 자체가 없어야 하므로 조건부로 넣는다.
+			*/
+			const spec = {
+				approval: specApproval.state,
+				fingerprint: specApproval.fingerprint,
+				findings: specFindings.map(({ code, severity, caseId, path }) => ({
+					code,
+					severity,
+					caseId,
+					path
+				}))
+			};
+			if (specApproval.approvedFingerprint !== void 0) spec.approvedFingerprint = specApproval.approvedFingerprint;
+			/**
+			* 승인 시점 판정은 파일에 적힌 그대로 싣는다. 지문이 불일치여도 억제하지 않는다.
+			* 텍스트 참고 문장을 지문 불일치에 억제하는 것은 사람이 읽는 화면의 규칙이고, 기계는
+			* `spec.approval` 로 불일치를 이미 안다. 설계 문서 §9.
+			* `approvedFingerprint` 와 같은 이유로 없을 때는 키 자체를 만들지 않는다.
+			*/
+			const approvedCases = validated.value.approval?.cases;
+			if (approvedCases !== void 0) spec.cases = approvedCases;
+			/**
+			* 결정론성은 비교까지 갔을 때만 키를 만든다. `--determinism` 이 없으면 기존 JSON 이
+			* 바이트 그대로여야 하고(설계 문서 §8), 비교를 못 한 경우에는 실어야 할
+			* `DeterminismResult` 자체가 없다. 그 사실은 아래에서 stderr 로 알린다.
+			*/
+			const machine = determinismOutcome?.kind === "compared" ? {
+				...finalReport,
+				spec,
+				determinism: determinismOutcome.result
+			} : {
+				...finalReport,
+				spec
+			};
+			dependencies.writeStdout(`${JSON.stringify(machine, null, 2)}\n`);
+		} else {
+			dependencies.writeStdout(dependencies.renderReport(finalReport, { color: dependencies.colorEnabled }));
+			/**
+			* 참고 문장은 보고서 뒤, 명세 승인 블록 앞이다. 케이스마다 한 블록으로 묶는다.
+			* 순서는 `runner` 가 정한 finding 순서이고 여기서 다시 정렬하지 않는다. 설계 문서 §7.2.
+			*/
+			if (specFindings.length > 0 || serverDefectCases.size > 0) {
+				const byCase = /* @__PURE__ */ new Map();
+				for (const finding of specFindings) {
+					const list = byCase.get(finding.caseId) ?? [];
+					list.push(finding);
+					byCase.set(finding.caseId, list);
+				}
+				/**
+				* 케이스 순서는 보고서가 정한다. `specFindings` 의 순서도 같은 출처에서 나오므로
+				* 여기서 다시 정렬해도 기존 순서가 그대로다. 승인 판정만 있고 finding 이 없는 케이스는
+				* `byCase` 에 없어서 이 목록으로 순회해야 빠지지 않는다.
+				*/
+				for (const item of finalReport.cases) {
+					if (item.status === "passed") continue;
+					const caseId = item.spec.id;
+					const list = byCase.get(caseId) ?? [];
+					for (const group of FINDING_GROUP_ORDER) {
+						const grouped = list.filter((finding) => FINDING_GROUP[finding.code] === group);
+						if (grouped.length === 0) continue;
+						dependencies.writeStdout(`\n${FINDING_HEADING[group](escapeTerminalText(caseId))}\n${grouped.map((finding) => `  → ${(0, _mcpeak_runner.describeSpecFinding)(finding)}\n`).join("")}`);
+					}
+					if (serverDefectCases.has(caseId)) dependencies.writeStdout(`\n${SERVER_DEFECT_NOTE_LINE}`);
+				}
+			}
+			if (shouldShowSpecApproval(specApproval, allPassed)) dependencies.writeStdout(`\n${renderSpecApproval(specApproval)}`);
+			/**
+			* 결정론성 블록은 보고서 뒤, 다른 블록과 같은 레이아웃 규칙(앞에 빈 줄)을 따른다.
+			* `--determinism` 없이는 한 줄도 찍지 않는다. 설계 문서 §8.
+			*/
+			if (determinismOutcome !== void 0) dependencies.writeStdout(`\n${renderDeterminism(determinismOutcome, {
+				stateRestored: input.resetCmd !== void 0,
+				stderrLines: input.stderrLines
+			})}`);
+		}
+		/**
+		* 기계가 읽는 출력에서는 비교 실패 사실이 사라진다(키를 만들지 않으므로). 그대로 두면
+		* 사용자는 왜 키가 없는지 알 수 없다. stdout 은 JSON 전용이므로 stderr 에 적는다.
+		*/
+		if (input.json && determinismOutcome !== void 0 && determinismOutcome.kind !== "compared") dependencies.writeStderr(`\n${renderDeterminism(determinismOutcome, {
+			stateRestored: input.resetCmd !== void 0,
+			stderrLines: input.stderrLines
+		})}`);
+	} catch {
+		return writeFailure(dependencies, {
+			code: "CLI_INTERNAL_ERROR",
+			...dictionary.CLI_INTERNAL_ERROR
+		});
+	}
+	const settled = snapshotDiagnostics();
+	if (!allPassed || settled.value !== void 0 && isAbnormalExit(settled.value)) writeDiagnostics(settled);
+	/**
+	* repair 번들. 스냅샷을 그대로 쓴다. 우리가 프로세스를 정리한 뒤의 상태를 다시 읽으면 그
+	* 상태를 서버 탓으로 적게 된다. `--repair-bundle` 을 주지 않으면 이 블록을 통째로 건너뛰므로
+	* 기존 경로의 출력과 종료 코드가 그대로다. 계획서 완료 조건 2.
+	*/
+	if (input.repairBundlePath !== void 0) {
+		const bundle = buildRepairBundle({
+			report: finalReport,
+			suite: validated.value,
+			specApproval,
+			processDiagnostics: settled.value
+		});
+		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
+			});
+		}
+	}
+	return allPassed ? 0 : 1;
+}
+//#endregion
+Object.defineProperty(exports, "GLOBAL_HELP", {
+	enumerable: true,
+	get: function() {
+		return GLOBAL_HELP;
+	}
+});
+Object.defineProperty(exports, "ReplayRuntimeUnavailableError", {
+	enumerable: true,
+	get: function() {
+		return ReplayRuntimeUnavailableError;
+	}
+});
+Object.defineProperty(exports, "VERIFY_USAGE_HINT", {
+	enumerable: true,
+	get: function() {
+		return VERIFY_USAGE_HINT;
+	}
+});
+Object.defineProperty(exports, "commandHelp", {
+	enumerable: true,
+	get: function() {
+		return commandHelp;
+	}
+});
+Object.defineProperty(exports, "nodeGenerateDependencies", {
+	enumerable: true,
+	get: function() {
+		return nodeGenerateDependencies;
+	}
+});
+Object.defineProperty(exports, "nodeReviewIO", {
+	enumerable: true,
+	get: function() {
+		return nodeReviewIO;
+	}
+});
+Object.defineProperty(exports, "parseRepairCommand", {
+	enumerable: true,
+	get: function() {
+		return parseRepairCommand;
+	}
+});
+Object.defineProperty(exports, "parseReplayCommand", {
+	enumerable: true,
+	get: function() {
+		return parseReplayCommand;
+	}
+});
+Object.defineProperty(exports, "parseTestCommand", {
+	enumerable: true,
+	get: function() {
+		return parseTestCommand;
+	}
+});
+Object.defineProperty(exports, "runCli", {
+	enumerable: true,
+	get: function() {
+		return runCli;
+	}
+});
+Object.defineProperty(exports, "runGenerateCommand", {
+	enumerable: true,
+	get: function() {
+		return runGenerateCommand;
+	}
+});
+Object.defineProperty(exports, "runRepairCommand", {
+	enumerable: true,
+	get: function() {
+		return runRepairCommand;
+	}
+});
+Object.defineProperty(exports, "runReplayCommand", {
+	enumerable: true,
+	get: function() {
+		return runReplayCommand;
+	}
+});
+Object.defineProperty(exports, "version", {
+	enumerable: true,
+	get: function() {
+		return version;
+	}
+});