Upload FAI-Bench task files batch 54

tasks/kfc/jit-source-arch-cache-key/task/.dockerignore

@@ -0,0 +1,24 @@
+# .dockerignore MUST live at the BUILD CONTEXT ROOT (this directory) — docker/BuildKit does
+# NOT read environment/.dockerignore. Build with:  docker build -f environment/Dockerfile .
+# The reference implementation and every authoring artefact MUST NOT reach an image layer.
+*.patch
+oracle*
+negative*
+baseline2*
+scope_card.json
+degradation_manifest.json
+task_meta.json
+loop_map_entry.json
+job.yaml
+intermediates/
+_retrofit*
+sr_validate*
+leak_audit/
+self_check/
+variants/
+**/__pycache__/
+**/*.pyc
+*.bak
+*.bak_*
+*.pre_*
+**/*.pre_*

tasks/kfc/jit-source-arch-cache-key/task/environment/Dockerfile

@@ -0,0 +1,161 @@
+# syntax=docker/dockerfile:1
+# =============================================================================
+# jit-source-arch-cache-key — OPEN-SOURCE, self-contained task image
+#
+#   Task: make the declared scope faster while preserving its observable behaviour exactly.
+#         Editable scope (the ONLY files the scope gate allows to change):
+##     - /app/repo/identity_key.py
+#
+#   FULLY PUBLIC — no internal mirror, no private base image, no prebuilt image.
+#   CPU ONLY — task.toml declares gpus = 0.
+#   Platform: linux/amd64 or arm64.
+#   Build context = this task directory (the Dockerfile lives in environment/).
+#
+# PROVENANCE of environment/repo/ (so anyone can re-derive it independently)
+#   recovered from: <internal registry>/kernelbench/insea-jit-source-arch-cache-key-loop16:loop-20260721T021500Z@sha256:b6e1405e15730a4d2605a010e43a832c62e79d533833700356bd01e7e77fea6d
+#   method: `crane manifest` -> the layers under 80 MB -> `crane blob` + tar, overlaid in
+#           manifest order; .git and any .wh..wh..opq marker dropped.
+#   verification: `git apply --check -p1 oracle.patch` succeeds against these bytes and `-R` does NOT — i.e. this tree is the exact baseline tree the reference patch was generated against.
+##
+# -----------------------------------------------------------------------------
+# BUILD  (needs outbound network for PyPI only — the working tree ships in this package)
+#     cd <...>/jit-source-arch-cache-key/task
+#     docker build -f environment/Dockerfile -t fai/kfc-jit-source-arch-cache-key:oss .
+#
+# RUN     docker run --rm -it fai/kfc-jit-source-arch-cache-key:oss
+# SCORE   docker run --rm -v "$PWD/tests:/tests:ro" fai/kfc-jit-source-arch-cache-key:oss bash /tests/test.sh
+#         # -> /logs/verifier/reward.json   (modes: candidate | noop | oracle | negative)
+#
+# 🔴 RE-CALIBRATE THE ANCHOR ON YOUR HARDWARE
+#   reward = min(1.0, ln(speedup/ref_speedup)/ln(ref_speedup)) if speedup > ref_speedup else 0.0; ref_speedup = 4.0 .
+#   tests/test.sh resolves it from tests/ref_speedup.txt FIRST, then falls back to
+#   /opt/verifier-correctness-manifest.json, then to 1.0 (which would make every reward 0).
+#   The value was calibrated on the authoring CPU lane (Intel Sapphire Rapids). The verifier supports mode dispatch natively, so
+#   re-measuring is ONE command (the reference patch is passed BY PATH and never baked):
+#     docker run --rm -v "$PWD/tests:/tests:ro" -v "<dir holding oracle.patch>:/patches:ro" \
+#       -e KERNELBENCH_VERIFY_MODE=oracle -e KERNELBENCH_ORACLE_PATCH=/patches/oracle.patch \
+#       fai/kfc-jit-source-arch-cache-key:oss bash /tests/test.sh
+#   then write the measured speedup into tests/ref_speedup.txt. See tests/ref_speedup.caveat.md.
+#   Sanity: noop (no patch) ~= 1.0 -> gated to 0; negative MUST score 0.
+#
+# VERSION ANCHORS
+#     Python 3.11 · standard library
+#   The original private base declared torch 2.5.1 / triton 3.1.0 and the task overlay then ran
+#   `pip install torch==2.7.0` — 2.7.0 is therefore the version the anchor was calibrated under.
+# =============================================================================
+FROM python:3.11-slim-bookworm
+
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC \
+    PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PIP_DISABLE_PIP_VERSION_CHECK=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential git ca-certificates curl procps coreutils tar gzip vim less file jq \
+    && rm -rf /var/lib/apt/lists/*
+
+# ---- venv at this EXACT path: tests/test.sh puts /opt/kernelbench-venv/bin at the head of PATH. ----
+ENV VENV=/opt/kernelbench-venv
+RUN python3 -m venv "$VENV"
+ENV PATH=$VENV/bin:$PATH
+RUN pip install --no-cache-dir -U pip setuptools wheel
+
+# ---- the graded working tree. A REAL directory (not a symlink): the scope gate runs
+#      `git -C /app/repo status --porcelain`, which cannot see through a symlink. ----
+RUN mkdir -p /app/repo /app/.timer /app/workspace /logs/verifier /logs/agent /logs/artifacts
+COPY environment/repo/ /app/repo/
+COPY instruction.md /app/instruction.md
+
+# ---- the baseline commit = the diff base the scope gate compares against.
+#      🔴 core.fileMode=false is LOAD-BEARING, not hygiene: a shipped image in this corpus had
+#      core.fileMode=true while some files were 0775 on disk but 100644 in the index, so
+#      `git status --porcelain` reported phantom out-of-scope paths in EVERY mode and forced
+#      reward to 0. Setting it false at creation makes that class of defect impossible. ----
+RUN git config --global user.email "reviewer@fai-bench.local" \
+ && git config --global user.name "fai-bench" \
+ && git config --global init.defaultBranch main \
+ && git config --global --add safe.directory /app/repo \
+ && cd /app/repo \
+ && git init -q \
+ && git config core.fileMode false \
+ && printf '__pycache__/\n*.pyc\n' >> .gitignore \
+ && git add -A \
+ && git commit -qm "baseline (graded starting point)" \
+ && rm -rf .git/logs \
+ && test "$(git rev-list --count HEAD)" = "1" \
+ && test -z "$(git remote)" \
+ && test "$(git config --get core.fileMode)" = "false" \
+ && test -z "$(git status --porcelain)" \
+ && echo "[build] /app/repo: 1 commit, no remote, fileMode=false, clean tree"
+
+# ---- runtime contract (copied verbatim from the shipped image) ----
+COPY environment/runtime/entrypoint.sh /app/entrypoint.sh
+COPY environment/runtime/timer.sh /app/timer.sh
+RUN chmod 0755 /app/entrypoint.sh /app/timer.sh && chown root:root /app/entrypoint.sh /app/timer.sh
+COPY environment/runtime/run_dev_bench.sh /app/workspace/run_dev_bench.sh
+RUN chmod 0755 /app/workspace/run_dev_bench.sh
+COPY environment/loop/ /opt/loop/
+RUN if [ -f /opt/loop/submit.sh ]; then chmod 0755 /opt/loop/submit.sh; fi \
+ && chown -R root:root /opt/loop \
+ && if [ -f /opt/loop/score_engine.sh ]; then chmod 0700 /opt/loop/score_engine.sh; fi \
+ && if [ -f /opt/loop/sanitize_feedback.py ]; then chmod 0700 /opt/loop/sanitize_feedback.py; fi \
+ && if [ -d /opt/loop/private ]; then chmod -R go-rwx /opt/loop/private; fi
+
+# ---- the FROZEN anchor fallback. tests/test.sh prefers tests/ref_speedup.txt (mounted) and falls
+#      back to THIS path; keeping both consistent makes the resolution explicit. Only the constant. ----
+COPY environment/verifier-correctness-manifest.json /opt/verifier-correctness-manifest.json
+
+# ---- OPEN grading suite is NOT baked: tests/ (test.sh + compute_reward.py + the workload/harness
+#   + ref_speedup.txt) is MOUNTED FRESH at /tests when scoring. It ships in this package —
+#   open-source, but outside the image so the graded harness cannot be edited from the session.
+
+# ---- 🔴 ANTI-LEAK ASSERTS (author-side artifact denylist) ----
+RUN set -eu; rc=0; \
+    hits="$(find / -xdev -type f \( -name 'oracle*.patch' -o -name 'negative*.patch' \
+              -o -name 'baseline2*.patch' -o -name 'scope_card.json' -o -name 'kernel_oracle.py' \
+              -o -name 'degradation_manifest.json' \) 2>/dev/null | head -10)"; \
+    if [ -n "$hits" ]; then echo "BUILD_ASSERT_FAIL: a reference/authoring file is baked:"; echo "$hits"; rc=1; fi; \
+    for p in /opt/verifier /opt/strong_baseline /opt/negative /opt/ceiling /tests; do \
+      if [ -e "$p" ]; then echo "BUILD_ASSERT_FAIL: frozen-surface path baked: $p"; rc=1; fi; \
+    done; \
+    test "$rc" = 0; \
+    echo "[build] ANTI-LEAK ASSERTS PASS"
+
+ENV PYTHONPATH=/app/repo \
+    PYTHONDONTWRITEBYTECODE=1 \
+    OMP_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1 \
+    OPENBLAS_NUM_THREADS=1
+WORKDIR /app/repo
+
+# ---- build-time smoke: the graded module imports FROM /app/repo (the verifier asserts the same
+#      thing at scoring time via its import-origin gate) and the scope files are present. ----
+# ---- frozen naive baseline for the verifier's SPEED DENOMINATOR.
+#      tests/test.sh resolves KB_BASELINE_MODULE=/opt/verifier-baseline/<file>; when that file
+#      is absent the whole benchmark block is SKIPPED and the run hard-fails with
+#      `validation_incomplete` (reward 0) no matter how good the submission is.
+#      It is a pristine copy of the shipped, pre-edit scope file, taken here at build time —
+#      exactly what the original task image baked. `cmp` proves the copy is byte-identical.
+RUN mkdir -p /opt/verifier-baseline \
+ && cp "/app/repo/identity_key.py" "/opt/verifier-baseline/identity_key.py" \
+ && cmp "/app/repo/identity_key.py" "/opt/verifier-baseline/identity_key.py" \
+ && chmod 0444 "/opt/verifier-baseline/identity_key.py" \
+ && echo "frozen baseline(s) baked: $(ls -l /opt/verifier-baseline | tail -n +2 | wc -l) file(s)"
+
+RUN python - <<'PY'
+import os, subprocess, sys
+sys.path.insert(0, "/app/repo")
+for f in ('/app/repo/identity_key.py',):
+    p = os.path.join("/app/repo", f)
+    assert os.path.isfile(p), f"scope file missing: {p}"
+    print("scope file present:", f, os.path.getsize(p), "B")
+for _b in ('identity_key.py',):
+    _p = os.path.join('/opt/verifier-baseline', _b)
+    assert os.path.isfile(_p), f"frozen baseline missing: {_p} (tests/test.sh would skip the benchmark and hard-fail validation_incomplete)"
+    print('frozen baseline:', _p, os.path.getsize(_p), 'B')
+n = subprocess.run(["git","-C","/app/repo","rev-list","--count","HEAD"],
+                   capture_output=True, text=True).stdout.strip()
+assert n == "1", f"git diff base broken (commits={n!r})"
+print("OK: scope files, import origin and git base all in place")
+PY
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+CMD ["tail","-f","/dev/null"]

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/dev_tests/compute_reward.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Canonical kernelbench reward writer (reused verbatim from the ready-task
+template kernel-opt-p0a4-003). Task-agnostic; do NOT special-case a task here.
+
+Dual-mode:
+  - correctness task (verifier_state.task_kind == "correctness"):
+        reward = 1.0 iff all hard gates true and no hard_fail_reasons, else 0.0; no timing.
+  - acceleration task:
+        reward = speedup (raw measured speedup — no cap, no log, no ref anchor)
+        iff all gates pass and speedup is finite and > 0; else 0.0.
+
+Reads:  /logs/loop/dev/verifier_state.json, /logs/loop/dev/benchmark_results.json
+Writes: /logs/loop/dev/reward.json, /logs/loop/dev/reward.txt
+"""
+import json, math
+from pathlib import Path
+
+LOG = Path("/logs/loop/dev")
+STATE = LOG / "verifier_state.json"
+BENCH = LOG / "benchmark_results.json"
+REWARD = LOG / "reward.json"
+TEXT = LOG / "reward.txt"
+
+GATES = [
+    "correctness_ok",
+    "trusted_restore_ok",
+    "hidden_correctness_ok",
+    "baseline_ok",
+    "benchmark_ok",
+    "anti_cheat_ok",
+]
+
+
+def read_json(path, default):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def main():
+    LOG.mkdir(parents=True, exist_ok=True)
+    state = read_json(STATE, {})
+    bench = read_json(BENCH, {})
+    hard = list(state.get("hard_fail_reasons") or [])
+    task_kind = state.get("task_kind") or bench.get("task_kind") or "acceleration"
+    gates_ok = all(bool(state.get(g)) for g in GATES)
+
+    speedup = ref = 1.0
+    reward = 0.0
+    if task_kind == "correctness":
+        reward = 1.0 if (gates_ok and not hard) else 0.0
+        if reward == 0.0 and not hard:
+            hard.append("correctness_or_validation_incomplete")
+    else:
+        try:
+            speedup = float(bench.get("aggregate_speedup") or bench.get("primary_metric_value") or 1.0)
+            ref = float(bench.get("ref_speedup") or bench.get("reference_metric_value") or 1.0)
+        except Exception:
+            speedup = ref = 1.0
+            hard.append("invalid_primary_metric_value")
+        # reward IS the raw measured speedup (no cap, no log, no ref anchor);
+        # ref_speedup is kept as calibration metadata only. reward is 0 only when a
+        # gate fails (correctness/anti-cheat) or the measured speedup is unusable.
+        if gates_ok and not hard and math.isfinite(speedup) and speedup > 0.0:
+            reward = speedup
+        if reward == 0.0 and not hard:
+            hard.append("validation_incomplete_or_bad_speedup")
+
+    out = {
+        "schema_version": "kernelbench_reward_v1",
+        "task_kind": task_kind,
+        "reward": reward,
+        "speedup": speedup,
+        "ref_speedup": ref,
+        "actual_hardware_type": state.get("actual_hardware_type", "") or bench.get("actual_hardware_type", ""),
+        "hard_fail_reasons": hard,
+        "state_path": str(STATE),
+        "benchmark_path": str(BENCH),
+    }
+    REWARD.write_text(json.dumps(out, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    TEXT.write_text(f"{reward}\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/dev_tests/count_bench.py

@@ -0,0 +1,92 @@
+"""Distinct-identity count for the build-spec identity task.
+
+The metric is a deterministic count: over a fixed labeled workload of build-specs,
+how many DISTINCT identities does a module's ``identity_key`` produce? A conservative
+identity treats every incidental spelling as different and emits many identities; a
+normalizing identity collapses the equivalent spellings of each class down toward the
+number of true classes. The score is the ratio baseline_count / candidate_count, so
+fewer identities (for the same workload) is better -- but only while no two
+genuinely-different specs share an identity.
+
+Invoked one MODE per process. ``test.sh`` runs candidate and the frozen baseline and
+takes the ratio. No profiler / no numerics library -- it is a pure count.
+
+Modes:
+  candidate  count distinct identities from /app/repo/identity_key.py; print COUNT=<n>
+  baseline   same, using the frozen baseline module (KB_BASELINE_MODULE)
+  verify     (safety) confirm the candidate NEVER gives two different-class specs
+             the same identity; print VERIFY_OK / VERIFY_FAIL
+"""
+
+import os
+import sys
+
+from kb_identity_harness import (
+    build_labeled_workload,
+    count_distinct_keys,
+    find_false_merges,
+    load_candidate,
+    load_module,
+    true_class_count,
+)
+
+
+def _baseline_module():
+    path = os.environ.get("KB_BASELINE_MODULE", "/opt/verifier-baseline/identity_key.py")
+    return load_module(path)
+
+
+def mode_candidate():
+    workload = build_labeled_workload()
+    print(f"COUNT={count_distinct_keys(load_candidate(), workload)}")
+    return 0
+
+
+def mode_baseline():
+    workload = build_labeled_workload()
+    print(f"COUNT={count_distinct_keys(_baseline_module(), workload)}")
+    return 0
+
+
+def mode_verify():
+    workload = build_labeled_workload()
+    classes = true_class_count(workload)
+    cand = load_candidate()
+    base = _baseline_module()
+
+    cand_bad = find_false_merges(cand, workload)
+    if cand_bad:
+        sample = sorted((sorted(v), k) for k, v in cand_bad.items())[:3]
+        print(f"VERIFY_FAIL candidate false-merges distinct classes: {sample}")
+        return 1
+    # sanity: the frozen baseline must itself be false-merge free.
+    base_bad = find_false_merges(base, workload)
+    if base_bad:
+        print(f"VERIFY_FAIL baseline unexpectedly false-merges: {sorted(base_bad.values())[:3]}")
+        return 1
+
+    cand_count = count_distinct_keys(cand, workload)
+    base_count = count_distinct_keys(base, workload)
+    # work-evidence: the baseline emits (base_count - classes) identities more than
+    # there are true classes; a full normalizer removes those redundant identities.
+    redundant = base_count - classes
+    print(f"VERIFY_OK signatures={len(workload)} true_classes={classes} "
+          f"candidate_identities={cand_count} baseline_identities={base_count} "
+          f"baseline_redundant_identities={redundant}")
+    return 0
+
+
+MODES = {"candidate": mode_candidate, "baseline": mode_baseline, "verify": mode_verify}
+
+
+def main():
+    mode = sys.argv[1] if len(sys.argv) > 1 else "candidate"
+    fn = MODES.get(mode)
+    if fn is None:
+        print(f"unknown mode {mode!r}; expected one of {sorted(MODES)}")
+        sys.exit(2)
+    sys.exit(fn())
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/dev_tests/kb_identity_harness.py

@@ -0,0 +1,185 @@
+"""Shared harness for the build-spec identity task (CPU, pure Python).
+
+Provides: the candidate loader, the equivalence-rule tables (source normalization,
+no-op option tokens), a deterministic *labeled* workload of build-specs grouped into
+true equivalence classes, and helpers that turn a candidate ``identity_key`` into a
+partition of that workload so the verifier can count distinct identities and detect a
+false merge (two genuinely-different specs sharing an identity). Standard library
+only, so the metric -- the number of distinct identities produced over the workload --
+is a deterministic count that is identical on any machine.
+
+The ground truth is the class LABEL attached to every spec when the workload is built:
+two specs share a class iff they were generated as equivalent spellings of the same
+base. candidate / baseline / oracle are all judged against these labels, never against
+each other.
+"""
+
+import hashlib
+import importlib.util
+import os
+import re
+
+
+# --------------------------------------------------------------------------- #
+# Equivalence rules (also disclosed to the solver in instruction.md).
+# --------------------------------------------------------------------------- #
+# Source text: comments and surrounding whitespace do not change the built artifact,
+# so they are incidental. Everything else in the source text is meaningful.
+_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
+_LINE_COMMENT = re.compile(r"//[^\n]*")
+
+# Option tokens equal to a build default; each is equivalent to the token being absent.
+NOOP_OPTIONS = {"o0", "dbgoff", "std0"}
+
+
+def canon_source(text):
+    """Canonical form of a source text: strip comments, collapse whitespace runs."""
+    text = _BLOCK_COMMENT.sub(" ", text)
+    text = _LINE_COMMENT.sub(" ", text)
+    return " ".join(text.split())
+
+
+def canon_options(options):
+    """Canonical option set: drop no-op defaults, de-duplicate, sort (order-free)."""
+    kept = {o for o in (options or []) if o not in NOOP_OPTIONS}
+    return sorted(kept)
+
+
+def _with_line_comment(source):
+    return source + "   // tuned build\n"
+
+
+def _with_block_comment(source):
+    return "/* rev2 */\n" + source + "\n\n  "
+
+
+def repo_dir():
+    return os.environ.get("KB_REPO_DIR", "/app/repo")
+
+
+def load_candidate():
+    """Import the candidate module from the repo under test."""
+    path = os.path.join(repo_dir(), "identity_key.py")
+    spec = importlib.util.spec_from_file_location("candidate_identity_key", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    if not hasattr(mod, "identity_key"):
+        raise AttributeError(f"{path} does not define identity_key")
+    return mod
+
+
+def load_module(path):
+    # deterministic module name derived from the path (no salted builtin hash()).
+    digest = hashlib.sha1(path.encode("utf-8")).hexdigest()[:12]
+    spec = importlib.util.spec_from_file_location("kb_identity_mod_" + digest, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+# --------------------------------------------------------------------------- #
+# Labeled workload: 12 true classes, each emitted as 4 equivalent spellings.
+# Distinct classes differ in at least one meaning-bearing field (source text /
+# target profile / effective option / toolchain tag / requested variant set).
+# classes 0 and 1 differ ONLY in target profile -- a normalizer that drops the target
+# merges them, which is a false merge (a wrong-target artifact would be reused).
+# --------------------------------------------------------------------------- #
+SRC_A = "o[i] = a[i] * b[i];"
+SRC_B = "o[i] = a[i] + b[i];"
+SRC_C = "o[i] = a[i] - b[i];"
+SRC_D = "acc = acc + a[k] * b[k];"
+SRC_E = "o[i] = a[i] > 0 ? a[i] : 0;"
+SRC_F = "o[i] = a[i] / b[i];"
+
+# base = (source, target, effective_options, toolchain, variants)
+CLASS_BASES = [
+    (SRC_A, "p80", (),             "v1", ()),           # 0  (target-trap A)
+    (SRC_A, "p90", (),             "v1", ()),           # 1  (target-trap B: only target differs from 0)
+    (SRC_B, "p80", (),             "v1", ()),           # 2  distinct source
+    (SRC_C, "p80", (),             "v1", ()),           # 3
+    (SRC_C, "p80", ("fast",),      "v1", ()),           # 4  effective option vs 3
+    (SRC_D, "p80", ("o3",),        "v1", ()),           # 5
+    (SRC_D, "p80", ("o2",),        "v1", ()),           # 6  different effective option value vs 5
+    (SRC_D, "p80", ("o3",),        "v2", ()),           # 7  different toolchain tag vs 5
+    (SRC_E, "p80", (),             "v1", ()),           # 8
+    (SRC_E, "p80", (),             "v1", ("kA",)),       # 9  variant present vs 8
+    (SRC_E, "p80", (),             "v1", ("kB", "kC")),  # 10 different variant set vs 9
+    (SRC_F, "p86", ("fast", "o3"), "v1", ()),           # 11 third target + two options
+]
+
+
+def _spellings(base):
+    """Return four equivalent-but-differently-spelled specs for one class.
+
+    All four normalize to the same spec (they differ only in source comments/whitespace,
+    option order, redundant no-op options, incidental build annotations, and requested
+    variant order), yet all four are byte-distinct so a conservative identity produces
+    four identities.
+    """
+    source, target, options, toolchain, variants = base
+    opts = list(options)
+    vs = list(variants)
+
+    def build_spec(src, opt_list, build=None, var_list=None):
+        d = {"source": src, "target": target, "options": list(opt_list), "toolchain": toolchain}
+        if var_list:
+            d["variants"] = list(var_list)
+        if build is not None:
+            d["build"] = build
+        return d
+
+    # S0: canonical source, options sorted, variants sorted, no build annotations.
+    s0 = build_spec(source, sorted(opts), var_list=sorted(vs))
+    # S1: source carries a trailing line comment + reflowed spacing (ignored).
+    s1 = build_spec(_with_line_comment(source), sorted(opts), var_list=sorted(vs))
+    # S2: options in a different ORDER + a redundant no-op token; a non-semantic build
+    #     annotation block; requested variants in a different order.
+    s2 = build_spec(source, list(reversed(opts)) + ["o0"],
+                    build={"tmpdir": "/tmp/b_" + target, "ts": 1700000000},
+                    var_list=list(reversed(vs)))
+    # S3: source with a block comment + extra newlines; options reversed with a DUPLICATE
+    #     of the first option (when present) + a different no-op token; a different build.
+    dup = [opts[0]] if opts else []
+    s3 = build_spec(_with_block_comment(source), list(reversed(opts)) + dup + ["dbgoff"],
+                    build={"tmpdir": "/tmp/x", "ts": 1700000001, "host": "node7"},
+                    var_list=list(reversed(vs)))
+    return [s0, s1, s2, s3]
+
+
+def build_labeled_workload():
+    """Deterministic list of ``(class_id, spec)`` pairs (48 = 12 classes x 4)."""
+    workload = []
+    for class_id, base in enumerate(CLASS_BASES):
+        for spec in _spellings(base):
+            workload.append((class_id, spec))
+    return workload
+
+
+def true_class_count(workload):
+    return len({class_id for class_id, _ in workload})
+
+
+# --------------------------------------------------------------------------- #
+# Turn a candidate identity function into a partition of the workload.
+# --------------------------------------------------------------------------- #
+def key_to_classes(module, workload):
+    """Map each produced identity -> the set of true class ids that landed on it."""
+    mapping = {}
+    for class_id, spec in workload:
+        key = module.identity_key(spec)
+        mapping.setdefault(key, set()).add(class_id)
+    return mapping
+
+
+def find_false_merges(module, workload):
+    """Return {identity: {class_ids}} for identities shared by >1 true class.
+
+    A non-empty result is a correctness failure: two genuinely different specs were
+    given the same identity.
+    """
+    return {k: v for k, v in key_to_classes(module, workload).items() if len(v) > 1}
+
+
+def count_distinct_keys(module, workload):
+    """Number of distinct identities the candidate produces over the workload."""
+    return len({module.identity_key(spec) for _, spec in workload})

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/dev_tests/ref_speedup.txt

@@ -0,0 +1 @@
+4.0

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/dev_tests/test.sh

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+# Verifier for jit-source-arch-cache-key (stable identity for a build-spec).
+# Pattern A, ACCELERATION lane. Deterministic value axis = recompile_count = number of
+# DISTINCT identities produced over a fixed labeled workload of build-specs. speedup =
+# baseline_recompiles / candidate_recompiles (= baseline_distinct_identities /
+# candidate_distinct_identities). Pure-Python stdlib -> a plain count, no profiler
+# needed. A false merge (two different-class specs sharing an identity -- e.g. two specs
+# differing only in target profile) is a hard correctness failure -> reward 0.
+# Modes: candidate|noop|oracle|negative
+set -uo pipefail
+# The harness may exec this in a NON-login shell; pin PATH so python3
+# resolves regardless of the base's default profile.
+export PATH=/opt/kernelbench-venv/bin:/usr/local/bin:/usr/bin:/bin:$PATH
+TESTS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO=/app/repo
+LOG=/logs/loop/dev
+mkdir -p "$LOG"
+MODE="${KERNELBENCH_VERIFY_MODE:-candidate}"
+CAND_FILE="$REPO/identity_key.py"
+export KB_CANDIDATE_MODULE="$CAND_FILE"
+export KB_BASELINE_MODULE=/opt/verifier-baseline/identity_key.py
+
+HARD=(); add_hard(){ HARD+=("$1"); }
+correctness_ok=true; trusted_restore_ok=true; hidden_correctness_ok=true
+baseline_ok=true; benchmark_ok=true; anti_cheat_ok=true
+expected_cases=12; actual_cases=0
+speedup=1.0; ref_speedup=1.0; hw="cpu"; cand_keys=0; base_keys=0
+
+cd "$REPO" 2>/dev/null || { add_hard "repo_missing"; correctness_ok=false; }
+
+if [ "$MODE" = "oracle" ] && [ -n "${KERNELBENCH_ORACLE_PATCH:-}" ]; then
+  # reviewer-only mode: reset the working tree to the frozen baseline so several
+  # modes running back-to-back in one container session each start clean. candidate/noop
+  # NEVER resets (this branch is skipped for them), so a solver session is untouched.
+  git -C "$REPO" checkout -- . 2>/dev/null || true; git -C "$REPO" clean -fdq 2>/dev/null || true
+  git -C "$REPO" apply "$KERNELBENCH_ORACLE_PATCH" 2>"$LOG/oracle_apply.log" || add_hard "oracle_apply_failed"
+fi
+if [ "$MODE" = "negative" ] && [ -n "${KERNELBENCH_NEGATIVE_PATCH:-}" ]; then
+  git -C "$REPO" checkout -- . 2>/dev/null || true; git -C "$REPO" clean -fdq 2>/dev/null || true
+  git -C "$REPO" apply "$KERNELBENCH_NEGATIVE_PATCH" 2>"$LOG/negative_apply.log" || true
+fi
+
+# anti-cheat: only identity_key.py may change
+git -C "$REPO" status --porcelain 2>/dev/null | awk '{print $2}' > "$LOG/anti_cheat_changed_files.txt"
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  case "$f" in
+    identity_key.py) : ;;
+    *__pycache__*) : ;;
+    *) anti_cheat_ok=false; add_hard "forbidden_edit_path:$f" ;;
+  esac
+done < "$LOG/anti_cheat_changed_files.txt"
+
+# anti-cheat: the normalization must be implemented in plain Python. Forbid pulling
+# in a tensor/graph framework or reading the hidden workload/reference harness.
+if [ -f "$CAND_FILE" ] && grep -Eq "cupy|jax|jaxlib|torch|triton|tensorflow|kb_identity_harness|test_identity_key|import[[:space:]]+tests|from[[:space:]]+tests" "$CAND_FILE"; then
+  anti_cheat_ok=false; add_hard "forbidden_framework_or_harness_reference"
+fi
+
+# trusted restore: hidden suite ships in tests/ payload (fresh at scoring)
+for f in test_identity_key.py count_bench.py kb_identity_harness.py; do
+  [ -f "$TESTS_DIR/$f" ] || { trusted_restore_ok=false; add_hard "hidden_supplement_missing:$f"; }
+done
+
+# ref_speedup: prefer the tests/-local override (uploaded fresh -> recalibrate without rebuild)
+if [ -f "$TESTS_DIR/ref_speedup.txt" ]; then
+  ref_speedup=$(tr -dc '0-9.' < "$TESTS_DIR/ref_speedup.txt")
+elif [ -f /opt/verifier-correctness-manifest.json ]; then
+  ref_speedup=$(python3 -c "import json;print(json.load(open('/opt/verifier-correctness-manifest.json')).get('ref_speedup',1.0))" 2>/dev/null || echo 1.0)
+fi
+hw="cpu:$(uname -m 2>/dev/null || echo unknown)"
+
+# correctness gate (pure python; no GPU): stable string + no false merge properties.
+if [ "$correctness_ok" = true ]; then
+  ( cd "$TESTS_DIR" && python3 test_identity_key.py ) > "$LOG/correctness.log" 2>&1
+  crc=$?
+  actual_cases=$(grep -cE '^CASE_PASS ' "$LOG/correctness.log" 2>/dev/null); actual_cases=${actual_cases:-0}
+  if [ "$crc" -ne 0 ] || [ "$actual_cases" -lt "$expected_cases" ]; then
+    hidden_correctness_ok=false; correctness_ok=false; add_hard "hidden_correctness_failed"
+  fi
+fi
+
+# benchmark: (1) confirm the candidate never gives two different-class signatures the
+# same identity (safety), then (2) count distinct identities for candidate vs the
+# frozen baseline over the fixed workload; speedup = base_keys / cand_keys.
+parse_count(){ sed -n 's/^COUNT=//p' "$1" 2>/dev/null | head -1; }
+if [ "$correctness_ok" = true ] && [ -f "$KB_BASELINE_MODULE" ]; then
+  ( cd "$TESTS_DIR" && python3 count_bench.py verify ) > "$LOG/verify.log" 2>&1
+  if [ $? -ne 0 ] || ! grep -q '^VERIFY_OK' "$LOG/verify.log"; then
+    benchmark_ok=false; add_hard "candidate_false_merge"
+  fi
+  if [ "$benchmark_ok" = true ]; then
+    ( cd "$TESTS_DIR" && python3 count_bench.py candidate ) > "$LOG/cand.out.log" 2>&1
+    ( cd "$TESTS_DIR" && python3 count_bench.py baseline ) > "$LOG/base.out.log" 2>&1
+    cand_keys=$(parse_count "$LOG/cand.out.log"); cand_keys=${cand_keys:-0}
+    base_keys=$(parse_count "$LOG/base.out.log"); base_keys=${base_keys:-0}
+    if [ -z "$cand_keys" ] || [ "$cand_keys" -le 0 ] 2>/dev/null || [ -z "$base_keys" ] || [ "$base_keys" -le 0 ] 2>/dev/null; then
+      benchmark_ok=false; add_hard "distinct_identity_count_unparsed"
+    else
+      speedup=$(python3 -c "print(f'{$base_keys/$cand_keys:.5f}')")
+    fi
+  fi
+else
+  benchmark_ok=false
+fi
+
+HARD_JSON="[]"; if [ ${#HARD[@]} -gt 0 ]; then HARD_JSON=$(printf '"%s",' "${HARD[@]}"); HARD_JSON="[${HARD_JSON%,}]"; fi
+DIAG_TAIL=""
+if [ "$correctness_ok" = false ] && [ -f "$LOG/correctness.log" ]; then
+  DIAG_TAIL=$(tail -60 "$LOG/correctness.log" | sed 's/"/\\"/g' | tr '\n' '\t' | sed 's/\t/\\n/g')
+fi
+cat > "$LOG/verifier_state.json" <<JSON
+{"schema_version":"kernelbench_verifier_state_v1","task_kind":"acceleration",
+ "correctness_ok":$correctness_ok,"trusted_restore_ok":$trusted_restore_ok,
+ "hidden_correctness_ok":$hidden_correctness_ok,"baseline_ok":$baseline_ok,
+ "benchmark_ok":$benchmark_ok,"anti_cheat_ok":$anti_cheat_ok,
+ "hard_fail_reasons":$HARD_JSON,
+ "expected_case_count":$expected_cases,"actual_case_count":$actual_cases,
+ "expected_benchmark_count":1,"actual_benchmark_count":1,
+ "actual_hardware_type":"$hw","mode":"$MODE",
+ "work_evidence_notes":["identity suite $actual_cases/$expected_cases ok","distinct identities candidate=$cand_keys baseline=$base_keys speedup=$speedup","correctness_tail:${DIAG_TAIL}"]}
+JSON
+cat > "$LOG/correctness_results.json" <<JSON
+{"schema_version":"kernelbench_correctness_results_v1",
+ "suites":[{"name":"hidden-identity-suite","visibility_class":"hidden_supplement","expected_case_count":$expected_cases,"actual_case_count":$actual_cases,"passed":$actual_cases,"failed":$((expected_cases-actual_cases)),"hard_fail_reasons":$HARD_JSON}],
+ "correctness_ok":$correctness_ok,"trusted_restore_ok":$trusted_restore_ok,"hidden_correctness_ok":$hidden_correctness_ok}
+JSON
+cat > "$LOG/benchmark_results.json" <<JSON
+{"schema_version":"kernelbench_benchmark_results_v1","task_kind":"acceleration","metric":"recompile_count",
+ "direction":"higher_is_better",
+ "workloads":[{"name":"buildspec-identity-count","speedup":$speedup,"candidate_recompiles":$cand_keys,"baseline_recompiles":$base_keys,"completion_counters":{"cases":"$actual_cases/$expected_cases"}}],
+ "aggregate_speedup":$speedup,"ref_speedup":$ref_speedup,"actual_hardware_type":"$hw"}
+JSON
+python3 "$TESTS_DIR/compute_reward.py" 2>/dev/null || python3 /tests/compute_reward.py 2>/dev/null || true
+REW=$(tr -d '[:space:]' < "$LOG/reward.txt" 2>/dev/null)
+echo "MODE=$MODE cases=$actual_cases/$expected_cases cand_recompiles=$cand_keys base_recompiles=$base_keys speedup=$speedup ref=$ref_speedup hw=$hw reward=$REW"
+[ -n "$REW" ] && exit 0 || exit 1

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/dev_tests/test_identity_key.py

@@ -0,0 +1,184 @@
+"""Correctness suite for the build-spec identity contract.
+
+Each case prints "CASE_PASS <name>" or "CASE_FAIL <name>: <reason>". The runner counts
+CASE_PASS lines. Pure standard library.
+
+Every case tests a *safety* / determinism property that any acceptable identity must
+satisfy: it returns a stable string, and it NEVER gives two genuinely-different specs
+the same identity. (Collapsing equivalent spellings is rewarded by the distinct-identity
+count, not gated here -- the conservative baseline, which collapses nothing, is still
+correct.)
+"""
+
+import sys
+import traceback
+
+from kb_identity_harness import (
+    build_labeled_workload,
+    find_false_merges,
+    load_candidate,
+)
+
+CASES = []
+
+
+def case(fn):
+    CASES.append(fn)
+    return fn
+
+
+def spec(source, target, options=None, toolchain="v1", variants=None, build=None):
+    d = {"source": source, "target": target, "toolchain": toolchain}
+    if options is not None:
+        d["options"] = list(options)
+    if variants is not None:
+        d["variants"] = list(variants)
+    if build is not None:
+        d["build"] = dict(build)
+    return d
+
+
+def _key(mod, s):
+    k = mod.identity_key(s)
+    if not isinstance(k, str) or not k:
+        raise AssertionError(f"identity_key must return a non-empty str, got {k!r}")
+    return k
+
+
+@case
+def returns_string_for_various(mod):
+    samples = [
+        spec("o[i]=a[i]*b[i];", "p80"),
+        spec("o[i]=a[i]+b[i];", "p90", options=["fast"], variants=["kA"]),
+        spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v2", build={"tmpdir": "/tmp/x"}),
+        {"source": "x=y;", "target": "p80"},  # minimal spec (no options/toolchain/variants/build)
+    ]
+    for s in samples:
+        _key(mod, s)
+
+
+@case
+def deterministic_repeat_same_object(mod):
+    s = spec("o[i]=a[i]*b[i];", "p80", options=["o3"])
+    if _key(mod, s) != _key(mod, s):
+        raise AssertionError("identity not stable across repeated calls on the same object")
+
+
+@case
+def deterministic_fresh_build(mod):
+    a = spec("acc+=a[k]*b[k];", "p80", options=["o3"], variants=["kA"])
+    b = spec("acc+=a[k]*b[k];", "p80", options=["o3"], variants=["kA"])
+    if _key(mod, a) != _key(mod, b):
+        raise AssertionError("two independently built identical specs got different identities")
+
+
+@case
+def distinct_source_distinct_keys(mod):
+    a = spec("o[i]=a[i]*b[i];", "p80")
+    b = spec("o[i]=a[i]+b[i];", "p80")
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("different source text collided")
+
+
+@case
+def distinct_target_distinct_keys(mod):
+    # same source + options + toolchain, different target profile -> a different artifact.
+    a = spec("o[i]=a[i]*b[i];", "p80", options=["o3"])
+    b = spec("o[i]=a[i]*b[i];", "p90", options=["o3"])
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("specs for different target profiles collided (target dropped?)")
+
+
+@case
+def distinct_effective_option_distinct_keys(mod):
+    a = spec("o[i]=a[i]*b[i];", "p80", options=["fast"])
+    b = spec("o[i]=a[i]*b[i];", "p80", options=[])
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("an effective (non-default) option was ignored")
+
+
+@case
+def distinct_option_value_distinct_keys(mod):
+    a = spec("acc+=a[k]*b[k];", "p80", options=["o3"])
+    b = spec("acc+=a[k]*b[k];", "p80", options=["o2"])
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("two different option values were merged")
+
+
+@case
+def distinct_toolchain_distinct_keys(mod):
+    a = spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v1")
+    b = spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v2")
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("different toolchain tags were merged (a stale artifact would be reused)")
+
+
+@case
+def distinct_variant_set_distinct_keys(mod):
+    a = spec("o[i]=a[i]>0?a[i]:0;", "p80")                       # no variants
+    b = spec("o[i]=a[i]>0?a[i]:0;", "p80", variants=["kA"])      # one variant
+    c = spec("o[i]=a[i]>0?a[i]:0;", "p80", variants=["kB", "kC"])  # a different variant set
+    keys = {_key(mod, a), _key(mod, b), _key(mod, c)}
+    if len(keys) != 3:
+        raise AssertionError("the requested variant set was ignored")
+
+
+@case
+def no_false_merge_full_workload(mod):
+    workload = build_labeled_workload()
+    bad = find_false_merges(mod, workload)
+    if bad:
+        sample = sorted((sorted(v), k) for k, v in bad.items())[:3]
+        raise AssertionError(f"identity shared by >1 true class (false merge): {sample}")
+
+
+@case
+def handles_edge_schema(mod):
+    empty_opts = spec("x=y;", "p80", options=[])           # explicit empty option set
+    no_opts = {"source": "x=y;", "target": "p80"}          # no options/toolchain/variants keys
+    with_build = spec("x=y;", "p80", build={"ts": 1})      # only an incidental build annotation
+    for s in (empty_opts, no_opts, with_build):
+        _key(mod, s)
+    # even at the degenerate schema, two specs for different targets must stay distinct.
+    other_target = {"source": "x=y;", "target": "p90"}
+    if _key(mod, no_opts) == _key(mod, other_target):
+        raise AssertionError("degenerate specs for different targets collided")
+
+
+@case
+def many_distinct_specs_pairwise_distinct(mod):
+    specs = [
+        spec("o[i]=a[i]*b[i];", "p80"),
+        spec("o[i]=a[i]+b[i];", "p80"),
+        spec("o[i]=a[i]*b[i];", "p90"),                             # target differs from #0
+        spec("acc+=a[k]*b[k];", "p80", options=["o3"]),
+        spec("acc+=a[k]*b[k];", "p80", options=["o2"]),             # option value differs
+        spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v2"),  # toolchain differs
+        spec("o[i]=a[i]/b[i];", "p86", options=["fast", "o3"]),
+        spec("o[i]=a[i]>0?a[i]:0;", "p80", variants=["kA"]),
+    ]
+    keys = [_key(mod, s) for s in specs]
+    if len(set(keys)) != len(specs):
+        raise AssertionError(f"expected {len(specs)} distinct identities, got {len(set(keys))}")
+
+
+def main():
+    mod = load_candidate()
+    passed = 0
+    for fn_case in CASES:
+        name = fn_case.__name__
+        try:
+            fn_case(mod)
+            passed += 1
+            print(f"CASE_PASS {name}")
+        except Exception as exc:  # noqa: BLE001
+            reason = f"{type(exc).__name__}: {exc}"
+            print(f"CASE_FAIL {name}: {reason.splitlines()[0][:300]}")
+            traceback.print_exc(file=sys.stderr)
+    total = len(CASES)
+    print(f"CASES_PASSED={passed}/{total}")
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/private/manifest.json

@@ -0,0 +1,11 @@
+{
+  "base_task_id": "jit-source-arch-cache-key",
+  "dev_engine": "private/dev_tests/test.sh (= the task verifier VERBATIM, output redirected to /logs/loop/dev, candidate mode)",
+  "max_submissions": 1,
+  "min_submissions": 1,
+  "note": "root-only (0700). ref_speedup is a protected secret; the sanitizer never emits it.",
+  "ref_speedup": 4.0,
+  "reward_formula": "acceleration: reward = speedup (raw measured ratio, uncapped; 0 if a gate fails). Matches the base compute_reward.py verbatim.",
+  "schema_version": "kernelbench_loop_manifest_v1",
+  "task_id": "jit-source-arch-cache-key"
+}

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/sanitize_feedback.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Sanitized feedback emitter (0700 root-owned) for jit-source-arch-cache-key.
+
+Invoked ONLY by /opt/loop/submit.sh. Reads the DEV engine products under
+/logs/loop/dev/ and the loop accounting under /logs/loop/, and prints ONLY a
+leak-free summary.
+
+Emits (nothing else, ever):
+  submission k/16
+  correctness: PASS | FAIL
+  [FAIL only] failing_invariant: <name from a fixed allow-list>
+  [FAIL only] diagnostic: <short, actionable, leak-free>
+  dev_speedup: <x>            (relative performance ratio vs the reference baseline; higher is better)
+  dev_reward: <r>             (= dev_speedup when correct, else 0; an in-session PROXY)
+  best_so_far: submission <j>, dev_speedup <x>, dev_reward <r>
+  remaining: <16 - k>
+  finalize_allowed: <true|false>
+  [harness path] harness_error: <message>  (candidate not at fault; budget not consumed)
+
+NEVER emits: verifier / test.sh / compute_reward contents; hidden workload
+names / seeds / counts / shapes; any threshold; ref_speedup; absolute timings or
+byte counts; actual_hardware_type.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+LOOP = Path("/logs/loop")
+DEV = LOOP / "dev"
+MIN_SUBMISSIONS = 3
+MAX_SUBMISSIONS = 16
+
+SIGNATURE = 'identity_key(spec: dict) -> str returning a stable identity string for a build-spec; do NOT change the public signature'
+PRIMITIVE_HINT = 'compute the identity from the spec content yourself with the Python standard library only; do not import a tensor / graph / array framework (torch / jax / jaxlib / cupy / tensorflow / triton) and do not read or import the test harness or its workload; do not reference those tokens even in comments (the scan is textual)'
+
+
+def _read_json(path: Path, default):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def _fmt(x, nd=4):
+    try:
+        return f"{float(x):.{nd}g}"
+    except Exception:
+        return str(x)
+
+
+def _named_invariant(state: dict):
+    hard = [str(r) for r in (state.get("hard_fail_reasons") or [])]
+
+    def has(*subs):
+        return any(any(s in h for s in subs) for h in hard)
+
+    if has("forbidden_edit_path", "forbidden_source"):
+        return ("edit_scope",
+                "only the single product file may change and it must not reference any "
+                "scoring / verifier path — keep your edits to the product implementation only")
+    if has("_primitive", "_operator"):
+        return ("allowed_ops", PRIMITIVE_HINT)
+    if has("product_file_missing", "candidate_load_failed", "repo_missing"):
+        return ("product_present_and_importable",
+                f"the product could not be found or imported — keep the public {SIGNATURE} intact")
+    if has("hidden_correctness_failed"):
+        return ("output_matches_reference",
+                "your output disagreed with the reference on at least one case (numeric tolerance, "
+                "dtype / shape / device, an error-contract probe that must raise, or a metamorphic "
+                f"invariant) — verify the contract of {SIGNATURE}")
+    if has("benchmark_execution_failed"):
+        return ("runs_without_error",
+                "the measurement could not complete — your implementation likely raised, produced "
+                "non-finite values, or disagreed with the baseline while being measured")
+    return ("verifier_completed",
+            "the check did not complete cleanly — re-check that your last change did not cause an early crash")
+
+
+def main() -> int:
+    try:
+        k = int((LOOP / "count").read_text(encoding="utf-8").strip())
+    except Exception:
+        k = 0
+
+    he = DEV / "harness_error.txt"
+    if he.exists():
+        try:
+            msg = he.read_text(encoding="utf-8").strip().splitlines()[0]
+        except Exception:
+            msg = "dev engine infrastructure error"
+        print(f"submission {k}/{MAX_SUBMISSIONS}")
+        print(f"harness_error: {msg} — this is NOT a defect in your code; do not debug the "
+              f"harness. Retry or continue optimizing (this attempt was not counted).")
+        return 0
+
+    state = _read_json(DEV / "verifier_state.json", {})
+    bench = _read_json(DEV / "benchmark_results.json", {})
+    reward = _read_json(DEV / "reward.json", {})
+
+    corr_ok = bool(state.get("correctness_ok"))
+    speedup = bench.get("aggregate_speedup", None)
+    r = reward.get("reward", 0.0)
+
+    print(f"submission {k}/{MAX_SUBMISSIONS}")
+    if corr_ok:
+        print("correctness: PASS")
+    else:
+        print("correctness: FAIL")
+        inv, hint = _named_invariant(state)
+        print(f"failing_invariant: {inv}")
+        print(f"diagnostic: {hint}")
+
+    print(f"dev_speedup: {_fmt(speedup) if speedup is not None else 'n/a'}")
+    print(f"dev_reward: {_fmt(r)}")
+
+    best = _read_json(LOOP / "best.json", None)
+    if best and isinstance(best, dict) and best.get("submission"):
+        print(f"best_so_far: submission {best.get('submission')}, "
+              f"dev_speedup {_fmt(best.get('speedup'))}, dev_reward {_fmt(best.get('reward'))}")
+    else:
+        print("best_so_far: (none — no correctness-passing submission yet)")
+
+    print(f"remaining: {max(0, MAX_SUBMISSIONS - k)}")
+    print(f"finalize_allowed: {'true' if k >= MIN_SUBMISSIONS else 'false'}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/score_engine.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# DEV scoring engine (0700 root:root) for jit-source-arch-cache-key. Invoked ONLY by
+# /opt/loop/submit.sh — never by the solver.
+#
+# It reuses the task verifier VERBATIM: it runs the baked copy of the base
+# task's tests/test.sh (byte-identical except its output dir is /logs/loop/dev
+# instead of /logs/verifier) against the LIVE /app/repo in the default candidate
+# mode (which scores /app/repo AS-IS and never clobbers it). The base
+# compute_reward.py writes reward = speedup (uncapped). The authoritative reward
+# still comes from the runner's end-of-session /tests/ run, NOT from here.
+#
+# PATH-pin: the agent shell + runner verifier exec are
+# NON-login; bare python3 has no torch. Pin the venv FIRST.
+export PATH=/opt/kernelbench-venv/bin:/root/.cargo/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DEV_OUT="${LOOP_DEV_OUT:-/logs/loop/dev}"
+mkdir -p "$DEV_OUT"
+# fresh run: clear any stale harness marker
+rm -f "$DEV_OUT/harness_error.txt" 2>/dev/null || true
+
+# Run the baked task verifier (candidate mode). Suppress its stdout entirely
+# (the base test.sh echoes a summary line carrying ref_speedup / hardware / raw
+# speedup — that MUST NOT reach the solver; only sanitize_feedback.py emits).
+KERNELBENCH_VERIFY_MODE=candidate bash "$HERE/private/dev_tests/test.sh" \
+  > "$DEV_OUT/dev_engine_stdout.log" 2>&1
+rc=$?
+
+# If the base verifier could not even write a reward (infra/torch/cuda failure),
+# it exits non-zero WITHOUT a reward.json. Synthesize a harness marker so
+# submit.sh treats it as infra (does not consume the solver's budget) rather than
+# a silent candidate FAIL.
+if [ "$rc" -ne 0 ] && [ ! -f "$DEV_OUT/reward.json" ] && [ ! -f "$DEV_OUT/harness_error.txt" ]; then
+  {
+    echo "dev_engine_exit_${rc}"
+    tail -n 40 "$DEV_OUT/dev_engine_stdout.log" 2>/dev/null
+  } > "$DEV_OUT/harness_error.txt"
+  exit 3
+fi
+exit 0

tasks/kfc/jit-source-arch-cache-key/task/environment/loop/submit.sh

@@ -0,0 +1,232 @@
+#!/usr/bin/env bash
+# Per-task 3-to-16-submission loop harness for
+# jit-source-arch-cache-key.
+#
+# The solver's ONLY sanctioned interface to scoring during the session
+# (0755 root:root; the engine + private assets it calls are 0700 root-owned).
+# Baked at /opt/loop/submit.sh so it is present from the first turn — unlike
+# /tests/, which the runner creates only AFTER the agent finishes.
+#
+# Usage:
+#   bash /opt/loop/submit.sh                      # score current /app/repo, get feedback
+#   bash /opt/loop/submit.sh --finalize [--reason "..."]   # plant best iterate, end loop
+#
+# Each `submit`:
+#   1. runs the baked DEV engine (visible-subset correctness + dev timing) on
+#      the LIVE /app/repo and returns SANITIZED feedback;
+#   2. snapshots the candidate tree (git stash-create tree hash + binary diff)
+#      to /logs/loop/submissions/<k>/;
+#   3. updates /logs/loop/best.json (best correctness-passing dev_reward);
+#   4. enforces min=3 / max=16.
+# On --finalize (>=3) or auto at k=16 it restores /app/repo's WORKING TREE to
+# the best correctness-passing snapshot (HEAD stays at the baseline commit so
+# the runner's end-of-session verifier still sees a product-only modification)
+# and writes /logs/loop/finalize.json for the audit.
+#
+# 🔴 PATH-pin: the agent shell + runner verifier exec are
+# NON-login; bare python3 has no torch. Pin the venv FIRST.
+export PATH=/opt/kernelbench-venv/bin:/root/.cargo/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO=/app/repo
+LOOP=/logs/loop
+DEV="$LOOP/dev"
+mkdir -p "$LOOP" "$LOOP/submissions" "$DEV"
+
+MIN_SUBMISSIONS=1
+MAX_SUBMISSIONS=1
+COUNT_FILE="$LOOP/count"
+BEST_FILE="$LOOP/best.json"
+STATE_JSONL="$LOOP/state.jsonl"
+FINALIZE_JSON="$LOOP/finalize.json"
+
+_read_count() {
+  if [ -f "$COUNT_FILE" ]; then
+    awk 'NR==1{gsub(/[^0-9]/,""); if($0=="")$0="0"; print; exit}' "$COUNT_FILE"
+  else
+    echo 0
+  fi
+}
+
+# Non-mutating snapshot of the current working tree -> a git tree hash.
+# `git stash create` builds dangling objects without touching HEAD/index/WT.
+_snapshot_tree() {
+  local c
+  c="$(git -C "$REPO" stash create 2>/dev/null || true)"
+  if [ -n "$c" ]; then
+    git -C "$REPO" rev-parse "$c^{tree}" 2>/dev/null || git -C "$REPO" rev-parse "HEAD^{tree}" 2>/dev/null
+  else
+    git -C "$REPO" rev-parse "HEAD^{tree}" 2>/dev/null
+  fi
+}
+
+# ------------------- argument parsing -------------------
+MODE=submit
+REASON=""
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --finalize) MODE=finalize; shift ;;
+    --reason) REASON="${2:-}"; shift 2 ;;
+    --reason=*) REASON="${1#--reason=}"; shift ;;
+    *) echo "usage: bash /opt/loop/submit.sh [--finalize [--reason \"<text>\"]]" >&2; exit 2 ;;
+  esac
+done
+
+# ------------------- finalize -------------------
+if [ "$MODE" = finalize ]; then
+  CUR="$(_read_count)"; CUR="${CUR:-0}"
+  if [ "$CUR" -lt "$MIN_SUBMISSIONS" ]; then
+    echo "minimum $MIN_SUBMISSIONS submission(s) required before finalize (you have $CUR/$MIN_SUBMISSIONS)"
+    exit 1
+  fi
+  # Restore /app/repo working tree to the best correctness-passing snapshot.
+  git -C "$REPO" reset -q --hard HEAD 2>/dev/null || true
+  git -C "$REPO" clean -qfd 2>/dev/null || true
+  WIN_DIFF=""
+  WIN_SUB=""
+  if [ -f "$BEST_FILE" ]; then
+    WIN_SUB="$(python3 -c 'import json,sys;print(json.load(open(sys.argv[1])).get("submission",""))' "$BEST_FILE" 2>/dev/null || true)"
+  fi
+  if [ -n "$WIN_SUB" ] && [ -f "$LOOP/submissions/$WIN_SUB/candidate.diff" ]; then
+    WIN_DIFF="$LOOP/submissions/$WIN_SUB/candidate.diff"
+    if [ -s "$WIN_DIFF" ]; then
+      git -C "$REPO" apply --whitespace=nowarn "$WIN_DIFF" 2>"$LOOP/finalize_apply.log" || \
+        echo "WARNING: could not re-apply the winning diff cleanly; see /logs/loop/finalize_apply.log" >&2
+    fi
+  fi
+  # Write finalize.json (winning index, k, dev_speedup trajectory, reason) for audit.
+  REASON="$REASON" WIN_SUB="$WIN_SUB" CUR="$CUR" python3 - <<'PY'
+import json, os
+from pathlib import Path
+LOOP = Path('/logs/loop')
+best = {}
+try:
+    best = json.loads((LOOP / 'best.json').read_text())
+except Exception:
+    best = {}
+traj = []
+try:
+    for line in (LOOP / 'state.jsonl').read_text().splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        row = json.loads(line)
+        traj.append({'submission': row.get('submission'),
+                     'dev_speedup': row.get('speedup'),
+                     'dev_reward': row.get('reward'),
+                     'correctness_ok': row.get('correctness_ok')})
+except Exception:
+    pass
+win = best.get('submission') if best else None
+out = {
+    'schema_version': 'kernelbench_loop_finalize_v1',
+    'task_id': 'jit-source-arch-cache-key',
+    'mode': 'baked',
+    'submissions_used': int(os.environ.get('CUR') or 0),
+    'min_submissions': 1, 'max_submissions': 1,
+    'winning_submission': win,
+    'winning_dev_speedup': best.get('speedup') if best else None,
+    'winning_dev_reward': best.get('reward') if best else None,
+    'winning_tree': best.get('tree') if best else None,
+    'dev_speedup_trajectory': traj,
+    'termination_reason': os.environ.get('REASON') or '',
+    'note': 'dev_reward is an in-session proxy; meta.reward is the runner end-of-session score of /app/repo.',
+}
+(LOOP / 'finalize.json').write_text(json.dumps(out, indent=2, sort_keys=True) + '\n')
+PY
+  # Integrity: recompute the restored tree hash for the audit trail.
+  RESTORED_TREE="$(_snapshot_tree)"
+  echo "restored_tree=$RESTORED_TREE" >> "$LOOP/finalize_apply.log" 2>/dev/null || true
+  if [ -n "$WIN_SUB" ]; then
+    WR="$(python3 -c 'import json,sys;b=json.load(open(sys.argv[1]));print(f"{b.get(\"speedup\")}", f"{b.get(\"reward\")}")' "$BEST_FILE" 2>/dev/null || echo "? ?")"
+    echo "finalized: submission $WIN_SUB at k=$CUR/$MAX_SUBMISSIONS (dev_speedup ${WR% *}, dev_reward ${WR#* }); the grader will now score /app/repo"
+  else
+    echo "finalized: no correctness-passing submission in $CUR tries — /app/repo restored to the starting baseline; final reward will be 0 (no_improvement). the grader will now score /app/repo"
+  fi
+  exit 0
+fi
+
+# ------------------- submit -------------------
+CUR="$(_read_count)"; CUR="${CUR:-0}"
+if [ "$CUR" -ge "$MAX_SUBMISSIONS" ]; then
+  echo "submission $CUR/$MAX_SUBMISSIONS"
+  echo "budget exhausted — call 'bash /opt/loop/submit.sh --finalize' to grade your best submission"
+  # Auto-finalize as a safety net.
+  echo "--- auto-finalizing best-of-$MAX_SUBMISSIONS ---"
+  exec bash "$HERE/submit.sh" --finalize --reason "auto-finalize at budget ceiling"
+fi
+
+# Run the DEV engine on the LIVE /app/repo.
+bash "$HERE/score_engine.sh"
+engine_rc=$?
+
+# HARNESS error path: the engine flagged an infra failure (rc=3 or a marker).
+# Do NOT consume the solver's budget for our bug.
+if [ "$engine_rc" -eq 3 ] || [ -f "$DEV/harness_error.txt" ]; then
+  python3 "$HERE/sanitize_feedback.py"
+  exit 0
+fi
+
+# Consume one submission.
+NEXT=$((CUR + 1))
+echo "$NEXT" > "$COUNT_FILE"
+
+# Snapshot the candidate: tree hash (non-mutating) + binary diff vs baseline HEAD.
+SNAP="$LOOP/submissions/$NEXT"
+mkdir -p "$SNAP"
+TREE="$(_snapshot_tree)"
+git -C "$REPO" diff --binary HEAD > "$SNAP/candidate.diff" 2>/dev/null || true
+echo "${TREE:-}" > "$SNAP/tree.txt"
+for f in verifier_state.json correctness_results.json benchmark_results.json reward.json; do
+  [ -f "$DEV/$f" ] && cp "$DEV/$f" "$SNAP/$f" 2>/dev/null || true
+done
+
+# Update best-of-k (only correctness-passing, strictly-greater dev_reward) and
+# append the per-submission audit row.
+NEXT="$NEXT" TREE="$TREE" python3 - <<'PY'
+import json, os, time
+from pathlib import Path
+LOOP = Path('/logs/loop'); DEV = LOOP / 'dev'
+k = int(os.environ['NEXT']); tree = os.environ.get('TREE') or ''
+try:
+    state = json.loads((DEV / 'verifier_state.json').read_text())
+except Exception:
+    state = {}
+try:
+    reward = json.loads((DEV / 'reward.json').read_text())
+except Exception:
+    reward = {}
+corr_ok = bool(state.get('correctness_ok'))
+r = float(reward.get('reward') or 0.0)
+s = float(reward.get('speedup') or 0.0)
+# append audit row
+row = {'submission': k, 'ts': int(time.time()), 'correctness_ok': corr_ok,
+       'reward': r, 'speedup': s, 'tree': tree,
+       'hard_fail_reasons': list(state.get('hard_fail_reasons') or [])}
+with (LOOP / 'state.jsonl').open('a', encoding='utf-8') as f:
+    f.write(json.dumps(row) + '\n')
+# update best
+if corr_ok:
+    best_p = LOOP / 'best.json'
+    try:
+        best = json.loads(best_p.read_text())
+    except Exception:
+        best = None
+    if best is None or r > float(best.get('reward') or -1.0):
+        best_p.write_text(json.dumps(
+            {'submission': k, 'reward': r, 'speedup': s, 'tree': tree},
+            indent=2, sort_keys=True) + '\n')
+PY
+
+# Print sanitized feedback.
+python3 "$HERE/sanitize_feedback.py"
+
+# Auto-finalize on the ceiling.
+if [ "$NEXT" -ge "$MAX_SUBMISSIONS" ]; then
+  echo ""
+  echo "--- budget exhausted (submission $MAX_SUBMISSIONS/$MAX_SUBMISSIONS). Auto-finalizing best-of-$MAX_SUBMISSIONS. ---"
+  exec bash "$HERE/submit.sh" --finalize --reason "auto-finalize at budget ceiling"
+fi
+
+exit 0

tasks/kfc/jit-source-arch-cache-key/task/environment/repo/identity_key.py

@@ -0,0 +1,57 @@
+"""Stable identity for a build-spec.
+
+Public entry point:
+    ``identity_key(spec: dict) -> str``
+
+A downstream stage keeps a table of already-produced *identities* and skips the
+expensive step for a build-spec whose identity it has already seen. So the identity
+must satisfy two properties:
+
+* two specs that are **equivalent** (they describe the same build, differing only in
+  incidental spelling) should map to the **same** identity, and
+* two specs that are **genuinely different** must map to **different** identities -- a
+  collision between two different specs would let the wrong prior artifact be reused,
+  which is never acceptable.
+
+Build-spec shape
+----------------
+A spec is a mapping with:
+
+* ``"source"``: the source text (a string).
+* ``"target"``: the target-profile tag (a string) the artifact is produced for.
+* ``"options"`` (optional): a list of build-option tokens (an unordered set).
+* ``"toolchain"`` (optional): the toolchain-version tag (a string).
+* ``"variants"`` (optional): a list of requested variant names (an unordered set).
+* ``"build"`` (optional): a mapping of incidental build annotations.
+
+This starting implementation is **correct but conservative**: it derives the identity
+from the spec almost verbatim (only the field order of a mapping is neutralized). It
+never merges two different specs, but specs that are merely spelled differently are
+treated as separate identities, so the downstream table holds more entries than there
+are truly distinct builds and the expensive step is repeated once per spelling.
+Reducing the number of distinct identities -- without ever merging two genuinely
+different specs -- is the goal.
+"""
+
+import json
+
+
+def _fnv1a_64(text):
+    """Deterministic 64-bit FNV-1a digest of ``text`` (fixed, not process-salted)."""
+    h = 0xCBF29CE484222325
+    for byte in text.encode("utf-8"):
+        h ^= byte
+        h = (h * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF
+    return format(h, "016x")
+
+
+def identity_key(spec):
+    """Return a stable string identity for ``spec``.
+
+    Conservative baseline: serialize the spec with a fixed field order and digest it.
+    Only mapping-field order is neutralized; every other incidental difference (source
+    comments/whitespace, option order, redundant no-op options, annotation fields)
+    still yields a new identity.
+    """
+    text = json.dumps(spec, sort_keys=True, separators=(",", ":"), default=repr)
+    return _fnv1a_64(text)

tasks/kfc/jit-source-arch-cache-key/task/environment/runtime/entrypoint.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Canonical entrypoint: start the timer in the background and hand the container to
+# a login shell so the orchestrator can keep it alive and exec /tests/test.sh into it.
+# `exec "$@"` is honored when a command is passed (e.g. local smoke). CPU task: no
+# GPU/venv assumptions — pin a portable PATH that resolves python3.
+set -euo pipefail
+export PATH=/opt/kernelbench-venv/bin:/usr/local/bin:/usr/bin:/bin:$PATH
+mkdir -p /app/.timer
+/app/timer.sh >/tmp/task-timer.log 2>&1 &
+if [ "$#" -gt 0 ]; then
+  exec "$@"
+fi
+exec /bin/bash -l

tasks/kfc/jit-source-arch-cache-key/task/environment/runtime/run_dev_bench.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PATH=/opt/kernelbench-venv/bin:/usr/local/bin:/usr/bin:/bin:$PATH
+printf '%s\n' 'Public development feedback only. Final verification runs additional trusted and hidden workloads.'
+exit 0

tasks/kfc/jit-source-arch-cache-key/task/environment/runtime/timer.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Minimal global timer stub; the harness replaces it with the real budget timer.
+set -euo pipefail
+export PATH=/opt/kernelbench-venv/bin:/usr/local/bin:/usr/bin:/bin:$PATH
+mkdir -p /app/.timer
+echo 10800 > /app/.timer/remaining_secs
+echo 10800 > /app/.timer/budget_secs

tasks/kfc/jit-source-arch-cache-key/task/environment/verifier-correctness-manifest.json

@@ -0,0 +1,32 @@
+{
+  "schema_version": "kernelbench_correctness_manifest_v1",
+  "task_id": "jit-source-arch-cache-key",
+  "task_kind": "acceleration",
+  "expected_case_count": 12,
+  "primary_workload": "buildspec-identity-count",
+  "ref_speedup": 1.0,
+  "ref_speedup_note": "Anchor 4.0 calibrated in oracle mode on the authoring CPU lane (Intel Sapphire Rapids). tests/ref_speedup.txt is authoritative at scoring; this file is only the in-image fallback. See tests/ref_speedup.caveat.md to re-measure on your hardware.",
+  "metric": "recompile_count",
+  "direction": "higher_is_better",
+  "target_hardware": "cpu (x86-64 Sapphire Rapids; pure-Python stdlib, fixed FNV-1a/sha1 hash -> deterministic count, no profiler)",
+  "value_axis": "recompile_count = number of DISTINCT identities produced by identity_key over a fixed labeled workload of build-specs; the naive baseline emits one identity per spelling (more identities than true classes), a full normalizer emits one per true equivalence class",
+  "correctness_axes": [
+    "returns_string_for_various",
+    "deterministic_repeat_same_object",
+    "deterministic_fresh_build",
+    "distinct_source_distinct_keys",
+    "distinct_target_distinct_keys",
+    "distinct_effective_option_distinct_keys",
+    "distinct_option_value_distinct_keys",
+    "distinct_toolchain_distinct_keys",
+    "distinct_variant_set_distinct_keys",
+    "no_false_merge_full_workload",
+    "handles_edge_schema",
+    "many_distinct_specs_pairwise_distinct"
+  ],
+  "safety_gate": "no false merge: over the whole labeled workload no identity may be shared by two DIFFERENT true equivalence classes (checked by count_bench.py verify and by the no_false_merge_full_workload case); two specs differing only in target profile are DIFFERENT classes, so dropping the target profile from the identity is a false merge = correctness failure -> reward 0",
+  "public_symbol": "identity_key",
+  "primary_edit_paths": [
+    "/app/repo/identity_key.py"
+  ]
+}

tasks/kfc/jit-source-arch-cache-key/task/instruction.md

@@ -0,0 +1,162 @@
+# Performance Optimization Task
+
+You are working on the work-reuse layer of a batch build service. The service receives
+a stream of **build-specs**. Before running an expensive step for a spec, it computes a
+short string **identity** for that spec and looks the identity up in a table of
+already-produced identities; a hit means the prior artifact can be reused and the
+expensive step is skipped. The file `identity_key.py` implements this identity as a
+single function, `identity_key`. It is correct but produces far more distinct identities
+than necessary.
+
+## Behavioral contract
+
+```python
+def identity_key(spec: dict) -> str:
+    ...
+```
+
+A **build-spec** is a mapping describing one build request:
+
+- `"source"`: the source text — a string.
+- `"target"`: the target-profile tag — a string. The produced artifact is specific to
+  this profile.
+- `"options"` (optional): a list of build-option tokens (strings). The list is an
+  **unordered set** of options.
+- `"toolchain"` (optional): the toolchain-version tag — a string.
+- `"variants"` (optional): a list of requested variant names (strings), also an
+  **unordered set**.
+- `"build"` (optional): a mapping of incidental build annotations.
+
+`identity_key(spec)` returns a **string**. It must be **deterministic and reproducible**:
+the same spec (and any spec equivalent to it, see below) always yields the same string,
+on every run and every machine — so derive it from the spec's content with a fixed rule,
+not from anything process- or run-dependent.
+
+### When are two build-specs equivalent?
+
+Two specs are **equivalent** (they describe the same build and must receive the **same**
+identity) when they are equal after applying **all** of the following normalizations. Any
+difference that survives all of them makes the specs **distinct**, and distinct specs
+must receive **different** identities.
+
+1. **Incidental build annotations are ignored.** The `"build"` mapping never affects the
+   identity — two specs that differ only in `"build"` (or in whether `"build"` is present
+   at all) are equivalent.
+2. **Field order is irrelevant.** The order in which the keys of any mapping are written
+   does not matter.
+3. **Source comments and whitespace are ignored.** Within `"source"`, line comments
+   (`// …` to end of line) and block comments (`/* … */`) carry no meaning, and runs of
+   whitespace are insignificant (any run of spaces/tabs/newlines is equivalent to a
+   single space; leading and trailing whitespace is insignificant). Two source texts that
+   are equal after removing comments and collapsing whitespace are equivalent. **Every
+   other difference in the source text is meaningful.**
+4. **Options are an unordered set with no-op defaults folded.** The order of `"options"`
+   does not matter, and duplicate tokens are redundant. The tokens `"o0"`, `"dbgoff"`,
+   and `"std0"` are **no-op defaults**: each is equivalent to the token being absent. Any
+   **other** option token is meaningful and must be kept.
+5. **Requested variants are an unordered set.** The order of `"variants"` does not matter
+   and duplicates are redundant, but **which** variant names are present is meaningful.
+
+Everything not listed above is **meaningful**: the source text (beyond comments and
+whitespace), the target-profile tag, each effective (non-default) option token, the
+toolchain-version tag, and the set of requested variant names. Specs that differ in any of
+these are **distinct** and must not share an identity.
+
+## Why the current implementation is wasteful
+
+The current code derives the identity from the spec almost verbatim: it only neutralizes
+the order of a mapping's keys. So two specs that are equivalent but merely spelled
+differently — the same source with a comment added or reflowed whitespace, the same
+options in a different order or with a no-op default written out, a stray build
+annotation, the same variants listed in a different order — are treated as **different**
+identities. The reuse table then holds one entry per spelling instead of one entry per
+genuinely distinct build, and the expensive step is repeated for every spelling of the
+same build.
+
+Make the identity **collapse the equivalent spellings** so that equivalent specs map to
+one identity and the reuse table holds as few entries as there are genuinely distinct
+builds — while **never** giving two genuinely different specs the same identity.
+
+## Correctness comes first
+
+A single **collision between two genuinely different specs** — for example treating two
+different target profiles, two different source texts, two different effective option
+values, two different toolchain tags, or two different variant sets as the same — is a
+hard failure and scores **zero**, no matter how few identities you produce. In
+particular, two specs that share everything but the **target profile** describe different
+artifacts and must never collide. Merging spellings that are only *incidentally* different
+is the goal; merging builds that are *actually* different is never allowed. The verifier
+checks both a suite of correctness cases and, over the whole workload, that no identity is
+shared by two genuinely different builds.
+
+## Forbidden
+
+Do **not** import a tensor / graph / array framework, and do **not** import or read the
+test harness or its workload. Compute the identity yourself from the spec content using
+the standard library only. The scoring harness scans your submitted file for those
+references and scores the task `0` (do not reference them even in comments).
+
+## Scope
+
+Optimize the product implementation in `identity_key.py` only. Do **not** edit tests,
+harnesses, workloads, or dependency/build files. The final submitted diff must contain
+only product-code changes. Public/dev feedback, when present, is representative only;
+final verification runs additional trusted and hidden workloads.
+
+## How this task is scored — ONE single submission (READ CAREFULLY)
+
+You get **exactly one** submission. There is no iterative loop, no budget of
+retries, and no per-round feedback to improve against: the moment you submit, the
+task is over.
+
+1. Read and profile the current implementation in `/app/repo/identity_key.py`, work out
+   what is slow, and make it faster — taking as long as you need. Test your work
+   yourself as much as you like *before* submitting: write your own scratch
+   benchmarks and your own correctness checks in a scratch directory you create.
+2. When — and only when — you are confident the solution is both correct and as
+   fast as you can make it, submit it **once**:
+
+   ```
+   bash /opt/loop/submit.sh
+   ```
+
+3. **Submitting ends the task.** That single call scores the current state of
+   `/app/repo`, records it as your final answer, and finalizes immediately. You
+   will not get a second attempt, and you will not get feedback you could iterate
+   on. A second call to `submit.sh` is refused.
+
+Because there is no second chance, spend your effort *before* the submission:
+convince yourself the contract holds on every case you can think of (the shapes,
+dtypes, boundary and error cases described above), and verify your own timing
+shows a real improvement over the shipped implementation. A fast but incorrect
+submission scores zero, and there is no round in which to repair it.
+
+The grade is produced by a full, trusted end-of-session verifier over more
+workloads than anything you can see, so make the one submission you have a
+genuinely correct one.
+
+## 🔴 Red line (hard — ANY one of these makes the whole task score 0)
+
+The scoring machinery is off-limits. Solve this task **independently**, using
+ONLY the code in `/app/repo` and your own knowledge and reasoning.
+
+- Do **NOT** read, `cat`, `open`, `less`, `head`/`tail`, `grep`, `find`, or edit
+  ANY verifier / correctness / timing / scoring / hidden-test file or directory,
+  wherever it may live. Running `bash /opt/loop/submit.sh` is the ONLY sanctioned
+  interaction with the scoring machinery.
+- Do **NOT** run any verifier directly or try to reproduce or reverse-engineer it
+  — score ONLY by calling `bash /opt/loop/submit.sh`.
+- Do **NOT** search for, print, or infer the hidden workloads, seeds, thresholds,
+  the metric name, or the reference speedup from any source.
+- Do **NOT** fetch or look up the source PR, the upstream repository, or a
+  reference solution (no web search, no `git` remote fetch, no network to the
+  source), whether the internet is on or off.
+- Do **NOT** use, quote, or condition your code on any verifier / scoring / source
+  material, however you might have come to see it.
+
+Stay inside `/app/repo` and scratch directories you create yourself.
+
+## 提交方式
+
+本题只有**一次**评分提交(kfc 全子集单次)。改完后运行一次 `bash /opt/loop/submit.sh`:它给当前 `/app/repo` 评分并**立即定稿**(无需再单独调 `--finalize`,也没有第二次机会 —— 再次调用只会重新定稿同一份已记录的最佳快照,不给新改动评分)。请先用你自己的脚本充分自测再提交。
+改动留在工作树里,不需要 `git commit`(判分读工作树,仓库 HEAD 必须停在初始基线 commit 上)。

tasks/kfc/jit-source-arch-cache-key/task/pre_artifacts.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+# ============================================================================
+# pre_artifacts.sh — kfc/jit-source-arch-cache-key
+#
+# Run by the runner INSIDE this task's container AFTER the agent session ends and BEFORE
+# grading (spec §1.1).  It turns whatever the agent left behind into a portable artifact:
+#
+#   /logs/artifacts/model.patch      unified diff: WORKING TREE vs the baked baseline commit
+#   /logs/artifacts/model_files.txt  one changed/added ABSOLUTE path per line
+#
+# 🔴 IT NEVER COMMITS, and the task statement never asks the agent to (spec H3 — the one
+#    place we deliberately differ from deep-swe, whose pre_artifacts.sh diffs <base>..HEAD).
+#    Reason: grading reads the WORKING TREE.  `git status --porcelain` is the scope gate,
+#    `git checkout -q HEAD -- <scope>` re-materialises the baseline for the paired timing,
+#    and loop16's `submit.sh --finalize` plants the best iterate with read-tree +
+#    checkout-index while HEAD stays on the baked baseline.  A commit moves HEAD, the scope
+#    gate then sees nothing, `checkout HEAD -- scope` hands the CANDIDATE back as the
+#    "baseline" — and a correct solve scores 0.
+#    `git add -AN` (intent-to-add) is what makes NEW files appear in `git diff`: it stages
+#    names only, writes no tree, creates no commit and leaves HEAD exactly where it was.
+#
+# EXIT CODE IS ALWAYS 0.  A missing or empty artifact must not fail the round; the verifier
+# scores the container on its own terms and gives 0 by itself.
+#
+# READ-ONLY ON THE GRADED STATE.  `add -AN` is done against a COPY of the repo's index
+# (GIT_INDEX_FILE), so after this script the repo's .git/index is byte-identical and the
+# verifier — which runs after us — sees exactly the `git status --porcelain` it would have
+# seen if this script had never run.  No commit, no HEAD move, no working-tree write.
+#
+# CAPTURE ROOTS for THIS task — derived from the package, never assumed:
+#   /app/repo          git repo, HEAD == the 1-commit carved baseline
+#       evidence  Dockerfile:127: WORKDIR /app/repo
+#       evidence  Dockerfile:76: && cd /app/repo \
+#       evidence  Dockerfile:83: && test "$(git rev-list --count HEAD)" = "1" \
+#       evidence  test.sh:15: REPO=/app/repo
+#
+# Single root => model.patch is a bare `git diff --binary <baseline>` (no banner).
+# model_files.txt carries ABSOLUTE paths, corpus-wide, so the two forms stay parseable
+# by one reader.
+#
+# loop16 task (environment/loop/ -> /opt/loop in the image): the harness auto-finalizes
+# at k=16 and `submit.sh --finalize` plants the best iterate in the WORKING TREE while
+# HEAD stays on the baked baseline — which is exactly what this script captures. Running
+# it after a finalize therefore yields the GRADED artifact, not the last raw edit.
+# ============================================================================
+set -uo pipefail
+
+OUT=/logs/artifacts
+PATCH="$OUT/model.patch"
+LIST="$OUT/model_files.txt"
+MULTI=0                 # 1 => several capture roots => each diff gets a banner line
+MAX_BLOB_KB=5120                # per-file cap for the tree-snapshot path (keeps the patch sane)
+
+mkdir -p "$OUT" 2>/dev/null || true
+: > "$PATCH" 2>/dev/null || true
+: > "$LIST"  2>/dev/null || true
+git config --global --add safe.directory '*' >/dev/null 2>&1 || true
+
+banner() {                 # $1=root $2=mode ; only when there is more than one root
+    if [ "$MULTI" = 1 ]; then
+        printf '# ==== pre_artifacts root=%s mode=%s ====\n' "$1" "$2" >> "$PATCH" 2>/dev/null
+    fi
+    return 0
+}
+
+list_add() {               # stdin: paths relative to $1 -> absolute, one per line
+    sed "s|^|${1%/}/|" >> "$LIST" 2>/dev/null || true
+    return 0
+}
+
+capture_git() {            # $1 = dir whose HEAD is the baked 1-commit baseline
+    root=$1
+    if [ ! -d "$root" ]; then echo "[pre_artifacts] SKIP (absent): $root"; return 0; fi
+    if ! git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        echo "[pre_artifacts] WARN $root has no .git -> falling back to a tree snapshot"
+        capture_tree "$root"
+        return 0
+    fi
+    # 🔴 SCRATCH INDEX. `add -AN` has to touch an index, and the verifier runs AFTER us and
+    # reads `git status --porcelain`; turning `?? newdir/` into `A newdir/file` there could
+    # flip a scope gate either way. So copy the repo's index aside and stage into the COPY —
+    # the repo's own .git/index is byte-identical when we are done.
+    tmpi=$(mktemp -d /tmp/pre_artifacts.XXXXXX 2>/dev/null) || tmpi=""
+    gd=$(git -C "$root" rev-parse --absolute-git-dir 2>/dev/null || true)
+    if [ -z "$gd" ]; then
+        gd=$(git -C "$root" rev-parse --git-dir 2>/dev/null || true)
+        case "$gd" in /*) ;; ?*) gd="$root/$gd" ;; esac
+    fi
+    if [ -n "$tmpi" ] && [ -n "$gd" ] && [ -f "$gd/index" ] && cp "$gd/index" "$tmpi/index" 2>/dev/null; then
+        GIT_INDEX_FILE="$tmpi/index"; export GIT_INDEX_FILE
+    else
+        echo "[pre_artifacts] WARN no scratch index for $root; staging into the real index"
+    fi
+    git -C "$root" add -AN . >/dev/null 2>&1 || true
+    base=HEAD
+    if ! git -C "$root" rev-parse -q --verify HEAD >/dev/null 2>&1; then
+        base=$(git -C "$root" hash-object -w -t tree /dev/null 2>/dev/null)
+        echo "[pre_artifacts] WARN $root has no commit; diffing against the empty tree"
+    else
+        n=$(git -C "$root" rev-list --count HEAD 2>/dev/null || echo 0)
+        case "$n" in ''|*[!0-9]*) n=0 ;; esac
+        if [ "$n" -gt 1 ]; then
+            base=$(git -C "$root" rev-list --max-parents=0 HEAD 2>/dev/null | tail -1)
+            echo "[pre_artifacts] 🔴 $root HEAD has $n commits but the contract says 1:"
+            echo "[pre_artifacts]    the agent committed. Diffing from the ROOT commit ${base} so"
+            echo "[pre_artifacts]    nothing is lost — but grading reads the WORKING TREE, so a moved"
+            echo "[pre_artifacts]    HEAD can still zero an otherwise-correct solve."
+        fi
+    fi
+    [ -n "${base:-}" ] || base=HEAD
+    banner "$root" "git-diff-vs-baseline"
+    git -C "$root" diff --binary "$base" >> "$PATCH" 2>/dev/null || true
+    names=$(git -C "$root" diff --name-only "$base" 2>/dev/null)
+    echo "[pre_artifacts] $root: baseline $(git -C "$root" rev-parse --short "$base" 2>/dev/null), $(printf '%s\n' "$names" | grep -c . ) changed path(s)"
+    unset GIT_INDEX_FILE
+    [ -n "$tmpi" ] && rm -rf "$tmpi" 2>/dev/null
+    printf '%s\n' "$names" | grep -v '^$' | list_add "$root"
+    return 0
+}
+
+capture_tree() {           # $1 = editable dir that is NOT a git repo -> full snapshot
+    root=$1
+    if [ ! -d "$root" ]; then echo "[pre_artifacts] SKIP (absent): $root"; return 0; fi
+    tmp=$(mktemp -d /tmp/pre_artifacts.XXXXXX 2>/dev/null) || return 0
+    if git init -q "$tmp/snap" >/dev/null 2>&1; then
+        GD="$tmp/snap/.git"
+        empty=$(git --git-dir="$GD" hash-object -w -t tree /dev/null 2>/dev/null)
+        ( cd "$root" 2>/dev/null || exit 0
+          find . -name .git -prune -o -name __pycache__ -prune -o \
+                 -type f ! -name '*.pyc' ! -name '*.pyo' -size -"${MAX_BLOB_KB}"k -print0 \
+            2>/dev/null \
+          | GIT_DIR="$GD" GIT_WORK_TREE="$root" xargs -0 -r git add -f -- ) >/dev/null 2>&1 || true
+        banner "$root" "tree-snapshot-not-a-git-repo"
+        GIT_DIR="$GD" GIT_WORK_TREE="$root" git diff --cached --binary "$empty" \
+            >> "$PATCH" 2>/dev/null || true
+    else
+        echo "[pre_artifacts] WARN could not stage a snapshot index for $root"
+    fi
+    rm -rf "$tmp" 2>/dev/null || true
+    all=$( cd "$root" 2>/dev/null && find . -name .git -prune -o -name __pycache__ -prune -o \
+              -type f -print 2>/dev/null | sed 's|^\./||' )
+    printf '%s\n' "$all" | grep -v '^$' | list_add "$root"
+    big=$( cd "$root" 2>/dev/null && find . -name .git -prune -o -type f \
+              -size +"${MAX_BLOB_KB}"k -print 2>/dev/null | grep -c . )
+    echo "[pre_artifacts] $root: tree snapshot (no git baseline here), $(printf '%s\n' "$all" | grep -c . ) file(s)"
+    if [ "${big:-0}" != 0 ]; then
+        echo "[pre_artifacts] NOTE $big file(s) under $root exceed ${MAX_BLOB_KB}KB: listed in"
+        echo "[pre_artifacts]      model_files.txt but their bytes are NOT inlined into model.patch."
+    fi
+    return 0
+}
+
+capture_git "/app/repo"
+bytes=$(wc -c < "$PATCH" 2>/dev/null || echo 0)
+case "$bytes" in ''|*[!0-9]*) bytes=0 ;; esac
+echo "[pre_artifacts] captured $bytes bytes, $(wc -l < "$LIST" 2>/dev/null || echo 0) path(s)"
+if [ "$bytes" -gt 67108864 ]; then
+    echo "[pre_artifacts] 🔴 NOTE model.patch is $bytes bytes (> 64MiB). Almost certainly a build"
+    echo "[pre_artifacts]    product or a checkpoint was left inside a capture root — which is also"
+    echo "[pre_artifacts]    an out-of-scope edit the verifier's scope gate will punish."
+fi
+exit 0

tasks/kfc/jit-source-arch-cache-key/task/solution/README.md

@@ -0,0 +1,13 @@
+# solution/ — reviewer-only 参考实现
+
+本目录里的补丁**不进镜像**(已被上下文根的 `.dockerignore` 排除)、**判分不运行**,
+只在两种场合用:
+
+1. **重标定锚点**(换硬件后):见 `../tests/ref_speedup.caveat.md`
+   ```
+   -e KERNELBENCH_VERIFY_MODE=oracle -e KERNELBENCH_ORACLE_PATCH=/patches/oracle.patch
+   ```
+2. **自证挖洞树的正确性**:`git apply --check -p1 oracle.patch` 必须能干净打在
+   `../environment/repo/` 上(正向可、反向不可),这证明该树就是被计分的起始点。
+
+`negative.patch` 是已知坏例(必须得 0),`baseline2.patch` 是中间基线(若有)。

tasks/kfc/jit-source-arch-cache-key/task/solution/baseline2.patch

@@ -0,0 +1,88 @@
+diff --git a/identity_key.py b/identity_key.py
+index 9e2a701..f9c4328 100644
+--- a/identity_key.py
++++ b/identity_key.py
+@@ -1,57 +1,33 @@
+-"""Stable identity for a build-spec.
+-
+-Public entry point:
+-    ``identity_key(spec: dict) -> str``
+-
+-A downstream stage keeps a table of already-produced *identities* and skips the
+-expensive step for a build-spec whose identity it has already seen. So the identity
+-must satisfy two properties:
+-
+-* two specs that are **equivalent** (they describe the same build, differing only in
+-  incidental spelling) should map to the **same** identity, and
+-* two specs that are **genuinely different** must map to **different** identities -- a
+-  collision between two different specs would let the wrong prior artifact be reused,
+-  which is never acceptable.
+-
+-Build-spec shape
+-----------------
+-A spec is a mapping with:
+-
+-* ``"source"``: the source text (a string).
+-* ``"target"``: the target-profile tag (a string) the artifact is produced for.
+-* ``"options"`` (optional): a list of build-option tokens (an unordered set).
+-* ``"toolchain"`` (optional): the toolchain-version tag (a string).
+-* ``"variants"`` (optional): a list of requested variant names (an unordered set).
+-* ``"build"`` (optional): a mapping of incidental build annotations.
+-
+-This starting implementation is **correct but conservative**: it derives the identity
+-from the spec almost verbatim (only the field order of a mapping is neutralized). It
+-never merges two different specs, but specs that are merely spelled differently are
+-treated as separate identities, so the downstream table holds more entries than there
+-are truly distinct builds and the expensive step is repeated once per spelling.
+-Reducing the number of distinct identities -- without ever merging two genuinely
+-different specs -- is the goal.
++"""baseline2 for jit-source-arch-cache-key (reviewer-only; NOT baked in image).
++
++Same canonicalization SEMANTICS as the oracle (normalize source text, drop no-op
++options + de-dup + order-free, sort the variant set, drop build annotations, keep
++target profile + toolchain tag) but a DIFFERENT mechanism: build a canonical nested
++TUPLE and digest its ``repr`` with sha1, instead of the oracle's json + FNV-1a. It
++induces the same partition and the same identity count (~12) as the oracle -> the same
++speedup -- which proves the verifier scores the identity PARTITION, not a byte-match
++against oracle code.
+ """
+ 
+-import json
++import hashlib
++import re
+ 
++_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
++_LINE_COMMENT = re.compile(r"//[^\n]*")
++NOOP_OPTIONS = {"o0", "dbgoff", "std0"}
+ 
+-def _fnv1a_64(text):
+-    """Deterministic 64-bit FNV-1a digest of ``text`` (fixed, not process-salted)."""
+-    h = 0xCBF29CE484222325
+-    for byte in text.encode("utf-8"):
+-        h ^= byte
+-        h = (h * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF
+-    return format(h, "016x")
+ 
++def _canon_source(text):
++    text = _BLOCK_COMMENT.sub(" ", text or "")
++    text = _LINE_COMMENT.sub(" ", text)
++    return " ".join(text.split())
+ 
+-def identity_key(spec):
+-    """Return a stable string identity for ``spec``.
+ 
+-    Conservative baseline: serialize the spec with a fixed field order and digest it.
+-    Only mapping-field order is neutralized; every other incidental difference (source
+-    comments/whitespace, option order, redundant no-op options, annotation fields)
+-    still yields a new identity.
+-    """
+-    text = json.dumps(spec, sort_keys=True, separators=(",", ":"), default=repr)
+-    return _fnv1a_64(text)
++def identity_key(spec):
++    source = _canon_source(spec.get("source", ""))
++    target = spec.get("target")
++    toolchain = spec.get("toolchain")
++    options = tuple(sorted({o for o in (spec.get("options") or []) if o not in NOOP_OPTIONS}))
++    variants = tuple(sorted(spec.get("variants") or []))
++    canon = (source, target, toolchain, options, variants)
++    return hashlib.sha1(repr(canon).encode("utf-8")).hexdigest()

tasks/kfc/jit-source-arch-cache-key/task/solution/negative.patch

@@ -0,0 +1,96 @@
+diff --git a/identity_key.py b/identity_key.py
+index 9e2a701..98ec768 100644
+--- a/identity_key.py
++++ b/identity_key.py
+@@ -1,43 +1,25 @@
+-"""Stable identity for a build-spec.
+-
+-Public entry point:
+-    ``identity_key(spec: dict) -> str``
+-
+-A downstream stage keeps a table of already-produced *identities* and skips the
+-expensive step for a build-spec whose identity it has already seen. So the identity
+-must satisfy two properties:
+-
+-* two specs that are **equivalent** (they describe the same build, differing only in
+-  incidental spelling) should map to the **same** identity, and
+-* two specs that are **genuinely different** must map to **different** identities -- a
+-  collision between two different specs would let the wrong prior artifact be reused,
+-  which is never acceptable.
+-
+-Build-spec shape
+-----------------
+-A spec is a mapping with:
+-
+-* ``"source"``: the source text (a string).
+-* ``"target"``: the target-profile tag (a string) the artifact is produced for.
+-* ``"options"`` (optional): a list of build-option tokens (an unordered set).
+-* ``"toolchain"`` (optional): the toolchain-version tag (a string).
+-* ``"variants"`` (optional): a list of requested variant names (an unordered set).
+-* ``"build"`` (optional): a mapping of incidental build annotations.
+-
+-This starting implementation is **correct but conservative**: it derives the identity
+-from the spec almost verbatim (only the field order of a mapping is neutralized). It
+-never merges two different specs, but specs that are merely spelled differently are
+-treated as separate identities, so the downstream table holds more entries than there
+-are truly distinct builds and the expensive step is repeated once per spelling.
+-Reducing the number of distinct identities -- without ever merging two genuinely
+-different specs -- is the goal.
++"""Negative for jit-source-arch-cache-key (reviewer-only; NOT baked in image).
++
++Over-canonicalizes: it DROPS the target-profile field (treats every target as the same).
++So two specs that differ ONLY in target profile -- e.g. the SAME source built for target
++``p80`` vs ``p90`` -- collapse to the SAME identity. That is a FALSE MERGE of two
++genuinely different builds: it would let an artifact produced for one target be reused
++for another (a wrong-target artifact). This must score reward 0 -- it fails
++distinct_target_distinct_keys, the whole-workload no_false_merge gate, and
++count_bench.py verify. It is otherwise a plausible full normalizer (source/options/
++toolchain/variants all handled), which is exactly why the false-merge safety gate has
++to catch it.
+ """
+ 
+ import json
++import re
++
++_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
++_LINE_COMMENT = re.compile(r"//[^\n]*")
++NOOP_OPTIONS = {"o0", "dbgoff", "std0"}
+ 
+ 
+ def _fnv1a_64(text):
+-    """Deterministic 64-bit FNV-1a digest of ``text`` (fixed, not process-salted)."""
+     h = 0xCBF29CE484222325
+     for byte in text.encode("utf-8"):
+         h ^= byte
+@@ -45,13 +27,22 @@ def _fnv1a_64(text):
+     return format(h, "016x")
+ 
+ 
++def _canon_source(text):
++    text = _BLOCK_COMMENT.sub(" ", text or "")
++    text = _LINE_COMMENT.sub(" ", text)
++    return " ".join(text.split())
++
++
+ def identity_key(spec):
+-    """Return a stable string identity for ``spec``.
+-
+-    Conservative baseline: serialize the spec with a fixed field order and digest it.
+-    Only mapping-field order is neutralized; every other incidental difference (source
+-    comments/whitespace, option order, redundant no-op options, annotation fields)
+-    still yields a new identity.
+-    """
+-    text = json.dumps(spec, sort_keys=True, separators=(",", ":"), default=repr)
+-    return _fnv1a_64(text)
++    source = _canon_source(spec.get("source", ""))
++    toolchain = spec.get("toolchain")
++    options = sorted({o for o in (spec.get("options") or []) if o not in NOOP_OPTIONS})
++    variants = sorted(spec.get("variants") or [])
++    # BUG (intentional): the target-profile field is dropped -> different targets collide.
++    canon = {
++        "source": source,
++        "toolchain": toolchain,
++        "options": options,
++        "variants": variants,
++    }
++    return _fnv1a_64(json.dumps(canon, sort_keys=True, separators=(",", ":"), default=repr))

tasks/kfc/jit-source-arch-cache-key/task/solution/oracle.patch

@@ -0,0 +1,97 @@
+diff --git a/identity_key.py b/identity_key.py
+index 9e2a701..2f759db 100644
+--- a/identity_key.py
++++ b/identity_key.py
+@@ -1,43 +1,25 @@
+-"""Stable identity for a build-spec.
+-
+-Public entry point:
+-    ``identity_key(spec: dict) -> str``
+-
+-A downstream stage keeps a table of already-produced *identities* and skips the
+-expensive step for a build-spec whose identity it has already seen. So the identity
+-must satisfy two properties:
+-
+-* two specs that are **equivalent** (they describe the same build, differing only in
+-  incidental spelling) should map to the **same** identity, and
+-* two specs that are **genuinely different** must map to **different** identities -- a
+-  collision between two different specs would let the wrong prior artifact be reused,
+-  which is never acceptable.
+-
+-Build-spec shape
+-----------------
+-A spec is a mapping with:
+-
+-* ``"source"``: the source text (a string).
+-* ``"target"``: the target-profile tag (a string) the artifact is produced for.
+-* ``"options"`` (optional): a list of build-option tokens (an unordered set).
+-* ``"toolchain"`` (optional): the toolchain-version tag (a string).
+-* ``"variants"`` (optional): a list of requested variant names (an unordered set).
+-* ``"build"`` (optional): a mapping of incidental build annotations.
+-
+-This starting implementation is **correct but conservative**: it derives the identity
+-from the spec almost verbatim (only the field order of a mapping is neutralized). It
+-never merges two different specs, but specs that are merely spelled differently are
+-treated as separate identities, so the downstream table holds more entries than there
+-are truly distinct builds and the expensive step is repeated once per spelling.
+-Reducing the number of distinct identities -- without ever merging two genuinely
+-different specs -- is the goal.
++"""Oracle for jit-source-arch-cache-key (reviewer-only; NOT baked in image).
++
++Full canonicalization: normalize the source text (strip comments, collapse whitespace),
++canonicalize the option set (drop no-op defaults, de-duplicate, sort for order-freedom),
++sort the requested variant set, drop the incidental build annotations, and KEEP every
++binary-affecting field (source, target profile, effective options, toolchain tag,
++variant set). Equivalent spellings collapse to one identity, so the number of distinct
++identities over the labeled workload equals the number of true equivalence classes
++(12) -- the fewest possible. speedup = baseline_recompiles / oracle_recompiles
++(~48 / ~12 = ~4.0). Never merges two genuinely different specs -- in particular two
++specs that differ only in target profile keep distinct identities.
+ """
+ 
+ import json
++import re
++
++_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
++_LINE_COMMENT = re.compile(r"//[^\n]*")
++NOOP_OPTIONS = {"o0", "dbgoff", "std0"}
+ 
+ 
+ def _fnv1a_64(text):
+-    """Deterministic 64-bit FNV-1a digest of ``text`` (fixed, not process-salted)."""
+     h = 0xCBF29CE484222325
+     for byte in text.encode("utf-8"):
+         h ^= byte
+@@ -45,13 +27,23 @@ def _fnv1a_64(text):
+     return format(h, "016x")
+ 
+ 
++def _canon_source(text):
++    text = _BLOCK_COMMENT.sub(" ", text or "")
++    text = _LINE_COMMENT.sub(" ", text)
++    return " ".join(text.split())
++
++
+ def identity_key(spec):
+-    """Return a stable string identity for ``spec``.
+-
+-    Conservative baseline: serialize the spec with a fixed field order and digest it.
+-    Only mapping-field order is neutralized; every other incidental difference (source
+-    comments/whitespace, option order, redundant no-op options, annotation fields)
+-    still yields a new identity.
+-    """
+-    text = json.dumps(spec, sort_keys=True, separators=(",", ":"), default=repr)
+-    return _fnv1a_64(text)
++    source = _canon_source(spec.get("source", ""))
++    target = spec.get("target")
++    toolchain = spec.get("toolchain")
++    options = sorted({o for o in (spec.get("options") or []) if o not in NOOP_OPTIONS})
++    variants = sorted(spec.get("variants") or [])
++    canon = {
++        "source": source,
++        "target": target,
++        "toolchain": toolchain,
++        "options": options,
++        "variants": variants,
++    }
++    return _fnv1a_64(json.dumps(canon, sort_keys=True, separators=(",", ":"), default=repr))

tasks/kfc/jit-source-arch-cache-key/task/solution/solve.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+# solution/solve.sh — kfc/jit-source-arch-cache-key
+# 把本题的参考实现落成「与 agent 提交等价」的形态,让 oracle 验证从手工传环境变量
+# 变成一条命令。本文件不进镜像(没有任何 COPY 取 solution/),判分器也不会运行它。
+#
+# oracle 形态 : 补丁式(patch)。tests/test.sh 的模式分派走 KERNELBENCH_ORACLE_PATCH 槽位:
+#               git -C "$REPO" apply -p1 "$KERNELBENCH_ORACLE_PATCH"
+#               产物(reviewer-only;本脚本只读,一个字节都不改):
+#                 solution/baseline2.patch, solution/negative.patch, solution/oracle.patch
+# $REPO       : /app/repo                      (tests/test.sh: REPO=/app/repo)
+# 被计分单元  : /app/repo/identity_key.py
+#               来源:tests/test.sh 的 CAND_FILE="$REPO/identity_key.py"
+# 落地方式    : git -C $REPO apply -p1 <patch> —— 只改工作树,不 commit
+#
+# 🔴 为什么绝不 commit(规范 H3):判分读**工作树** —— `git status --porcelain` 是 scope
+#    硬闸门,`git checkout -q HEAD -- <scope>` 取基线,且镜像自证 /app/repo 的 HEAD 恰好
+#    只有 1 个 commit(那就是挖洞基线)。一旦 commit,HEAD 前移 → 闸门看不到改动、
+#    `checkout HEAD -- scope` 把 candidate 当成基线 → 正确解被判 0。
+#    本脚本落地后会自己断言 HEAD 与 commit 数没变。
+#
+# ── 落地后判分的那条完整命令(同一个容器里跑完 3 步)────────────────────────
+#   PKG=<fai_bench>/tasks/kfc/jit-source-arch-cache-key/task
+#   IMG=fai/kfc-jit-source-arch-cache-key:oss
+#   # 1) 起容器。判分容器始终 --network=none;tests/ 和 solution/ 都**没有**烤进镜像
+#   #    (Dockerfile 里没有一条 COPY 取它们),所以这两个目录必须挂进来。
+#   #    该题 task.toml 声明 gpus=0;锚点的标定硬件/运行栈见 tests/ref_speedup.caveat.md
+#   docker run -d --name kfc-solve --network=none \
+#     -v "$PKG/tests":/tests -v "$PKG/solution":/solution "$IMG"
+#   # 2) 落地参考实现到工作树(本脚本;不 commit)
+#   docker exec kfc-solve bash /solution/solve.sh
+#   # 3) 判分。KERNELBENCH_VERIFY_MODE 必须留在默认的 candidate —— 这就是 agent 的
+#   #    真实评分路径;设成 oracle/negative 会让 test.sh 自己再落地一遍,绕过本脚本。
+#   docker exec -e KERNELBENCH_VERIFY_MODE=candidate kfc-solve bash /tests/test.sh
+#   docker exec kfc-solve cat /logs/verifier/reward.json   # 判分结果
+#   docker rm -f kfc-solve
+#
+#   期望:oracle → 性能题得 0(它就是锚点本身; min(1, ln(speedup/ref_speedup)/ln(ref_speedup))(speedup ≤ ref_speedup 时为 0)
+#         在 speedup≈ref_speedup 处 = 0 —— 打平 oracle 不得分,必须超过。
+#         所以"oracle 跑对了"的判据不是 reward>0,而是 speedup≈ref_speedup 且
+#         hard_fail_reasons 为空;实现类二值题 = 1.0 —— 权威公式是
+#         tests/test.sh 写出的 reward_formula 字段);--negative → 0;
+#         --noop(在纯净容器里)→ 0(挖洞基线过不了正确性门)。
+#   本题带 loop16 harness:`bash /opt/loop/submit.sh` 判的也是同一棵工作树、
+#   同样走 candidate 模式(口径一致),所以落地后直接自评也成立。
+# ──────────────────────────────────────────────────────────────────────────
+#
+# 用法(规范 2 的统一 CLI):
+#   bash solution/solve.sh              # 落地 oracle(参考实现)
+#   bash solution/solve.sh --negative   # 落地 negative(已知坏例,必须得 0)
+#   bash solution/solve.sh --baseline2  # 落地 baseline2(中间基线)
+#   bash solution/solve.sh --noop       # 把可编辑面复位到烤入基线(对照组)
+#
+# --noop 语义:把可编辑面复位到烤入基线(与 verifier 取基线的方式一致 ——
+#   `git checkout HEAD -- <scope>`,HEAD 不动),使对照组能量到真正的 no-op 值。
+#   runner 在同一个容器里连着跑 oracle → noop 做对照时,靠它把上一轮落地归零。
+#
+# 幂等:每次落地前先把被计分单元 `git checkout HEAD --` 复位,重复执行结果一致。
+# 失败一律非 0 退出并打印原因(补丁打不上 / 变体文件缺失 / scope 路径不存在 / HEAD 被移动)。
+set -uo pipefail
+
+TASK_ID="jit-source-arch-cache-key"
+REPO="${KFC_REPO_DIR:-/app/repo}"
+SCOPE=("identity_key.py")
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+say(){ printf '[solve.sh %s] %s\n' "$TASK_ID" "$*"; }
+die(){ printf '[solve.sh %s] ERROR: %s\n' "$TASK_ID" "$*" >&2; exit 1; }
+# 每次调用单独带 safe.directory,不去改容器里的全局 gitconfig
+GIT(){ git -c safe.directory='*' -C "$REPO" "$@"; }
+
+usage(){ cat <<'USAGE'
+usage: bash solve.sh [--oracle | --negative | --baseline2 | --noop]
+  (无参数)      落地 oracle 参考实现(oracle.patch)
+  --negative    落地 negative 已知坏���(negative.patch)
+  --baseline2   落地 baseline2 中间基线(baseline2.patch)
+  --noop        把可编辑面复位到烤入基线(与 verifier 取基线一致,HEAD 不动)
+USAGE
+}
+
+WHICH=oracle
+case "${1:-}" in
+  ""|--oracle) WHICH=oracle ;;
+  --negative)  WHICH=negative ;;
+  --baseline2) WHICH=baseline2 ;;
+  --noop)      WHICH=noop ;;
+  -h|--help)   usage; exit 0 ;;
+  *)           usage >&2; die "未知参数 '$1'" ;;
+esac
+
+# ---- 产物定位:脚本同目录优先,其次容器里的常见挂载点 ----
+artifact(){
+  local n="$1" c
+  for c in "$HERE/$n" "/solution/$n" "${KFC_SOLUTION_DIR:-/nonexistent}/$n"; do
+    [ -f "$c" ] && { printf '%s\n' "$c"; return 0; }
+  done
+  return 1
+}
+
+case "$WHICH" in
+  noop)     ART="" ;;
+  oracle)   ART="oracle.patch" ;;
+  negative) ART="negative.patch" ;;
+  baseline2) ART="baseline2.patch" ;;
+  *) die "本题没有 $WHICH 变体(solution/ 里只有:oracle.patch, negative.patch, baseline2.patch)" ;;
+esac
+
+# ---- 环境前置检查 ----
+GIT rev-parse --git-dir >/dev/null 2>&1 \
+  || die "$REPO 不是 git 工作树 —— 本脚本必须在题目容器里跑(镜像在 build 时才 git init 挖洞基线)"
+for s in "${SCOPE[@]}"; do
+  [ -e "$REPO/$s" ] || die "被计分单元不存在:$REPO/$s(REPO 不对?可用 KFC_REPO_DIR 覆盖)"
+done
+HEAD_BEFORE="$(GIT rev-parse HEAD)" || die "读不到 $REPO 的 HEAD"
+N_BEFORE="$(GIT rev-list --count HEAD)"
+
+if [ "$WHICH" = noop ]; then
+  # --noop 把可编辑面复位到烤入基线(与 verifier 取基线的方式一致 —— `git checkout HEAD -- <scope>`,
+  # HEAD 不动),使对照组能量到真正的 no-op 值。runner 在同一个容器里连着跑 oracle → noop 时靠它归零。
+  DIRTY_BEFORE="$(GIT status --porcelain -- "${SCOPE[@]}" | sed '/^$/d')"
+  GIT checkout -q HEAD -- "${SCOPE[@]}" || die "复位被计分单元失败(${SCOPE[*]})"
+  DIRTY_AFTER="$(GIT status --porcelain -- "${SCOPE[@]}" | sed '/^$/d')"
+  if [ -n "$DIRTY_AFTER" ]; then
+    printf '%s\n' "$DIRTY_AFTER" | sed "s|^|[solve.sh $TASK_ID]   |" >&2
+    die "复位后被计分单元仍不干净(见上)—— 量不到真正的 no-op 值"
+  fi
+  [ "$HEAD_BEFORE" = "$(GIT rev-parse HEAD)" ] || die "HEAD 被移动了,判分会把 candidate 当基线"
+  [ "$N_BEFORE" = "$(GIT rev-list --count HEAD)" ] || die "commit 数变了,HEAD 不再是唯一的挖洞基线"
+  if [ -n "$DIRTY_BEFORE" ]; then
+    say "--noop:已把可编辑面复位到烤入基线;原先这些是脏的:"
+    printf '%s\n' "$DIRTY_BEFORE" | sed "s|^|[solve.sh $TASK_ID]   |"
+  else
+    say "--noop:可编辑面本来就是干净的烤入基线,无需复位"
+  fi
+  say "--noop 完成:${SCOPE[*]} = 烤入基线(HEAD 未动 @ ${HEAD_BEFORE:0:12})"
+  exit 0
+fi
+
+PATCH="$(artifact "$ART")" || die "找不到参考产物 $ART(查过 $HERE/、/solution/、\$KFC_SOLUTION_DIR/)"
+
+# ---- 幂等:先把被计分单元退回挖洞基线,再打补丁(否则二次 apply 必然失败) ----
+GIT checkout -q HEAD -- "${SCOPE[@]}" || die "复位被计分单元失败(${SCOPE[*]})"
+GIT apply -p1 --check "$PATCH" \
+  || die "补丁打不上:$PATCH —— 挖洞树与该补丁不匹配,或工作树被别的改动污染了"
+GIT apply -p1 "$PATCH" || die "git apply 失败:$PATCH"
+
+# ---- 硬要求:HEAD 一步都不能动(规范 H3) ----
+HEAD_AFTER="$(GIT rev-parse HEAD)"
+[ "$HEAD_BEFORE" = "$HEAD_AFTER" ] || die "HEAD 被移动了($HEAD_BEFORE -> $HEAD_AFTER),判分会把 candidate 当基线"
+[ "$N_BEFORE" = "$(GIT rev-list --count HEAD)" ] || die "commit 数变了,HEAD 不再是唯一的挖洞基线"
+
+say "已落地 $WHICH:$(basename "$PATCH") -> ${SCOPE[*]}(工作树改动,HEAD 未动 @ ${HEAD_AFTER:0:12})"
+GIT status --porcelain -- "${SCOPE[@]}" | sed "s|^|[solve.sh $TASK_ID]   |"
+
+# ---- 顺手体检 scope 闸门:工作树里除了被计分单元不该有别的改动 ----
+STRAY="$(GIT status --porcelain | awk '{print $NF}' \
+         | grep -v -e '__pycache__' -e '\.pyc$' -e '^identity_key\.py$' || true)"
+[ -z "$STRAY" ] || { say "⚠ 工作树里还有 scope 外的改动,判分会 out_of_scope_edit 直接归 0:"; \
+                     printf '%s\n' "$STRAY" | sed "s|^|[solve.sh $TASK_ID]   |"; }
+exit 0

tasks/kfc/jit-source-arch-cache-key/task/task.toml

@@ -0,0 +1,81 @@
+schema_version = "2.0"
+
+# 提交产物(pre_artifacts.sh 在判分前于同一容器内产出;规范 §1)
+artifacts = ["/logs/artifacts/model.patch", "/logs/artifacts/model_files.txt"]
+
+[task]
+id = "jit-source-arch-cache-key"
+bench = "kfc"
+kind = "performance"
+language = "python"
+title = "You are working on the work-reuse layer of a batch build service."
+instruction = "instruction.md"
+
+[agent]
+timeout_sec = 21600
+
+# carved-tree provenance (environment/repo/ recovered from): <internal registry>/kernelbench/insea-jit-source-arch-cache-key-loop16:loop-20260721T021500Z@sha256:b6e1405e15730a4d2605a010e43a832c62e79d533833700356bd01e7e77fea6d
+# Open-source build: `cd <this dir> && docker build -f environment/Dockerfile -t fai/kfc-jit-source-arch-cache-key:oss .`
+[environment]
+docker_image = "fai/kfc-jit-source-arch-cache-key:oss"
+dockerfile = "environment/Dockerfile"
+build_timeout_sec = 3600
+cpus = 8
+memory_mb = 16000
+gpus = 0
+allow_internet = false
+
+[verifier]
+entrypoint = "tests/test.sh"
+mode = "shared"
+timeout_sec = 3600
+task_kind = "acceleration"
+contract_pattern = "A"
+timing_metric = "recompile_count"
+candidate_source_root = "/app/repo"
+primary_edit_paths = ["/app/repo/identity_key.py"]
+forbidden_edit_paths = ["/app/repo/tests/**", "/opt/verifier-*", "/tests/**", "/opt/loop/**"]
+result_paths = [
+    "/logs/verifier/verifier_state.json",
+    "/logs/verifier/correctness_results.json",
+    "/logs/verifier/benchmark_results.json",
+    "/logs/verifier/reward.json",
+    "/logs/verifier/reward.txt",
+]
+
+[primary_metric]
+name = "buildspec_identity_recompile_count_speedup"
+goal = "maximize"
+metric_kind = "recompile_count"
+reward_formula = "acceleration: reward = measured speedup = baseline_recompiles / candidate_recompiles, where recompile_count = the number of DISTINCT identities a module's identity_key produces over a fixed labeled workload of build-specs (48 specs = 12 true equivalence classes x 4 spellings). Deterministic and hardware-portable (pure-Python stdlib, fixed FNV-1a/sha1 hash; no profiler). The frozen baseline emits one identity per spelling (~48) so its own speedup is ~1.0; a full normalizer emits one per true class (~12) -> speedup ~4.0. The 12-case hidden correctness suite, the whole-workload no-false-merge safety gate (any identity shared by two DIFFERENT true classes = correctness failure -> reward 0; two specs differing only in target profile are DIFFERENT classes), and the anti-cheat (only identity_key.py may change; no tensor/graph framework or harness import) are hard gates."
+ref_speedup = 4.0
+ref_speedup_source = "tests/ref_speedup.txt"
+calibrated_on = "Intel Sapphire Rapids CPU lane"
+correctness_gates = [
+    "hidden_case_suite",
+    "returns_string_for_various",
+    "deterministic_repeat_same_object",
+    "deterministic_fresh_build",
+    "distinct_source_distinct_keys",
+    "distinct_target_distinct_keys",
+    "distinct_effective_option_distinct_keys",
+    "distinct_option_value_distinct_keys",
+    "distinct_toolchain_distinct_keys",
+    "distinct_variant_set_distinct_keys",
+    "no_false_merge_full_workload",
+    "handles_edge_schema",
+    "many_distinct_specs_pairwise_distinct",
+    "candidate_false_merge",
+    "anti_cheat_forbidden_edit",
+    "forbidden_framework_or_harness_reference",
+]
+
+[loop]
+min_submissions = 1
+max_submissions = 1
+submit = "bash /opt/loop/submit.sh"
+mode = "baked"
+feedback_surface = "/opt/loop/submit.sh"
+# single-submission — min=max=1; the first
+# `bash /opt/loop/submit.sh` IS the final graded submission (submit == finalize).
+declared_submission_policy = "single_submission"

tasks/kfc/jit-source-arch-cache-key/task/tests/compute_reward.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Canonical kernelbench reward writer (task-agnostic; do NOT special-case a task here).
+
+Reward definition:
+
+  performance (acceleration):
+      reward = min(1.0, ln(speedup/ref_speedup)/ln(ref_speedup)) if speedup > ref_speedup else 0.0
+      -> matching the oracle (speedup == ref_speedup) scores 0.5
+      -> reaching ref_speedup**2 caps at 1.0
+      value range is strictly [0.0, 1.0]
+      HARD PRE-GATES (any one hit => reward 0, the formula is never evaluated):
+        build/import failure, ANY correctness case fail, cheating, forbidden
+        edit path, speedup <= 1, ref_speedup <= 1.
+  implementation (correctness):
+      reward = 1.0 iff EVERY test case passes and no cheating, else 0.0 (binary).
+
+Reads:  /logs/verifier/verifier_state.json, /logs/verifier/benchmark_results.json
+Writes: /logs/verifier/reward.json, /logs/verifier/reward.txt
+"""
+import json, math
+from pathlib import Path
+
+LOG = Path("/logs/verifier")
+STATE = LOG / "verifier_state.json"
+BENCH = LOG / "benchmark_results.json"
+REWARD = LOG / "reward.json"
+TEXT = LOG / "reward.txt"
+
+# Every gate below is a HARD gate: build/import origin, correctness (visible AND
+# hidden), baseline sanity, benchmark validity, anti-cheat / forbidden-path.
+GATES = [
+    "correctness_ok",
+    "trusted_restore_ok",
+    "hidden_correctness_ok",
+    "baseline_ok",
+    "benchmark_ok",
+    "anti_cheat_ok",
+]
+
+
+def read_json(path, default):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def _case_counts(state, bench):
+    """(passed, total) test cases when the verifier reports them; else (None, None)."""
+    exp = state.get("expected_case_count")
+    act = state.get("actual_case_count")
+    try:
+        exp = int(exp); act = int(act)
+    except Exception:
+        return (None, None)
+    if exp <= 0:
+        return (None, None)
+    return (act, exp)
+
+
+def main():
+    LOG.mkdir(parents=True, exist_ok=True)
+    state = read_json(STATE, {})
+    bench = read_json(BENCH, {})
+    hard = list(state.get("hard_fail_reasons") or [])
+    task_kind = state.get("task_kind") or bench.get("task_kind") or "acceleration"
+    gates_ok = all(bool(state.get(g)) for g in GATES)
+
+    passed, total = _case_counts(state, bench)
+    # A short test suite is a correctness FAIL, not a partial credit: reward.md
+    # requires EVERY case to pass (implementation) / no case to fail (performance).
+    all_cases_ok = True
+    if passed is not None and total is not None and passed < total:
+        all_cases_ok = False
+        if not any("case" in str(h) or "correctness" in str(h) for h in hard):
+            hard.append("correctness_cases_incomplete")
+
+    speedup = ref = 1.0
+    reward = 0.0
+
+    if task_kind == "correctness":
+        # ---- implementation class: BINARY. All cases pass + no cheating -> 1.0, else 0.0.
+        reward = 1.0 if (gates_ok and all_cases_ok and not hard) else 0.0
+        if reward == 0.0 and not hard:
+            hard.append("correctness_or_validation_incomplete")
+    else:
+        # ---- performance class: log-ratio reward, behind the hard pre-gates.
+        try:
+            speedup = float(bench.get("aggregate_speedup") or bench.get("primary_metric_value") or 1.0)
+            ref = float(bench.get("ref_speedup") or bench.get("reference_metric_value") or 1.0)
+        except Exception:
+            speedup = ref = 1.0
+            hard.append("invalid_primary_metric_value")
+
+        if not (math.isfinite(speedup) and speedup > 0.0):
+            hard.append("invalid_primary_metric_value")
+        # pre-gate 5: the candidate must actually beat the baseline
+        elif speedup <= 1.0:
+            hard.append("speedup_not_above_baseline")
+        # pre-gate 6: the reference anchor must be a real speedup
+        if not (math.isfinite(ref) and ref > 1.0):
+            hard.append("ref_speedup_invalid")
+
+        if gates_ok and all_cases_ok and not hard:
+            reward = min(1.0, max(0.0, min(1.0, math.log(speedup) / math.log(ref) - 1.0)))
+            # value range is strictly [0.0, 1.0]
+            reward = max(0.0, min(1.0, reward))
+        else:
+            reward = 0.0
+            if not hard:
+                hard.append("validation_incomplete_or_bad_speedup")
+
+    out = {
+        "schema_version": "kernelbench_reward_v2_logratio",
+        # reward.md result-JSON field: "performance" | "implementation"
+        "task_type": "implementation" if task_kind == "correctness" else "performance",
+        "task_kind": task_kind,
+        "reward": reward,
+        "speedup": speedup,
+        "ref_speedup": ref,
+        "reward_formula": ("binary: 1.0 iff all cases pass and no cheating, else 0.0"
+                           if task_kind == "correctness"
+                           else "min(1.0, ln(speedup/ref_speedup)/ln(ref_speedup)) if speedup > ref_speedup else 0.0; 0 if any hard pre-gate hit"),
+        "actual_hardware_type": state.get("actual_hardware_type", "") or bench.get("actual_hardware_type", ""),
+        "hard_fail_reasons": hard,
+        "state_path": str(STATE),
+        "benchmark_path": str(BENCH),
+    }
+    # reward.md result-JSON contract: performance always carries `cv`,
+    # implementation always carries `tests{passed,total}`.
+    if out["task_type"] == "performance":
+        out["cv"] = bench.get("cv")          # None when this harness does not measure dispersion
+        if passed is not None and total is not None:
+            out["tests"] = {"passed": passed, "total": total}
+    else:
+        out["tests"] = ({"passed": passed, "total": total}
+                        if (passed is not None and total is not None)
+                        else {"passed": 0 if hard else 1, "total": 1})
+    REWARD.write_text(json.dumps(out, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    TEXT.write_text(f"{reward}\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/jit-source-arch-cache-key/task/tests/count_bench.py

@@ -0,0 +1,92 @@
+"""Distinct-identity count for the build-spec identity task.
+
+The metric is a deterministic count: over a fixed labeled workload of build-specs,
+how many DISTINCT identities does a module's ``identity_key`` produce? A conservative
+identity treats every incidental spelling as different and emits many identities; a
+normalizing identity collapses the equivalent spellings of each class down toward the
+number of true classes. The score is the ratio baseline_count / candidate_count, so
+fewer identities (for the same workload) is better -- but only while no two
+genuinely-different specs share an identity.
+
+Invoked one MODE per process. ``test.sh`` runs candidate and the frozen baseline and
+takes the ratio. No profiler / no numerics library -- it is a pure count.
+
+Modes:
+  candidate  count distinct identities from /app/repo/identity_key.py; print COUNT=<n>
+  baseline   same, using the frozen baseline module (KB_BASELINE_MODULE)
+  verify     (safety) confirm the candidate NEVER gives two different-class specs
+             the same identity; print VERIFY_OK / VERIFY_FAIL
+"""
+
+import os
+import sys
+
+from kb_identity_harness import (
+    build_labeled_workload,
+    count_distinct_keys,
+    find_false_merges,
+    load_candidate,
+    load_module,
+    true_class_count,
+)
+
+
+def _baseline_module():
+    path = os.environ.get("KB_BASELINE_MODULE", "/opt/verifier-baseline/identity_key.py")
+    return load_module(path)
+
+
+def mode_candidate():
+    workload = build_labeled_workload()
+    print(f"COUNT={count_distinct_keys(load_candidate(), workload)}")
+    return 0
+
+
+def mode_baseline():
+    workload = build_labeled_workload()
+    print(f"COUNT={count_distinct_keys(_baseline_module(), workload)}")
+    return 0
+
+
+def mode_verify():
+    workload = build_labeled_workload()
+    classes = true_class_count(workload)
+    cand = load_candidate()
+    base = _baseline_module()
+
+    cand_bad = find_false_merges(cand, workload)
+    if cand_bad:
+        sample = sorted((sorted(v), k) for k, v in cand_bad.items())[:3]
+        print(f"VERIFY_FAIL candidate false-merges distinct classes: {sample}")
+        return 1
+    # sanity: the frozen baseline must itself be false-merge free.
+    base_bad = find_false_merges(base, workload)
+    if base_bad:
+        print(f"VERIFY_FAIL baseline unexpectedly false-merges: {sorted(base_bad.values())[:3]}")
+        return 1
+
+    cand_count = count_distinct_keys(cand, workload)
+    base_count = count_distinct_keys(base, workload)
+    # work-evidence: the baseline emits (base_count - classes) identities more than
+    # there are true classes; a full normalizer removes those redundant identities.
+    redundant = base_count - classes
+    print(f"VERIFY_OK signatures={len(workload)} true_classes={classes} "
+          f"candidate_identities={cand_count} baseline_identities={base_count} "
+          f"baseline_redundant_identities={redundant}")
+    return 0
+
+
+MODES = {"candidate": mode_candidate, "baseline": mode_baseline, "verify": mode_verify}
+
+
+def main():
+    mode = sys.argv[1] if len(sys.argv) > 1 else "candidate"
+    fn = MODES.get(mode)
+    if fn is None:
+        print(f"unknown mode {mode!r}; expected one of {sorted(MODES)}")
+        sys.exit(2)
+    sys.exit(fn())
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/jit-source-arch-cache-key/task/tests/kb_identity_harness.py

@@ -0,0 +1,185 @@
+"""Shared harness for the build-spec identity task (CPU, pure Python).
+
+Provides: the candidate loader, the equivalence-rule tables (source normalization,
+no-op option tokens), a deterministic *labeled* workload of build-specs grouped into
+true equivalence classes, and helpers that turn a candidate ``identity_key`` into a
+partition of that workload so the verifier can count distinct identities and detect a
+false merge (two genuinely-different specs sharing an identity). Standard library
+only, so the metric -- the number of distinct identities produced over the workload --
+is a deterministic count that is identical on any machine.
+
+The ground truth is the class LABEL attached to every spec when the workload is built:
+two specs share a class iff they were generated as equivalent spellings of the same
+base. candidate / baseline / oracle are all judged against these labels, never against
+each other.
+"""
+
+import hashlib
+import importlib.util
+import os
+import re
+
+
+# --------------------------------------------------------------------------- #
+# Equivalence rules (also disclosed to the solver in instruction.md).
+# --------------------------------------------------------------------------- #
+# Source text: comments and surrounding whitespace do not change the built artifact,
+# so they are incidental. Everything else in the source text is meaningful.
+_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
+_LINE_COMMENT = re.compile(r"//[^\n]*")
+
+# Option tokens equal to a build default; each is equivalent to the token being absent.
+NOOP_OPTIONS = {"o0", "dbgoff", "std0"}
+
+
+def canon_source(text):
+    """Canonical form of a source text: strip comments, collapse whitespace runs."""
+    text = _BLOCK_COMMENT.sub(" ", text)
+    text = _LINE_COMMENT.sub(" ", text)
+    return " ".join(text.split())
+
+
+def canon_options(options):
+    """Canonical option set: drop no-op defaults, de-duplicate, sort (order-free)."""
+    kept = {o for o in (options or []) if o not in NOOP_OPTIONS}
+    return sorted(kept)
+
+
+def _with_line_comment(source):
+    return source + "   // tuned build\n"
+
+
+def _with_block_comment(source):
+    return "/* rev2 */\n" + source + "\n\n  "
+
+
+def repo_dir():
+    return os.environ.get("KB_REPO_DIR", "/app/repo")
+
+
+def load_candidate():
+    """Import the candidate module from the repo under test."""
+    path = os.path.join(repo_dir(), "identity_key.py")
+    spec = importlib.util.spec_from_file_location("candidate_identity_key", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    if not hasattr(mod, "identity_key"):
+        raise AttributeError(f"{path} does not define identity_key")
+    return mod
+
+
+def load_module(path):
+    # deterministic module name derived from the path (no salted builtin hash()).
+    digest = hashlib.sha1(path.encode("utf-8")).hexdigest()[:12]
+    spec = importlib.util.spec_from_file_location("kb_identity_mod_" + digest, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+# --------------------------------------------------------------------------- #
+# Labeled workload: 12 true classes, each emitted as 4 equivalent spellings.
+# Distinct classes differ in at least one meaning-bearing field (source text /
+# target profile / effective option / toolchain tag / requested variant set).
+# classes 0 and 1 differ ONLY in target profile -- a normalizer that drops the target
+# merges them, which is a false merge (a wrong-target artifact would be reused).
+# --------------------------------------------------------------------------- #
+SRC_A = "o[i] = a[i] * b[i];"
+SRC_B = "o[i] = a[i] + b[i];"
+SRC_C = "o[i] = a[i] - b[i];"
+SRC_D = "acc = acc + a[k] * b[k];"
+SRC_E = "o[i] = a[i] > 0 ? a[i] : 0;"
+SRC_F = "o[i] = a[i] / b[i];"
+
+# base = (source, target, effective_options, toolchain, variants)
+CLASS_BASES = [
+    (SRC_A, "p80", (),             "v1", ()),           # 0  (target-trap A)
+    (SRC_A, "p90", (),             "v1", ()),           # 1  (target-trap B: only target differs from 0)
+    (SRC_B, "p80", (),             "v1", ()),           # 2  distinct source
+    (SRC_C, "p80", (),             "v1", ()),           # 3
+    (SRC_C, "p80", ("fast",),      "v1", ()),           # 4  effective option vs 3
+    (SRC_D, "p80", ("o3",),        "v1", ()),           # 5
+    (SRC_D, "p80", ("o2",),        "v1", ()),           # 6  different effective option value vs 5
+    (SRC_D, "p80", ("o3",),        "v2", ()),           # 7  different toolchain tag vs 5
+    (SRC_E, "p80", (),             "v1", ()),           # 8
+    (SRC_E, "p80", (),             "v1", ("kA",)),       # 9  variant present vs 8
+    (SRC_E, "p80", (),             "v1", ("kB", "kC")),  # 10 different variant set vs 9
+    (SRC_F, "p86", ("fast", "o3"), "v1", ()),           # 11 third target + two options
+]
+
+
+def _spellings(base):
+    """Return four equivalent-but-differently-spelled specs for one class.
+
+    All four normalize to the same spec (they differ only in source comments/whitespace,
+    option order, redundant no-op options, incidental build annotations, and requested
+    variant order), yet all four are byte-distinct so a conservative identity produces
+    four identities.
+    """
+    source, target, options, toolchain, variants = base
+    opts = list(options)
+    vs = list(variants)
+
+    def build_spec(src, opt_list, build=None, var_list=None):
+        d = {"source": src, "target": target, "options": list(opt_list), "toolchain": toolchain}
+        if var_list:
+            d["variants"] = list(var_list)
+        if build is not None:
+            d["build"] = build
+        return d
+
+    # S0: canonical source, options sorted, variants sorted, no build annotations.
+    s0 = build_spec(source, sorted(opts), var_list=sorted(vs))
+    # S1: source carries a trailing line comment + reflowed spacing (ignored).
+    s1 = build_spec(_with_line_comment(source), sorted(opts), var_list=sorted(vs))
+    # S2: options in a different ORDER + a redundant no-op token; a non-semantic build
+    #     annotation block; requested variants in a different order.
+    s2 = build_spec(source, list(reversed(opts)) + ["o0"],
+                    build={"tmpdir": "/tmp/b_" + target, "ts": 1700000000},
+                    var_list=list(reversed(vs)))
+    # S3: source with a block comment + extra newlines; options reversed with a DUPLICATE
+    #     of the first option (when present) + a different no-op token; a different build.
+    dup = [opts[0]] if opts else []
+    s3 = build_spec(_with_block_comment(source), list(reversed(opts)) + dup + ["dbgoff"],
+                    build={"tmpdir": "/tmp/x", "ts": 1700000001, "host": "node7"},
+                    var_list=list(reversed(vs)))
+    return [s0, s1, s2, s3]
+
+
+def build_labeled_workload():
+    """Deterministic list of ``(class_id, spec)`` pairs (48 = 12 classes x 4)."""
+    workload = []
+    for class_id, base in enumerate(CLASS_BASES):
+        for spec in _spellings(base):
+            workload.append((class_id, spec))
+    return workload
+
+
+def true_class_count(workload):
+    return len({class_id for class_id, _ in workload})
+
+
+# --------------------------------------------------------------------------- #
+# Turn a candidate identity function into a partition of the workload.
+# --------------------------------------------------------------------------- #
+def key_to_classes(module, workload):
+    """Map each produced identity -> the set of true class ids that landed on it."""
+    mapping = {}
+    for class_id, spec in workload:
+        key = module.identity_key(spec)
+        mapping.setdefault(key, set()).add(class_id)
+    return mapping
+
+
+def find_false_merges(module, workload):
+    """Return {identity: {class_ids}} for identities shared by >1 true class.
+
+    A non-empty result is a correctness failure: two genuinely different specs were
+    given the same identity.
+    """
+    return {k: v for k, v in key_to_classes(module, workload).items() if len(v) > 1}
+
+
+def count_distinct_keys(module, workload):
+    """Number of distinct identities the candidate produces over the workload."""
+    return len({module.identity_key(spec) for _, spec in workload})

tasks/kfc/jit-source-arch-cache-key/task/tests/ref_speedup.caveat.md

@@ -0,0 +1,29 @@
+# ref_speedup 硬件/环境 caveat(开源版新增,不改变判分逻辑)
+
+`ref_speedup.txt` 里的 **4.0** 是 oracle 标定常量,判分时只读、不重跑 oracle:
+
+    reward = min(1.0, ln(speedup/ref_speedup)/ln(ref_speedup)) if speedup > ref_speedup else 0.0
+
+`tests/test.sh` 的解析顺序是 **`tests/ref_speedup.txt` → `/opt/verifier-correctness-manifest.json` → 1.0**;
+回落到 1.0 会让所有 reward 归 0,所以这个文件必须存在且 > 1。
+
+## 标定条件
+
+- 硬件:**the authoring CPU lane (Intel Sapphire Rapids)**
+- 运行栈:`torch 2.7.0`(原始私有基座声明 torch 2.5.1/triton 3.1.0,任务 overlay 又 `pip install torch==2.7.0`,锚点即在 2.7.0 下标定)
+- 线程:`OMP/MKL/OPENBLAS_NUM_THREADS=1`(计时稳定性的一部分,已写进镜像 ENV)
+
+## 硬件不一致时如何重标
+
+verifier 原生支持模式分派,参考实现**按路径传入、从不烤进镜像**:
+
+```bash
+docker run --rm -v "$PWD/tests:/tests:ro" -v "<放 oracle.patch 的目录>:/patches:ro" \
+  -e KERNELBENCH_VERIFY_MODE=oracle -e KERNELBENCH_ORACLE_PATCH=/patches/oracle.patch \
+  fai/kfc-jit-source-arch-cache-key:oss bash /tests/test.sh
+# 从 /logs/verifier/ 读实测 speedup(建议 >=3 次取中位数),写回 tests/ref_speedup.txt
+```
+
+自证:`noop`(不打补丁)应 ≈1.0 → 被门到 0;`negative`(`KERNELBENCH_NEGATIVE_PATCH=`)必须 0。
+
+参考实现:见本包 `solution/oracle.patch`(reviewer-only,已被 `.dockerignore` 排除,不进镜像)。

tasks/kfc/jit-source-arch-cache-key/task/tests/ref_speedup.txt

@@ -0,0 +1 @@
+4.0

tasks/kfc/jit-source-arch-cache-key/task/tests/test.sh

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+# Verifier for jit-source-arch-cache-key (stable identity for a build-spec).
+# Pattern A, ACCELERATION lane. Deterministic value axis = recompile_count = number of
+# DISTINCT identities produced over a fixed labeled workload of build-specs. speedup =
+# baseline_recompiles / candidate_recompiles (= baseline_distinct_identities /
+# candidate_distinct_identities). Pure-Python stdlib -> a plain count, no profiler
+# needed. A false merge (two different-class specs sharing an identity -- e.g. two specs
+# differing only in target profile) is a hard correctness failure -> reward 0.
+# Modes: candidate|noop|oracle|negative
+set -uo pipefail
+# The harness may exec this in a NON-login shell; pin PATH so python3
+# resolves regardless of the base's default profile.
+export PATH=/opt/kernelbench-venv/bin:/usr/local/bin:/usr/bin:/bin:$PATH
+TESTS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO=/app/repo
+LOG=/logs/verifier
+mkdir -p "$LOG"
+MODE="${KERNELBENCH_VERIFY_MODE:-candidate}"
+CAND_FILE="$REPO/identity_key.py"
+export KB_CANDIDATE_MODULE="$CAND_FILE"
+export KB_BASELINE_MODULE=/opt/verifier-baseline/identity_key.py
+
+HARD=(); add_hard(){ HARD+=("$1"); }
+correctness_ok=true; trusted_restore_ok=true; hidden_correctness_ok=true
+baseline_ok=true; benchmark_ok=true; anti_cheat_ok=true
+expected_cases=12; actual_cases=0
+speedup=1.0; ref_speedup=1.0; hw="cpu"; cand_keys=0; base_keys=0
+
+cd "$REPO" 2>/dev/null || { add_hard "repo_missing"; correctness_ok=false; }
+
+if [ "$MODE" = "oracle" ] && [ -n "${KERNELBENCH_ORACLE_PATCH:-}" ]; then
+  # reviewer-only mode: reset the working tree to the frozen baseline so several
+  # modes running back-to-back in one container session each start clean. candidate/noop
+  # NEVER resets (this branch is skipped for them), so a solver session is untouched.
+  git -C "$REPO" checkout -- . 2>/dev/null || true; git -C "$REPO" clean -fdq 2>/dev/null || true
+  git -C "$REPO" apply "$KERNELBENCH_ORACLE_PATCH" 2>"$LOG/oracle_apply.log" || add_hard "oracle_apply_failed"
+fi
+if [ "$MODE" = "negative" ] && [ -n "${KERNELBENCH_NEGATIVE_PATCH:-}" ]; then
+  git -C "$REPO" checkout -- . 2>/dev/null || true; git -C "$REPO" clean -fdq 2>/dev/null || true
+  git -C "$REPO" apply "$KERNELBENCH_NEGATIVE_PATCH" 2>"$LOG/negative_apply.log" || true
+fi
+
+# anti-cheat: only identity_key.py may change
+git -C "$REPO" status --porcelain 2>/dev/null | awk '{print $2}' > "$LOG/anti_cheat_changed_files.txt"
+while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  case "$f" in
+    identity_key.py) : ;;
+    *__pycache__*) : ;;
+    *) anti_cheat_ok=false; add_hard "forbidden_edit_path:$f" ;;
+  esac
+done < "$LOG/anti_cheat_changed_files.txt"
+
+# anti-cheat: the normalization must be implemented in plain Python. Forbid pulling
+# in a tensor/graph framework or reading the hidden workload/reference harness.
+if [ -f "$CAND_FILE" ] && grep -Eq "cupy|jax|jaxlib|torch|triton|tensorflow|kb_identity_harness|test_identity_key|import[[:space:]]+tests|from[[:space:]]+tests" "$CAND_FILE"; then
+  anti_cheat_ok=false; add_hard "forbidden_framework_or_harness_reference"
+fi
+
+# trusted restore: hidden suite ships in tests/ payload (fresh at scoring)
+for f in test_identity_key.py count_bench.py kb_identity_harness.py; do
+  [ -f "$TESTS_DIR/$f" ] || { trusted_restore_ok=false; add_hard "hidden_supplement_missing:$f"; }
+done
+
+# ref_speedup: prefer the tests/-local override (uploaded fresh -> recalibrate without rebuild)
+if [ -f "$TESTS_DIR/ref_speedup.txt" ]; then
+  ref_speedup=$(tr -dc '0-9.' < "$TESTS_DIR/ref_speedup.txt")
+elif [ -f /opt/verifier-correctness-manifest.json ]; then
+  ref_speedup=$(python3 -c "import json;print(json.load(open('/opt/verifier-correctness-manifest.json')).get('ref_speedup',1.0))" 2>/dev/null || echo 1.0)
+fi
+hw="cpu:$(uname -m 2>/dev/null || echo unknown)"
+
+# correctness gate (pure python; no GPU): stable string + no false merge properties.
+if [ "$correctness_ok" = true ]; then
+  ( cd "$TESTS_DIR" && python3 test_identity_key.py ) > "$LOG/correctness.log" 2>&1
+  crc=$?
+  actual_cases=$(grep -cE '^CASE_PASS ' "$LOG/correctness.log" 2>/dev/null); actual_cases=${actual_cases:-0}
+  if [ "$crc" -ne 0 ] || [ "$actual_cases" -lt "$expected_cases" ]; then
+    hidden_correctness_ok=false; correctness_ok=false; add_hard "hidden_correctness_failed"
+  fi
+fi
+
+# benchmark: (1) confirm the candidate never gives two different-class signatures the
+# same identity (safety), then (2) count distinct identities for candidate vs the
+# frozen baseline over the fixed workload; speedup = base_keys / cand_keys.
+parse_count(){ sed -n 's/^COUNT=//p' "$1" 2>/dev/null | head -1; }
+if [ "$correctness_ok" = true ] && [ -f "$KB_BASELINE_MODULE" ]; then
+  ( cd "$TESTS_DIR" && python3 count_bench.py verify ) > "$LOG/verify.log" 2>&1
+  if [ $? -ne 0 ] || ! grep -q '^VERIFY_OK' "$LOG/verify.log"; then
+    benchmark_ok=false; add_hard "candidate_false_merge"
+  fi
+  if [ "$benchmark_ok" = true ]; then
+    ( cd "$TESTS_DIR" && python3 count_bench.py candidate ) > "$LOG/cand.out.log" 2>&1
+    ( cd "$TESTS_DIR" && python3 count_bench.py baseline ) > "$LOG/base.out.log" 2>&1
+    cand_keys=$(parse_count "$LOG/cand.out.log"); cand_keys=${cand_keys:-0}
+    base_keys=$(parse_count "$LOG/base.out.log"); base_keys=${base_keys:-0}
+    if [ -z "$cand_keys" ] || [ "$cand_keys" -le 0 ] 2>/dev/null || [ -z "$base_keys" ] || [ "$base_keys" -le 0 ] 2>/dev/null; then
+      benchmark_ok=false; add_hard "distinct_identity_count_unparsed"
+    else
+      speedup=$(python3 -c "print(f'{$base_keys/$cand_keys:.5f}')")
+    fi
+  fi
+else
+  benchmark_ok=false
+fi
+
+HARD_JSON="[]"; if [ ${#HARD[@]} -gt 0 ]; then HARD_JSON=$(printf '"%s",' "${HARD[@]}"); HARD_JSON="[${HARD_JSON%,}]"; fi
+DIAG_TAIL=""
+if [ "$correctness_ok" = false ] && [ -f "$LOG/correctness.log" ]; then
+  DIAG_TAIL=$(tail -60 "$LOG/correctness.log" | sed 's/"/\\"/g' | tr '\n' '\t' | sed 's/\t/\\n/g')
+fi
+cat > "$LOG/verifier_state.json" <<JSON
+{"schema_version":"kernelbench_verifier_state_v1","task_kind":"acceleration",
+ "correctness_ok":$correctness_ok,"trusted_restore_ok":$trusted_restore_ok,
+ "hidden_correctness_ok":$hidden_correctness_ok,"baseline_ok":$baseline_ok,
+ "benchmark_ok":$benchmark_ok,"anti_cheat_ok":$anti_cheat_ok,
+ "hard_fail_reasons":$HARD_JSON,
+ "expected_case_count":$expected_cases,"actual_case_count":$actual_cases,
+ "expected_benchmark_count":1,"actual_benchmark_count":1,
+ "actual_hardware_type":"$hw","mode":"$MODE",
+ "work_evidence_notes":["identity suite $actual_cases/$expected_cases ok","distinct identities candidate=$cand_keys baseline=$base_keys speedup=$speedup","correctness_tail:${DIAG_TAIL}"]}
+JSON
+cat > "$LOG/correctness_results.json" <<JSON
+{"schema_version":"kernelbench_correctness_results_v1",
+ "suites":[{"name":"hidden-identity-suite","visibility_class":"hidden_supplement","expected_case_count":$expected_cases,"actual_case_count":$actual_cases,"passed":$actual_cases,"failed":$((expected_cases-actual_cases)),"hard_fail_reasons":$HARD_JSON}],
+ "correctness_ok":$correctness_ok,"trusted_restore_ok":$trusted_restore_ok,"hidden_correctness_ok":$hidden_correctness_ok}
+JSON
+cat > "$LOG/benchmark_results.json" <<JSON
+{"schema_version":"kernelbench_benchmark_results_v1","task_kind":"acceleration","metric":"recompile_count",
+ "direction":"higher_is_better",
+ "workloads":[{"name":"buildspec-identity-count","speedup":$speedup,"candidate_recompiles":$cand_keys,"baseline_recompiles":$base_keys,"completion_counters":{"cases":"$actual_cases/$expected_cases"}}],
+ "aggregate_speedup":$speedup,"ref_speedup":$ref_speedup,"actual_hardware_type":"$hw"}
+JSON
+python3 "$TESTS_DIR/compute_reward.py" 2>/dev/null || python3 /tests/compute_reward.py 2>/dev/null || true
+REW=$(tr -d '[:space:]' < "$LOG/reward.txt" 2>/dev/null)
+echo "MODE=$MODE cases=$actual_cases/$expected_cases cand_recompiles=$cand_keys base_recompiles=$base_keys speedup=$speedup ref=$ref_speedup hw=$hw reward=$REW"
+[ -n "$REW" ] && exit 0 || exit 1

tasks/kfc/jit-source-arch-cache-key/task/tests/test_identity_key.py

@@ -0,0 +1,184 @@
+"""Correctness suite for the build-spec identity contract.
+
+Each case prints "CASE_PASS <name>" or "CASE_FAIL <name>: <reason>". The runner counts
+CASE_PASS lines. Pure standard library.
+
+Every case tests a *safety* / determinism property that any acceptable identity must
+satisfy: it returns a stable string, and it NEVER gives two genuinely-different specs
+the same identity. (Collapsing equivalent spellings is rewarded by the distinct-identity
+count, not gated here -- the conservative baseline, which collapses nothing, is still
+correct.)
+"""
+
+import sys
+import traceback
+
+from kb_identity_harness import (
+    build_labeled_workload,
+    find_false_merges,
+    load_candidate,
+)
+
+CASES = []
+
+
+def case(fn):
+    CASES.append(fn)
+    return fn
+
+
+def spec(source, target, options=None, toolchain="v1", variants=None, build=None):
+    d = {"source": source, "target": target, "toolchain": toolchain}
+    if options is not None:
+        d["options"] = list(options)
+    if variants is not None:
+        d["variants"] = list(variants)
+    if build is not None:
+        d["build"] = dict(build)
+    return d
+
+
+def _key(mod, s):
+    k = mod.identity_key(s)
+    if not isinstance(k, str) or not k:
+        raise AssertionError(f"identity_key must return a non-empty str, got {k!r}")
+    return k
+
+
+@case
+def returns_string_for_various(mod):
+    samples = [
+        spec("o[i]=a[i]*b[i];", "p80"),
+        spec("o[i]=a[i]+b[i];", "p90", options=["fast"], variants=["kA"]),
+        spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v2", build={"tmpdir": "/tmp/x"}),
+        {"source": "x=y;", "target": "p80"},  # minimal spec (no options/toolchain/variants/build)
+    ]
+    for s in samples:
+        _key(mod, s)
+
+
+@case
+def deterministic_repeat_same_object(mod):
+    s = spec("o[i]=a[i]*b[i];", "p80", options=["o3"])
+    if _key(mod, s) != _key(mod, s):
+        raise AssertionError("identity not stable across repeated calls on the same object")
+
+
+@case
+def deterministic_fresh_build(mod):
+    a = spec("acc+=a[k]*b[k];", "p80", options=["o3"], variants=["kA"])
+    b = spec("acc+=a[k]*b[k];", "p80", options=["o3"], variants=["kA"])
+    if _key(mod, a) != _key(mod, b):
+        raise AssertionError("two independently built identical specs got different identities")
+
+
+@case
+def distinct_source_distinct_keys(mod):
+    a = spec("o[i]=a[i]*b[i];", "p80")
+    b = spec("o[i]=a[i]+b[i];", "p80")
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("different source text collided")
+
+
+@case
+def distinct_target_distinct_keys(mod):
+    # same source + options + toolchain, different target profile -> a different artifact.
+    a = spec("o[i]=a[i]*b[i];", "p80", options=["o3"])
+    b = spec("o[i]=a[i]*b[i];", "p90", options=["o3"])
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("specs for different target profiles collided (target dropped?)")
+
+
+@case
+def distinct_effective_option_distinct_keys(mod):
+    a = spec("o[i]=a[i]*b[i];", "p80", options=["fast"])
+    b = spec("o[i]=a[i]*b[i];", "p80", options=[])
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("an effective (non-default) option was ignored")
+
+
+@case
+def distinct_option_value_distinct_keys(mod):
+    a = spec("acc+=a[k]*b[k];", "p80", options=["o3"])
+    b = spec("acc+=a[k]*b[k];", "p80", options=["o2"])
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("two different option values were merged")
+
+
+@case
+def distinct_toolchain_distinct_keys(mod):
+    a = spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v1")
+    b = spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v2")
+    if _key(mod, a) == _key(mod, b):
+        raise AssertionError("different toolchain tags were merged (a stale artifact would be reused)")
+
+
+@case
+def distinct_variant_set_distinct_keys(mod):
+    a = spec("o[i]=a[i]>0?a[i]:0;", "p80")                       # no variants
+    b = spec("o[i]=a[i]>0?a[i]:0;", "p80", variants=["kA"])      # one variant
+    c = spec("o[i]=a[i]>0?a[i]:0;", "p80", variants=["kB", "kC"])  # a different variant set
+    keys = {_key(mod, a), _key(mod, b), _key(mod, c)}
+    if len(keys) != 3:
+        raise AssertionError("the requested variant set was ignored")
+
+
+@case
+def no_false_merge_full_workload(mod):
+    workload = build_labeled_workload()
+    bad = find_false_merges(mod, workload)
+    if bad:
+        sample = sorted((sorted(v), k) for k, v in bad.items())[:3]
+        raise AssertionError(f"identity shared by >1 true class (false merge): {sample}")
+
+
+@case
+def handles_edge_schema(mod):
+    empty_opts = spec("x=y;", "p80", options=[])           # explicit empty option set
+    no_opts = {"source": "x=y;", "target": "p80"}          # no options/toolchain/variants keys
+    with_build = spec("x=y;", "p80", build={"ts": 1})      # only an incidental build annotation
+    for s in (empty_opts, no_opts, with_build):
+        _key(mod, s)
+    # even at the degenerate schema, two specs for different targets must stay distinct.
+    other_target = {"source": "x=y;", "target": "p90"}
+    if _key(mod, no_opts) == _key(mod, other_target):
+        raise AssertionError("degenerate specs for different targets collided")
+
+
+@case
+def many_distinct_specs_pairwise_distinct(mod):
+    specs = [
+        spec("o[i]=a[i]*b[i];", "p80"),
+        spec("o[i]=a[i]+b[i];", "p80"),
+        spec("o[i]=a[i]*b[i];", "p90"),                             # target differs from #0
+        spec("acc+=a[k]*b[k];", "p80", options=["o3"]),
+        spec("acc+=a[k]*b[k];", "p80", options=["o2"]),             # option value differs
+        spec("acc+=a[k]*b[k];", "p80", options=["o3"], toolchain="v2"),  # toolchain differs
+        spec("o[i]=a[i]/b[i];", "p86", options=["fast", "o3"]),
+        spec("o[i]=a[i]>0?a[i]:0;", "p80", variants=["kA"]),
+    ]
+    keys = [_key(mod, s) for s in specs]
+    if len(set(keys)) != len(specs):
+        raise AssertionError(f"expected {len(specs)} distinct identities, got {len(set(keys))}")
+
+
+def main():
+    mod = load_candidate()
+    passed = 0
+    for fn_case in CASES:
+        name = fn_case.__name__
+        try:
+            fn_case(mod)
+            passed += 1
+            print(f"CASE_PASS {name}")
+        except Exception as exc:  # noqa: BLE001
+            reason = f"{type(exc).__name__}: {exc}"
+            print(f"CASE_FAIL {name}: {reason.splitlines()[0][:300]}")
+            traceback.print_exc(file=sys.stderr)
+    total = len(CASES)
+    print(f"CASES_PASSED={passed}/{total}")
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/s4-fft-longconv/task/.dockerignore

@@ -0,0 +1,24 @@
+# .dockerignore MUST live at the BUILD CONTEXT ROOT (this directory) — docker/BuildKit does
+# NOT read environment/.dockerignore. Build with:  docker build -f environment/Dockerfile .
+# The reference implementation and every authoring artefact MUST NOT reach an image layer.
+*.patch
+oracle*
+negative*
+baseline2*
+scope_card.json
+degradation_manifest.json
+task_meta.json
+loop_map_entry.json
+job.yaml
+intermediates/
+_retrofit*
+sr_validate*
+leak_audit/
+self_check/
+variants/
+**/__pycache__/
+**/*.pyc
+*.bak
+*.bak_*
+*.pre_*
+**/*.pre_*

tasks/kfc/s4-fft-longconv/task/environment/Dockerfile

@@ -0,0 +1,153 @@
+# syntax=docker/dockerfile:1
+# =============================================================================
+# s4-fft-longconv — OPEN-SOURCE, self-contained task image
+#
+#   Task: make the declared scope faster while preserving its observable behaviour exactly.
+#         Editable scope (the ONLY files the scope gate allows to change):
+##     (declared in tests/test.sh)
+#
+#   FULLY PUBLIC — no internal mirror, no private base image, no prebuilt image.
+#   Needs 1 NVIDIA GPU to RUN (task.toml: gpus = 1, anchor calibrated on H20); no GPU to BUILD.
+#   Platform: linux/amd64 ONLY (official torch wheels are manylinux x86_64).
+#   Build context = this task directory (the Dockerfile lives in environment/).
+#
+# PROVENANCE of environment/repo/ (so anyone can re-derive it independently)
+#   recovered from: <internal registry>/kernelbench/wre-arch-s4-fft-longconv:v1@sha256:4215533296f1f970d093257f96b14d5cada8925b220966c41471b23d78c36542
+#   method: `crane manifest` -> the layers under 80 MB -> `crane blob` + tar, overlaid in
+#           manifest order; .git and any .wh..wh..opq marker dropped.
+#   verification: this task ships no oracle.patch (its reference exists only as a single-file variant), so the tree is pinned by the image digest above; the scope files and the import-origin gate are asserted at build.
+##
+# -----------------------------------------------------------------------------
+# BUILD  (needs outbound network for PyPI only — the working tree ships in this package)
+#     cd <...>/s4-fft-longconv/task
+#     docker build -f environment/Dockerfile -t fai/kfc-s4-fft-longconv:oss .
+#
+# RUN     docker run --rm --gpus all -it fai/kfc-s4-fft-longconv:oss
+# SCORE   docker run --rm --gpus all -v "$PWD/tests:/tests:ro" fai/kfc-s4-fft-longconv:oss bash /tests/test.sh
+#         # -> /logs/verifier/reward.json   (modes: candidate | noop | oracle | negative)
+#
+# 🔴 NO ANCHOR TO RE-CALIBRATE (binary reward)
+#   IMPLEMENTATION-CLASS TASK: reward is binary 0/1 (all correctness cases pass and no
+#   cheating -> 1.0, else 0.0). There is NO ref_speedup anchor, so nothing to re-calibrate.
+#   tests/test.sh scores correctness only; no ref_speedup.txt ships with this task and
+#   none is read. Timing IS still recorded as diagnostic metadata (and the in-image
+#   manifest keeps an oracle_ms record from the H20 validation run) but it never enters
+#   the reward. The reference implementation is solution/kernel_oracle.py, applied by
+#   copying it over the editable file; solution/kernel_negative.py is the known-bad
+#   control that MUST score 0. See tests/ref_speedup.caveat.md.
+#
+# VERSION ANCHORS
+#     CUDA 12.6 · Python 3.10 · torch 2.7.0 (cu126, brings its matching triton 3.3.x)
+#   The original private base declared torch 2.5.1 / triton 3.1.0 and the task overlay then ran
+#   `pip install torch==2.7.0` — 2.7.0 is therefore the version the anchor was calibrated under.
+# =============================================================================
+FROM nvidia/cuda:12.6.2-devel-ubuntu22.04
+
+# Compute capability you will RUN on (Triton JITs for the live device; this only affects
+# hand-built CUDA extensions): 8.0 A100 / 8.9 L40S-4090 / 9.0 H100-H20 / 10.0 B200
+ARG TORCH_CUDA_ARCH_LIST="9.0"
+ARG TORCH_VERSION=2.7.0
+
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC \
+    PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PIP_DISABLE_PIP_VERSION_CHECK=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential gcc-10 g++-10 cmake ninja-build pkg-config \
+        python3.10 python3.10-dev python3.10-venv python3-pip python-is-python3 \
+        git ca-certificates curl procps coreutils tar gzip vim less file jq \
+    && update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100 \
+    && update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 100 \
+    && rm -rf /var/lib/apt/lists/*
+
+# ---- venv at this EXACT path: tests/test.sh puts /opt/kernelbench-venv/bin at the head of PATH,
+#      and a bare python3 from anywhere else would not have torch. ----
+ENV VENV=/opt/kernelbench-venv
+RUN python3.10 -m venv "$VENV"
+ENV PATH=$VENV/bin:/usr/local/cuda/bin:$PATH \
+    TORCH_CUDA_ARCH_LIST=${TORCH_CUDA_ARCH_LIST}
+RUN pip install --no-cache-dir -U pip setuptools wheel
+RUN pip install --no-cache-dir --extra-index-url https://download.pytorch.org/whl/cu126 \
+        "torch==${TORCH_VERSION}" \
+ && python -c "import torch, triton; print('torch', torch.__version__, '| triton', triton.__version__); assert torch.__version__.startswith('2.7.0'), torch.__version__"
+
+# ---- the graded working tree. A REAL directory (not a symlink): the scope gate runs
+#      `git -C /app/repo status --porcelain`, which cannot see through a symlink. ----
+RUN mkdir -p /app/repo /app/.timer /app/workspace /logs/verifier /logs/agent /logs/artifacts
+COPY environment/repo/ /app/repo/
+COPY instruction.md /app/instruction.md
+
+# ---- the baseline commit = the diff base the scope gate compares against.
+#      🔴 core.fileMode=false is LOAD-BEARING, not hygiene: a shipped image in this corpus had
+#      core.fileMode=true while some files were 0775 on disk but 100644 in the index, so
+#      `git status --porcelain` reported phantom out-of-scope paths in EVERY mode and forced
+#      reward to 0. Setting it false at creation makes that class of defect impossible. ----
+RUN git config --global user.email "reviewer@fai-bench.local" \
+ && git config --global user.name "fai-bench" \
+ && git config --global init.defaultBranch main \
+ && git config --global --add safe.directory /app/repo \
+ && cd /app/repo \
+ && git init -q \
+ && git config core.fileMode false \
+ && printf '__pycache__/\n*.pyc\n' >> .gitignore \
+ && git add -A \
+ && git commit -qm "baseline (graded starting point)" \
+ && rm -rf .git/logs \
+ && test "$(git rev-list --count HEAD)" = "1" \
+ && test -z "$(git remote)" \
+ && test "$(git config --get core.fileMode)" = "false" \
+ && test -z "$(git status --porcelain)" \
+ && echo "[build] /app/repo: 1 commit, no remote, fileMode=false, clean tree"
+
+# ---- runtime contract (copied verbatim from the shipped image) ----
+COPY environment/runtime/entrypoint.sh /app/entrypoint.sh
+COPY environment/runtime/timer.sh /app/timer.sh
+RUN chmod 0755 /app/entrypoint.sh /app/timer.sh && chown root:root /app/entrypoint.sh /app/timer.sh
+COPY environment/runtime/run_dev_bench.sh /app/workspace/run_dev_bench.sh
+RUN chmod 0755 /app/workspace/run_dev_bench.sh
+
+# ---- the FROZEN anchor fallback. tests/test.sh prefers tests/ref_speedup.txt (mounted) and falls
+#      back to THIS path; keeping both consistent makes the resolution explicit. Only the constant. ----
+COPY environment/verifier-correctness-manifest.json /opt/verifier-correctness-manifest.json
+
+# ---- OPEN grading suite is NOT baked: tests/ (test.sh + compute_reward.py + the workload/harness
+#   + ref_speedup.txt) is MOUNTED FRESH at /tests when scoring. It ships in this package —
+#   open-source, but outside the image so the graded harness cannot be edited from the session.
+
+# ---- 🔴 ANTI-LEAK ASSERTS (author-side artifact denylist) ----
+RUN set -eu; rc=0; \
+    hits="$(find / -xdev -type f \( -name 'oracle*.patch' -o -name 'negative*.patch' \
+              -o -name 'baseline2*.patch' -o -name 'scope_card.json' -o -name 'kernel_oracle.py' \
+              -o -name 'degradation_manifest.json' \) 2>/dev/null | head -10)"; \
+    if [ -n "$hits" ]; then echo "BUILD_ASSERT_FAIL: a reference/authoring file is baked:"; echo "$hits"; rc=1; fi; \
+    for p in /opt/verifier /opt/strong_baseline /opt/negative /opt/ceiling /tests; do \
+      if [ -e "$p" ]; then echo "BUILD_ASSERT_FAIL: frozen-surface path baked: $p"; rc=1; fi; \
+    done; \
+    test "$rc" = 0; \
+    echo "[build] ANTI-LEAK ASSERTS PASS"
+
+ENV PYTHONPATH=/app/repo \
+    PYTHONDONTWRITEBYTECODE=1 \
+    OMP_NUM_THREADS=1 \
+    MKL_NUM_THREADS=1 \
+    OPENBLAS_NUM_THREADS=1 \
+    LD_LIBRARY_PATH=/opt/kernelbench-venv/lib/python3.10/site-packages/torch/lib:/usr/local/cuda/lib64:/usr/local/nvidia/lib64
+WORKDIR /app/repo
+
+# ---- build-time smoke: the graded module imports FROM /app/repo (the verifier asserts the same
+#      thing at scoring time via its import-origin gate) and the scope files are present. ----
+RUN python - <<'PY'
+import os, subprocess, sys
+sys.path.insert(0, "/app/repo")
+for f in ():
+    p = os.path.join("/app/repo", f)
+    assert os.path.isfile(p), f"scope file missing: {p}"
+    print("scope file present:", f, os.path.getsize(p), "B")
+print("NOTE: no importable scope module for this task; tests/test.sh owns the\n       import-origin gate at scoring time")
+n = subprocess.run(["git","-C","/app/repo","rev-list","--count","HEAD"],
+                   capture_output=True, text=True).stdout.strip()
+assert n == "1", f"git diff base broken (commits={n!r})"
+print("OK: scope files, import origin and git base all in place")
+PY
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+CMD ["tail","-f","/dev/null"]

tasks/kfc/s4-fft-longconv/task/environment/repo/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

tasks/kfc/s4-fft-longconv/task/environment/repo/gated_gelu.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+
+
+def gated_gelu(x: torch.Tensor, approximate: str = "none") -> torch.Tensor:
+    """Apply a gated GELU activation over the last dimension.
+
+    The input's last dimension is split in half. GELU is applied to the first
+    half and multiplied by the second half. This straightforward implementation
+    intentionally relies on ordinary PyTorch tensor operations.
+    """
+    if approximate not in ("none", "tanh"):
+        raise ValueError("approximate must be 'none' or 'tanh'")
+    if not x.is_cuda:
+        raise ValueError("x must be a CUDA tensor")
+    if x.dim() < 1:
+        raise ValueError("x must have at least one dimension")
+    if x.shape[-1] % 2 != 0:
+        raise ValueError("last dimension must be even")
+    d = x.shape[-1] // 2
+    return F.gelu(x[..., :d], approximate=approximate) * x[..., d:]

tasks/kfc/s4-fft-longconv/task/environment/repo/submission/kernel.py

@@ -0,0 +1,39 @@
+# Performance Optimization Task — submission entry point.
+#
+# Implement `causal_conv` to the contract in instruction.md, then make it as fast as possible.
+# This is the ONLY file you edit. The verifier grades numerical correctness first (bf16 output
+# within rtol=atol=2e-2 of a seeded fp32 reference), then latency on GPU (H20). A submission that
+# leaves NotImplementedError in place scores 0.
+
+import torch
+
+
+def causal_conv(u, k):
+    """Causal (non-circular) 1-D convolution of each input sequence with its channel's kernel.
+
+    Args:
+        u: bfloat16 tensor, shape [B, H, L] (B sequences, H channels, length L).
+        k: bfloat16 tensor, shape [H, L] (per-channel causal kernel, full length L).
+
+    For every (b, h) and output position t in [0, L):
+
+        y[b, h, t] = sum_{s=0}^{t} k[h, t - s] * u[b, h, s]
+
+    i.e. the linear convolution of u[b,h] with k[h], truncated to the first L samples (a causal
+    system: output t depends only on inputs s <= t; no wrap-around from the tail of the sequence).
+    Compute the accumulation in fp32, then cast the result back to bf16.
+
+    Returns:
+        bfloat16 tensor, shape [B, H, L].
+    """
+    raise NotImplementedError("implement causal_conv to the contract in instruction.md")
+
+
+def custom_kernel(data):
+    """Entry point the verifier calls.
+
+    data = (u, k, config) where config = {"L": int}. Already wired to call causal_conv and return
+    the convolved sequences.
+    """
+    u, k, config = data
+    return causal_conv(u, k)

tasks/kfc/s4-fft-longconv/task/environment/runtime/entrypoint.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PATH=/opt/kernelbench-venv/bin:/root/.cargo/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+
+if [ -x /app/timer.sh ]; then
+  /app/timer.sh >/app/.timer/timer.log 2>&1 &
+fi
+
+if [ "$#" -gt 0 ]; then
+  exec "$@"
+fi
+
+exec /bin/bash -l

tasks/kfc/s4-fft-longconv/task/environment/runtime/run_dev_bench.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PATH=/opt/kernelbench-venv/bin:/root/.cargo/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+KERNELBENCH_VERIFY_MODE="${KERNELBENCH_VERIFY_MODE:-candidate}" bash /tests/test.sh

tasks/kfc/s4-fft-longconv/task/environment/runtime/timer.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PATH=/opt/kernelbench-venv/bin:/root/.cargo/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+mkdir -p /app/.timer
+date -u +%FT%TZ > /app/.timer/start.txt
+remaining=${FRONTIER_REMAINING_SECS:-21600}
+printf '%s\n' "$remaining" > /app/.timer/remaining_secs
+printf '%s\n' "$remaining" > /app/.timer/budget_secs
+printf '%s\n' "$$" > /app/.timer/timer.pid
+while true; do
+  sleep 60
+done

tasks/kfc/s4-fft-longconv/task/environment/verifier-correctness-manifest.json

@@ -0,0 +1 @@
+{"oracle_ms": 0.11348799988627434}

tasks/kfc/s4-fft-longconv/task/instruction.md

@@ -0,0 +1,84 @@
+# Performance Optimization Task
+
+You are given a clean Python workspace with a single editable file:
+
+```
+submission/kernel.py
+```
+
+This is the **only** file you may edit. Editing any other file (or importing an
+implementation from anywhere else) causes the whole task to score 0.
+
+## Objective
+
+`submission/kernel.py` ships a required function `causal_conv` whose body is **not implemented**
+(it raises `NotImplementedError`). Implement it to the contract below so it is numerically
+correct, then make it as fast as possible on the hidden benchmark workloads. Reward is measured on
+GPU (H20). Correctness is a hard prerequisite: a fast-but-wrong implementation, or one that still
+raises `NotImplementedError`, scores 0.
+
+## Interface contract (implement exactly this)
+
+### `causal_conv(u, k) -> y`
+
+A **causal** (non-circular) 1-D convolution of each input sequence with its channel's full-length
+kernel — the "convolution mode" of a long-kernel sequence layer.
+
+- `u`: `bfloat16` tensor, shape `[B, H, L]` (`B` sequences, `H` channels, length `L`).
+- `k`: `bfloat16` tensor, shape `[H, L]` (a per-channel causal kernel, full length `L`).
+
+For every `(b, h)` and output position `t` in `[0, L)`:
+
+```
+y[b, h, t] = sum_{s=0}^{t} k[h, t - s] * u[b, h, s]
+```
+
+This is the linear convolution of `u[b,h]` with `k[h]`, **truncated to the first `L` samples**. The
+system is causal: output `t` depends only on inputs `s <= t`. There is **no wrap-around** — the tail
+of the sequence must not fold back into early outputs (that would be a circular convolution, which
+is wrong). Accumulate in **fp32**, then cast the result back to `bf16`.
+
+### `custom_kernel(data) -> y`
+
+`data = (u, k, config)` where `config = {"L": int}`. Already wired to call `causal_conv(u, k)` and
+return `y`. You implement the primitive.
+
+## Correctness
+
+Outputs are compared against a seeded fp32 reference within `rtol = atol = 2e-2` across a hidden
+set of shapes spanning `L=1` (single tap), tiny `L`, odd / non-power-of-two `L`, odd channel
+counts, and a large regime (`L` up to ~2048). The causal boundary must be exact — a submission
+that reads future samples (e.g. a circular convolution with no zero-padding) fails the gate.
+Outputs must genuinely depend on the inputs (the grader runs the op on two different inputs of the
+same shape and rejects identical outputs).
+
+## Latency
+
+Once correct, the function is timed on GPU with CUDA events (block of medians, the `u` input
+regenerated every timed iteration; a warmup window is discarded). The primary benchmark uses a
+**long** sequence length `L`. Evaluating the convolution directly — an `O(L^2)` sum per output
+position, or equivalently a dense lower-triangular Toeplitz matrix apply — is correct but its cost
+grows with `L^2`. A full-length convolution can instead be evaluated in `O(L log L)`; expressing it
+so the work grows as `L log L` rather than `L^2` is the reference point. The score is dominated by
+the largest `L`.
+
+## Workload shape (what the hidden benchmark covers)
+
+- `bfloat16` `u [B, H, L]` and `k [H, L]`, with `L` up to ~2048, modest `B` and `H`, single GPU.
+- `L=1`, tiny, odd, and non-power-of-two shapes as well as large ones.
+- The score is dominated by the largest shapes, so a fast tiny case cannot offset a slow large one.
+
+## Rules
+
+- Edit only `submission/kernel.py`, and keep the `causal_conv` and `custom_kernel` signatures. Any
+  other change (or importing the answer from another module/file/package) scores 0.
+- Solve independently. Do **not** download, clone, fetch, or `pip install` any external
+  repository, kernel library, or reference implementation to obtain the answer; do **not** attempt
+  to bypass or disable the environment's network isolation (e.g. by unsetting proxy environment
+  variables or opening raw sockets). Any such action scores the whole task 0, regardless of
+  measured speed.
+- You may use `torch` and `triton` (both are installed). You do not need any other package.
+
+## 提交方式
+
+本题为**实现类,只有一次评分**。把改动**留在工作树里**即可 —— 直接编辑允许的文件,不需要 `bash /opt/loop/submit.sh`,也不需要 `git commit`(判分读工作树,仓库 HEAD 必须停在初始基线 commit 上;评分由结束后的 `tests/test.sh` 一次性给出)。

tasks/kfc/s4-fft-longconv/task/pre_artifacts.sh

@@ -0,0 +1,157 @@
+#!/bin/bash
+# ============================================================================
+# pre_artifacts.sh — kfc/s4-fft-longconv
+#
+# Run by the runner INSIDE this task's container AFTER the agent session ends and BEFORE
+# grading (spec §1.1).  It turns whatever the agent left behind into a portable artifact:
+#
+#   /logs/artifacts/model.patch      unified diff: WORKING TREE vs the baked baseline commit
+#   /logs/artifacts/model_files.txt  one changed/added ABSOLUTE path per line
+#
+# 🔴 IT NEVER COMMITS, and the task statement never asks the agent to (spec H3 — the one
+#    place we deliberately differ from deep-swe, whose pre_artifacts.sh diffs <base>..HEAD).
+#    Reason: grading reads the WORKING TREE.  `git status --porcelain` is the scope gate,
+#    `git checkout -q HEAD -- <scope>` re-materialises the baseline for the paired timing,
+#    and loop16's `submit.sh --finalize` plants the best iterate with read-tree +
+#    checkout-index while HEAD stays on the baked baseline.  A commit moves HEAD, the scope
+#    gate then sees nothing, `checkout HEAD -- scope` hands the CANDIDATE back as the
+#    "baseline" — and a correct solve scores 0.
+#    `git add -AN` (intent-to-add) is what makes NEW files appear in `git diff`: it stages
+#    names only, writes no tree, creates no commit and leaves HEAD exactly where it was.
+#
+# EXIT CODE IS ALWAYS 0.  A missing or empty artifact must not fail the round; the verifier
+# scores the container on its own terms and gives 0 by itself.
+#
+# READ-ONLY ON THE GRADED STATE.  `add -AN` is done against a COPY of the repo's index
+# (GIT_INDEX_FILE), so after this script the repo's .git/index is byte-identical and the
+# verifier — which runs after us — sees exactly the `git status --porcelain` it would have
+# seen if this script had never run.  No commit, no HEAD move, no working-tree write.
+#
+# CAPTURE ROOTS for THIS task — derived from the package, never assumed:
+#   /app/repo          git repo, HEAD == the 1-commit carved baseline
+#       evidence  Dockerfile:134: WORKDIR /app/repo
+#       evidence  Dockerfile:88: && cd /app/repo \
+#       evidence  Dockerfile:95: && test "$(git rev-list --count HEAD)" = "1" \
+#       evidence  test.sh:17: REPO=/app/repo
+#
+# Single root => model.patch is a bare `git diff --binary <baseline>` (no banner).
+# model_files.txt carries ABSOLUTE paths, corpus-wide, so the two forms stay parseable
+# by one reader.
+# ============================================================================
+set -uo pipefail
+
+OUT=/logs/artifacts
+PATCH="$OUT/model.patch"
+LIST="$OUT/model_files.txt"
+MULTI=0                 # 1 => several capture roots => each diff gets a banner line
+MAX_BLOB_KB=5120                # per-file cap for the tree-snapshot path (keeps the patch sane)
+
+mkdir -p "$OUT" 2>/dev/null || true
+: > "$PATCH" 2>/dev/null || true
+: > "$LIST"  2>/dev/null || true
+git config --global --add safe.directory '*' >/dev/null 2>&1 || true
+
+banner() {                 # $1=root $2=mode ; only when there is more than one root
+    if [ "$MULTI" = 1 ]; then
+        printf '# ==== pre_artifacts root=%s mode=%s ====\n' "$1" "$2" >> "$PATCH" 2>/dev/null
+    fi
+    return 0
+}
+
+list_add() {               # stdin: paths relative to $1 -> absolute, one per line
+    sed "s|^|${1%/}/|" >> "$LIST" 2>/dev/null || true
+    return 0
+}
+
+capture_git() {            # $1 = dir whose HEAD is the baked 1-commit baseline
+    root=$1
+    if [ ! -d "$root" ]; then echo "[pre_artifacts] SKIP (absent): $root"; return 0; fi
+    if ! git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        echo "[pre_artifacts] WARN $root has no .git -> falling back to a tree snapshot"
+        capture_tree "$root"
+        return 0
+    fi
+    # 🔴 SCRATCH INDEX. `add -AN` has to touch an index, and the verifier runs AFTER us and
+    # reads `git status --porcelain`; turning `?? newdir/` into `A newdir/file` there could
+    # flip a scope gate either way. So copy the repo's index aside and stage into the COPY —
+    # the repo's own .git/index is byte-identical when we are done.
+    tmpi=$(mktemp -d /tmp/pre_artifacts.XXXXXX 2>/dev/null) || tmpi=""
+    gd=$(git -C "$root" rev-parse --absolute-git-dir 2>/dev/null || true)
+    if [ -z "$gd" ]; then
+        gd=$(git -C "$root" rev-parse --git-dir 2>/dev/null || true)
+        case "$gd" in /*) ;; ?*) gd="$root/$gd" ;; esac
+    fi
+    if [ -n "$tmpi" ] && [ -n "$gd" ] && [ -f "$gd/index" ] && cp "$gd/index" "$tmpi/index" 2>/dev/null; then
+        GIT_INDEX_FILE="$tmpi/index"; export GIT_INDEX_FILE
+    else
+        echo "[pre_artifacts] WARN no scratch index for $root; staging into the real index"
+    fi
+    git -C "$root" add -AN . >/dev/null 2>&1 || true
+    base=HEAD
+    if ! git -C "$root" rev-parse -q --verify HEAD >/dev/null 2>&1; then
+        base=$(git -C "$root" hash-object -w -t tree /dev/null 2>/dev/null)
+        echo "[pre_artifacts] WARN $root has no commit; diffing against the empty tree"
+    else
+        n=$(git -C "$root" rev-list --count HEAD 2>/dev/null || echo 0)
+        case "$n" in ''|*[!0-9]*) n=0 ;; esac
+        if [ "$n" -gt 1 ]; then
+            base=$(git -C "$root" rev-list --max-parents=0 HEAD 2>/dev/null | tail -1)
+            echo "[pre_artifacts] 🔴 $root HEAD has $n commits but the contract says 1:"
+            echo "[pre_artifacts]    the agent committed. Diffing from the ROOT commit ${base} so"
+            echo "[pre_artifacts]    nothing is lost — but grading reads the WORKING TREE, so a moved"
+            echo "[pre_artifacts]    HEAD can still zero an otherwise-correct solve."
+        fi
+    fi
+    [ -n "${base:-}" ] || base=HEAD
+    banner "$root" "git-diff-vs-baseline"
+    git -C "$root" diff --binary "$base" >> "$PATCH" 2>/dev/null || true
+    names=$(git -C "$root" diff --name-only "$base" 2>/dev/null)
+    echo "[pre_artifacts] $root: baseline $(git -C "$root" rev-parse --short "$base" 2>/dev/null), $(printf '%s\n' "$names" | grep -c . ) changed path(s)"
+    unset GIT_INDEX_FILE
+    [ -n "$tmpi" ] && rm -rf "$tmpi" 2>/dev/null
+    printf '%s\n' "$names" | grep -v '^$' | list_add "$root"
+    return 0
+}
+
+capture_tree() {           # $1 = editable dir that is NOT a git repo -> full snapshot
+    root=$1
+    if [ ! -d "$root" ]; then echo "[pre_artifacts] SKIP (absent): $root"; return 0; fi
+    tmp=$(mktemp -d /tmp/pre_artifacts.XXXXXX 2>/dev/null) || return 0
+    if git init -q "$tmp/snap" >/dev/null 2>&1; then
+        GD="$tmp/snap/.git"
+        empty=$(git --git-dir="$GD" hash-object -w -t tree /dev/null 2>/dev/null)
+        ( cd "$root" 2>/dev/null || exit 0
+          find . -name .git -prune -o -name __pycache__ -prune -o \
+                 -type f ! -name '*.pyc' ! -name '*.pyo' -size -"${MAX_BLOB_KB}"k -print0 \
+            2>/dev/null \
+          | GIT_DIR="$GD" GIT_WORK_TREE="$root" xargs -0 -r git add -f -- ) >/dev/null 2>&1 || true
+        banner "$root" "tree-snapshot-not-a-git-repo"
+        GIT_DIR="$GD" GIT_WORK_TREE="$root" git diff --cached --binary "$empty" \
+            >> "$PATCH" 2>/dev/null || true
+    else
+        echo "[pre_artifacts] WARN could not stage a snapshot index for $root"
+    fi
+    rm -rf "$tmp" 2>/dev/null || true
+    all=$( cd "$root" 2>/dev/null && find . -name .git -prune -o -name __pycache__ -prune -o \
+              -type f -print 2>/dev/null | sed 's|^\./||' )
+    printf '%s\n' "$all" | grep -v '^$' | list_add "$root"
+    big=$( cd "$root" 2>/dev/null && find . -name .git -prune -o -type f \
+              -size +"${MAX_BLOB_KB}"k -print 2>/dev/null | grep -c . )
+    echo "[pre_artifacts] $root: tree snapshot (no git baseline here), $(printf '%s\n' "$all" | grep -c . ) file(s)"
+    if [ "${big:-0}" != 0 ]; then
+        echo "[pre_artifacts] NOTE $big file(s) under $root exceed ${MAX_BLOB_KB}KB: listed in"
+        echo "[pre_artifacts]      model_files.txt but their bytes are NOT inlined into model.patch."
+    fi
+    return 0
+}
+
+capture_git "/app/repo"
+bytes=$(wc -c < "$PATCH" 2>/dev/null || echo 0)
+case "$bytes" in ''|*[!0-9]*) bytes=0 ;; esac
+echo "[pre_artifacts] captured $bytes bytes, $(wc -l < "$LIST" 2>/dev/null || echo 0) path(s)"
+if [ "$bytes" -gt 67108864 ]; then
+    echo "[pre_artifacts] 🔴 NOTE model.patch is $bytes bytes (> 64MiB). Almost certainly a build"
+    echo "[pre_artifacts]    product or a checkpoint was left inside a capture root — which is also"
+    echo "[pre_artifacts]    an out-of-scope edit the verifier's scope gate will punish."
+fi
+exit 0

tasks/kfc/s4-fft-longconv/task/solution/README.md

@@ -0,0 +1,13 @@
+# solution/ — reviewer-only 参考实现
+
+本目录里的补丁**不进镜像**(已被上下文根的 `.dockerignore` 排除)、**判分不运行**,
+只在两种场合用:
+
+1. **重标定锚点**(换硬件后):见 `../tests/ref_speedup.caveat.md`
+   ```
+   -e KERNELBENCH_VERIFY_MODE=oracle -e KERNELBENCH_ORACLE_PATCH=/patches/oracle.patch
+   ```
+2. **自证挖洞树的正确性**:`git apply --check -p1 oracle.patch` 必须能干净打在
+   `../environment/repo/` 上(正向可、反向不可),这证明该树就是被计分的起始点。
+
+`negative.patch` 是已知坏例(必须得 0),`baseline2.patch` 是中间基线(若有)。

tasks/kfc/s4-fft-longconv/task/solution/kernel_negative.py

@@ -0,0 +1,19 @@
+# Reviewer-only NEGATIVE (not baked into the image): fast but WRONG. Uses a CIRCULAR convolution (FFT at
+# length L with no zero-padding) instead of the causal linear convolution. The missing zero-pad
+# lets the tail of the sequence wrap around into early outputs, so a position t reads "future"
+# samples via the wrap -- it violates causality and disagrees with the reference for any L > 1.
+# It is a single fast FFT pass, so it must FAIL the correctness gate (not the timing).
+import torch
+
+
+def causal_conv(u, k):
+    B, H, L = u.shape
+    uf = torch.fft.rfft(u.float(), n=L, dim=-1)             # WRONG: n=L -> circular, no padding
+    kf = torch.fft.rfft(k.float(), n=L, dim=-1).unsqueeze(0)
+    y = torch.fft.irfft(uf * kf, n=L, dim=-1)[..., :L]
+    return y.to(torch.bfloat16)
+
+
+def custom_kernel(data):
+    u, k, config = data
+    return causal_conv(u, k)

tasks/kfc/s4-fft-longconv/task/solution/kernel_oracle.py

@@ -0,0 +1,24 @@
+# Reviewer-only ORACLE (not baked into the image): the fast form. A causal 1-D convolution with a full-length
+# kernel is evaluated in O(L log L) via the FFT: zero-pad both operands to length >= 2L-1, take
+# the real FFT, multiply in the frequency domain, inverse-FFT, and keep the first L samples (the
+# zero-padding makes the circular convolution equal the causal linear convolution). Grounded in
+# TRAIN.ARCH.SSM: state-spaces/s4 — the S4/S4D "convolution mode" materializes the SSM kernel of
+# length L and applies it to the sequence with an FFT (the global long convolution), instead of
+# stepping the O(L^2) recurrence/direct sum. Never baked; calibrates oracle_ms + proves headroom.
+import torch
+
+
+def causal_conv(u, k):
+    B, H, L = u.shape
+    n = 1
+    while n < 2 * L:
+        n <<= 1
+    uf = torch.fft.rfft(u.float(), n=n, dim=-1)
+    kf = torch.fft.rfft(k.float(), n=n, dim=-1).unsqueeze(0)  # [1,H,.]
+    y = torch.fft.irfft(uf * kf, n=n, dim=-1)[..., :L]
+    return y.to(torch.bfloat16)
+
+
+def custom_kernel(data):
+    u, k, config = data
+    return causal_conv(u, k)

tasks/kfc/s4-fft-longconv/task/solution/solve.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# solution/solve.sh — kfc/s4-fft-longconv
+# 把本题的参考实现落成「与 agent 提交等价」的形态,让 oracle 验证从手工传环境变量
+# 变成一条命令。本文件不进镜像(没有任何 COPY 取 solution/),判分器也不会运行它。
+#
+# oracle 形态 : 单文件变体(file)。tests/test.sh 的模式分派走 KERNELBENCH_ORACLE_FILE 槽位:
+#               cp "$KERNELBENCH_ORACLE_FILE" "$REPO/$SUB"
+#               产物(reviewer-only;本脚本只读,一个字节都不改):
+#                 solution/kernel_negative.py, solution/kernel_oracle.py
+# $REPO       : /app/repo                      (tests/test.sh: REPO=/app/repo)
+# 被计分单元  : /app/repo/submission/kernel.py
+#               来源:tests/test.sh 的 SUB="submission/kernel.py"
+# 落地方式    : cp <变体> $REPO/submission/kernel.py —— 只改工作树,不 commit
+#
+# 🔴 为什么绝不 commit(规范 H3):判分读**工作树** —— `git status --porcelain` 是 scope
+#    硬闸门,`git checkout -q HEAD -- <scope>` 取基线,且镜像自证 /app/repo 的 HEAD 恰好
+#    只有 1 个 commit(那就是挖洞基线)。一旦 commit,HEAD 前移 → 闸门看不到改动、
+#    `checkout HEAD -- scope` 把 candidate 当成基线 → 正确解被判 0。
+#    本脚本落地后会自己断言 HEAD 与 commit 数没变。
+#
+# ── 落地后判分的那条完整命令(同一个容器里跑完 3 步)────────────────────────
+#   PKG=<fai_bench>/tasks/kfc/s4-fft-longconv/task
+#   IMG=fai/kfc-s4-fft-longconv:oss
+#   # 1) 起容器。判分容器始终 --network=none;tests/ 和 solution/ 都**没有**烤进镜像
+#   #    (Dockerfile 里没有一条 COPY 取它们),所以这两个目录必须挂进来。
+#   #    该题 task.toml 声明 gpus=1;锚点的标定硬件/运行栈见 tests/ref_speedup.caveat.md
+#   docker run -d --name kfc-solve --network=none --gpus all \
+#     -v "$PKG/tests":/tests -v "$PKG/solution":/solution "$IMG"
+#   # 2) 落地参考实现到工作树(本脚本;不 commit)
+#   docker exec kfc-solve bash /solution/solve.sh
+#   # 3) 判分。KERNELBENCH_VERIFY_MODE 必须留在默认的 candidate —— 这就是 agent 的
+#   #    真实评分路径;设成 oracle/negative 会让 test.sh 自己再落地一遍,绕过本脚本。
+#   docker exec -e KERNELBENCH_VERIFY_MODE=candidate kfc-solve bash /tests/test.sh
+#   docker exec kfc-solve cat /logs/verifier/reward.json   # 判分结果
+#   docker rm -f kfc-solve
+#
+#   期望:oracle → 性能题得 0(它就是锚点本身; min(1, ln(speedup/ref_speedup)/ln(ref_speedup))(speedup ≤ ref_speedup 时为 0)
+#         在 speedup≈ref_speedup 处 = 0 —— 打平 oracle 不得分,必须超过。
+#         所以"oracle 跑对了"的判据不是 reward>0,而是 speedup≈ref_speedup 且
+#         hard_fail_reasons 为空;实现类二值题 = 1.0 —— 权威公式是
+#         tests/test.sh 写出的 reward_formula 字段);--negative → 0;
+#         --noop(在纯净容器里)→ 0(挖洞基线过不了正确性门)。
+# ──────────────────────────────────────────────────────────────────────────
+#
+# 用法(规范 2 的统一 CLI):
+#   bash solution/solve.sh              # 落地 oracle(参考实现)
+#   bash solution/solve.sh --negative   # 落地 negative(已知坏例,必须得 0)
+#   bash solution/solve.sh --baseline2  # 落地 baseline2(中间基线)
+#   bash solution/solve.sh --noop       # 把可编辑面复位到烤入基线(对照组)
+#
+# --noop 语义:把可编辑面复位到烤入基线(与 verifier 取基线的方式一致 ——
+#   `git checkout HEAD -- <scope>`,HEAD 不动),使对照组能量到真正的 no-op 值。
+#   runner 在同一个容器里连着跑 oracle → noop 做对照时,靠它把上一轮落地归零。
+#
+# 幂等:每次落地前先把被计分单元 `git checkout HEAD --` 复位,重复执行结果一致。
+# 失败一律非 0 退出并打印原因(补丁打不上 / 变体文件缺失 / scope 路径不存在 / HEAD 被移动)。
+set -uo pipefail
+
+TASK_ID="s4-fft-longconv"
+REPO="${KFC_REPO_DIR:-/app/repo}"
+SUB="submission/kernel.py"
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+say(){ printf '[solve.sh %s] %s\n' "$TASK_ID" "$*"; }
+die(){ printf '[solve.sh %s] ERROR: %s\n' "$TASK_ID" "$*" >&2; exit 1; }
+GIT(){ git -c safe.directory='*' -C "$REPO" "$@"; }
+
+usage(){ cat <<'USAGE'
+usage: bash solve.sh [--oracle | --negative | --noop]
+  (无参数)      落地 oracle 参考实现(kernel_oracle.py)
+  --negative    落地 negative 已知坏例(kernel_negative.py)
+  --noop        把可编辑面复位到烤入基线(与 verifier 取基线一致,HEAD 不动)
+USAGE
+}
+
+WHICH=oracle
+case "${1:-}" in
+  ""|--oracle) WHICH=oracle ;;
+  --negative)  WHICH=negative ;;
+  --baseline2) WHICH=baseline2 ;;
+  --noop)      WHICH=noop ;;
+  -h|--help)   usage; exit 0 ;;
+  *)           usage >&2; die "未知参数 '$1'" ;;
+esac
+
+artifact(){
+  local n="$1" c
+  for c in "$HERE/$n" "/solution/$n" "${KFC_SOLUTION_DIR:-/nonexistent}/$n"; do
+    [ -f "$c" ] && { printf '%s\n' "$c"; return 0; }
+  done
+  return 1
+}
+
+case "$WHICH" in
+  noop)     ART="" ;;
+  oracle)   ART="kernel_oracle.py" ;;
+  negative) ART="kernel_negative.py" ;;
+  *) die "本题没有 $WHICH 变体(solution/ 里只有:kernel_oracle.py, kernel_negative.py)" ;;
+esac
+
+GIT rev-parse --git-dir >/dev/null 2>&1 \
+  || die "$REPO 不是 git 工作树 —— 本脚本必须在题目容器里跑(镜像在 build 时才 git init 挖洞基线)"
+[ -f "$REPO/$SUB" ] || die "被计分单元不存在:$REPO/$SUB(REPO 不对?可用 KFC_REPO_DIR 覆盖)"
+HEAD_BEFORE="$(GIT rev-parse HEAD)" || die "读不到 $REPO 的 HEAD"
+N_BEFORE="$(GIT rev-list --count HEAD)"
+
+if [ "$WHICH" = noop ]; then
+  # --noop 把可编辑面复位到烤入基线(与 verifier 取基线的方式一致 —— `git checkout HEAD -- <scope>`,
+  # HEAD 不动),使对照组能量到真正的 no-op 值。scope 文件在 git 树里,所以 checkout 就够。
+  DIRTY_BEFORE="$(GIT status --porcelain -- "$SUB" | sed '/^$/d')"
+  GIT checkout -q HEAD -- "$SUB" || die "复位被计分单元失败($SUB)"
+  DIRTY_AFTER="$(GIT status --porcelain -- "$SUB" | sed '/^$/d')"
+  if [ -n "$DIRTY_AFTER" ]; then
+    printf '%s\n' "$DIRTY_AFTER" | sed "s|^|[solve.sh $TASK_ID]   |" >&2
+    die "复位后被计分单元仍不干净(见上)—— 量不到真正的 no-op 值"
+  fi
+  [ "$HEAD_BEFORE" = "$(GIT rev-parse HEAD)" ] || die "HEAD 被移动了,判分会把 candidate 当基线"
+  [ "$N_BEFORE" = "$(GIT rev-list --count HEAD)" ] || die "commit 数变了,HEAD 不再是唯一的挖洞基线"
+  if [ -n "$DIRTY_BEFORE" ]; then
+    say "--noop:已把可编辑面复位到烤入基线的 stub;原先这些是脏的:"
+    printf '%s\n' "$DIRTY_BEFORE" | sed "s|^|[solve.sh $TASK_ID]   |"
+  else
+    say "--noop:可编辑面本来就是干净的烤入基线 stub,无需复位"
+  fi
+  say "--noop 完成:$SUB = 烤入基线 stub(HEAD 未动 @ ${HEAD_BEFORE:0:12})"
+  exit 0
+fi
+
+VAR="$(artifact "$ART")" || die "找不到参考产物 $ART(查过 $HERE/、/solution/、\$KFC_SOLUTION_DIR/)"
+
+# ---- 幂等:先复位到挖洞基线的 stub,再整文件覆盖(cp 保留目标文件原有权限) ----
+GIT checkout -q HEAD -- "$SUB" || die "复位被计分单元失败($SUB)"
+cp -f "$VAR" "$REPO/$SUB" || die "写入失败:$REPO/$SUB"
+
+HEAD_AFTER="$(GIT rev-parse HEAD)"
+[ "$HEAD_BEFORE" = "$HEAD_AFTER" ] || die "HEAD 被移动了($HEAD_BEFORE -> $HEAD_AFTER),判分会把 candidate 当基线"
+[ "$N_BEFORE" = "$(GIT rev-list --count HEAD)" ] || die "commit 数变了,HEAD 不再是唯一的挖洞基线"
+
+say "已落地 $WHICH:$(basename "$VAR") -> $SUB(工作树改动,HEAD 未动 @ ${HEAD_AFTER:0:12})"
+GIT status --porcelain -- "$SUB" | sed "s|^|[solve.sh $TASK_ID]   |"
+
+STRAY="$(GIT status --porcelain | awk '{print $NF}' \
+         | grep -v -e '__pycache__' -e '\.pyc$' -e "^$SUB\$" || true)"
+[ -z "$STRAY" ] || { say "⚠ 工作树里还有 scope 外的改动,判分会 out_of_scope_edit 直接归 0:"; \
+                     printf '%s\n' "$STRAY" | sed "s|^|[solve.sh $TASK_ID]   |"; }
+exit 0

tasks/kfc/s4-fft-longconv/task/task.toml

@@ -0,0 +1,53 @@
+# Reconstructed: the source package shipped a 0-byte task.toml;
+# the values below mirror the task metadata.
+
+schema_version = "2.0"
+
+# 提交产物(pre_artifacts.sh 在判分前于同一容器内产出;规范 §1)
+artifacts = ["/logs/artifacts/model.patch", "/logs/artifacts/model_files.txt"]
+
+[task]
+id = "s4-fft-longconv"
+bench = "kfc"
+kind = "implementation"
+language = "python"
+title = "submission/kernel.py ships a required function causal_conv whose body is not implemented (it raises NotImplementedError)."
+instruction = "instruction.md"
+
+[agent]
+timeout_sec = 5400
+
+# carved-tree provenance (environment/repo/ recovered from): <internal registry>/kernelbench/wre-arch-s4-fft-longconv:v1@sha256:4215533296f1f970d093257f96b14d5cada8925b220966c41471b23d78c36542
+# 🔁 LOOP16: the shipped image is the loop16 overlay (`crane append` onto the :oss base, purely
+#    additive — /opt/loop only, NOTHING under tests/ changed). Build it in two steps:
+#      docker build -f environment/Dockerfile             -t fai/kfc-s4-fft-longconv:oss .
+#      docker build -f environment/loop_overlay/Dockerfile -t fai/kfc-s4-fft-longconv:oss-loop16 environment/loop_overlay
+#    The single-shot form (:oss) is a valid alternative; the graded surface (tests/) is identical in both.
+[environment]
+docker_image = "fai/kfc-s4-fft-longconv:oss"
+build_timeout_sec = 3600
+cpus = 8
+memory_mb = 32768
+gpus = 1
+# H20 只是**锚点标定用卡**,不是硬性限制。换卡时:①按 tests/ref_speedup.caveat.md 重标锚点;
+#   ②用 --build-arg TORCH_CUDA_ARCH_LIST=<你的算力> 构建镜像。
+gpu_types = ["H20"]
+allow_internet = false
+
+[verifier]
+entrypoint = "tests/test.sh"
+mode = "shared"
+primary_edit_paths = ["submission/kernel.py"]
+result_paths = ["/logs/verifier/reward.json"]
+
+[primary_metric]
+name = "reward"
+goal = "maximize"
+calibrated_on = "NVIDIA H20"
+
+# loop16: the shipped image bakes /opt/loop; the in-session dev proxy re-runs THIS task's own
+# verifier (candidate mode) on the live /app/repo. This is an IMPLEMENTATION-class task (binary
+# reward), so best-of-k ranks on the dual-emitted RAW vs_oracle speed signal to prefer the fastest
+# correctness-passing kernel. At most 16 submissions, at least 1; the model decides when to stop
+# (min=1 so --finalize works any time). NO calibrated anchor is baked. The graded score is the
+# runner's fresh end-of-session tests/ grade (binary correctness over hidden shapes).

tasks/kfc/s4-fft-longconv/task/tests/compute_reward.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""compute_reward for s4-fft-longconv (IMPLEMENTATION class).
+
+reward = 1.0 iff every test case passes and there is no cheat / scope violation,
+reward = 0.0 otherwise   [implementation class]
+
+The authoritative verdict is written by test.sh, which owns the correctness /
+scope-diff / import-origin / anti-cheat HARD gates (the baked hollow stub raises
+NotImplementedError, so the starter fails correctness and scores 0). This CLI
+mirrors the same binary rule and reports the measured vs_oracle ratio as
+DIAGNOSTIC METADATA only — never as the reward.
+
+Why binary rather than the performance log formula: this task has NO timeable
+baseline (the starter does not run), and its only timing anchor is the oracle
+itself, so ref_speedup ~= 1.0 and min(1.0, ln(speedup/ref_speedup)/ln(ref_speedup)) if speedup > ref_speedup else 0.0 is
+degenerate/undefined. reward.md's legality rule for the starter package
+("implementation class must fail at least one testcase") is what this satisfies.
+"""
+import json
+import sys
+
+TOKEN = "WRE_RESULT "
+
+
+def load(path):
+    for line in open(path):
+        if line.startswith(TOKEN):
+            return json.loads(line[len(TOKEN):])
+    raise SystemExit(f"no {TOKEN.strip()} in {path}")
+
+
+def main():
+    cand = load(sys.argv[1])
+    oracle_ms = float(sys.argv[2]) if len(sys.argv) > 2 else -1.0
+    cm = cand.get("timing_ms", -1)
+
+    # correctness is the AND of every case; the workload reports it as one flag.
+    correctness_ok = bool(cand.get("correctness_ok", False))
+    hard = [] if correctness_ok else ["correctness_failed"]
+    reward = 1.0 if (correctness_ok and not hard) else 0.0
+
+    vs_oracle = (oracle_ms / cm) if (cm and cm > 0 and oracle_ms > 0) else 0.0
+    print(json.dumps({
+        "task_type": "implementation",
+        "reward": reward,
+        "reward_formula": "implementation: 1.0 iff every case passes and no cheat, else 0.0",
+        "hard_fail_reasons": hard,
+        "tests": {"passed": (1 if correctness_ok else 0), "total": 1,
+                  "note": "correctness_ok is the AND over every hidden case"},
+        "metadata": {"vs_oracle": round(vs_oracle, 6), "oracle_ms": oracle_ms,
+                     "candidate_ms": cm,
+                     "note": "vs_oracle is diagnostic metadata only, never the reward"},
+        "vs_oracle": round(vs_oracle, 6),
+        "oracle_ms": oracle_ms,
+        "candidate_ms": cm,
+    }))
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/s4-fft-longconv/task/tests/ref_speedup.caveat.md

@@ -0,0 +1,29 @@
+# ref_speedup 硬件/环境 caveat(开源版新增,不改变判分逻辑)
+
+本题是**实现类**任务:reward 为二值 0/1(全部正确性用例通过且无作弊 -> 1.0,否则 0.0),**不使用 ref_speedup 锚点**,因此无需重标定。下方公式仅对性能类任务适用:
+
+    reward = min(1.0, ln(speedup/ref_speedup)/ln(ref_speedup)) if speedup > ref_speedup else 0.0
+
+本题不随包提供 `tests/ref_speedup.txt`,判分也不读它 —— 二值 reward 与锚点无关。
+`environment/verifier-correctness-manifest.json` 里的 `oracle_ms` 仅作诊断记录,不参与判分。
+
+## 标定条件
+
+- 硬件:**NVIDIA H20**
+- 运行栈:`torch 2.7.0`(原始私有基座声明 torch 2.5.1/triton 3.1.0,任务 overlay 又 `pip install torch==2.7.0`,锚点即在 2.7.0 下标定)
+- 线程:`OMP/MKL/OPENBLAS_NUM_THREADS=1`(计时稳定性的一部分,已写进镜像 ENV)
+
+## 换硬件时要做什么
+
+**不需要重标定** —— 本题 reward 是二值的,与硬件无关。上面的「标定条件」只是记录
+参考实现当初被验证的环境;换卡后正确性用例应当照常全过。
+
+参考实现与反例是**单文件形式**(不是 patch),覆盖到可编辑文件上即可:
+
+- `solution/kernel_oracle.py` —— 参考实现,应当得 1.0
+- `solution/kernel_negative.py` —— 已知坏例,**必须**得 0.0
+
+两者都不进镜像(已被 `.dockerignore` 排除),判分时也从不运行。
+
+计时仍会作为诊断元数据记录(`environment/verifier-correctness-manifest.json`
+的 `oracle_ms` 是 H20 验证时的记录值),但不参与 reward。