Freeze actual Google music metadata and precise speech timing diagnostics

tools/speech-eval/run.py

@@ -148,10 +148,19 @@ def main():
     parser.add_argument("--ffprobe", type=Path, required=True)
     parser.add_argument("--model", type=Path, required=True)
     parser.add_argument("--candidate", choices=MODELS, required=True)
+    parser.add_argument("--token-sentences", action="store_true", help="Frozen ordinary token-time diagnostic; retains original segments")
     parser.add_argument("--fixture", type=Path, default=Path("fixtures/media/fixture.json"))
     parser.add_argument("--scratch-parent", type=Path, required=True)
     parser.add_argument("--output", type=Path, required=True)
     args = parser.parse_args()
+    if args.output.exists():
+        raise ValueError("Never overwrite experiment evidence")
+    if args.token_sentences and args.candidate != "base":
+        raise ValueError("Frozen token experiment accepts multilingual base only")
+    if args.token_sentences:
+        policy = json.loads(Path(__file__).with_name("token-policy.json").read_text(encoding="utf-8"))
+        if policy["worker_sha256"] != args.whisper_sha256:
+            raise ValueError("Frozen token experiment worker mismatch")
     size, digest = MODELS[args.candidate]
     if args.model.stat().st_size != size or sha256(args.model) != digest:
         raise ValueError("Model size/SHA verification failed")
@@ -200,20 +209,34 @@ def main():
                 else:
                     asr_ms = run_owned([str(args.whisper.resolve()), "--no-gpu", "--threads", "1", "--processors", "1",
                         "--language", "auto", "--model", str(args.model.resolve()), "--file", str(wav),
-                        "--output-json", "--output-file", str(prefix)], scratch, "asr", [(output, MAX_OUTPUT)], 600)
+                        "--output-json-full" if args.token_sentences else "--output-json",
+                        "--output-file", str(prefix)], scratch, "asr", [(output, MAX_OUTPUT)], 600)
                     raw = json.loads(output.read_text(encoding="utf-8"))
                     result["windows"].append(recognized_window(raw, offset, length, decode_ms, asr_ms))
                     result["windows"][-1]["decoded_frames"] = frames
+                    if args.token_sentences:
+                        from token_alignment import aligned_segments
+                        try:
+                            result["windows"][-1]["aligned_segments"] = aligned_segments(raw, offset, length)
+                        except (ValueError, KeyError, TypeError) as error:
+                            result["windows"][-1]["alignment_validation_error"] = str(error)
                 args.output.parent.mkdir(parents=True, exist_ok=True)
                 checkpoint = {"complete": False, "fixture_sha256": sha256(args.fixture),
                               "model_sha256": digest, "worker_sha256": args.whisper_sha256,
                               "rows": [*rows, result]}
+                if args.token_sentences:
+                    checkpoint["alignment_policy"] = policy["policy"]
+                    checkpoint["alignment_policy_sha256"] = sha256(Path(__file__).with_name("token-policy.json"))
                 args.output.write_text(json.dumps(checkpoint, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
             if source.stat().st_size != asset["bytes"] or sha256(source) != asset["sha256"]:
                 raise ValueError("Source changed during recognition")
             rows.append(result)
     failures = [{"asset": row["asset"], "offset_ms": window["offset_ms"], "error": window["validation_error"]}
                 for row in rows for window in row["windows"] if "validation_error" in window]
+    if args.token_sentences:
+        failures.extend({"asset": row["asset"], "offset_ms": window["offset_ms"],
+                         "error": window["alignment_validation_error"]}
+                        for row in rows for window in row["windows"] if "alignment_validation_error" in window)
     report = {"version": 1, "complete": True, "quality_failed": bool(failures), "validation_failures": failures,
               "scope": "Actual ASR diagnostic, not Google retrieval or production integration",
               "fixture_sha256": sha256(args.fixture), "upstream_commit": UPSTREAM,
@@ -223,6 +246,11 @@ def main():
               "harness_sha256": sha256(Path(__file__)),
               "policy": "primary-audio-range-v3;aresample16000-before-atrim;samplecoverage-1ms;nonoverlapping30s;independent-process-per-window;auto-language;segment-times",
               "rows": rows}
+    if args.token_sentences:
+        from token_alignment import POLICY
+        report["alignment_policy"] = POLICY
+        report["alignment_contract_sha256"] = sha256(Path(__file__).with_name("token_alignment.py"))
+        report["alignment_policy_sha256"] = sha256(Path(__file__).with_name("token-policy.json"))
     args.output.parent.mkdir(parents=True, exist_ok=True)
     args.output.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")