@mcpeak/cli 0.11.0 → 0.12.0

package/dist/{test-command-B_faNSfA.cjs → test-command-1m3myzTS.cjs}

@@ -1,12 +1,13 @@
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let node_readline_promises = require("node:readline/promises");
+let _mcpeak_generate = require("@mcpeak/generate");
 let _mcpeak_runner = require("@mcpeak/runner");
 let node_child_process = require("node:child_process");
 let _mcpeak_core = require("@mcpeak/core");
 let node_fs = require("node:fs");
 //#region package.json
-var version = "0.11.0";
+var version = "0.12.0";
 //#endregion
 //#region src/repair-render.ts
 /**
@@ -43,12 +44,21 @@ const APPROVAL_LABEL = {
 	mismatched: "승인 지문 불일치",
 	absent: "승인 지문 없음"
 };
+const RUN_HISTORY_LABEL = {
+	present: "실행 기록 있음",
+	absent: "실행 기록 없음"
+};
+/**
+* 명세를 오라클로 볼 수 있는가. `generate` 의 `specIsOracle` 과 같은 뜻이지만 여기서 다시
+* 판정한다. 화면 렌더러는 진단 통로를 로드하지 않는다(설계서 §4.5).
+*/
+const isOracle = (bundle) => bundle.spec.approval === "matched" && bundle.spec.runHistory === "present";
 /**
 * 지문이 승인 상태가 아닐 때 결과 맨 위에 붙는 블록. 결과가 `unsure` 여도 붙는다. 설계서 §6.5.
 * `matched` 면 빈 문자열이다.
 */
-function renderApprovalNotice(approval) {
-	if (approval === "matched") return "";
+function renderApprovalNotice(approval, runHistory) {
+	if (approval === "matched") return runHistory === "present" ? "" : "⚠ 이 명세는 승인 지문이 일치하지만 실제 서버 실행 기록이 없습니다.\n  --baseline-only 나 --no-dry-run 으로 저장하면 케이스가 한 번도 실행되지 않은 채 승인됩니다.\n  입력값이 생성 시점의 자리값일 수 있어, 아래 제안은 명세 쪽 원인도 함께 받았습니다.\n\n";
 	if (approval === "mismatched") return "⚠ 이 명세는 승인 상태가 아닙니다 (지문 불일치).\n  실패 원인이 서버가 아니라 명세일 수 있습니다. 아래 제안은 그 전제로 받았습니다.\n\n";
 	return "⚠ 이 명세는 승인 지문이 없습니다.\n  실제 서버로 검증된 적이 없는 명세일 수 있습니다. 아래 제안은 그 전제로 받았습니다.\n\n";
 }
@@ -61,6 +71,7 @@ function kilobytes(bytes) {
 */
 function renderRepairConfirm(view) {
 	const scope = view.omittedFailures === 0 ? `실패 ${view.totalFailures}건 중 ${view.sentFailures}건` : `실패 ${view.totalFailures}건 중 ${view.sentFailures}건 (--max-cases ${view.maxCases}, ${view.omittedFailures}건 제외)`;
+	const toolLine = view.omittedToolSchemas === 0 ? `${view.sentTools}개` : `${view.sentTools}개 (스키마 제외 ${view.omittedToolSchemas}개)`;
 	let stderrLine;
 	if (!view.includeStderr) stderrLine = "(전송하지 않음)";
 	else if (view.stderr === void 0 || view.stderr === "") stderrLine = "없음";
@@ -74,7 +85,8 @@ function renderRepairConfirm(view) {
 		"\n",
 		`  provider   ${view.providerId} (${escapeTerminalText$2(view.model)})\n`,
 		`  대상       ${scope}\n`,
-		`  명세 상태  ${APPROVAL_LABEL[view.approval]}\n`,
+		`  명세 상태  ${APPROVAL_LABEL[view.approval]} · ${RUN_HISTORY_LABEL[view.runHistory]}\n`,
+		`  도구       ${toolLine}\n`,
 		`  stderr     ${stderrLine}\n`,
 		`  전송 크기  ${kilobytes(view.requestBytes)}\n`,
 		"\n",
@@ -130,7 +142,7 @@ function renderRepairResult(options) {
 	const parts = [
 		`── 서버 수정 방향 (${options.providerId} / ${escapeTerminalText$2(options.model)}) ──\n`,
 		"\n",
-		renderApprovalNotice(options.bundle.spec.approval)
+		renderApprovalNotice(options.bundle.spec.approval, options.bundle.spec.runHistory)
 	];
 	if (options.result.status === "unsure") {
 		/**
@@ -166,7 +178,7 @@ function renderRepairResult(options) {
 				parts.push(`  원인 후보  ${escapeTerminalText$2(cause.summary)}\n`);
 				if (cause.location !== "") parts.push(`  확인할 곳  ${escapeTerminalText$2(cause.location)}\n`);
 				if (cause.evidence !== "") parts.push(`  근거       ${escapeTerminalText$2(cause.evidence)}\n`);
-				if (cause.target === "spec" && options.bundle.spec.approval !== "matched") parts.push("  분류       명세 쪽 원인으로 봄\n");
+				if (cause.target === "spec" && !isOracle(options.bundle)) parts.push("  분류       명세 쪽 원인으로 봄\n");
 			}
 		}
 	}
@@ -241,6 +253,11 @@ function echoValue(value) {
 */
 const SECRET_INPUT_HINT = "값은 셸 히스토리에 남지 않게 넣으세요. 예: `read -rs MCP_TOKEN; export MCP_TOKEN`";
 /**
+* 같은 `read -rs` 예시를 명령줄 모양 그대로 둔 것. `--env` 안내가 올바른 호출 예시 바로 위에
+* 적는다. `MCP_TOKEN` 자리는 `replaceAll` 로 실제 이름으로 바꿔 쓴다.
+*/
+const SECRET_ENV_EXAMPLE = "     read -rs MCP_TOKEN; export MCP_TOKEN";
+/**
 * `--url` 값을 검증한다.
 *
 * 스킴을 http·https 로 제한한다. `file:` 이나 `ws:` 를 넘기면 `core` 의 SDK 안쪽에서
@@ -296,6 +313,34 @@ function createHeaderEnvCollector() {
 		snapshot: () => Object.freeze({ ...values })
 	};
 }
+/**
+* `--env <NAME>` 값 하나를 검사한다. **이름만** 받는다. 값을 여기 넣으면 `ps` 와 셸
+* 히스토리와 녹화 출처에 그대로 남는다. 그것이 이 옵션이 이름만 받는 이유고, 거절 문장이
+* 그 이유를 말해야 한다.
+*
+* `NODE_OPTIONS` 와 `MCPEAK_*` 는 External 배선이 자식 환경에 직접 쓰는 이름이다. 배선이
+* 사용자 값 **뒤에** 얹히므로 덮이지는 않지만, 받아 놓고 조용히 덮어쓰면 "막은 척" 이 된다.
+*/
+function parseEnvForwardOption(raw) {
+	const name = raw.trim();
+	if (name === "") return err("`--env` 옵션 값이 필요합니다.");
+	if (!ENV_NAME_PATTERN.test(name)) return err(`\`--env\` 는 환경변수 **이름**만 받습니다: '${echoValue(raw)}'\n→ 값을 명령줄에 쓰면 \`ps\` 목록과 셸 히스토리, 녹화 출처에 그대로 남기 때문입니다.
+→ 값은 환경변수에 넣고 이름만 넘기세요:
+${SECRET_ENV_EXAMPLE.replaceAll("MCP_TOKEN", "SUPABASE_ACCESS_TOKEN")}\n     mcpeak test suite.json --command npx --arg -y --arg <서버> --env SUPABASE_ACCESS_TOKEN`);
+	if (name === "NODE_OPTIONS") return err("`--env NODE_OPTIONS` 는 받지 않습니다.\n→ 부모의 `NODE_OPTIONS` 는 녹화·재생 배선이 자식에게 이미 이어 붙입니다.");
+	if (name.startsWith("MCPEAK_")) return err(`\`--env ${name}\` 는 받지 않습니다.\n→ \`MCPEAK_\` 로 시작하는 이름은 녹화·재생 배선이 자식 환경에 직접 씁니다. 사용자 값이 그것을 덮으면 녹화가 조용히 꺼집니다.`);
+	return ok(name);
+}
+function createEnvForwardCollector() {
+	const names = [];
+	return {
+		add(name) {
+			if (names.includes(name)) return `\`--env ${name}\` 이 두 번 있습니다. 한 번만 쓰세요.`;
+			names.push(name);
+		},
+		snapshot: () => Object.freeze([...names])
+	};
+}
 /** 대상을 사람이 읽는 한 조각으로 만든다. 오류 문장이 무엇에 붙으려 했는지 말할 때 쓴다. */
 function describeTarget(target) {
 	return target.transport === "stdio" ? [target.command, ...target.args].join(" ") : target.url;
@@ -308,13 +353,23 @@ var ConnectTargetError = class extends Error {};
 *
 * `env` 는 stdio 전용이다. External 배선이 만든 자식 환경 변수라 띄울 프로세스가 있어야
 * 뜻이 있고, 파서가 `--url` 과 External 세션 옵션의 동시 사용을 이미 막는다.
+*
+* 자식 환경은 세 겹이고 순서가 계약이다(설계 §4.1):
+* SDK 기본 허용 목록 < `--env` 로 넘긴 것 < External 배선(`options.env`).
+* 배선이 마지막이다. 배선 변수가 사용자 값에 덮이면 녹화가 조용히 꺼진다.
 */
 async function openConnection(target, dependencies, options) {
-	if (target.transport === "stdio") return await dependencies.connectStdio({
-		command: target.command,
-		args: target.args,
-		...options?.env === void 0 ? {} : { env: options.env }
-	});
+	if (target.transport === "stdio") {
+		const env = {
+			...resolveForwardedEnv(target.envNames, dependencies.readEnv),
+			...options?.env
+		};
+		return await dependencies.connectStdio({
+			command: target.command,
+			args: target.args,
+			...Object.keys(env).length === 0 ? {} : { env }
+		});
+	}
 	const connectHttp = dependencies.connectHttp;
 	if (connectHttp === void 0) throw new ConnectTargetError("이 진입점은 원격(Streamable HTTP) 서버를 지원하지 않습니다.\n→ `--url` 대신 `--command` 로 서버를 직접 띄우세요.");
 	const headers = resolveHeaders(target.headerEnv, dependencies.readEnv);
@@ -355,6 +410,22 @@ function resolveHeaders(headerEnv, readEnv) {
 	}
 	return ok(headers);
 }
+/**
+* `--env` 이름을 값으로 바꾼다. **비어 있으면 이름만 말한다.** 값이 비었다는 사실을 알리려다
+* 값을 화면에 찍으면 이 옵션이 존재하는 이유가 없어진다(ADR-0070 §3).
+*/
+function resolveForwardedEnv(names, readEnv) {
+	if (names.length === 0) return {};
+	if (readEnv === void 0) throw new ConnectTargetError("이 진입점은 `--env` 를 지원하지 않습니다.\n→ 환경변수를 읽는 주입점(readEnv)이 배선되지 않았습니다.");
+	const env = {};
+	for (const name of names) {
+		const value = readEnv(name);
+		if (value === void 0 || value === "") throw new ConnectTargetError(`환경변수 \`${name}\` 가 비어 있습니다.\n→ 값을 넣고 다시 실행하세요:
+${SECRET_ENV_EXAMPLE.replaceAll("MCP_TOKEN", name)}`);
+		env[name] = value;
+	}
+	return env;
+}
 //#endregion
 //#region src/dry-run.ts
 /** 보고서가 상한을 넘긴 경우의 안내. 케이스 수 말고는 사용자가 손댈 수 있는 것이 없다. */
@@ -389,6 +460,24 @@ const caseBlocks = (report) => {
 	}
 	return report.cases.map((_, index) => (blocks[index] ?? []).join("\n"));
 };
+/** `renderReport` 가 건너뛴 단언 줄에 붙이는 표시. reporter.ts 와 같은 값이다. */
+const SKIPPED_MARK$1 = "(건너뜀) ";
+/** 케이스 본문 줄에서 들여쓰기를 벗긴다. 들여쓰기가 없는 줄은 본문이 아니다. */
+const bodyLines$1 = (block) => block.split("\n").filter((line) => line.startsWith(INDENT$1)).map((line) => line.slice(4));
+/**
+* 실패 사유 첫 줄을 고른다. **문장을 새로 만들지 않고 렌더된 블록에서 고르기만 한다.**
+*
+* 판정은 구조화된 값으로 한다. `operation.status` 와 `assertions[].status` 가 이미 사실을
+* 담고 있는데 렌더 문자열을 다시 파싱하면, 문안이 바뀌는 날 조용히 어긋난다. `(건너뜀) ` 줄을
+* 실패한 단언으로 읽던 것이 정확히 그 방식의 결과다(설계 §3.3).
+*/
+const failureLineOf = (result, block) => {
+	const body = bodyLines$1(block);
+	if (result.operation.status !== "completed") return body[0] ?? "";
+	const failed = result.assertions.find((assertion) => assertion.status === "failed");
+	if (failed === void 0) return "";
+	return body.find((line) => line.startsWith(failed.spec.type) && !line.includes(SKIPPED_MARK$1)) ?? "";
+};
 /**
 * 연결 상실 사유별 문장. `runner` 의 `reporter.ts`·`junit.ts` 가 쓰는 어휘를 그대로 따른다.
 * 같은 죽음을 `test` 에서 볼 때와 `generate` 에서 볼 때 다른 낱말로 부르면 두 번 배우게 된다.
@@ -446,6 +535,8 @@ const toResult = (report) => {
 		status: result.status,
 		detail: blocks[index] ?? "",
 		rejectionBasis: result.rejectionBasis,
+		operationFailed: result.operation.status !== "completed",
+		failureLine: failureLineOf(result, blocks[index] ?? ""),
 		...result.rejectionBody === void 0 ? {} : { rejectionBody: result.rejectionBody }
 	}));
 	const aborted = abortedFromStop(report);
@@ -644,7 +735,22 @@ const REMOTE_TARGET_OPTIONS = `  --url <URL>           이미 떠 있는 Streama
                         남기 때문입니다. 값을 넣을 때도 히스토리에 남기지 마세요:
                           read -rs MCP_TOKEN; export MCP_TOKEN
                           mcpeak … --header-env Authorization=MCP_TOKEN`;
-const TEST_USAGE = "사용법: mcpeak test <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] | --url <URL> [--header-env <헤더이름>=<환경변수이름> ...]) [--determinism] [--reset-cmd <command>] [--json] [--junit <path>] [--repair-bundle <path>] [--stderr-lines <N>] [--session <path> | --record-session <path>]";
+/**
+* stdio 대상의 환경변수 전달 옵션. `test` 와 `generate` 가 같은 문장을 쓴다.
+*
+* `--env` 가 이름만 받는 이유를 여기서 말한다. 이유를 모르면 사용자는 `--arg KEY=값` 이나
+* `--command env` 래퍼로 우회하고, 그것이 이 옵션이 막으려던 노출이다. `--header-env` 와 같은
+* 근거다.
+*/
+const ENV_FORWARD_OPTION = `  --env <NAME>          부모 환경변수 NAME 을 서버 프로세스에 넘깁니다. 반복할 수 있습니다.
+                        SDK 는 HOME·PATH 등 고정 목록만 자식에게 주므로, API 키처럼 서버가
+                        환경에서 읽는 값은 이 옵션으로 이름을 지정해야 갑니다. 값을 직접
+                        받지 않는 이유는 명령줄에 쓴 토큰이 \`ps\` 목록과 셸 히스토리, 녹화
+                        출처에 그대로 남기 때문입니다. \`NODE_OPTIONS\` 와 \`MCPEAK_\` 로
+                        시작하는 이름은 녹화·재생 배선이 쓰므로 받지 않습니다:
+                          read -rs SUPABASE_ACCESS_TOKEN; export SUPABASE_ACCESS_TOKEN
+                          mcpeak … --command npx --arg -y --arg <서버> --env SUPABASE_ACCESS_TOKEN`;
+const TEST_USAGE = "사용법: mcpeak test <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] [--env <NAME> ...] | --url <URL> [--header-env <헤더이름>=<환경변수이름> ...]) [--determinism] [--reset-cmd <command>] [--json] [--junit <path>] [--repair-bundle <path>] [--stderr-lines <N>] [--session <path> | --record-session <path>]";
 /**
 * 시험 실행 옵션 설명. `--determinism` 은 툴을 2회 호출하므로 부작용이 있는 서버에서 모르고
 * 쓰면 사고가 난다. 그 경고가 사용법 한 줄에는 들어가지 않는다.
@@ -668,6 +774,7 @@ const TEST_OPTIONS = `옵션:
                         출력을 CI 로그에 남기기 전에 확인하세요
   --reset-cmd <command> 각 시험 실행 전에 이 명령을 한 번 실행합니다. 셸을 거치지
                         않으므로 파이프나 && 는 쓸 수 없습니다
+${ENV_FORWARD_OPTION}
 ${REMOTE_TARGET_OPTIONS}
   --record-session <path>
                         서버가 \`globalThis.fetch\` 로 밖에 부른 HTTP 호출만 녹화합니다.
@@ -692,7 +799,7 @@ feature\` 가 stderr 에 한 줄 찍힙니다(실측: Node 22.18.0 에서 나오
 \`node:sqlite\` 를 처음 로드할 때 한 번 나오므로 실행당 한 줄이며, 세션 옵션이 없는 실행에는
 붙지 않습니다. Node 가 그 모듈을 아직 실험적으로 표시한다는 뜻이고, **저장된 녹화는 표준
 SQLite 파일이라 영향받지 않습니다.**`;
-const GENERATE_USAGE = "사용법: mcpeak generate --out <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] | --url <URL> [--header-env <헤더이름>=<환경변수이름> ...]) [--suite-id <id>] [--name <name>] [--baseline-only] [--provider <codex|claude>] [--model <model>] [--no-dry-run] [--reset-cmd <command>] [--no-repair] [--force]";
+const GENERATE_USAGE = "사용법: mcpeak generate --out <suite.json> (-- <executable> [args...] | --command <executable> [--arg <value> ...] [--env <NAME> ...] | --url <URL> [--header-env <헤더이름>=<환경변수이름> ...]) [--suite-id <id>] [--name <name>] [--baseline-only] [--provider <codex|claude>] [--model <model>] [--no-dry-run] [--reset-cmd <command>] [--fixtures <path>] [--no-repair] [--diagnose-rejections] [--force]";
 /**
 * 시험 실행 옵션 설명. 사용법 한 줄로는 `--reset-cmd` 가 셸을 거치지 않는다는 제약을 알 수
 * 없다. 모르고 쓰면 사고가 나는 값이다.
@@ -709,13 +816,25 @@ const GENERATE_DRY_RUN_OPTIONS = `옵션:
                         달라져 재승인이 뜹니다. 고정하려면 --suite-id 와 --name 을
                         직접 지정하세요
   --no-dry-run          승인 전 시험 실행을 건너뜁니다. 케이스가 실제 서버에서 확인되지
-                        않은 채 저장됩니다
+                        않은 채 저장되고, 실행이 필요한 AI 사전보완도 건너뜁니다
   --reset-cmd <command> 시험 실행 전에 이 명령을 한 번 실행합니다. 셸을 거치지 않으므로
                         파이프나 && 는 쓸 수 없습니다
+  --fixtures <path>     실재하는 자원을 가리키는 값을 도구·필드별로 적은 JSON 파일입니다.
+                        생략하면 \`mcpeak.fixtures.json\` 을 찾고, 없으면 그냥 진행합니다.
+                        픽스처 파일에 토큰·비밀번호·API 키를 적지 마세요. 이 파일의 값은
+                        생성된 명세에 그대로 들어갑니다. 인증이 필요한 서버는 서버 기동
+                        환경변수로 자격을 넘기고, 픽스처에는 그 자격으로 접근 가능한
+                        자원 식별자만 적으세요
   --no-repair           시험 실행이 실패해도 입력값을 고쳐 다시 시도하지 않습니다.
                         실패가 곧바로 분류 화면으로 갑니다
+  --diagnose-rejections
+                        통과한 거절 케이스의 응답을 나열하고, provider 가 있으면 그 거절이
+                        입력 검증 때문인지 서버 내부 오류인지 AI 에게 참고 의견을 묻습니다.
+                        기본은 끕니다. 손으로 쓴 거절 문장은 전부 이 목록에 오르므로,
+                        서버가 잘못된 입력에 그냥 터지는지 의심될 때 켜세요
   --force               \`--out\` 경로에 파일이 있으면 지우고 새로 씁니다. 기본은 저장을
                         멈추는 것입니다
+${ENV_FORWARD_OPTION}
 ${REMOTE_TARGET_OPTIONS}`;
 const REPAIR_USAGE = "사용법: mcpeak repair <bundle.json> --provider <codex|claude> --model <model> [--max-cases <N>] [--no-stderr] [--yes]";
 /**
@@ -854,15 +973,9 @@ function renderHttpDiagnostics(diagnostics) {
 //#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  정상 응답을 기대했지만 오류 응답을 받았습니다.`;
-/**
 * 제안값의 출처를 말한다. `propose` 는 provider 가 있을 때만 배선되므로 여기 오는 값은
 * **항상 provider 가 만든 것**이다 — 그런데 전에는 서버에 귀속했다(#286).
 * 표기를 못 받은 경우에도 서버라고 말하지 않는다.
@@ -920,20 +1033,21 @@ const parseAnswer = (answer) => {
 		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 형식이다.
+*
+* 형식은 제안 유무와 **무관하게 하나다**(2026-09-13 설계 §4.5). 갈래가 둘이면 같은 화면이
+* 회차마다 다른 모양이 되고, 사용자가 무엇을 누르면 무엇이 들어가는지를 두 번 배운다.
 */
 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)}]`;
+	const parts = [`필드 ${options.index}/${options.total}`];
+	if (options.declared !== void 0) parts.push(options.declared);
+	if (options.current !== void 0) parts.push(`현재 ${JSON.stringify(options.current)}`);
+	parts.push(options.proposed === void 0 ? "엔터 = 현재 값 유지" : `엔터 = 제안 값 ${JSON.stringify(options.proposed)}`);
+	const question = `${BODY}${options.tool}.${options.field} (${parts.join(", ")}): `;
 	for (;;) {
 		const answer = await io.input(question);
 		if (answer.trim() === "") return fallback;
@@ -949,10 +1063,16 @@ const askRound = async (io, target, options) => {
 	const next = {};
 	const asked = [];
 	let unchanged = true;
+	const total = Object.keys(options.current).filter((field) => options.reuse?.get(field) === void 0).length;
+	let index = 0;
 	for (const [field, value] of Object.entries(options.current)) {
 		const cached = options.reuse?.get(field);
+		if (cached === void 0) index += 1;
 		const answered = cached === void 0 ? await askField(io, {
+			tool: target.tool,
 			field,
+			index,
+			total,
 			current: value,
 			proposed: options.proposed?.[field],
 			declared: declaredTypeOf(options.tools, target.tool, field)
@@ -974,11 +1094,27 @@ async function repairInputs(options) {
 	* 이 호출이 끝나면 사라진다(§4.6).
 	*/
 	const cache = /* @__PURE__ */ new Map();
+	/**
+	* 이 값을 누가 정했는가(#390 사양 0).
+	*
+	* 캐시에서 재사용한 필드는 **값을 준 케이스의 출처를 그대로 물려받는다.** 캐시가 값만
+	* 담으면 사람이 AI 제안을 고쳐 넣은 값이 뒤 케이스에서 "AI 제안" 으로 찍혀 화면이
+	* 거짓말을 한다.
+	*
+	* 비교는 `===` 가 아니라 `canonicalJson` 이다. 제안값이 객체나 배열일 수 있다.
+	*/
+	const originOf = (tool, field, value, proposed) => {
+		const cached = cache.get(cacheKey(tool, field));
+		if (cached !== void 0 && (0, _mcpeak_runner.canonicalJson)(cached.value) === (0, _mcpeak_runner.canonicalJson)(value)) return cached.origin;
+		if (proposed !== void 0 && Object.hasOwn(proposed, field) && (0, _mcpeak_runner.canonicalJson)(proposed[field]) === (0, _mcpeak_runner.canonicalJson)(value)) return "aiProposed";
+		return "humanRepaired";
+	};
 	/** §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(`${HEAD}[${index + 1}/${options.targets.length}] ${target.caseName}\n`);
+		options.io.write(`${BODY}${target.failureLine}\n`);
+		for (const line of target.serverMessage.split("\n").filter((line) => line !== "")) options.io.write(`${BODY}→ ${line}\n`);
 		options.io.write("\n");
 		const attempts = [];
 		const fields = Object.keys(target.input);
@@ -997,7 +1133,7 @@ async function repairInputs(options) {
 		const first = await askRound(options.io, target, {
 			current: target.input,
 			proposed,
-			reuse: new Map(reused.map((field) => [field, cache.get(cacheKey(target.tool, field))])),
+			reuse: new Map(reused.map((field) => [field, cache.get(cacheKey(target.tool, field)).value])),
 			tools: options.tools
 		});
 		if (first.unchanged) {
@@ -1013,10 +1149,17 @@ async function repairInputs(options) {
 		for (const [field, value] of Object.entries(first.input)) attempts.push({
 			field,
 			value,
-			passed: firstVerdict.passed
+			passed: firstVerdict.passed,
+			origin: originOf(target.tool, field, value, proposed)
 		});
 		if (firstVerdict.passed) {
-			for (const field of first.asked) cache.set(cacheKey(target.tool, field), first.input[field]);
+			for (const field of first.asked) {
+				const value = first.input[field];
+				cache.set(cacheKey(target.tool, field), {
+					value,
+					origin: originOf(target.tool, field, value, proposed)
+				});
+			}
 			options.io.write(`${PASSED_LINE}\n`);
 			outcomes.push({
 				caseId: target.caseId,
@@ -1054,10 +1197,17 @@ async function repairInputs(options) {
 		for (const [field, value] of Object.entries(second.input)) attempts.push({
 			field,
 			value,
-			passed: secondVerdict.passed
+			passed: secondVerdict.passed,
+			origin: originOf(target.tool, field, value, void 0)
 		});
 		if (secondVerdict.passed) {
-			for (const field of second.asked) cache.set(cacheKey(target.tool, field), second.input[field]);
+			for (const field of second.asked) {
+				const value = second.input[field];
+				cache.set(cacheKey(target.tool, field), {
+					value,
+					origin: originOf(target.tool, field, value, void 0)
+				});
+			}
 			options.io.write(`${PASSED_LINE}\n`);
 			outcomes.push({
 				caseId: target.caseId,
@@ -1077,7 +1227,208 @@ async function repairInputs(options) {
 	return outcomes;
 }
 //#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} 로 종료되었습니다.`;
+/** 등급이 "같은 초기 상태" 를 보장하는가. 후보 비교의 전제다. */
+const resetIsComparable = (grade) => grade === "freshProcess" || grade === "commandOnly";
+/**
+* 등급별 화면 문안. **상수로 둔다.** 호출부에서 문자열을 조립하면 같은 등급이 화면마다
+* 다른 문장으로 나가고, 사용자는 두 화면이 같은 것을 말하는지 알 수 없다.
+*/
+const RESET_GRADE_LINE = {
+	freshProcess: "초기 상태: 서버를 다시 띄우고 초기화 명령을 실행했습니다.",
+	commandOnly: "초기 상태: 초기화 명령만 실행했습니다. 서버 프로세스의 메모리 상태는 그대로입니다.",
+	none: "초기 상태: 초기화 수단이 없습니다. 앞 실행이 바꾼 상태가 남아 있을 수 있습니다. --reset-cmd 로 지정하세요.",
+	failed: "초기 상태: 초기화 명령이 실패했습니다. 이 실행의 결과를 검증 완료로 보지 않습니다."
+};
+/**
+* 초기화를 시도하고 등급을 돌려준다. 던지지 않는다. 호출부가 등급을 보고 판단한다.
+*
+* `runResetCommand` 를 그대로 두는 이유: 그 함수는 "명령이 실패하면 던진다" 는 계약이고
+* 시험 실행 직전 경로가 그 계약에 의존한다(실패하면 실행을 시작하지 않는다). 등급이
+* 필요한 자리는 판단이 다르다. 실패해도 진행하되 무엇을 못 했는지 적는다.
+*
+* `ResetCommandError` 가 아닌 오류는 **던진다.** 우리 결함을 등급으로 위장하면 초기화가
+* 안 된 것과 우리 코드가 깨진 것이 화면에서 같아 보인다.
+*/
+async function attemptReset(resetCmd) {
+	if (resetCmd === void 0) return { grade: "none" };
+	try {
+		await runResetCommand(resetCmd);
+		return { grade: "commandOnly" };
+	} catch (error) {
+		if (!(error instanceof ResetCommandError)) throw error;
+		return {
+			grade: "failed",
+			error
+		};
+	}
+}
+//#endregion
 //#region src/pre-fill-wiring.ts
+/** 두 후보를 같은 초기 상태에서 못 돌렸을 때의 첫 줄. 아래에 등급 문장이 이어 붙는다. */
+const COMPARE_SKIPPED_HEAD = "사전보완 비교를 건너뜁니다: 두 후보를 같은 초기 상태에서 실행할 수 없습니다.";
+/**
+* 비교 불가 사유. 앞·사이 두 등급 중 비교 불가인 것의 문장을 이어 붙인다.
+*
+* 둘이 같은 등급이면 한 번만 찍는다. 다르면 **둘 다 찍는다.** `failed` 가 `none` 보다
+* 약하다고 보지 않는다. 둘은 다음에 할 일이 다르다. `none` 은 `--reset-cmd` 를 주는 것이고
+* `failed` 는 그 명령을 고치는 것이다.
+*/
+function compareSkippedReason(before, between) {
+	const lines = [];
+	for (const grade of [before, between]) if (!resetIsComparable(grade) && !lines.includes(RESET_GRADE_LINE[grade])) lines.push(RESET_GRADE_LINE[grade]);
+	return [COMPARE_SKIPPED_HEAD, ...lines].join("\n");
+}
+/**
+* 시험 실행 상세의 본문 들여쓰기. `dry-run.ts` 의 `INDENT` 와 같은 값이다.
+* 그 파일을 다른 태스크가 고치고 있어 import 하지 않고 여기에 둔다.
+*/
+const DETAIL_INDENT = "    ";
+/** 서버 위반 줄의 접두사. 들여쓰기 뒤에 붙는다. */
+const VIOLATION_PREFIX = `${DETAIL_INDENT}→ `;
+/**
+* 시험 실행 상세에서 서버가 낸 위반 줄만 뽑아 개행으로 잇는다.
+* 위반 줄이 없으면 들여쓰기가 있는 첫 본문 줄을 그대로 쓴다. 그것도 없으면 빈 문자열이다.
+* 관측하지 못한 것을 관측했다고 적지 않는다(설계 §4.1).
+*/
+function serverMessageOf$1(detail) {
+	const lines = detail.split("\n");
+	const violations = lines.filter((line) => line.startsWith(VIOLATION_PREFIX)).map((line) => line.slice(VIOLATION_PREFIX.length));
+	if (violations.length > 0) return violations.join("\n");
+	const first = lines.find((line) => line.startsWith(DETAIL_INDENT) && line.trim() !== "");
+	return first === void 0 ? "" : first.slice(4);
+}
 const plainObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** 케이스 하나에 제안 값들을 얹은 입력. 원본을 바꾸지 않는다. */
 function withProposals(input, proposals) {
@@ -1135,8 +1486,39 @@ async function applyPreFill(options) {
 		suite: baseline,
 		cases: [],
 		adopted: 0,
-		notAdopted: 0
+		notAdopted: 0,
+		held: 0,
+		excluded: [],
+		compared: true
 	};
+	const excluded = [];
+	const specById = new Map(baseline.cases.map((item) => [item.id, item]));
+	for (const [caseId, proposals] of byCase) {
+		const item = specById.get(caseId);
+		for (const proposal of proposals) {
+			if (item === void 0) {
+				excluded.push({
+					caseId,
+					field: proposal.field,
+					reason: "명세에 없는 케이스"
+				});
+				continue;
+			}
+			if (item.operation.type !== "callTool") {
+				excluded.push({
+					caseId,
+					field: proposal.field,
+					reason: "callTool 이 아닌 케이스"
+				});
+				continue;
+			}
+			if (!plainObject$1(item.operation.input)) excluded.push({
+				caseId,
+				field: proposal.field,
+				reason: "입력이 객체가 아닌 케이스"
+			});
+		}
+	}
 	const targetIds = /* @__PURE__ */ new Set();
 	const aiInputs = /* @__PURE__ */ new Map();
 	for (const item of baseline.cases) {
@@ -1152,31 +1534,44 @@ async function applyPreFill(options) {
 		suite: baseline,
 		cases: [],
 		adopted: 0,
-		notAdopted: 0
+		notAdopted: 0,
+		held: 0,
+		excluded,
+		compared: true
 	};
+	const resetOnce = options.reset ?? (async () => "none");
+	const gradeBefore = await resetOnce();
 	const baselineRun = await run({
 		client,
 		suite: subsetSuite(baseline, targetIds)
 	});
+	const gradeBetween = await resetOnce();
 	const aiRun = await run({
 		client,
 		suite: subsetSuite(baseline, targetIds, aiInputs)
 	});
+	const comparable = resetIsComparable(gradeBefore) && resetIsComparable(gradeBetween);
 	const aborted = baselineRun.aborted !== void 0 || aiRun.aborted !== void 0;
 	const baselinePassed = passedIds(baselineRun);
 	const aiPassed = passedIds(aiRun);
+	const aiDetails = new Map(aiRun.outcomes.map((outcome) => [outcome.caseId, outcome.detail]));
 	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;
+		const useAi = comparable && !aborted && !basePass && aiPass;
 		if (useAi) adoptedIds.add(item.id);
+		const held = comparable && !aborted && !basePass && !aiPass;
 		cases.push({
 			caseId: item.id,
 			source: useAi ? "ai" : "baseline",
-			needsClassification: !aborted && !basePass && !aiPass
+			needsClassification: held,
+			...held ? {
+				proposedFields: byCase.get(item.id) ?? [],
+				serverMessage: serverMessageOf$1(aiDetails.get(item.id) ?? "")
+			} : {}
 		});
 	}
 	const adopted = adoptedIds.size;
@@ -1187,7 +1582,11 @@ async function applyPreFill(options) {
 		},
 		cases,
 		adopted,
-		notAdopted: cases.length - adopted
+		notAdopted: cases.length - adopted,
+		held: cases.filter((item) => item.needsClassification).length,
+		excluded,
+		compared: comparable,
+		...comparable ? {} : { skippedReason: compareSkippedReason(gradeBefore, gradeBetween) }
 	};
 }
 /** 점 표기 경로를 따라 필드 스키마를 찾는다. 못 찾으면 undefined 다. */
@@ -1469,196 +1868,88 @@ async function proposeRepair(options) {
 	} catch {
 		return UNAVAILABLE;
 	}
-}
-//#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)));
+}
+//#endregion
+//#region src/repair-target.ts
+/** `renderReport` 가 케이스 본문 줄에 쓰는 들여쓰기. dry-run.ts 의 INDENT 와 같은 값이다. */
+const INDENT = "    ";
+/** 단언 진단의 위반 줄 표시. 이 줄에만 서버가 돌려준 값이 실려 있다. */
+const VIOLATION_MARK = "→ ";
+/** 실패 사유 판정에 쓰는 단언 타입. 이 줄이 있어야 "정상 응답을 기대했는데 오류" 다. */
+const IS_ERROR = "isError";
+/** `renderReport` 가 건너뛴 단언 줄에 붙이는 표시. 건너뛴 단언은 실패가 아니다. */
+const SKIPPED_MARK = "(건너뜀) ";
+/** 케이스 본문 줄에서 들여쓰기를 벗긴다. 들여쓰기가 없는 줄은 본문이 아니다. */
+const bodyLines = (detail) => detail.split("\n").filter((line) => line.startsWith(INDENT)).map((line) => line.slice(4));
+/**
+* 실패 사유가 `isError` 단언인가. 단언 줄은 타입 이름으로 시작하고, 진단 문장과 해결 줄은
+* 그렇지 않다.
+*
+* **`(건너뜀) ` 이 붙은 줄은 실패가 아니다.** 호출이 끝나지 못하면 단언이 전부 건너뛰기로
+* 그려지는데, 그것을 실패로 읽어 못 고칠 케이스를 교정 대상에 올리던 것이 이번 결함이다.
+* 앞단에서 `operationFailed` 로 이미 가르지만 여기서도 방어적으로 뺀다.
+*/
+const failedByIsError = (detail) => bodyLines(detail).some((line) => line.startsWith(IS_ERROR) && !line.includes(SKIPPED_MARK));
+/**
+* 서버가 돌려준 오류 본문을 뽑는다. 문장을 새로 만들지 않고 위반 줄을 그대로 옮긴다.
+* `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 eligible = (spec, outcome, origins) => {
+	if (outcome.status === "passed") return false;
+	if (spec.operation.type !== "callTool") return false;
+	if (Object.keys(spec.operation.input).length === 0) return false;
+	if (origins.get(outcome.caseId) === "user") return false;
+	if (expectsError(spec)) return false;
+	return true;
+};
+/**
+* 교정 대상과 못 고칠 실패를 한 번 순회해 가른다. 두 배열 모두 `outcomes` 순서다.
+* 정렬하지 않는다. 순서를 바꾸면 화면 번호가 앞선 결과 화면과 어긋난다.
+*/
+function selectRepairTargets(options) {
+	const specs = new Map(options.suite.cases.map((spec) => [spec.id, spec]));
+	const targets = [];
+	const thrown = [];
+	for (const outcome of options.outcomes) {
+		const spec = specs.get(outcome.caseId);
+		if (spec === void 0) continue;
+		if (!eligible(spec, outcome, options.origins)) continue;
+		if (outcome.operationFailed) {
+			thrown.push({
+				caseId: outcome.caseId,
+				caseName: outcome.caseName,
+				failureLine: outcome.failureLine,
+				serverMessage: serverMessageOf(outcome.detail)
 			});
+			continue;
+		}
+		if (!failedByIsError(outcome.detail)) continue;
+		if (spec.operation.type !== "callTool") continue;
+		targets.push({
+			caseId: outcome.caseId,
+			caseName: outcome.caseName,
+			tool: spec.operation.tool,
+			input: spec.operation.input,
+			serverMessage: serverMessageOf(outcome.detail),
+			failureLine: outcome.failureLine
 		});
-	});
+	}
+	return {
+		targets,
+		thrown
+	};
 }
