fix(b-gate): the binding measures an execution, and the row-3 sentence stops counting doors
Third repair of the same failure, and the first that does not read a NAME. The judge measured
row 1 to 17 of 17 with 17 one-line probes and a door module without a single import: "the probe
touches the door" was still a text check, one notch further in.
What is measured now, in the probe's own source: an EXECUTION SITE (a process starter carrying
the door's name in its arguments, or the entry imported from the door's module and called), and
an assert that is DATA-DEPENDENT on that call. Dead code is pruned first -- a call in a branch
that never runs, or after a return, is no execution. The honest forms the suite already uses
keep counting: the command built in a variable first, and the subprocess started in a helper
that returns it.
All seven forms the judge measured (a1, a2, b1, b2, c1, c2 + the one-liner recipe) now give
0 of 1, each with an rc-0 control in the same setup.
[mutation-ok] -- no guard is switched off. The two `if False:` lines in this diff are the
judge's b1 probe form planted as test DATA (a Python string written into a tmp_path file the
gate only PARSES, never runs) and the docstring naming why dead code is pruned. The commit adds
the rule that makes `if False:` around a door call stop counting.
Naming the step becomes a DISCRIMINATOR, as a class: it is required only when more than one step
stands behind the same door. Driving a door with a sole step IS driving that step -- which is why
`gate` (a real end-to-end door probe against v1_gate) was rejected on a name technicality. Row 1:
0 -> 1 of 17. For a subcommand door the command name must stand in what was actually executed,
and the CLI itself must be registered or `-m`-runnable: an add_parser in a module nobody can
start is no door.
held_out: a reason must be named prose. "-", "todo", "x", "." were all accepted as a reason by
`.strip()`; measured against the contract's own 28 reasons (shortest: 30 chars, three words).
Row 3: the five forms the checkpoint measured as open AND cheap to close are closed -- importlib
for both SDK names, deno/npm exec/yarn dlx, and the official TypeScript SDK. 12 of 12 -> 15 of 15,
still 0 hits over 512 published files. The limit sentence stops enumerating what remains ("EXACTLY
TWO", then "THREE" -- both falsified by the first new measurement) and says what the guard IS.
N7 stays open in the gate and is closed in the suite: a deleted off-path step still shrinks the
denominator silently there, so the four are written out in an arm that goes red when one goes.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
parent
42720faa03
commit
e47be68b57
SSH key fingerprint:
SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
3 changed files with 786 additions and 144 deletions
|
|
@ -44,9 +44,9 @@ _NOW = datetime(2026, 9, 19, 12, 0, tzinfo=timezone.utc)
|
|||
#: Repoets egne tall ved skriving (19.09.2026), talt av armene under mot KILDEN. De står her for
|
||||
#: at en stille endring i kjørestien skal vise seg som en rød test og ikke som et nytt tall.
|
||||
_STEPS_TODAY = 17
|
||||
_EXTERNAL_TODAY = 0
|
||||
_EXTERNAL_TODAY = 1
|
||||
_ROLES_TODAY = ("proposer", "checker")
|
||||
_PATTERNS_TODAY = 12
|
||||
_PATTERNS_TODAY = 15
|
||||
|
||||
|
||||
def _write(path: Path, text: str) -> None:
|
||||
|
|
@ -106,10 +106,10 @@ def test_the_step_denominator_equals_an_independent_count_of_the_source() -> Non
|
|||
assert row.n == _STEPS_TODAY
|
||||
|
||||
|
||||
def test_row1_today_is_red_with_no_step_callable_from_outside() -> None:
|
||||
"""Var «3 av 17» til 19.09. De tre falt da proben ble BUNDET til steget: to av dem driver
|
||||
riktig dør uten å navngi hvilket steg de beviser, den tredje går ikke gjennom døren i det
|
||||
hele tatt. Ingen av dem var en kodefeil — det var kontrakten som godtok dem."""
|
||||
def test_row1_today_is_red_with_the_steps_that_have_no_door_named() -> None:
|
||||
"""Var «3 av 17» til 19.09, så 0 av 17 da proben ble BUNDET til steget. Fra 20.09 teller
|
||||
``gate`` igjen: den proben kjører v1-gaten som subprosess og leser JSON-en ut av den, og
|
||||
steget er alene bak den døren — den ble avvist på en navneteknikalitet, ikke på atferd."""
|
||||
passing = {n: "passed" for step in _CONFIG["steps"] for n in step.get("probe", ())}
|
||||
row = gate.score_toolbox(_CONFIG["steps"], _SRC, _CONFIG["run_path"], passing, _REPO)
|
||||
assert (row.k, row.n, row.status) == (_EXTERNAL_TODAY, _STEPS_TODAY, gate.RED)
|
||||
|
|
@ -117,7 +117,7 @@ def test_row1_today_is_red_with_no_step_callable_from_outside() -> None:
|
|||
assert "validering" in named and "utboks" in named
|
||||
assert "prepass-artefakt" in named and "parse-feil" in named
|
||||
bound = {x.split(":")[0] for x in row.exceptions if "atferdsprobe" in x}
|
||||
assert bound == {"rundebinding", "rapport", "gate"}, row.exceptions
|
||||
assert bound == {"rundebinding", "rapport"}, row.exceptions
|
||||
|
||||
|
||||
def _fake_src(root: Path, *, chat_client: bool, symbol: str = "gjoer_noe") -> Path:
|
||||
|
|
@ -1136,14 +1136,20 @@ def test_a_probe_that_drives_the_door_without_naming_the_step_proves_the_door_on
|
|||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""To steg bak SAMME dør er det vanlige tilfellet (``round_builder`` bærer to). En probe som
|
||||
bare kjører kommandoen skiller dem ikke — den må navngi steget den beviser."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_probe(tmp_path)
|
||||
assert gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path).k == 1
|
||||
bare kjører kommandoen skiller dem ikke — den må navngi steget den beviser.
|
||||
|
||||
_write_probe(tmp_path, needle="et_helt_annet_steg")
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (row.k, row.n) == (0, 1)
|
||||
Nevneren er TO med vilje (endret 20.09): navngivningen er en diskriminator, og et steg som
|
||||
er alene bak sin dør har ingenting å skilles fra — se
|
||||
``test_the_sole_step_behind_a_door_is_proved_by_driving_that_door``."""
|
||||
src = _two_step_src(tmp_path)
|
||||
a = _write_probe(tmp_path, needle="gjoer_noe", nodeid="tests/test_a.py::test_a")
|
||||
b = _write_probe(tmp_path, needle="gjoer_noe_annet", nodeid="tests/test_b.py::test_b")
|
||||
outcomes = {a: "passed", b: "passed"}
|
||||
assert gate.score_toolbox(_two_steps(a, b), src, _fake_run_path(), outcomes, tmp_path).k == 2
|
||||
|
||||
b = _write_probe(tmp_path, needle="et_helt_annet_steg", nodeid="tests/test_b.py::test_b")
|
||||
row = gate.score_toolbox(_two_steps(a, b), src, _fake_run_path(), outcomes, tmp_path)
|
||||
assert (row.k, row.n) == (1, 2)
|
||||
assert any("navngir ikke steget" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
|
|
@ -1165,9 +1171,18 @@ def test_a_probe_that_only_mentions_the_door_or_the_step_proves_neither(tmp_path
|
|||
assert (row.k, row.n) == (0, 1), row.exceptions
|
||||
assert any("rører ikke døren" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
_write_probe(tmp_path, needle="et_annet_navn", docstring="gjoer_noe")
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (row.k, row.n) == (0, 1), row.exceptions
|
||||
to_steg = _two_step_src(tmp_path)
|
||||
a = _write_probe(tmp_path, needle="gjoer_noe", nodeid="tests/test_a.py::test_a")
|
||||
b = _write_probe(
|
||||
tmp_path,
|
||||
needle="et_annet_navn",
|
||||
docstring="gjoer_noe_annet",
|
||||
nodeid="tests/test_b.py::test_b",
|
||||
)
|
||||
row = gate.score_toolbox(
|
||||
_two_steps(a, b), to_steg, _fake_run_path(), {a: "passed", b: "passed"}, tmp_path
|
||||
)
|
||||
assert (row.k, row.n) == (1, 2), row.exceptions
|
||||
assert any("navngir ikke steget" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
|
|
@ -1452,3 +1467,398 @@ def test_a_runbook_without_the_sections_the_contract_names_is_not_green(tmp_path
|
|||
row = gate.score_runbook(cfg, tmp_path, now=_NOW)
|
||||
assert row.status == gate.NOT_MEASURED, row.exceptions
|
||||
assert any("seksjon" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
# --- rad 1, TREDJE reparasjon: bindingen måler UTFØRELSE, ikke tekst --------------------------
|
||||
#
|
||||
# Sjekkpunktet 19.09 (`a37e429`) MÅLTE at rad 1 kunne bli 17 av 17 med 17 énlinjes-prober og en
|
||||
# dørmodul uten én eneste import: «proben rører døren» var en tekstsjekk ett hakk lenger inne.
|
||||
# Dommerens seks probeformer + oppskriften står her, hver som sin egen arm, og hver skal gi 0.
|
||||
|
||||
|
||||
def _write_raw_probe(root: Path, body: str, nodeid: str = _FAKE_PROBE) -> str:
|
||||
"""En probe skrevet ORDRETT — de uærlige formene kan ikke uttrykkes gjennom ``_write_probe``."""
|
||||
file_part, _, name = nodeid.partition("::")
|
||||
_write(root / file_part, body.replace("<navn>", name))
|
||||
return nodeid
|
||||
|
||||
|
||||
#: Dommerens sju former, verbatim slik de ble målt: seks som BRAST mot forrige utgave, pluss
|
||||
#: oppskriften «17 énlinjes-prober + dørmodul uten imports» i sin minste form. Døren er
|
||||
#: ``fakesrc.driver``, steget ``gjoer_noe`` — nøyaktig dem ``_one_step`` erklærer.
|
||||
_JUKSEFORMER: tuple[tuple[str, str], ...] = (
|
||||
(
|
||||
"a1-navn-i-ubrukt-variabel",
|
||||
"def <navn>(tmp_path):\n"
|
||||
' door = "fakesrc.driver"\n'
|
||||
' steg = "gjoer_noe"\n'
|
||||
" assert isinstance(door, str) and isinstance(steg, str)\n",
|
||||
),
|
||||
(
|
||||
"a2-importert-aldri-kalt",
|
||||
"from fakesrc import driver\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
" assert driver is not None\n"
|
||||
' assert "gjoer_noe"\n',
|
||||
),
|
||||
(
|
||||
"b1-kallet-i-doed-gren",
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
" if False:\n"
|
||||
' subprocess.run([sys.executable, "-m", "fakesrc.driver", "--steg", "gjoer_noe"])\n'
|
||||
" assert True\n",
|
||||
),
|
||||
(
|
||||
"b2-kallet-etter-return",
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
' assert "gjoer_noe"\n'
|
||||
" return None\n"
|
||||
' subprocess.run([sys.executable, "-m", "fakesrc.driver", "--steg", "gjoer_noe"])\n',
|
||||
),
|
||||
(
|
||||
"c1-resultatet-forkastet",
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
' subprocess.run([sys.executable, "-m", "fakesrc.driver", "--steg", "gjoer_noe"])\n'
|
||||
" assert 2 + 2 == 4\n",
|
||||
),
|
||||
(
|
||||
"c2-bare-skrevet-ut",
|
||||
'def <navn>(tmp_path):\n print("fakesrc.driver", "gjoer_noe")\n assert True\n',
|
||||
),
|
||||
(
|
||||
"oppskriften-enlinjes",
|
||||
'def <navn>(tmp_path):\n assert len("fakesrc.driver") and len("gjoer_noe")\n',
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("form", "body"), _JUKSEFORMER, ids=[n for n, _ in _JUKSEFORMER])
|
||||
def test_none_of_the_judges_seven_forms_is_a_behaviour_probe(
|
||||
tmp_path: Path, form: str, body: str
|
||||
) -> None:
|
||||
"""Hver form plantes ALENE, med rc-0-kontrollen først: den ærlige proben teller, formen ikke.
|
||||
|
||||
Uten kontrollen ville armen bestått mot en gate som avviste ALT — «0 av 1» er et
|
||||
måleresultat bare når 1 av 1 er oppnåelig i samme oppsett."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_probe(tmp_path)
|
||||
kontroll = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (kontroll.k, kontroll.n) == (1, 1), kontroll.exceptions
|
||||
|
||||
_write_raw_probe(tmp_path, body)
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (row.k, row.n) == (0, 1), (form, row.exceptions)
|
||||
assert any("atferdsprobe" in x for x in row.exceptions), (form, row.exceptions)
|
||||
|
||||
|
||||
def test_a_probe_that_runs_the_door_and_throws_the_result_away_proves_nothing(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""Dommerens c1, med sin EGEN grunn: kallet skjedde, men ingen assert leser det det ga.
|
||||
Skilles fra «rører ikke døren», for det er to ulike feil og bare den ene er en løgn."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_raw_probe(tmp_path, dict(_JUKSEFORMER)["c1-resultatet-forkastet"])
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert row.k == 0
|
||||
assert any("asserter ikke på det døren" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
def test_a_probe_that_only_names_the_door_never_reaches_the_execution_rule(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""Dommerens a1: navnet står i kilden, men ingen prosess starter. Grunnen skal være at døren
|
||||
ikke RØRES — ikke at asserten er feil, for da ville en assert-fiks «løst» det."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_raw_probe(tmp_path, dict(_JUKSEFORMER)["a1-navn-i-ubrukt-variabel"])
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert any("rører ikke døren" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
def test_an_honest_probe_that_starts_the_door_through_a_helper_still_counts(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""Den ÆRLIGE formen suiten faktisk bruker (``test_v1_gate._cli``): subprosessen startes i en
|
||||
hjelper, og testen asserter på det hjelperen ga tilbake. En regel som feller den, feller
|
||||
kapabilitet — som er den motsatte feilen av den vi retter."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_raw_probe(
|
||||
tmp_path,
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def _cli(*args):\n"
|
||||
" return subprocess.run(\n"
|
||||
' [sys.executable, "-m", "fakesrc.driver", *args], capture_output=True, text=True\n'
|
||||
" )\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
' proc = _cli("--steg", "gjoer_noe")\n'
|
||||
" assert proc.returncode == 0\n",
|
||||
)
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (row.k, row.n) == (1, 1), row.exceptions
|
||||
|
||||
|
||||
def test_a_probe_that_builds_the_command_in_a_variable_first_still_counts(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""``round_builder``-probens form: ``base = [sys.executable, "-m", "<modul>"]`` og
|
||||
``subprocess.run([*base, …])``. Strengen når kallet gjennom en variabel; det er en
|
||||
utførelse."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_raw_probe(
|
||||
tmp_path,
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
' base = [sys.executable, "-m", "fakesrc.driver"]\n'
|
||||
' ok = subprocess.run([*base, "--steg", "gjoer_noe"], capture_output=True, text=True)\n'
|
||||
" assert ok.returncode == 0, ok.stderr\n",
|
||||
)
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (row.k, row.n) == (1, 1), row.exceptions
|
||||
|
||||
|
||||
def test_the_step_name_must_stand_in_what_was_actually_executed(tmp_path: Path) -> None:
|
||||
"""Navngivningen flyttes fra «et hvilket som helst kall-argument» til DEN kommandolinja som
|
||||
ble kjørt. To steg bak samme dør, samme kommando — ordet som skiller dem må være i argv."""
|
||||
src = _two_step_src(tmp_path)
|
||||
a = _write_raw_probe(
|
||||
tmp_path,
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
" proc = subprocess.run(\n"
|
||||
' [sys.executable, "-m", "fakesrc.driver", "--steg", "gjoer_noe"],\n'
|
||||
" capture_output=True,\n"
|
||||
" )\n"
|
||||
" assert proc.returncode == 0\n",
|
||||
nodeid="tests/test_a.py::test_a",
|
||||
)
|
||||
b = _write_raw_probe(
|
||||
tmp_path,
|
||||
"import subprocess\nimport sys\n\n\n"
|
||||
"def <navn>(tmp_path):\n"
|
||||
" proc = subprocess.run(\n"
|
||||
' [sys.executable, "-m", "fakesrc.driver"], capture_output=True\n'
|
||||
" )\n"
|
||||
' hjelp("gjoer_noe_annet")\n'
|
||||
" assert proc.returncode == 0\n",
|
||||
nodeid="tests/test_b.py::test_b",
|
||||
)
|
||||
row = gate.score_toolbox(
|
||||
_two_steps(a, b), src, _fake_run_path(), {a: "passed", b: "passed"}, tmp_path
|
||||
)
|
||||
assert (row.k, row.n) == (1, 2), row.exceptions
|
||||
assert any("navngir ikke steget" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
def test_the_sole_step_behind_a_door_is_proved_by_driving_that_door(tmp_path: Path) -> None:
|
||||
"""KLASSE-rettingen av 3 → 0: navngivningen er en DISKRIMINATOR mellom steg som deler dør.
|
||||
Er steget alene bak sin dør, er det å kjøre døren å kjøre steget — og en ekte ende-til-ende
|
||||
dørprobe skal ikke avvises på en navneteknikalitet (målt 19.09 på ``gate``-proben)."""
|
||||
src = _fake_src(tmp_path, chat_client=False)
|
||||
_write_probe(tmp_path, needle="et_helt_annet_ord")
|
||||
row = gate.score_toolbox(_one_step(), src, _fake_run_path(), _FAKE_PASSED, tmp_path)
|
||||
assert (row.k, row.n) == (1, 1), row.exceptions
|
||||
|
||||
# ... og den samme proben beviser INGEN av to steg som deler døren.
|
||||
delt = _write_probe(tmp_path, needle="et_helt_annet_ord", nodeid="tests/test_x.py::test_x")
|
||||
annen = _write_probe(tmp_path, needle="et_helt_annet_ord", nodeid="tests/test_y.py::test_y")
|
||||
row = gate.score_toolbox(
|
||||
_two_steps(delt, annen),
|
||||
_two_step_src(tmp_path),
|
||||
_fake_run_path(),
|
||||
{delt: "passed", annen: "passed"},
|
||||
tmp_path,
|
||||
)
|
||||
assert row.k == 0, row.exceptions
|
||||
assert all("navngir ikke steget" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
def test_the_gates_own_gate_probe_binds_after_the_class_fix() -> None:
|
||||
"""Det ene steget som SKULLE telle før og ikke gjorde det: ``gate`` kjører v1-gaten som
|
||||
subprosess og leser JSON-en ut av den, og er ALENE bak sin dør — talt her, ikke antatt.
|
||||
Målt gjennom raden, ikke gjennom en hjelper: det er raden som er påstanden."""
|
||||
doer = [
|
||||
(s["entry"]["module"], s["entry"].get("scope", "main"), s["entry"].get("command", ""))
|
||||
for s in _CONFIG["steps"]
|
||||
]
|
||||
gate_step = next(s for s in _CONFIG["steps"] if s["id"] == "gate")
|
||||
noekkel = (
|
||||
gate_step["entry"]["module"],
|
||||
gate_step["entry"].get("scope", "main"),
|
||||
gate_step["entry"].get("command", ""),
|
||||
)
|
||||
assert doer.count(noekkel) == 1, "armen forutsetter at gate er alene bak sin dør"
|
||||
|
||||
row = gate.score_toolbox(
|
||||
_CONFIG["steps"], _SRC, _CONFIG["run_path"], _all_probes_passed(), _REPO
|
||||
)
|
||||
assert not any(x.startswith("gate:") for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
def _all_probes_passed() -> dict[str, str]:
|
||||
"""Hver nodeid kontrakten navngir, som «passed» — utfallet er IKKE det som måles her."""
|
||||
return {nodeid: "passed" for nodeid in gate.probe_nodeids(_CONFIG)}
|
||||
|
||||
|
||||
def test_the_door_rule_says_that_it_measures_an_execution_and_states_its_limit() -> None:
|
||||
"""A8-klassen: regelen skal si nøyaktig hva koden MÅLER, og hva den ikke kan se."""
|
||||
rule = gate.EXTERNAL_DOOR.casefold()
|
||||
assert "utførelse" in rule
|
||||
assert "dataavhengig" in rule
|
||||
assert "alene bak" in rule
|
||||
# Grensen dommeren navnga som den eneste formen som ikke kan skrives forbi.
|
||||
assert "muter" in rule or "mutant" in rule
|
||||
|
||||
|
||||
# --- rad 1: en grunn skal være NAVNGITT prosa, ikke bare ikke-tom -----------------------------
|
||||
|
||||
|
||||
@pytest.mark.parametrize("plassholder", ["-", "todo", "x", ".", "??", "n/a"])
|
||||
def test_a_placeholder_is_not_a_named_reason(tmp_path: Path, plassholder: str) -> None:
|
||||
"""Sjekkpunktet målte at «-», «todo», «x» og «.» alle ble godtatt som grunn: ``.strip()``
|
||||
skilte tom fra ikke-tom, ikke grunn fra ikke-grunn."""
|
||||
src, spec = _mini_run_path(tmp_path, extra_call=True)
|
||||
spec["held_out"] = [{"symbol": "beta", "reason": "hjelper inne i alfa, ikke et eget steg"}]
|
||||
steps = [
|
||||
{
|
||||
"id": "alfa",
|
||||
"label": "alfa",
|
||||
"module": "steg.py",
|
||||
"symbol": "alfa",
|
||||
"driver": {"module": "kjor.py", "scope": "run_project"},
|
||||
"entry": {"kind": "module-main", "module": "kjor.py", "scope": "main"},
|
||||
}
|
||||
]
|
||||
assert gate.score_toolbox(steps, src, spec, {}, tmp_path).n == 1, "kontroll: ekte prosa holder"
|
||||
|
||||
spec["held_out"] = [{"symbol": "beta", "reason": plassholder}]
|
||||
row = gate.score_toolbox(steps, src, spec, {}, tmp_path)
|
||||
assert row.n == 2, f"{plassholder!r} er ingen grunn — symbolet blir i nevneren"
|
||||
assert any("UTEN grunn" in x for x in row.exceptions), row.exceptions
|
||||
|
||||
|
||||
def test_every_held_out_reason_in_the_contract_is_named_prose() -> None:
|
||||
"""Terskelen måles mot kontraktens egne 28 grunner, gjennom RADEN: strammes den så den
|
||||
feller ekte prosa, vokser nevneren og denne armen blir rød. Tallet 28 er talt her."""
|
||||
grunner = [str(h["reason"]) for h in _CONFIG["run_path"]["held_out"]]
|
||||
assert len(grunner) == 28
|
||||
assert min(len(g) for g in grunner) >= 30, "margin mot terskelen, målt"
|
||||
row = gate.score_toolbox(_CONFIG["steps"], _SRC, _CONFIG["run_path"], {}, _REPO)
|
||||
assert row.n == _STEPS_TODAY, "en ekte grunn skal ikke falle ut som plassholder"
|
||||
assert sum(1 for d in row.diagnostics if d.startswith("holdt utenfor: ")) >= len(grunner)
|
||||
assert not any("UTEN GRUNN" in d for d in row.diagnostics), row.diagnostics
|
||||
|
||||
|
||||
def test_the_row_limit_says_the_off_path_steps_have_no_derived_denominator() -> None:
|
||||
"""N7, uttalt: de fire stegene utenfor kjørestien har ingen utledet kilde, og et slettet
|
||||
off-path-steg tar derfor nevneren 17 → 16. Gaten kan ikke felle det; suiten kan."""
|
||||
assert "utenfor kjørestien" in gate.RUN_PATH_LIMIT
|
||||
assert "suiten" in gate.RUN_PATH_LIMIT
|
||||
|
||||
|
||||
#: De fire stegene som er erklært UTENFOR kjørestien, talt for hånd i kontrakten 20.09.2026.
|
||||
#: Dette er N7s eneste vakt: sletter noen et av dem, krymper nevneren stille i GATEN — her blir
|
||||
#: det rødt, og navnet står igjen i suiten.
|
||||
_OFF_PATH_TODAY: tuple[tuple[str, str, str], ...] = (
|
||||
("gate", "evals/v1_gate.py", "main"),
|
||||
("rapport", "evals/round_builder.py", "build_round"),
|
||||
("rundebinding", "evals/round_builder.py", "main"),
|
||||
("validering", "run.py", "evaluate_mandate_candidates"),
|
||||
)
|
||||
|
||||
|
||||
def test_no_off_path_step_can_be_deleted_without_this_arm_going_red() -> None:
|
||||
driver = (str(_CONFIG["run_path"]["module"]), str(_CONFIG["run_path"]["scope"]))
|
||||
funnet = tuple(
|
||||
sorted(
|
||||
(str(s["id"]), str(s["driver"]["module"]), str(s["driver"]["scope"]))
|
||||
for s in _CONFIG["steps"]
|
||||
if (str(s["driver"]["module"]), str(s["driver"]["scope"])) != driver
|
||||
)
|
||||
)
|
||||
assert funnet == _OFF_PATH_TODAY
|
||||
|
||||
|
||||
# --- rad 1: en underkommando er bare en dør når modulen selv er kallbar utenfra ---------------
|
||||
|
||||
|
||||
def test_a_subcommand_is_only_a_door_when_its_module_is_reachable_from_outside(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""En ``add_parser("x")`` i en modul ingen kan starte er ingen dør: underkommandoen er et
|
||||
navn inne i en CLI, og CLI-en selv må være registrert (konsoll-skript eller ``-m``)."""
|
||||
src = tmp_path / "fakesrc"
|
||||
_write(src / "steg.py", "def gjoer_noe():\n return 42\n")
|
||||
_write(
|
||||
src / "verktoey.py",
|
||||
"import argparse\n\nfrom fakesrc.steg import gjoer_noe\n\n\n"
|
||||
"def main(argv=None):\n"
|
||||
" parser = argparse.ArgumentParser()\n"
|
||||
' sub = parser.add_subparsers(dest="kommando")\n'
|
||||
' sub.add_parser("naviger-pakke")\n'
|
||||
" args = parser.parse_args(argv)\n"
|
||||
' if args.kommando == "naviger-pakke":\n'
|
||||
" return gjoer_noe()\n"
|
||||
" return 2\n",
|
||||
)
|
||||
entry = {
|
||||
"kind": "subcommand",
|
||||
"module": "verktoey.py",
|
||||
"scope": "main",
|
||||
"command": "naviger-pakke",
|
||||
}
|
||||
_fake_pyproject(tmp_path, {})
|
||||
ok, why = gate.registered_entry(src, tmp_path, "fakesrc", entry)
|
||||
assert ok is False and ("pyproject" in why or "__main__" in why), why
|
||||
|
||||
_fake_pyproject(tmp_path, {"fake-verktoey": "fakesrc.verktoey:main"})
|
||||
assert gate.registered_entry(src, tmp_path, "fakesrc", entry) == (True, "")
|
||||
|
||||
|
||||
# --- rad 3: de fem veiene sjekkpunktet målte som åpne OG billige å lukke ----------------------
|
||||
|
||||
#: Hver form er base64 av nøyaktig det som ble plantet. Klartekst her ville vært radens eget funn.
|
||||
_MAALTE_AAPNE_VEIER = (
|
||||
("dynamisk-import-modul", "aW1wb3J0bGliLmltcG9ydF9tb2R1bGUoImNsYXVkZV9hZ2VudF9zZGsiKQ=="),
|
||||
("dynamisk-import-modul-anthropic", "aW1wb3J0bGliLmltcG9ydF9tb2R1bGUoImFudGhyb3BpYyIp"),
|
||||
("node-runner-deno", "ZGVubyBydW4gLUEgbnBtOkBhbnRocm9waWMtYWkvY2xhdWRlLWNvZGUgLXAgIngi"),
|
||||
("node-runner-npm-exec", "bnBtIGV4ZWMgQGFudGhyb3BpYy1haS9jbGF1ZGUtY29kZSAtLSAtcCAieCI="),
|
||||
("node-runner-yarn-dlx", "eWFybiBkbHggQGFudGhyb3BpYy1haS9jbGF1ZGUtY29kZSAtcCAieCI="),
|
||||
(
|
||||
"sdk-ts-import",
|
||||
"aW1wb3J0IHsgcXVlcnkgfSBmcm9tICJAYW50aHJvcGljLWFpL2NsYXVkZS1hZ2VudC1zZGsiOw==",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("form", "snippet"), _MAALTE_AAPNE_VEIER, ids=[n for n, _ in _MAALTE_AAPNE_VEIER]
|
||||
)
|
||||
def test_every_form_the_checkpoint_measured_as_slipping_through_is_now_caught(
|
||||
tmp_path: Path, form: str, snippet: str
|
||||
) -> None:
|
||||
"""Tolv indirekte former slapp 19.09; fem av dem var verken eksotiske eller uoppregnelige.
|
||||
Hver plantes alene, med rc-0-kontroll før og etter."""
|
||||
cfg = json.loads(json.dumps(_CONFIG["no_claude_path"]))
|
||||
cfg["manifest"] = {"sentinel": "src/run.py", "sentinels": ["src/run.py"]}
|
||||
_write(tmp_path / "src" / "run.py", "x = 1\n")
|
||||
assert gate.score_no_claude_path(cfg, tmp_path).status == gate.GREEN, "kontroll: ren flate"
|
||||
planted = tmp_path / "src" / "plantet.ts"
|
||||
_write(planted, gate.decode(snippet) + "\n")
|
||||
row = gate.score_no_claude_path(cfg, tmp_path)
|
||||
assert row.status == gate.RED, (form, row.exceptions)
|
||||
planted.unlink()
|
||||
assert gate.score_no_claude_path(cfg, tmp_path).status == gate.GREEN
|
||||
|
||||
|
||||
def test_the_row_limit_is_a_class_description_and_no_longer_an_enumeration() -> None:
|
||||
"""Tredje runde med samme mønster: «NØYAKTIG TO veier» → «TRE veier», begge falsifisert av
|
||||
den første målingen som ble gjort. Setningen skal si hva vakten ER og hva den ikke ser —
|
||||
aldri hvor mange veier som står igjen."""
|
||||
limit = gate.NO_CLAUDE_LIMIT.casefold()
|
||||
assert "to veier står igjen" not in limit
|
||||
assert "tre veier står igjen" not in limit
|
||||
assert "tekstmønstre" in limit or "tekstvakt" in limit
|
||||
assert "uttømmende" in limit
|
||||
assert "git-manifestet" in limit
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue