feat: R10 입력 고정과 평가 봉인을 분리

상황:
평가 입력 고정이 사람 검수와 평가자 준비를 요구하는 round seal에 결합돼 03 leaf가 자체 책임을 끝내지 못했다.

변경:
current source와 허용된 기계 리포트 및 참조 산출물만 해시로 고정하는 --freeze-input 전이, 변조 검증, TODO 삭제 보호 계약을 추가했다.

영향:
input-frozen은 사람 검수나 R10 통과를 주장하지 않으며 기존 --seal과 독립 report 게이트는 계속 모든 외부 조건을 요구한다.

검증:
preflight 3/3, 관련 pytest 45개, docs gate, ruff, py_compile, git diff check를 통과했다.

Author: eddmpython

docs/skills/ops/foundation/testing-and-gates.md

@@ -116,8 +116,8 @@ uv run python -X utf8 tests/run.py gate attempts
 | --- | --- | --- |
 | `docs` | fast | 운영 문서 포인터, gate 정의, CI 연결 상태를 확인한다. |
 | `root-clean` | fast | 저장소 루트가 canonical tree와 맞고 로컬 실습 파일, 로그, 임시 산출물이 남지 않았는지 확인한다. |
-| `evaluation-contract` | fast | clean implementation commit에서 목표 점수 없는 frozen rubric, closed raw report·canonical finding ledger schema, bundle exclusion과 raw report·scope·maturity·score/severity 보존 negative fixture를 검증한다. R10 bundle의 허용 목록 machine report와 직접 참조 JSON·이미지는 current source commit, 원본 hash, read-only entry로 묶고 stale·dirty scope는 seal을 차단한다. 독립 evaluator 배정과 R10 report 생성은 실행하지 않는다. |
-| `plan-quality` | fast | mainPlan이 미완료 TODO만 보존하는지, 현재 사실과 R10 draft가 일관적인지 검사한다. evaluator 배정·sealed scope·raw report 같은 외부 readiness blocker만 남은 draft는 통과하지만 blocker를 report에서 제거하지 않는다. |
+| `evaluation-contract` | fast | clean implementation commit에서 목표 점수 없는 frozen rubric, closed raw report·canonical finding ledger schema, bundle exclusion과 raw report·scope·maturity·score/severity 보존 negative fixture를 검증한다. R10 bundle의 허용 목록 machine report와 직접 참조 JSON·이미지는 current source commit, 원본 hash, read-only entry로 묶고 stale·dirty scope는 input freeze와 round seal을 모두 차단한다. 독립 evaluator 배정과 R10 report 생성은 실행하지 않는다. |
+| `plan-quality` | fast | mainPlan이 미완료 TODO만 보존하는지, 현재 사실과 R10 bundle이 일관적인지 검사한다. current source와 machine evidence만 고정한 `input-frozen` 상태는 evaluator 배정·사람 검수·raw report·round seal을 주장하지 않는다. 이 외부 readiness blocker가 명시돼 있으면 통과하지만 blocker를 report에서 제거하지 않는다. |
 | `r10-independent-review` | release | 서명 hash와 가용 기간이 있는 독립 evaluator roster, sealed scope, 세 raw report byte seal·결정적 Markdown view와 손실 없는 canonical finding ledger를 목표 점수 없이 엄격하게 검사한다. open P0·P1은 점수와 무관하게 `product-release`를 차단한다. |
 | `backend` | fast | Python backend 전체 테스트를 최대 1800초 안에서 실행한다. `tests/_attempts`는 `--ignore`로 수집하지 않고, 0.25초 이상 걸린 항목 중 가장 느린 25개를 출력해 preflight 병목을 관찰한다. |
 | `attempts` | experiment | 운영과 분리된 `tests/_attempts` 실험 샌드박스를 실행한다. preflight/quality-cycle/CI 비포함이며 `tier` 스윕에도 끼지 않는다. |
@@ -256,4 +256,5 @@ uv run python -X utf8 tests/run.py gate attempts
 - `landing-build`는 공개 문서 surface가 generated docs 본문 HTML을 nav chunk에 싣지 않는지도 확인한다. `docsNav.js`는 metadata와 `contentModule`만 담고, 각 문서 본문 module은 화면과 prerender가 소비하는 `html`만 가진 채 `landing/src/lib/generated/docsPages/page*.js`로 분리되어 slug route에서 동적 로딩되어야 한다. 검색 원문 `text`는 `searchIndex.js`가 소유하므로 페이지 module에 중복하지 않는다. `docs/skills` 핵심 SSOT 문구가 generated docs에 반영되지 않은 stale 상태도 실패로 본다.
 - 기존 부채를 새 테스트로 한 번에 해결하지 못하면 별도 baseline 또는 명시적 TODO 문서로 분리한다.
 - CI YAML은 세부 명령을 소유하지 않고 `tests/run.py gate <name>`만 호출한다.
-- `evaluation-contract`은 rubric·raw report schema·canonical finding ledger schema·negative fixture 자체만 봉인한다. sealed bundle, evaluator roster, 실제 raw report와 finding ledger는 `08-r10-independent-review`가 소유하며 이 downstream 산출물을 계약 packet의 완료 조건으로 되돌리지 않는다.
+- `buildPrdEvaluationBundle.py --freeze-input`은 clean source commit, current machine report 9개, 직접 참조 artifact, rubric과 exclusion manifest만 `input-frozen`으로 고정한다. archive와 scope hash가 바뀌면 `--check`와 `plan-quality`가 실패한다. 이 전이는 `sealed: false`, `roundState: blocked`, `roundSealEligible: false`를 유지하므로 evaluator 배정, 사람 검수, 독립 report나 R10 통과를 대신하지 않는다. 이후 모든 remediation과 evaluator 조건이 갖춰진 경우에만 별도 `--seal`이 round scope를 봉인한다.
+- `evaluation-contract`은 rubric·raw report schema·canonical finding ledger schema·negative fixture 자체만 봉인한다. round seal, evaluator roster, 실제 raw report와 finding ledger는 `08-r10-independent-review`가 소유하며 이 downstream 산출물을 입력 고정 packet의 완료 조건으로 되돌리지 않는다.

docs/skills/ops/tools/buildPrdEvaluationBundle.py

@@ -790,6 +790,34 @@ def remediationSealBlockers(inputManifest: dict[str, Any]) -> list[str]:
     return blockers
 
 
+def rubricFreezeBlockers(inputManifest: dict[str, Any], rubricBytes: bytes) -> list[str]:
+    rubric = inputManifest.get("rubric")
+    if (
+        not isinstance(rubric, dict)
+        or rubric.get("sha256") != sha256Bytes(rubricBytes)
+        or rubric.get("targetScore") is not None
+        or rubric.get("passThreshold") is not None
+    ):
+        return ["frozen rubric metadata is invalid"]
+    return []
+
+
+def inputFreezeReadiness(
+    inputManifest: dict[str, Any],
+    rubricBytes: bytes,
+    machineEvidenceBlockers: Iterable[str] = (),
+) -> dict[str, Any]:
+    freezeBlockers = sorted(
+        set(list(machineEvidenceBlockers) + rubricFreezeBlockers(inputManifest, rubricBytes))
+    )
+    return {
+        "freezeEligible": not freezeBlockers,
+        "inputFrozen": False,
+        "freezeBlockingReasons": freezeBlockers,
+        "blockingReasons": list(freezeBlockers),
+    }
+
+
 def roundReadiness(
     inputManifest: dict[str, Any],
     roster: dict[str, Any],
@@ -800,15 +828,8 @@ def roundReadiness(
         remediationSealBlockers(inputManifest)
         + verifyEvaluatorRoster(roster)
         + list(machineEvidenceBlockers)
+        + rubricFreezeBlockers(inputManifest, rubricBytes)
     )
-    rubric = inputManifest.get("rubric")
-    if (
-        not isinstance(rubric, dict)
-        or rubric.get("sha256") != sha256Bytes(rubricBytes)
-        or rubric.get("targetScore") is not None
-        or rubric.get("passThreshold") is not None
-    ):
-        sealBlockers.append("frozen rubric metadata is invalid")
     blockers = list(sealBlockers)
     if inputManifest.get("sealed") is not True or inputManifest.get("roundState") != "ready":
         blockers.append("R10 input manifest is not sealed and ready")
@@ -839,6 +860,32 @@ def buildEvaluationScopeManifest(entries: tuple[BundleEntry, ...], *, gitHead: s
     }
 
 
+def inputFreezeMatches(
+    binding: Any,
+    scope: dict[str, Any],
+    archive: dict[str, Any],
+    machineEvidence: dict[str, Any],
+) -> bool:
+    return (
+        isinstance(binding, dict)
+        and binding.get("state") == "frozen"
+        and binding.get("manifestPath") == relativePath(MANIFEST_PATH)
+        and binding.get("archivePath") == archive["path"]
+        and binding.get("gitCommit") == scope["gitCommit"]
+        and binding.get("dirtyDiffHash") == scope["dirtyDiffHash"]
+        and binding.get("manifestHash") == scope["manifestHash"]
+        and binding.get("evaluationBundleHash") == archive["sha256"]
+        and binding.get("fileCount") == scope["fileCount"]
+        and binding.get("machineEvidenceIndexPath") == EVIDENCE_INDEX_PATH
+        and binding.get("requiredReportCount") == machineEvidence["requiredReportCount"]
+        and binding.get("includedReportCount") == machineEvidence["includedReportCount"]
+        and binding.get("artifactCount") == machineEvidence["artifactCount"]
+        and binding.get("allCurrent") is True
+        and machineEvidence["allCurrent"] is True
+        and machineEvidence["blockingReasons"] == []
+    )
+
+
 def buildPrdEvaluationBundle() -> tuple[dict[str, Any], bytes]:
     gitHead = currentGitHead()
     scopeCommit = latestIncludedScopeCommit(gitHead)
@@ -861,9 +908,23 @@ def buildPrdEvaluationBundle() -> tuple[dict[str, Any], bytes]:
     beforeDiffHash = dirtyDiffHash(entries, beforeStatuses)
     scope = buildEvaluationScopeManifest(entries, gitHead=scopeCommit, diffHash=beforeDiffHash)
     archiveBytes = buildZipBytes(entries)
+    archive = {
+        "path": relativePath(ARCHIVE_PATH),
+        "sha256": sha256Bytes(archiveBytes),
+        "bytes": len(archiveBytes),
+        "format": "zip",
+        "compression": ZIP_COMPRESSION_NAME,
+        "compressionMethod": ZIP_COMPRESSION,
+        "readOnlyEntries": True,
+    }
     if currentGitHead() != gitHead or changedScopeStatuses() != beforeStatuses:
         raise BundleError("evaluation scope changed while the bundle was being built")
     inputManifest = loadMapping(INPUT_PATH)
+    inputReadiness = inputFreezeReadiness(
+        inputManifest,
+        sourceBytes[relativePath(RUBRIC_SOURCE)],
+        machineEvidence["blockingReasons"],
+    )
     readiness = roundReadiness(
         inputManifest,
         loadMapping(ROSTER_PATH),
@@ -879,29 +940,52 @@ def buildPrdEvaluationBundle() -> tuple[dict[str, Any], bytes]:
         and inputScope.get("gitCommit") == scope["gitCommit"]
         and inputScope.get("dirtyDiffHash") == scope["dirtyDiffHash"]
         and inputScope.get("manifestHash") == scope["manifestHash"]
-        and inputScope.get("evaluationBundleHash") == sha256Bytes(archiveBytes)
+        and inputScope.get("evaluationBundleHash") == archive["sha256"]
     )
+    frozenBinding = inputManifest.get("inputFreeze")
+    frozenBindingPresent = isinstance(frozenBinding, dict) and frozenBinding.get("state") == "frozen"
+    frozenInputMatches = inputFreezeMatches(frozenBinding, scope, archive, machineEvidence)
+    inputReadiness["inputFrozen"] = inputReadiness["freezeEligible"] and frozenInputMatches
+    if frozenBindingPresent and not frozenInputMatches:
+        inputReadiness["blockingReasons"] = sorted(
+            set(inputReadiness["blockingReasons"] + ["frozen input scope does not match the current bundle"])
+        )
     if inputManifest.get("sealed") is True and not sealedScopeMatches:
         readiness["blockingReasons"] = sorted(
             set(readiness["blockingReasons"] + ["sealed input scope does not match the current bundle"])
         )
+    if not inputReadiness["inputFrozen"] and not sealedScopeMatches:
+        readiness["sealEligible"] = False
+        readiness["sealBlockingReasons"] = sorted(
+            set(readiness["sealBlockingReasons"] + ["R10 input bundle is not frozen"])
+        )
+        readiness["blockingReasons"] = sorted(
+            set(readiness["blockingReasons"] + ["R10 input bundle is not frozen"])
+        )
     readiness["roundReady"] = readiness["sealEligible"] and sealedScopeMatches
-    scope["sealState"] = "sealed" if sealedScopeMatches else "draft"
-    state = "sealed" if sealedScopeMatches else "ready-to-seal" if readiness["sealEligible"] else "draft"
+    scope["sealState"] = (
+        "sealed"
+        if sealedScopeMatches
+        else "input-frozen"
+        if inputReadiness["inputFrozen"]
+        else "draft"
+    )
+    state = (
+        "sealed"
+        if sealedScopeMatches
+        else "input-frozen"
+        if inputReadiness["inputFrozen"]
+        else "ready-to-seal"
+        if readiness["sealEligible"]
+        else "draft"
+    )
     manifest = {
         "schemaVersion": 1,
         "roundId": "R10",
         "state": state,
         "scope": {key: value for key, value in scope.items() if key != "files"},
-        "archive": {
-            "path": relativePath(ARCHIVE_PATH),
-            "sha256": sha256Bytes(archiveBytes),
-            "bytes": len(archiveBytes),
-            "format": "zip",
-            "compression": ZIP_COMPRESSION_NAME,
-            "compressionMethod": ZIP_COMPRESSION,
-            "readOnlyEntries": True,
-        },
+        "archive": archive,
+        "inputReadiness": inputReadiness,
         "roundReadiness": readiness,
         "machineEvidence": {
             "indexPath": EVIDENCE_INDEX_PATH,
@@ -1026,6 +1110,66 @@ def draftInputManifest(inputManifest: dict[str, Any], bundleManifest: dict[str,
     return updated
 
 
+def frozenInputManifest(inputManifest: dict[str, Any], bundleManifest: dict[str, Any]) -> dict[str, Any]:
+    inputReadiness = bundleManifest.get("inputReadiness")
+    if not isinstance(inputReadiness, dict) or inputReadiness.get("freezeEligible") is not True:
+        reasons = (
+            inputReadiness.get("freezeBlockingReasons", [])
+            if isinstance(inputReadiness, dict)
+            else ["input freeze readiness is absent"]
+        )
+        raise BundleError("R10 input cannot be frozen: " + "; ".join(reasons))
+    scope = bundleManifest["scope"]
+    archive = bundleManifest["archive"]
+    machineEvidence = bundleManifest["machineEvidence"]
+    updated = draftInputManifest(inputManifest, bundleManifest)
+    remainingSealBlockers = [
+        blocker
+        for blocker in bundleManifest["roundReadiness"]["sealBlockingReasons"]
+        if blocker != "R10 input bundle is not frozen"
+    ]
+    updated["draftBundle"]["sealEligible"] = not remainingSealBlockers
+    updated["inputFreeze"] = {
+        "state": "frozen",
+        "manifestPath": relativePath(MANIFEST_PATH),
+        "archivePath": archive["path"],
+        "gitCommit": scope["gitCommit"],
+        "dirtyDiffHash": scope["dirtyDiffHash"],
+        "manifestHash": scope["manifestHash"],
+        "evaluationBundleHash": archive["sha256"],
+        "fileCount": scope["fileCount"],
+        "machineEvidenceIndexPath": machineEvidence["indexPath"],
+        "requiredReportCount": machineEvidence["requiredReportCount"],
+        "includedReportCount": machineEvidence["includedReportCount"],
+        "artifactCount": machineEvidence["artifactCount"],
+        "allCurrent": machineEvidence["allCurrent"],
+    }
+    return updated
+
+
+def freezeInputBundle(manifest: dict[str, Any], archiveBytes: bytes) -> dict[str, Any]:
+    inputManifest = loadMapping(INPUT_PATH)
+    updatedInput = frozenInputManifest(inputManifest, manifest)
+    originalInputBytes = INPUT_PATH.read_bytes()
+    updatedInputBytes = yaml.safe_dump(updatedInput, allow_unicode=True, sort_keys=False, width=120).encode("utf-8")
+    try:
+        writeAtomic(INPUT_PATH, updatedInputBytes)
+        frozenManifest, frozenArchiveBytes = buildPrdEvaluationBundle()
+        if (
+            frozenManifest["state"] != "input-frozen"
+            or frozenManifest["inputReadiness"]["inputFrozen"] is not True
+        ):
+            raise BundleError("R10 input was updated but the current bundle did not reach an input-frozen state")
+        if frozenArchiveBytes != archiveBytes:
+            raise BundleError("evaluation archive changed during the input freeze transition")
+    except Exception:
+        writeAtomic(INPUT_PATH, originalInputBytes)
+        raise
+    writeAtomic(ARCHIVE_PATH, frozenArchiveBytes, readOnly=True)
+    writeAtomic(MANIFEST_PATH, dumpManifest(frozenManifest))
+    return frozenManifest
+
+
 def sealBundle(manifest: dict[str, Any], archiveBytes: bytes) -> dict[str, Any]:
     inputManifest = loadMapping(INPUT_PATH)
     updatedInput = sealedInputManifest(inputManifest, manifest)
@@ -1051,6 +1195,11 @@ def buildParser() -> argparse.ArgumentParser:
     action = parser.add_mutually_exclusive_group(required=True)
     action.add_argument("--write", action="store_true", help="Write the tracked manifest and generated ZIP archive.")
     action.add_argument("--check", action="store_true", help="Verify the tracked manifest against the current scope.")
+    action.add_argument(
+        "--freeze-input",
+        action="store_true",
+        help="Freeze current source and machine evidence without claiming evaluator or round readiness.",
+    )
     action.add_argument("--seal", action="store_true", help="Seal only after remediation and evaluator evidence is ready.")
     return parser
 
@@ -1065,6 +1214,12 @@ def main(argv: list[str] | None = None) -> int:
                 f"sealed R10 bundle: {sealed['scope']['fileCount']} files, "
                 f"sha256={sealed['archive']['sha256']}"
             )
+        elif args.freeze_input:
+            frozen = freezeInputBundle(manifest, archiveBytes)
+            print(
+                f"froze R10 input bundle: {frozen['scope']['fileCount']} files, "
+                f"sha256={frozen['archive']['sha256']}"
+            )
         elif args.write:
             inputManifest = loadMapping(INPUT_PATH)
             updatedInput = draftInputManifest(inputManifest, manifest)
@@ -1074,14 +1229,16 @@ def main(argv: list[str] | None = None) -> int:
             )
             writeAtomic(ARCHIVE_PATH, archiveBytes, readOnly=True)
             writeAtomic(MANIFEST_PATH, dumpManifest(manifest))
+            state = "input-frozen" if manifest["inputReadiness"]["inputFrozen"] else "draft"
             print(
-                f"wrote draft R10 bundle: {manifest['scope']['fileCount']} files, "
+                f"wrote {state} R10 bundle: {manifest['scope']['fileCount']} files, "
                 f"sha256={manifest['archive']['sha256']}"
             )
         else:
             verifyWrittenManifest(manifest)
             print(
                 f"ok: R10 bundle manifest matches {manifest['scope']['fileCount']} files; "
+                f"inputFrozen={str(manifest['inputReadiness']['inputFrozen']).lower()}, "
                 f"sealEligible={str(manifest['roundReadiness']['sealEligible']).lower()}"
             )
     except BundleError as exc:

docs/skills/ops/tools/buildPrdRoundFactAudit.py

@@ -304,6 +304,8 @@ def buildPrdRoundFactAudit() -> dict[str, Any]:
         "auditComplete": True,
         "scoreThresholdApplied": False,
         "productCompletionEligible": False,
+        "inputFreezeEligible": actualManifest["inputReadiness"]["freezeEligible"],
+        "inputFrozen": actualManifest["inputReadiness"]["inputFrozen"],
         "roundSealEligible": actualManifest["roundReadiness"]["sealEligible"],
         "scope": {
             "gitCommit": scope["gitCommit"],
@@ -366,7 +368,7 @@ def main(argv: list[str] | None = None) -> int:
                     "R10 fact audit is stale; run "
                     "uv run --no-sync python -X utf8 docs/skills/ops/tools/buildPrdRoundFactAudit.py --write"
                 )
-            print("ok: R10 fact audit matches the current draft bundle")
+            print("ok: R10 fact audit matches the current evaluation bundle")
     except FactAuditError as exc:
         print(f"FAIL: {exc}", file=sys.stderr)
         return 1