-/** stderr 이 비어 있는데 시그널로 죽었으면 그 사실만이라도 남긴다. */
-const describeSignal = (signal) => signal === null ? "" : `시그널 ${signal} 로 종료되었습니다.`;
 //#endregion
 //#region src/generate-command.ts
 var UsageError$1 = class extends Error {};
@@ -1757,6 +2048,7 @@ const optionNames$1 = /* @__PURE__ */ new Set([
 	"--out",
 	"--command",
 	"--arg",
+	"--env",
 	"--url",
 	"--header-env",
 	"--baseline-only",
@@ -1764,7 +2056,9 @@ const optionNames$1 = /* @__PURE__ */ new Set([
 	"--model",
 	"--no-dry-run",
 	"--reset-cmd",
+	"--fixtures",
 	"--no-repair",
+	"--diagnose-rejections",
 	"--force"
 ]);
 /** 값을 받지 않는 옵션. `=` 를 붙여 쓸 수 없고 두 번 쓸 수 없다. */
@@ -1772,6 +2066,7 @@ const flagNames$1 = /* @__PURE__ */ new Set([
 	"--baseline-only",
 	"--no-dry-run",
 	"--no-repair",
+	"--diagnose-rejections",
 	"--force"
 ]);
 const removedGenerateOptions = /* @__PURE__ */ new Set(["--cassette", "--record"]);
@@ -1803,6 +2098,7 @@ function parseGenerateCommand(argv) {
 	const args = [];
 	const flags = /* @__PURE__ */ new Set();
 	const headerEnv = createHeaderEnvCollector();
+	const envForward = createEnvForwardCollector();
 	for (let index = 0; index < argv.length; index++) {
 		const item = argv[index];
 		if (item === void 0) continue;
@@ -1843,6 +2139,13 @@ function parseGenerateCommand(argv) {
 			if (rejected !== void 0) throw new UsageError$1(rejected);
 			continue;
 		}
+		if (option === "--env") {
+			const parsed = parseEnvForwardOption(value);
+			if (!parsed.ok) throw new UsageError$1(parsed.message);
+			const rejected = envForward.add(parsed.value);
+			if (rejected !== void 0) throw new UsageError$1(rejected);
+			continue;
+		}
 		if (values.has(option)) throw new UsageError$1(`\`${option}\`는 한 번만 사용할 수 있습니다.`);
 		values.set(option, value);
 	}
@@ -1859,6 +2162,7 @@ function parseGenerateCommand(argv) {
 	if (command !== void 0 && rawUrl !== void 0) throw new UsageError$1("`--command` 와 `--url` 은 함께 쓸 수 없습니다.\n→ `--command` 는 서버를 프로세스로 띄우고, `--url` 은 이미 떠 있는 원격 서버에 붙습니다.\n→ 둘 중 무엇에서 명세를 뽑을지 하나만 고르세요.");
 	if (command === void 0 && rawUrl === void 0) throw new UsageError$1("`--command` 또는 `--url` 옵션이 필요합니다.");
 	if (rawUrl !== void 0 && args.length > 0) throw new UsageError$1("`--arg` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--arg` 는 우리가 띄우는 프로세스에 넘길 인자입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
+	if (rawUrl !== void 0 && envForward.snapshot().length > 0) throw new UsageError$1("`--env` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--env` 는 우리가 띄우는 프로세스의 환경에 넣을 변수입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
 	if (command !== void 0 && !headerEnv.isEmpty()) throw new UsageError$1("`--header-env` 는 `--url` 과 함께만 쓸 수 있습니다.\n→ 헤더는 HTTP 요청에 실립니다. `--command` 로 띄운 서버와는 stdio 로 이야기합니다.");
 	const url = (() => {
 		if (rawUrl === void 0) return void 0;
@@ -1874,9 +2178,13 @@ function parseGenerateCommand(argv) {
 	const dryRun = !flags.has("--no-dry-run");
 	const repair = !flags.has("--no-repair");
 	if (!dryRun && !repair) throw new UsageError$1("`--no-dry-run`과 `--no-repair`는 함께 사용할 수 없습니다.");
+	const diagnoseRejections = flags.has("--diagnose-rejections");
+	if (diagnoseRejections && !dryRun) throw new UsageError$1("`--diagnose-rejections`는 `--no-dry-run`과 함께 사용할 수 없습니다. 시험 실행이 없으면 확인할 거절이 없습니다.");
 	const resetCmd = values.get("--reset-cmd");
 	if (!dryRun && resetCmd !== void 0) throw new UsageError$1("`--no-dry-run`과 `--reset-cmd`는 함께 사용할 수 없습니다.");
 	if (resetCmd !== void 0 && resetCmd.trim() === "") throw new UsageError$1("`--reset-cmd` 옵션 값이 필요합니다.");
+	const fixturesPath = values.get("--fixtures");
+	if (fixturesPath !== void 0 && fixturesPath.trim() === "") throw new UsageError$1("`--fixtures` 옵션 값이 필요합니다.");
 	return Object.freeze({
 		suiteId: values.get("--suite-id"),
 		name: values.get("--name"),
@@ -1884,7 +2192,8 @@ function parseGenerateCommand(argv) {
 		target: url === void 0 ? Object.freeze({
 			transport: "stdio",
 			command,
-			args: Object.freeze(args)
+			args: Object.freeze(args),
+			envNames: envForward.snapshot()
 		}) : Object.freeze({
 			transport: "http",
 			url,
@@ -1896,7 +2205,9 @@ function parseGenerateCommand(argv) {
 		dryRun,
 		force: flags.has("--force"),
 		resetCmd,
-		repair
+		repair,
+		diagnoseRejections,
+		fixturesPath
 	});
 }
 /**
@@ -1963,6 +2274,8 @@ async function saveSuite(input, suite, fingerprint, deps, approvals = []) {
 	}
 }
 const defaultModel = (provider) => provider === "codex" ? "gpt-5.6-luna" : "haiku";
+/** 대시보드의 검토 하위 입력에서 상위 메뉴로 돌아갈 때 쓰는 내부 제어값. */
+const REVIEW_BACK_VALUE = "__mcpeak_review_back__";
 /**
 * 전송 승인 화면. **통로마다 보내는 것이 다르므로 목록을 받는다**(#286) — 입력값 교정은
 * 실패한 케이스의 서버 응답 원문까지 싣는데, 기본 문구로 덮으면 화면이 사실보다 적게 말한다.
@@ -2194,8 +2507,221 @@ function writeDryRunNotice(io, notice) {
 	}
 	io.write("\n이 실행은 서버 상태를 바꿀 수 있습니다. 입력 검증이 없는 서버라면 외부 API 호출도\n그대로 나갑니다.\n");
 }
+/** `--fixtures` 를 안 주면 보는 경로. 없으면 조용히 지나간다(설계 §2.3). */
+const DEFAULT_FIXTURES_PATH = "mcpeak.fixtures.json";
+/**
+* 픽스처 파일을 읽는다. 읽을 수 없으면 사유를 stderr 에 적고 `null` 을 돌려준다(호출자가
+* 종료 코드 1 로 끝낸다).
+*
+* 파일 접근은 `deps.exists` · `deps.readFile` 주입점만 쓴다. `node:fs` 를 직접 부르면
+* 유닛테스트가 실제 파일 시스템을 타게 되고, 그것이 ADR-0013 이 막은 것이다.
+*/
+async function loadFixtures(input, deps) {
+	const explicit = input.fixturesPath !== void 0;
+	const path = input.fixturesPath ?? DEFAULT_FIXTURES_PATH;
+	let found;
+	try {
+		found = await deps.exists(path);
+	} catch (error) {
+		if (!explicit) return {};
+		const code = error?.code;
+		deps.writeStderr(`오류 [GENERATE_FIXTURE_UNREADABLE]: 픽스처 파일을 확인하지 못했습니다. 경로: ${path}${typeof code === "string" ? ` (${code})` : ""}\n해결: 그 경로와 상위 디렉터리의 권한을 확인하세요.\n`);
+		return null;
+	}
+	if (!found) {
+		if (!explicit) return {};
+		deps.writeStderr(`오류 [GENERATE_FIXTURE_NOT_FOUND]: 픽스처 파일이 없습니다. 경로: ${path}\n해결: 경로를 확인하거나 \`--fixtures\` 를 빼고 실행하세요.\n`);
+		return null;
+	}
+	let text;
+	try {
+		text = new TextDecoder("utf-8", { fatal: true }).decode(await deps.readFile(path));
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		deps.writeStderr(`오류 [GENERATE_FIXTURE_UNREADABLE]: 픽스처 파일을 읽지 못했습니다. 경로: ${path} (${escapeTerminalText$2(reason)})\n해결: 파일이 UTF-8 텍스트인지, 읽기 권한이 있는지 확인하세요.\n`);
+		return null;
+	}
+	const read = (0, _mcpeak_generate.readFixtureFile)(text);
+	if (read.status === "invalid") {
+		deps.writeStderr(`오류 [GENERATE_FIXTURE_INVALID]: ${escapeTerminalText$2(read.reason)} 경로: ${path}\n해결: 픽스처 파일을 고친 뒤 다시 실행하세요.\n`);
+		return null;
+	}
+	const tools = Object.values(read.file.tools ?? {});
+	const fields = tools.reduce((total, item) => total + Object.keys(item).length, 0);
+	deps.writeStdout(`▸ 픽스처: ${escapeTerminalText$2(path)} (도구 ${tools.length}개, 필드 ${fields}개)\n`);
+	return { file: read.file };
+}
+/**
+* 교정한 값을 픽스처 파일로 되돌린다(#390 T3).
+*
+* **기존 파일을 절대 고치지 않는다.** 병합 로직을 만들지 않는다. 파일이 있으면 붙여 넣을
+* 조각만 찍는다. 덮어쓸 수 있는 primitive 를 두지 않는다는 것이 이 저장소의 결론이고
+* (`docs/reports/task-r4.md`), `rename` 으로 떨어지고 싶어지는 자리에서 그 결정을
+* 우회하지 않는다. `openTemp` → `link` → `unlink` 만 쓴다.
+*/
+async function writeBackFixtures(input, deps, io, targets, repairs) {
+	const { entries, nestedFields } = collectFixtureWriteback(targets, repairs);
+	if (nestedFields.length > 0) io.write(`▸ 중첩 경로 ${nestedFields.length}건은 픽스처에 적을 수 없습니다(최상위 필드만 받습니다): ${nestedFields.join(", ")}\n`);
+	if (entries.length === 0) return;
+	const path = input.fixturesPath ?? DEFAULT_FIXTURES_PATH;
+	let exists;
+	/** 확인 자체가 실패했을 때의 오류 코드. 파일이 **있는 것과 다르다.** */
+	let checkFailed;
+	try {
+		exists = await deps.exists(path);
+	} catch (error) {
+		exists = true;
+		const code = error?.code;
+		checkFailed = typeof code === "string" ? code : "알 수 없는 오류";
+	}
+	if (checkFailed !== void 0) {
+		io.write(`픽스처 파일이 있는지 확인하지 못해 쓰지 않았습니다: ${path} (${checkFailed})\n아래 조각을 직접 붙여 넣으세요.
+
+` + renderFixtureSnippet(entries));
+		return;
+	}
+	if (exists) {
+		io.write(`교정한 값 ${entries.length}건을 픽스처에 반영하려면 ${path} 의 "tools" 아래에 붙이세요.\n기존 파일이 있어 우리가 고치지 않습니다.
+
+` + renderFixtureSnippet(entries));
+		return;
+	}
+	if (!io.interactive) {
+		io.write(`교정한 값 ${entries.length}건을 픽스처로 저장할 수 있습니다. 대화형으로 다시 실행하면 ${path} 에 저장할지 묻습니다.\n\n` + renderFixtureSnippet(entries));
+		return;
+	}
+	io.write(`교정한 값 ${entries.length}건을 ${path} 에 저장할까요?\n`);
+	const width = Math.max(...entries.map((entry) => `${entry.tool}.${entry.field}`.length));
+	for (const entry of entries) io.write(`  ${`${entry.tool}.${entry.field}`.padEnd(width)}  ${JSON.stringify(entry.value)}  ${ORIGIN_LABEL[entry.origin]}\n`);
+	if (!await io.confirm("저장할까요?")) return;
+	const temporary = temporaryPath(path);
+	let created = false;
+	try {
+		const handle = await deps.openTemp(temporary);
+		created = true;
+		try {
+			await handle.writeFile(renderFixtureFile(entries), "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await deps.link(temporary, path);
+		io.write(`▸ 픽스처를 저장했습니다: ${path}\n`);
+	} catch (error) {
+		const code = error?.code;
+		io.write(`▸ 픽스처를 저장하지 못했습니다: ${path}${typeof code === "string" ? ` (${code})` : ""}\n  아래 조각을 직접 붙여 넣으세요.
+
+` + renderFixtureSnippet(entries));
+	} finally {
+		if (created) await deps.unlink(temporary).catch(() => void 0);
+	}
+}
+/** UTF-16 코드 단위 안정 비교. `localeCompare` 는 로캘·ICU 데이터에 따라 결과가 달라진다. */
+const byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** 출처 표기. `humanRepaired` 와 `aiProposed` 를 갈라 적는다. */
+const ORIGIN_LABEL = {
+	humanRepaired: "(사람이 입력)",
+	aiProposed: "(AI 제안, 사람이 확인)"
+};
+/**
+* 교정으로 통과한 값을 도구·필드로 모은다.
+*
+* 통과한 시도만 본다. 안 통한 값을 픽스처에 적으면 다음 실행이 그 값으로 시작해 같은 이유로
+* 죽는다. 같은 `(도구, 필드)` 가 여러 케이스에서 나오면 **뒤 케이스가 앞을 덮지 않는다.**
+* 앞 케이스의 값이 캐시로 뒤에 퍼진 것이라 값이 같고, 다르다면 먼저 통과한 쪽을 쓴다.
+*/
+function collectFixtureWriteback(targets, repairs) {
+	const toolOf = new Map(targets.map((item) => [item.caseId, item.tool]));
+	const entries = /* @__PURE__ */ new Map();
+	const nested = /* @__PURE__ */ new Set();
+	for (const repair of repairs) {
+		const tool = toolOf.get(repair.caseId);
+		if (tool === void 0) continue;
+		for (const attempt of repair.attempts) {
+			if (!attempt.passed) continue;
+			if (attempt.field.includes(".") || attempt.field.includes("[")) {
+				nested.add(`${tool}.${attempt.field}`);
+				continue;
+			}
+			const key = `${tool}\u0000${attempt.field}`;
+			if (entries.has(key)) continue;
+			entries.set(key, {
+				tool,
+				field: attempt.field,
+				value: attempt.value,
+				origin: attempt.origin
+			});
+		}
+	}
+	return {
+		entries: [...entries.values()].sort((a, b) => a.tool === b.tool ? byCodeUnit(a.field, b.field) : byCodeUnit(a.tool, b.tool)),
+		nestedFields: [...nested].sort(byCodeUnit)
+	};
+}
+/**
+* 픽스처 파일 본문. **결정론적이어야 한다.** 도구·필드 이름 코드 단위 오름차순,
+* `JSON.stringify(x, null, 2)`, 끝 개행 하나다. 순서가 흔들리면 diff 가 매번 커진다.
+*/
+function renderFixtureFile(entries) {
+	const tools = {};
+	for (const entry of entries) {
+		const fields = tools[entry.tool] ?? {};
+		fields[entry.field] = entry.value;
+		tools[entry.tool] = fields;
+	}
+	return `${JSON.stringify({
+		schemaVersion: 1,
+		tools
+	}, null, 2)}\n`;
+}
+/**
+* 기존 파일이 있을 때 찍는 조각. **붙여 넣을 수 있는 모양이어야 한다.**
+*
+* 사용자가 손으로 JSON 을 고치는 자리라 쉼표 하나가 틀리면 파일이 깨진다. 마지막 줄에
+* 쉼표를 붙이지 않는다.
+*/
+function renderFixtureSnippet(entries) {
+	const byTool = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const fields = byTool.get(entry.tool) ?? {};
+		fields[entry.field] = entry.value;
+		byTool.set(entry.tool, fields);
+	}
+	return `${[...byTool.entries()].map(([tool, fields]) => `  ${JSON.stringify(tool)}: ${JSON.stringify(fields)}`).join(",\n")}\n`;
+}
+/**
+* 실패한 케이스에 붙이는 자리값 안내(설계 §2.2).
+*
+* **필드 이름으로 추측하지 않는다.** 판정 근거는 "그 값을 우리가 지어냈는가" 하나이고,
+* 그것은 `fieldOrigins` 가 말해 주는 사실이다. 이름 표를 만들면 `q` 나 `target` 인 식별자를
+* 놓치고 이름이 `name` 인 순수 문자열에 잘못 붙는다.
+*
+* `userFixture` · `schemaDeclared` 에는 안 붙인다. 사용자가 실재를 보증했거나 서버가 준
+* 값이라 서버 쪽을 먼저 봐야 한다.
+*/
+function placeholderGuidance(caseId, suite, fixtures) {
+	if (fixtures === void 0) return "";
+	const spec = suite.cases.find((item) => item.id === caseId);
+	if (spec === void 0 || spec.operation.type !== "callTool") return "";
+	if (spec.assertions.some((assertion) => assertion.type === "isError" && assertion.expected === true)) return "";
+	const { tool, input } = spec.operation;
+	let text = "";
+	const seen = /* @__PURE__ */ new Set();
+	for (const origin of fixtures.fieldOrigins) {
+		if (origin.tool !== tool || origin.origin !== "schemaHint") continue;
+		if (!Object.hasOwn(input, origin.field) || seen.has(origin.field)) continue;
+		seen.add(origin.field);
+		const field = escapeTerminalText$2(origin.field);
+		const value = escapeTerminalText$2(JSON.stringify(input[origin.field]) ?? "undefined");
+		text += `    ℹ 이 케이스의 '${field}' 값 ${value} 은 스키마의 type 만 보고 만든 자리값입니다.\n      실재하는 자원을 가리키지 않으므로 서버 결함이 아닐 수 있습니다.
+      해결: ${escapeTerminalText$2(fixtures.path)} 에 ${escapeTerminalText$2(tool)}.${field} 값을 지정하세요.\n`;
+		const note = fixtures.notes?.[tool]?.[origin.field];
+		if (note !== void 0) text += `      메모: ${escapeTerminalText$2(note)}\n`;
+	}
+	return text;
+}
 /** 시험 실행 결과(§8.2). 0건인 종류는 찍지 않는다. */
-function writeDryRunResult(io, result) {
+function writeDryRunResult(io, result, suite, fixtures) {
 	const failures = result.outcomes.filter((outcome) => outcome.status !== "passed");
 	const passed = result.outcomes.length - failures.length;
 	io.write("\n");
@@ -2205,11 +2731,16 @@ function writeDryRunResult(io, result) {
 		io.write("\n");
 		io.write(failureHeading(index, outcome.caseName));
 		io.write(detailBlock(outcome.detail));
+		if (suite !== void 0) io.write(placeholderGuidance(outcome.caseId, suite, fixtures));
 	}
 	if (failures.length > 0) io.write("\n");
 }
 /**
 * 거절 근거 미확인 목록 (#89 · 설계 문서 §5.2). 시험 실행 결과 블록 바로 아래에 붙는다.
+* `--diagnose-rejections` 를 켰을 때만 부른다(ADR-0098).
+*
+* 무엇을 셀지는 부르는 쪽이 정해 배열로 넘긴다. 여기서 다시 거르면 같은 규칙이 두 곳에
+* 생기고, 한쪽만 고쳐지면 목록의 건수와 진단 건수가 소리 없이 갈린다.
 *
 * **이 케이스들은 통과했다.** 목록은 판정도 저장 여부도 바꾸지 않는다. `unverified` 는
 * "거절이 아니다" 가 아니라 "확인하지 못했다" 는 뜻이라, 문장이 실패나 결함이라고 말하지 않고
@@ -2219,8 +2750,7 @@ function writeDryRunResult(io, result) {
 * 여러 줄 응답이 한 줄이 되고 제어 문자도 함께 무해해진다. 자르기는 `runner` 가 이미 진단 값과
 * 같은 상한에서 했다(`clampObservedText`). 여기서 규칙을 새로 만들지 않는다.
 */
-function writeRejectionUnverified(io, result) {
-	const unverified = result.outcomes.filter((outcome) => outcome.rejectionBasis === "unverified");
+function writeRejectionUnverified(io, unverified) {
 	if (unverified.length === 0) return;
 	const ids = unverified.map((outcome) => escapeTerminalText$2(outcome.caseId));
 	const column = Math.max(...ids.map((id) => Array.from(id).length));
@@ -2272,11 +2802,10 @@ function writeRejectionDiagnosis(io, requested, results) {
 * 실패는 흐름을 끊지 않는다. 안내만 찍고 승인 화면이 이어진다. 진단은 참고이지 전제가 아니다.
 */
 async function askRejectionDiagnosis(options) {
-	const { io, deps, provider } = options;
+	const { io, deps, provider, unverified } = 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 [];
@@ -2321,6 +2850,28 @@ async function askRejectionDiagnosis(options) {
 	writeRejectionDiagnosis(io, cases.length, dispatched.results);
 }
 /**
+* 최종 전량 재검증을 못 했을 때의 문장. 상수로 둔다.
+*
+* 개별 케이스가 단독으로 통과한 것과 전량을 순서대로 돌려 통과한 것은 다르다. A 가 통과하고
+* B 가 단독으로 통과해도, A 다음에 B 를 돌리면 B 가 실패할 수 있다. 그 사실을 안 적으면
+* 사용자는 저장 뒤 첫 `mcpeak test` 에서 처음 안다(이슈 #399).
+*/
+const FINAL_REVALIDATION_SKIPPED_LINES = "최종 전량 재검증을 하지 않았습니다. 개별 케이스 통과 기록만 있습니다.\n저장 후 `mcpeak test` 로 전체를 한 번 실행해 확인하세요.\n";
+/** 재검증 확인 화면. 실제 서버 호출이 는다는 사실을 묻기 전에 적는다. */
+function writeFinalRevalidationNotice(io, grade, caseCount) {
+	io.write(`최종 명세를 처음부터 다시 실행해 검증합니다.
+  ${RESET_GRADE_LINE[grade]}\n  실행할 케이스: ${caseCount}건 (실제 서버 호출입니다)\n`);
+}
+/** 저장 화면의 검증 범위 줄(§5). 검증 범위를 남기는 **유일한 자리**다. */
+function writeVerificationScope(io, verification, caseCount) {
+	if (verification === "fullSuite") {
+		io.write(`  검증 범위: ${caseCount}건을 최종 전량 실행에서 확인했습니다.\n`);
+		return;
+	}
+	io.write(`  검증 범위: ${caseCount}건은 개별 실행에서만 확인했습니다. 전량 재검증을 하지 않았습니다.\n  저장 후 \`mcpeak test\` 로 전체를 한 번 실행해 확인하세요.
+`);
+}
+/**
 * 반영 요약(§8.8). 저장 확인 직전에 찍는다. 교정이 0건이면 아무것도 찍지 않는다.
 * 지문이 바뀐 이유가 화면에 남아야 사용자가 나중에 diff 를 보고 놀라지 않는다(§5.4).
 */
@@ -2417,7 +2968,7 @@ function writeResetFailure(io, error) {
 	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 = []) {
+async function runInteractiveReview(input, tools, session, deps, connection, skippedTools = [], outputContractSkips = [], validBranchSkips = [], fixtures) {
 	const io = deps.reviewIO;
 	const prepare = deps.prepareAuthoringRequest;
 	const dispatch = deps.dispatchAuthoringRequest;
@@ -2510,22 +3061,41 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 						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 targets = input.repair ? selectRepairTargets({
+					writeDryRunResult(io, result, dryRunSuite, fixtures);
+					const unverified = result.outcomes.filter((outcome) => outcome.status === "passed" && outcome.rejectionBasis === "unverified");
+					if (input.diagnoseRejections) {
+						writeRejectionUnverified(io, unverified);
+						await askRejectionDiagnosis({
+							io,
+							deps,
+							unverified,
+							suite: dryRunSuite,
+							tools,
+							provider: preferred === void 0 ? void 0 : deps.rejectionProviders?.[preferred]?.(model ?? defaultModel(preferred)),
+							model: model ?? (preferred === void 0 ? "" : defaultModel(preferred))
+						});
+					} else if (unverified.length > 0) io.write(`  통과한 거절 케이스 ${unverified.length}건의 근거는 확인하지 않았습니다. --diagnose-rejections 로 목록과 AI 진단을 볼 수 있습니다.
+
+`);
+					const selection = input.repair ? selectRepairTargets({
 						suite: dryRunSuite,
 						outcomes: result.outcomes,
 						origins: originsOf(session)
-					}) : [];
+					}) : {
+						targets: [],
+						thrown: []
+					};
+					if (selection.thrown.length > 0) {
+						io.write(`  교정 대상이 아닌 실패 ${selection.thrown.length}건 (호출 자체가 실패했습니다. 입력값 문제가 아닙니다)\n`);
+						for (const item of selection.thrown) {
+							io.write(`    ${item.caseName}\n`);
+							const body = item.serverMessage.split("\n").filter((line) => line !== "");
+							if (body.length === 0) io.write(`      ${item.failureLine}\n`);
+							else for (const line of body) io.write(`      → ${line}\n`);
+						}
+						io.write("\n");
+					}
+					const targets = selection.targets;
 					let attempts;
 					let effective = result;
 					if (targets.length > 0) {
@@ -2579,6 +3149,7 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 						});
 						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]));
+						await writeBackFixtures(input, deps, io, targets, repairs);
 						if (repaired.size > 0) {
 							repairedCases = repaired.size;
 							repairChanges = repairApplications(dryRunSuite, repaired);
@@ -2624,9 +3195,47 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 					}
 					approvals = review.approvals;
 				}
+				/**
+				* 11.5. 최종 전량 재검증(§2, 이슈 #399).
+				*
+				* 입력값 교정은 케이스 하나만 담은 스위트로 재실행한다. 그 판단은 그 자리에서 옳다.
+				* 문제는 그 뒤다. 저장 판정이 원래 실행 결과와 교정된 케이스의 **단독 통과**를 합친
+				* 것이었다. **합집합은 실행이 아니다.** A 가 통과하고 B 가 단독으로 통과해도 A 다음에
+				* B 를 돌리면 B 가 실패할 수 있고, 그 사실은 저장 뒤 첫 `mcpeak test` 에서야 드러난다.
+				*
+				* 여기서 초기 상태로 되돌리고 최종 스위트 전량을 한 번에 돌린다. **그 결과가 저장
+				* 판정이다.**
+				*/
+				let verification = "isolated";
+				const revalidationSuite = session.approvedDraft.suite;
+				if (input.dryRun) {
+					const finalCaseCount = revalidationSuite.cases.length;
+					const grade = (await (deps.attemptReset ?? attemptReset)(input.resetCmd)).grade;
+					writeFinalRevalidationNotice(io, grade, finalCaseCount);
+					if (await io.confirm("   다시 실행할까요?")) {
+						const again = await runDryRun({
+							client: connection.client,
+							suite: revalidationSuite
+						});
+						if (again.aborted !== void 0) {
+							writeDryRunAborted(io, again, finalCaseCount, diagnostics());
+							continue;
+						}
+						writeDryRunResult(io, again);
+						const expectedToFail = new Set(approvals.filter((item) => item.status === "serverDefect").map((item) => item.id));
+						const regressed = again.outcomes.filter((outcome) => outcome.status !== "passed" && !expectedToFail.has(outcome.caseId));
+						if (regressed.length > 0) {
+							io.write(`최종 전량 실행에서 ${regressed.length}건이 실패했습니다. 개별 실행에서는 통과했지만 순서대로 돌리면 실패합니다.\n  앞 케이스가 바꾼 상태를 뒤 케이스가 물려받습니다. 케이스 순서나 입력값을 확인하세요.
+`);
+							continue;
+						}
+						verification = "fullSuite";
+					} else io.write(FINAL_REVALIDATION_SKIPPED_LINES);
+				}
 				const fingerprint = session.approvedDraft.suiteFingerprint;
 				io.write(`Final fingerprint: ${fingerprint}\n`);
 				writeRepairSummary(io, repairedCases, repairChanges);
+				writeVerificationScope(io, verification, revalidationSuite.cases.length);
 				if (!await io.confirm("최종 JSON을 저장할까요?")) continue;
 				const final = deps.finalizeAuthoringDraft({
 					session,
@@ -2646,7 +3255,7 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 					reportCoverageSafely(deps, () => deps.computeCoverage?.({
 						suite: finalSuite,
 						tools: tools.filter((_tool, index) => !skippedIndexes.has(index))
-					}), finalSuite, skippedTools);
+					}), finalSuite, skippedTools, outputContractSkips, validBranchSkips);
 					return 0;
 				} catch (error) {
 					if (error instanceof OutputExistsError) outputExistsFailure(deps, error.path);
@@ -2666,7 +3275,9 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 					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);
+				const selectedInput = action === "select" ? await io.input("적용할 change ID를 쉼표로 입력하세요: ") : null;
+				if (selectedInput === "__mcpeak_review_back__") continue;
+				const selected = selectedInput === null ? diff.changes.map((change) => change.id) : selectedInput.split(",").map((id) => id.trim()).filter(Boolean);
 				if (!await confirmSpecFindings(io, candidate, diff, selected)) continue;
 				if (!await io.confirm("선택한 변경을 적용할까요?")) continue;
 				const result = apply({
@@ -2684,6 +3295,7 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 			}
 			if (action === "edit") {
 				const path = await io.input("편집한 JSON 파일 경로: ");
+				if (path === "__mcpeak_review_back__") continue;
 				try {
 					const result = reviewLocal({
 						session,
@@ -2707,15 +3319,24 @@ async function runInteractiveReview(input, tools, session, deps, connection, ski
 				io.write("지원하지 않는 메뉴입니다.\n");
 				continue;
 			}
+			const previousPreferred = preferred;
+			const previousModel = model;
 			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 selectedModel = model ?? await io.input(`${providerId} model (${defaultModel(providerId)}): `);
+			if (selectedModel === "__mcpeak_review_back__") {
+				preferred = previousPreferred;
+				model = previousModel;
+				continue;
+			}
+			model = selectedModel || defaultModel(providerId);
 			const provider = deps.providers?.[providerId]?.(model);
 			if (!provider) {
 				io.write(`${providerId} provider를 사용할 수 없습니다.\n`);
 				continue;
 			}
 			const instruction = await io.input(action === "revise" ? "피드백: " : "AI 요청: ");
+			if (instruction === "__mcpeak_review_back__") continue;
 			const preview = prepare({
 				mode: action === "revise" ? "revise" : "initial",
 				instruction,
@@ -2770,7 +3391,8 @@ const AXIS_LABEL = {
 	REQUIRED_OMITTED: "필수 필드 누락 거절",
 	TYPE_VIOLATION: "타입 위반 거절",
 	ENUM_VIOLATION: "선언되지 않은 값 거절",
-	RANGE_VIOLATION: "선언된 범위 밖 값 거절"
+	RANGE_VIOLATION: "선언된 범위 밖 값 거절",
+	UNDECLARED_FIELD: "선언되지 않은 필드 거절"
 };
 /**
 * runner 보고서 상한(1MB)에 닿기 전에 알리는 임계.
@@ -2797,9 +3419,44 @@ 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]}`;
+/**
+* 범위 경계를 사람이 읽는 말로. 화면에만 쓰는 이름이라 축 정체성(`bound`)과는 별개다.
+* `Record<ContractRangeBound, string>` 이라서 `runner` 가 경계를 늘리면 여기서 타입 오류가
+* 난다. AXIS_LABEL 과 같은 이유로 같은 형태다.
+*/
+const RANGE_BOUND_LABEL = {
+	lower: "하한",
+	upper: "상한"
+};
+/**
+* 축을 못 만든 사유를 사람 문장으로. `Record<UnanalyzedReason, string>` 이라서 `runner` 가
+* 사유를 늘리면 여기서 타입 오류가 난다. AXIS_LABEL 과 같은 이유로 같은 형태다.
+*
+* 이름만 나열하던 종전 화면은 사용자가 할 수 있는 일이 없었다. `filters` 하나만 보고는
+* 선언을 고쳐야 하는지, 우리 상한에 걸린 것인지, 애초에 읽을 근거가 없는 것인지 알 수 없다.
+* 이 프로젝트에서 실패 메시지는 곧 제품이다.
+*/
+const UNANALYZED_REASON_LABEL = {
+	blockingKeyword: "anyOf·oneOf·allOf·not·$ref 가 선언돼 있어 읽지 못했습니다.",
+	noProperties: "object 인데 properties 선언이 없어 안을 읽지 못했습니다.",
+	tupleItems: "items 가 배열(튜플)이라 원소 스키마를 하나로 묶지 못했습니다.",
+	depthLimit: "중첩 깊이 상한(3)을 넘어 더 내려가지 않았습니다.",
+	pathLimit: "한 도구의 경로 수 상한(64)을 넘어 더 만들지 않았습니다.",
+	pathCollision: "경로 표기가 다른 필드와 겹쳐 양쪽 다 제외했습니다.",
+	noGround: "type·enum·범위를 하나도 읽지 못해 요구할 근거가 없습니다.",
+	unreadablePath: "이름에 '.' 이나 '[' 가 들어 경로로 읽으면 다른 자리를 가리켜 제외했습니다."
+};
+/**
+* 축 하나를 사람이 읽는 문장으로. 필드가 없는 축(HAPPY_PATH)은 종류만 적는다.
+*
+* 괄호는 범위 축에만 붙는다. 상한 축과 하한 축은 종류도 필드도 같아서, 경계를 안 적으면
+* 미검증 줄이 두 번 똑같이 나온다(이슈 #387). 같은 문장이 두 줄이면 사용자는 화면이 고장 난
+* 것으로 읽지, 한쪽 경계만 비었다는 뜻으로 읽지 않는다. 다른 축은 그럴 일이 없으므로 문장을
+* 그대로 둔다.
+*/
+function axisLabel(kind, field, bound) {
+	const base = field === null ? AXIS_LABEL[kind] : `${field} 의 ${AXIS_LABEL[kind]}`;
+	return bound === null ? base : `${base} (${RANGE_BOUND_LABEL[bound]})`;
 }
 /** 툴 한 개의 줄과 그 아래 들여쓴 줄들. */
 function coverageToolLines(tool, nameWidth) {
@@ -2809,11 +3466,15 @@ function coverageToolLines(tool, nameWidth) {
 		`    → 입력 스키마를 해석하지 못해 이 툴의 축을 세지 못했습니다 (${tool.unanalyzableReason ?? "schema"})`,
 		"    → 이 툴은 커버리지 숫자에 들어가지 않습니다"
 	];
-	const labels = tool.axes.filter((axis) => axis.caseId === null).map((axis) => axisLabel(axis.kind, axis.field));
+	const labels = tool.axes.filter((axis) => axis.caseId === null).map((axis) => axisLabel(axis.kind, axis.field, axis.bound));
 	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(", ")}. 이 필드의 축은 세지 않았습니다`);
+	if (tool.unanalyzedFields.length > 0) {
+		lines.push(`    → 해석 못 한 필드 ${tool.unanalyzedFields.length}개. 이 필드의 축은 세지 않았습니다`);
+		const pathWidth = Math.max(0, ...tool.unanalyzedFields.map((f) => displayWidth(f.path))) + 3;
+		for (const field of tool.unanalyzedFields) lines.push(`      ${padToWidth(field.path, pathWidth)}${UNANALYZED_REASON_LABEL[field.reason]}`);
+	}
 	return lines;
 }
 /**
@@ -2856,13 +3517,17 @@ function renderSkippedTools(skipped) {
 * authoring 화면의 어법을 따르되 **전송 데이터 목록은 사실대로** 적는다. 여기서 나가는 것은
 * suite 전량이 아니라 툴 선언과 baseline 이 넣은 값뿐이다. authoring 문안을 그대로 태우면
 * 사용자가 승인하는 내용과 실제로 나가는 내용이 달라진다.
+*
+* 실제 서버 호출이 이 확인 뒤에 일어난다는 사실도 여기서 말한다. 저장 메뉴의 "계속할까요?" 만
+* 보고 온 사용자가 그 앞의 호출을 모른 채 승인하면 안 된다(#397).
 */
 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 이 넣은 값, 그 값의 출처
 받는 것: 값 제안뿐입니다. 케이스를 더하거나 구조를 바꾸지 않습니다.
-`);
+채택 판정: 제안이 돌아온 케이스마다 baseline 값과 제안 값으로 실제 서버를 각각 한 번씩
+  부릅니다. 위 케이스 ${request.cases.length}개가 그 상한입니다. 상태를 바꾸는 툴이면 그 부작용이 남습니다.\n`);
 	if (request.omitted.tools > 0) io.write(`⚠ 크기 상한 때문에 툴 ${request.omitted.tools}개를 요청에서 뺐습니다. 그 툴은 baseline 값 그대로 갑니다.\n`);
 }
 /**
@@ -2881,21 +3546,54 @@ function renderUnknownFormatSkips(skips) {
 	}
 	return `${lines.join("\n")}\n`;
 }
+/** 입력 케이스는 남겼지만 저장된 출력 계약을 만들지 못한 범위를 명시한다. */
+function renderOutputContractSkips(skips) {
+	if (skips.length === 0) return "";
+	return `${skips.map((skip) => `경고: 툴 '${skip.name}'의 출력 계약을 자동 검증하지 않습니다.\n      위치: ${skip.path}\n      이유: ${skip.message}\n      정상 호출의 isError 검사는 유지되지만 structuredContent 계약은 미검증입니다.`).join("\n")}\n`;
+}
+/**
+* 정상 입력 중 케이스를 만들지 못한 분기를 명시한다. 없으면 빈 문자열이다.
+*
+* 침묵하면 "정상 입력은 전부 밟았다" 로 읽힌다. 커버리지 표의 축은 위반 축이라 여기서 빠진
+* 분기를 세지 않으므로, 이 덩어리가 없으면 사용자가 빈틈을 볼 수 있는 자리가 없다.
+*
+* `reason` 은 `generate` 가 만들어 보낸 문장을 그대로 쓴다. 여기서 다시 쓰면 같은 상황이 두
+* 문안으로 갈린다. 순서도 `skips` 배열 그대로다. `generate` 가 이미 결정론적으로 정렬했고,
+* 여기서 다시 정렬하면 두 곳이 갈린다.
+*/
+function renderValidBranchSkips(skips) {
+	if (skips.length === 0) return "";
+	const lines = [`정상 분기: 툴 ${new Set(skips.map((skip) => skip.tool)).size}개에서 ${skips.length}개 분기를 실행하지 않았습니다.`];
+	for (const skip of skips) lines.push(`  ${skip.tool}.${skip.field}  ${skip.reason}`);
+	return `${lines.join("\n")}\n`;
+}
 /**
 * AI 사전보완 결과 요약. 대상이 없으면 빈 문자열이다.
 *
+* 네 갈래를 나눠 적는다(설계 §4.3). `미채택` 과 `보류` 를 합쳐 "baseline 값이 이미 통과" 라고
+* 쓰면 baseline 이 실패한 케이스에 사실과 다른 말이 붙는다.
+*
 * **`버림` 은 사유와 대상을 반드시 적는다.** 개수만 적으면 사용자가 무엇을 잃었는지 모른다
 * (이슈 #120 이 `discarded` 가 개수뿐이라고 지적한 것과 같은 계열이다). 버림이 0건이면 그 줄을
 * 아예 찍지 않는다.
 */
 function renderPreFillSummary(options) {
-	const { toolCount, proposedToolCount, adopted, notAdopted, discarded } = options;
-	if (proposedToolCount === 0 && discarded.length === 0) return "";
+	const { toolCount, proposedToolCount, adopted, notAdopted, held, heldCases, excluded, discarded } = options;
+	if (proposedToolCount === 0 && discarded.length === 0 && excluded.length === 0) return "";
 	const lines = [
 		`AI 사전보완: 툴 ${toolCount}개 중 ${proposedToolCount}개에 값 제안을 받았습니다.`,
 		`  채택 ${adopted} (실제 서버에서 baseline 값이 실패하고 제안 값이 통과)`,
-		`  미채택 ${notAdopted} (baseline 값이 이미 통과)`
+		`  미채택 ${notAdopted - held} (baseline 값이 이미 통과)`
 	];
+	if (held > 0) {
+		lines.push(`  보류 ${held} (baseline 값도 제안 값도 실패. 분류 화면에서 정합니다)`);
+		for (const item of heldCases) {
+			const proposals = item.proposedFields.map((p) => `${p.field}: ${JSON.stringify(p.value)}`).join(", ");
+			lines.push(`    ${item.caseId}  ${proposals}`);
+			for (const line of item.serverMessage.split("\n").filter((s) => s !== "")) lines.push(`      → ${line}`);
+		}
+	}
+	for (const item of excluded) lines.push(`  제외 1 (${item.reason}: ${item.caseId}.${item.field})`);
 	for (const item of discarded) lines.push(`  버림 1 (${item.reason}: ${item.caseId}.${item.field})`);
 	return `${lines.join("\n")}\n`;
 }
@@ -2916,13 +3614,17 @@ function renderCaseCountNotice(caseCount) {
 `;
 }
 /** 커버리지·건너뜀·케이스 수 고지를 stdout 에 찍는다. 전부 빈 문자열이면 아무것도 안 찍는다. */
-function writeCoverageReport(deps, coverage, suite, skippedTools) {
+function writeCoverageReport(deps, coverage, suite, skippedTools, outputContractSkips, validBranchSkips) {
 	if (coverage !== void 0) {
 		const text = renderCoverage(coverage);
 		if (text !== "") deps.writeStdout(text);
 	}
 	const skippedText = renderSkippedTools(skippedTools);
 	if (skippedText !== "") deps.writeStdout(skippedText);
+	const outputContractText = renderOutputContractSkips(outputContractSkips);
+	if (outputContractText !== "") deps.writeStdout(outputContractText);
+	const validBranchText = renderValidBranchSkips(validBranchSkips);
+	if (validBranchText !== "") deps.writeStdout(validBranchText);
 	const notice = renderCaseCountNotice(suite.cases.length);
 	if (notice !== "") deps.writeStdout(notice);
 }
@@ -2936,9 +3638,9 @@ function writeCoverageReport(deps, coverage, suite, skippedTools) {
 * coverage 를 값이 아니라 thunk 로 받는 이유는 `computeCoverage` 자체가 던지는 경우까지 이 경계
 * 안에 넣기 위해서다.
 */
-function reportCoverageSafely(deps, coverage, suite, skippedTools = []) {
+function reportCoverageSafely(deps, coverage, suite, skippedTools = [], outputContractSkips = [], validBranchSkips = []) {
 	try {
-		writeCoverageReport(deps, coverage(), suite, skippedTools);
+		writeCoverageReport(deps, coverage(), suite, skippedTools, outputContractSkips, validBranchSkips);
 	} catch {
 		deps.writeStderr("경고 [GENERATE_COVERAGE_UNAVAILABLE]: 명세는 저장했지만 커버리지를 계산하지 못했습니다.\n해결: 저장된 명세는 그대로 `mcpeak test` 로 쓸 수 있습니다. 커버리지만 다시 보려면 다른 --out 경로로 generate 를 실행하세요.\n");
 	}
@@ -2952,6 +3654,9 @@ function reportCoverageSafely(deps, coverage, suite, skippedTools = []) {
 * **provider 가 죽어도 툴을 건너뛰지 않는다.** provider 실패는 사용자 서버의 문제가 아니라
 * 우리 쪽 사정이고, 그것 때문에 케이스를 잃는 손해가 더 크다. baseline 값으로 진행하고
 * 그 사실을 화면에 적는다.
+*
+* **`--no-dry-run` 이면 돌지 않는다.** 채택을 정하는 것이 실제 서버 실행인데 그 경로에는 실행이
+* 없다. 이 분기가 빠져 있어 시험 실행을 끄고도 툴이 두 번 호출됐다(#397).
 */
 async function runPreFill(input, tools, baseline, deps, client) {
 	const skip = {
@@ -2973,6 +3678,10 @@ async function runPreFill(input, tools, baseline, deps, client) {
 		baseline: baseline.suite
 	});
 	if (request === null) return skip;
+	if (!input.dryRun) {
+		io.write("▸ 시험 실행이 꺼져 있어(--no-dry-run) AI 사전보완을 건너뜁니다. 제안 값의 채택은 실제 서버\n  실행이 정하는데 그 실행이 없습니다. baseline 값으로 진행합니다.\n  AI 사전보완이 필요하면 --no-dry-run 없이 실행하세요.\n");
+		return skip;
+	}
 	let view;
 	try {
 		view = preview({
@@ -3001,13 +3710,22 @@ async function runPreFill(input, tools, baseline, deps, client) {
 	const applied = await applyPreFill({
 		client,
 		baseline: baseline.suite,
-		preFill: dispatched.result
+		preFill: dispatched.result,
+		reset: () => (deps.attemptReset ?? attemptReset)(input.resetCmd).then((result) => result.grade)
 	});
+	if (applied.skippedReason !== void 0) io.write(`▸ ${applied.skippedReason}\n`);
 	io.write(renderPreFillSummary({
 		toolCount: tools.length,
 		proposedToolCount: request.tools.length,
 		adopted: applied.adopted,
 		notAdopted: applied.notAdopted,
+		held: applied.held,
+		heldCases: applied.cases.filter((item) => item.needsClassification).map((item) => ({
+			caseId: item.caseId,
+			proposedFields: item.proposedFields ?? [],
+			serverMessage: item.serverMessage ?? ""
+		})),
+		excluded: applied.excluded,
 		discarded: dispatched.result.discarded
 	}));
 	return {
@@ -3039,6 +3757,10 @@ async function runGenerateCommand(argv, deps) {
 		deps.writeStderr("오류 [GENERATE_INTERACTIVE_REQUIRED]: AI 검토에는 TTY가 필요합니다.\n해결: `--baseline-only`를 지정하거나 대화형 터미널에서 실행하세요.\n");
 		return 1;
 	}
+	const fixturesRead = await loadFixtures(input, deps);
+	if (fixturesRead === null) return 1;
+	const fixtureFile = fixturesRead.file;
+	const fixturePath = input.fixturesPath ?? DEFAULT_FIXTURES_PATH;
 	let connection;
 	/**
 	* 대화형 검토는 아래 try 밖에서 돌린다. 검토가 던지는 오류를 여기 catch 가 삼키면
@@ -3059,7 +3781,8 @@ async function runGenerateCommand(argv, deps) {
 		}
 		const baseline = deps.createBaselineSuite(tools, {
 			suiteId: input.suiteId,
-			suiteName: input.name
+			suiteName: input.name,
+			...fixtureFile === void 0 ? {} : { fixtures: fixtureFile }
 		});
 		let sessionSuite = baseline.suite;
 		let preFilledCaseIds = [];
@@ -3084,7 +3807,14 @@ async function runGenerateCommand(argv, deps) {
 				active,
 				session,
 				tools,
-				skippedTools: baseline.skippedTools
+				skippedTools: baseline.skippedTools,
+				outputContractSkips: baseline.outputContractSkips,
+				validBranchSkips: baseline.validBranchSkips,
+				fixtures: {
+					path: fixturePath,
+					fieldOrigins: baseline.fieldOrigins,
+					...fixtureFile?.notes === void 0 ? {} : { notes: fixtureFile.notes }
+				}
 			};
 		} else {
 			const final = deps.finalizeAuthoringDraft({
@@ -3098,7 +3828,7 @@ async function runGenerateCommand(argv, deps) {
 			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);
+			reportCoverageSafely(deps, () => baseline.coverage, finalSuite, baseline.skippedTools, baseline.outputContractSkips, baseline.validBranchSkips);
 			return 0;
 		}
 	} catch (error) {
@@ -3129,7 +3859,7 @@ async function runGenerateCommand(argv, deps) {
 		return 1;
 	}
 	try {
-		return await runInteractiveReview(input, review.tools, review.session, deps, review.active, review.skippedTools);
+		return await runInteractiveReview(input, review.tools, review.session, deps, review.active, review.skippedTools, review.outputContractSkips, review.validBranchSkips, review.fixtures);
 	} finally {
 		await review.active.close().catch(() => void 0);
 	}
@@ -3228,6 +3958,18 @@ function caseApprovalStatuses(suite) {
 	return new Map((suite.approval?.cases ?? []).map((entry) => [entry.id, entry.status]));
 }
 /**
+* 승인 시점에 실제 서버 실행 기록이 남았는가. `approval.cases` 의 존재가 기준이다.
+*
+* `generate` 는 시험 실행을 마치고 사람이 분류를 끝냈을 때만 이 키를 쓴다(`renderSuite` 의
+* 주석과 `reviewDryRun`). 그래서 `--baseline-only`·`--no-dry-run` 으로 저장한 명세는 지문이
+* 있어도 이 키가 없다. 지문 일치와 실행 기록은 별개다(#385).
+*
+* 빈 배열은 저장되지 않지만 손으로 쓴 파일에는 있을 수 있으므로 길이로 본다.
+*/
+function specRunHistory(suite) {
+	return (suite.approval?.cases?.length ?? 0) > 0 ? "present" : "absent";
+}
+/**
 * `serverDefect` 로 표시된 케이스가 다시 실패했을 때 붙이는 한 줄. 설계 문서 §9.
 * 들여쓰기는 보고서의 케이스 블록과 맞춘다. 개행으로 끝나고 호출자가 앞에 빈 줄을 붙인다.
 *
@@ -3252,6 +3994,18 @@ function renderSpecApproval(result, allPassed) {
 	return `명세: 현재 명세와 저장된 approval.fingerprint가 불일치함
   → 승인 ${short(result.approvedFingerprint ?? "")}   현재 ${short(result.fingerprint)}\n` + outcome + "  → 지문만으로는 변경 내용을 알 수 없습니다. 버전 관리에서 명세를 비교하세요.\n  → 의도한 변경이면 같은 설정으로 mcpeak generate 를 다시 실행하고 --force 로 재승인하세요.\n";
 }
+/**
+* 도구 하나의 스키마 직렬화 상한. 넘으면 스키마를 빼고 `schemasOmitted` 로 표시한다.
+*
+* 관측된 실제 MCP 도구 스키마는 대부분 1 KiB 아래다. 8 KiB 를 넘는 것은 $defs 가 수십 개
+* 달린 생성 스키마이고, 그런 것은 통째로 실어도 AI 가 원인을 좁히는 데 못 쓰면서 요청
+* 예산만 먹는다. `MAX_REQUEST_BYTES`(256 KiB)에 걸려 요청 전체가 거절되는 것보다 그 도구만
+* 줄이는 편이 낫다(#393).
+*
+* `maxCases` 기본값이 12 이고 실패 케이스가 부른 도구만 싣는다. 도구 하나가 8 KiB 를 넘지
+* 않으면 12개라도 96 KiB 이고, 나머지(진단·입력·stderr)를 더해도 256 KiB 아래다.
+*/
+const MAX_TOOL_SCHEMA_BYTES = 8192;
 /** 번들에 적는 CLI 식별자. `mcpeak --version` 이 찍는 것과 같은 출처를 쓴다. */
 const REPAIR_BUNDLE_GENERATED_BY = `mcpeak ${version}`;
 /**
@@ -3292,6 +4046,10 @@ function buildRepairBundle(options) {
 			caseId: item.spec.id,
 			caseName: item.spec.name,
 			status: item.status,
+			assertions: item.assertions.map((assertion) => ({
+				type: assertion.spec.type,
+				status: assertion.status
+			})),
 			diagnostics: diagnosticsOf(item)
 		};
 		if (item.spec.operation.type === "callTool") {
@@ -3306,20 +4064,43 @@ function buildRepairBundle(options) {
 		suiteId: options.report.suite.id,
 		suiteName: options.report.suite.name,
 		approval: options.specApproval.state,
+		runHistory: specRunHistory(options.suite),
 		fingerprint: options.specApproval.fingerprint
 	};
 	if (options.specApproval.approvedFingerprint !== void 0) spec.approvedFingerprint = options.specApproval.approvedFingerprint;
+	const called = new Set(failures.map((failure) => failure.tool).filter(Boolean));
+	let toolSchemasOmitted = 0;
+	const tools = (options.tools ?? []).filter((tool) => called.has(tool.name)).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0).map((tool) => {
+		const schemas = { inputSchema: tool.inputSchema ?? {} };
+		if (tool.outputSchema !== void 0) schemas.outputSchema = tool.outputSchema;
+		const omitted = Buffer.byteLength(JSON.stringify(schemas), "utf8") > MAX_TOOL_SCHEMA_BYTES;
+		if (omitted) toolSchemasOmitted++;
+		const entry = {
+			name: tool.name,
+			inputSchema: omitted ? {} : schemas.inputSchema
+		};
+		if (!omitted && schemas.outputSchema !== void 0) entry.outputSchema = schemas.outputSchema;
+		if (tool.description !== void 0) entry.description = tool.description;
+		if (omitted) entry.schemasOmitted = true;
+		return entry;
+	});
 	const bundle = {
-		bundleVersion: 1,
+		bundleVersion: 3,
 		generatedBy: options.cliVersion ?? REPAIR_BUNDLE_GENERATED_BY,
 		spec,
-		failures
+		failures,
+		tools,
+		target: { transport: options.target.transport }
 	};
+	if (toolSchemasOmitted > 0) bundle.truncated = { toolSchemas: toolSchemasOmitted };
 	/**
 	* 내용이 있을 때만 담는다. 판정은 화면이 쓰는 `hasDiagnosticContent` 와 **같은 함수**다.
 	* 규칙이 갈라지면 화면에는 안 뜨는 것이 번들에는 들어간다. 설계서 §4.2.
 	*/
-	if (options.processDiagnostics !== void 0 && hasDiagnosticContent(options.processDiagnostics)) bundle.process = options.processDiagnostics;
+	if (options.processDiagnostics !== void 0 && hasDiagnosticContent(options.processDiagnostics)) bundle.process = {
+		...options.processDiagnostics,
+		scope: "suite"
+	};
 	return bundle;
 }
 /**
@@ -3340,8 +4121,8 @@ 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 "versionMismatch": return `번들 형식 버전이 이 CLI 가 아는 3 이 아닙니다. 최신 \`mcpeak test --repair-bundle\` 로 다시 만드세요.`;
+		case "missingField": return "번들에 필요한 항목이 없거나 값이 형식과 다릅니다. `spec` 의 `suiteId`·`suiteName`·`approval`·`runHistory`, 각 실패의 `caseId`·`caseName`·`status`·`assertions`·`diagnostics`, 각 진단의 `code`·`message`, 각 단언의 `type`·`status`, 도구 목록 `tools` 와 각 도구의 `name`·`inputSchema`, 대상 `target` 의 `transport` 가 있어야 합니다. `process` 가 있으면 그 안에 `scope` 도 있어야 합니다. `mcpeak test --repair-bundle` 로 다시 만드세요.";
 		case "emptyFailures": return "번들에 실패한 케이스가 없습니다. 진단할 근거가 없으므로 provider 를 부르지 않습니다. 실패가 있는 실행에서 번들을 다시 만드세요.";
 	}
 }
@@ -3358,6 +4139,7 @@ const APPROVAL_STATES = [
 	"mismatched",
 	"absent"
 ];
+const RUN_HISTORIES = ["present", "absent"];
 const FAILURE_STATUSES = [
 	"failed",
 	"timedOut",
@@ -3365,6 +4147,13 @@ const FAILURE_STATUSES = [
 	"notRun"
 ];
 const APPROVED_AS = ["passed", "serverDefect"];
+/** runner 의 `AssertionResult.status` 와 같은 네 값이다. 케이스 상태와 다른 유니온이다. */
+const ASSERTION_STATUSES = [
+	"passed",
+	"failed",
+	"skipped",
+	"notRun"
+];
 const isOneOf = (value, allowed) => typeof value === "string" && allowed.includes(value);
 /**
 * 소비하는 필드가 실제로 있고 형식이 맞는지 본다.
@@ -3381,6 +4170,12 @@ function failureShapeValid(failure) {
 	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.assertions)) return false;
+	for (const assertion of failure.assertions) {
+		if (!plainObject(assertion)) return false;
+		if (typeof assertion.type !== "string") return false;
+		if (!isOneOf(assertion.status, ASSERTION_STATUSES)) return false;
+	}
 	if (!Array.isArray(failure.diagnostics)) return false;
 	for (const diagnostic of failure.diagnostics) {
 		if (!plainObject(diagnostic)) return false;
@@ -3390,11 +4185,20 @@ function failureShapeValid(failure) {
 	}
 	return true;
 }
+function toolShapeValid(tool) {
+	if (!plainObject(tool)) return false;
+	if (typeof tool.name !== "string" || tool.name === "") return false;
+	if (!plainObject(tool.inputSchema)) return false;
+	if (tool.outputSchema !== void 0 && !plainObject(tool.outputSchema)) return false;
+	if (tool.description !== void 0 && typeof tool.description !== "string") 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 (!isOneOf(spec.runHistory, RUN_HISTORIES)) return false;
 	if (typeof spec.fingerprint !== "string") return false;
 	return true;
 }
@@ -3412,7 +4216,7 @@ function readRepairBundle(text) {
 		status: "invalid",
 		reason: "notObject"
 	};
-	if (parsed.bundleVersion !== 1) return {
+	if (parsed.bundleVersion !== 3) return {
 		status: "invalid",
 		reason: "versionMismatch"
 	};
@@ -3428,6 +4232,28 @@ function readRepairBundle(text) {
 		status: "invalid",
 		reason: "missingField"
 	};
+	if (!Array.isArray(parsed.tools)) return {
+		status: "invalid",
+		reason: "missingField"
+	};
+	for (const tool of parsed.tools) if (!toolShapeValid(tool)) return {
+		status: "invalid",
+		reason: "missingField"
+	};
+	if (!plainObject(parsed.target) || typeof parsed.target.transport !== "string") return {
+		status: "invalid",
+		reason: "missingField"
+	};
+	if (parsed.process !== void 0) {
+		if (!plainObject(parsed.process)) return {
+			status: "invalid",
+			reason: "missingField"
+		};
+		if (parsed.process.scope !== "suite") return {
+			status: "invalid",
+			reason: "missingField"
+		};
+	}
 	if (parsed.failures.length === 0) return {
 		status: "invalid",
 		reason: "emptyFailures"
@@ -3506,6 +4332,16 @@ function parseRepairCommand(argv) {
 * `repair` 명령. 번들을 읽고, 전송 내용을 확인받고, provider 에게 진단을 물어 화면에 찍는다.
 * 파일도 명세도 고치지 않는다. 종료 코드는 운영 실패에만 1 이다(설계서 §7.1).
 */
+/**
+* 진단 요청이 크기 상한을 넘었을 때의 문장.
+*
+* `repair-render.ts` 가 아니라 여기 두는 이유는 그 파일이 화면 조립을 맡고 이 문장은 이
+* 명령의 실패 경로에만 쓰이기 때문이다. 다른 실패 문장들처럼 `deps.writeStderr` 로 나간다.
+*
+* 무엇이 왜 큰지와 사용자가 할 수 있는 일을 함께 적는다. 상한 계산이 틀렸을 때 스택
+* 트레이스만 뜨면 사용자는 할 수 있는 일이 없다(#393).
+*/
+const REPAIR_REQUEST_TOO_LARGE_LINE = "오류 [REPAIR_REQUEST_TOO_LARGE]: 진단 요청이 크기 상한을 넘었습니다.\n  번들의 도구 선언이 너무 큽니다. --max-cases 를 줄여 실패 케이스 수를 낮추면\n  함께 실리는 도구도 줄어듭니다.\n";
 async function runRepairCommand(argv, deps) {
 	let input;
 	try {
@@ -3533,27 +4369,49 @@ async function runRepairCommand(argv, deps) {
 		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
-	});
+	/**
+	* 요청 크기 상한을 넘으면 `prepareDiagnosisRequest` 가 `RangeError` 를 던진다.
+	* 도구 선언을 싣기 시작하면서 실제로 닿을 수 있는 자리가 됐다(#393).
+	*
+	* 던진 것을 그대로 두면 스택 트레이스가 화면에 뜨고 사용자가 할 수 있는 일이 없다.
+	* 번들을 다시 만들 수도 없다. 그 안에 이미 도구가 들어 있기 때문이다.
+	*/
+	let preview;
+	try {
+		preview = deps.diagnosis.prepare({
+			specTrust: {
+				fingerprint: bundle.spec.approval,
+				runHistory: bundle.spec.runHistory
+			},
+			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: bundle.tools.map((tool) => ({
+				name: tool.name,
+				inputSchema: tool.inputSchema,
+				...tool.description === void 0 ? {} : { description: tool.description },
+				...tool.outputSchema === void 0 ? {} : { outputSchema: tool.outputSchema }
+			})),
+			providerId: input.providerId,
+			model: input.model,
+			maxCases: input.maxCases,
+			includeStderr: input.includeStderr
+		});
+	} catch (error) {
+		if (!(error instanceof RangeError)) throw error;
+		deps.writeStderr(REPAIR_REQUEST_TOO_LARGE_LINE);
+		return 1;
+	}
 	const confirmView = {
 		providerId: input.providerId,
 		model: input.model,
@@ -3562,8 +4420,11 @@ async function runRepairCommand(argv, deps) {
 		omittedFailures: preview.omitted.failures,
 		maxCases: input.maxCases,
 		approval: bundle.spec.approval,
+		runHistory: bundle.spec.runHistory,
 		includeStderr: input.includeStderr,
 		...preview.request.processDiagnostics === void 0 ? {} : { stderr: preview.request.processDiagnostics.stderr },
+		sentTools: bundle.tools.length,
+		omittedToolSchemas: bundle.tools.filter((tool) => tool.schemasOmitted === true).length,
 		requestBytes: preview.byteLength
 	};
 	if (!input.yes) {
@@ -3737,6 +4598,7 @@ async function startExternalWiring(options) {
 			mode: "record",
 			sessionId: SESSION_ID,
 			store,
+			...options.origin === void 0 ? {} : { origin: options.origin },
 			...options.existingNodeOptions === void 0 ? {} : { existingNodeOptions: options.existingNodeOptions }
 		}) : await startExternalCoordinator({
 			mode: "replay",
@@ -3873,6 +4735,7 @@ function parseTestCommand(argv) {
 	let recordSessionPath;
 	const args = [];
 	const headerEnv = createHeaderEnvCollector();
+	const envForward = createEnvForwardCollector();
 	for (let index = 1; index < argv.length; index += 1) {
 		const token = argv[index] ?? "";
 		/**
@@ -3925,6 +4788,15 @@ function parseTestCommand(argv) {
 				const rejected = headerEnv.add(parsed.value.header, parsed.value.envName);
 				if (rejected !== void 0) fail(rejected);
 			}
+		} else if (token === "--env" || token.startsWith("--env=")) {
+			const read = readOptionValue(argv, token, "--env", index);
+			index = read.index;
+			const parsed = parseEnvForwardOption(read.value);
+			if (!parsed.ok) fail(parsed.message);
+			else {
+				const rejected = envForward.add(parsed.value);
+				if (rejected !== void 0) fail(rejected);
+			}
 		} else if (token === "--arg" || token.startsWith("--arg=")) {
 			let value;
 			if (token === "--arg") {
@@ -4024,6 +4896,7 @@ function parseTestCommand(argv) {
 		hint: TEST_USAGE_HINT
 	});
 	if (url !== void 0 && args.length > 0) fail("`--arg` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--arg` 는 우리가 띄우는 프로세스에 넘길 인자입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
+	if (url !== void 0 && envForward.snapshot().length > 0) fail("`--env` 는 `--url` 과 함께 쓸 수 없습니다.\n→ `--env` 는 우리가 띄우는 프로세스의 환경에 넣을 변수입니다. 원격 서버에는 띄울 프로세스가 없습니다.");
 	if (command !== void 0 && !headerEnv.isEmpty()) fail("`--header-env` 는 `--url` 과 함께만 쓸 수 있습니다.\n→ 헤더는 HTTP 요청에 실립니다. `--command` 로 띄운 서버와는 stdio 로 이야기합니다.");
 	if (url !== void 0 && stderrLines !== void 0) fail("`--stderr-lines` 는 `--url` 과 함께 쓸 수 없습니다.\n→ 이 옵션은 우리가 띄운 프로세스의 stderr 를 보여줍니다. 원격 서버에는 그 프로세스가 없습니다.\n→ 원격 서버 실패는 엔드포인트와 HTTP 상태로 진단합니다. 그 블록은 항상 나옵니다.");
 	if (url !== void 0 && (sessionPath !== void 0 || recordSessionPath !== void 0)) fail("External 세션 옵션은 `--url` 과 함께 쓸 수 없습니다.\n→ External 배선은 우리가 띄운 자식 프로세스의 환경변수로 들어갑니다.\n→ 원격 서버는 우리가 띄우지 않으므로 그 주입 지점이 없습니다.");
@@ -4034,7 +4907,8 @@ function parseTestCommand(argv) {
 		target: url === void 0 ? Object.freeze({
 			transport: "stdio",
 			command,
-			args: Object.freeze(args)
+			args: Object.freeze(args),
+			envNames: envForward.snapshot()
 		}) : Object.freeze({
 			transport: "http",
 			url,
@@ -4881,7 +5755,9 @@ async function runCliCore(argv, dependencies, childEnv) {
 			report: finalReport,
 			suite: validated.value,
 			specApproval,
-			processDiagnostics: settled.value
+			processDiagnostics: settled.value,
+			tools,
+			target: { transport: input.target.transport }
 		});
 		if (bundle === void 0) dependencies.writeStdout(`\n${REPAIR_BUNDLE_EMPTY_LINE}`);
 		else try {
@@ -4961,7 +5837,7 @@ function externalOpenFailure(mode, path, error) {
 	if (code === "REPLAY_SOURCE_INVALID") return {
 		code: "EXTERNAL_SESSION_FAILED",
 		message: `녹화가 완료되지 않은 세션입니다: ${shownPath}`,
-		hint: "녹화 실행이 실패했을 수 있습니다. `--record-session` 으로 다시 녹화하세요."
+		hint: "녹화가 도중에 끊겼거나, 지원하지 않는 응답(비-JSON·redirect)을 만나 호출을 끝내지 못한 세션입니다. `--record-session` 으로 다시 녹화하세요."
 	};
 	if (code === "SCHEMA_VERSION_UNSUPPORTED") return {
 		code: "EXTERNAL_SESSION_FAILED",
@@ -4990,10 +5866,15 @@ function externalOpenFailure(mode, path, error) {
 function externalCloseFailure(error) {
 	const code = error?.code;
 	const detail = error instanceof Error ? error.message : String(error);
+	if (code === "INCOMPLETE_SESSION") return {
+		code: "EXTERNAL_SESSION_FAILED",
+		message: "녹화를 완료하지 못했습니다. 끝나지 않은 외부 호출이 남았습니다.",
+		hint: detail
+	};
 	return {
 		code: "EXTERNAL_SESSION_FAILED",
 		message: "External 세션을 닫지 못했습니다.",
-		hint: code === "INCOMPLETE_SESSION" ? detail : escapeTerminalText(detail)
+		hint: escapeTerminalText(detail)
 	};
 }
 /** 같은 단서의 재생 판. 남지 않는 것이 아니라 **실제 네트워크로 나가는** 것이 요점이다. */
@@ -5047,7 +5928,8 @@ function externalSessionOutcome(summary, sessionPath) {
 	const shownPath = escapeTerminalText(sessionPath);
 	if (summary.mode === "record") {
 		if (summary.interactionCount === 0) return void 0;
-		if (summary.status !== "completed") return `\n→ 이 실행이 실패해 녹화를 완료하지 않았습니다: ${shownPath}\n  외부 호출 ${summary.interactionCount}건을 잡았지만 재생 원본으로 쓸 수 없습니다.\n→ 실패 원인을 고친 뒤 다시 녹화하세요.
+		if (summary.status !== "completed") return `\n→ 녹화가 완료되지 않은 채 닫혔습니다: ${shownPath}\n  외부 호출 ${summary.interactionCount}건을 잡았지만 재생 원본으로 쓸 수 없습니다.\n→ 테스트 판정과는 무관합니다. 녹화 자체가 도중에 중단됐습니다.
+→ 위에 나온 원인을 고친 뒤 다시 녹화하세요.
 `;
 		return `\n→ 외부 호출 ${summary.interactionCount}건을 녹화했습니다: ${shownPath}\n  이 수는 어댑터가 잡은 호출만 셉니다. 범위 밖 호출은 세션에 남지 않습니다.
 `;
@@ -5094,9 +5976,16 @@ function formatUtc(recordedAt, date, time) {
 	return `${date} ${time} UTC`;
 }
 function externalSessionNotice(summary) {
+	const others = summary.otherProcessCalls ?? 0;
 	if (summary.mode === "record") {
-		if (summary.interactionCount > 0) return void 0;
-		return "\n알림: 이 실행에서 외부 호출이 하나도 녹화되지 않았습니다.\n→ 서버가 외부 API를 호출했다면 지원 범위를 벗어났는지 확인하세요.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
+		if (summary.interactionCount === 0 && others > 0) return `
+알림: 이 실행에서 외부 호출이 하나도 녹화되지 않았습니다.
+→ 다른 프로세스가 먼저 이 세션의 기록을 시작해, 이 실행의 호출 ${others}건을 녹화하지 않았습니다.\n→ 서버가 외부 API를 자식 프로세스에서 부르면 먼저 시작한 쪽만 녹화됩니다.
+`;
+		if (summary.interactionCount === 0) return "\n알림: 이 실행에서 외부 호출이 하나도 녹화되지 않았습니다.\n→ 서버가 외부 API를 호출했다면 지원 범위를 벗어났는지 확인하세요.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
+		if (others > 0) return `\n알림: 이 실행의 외부 호출 ${others}건이 다른 프로세스에서 나와 녹화되지 않았습니다.\n→ 녹화본은 이 서버가 한 일의 일부만 담고 있습니다. 재생은 나머지를 막지 못합니다.
+`;
+		return;
 	}
 	if (summary.interactionCount === 0) return "\n알림: 이 세션에는 녹화된 외부 호출이 0건입니다. 재생할 것이 없었습니다.\n→ 녹화 실행이 외부 호출을 하나도 잡지 못했다는 뜻입니다. 이 세션은 아무 호출도 막지 못합니다.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
 	if (summary.consumedCount === 0) return "\n알림: 이 실행에서 녹화된 외부 호출이 하나도 재생되지 않았습니다.\n→ 지원 범위 밖의 호출은 실제 네트워크로 나갔을 수 있습니다.\n→ MCPeak은 서버가 `globalThis.fetch`로 부른 것만 잡습니다.\n";
@@ -5148,6 +6037,7 @@ async function runCli(argv, dependencies) {
 		wiring = await startExternalWiring({
 			mode: mode.mode,
 			sessionPath: mode.path,
+			...mode.origin === void 0 ? {} : { origin: mode.origin },
 			existingNodeOptions: process.env.NODE_OPTIONS
 		});
 	} catch (error) {
@@ -5161,7 +6051,7 @@ async function runCli(argv, dependencies) {
 		throw error;
 	}
 	try {
-		const summary = await wiring.finish(exitCode === 0 ? "completed" : "failed");
+		const summary = await wiring.finish("completed");
 		const outcome = externalSessionOutcome(summary, mode.path);
 		if (outcome !== void 0) dependencies.writeStderr(outcome);
 		if (summary.mode === "replay") {
@@ -5202,10 +6092,18 @@ function externalModeOf(argv) {
 	} catch {
 		return;
 	}
-	if (input.recordSessionPath !== void 0) return {
-		mode: "record",
-		path: input.recordSessionPath
-	};
+	if (input.recordSessionPath !== void 0) {
+		const origin = input.target.transport === "stdio" ? {
+			command: input.target.command,
+			args: input.target.args,
+			suitePath: input.suitePath
+		} : void 0;
+		return {
+			mode: "record",
+			path: input.recordSessionPath,
+			...origin === void 0 ? {} : { origin }
+		};
+	}
 	if (input.sessionPath !== void 0) return {
 		mode: "replay",
 		path: input.sessionPath
@@ -5218,6 +6116,12 @@ Object.defineProperty(exports, "GLOBAL_HELP", {
 		return GLOBAL_HELP;
 	}
 });
+Object.defineProperty(exports, "REVIEW_BACK_VALUE", {
+	enumerable: true,
+	get: function() {
+		return REVIEW_BACK_VALUE;
+	}
+});
 Object.defineProperty(exports, "commandDiscovery", {
 	enumerable: true,
 	get: function() {