test(pipeline): the checks of the pure pipeline
Stream, Normalize, Merge, Dispositions, Config, CodeKeys and the pure half
of CommitsMode, each a test of its own (131 checks). The fixture rewrites
are checked in (code-keys/<name>/, commits3/), so the suite reads fixtures
and edits nothing. The allowlist, command-line and MCP checks of
CommitsMode come with the pool they test.
Among them: this binary's `<exe> sql` spelling counts as a SQL call, and a
result line with a raw U+2028 in a JSON string is still the result line.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 06:56:09 +01:00
// SPDX-License-Identifier: AGPL-3.0-only
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
// Code keys: a static code pass is keyed on its code, a functional pass on
// its code AND the range. Every rewrite of the commits fixture is checked in
// under tests/Goldens/fixture/code-keys/<rewrite>/.
import std ;
import Crafter . Review ;
namespace fs = std : : filesystem ;
using namespace Crafter : : Review ;
namespace {
std : : int32_t Failures = 0 ;
const std : : string Fn ( Plan : : FunctionalLens ) ;
void Check ( std : : string_view name , bool cond , std : : string_view detail = { } ) {
std : : println ( " {}{}{} " , cond ? " ok " : " FAIL " , name , ! cond & & ! detail . empty ( ) ? std : : format ( " ({}) " , detail ) : std : : string ( ) ) ;
if ( ! cond ) + + Failures ;
}
using Keys = std : : map < std : : string , std : : string > ;
Keys CodeKeys ( const fs : : path & d , const std : : string & lens = " repo-bug-prover.md " , std : : string_view env = { } ) {
const Inventory : : Built built = Inventory : : Build ( " commits " , d . string ( ) ) ;
const Plan : : CommitCode cc = Plan : : CommitCodeOf ( Artifact : : PatchTexts ( d ) ) ;
Keys out ;
for ( const Json & u : built . out . at ( " units " ) ) {
const std : : string id = u . at ( " id " ) . get < std : : string > ( ) ;
if ( Plan : : KindFor ( lens , u ) ! = " code " ) continue ;
if ( lens = = Fn & & ( id . ends_with ( " :outside " ) | | id . ends_with ( " :absent " ) | | id . ends_with ( " #hdr " ) ) ) continue ;
const Json job = { { " kind " , " block " } , { " unit " , id } , { " unitKind " , " code " } } ;
out [ id ] = Plan : : BlockReuseKey ( job , lens , Plan : : UnitText ( built . lines , u ) , cc , { } , " c " , 1 , env ) . value_or ( " " ) ;
}
return out ;
}
feat(lenses): the commit-truth lens, repo-facts, as Gate 4
Every claim in every commit message, and in the documentation the range
adds or changes, proven or gone. The lens's block kinds are text, doc and
slot: a message unit is keyed on its text, the base and the code up to its
commit (MessageDeps); a documentation unit on its file, its normalised
text, the base and the code of the whole range (DocKeyParts); a diffstat on
its text alone; whole:order and whole:absent are asked in slot passes of
its own, never stored. A documentation file's diff header and a part the
commit writes nothing in are a mechanical n/a. Budgets 60/40 for a text or
doc block, 50/35 for a slot; one read. Gate 4, after the proofs, so the
messages and documents are read once the code they describe has settled;
the owner's gate is 5.
The goldens that follow from the lens table are derived by
tests/Goldens/derive.py, which asserts that the recorded table still
reproduces the recorded entries before it writes.
Proven, with the opt-in commit after this one: the suite (26 passed); a dry
run of a scratch range (2 commits, a README with sections) by the previous
binary and this one with the three static lenses on and the rest off, 25
prompts and 4 system files byte for byte; with repo-facts on as well,
those files unchanged and 10 passes and 1 system file added.
The lens's firing proof in this pipeline is owed (the owner's go).
2026-10-31 20:08:26 +01:00
// {unit id: reuse key} of every text and doc unit under the commit-truth
// lens (a doc file header and a context-only part are auto-n/a: no key).
Keys TruthKeys ( const fs : : path & d , std : : string_view env = { } ) {
const Inventory : : Built built = Inventory : : Build ( " commits " , d . string ( ) ) ;
const Plan : : CommitCode cc = Plan : : CommitCodeOf ( Artifact : : PatchTexts ( d ) ) ;
const Json & units = built . out . at ( " units " ) ;
Keys out ;
for ( const Json & job : Plan : : PlanLens ( Plan : : FactsLens , units , built . lines ) . blocks ) {
if ( job . at ( " kind " ) ! = " block " ) continue ;
const std : : string id = job . at ( " unit " ) . get < std : : string > ( ) ;
const Json * u = nullptr ;
for ( const Json & unit : units ) {
if ( unit . at ( " id " ) = = id ) u = & unit ;
}
out [ id ] = Plan : : BlockReuseKey ( job , Plan : : FactsLens , Plan : : UnitText ( built . lines , * u ) , cc , { } , " c " , 1 , env ) . value_or ( " " ) ;
}
return out ;
}
test(pipeline): the checks of the pure pipeline
Stream, Normalize, Merge, Dispositions, Config, CodeKeys and the pure half
of CommitsMode, each a test of its own (131 checks). The fixture rewrites
are checked in (code-keys/<name>/, commits3/), so the suite reads fixtures
and edits nothing. The allowlist, command-line and MCP checks of
CommitsMode come with the pool they test.
Among them: this binary's `<exe> sql` spelling counts as a SQL call, and a
result line with a raw U+2028 in a JSON string is still the result line.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 06:56:09 +01:00
std : : optional < std : : string > WholeKey ( const fs : : path & d , const std : : string & lens = " repo-better-solution.md " , std : : string_view env = { } ) {
return Plan : : WholeCodeKey ( { { " kind " , " whole " } , { " unit " , nullptr } } , lens , Plan : : CommitCodeOf ( Artifact : : PatchTexts ( d ) ) , { } , " c " , 1 , env ) ;
}
std : : set < std : : string > Changed ( const Keys & now , const Keys & before ) {
std : : set < std : : string > out ;
for ( const auto & [ id , key ] : before ) {
if ( now . at ( id ) ! = key ) out . insert ( id ) ;
}
return out ;
}
bool AllChanged ( const Keys & now , const Keys & before ) {
return Changed ( now , before ) . size ( ) = = before . size ( ) ;
}
std : : string Show ( const std : : set < std : : string > & ids ) {
Json out = Json : : array ( ) ;
for ( const std : : string & id : ids ) out . push_back ( id ) ;
return Dyn : : ReprValue ( out ) ;
}
}
int main ( ) {
std : : println ( " reuse keys: a static code pass is keyed on its code; a functional pass on its code AND the range (fixtures/commits and rewrites of it) " ) ;
const fs : : path fixture = fs : : current_path ( ) / " tests " / " Goldens " / " fixture " ;
const fs : : path src = fixture / " commits " ;
auto rewrite = [ & ] ( std : : string_view name ) { return fixture / " code-keys " / name ; } ;
const Keys base = CodeKeys ( src ) ;
const Keys fbase = CodeKeys ( src , Fn ) ;
const Keys sbase = CodeKeys ( src , " repo-security.md " ) ;
std : : set < std : : string > baseValues ;
std : : set < std : : string > sbaseValues ;
for ( const auto & [ id , key ] : base ) baseValues . insert ( key ) ;
for ( const auto & [ id , key ] : sbase ) sbaseValues . insert ( key ) ;
const bool keysDiffer = std : : ranges : : all_of ( base , [ & ] ( const auto & entry ) { return sbase . contains ( entry . first ) & & sbase . at ( entry . first ) ! = entry . second ; } ) ;
Check ( " the security lens keys the same code units as the bug-prover, every key its own (the lens file is in the key): a verdict of one is never evidence for the other " ,
std : : ranges : : equal ( std : : views : : keys ( sbase ) , std : : views : : keys ( base ) ) & & keysDiffer & & sbaseValues . size ( ) = = baseValues . size ( ) ) ;
std : : set < std : : string > slots ;
for ( const auto & [ id , key ] : base ) {
if ( id . ends_with ( " :outside " ) | | id . ends_with ( " :absent " ) ) slots . insert ( id ) ;
}
std : : set < std : : string > fbaseValues ;
for ( const auto & [ id , key ] : fbase ) fbaseValues . insert ( key ) ;
const std : : set < std : : string > functionalUnits = { " p1:hello.py#1 " , " p2:hello.py#1 " , " p2:hello.py#2 " } ;
std : : set < std : : string > shared ;
std : : ranges : : set_intersection ( baseValues , fbaseValues , std : : inserter ( shared , shared . begin ( ) ) ) ;
Check ( " fixture: every static code unit has a key (4 slots, hunks, headers), the functional units are the hunks alone, no doc unit, no shared key " ,
std : : ranges : : all_of ( base , [ ] ( const auto & entry ) { return ! entry . second . empty ( ) ; } ) & & slots . size ( ) = = 4 & & base . contains ( " p2:hello.py#hdr " )
& & std : : set < std : : string > ( std : : views : : keys ( fbase ) . begin ( ) , std : : views : : keys ( fbase ) . end ( ) ) = = functionalUnits
& & std : : ranges : : none_of ( base , [ ] ( const auto & entry ) { return entry . first . contains ( " .md# " ) ; } ) & & shared . empty ( ) ) ;
const fs : : path rw = rewrite ( " rewrite " ) ;
Check ( " a rewrite that leaves the code alone (ids, counter, blobs, line numbers, git version, a reworded message) -> every key the same, static and functional " ,
CodeKeys ( rw ) = = base & & CodeKeys ( rw , Fn ) = = fbase & & WholeKey ( rw ) = = WholeKey ( src ) & & WholeKey ( rw , Fn ) = = WholeKey ( src , Fn )
& & Artifact : : ArtifactHash ( " commits " , rw ) ! = Artifact : : ArtifactHash ( " commits " , src ) ) ;
const fs : : path code = rewrite ( " code " ) ;
std : : set < std : : string > diff = Changed ( CodeKeys ( code ) , base ) ;
std : : set < std : : string > expected = slots ;
expected . insert ( " p2:hello.py#1 " ) ;
Check ( " one changed line in p2:hello.py#1 -> static: that hunk and the four slots, nothing else " , diff = = expected , Show ( diff ) ) ;
Check ( " ...functional: EVERY unit is asked again (the range is in its key) " , AllChanged ( CodeKeys ( code , Fn ) , fbase ) ) ;
Check ( " ...and both whole passes " , WholeKey ( code ) ! = WholeKey ( src ) & & WholeKey ( code , Fn ) ! = WholeKey ( src , Fn ) ) ;
const Keys ctx = CodeKeys ( rewrite ( " context " ) ) ;
Check ( " a changed context line re-keys its hunk " , ctx . at ( " p2:hello.py#1 " ) ! = base . at ( " p2:hello.py#1 " ) & & ctx . at ( " p2:hello.py#2 " ) = = base . at ( " p2:hello.py#2 " ) ) ;
const fs : : path nobody = rewrite ( " nobody " ) ;
Check ( " p2 loses its body -> p2:absent alone (static); nothing functional " , Changed ( CodeKeys ( nobody ) , base ) = = std : : set < std : : string > { " p2:absent " } & & CodeKeys ( nobody , Fn ) = = fbase ) ;
const fs : : path bse = rewrite ( " base " ) ;
Check ( " another base -> every key changes, static, functional and both wholes " , AllChanged ( CodeKeys ( bse ) , base ) & & AllChanged ( CodeKeys ( bse , Fn ) , fbase ) & & WholeKey ( bse ) ! = WholeKey ( src ) ) ;
const fs : : path mode = rewrite ( " mode " ) ;
expected = slots ;
expected . insert ( " p2:hello.py#hdr " ) ;
Check ( " a mode change re-keys the file header (and the slots), not the hunks; the functional hunks follow the range " , Changed ( CodeKeys ( mode ) , base ) = = expected
& & AllChanged ( CodeKeys ( mode , Fn ) , fbase ) ) ;
const fs : : path docs = rewrite ( " docs " ) ;
Check ( " a reworded README sentence -> no key changes anywhere (documentation is nobody's code) " , CodeKeys ( docs ) = = base & & CodeKeys ( docs , Fn ) = = fbase & & WholeKey ( docs ) = = WholeKey ( src ) ) ;
const fs : : path nodoc = rewrite ( " nodoc " ) ;
Check ( " p2 drops its README hunk -> p2's two slots and the whole passes are asked again, no hunk " , Changed ( CodeKeys ( nodoc ) , base ) = = std : : set < std : : string > { " p2:absent " , " p2:outside " }
& & WholeKey ( nodoc ) ! = WholeKey ( src ) & & CodeKeys ( nodoc , Fn ) = = fbase ) ;
// The environment in the keys (plan.ENVIRONMENTS item 1).
const Keys sb = CodeKeys ( src , " repo-bug-prover.md " , " supabase " ) ;
const Keys fb = CodeKeys ( src , Fn , " browser+supabase " ) ;
Check ( " environment: a lens in its default environment keeps the key every stored verdict was built with (none for the static lenses, browser for the functional lens) " ,
CodeKeys ( src , " repo-bug-prover.md " , " none " ) = = base & & CodeKeys ( src , Fn , " browser " ) = = fbase & & WholeKey ( src , " repo-better-solution.md " , " none " ) = = WholeKey ( src )
& & WholeKey ( src , Fn , " browser " ) = = WholeKey ( src , Fn ) & & Plan : : EnvDeps ( " repo-bug-prover.md " ) . empty ( ) & & Plan : : EnvDeps ( Fn , " browser " ) . empty ( )
& & Plan : : EnvDeps ( Fn , " browser+supabase " ) = = std : : vector < std : : string > { " env=browser+supabase " } ) ;
std : : set < std : : string > everyKey ;
for ( const Plan : : Environment & environment : Plan : : Environments ) {
for ( const auto & [ id , key ] : CodeKeys ( src , " repo-bug-prover.md " , environment . name ) ) everyKey . insert ( key ) ;
}
Check ( " environment: any other environment re-keys every unit, block and whole, static and functional - each environment its own keys, none shared " ,
AllChanged ( sb , base ) & & AllChanged ( fb , fbase ) & & WholeKey ( src , " repo-better-solution.md " , " supabase " ) ! = WholeKey ( src )
& & WholeKey ( src , Fn , " browser+supabase " ) ! = WholeKey ( src , Fn ) & & everyKey . size ( ) = = Plan : : Environments . size ( ) * base . size ( ) ) ;
expected = slots ;
expected . insert ( " p2:hello.py#1 " ) ;
Check ( " environment: the code rules hold inside an environment - a rewrite that leaves the code alone keeps every supabase key, a changed line re-keys that hunk and the slots alone " ,
CodeKeys ( rw , " repo-bug-prover.md " , " supabase " ) = = sb & & CodeKeys ( rw , Fn , " browser+supabase " ) = = fb
& & WholeKey ( rw , " repo-better-solution.md " , " supabase " ) = = WholeKey ( src , " repo-better-solution.md " , " supabase " )
& & Changed ( CodeKeys ( code , " repo-bug-prover.md " , " supabase " ) , sb ) = = expected ) ;
feat(lenses): the commit-truth lens, repo-facts, as Gate 4
Every claim in every commit message, and in the documentation the range
adds or changes, proven or gone. The lens's block kinds are text, doc and
slot: a message unit is keyed on its text, the base and the code up to its
commit (MessageDeps); a documentation unit on its file, its normalised
text, the base and the code of the whole range (DocKeyParts); a diffstat on
its text alone; whole:order and whole:absent are asked in slot passes of
its own, never stored. A documentation file's diff header and a part the
commit writes nothing in are a mechanical n/a. Budgets 60/40 for a text or
doc block, 50/35 for a slot; one read. Gate 4, after the proofs, so the
messages and documents are read once the code they describe has settled;
the owner's gate is 5.
The goldens that follow from the lens table are derived by
tests/Goldens/derive.py, which asserts that the recorded table still
reproduces the recorded entries before it writes.
Proven, with the opt-in commit after this one: the suite (26 passed); a dry
run of a scratch range (2 commits, a README with sections) by the previous
binary and this one with the three static lenses on and the rest off, 25
prompts and 4 system files byte for byte; with repo-facts on as well,
those files unchanged and 10 passes and 1 system file added.
The lens's firing proof in this pipeline is owed (the owner's go).
2026-10-31 20:08:26 +01:00
// The commit-truth lens's keys (2026-10-31, the fp6 driver's doc_reuse_key
// and message_deps): a doc unit on its file, its text, the base and the
// code of the whole range; a message on its text, the base and the code
// up to its commit; a diffstat on its text alone; a slot pass never.
const Keys tbase = TruthKeys ( src ) ;
std : : set < std : : string > tbaseValues ;
for ( const auto & [ id , key ] : tbase ) tbaseValues . insert ( key ) ;
std : : set < std : : string > sharedWithCode ;
std : : ranges : : set_intersection ( baseValues , tbaseValues , std : : inserter ( sharedWithCode , sharedWithCode . begin ( ) ) ) ;
const std : : set < std : : string > truthUnits = { " p1:subject " , " p1:diffstat " , " p2:subject " , " p2:msg " , " p2:diffstat " , " p2:README.md#1 " } ;
Check ( " fixture: the commit-truth lens keys the five text units and the one doc unit (the README header is n/a), every key its own, none a code key's, no slot key " ,
std : : set < std : : string > ( std : : views : : keys ( tbase ) . begin ( ) , std : : views : : keys ( tbase ) . end ( ) ) = = truthUnits & & std : : ranges : : all_of ( tbase , [ ] ( const auto & e ) { return ! e . second . empty ( ) ; } )
& & tbaseValues . size ( ) = = tbase . size ( ) & & sharedWithCode . empty ( ) ) ;
const Keys trw = TruthKeys ( rw ) ;
Check ( " the rewrite (p2's message reworded, the patch counter bumped): the doc key and the diffstat keys hold, p2's body and both subjects are asked again " ,
trw . at ( " p2:README.md#1 " ) = = tbase . at ( " p2:README.md#1 " ) & & trw . at ( " p1:diffstat " ) = = tbase . at ( " p1:diffstat " ) & & trw . at ( " p2:diffstat " ) = = tbase . at ( " p2:diffstat " )
& & trw . at ( " p2:msg " ) ! = tbase . at ( " p2:msg " ) & & trw . at ( " p1:subject " ) ! = tbase . at ( " p1:subject " ) & & trw . at ( " p2:subject " ) ! = tbase . at ( " p2:subject " ) ) ;
const Keys tdocs = TruthKeys ( docs ) ;
Check ( " a reworded README sentence: its doc unit is asked again, nothing else of this lens " , Changed ( tdocs , tbase ) = = std : : set < std : : string > { " p2:README.md#1 " } ) ;
const Keys tcode = TruthKeys ( code ) ;
Check ( " one changed line in p2's code: the doc unit (the range is in its key) and p2's subject and body (the code up to p2) are asked again; p1's subject and the diffstats hold " ,
Changed ( tcode , tbase ) = = std : : set < std : : string > { " p2:README.md#1 " , " p2:subject " , " p2:msg " } , Show ( Changed ( tcode , tbase ) ) ) ;
Check ( " another base: every doc and message key changes; a diffstat depends on no code " , Changed ( TruthKeys ( bse ) , tbase ) = = std : : set < std : : string > { " p2:README.md#1 " , " p1:subject " , " p2:subject " , " p2:msg " } ) ;
Check ( " p2 drops its README hunk: no doc key is left " , ! TruthKeys ( nodoc ) . contains ( " p2:README.md#1 " ) & & TruthKeys ( nodoc ) . size ( ) = = 5 ) ;
const Plan : : CommitCode c0 = Plan : : CommitCodeOf ( Artifact : : PatchTexts ( src ) ) ;
const Plan : : CommitCode c1 = Plan : : CommitCodeOf ( Artifact : : PatchTexts ( code ) ) ;
Check ( " doc key: a sentence depends on the code of the whole range - a later commit's code change asks an earlier commit's sentence again; a part is keyed on its file, not on its hunk or part number " ,
Plan : : DocKeyParts ( " p1:README.md#1 " , c0 ) ! = Plan : : DocKeyParts ( " p1:README.md#1 " , c1 ) & & Plan : : DocKeyParts ( " p2:README.md#1 " , c0 ) = = Plan : : DocKeyParts ( " p2:README.md#3.12 " , c0 )
& & Plan : : DocKeyParts ( " p2:README.md#1 " , c0 ) . first ! = Plan : : DocKeyParts ( " p2:AGENTS.md#1 " , c0 ) . first & & Plan : : DocKeyParts ( " p2:README.md#1 " , c0 ) . first = = " doc:README.md "
& & c0 . docs . at ( 1 ) . empty ( ) & & c0 . docs . at ( 2 ) . size ( ) = = 1 & & c0 . docs . at ( 2 ) . at ( 0 ) . starts_with ( " diff --git a/README.md b/README.md \n new file mode " ) ) ;
Check ( " message key: a commit message depends on the code up to its own commit - p2's code change asks p2's subject and body again, not p1's; a diffstat, a slot and a hunk depend on no code " ,
Plan : : MessageDeps ( " p2:msg " , c0 ) ! = Plan : : MessageDeps ( " p2:msg " , c1 ) & & Plan : : MessageDeps ( " p2:subject " , c0 ) ! = Plan : : MessageDeps ( " p2:subject " , c1 )
& & Plan : : MessageDeps ( " p1:subject " , c0 ) = = Plan : : MessageDeps ( " p1:subject " , c1 ) & & ! Plan : : MessageDeps ( " p1:subject " , c0 ) . empty ( ) & & Plan : : MessageDeps ( " p2:diffstat " , c0 ) . empty ( )
& & Plan : : MessageDeps ( " whole:order " , c0 ) . empty ( ) & & Plan : : MessageDeps ( " p2:hello.py#1 " , c0 ) . empty ( ) & & Plan : : MessageDeps ( " p2:msg \n " , c0 ) = = Plan : : MessageDeps ( " p2:msg " , c0 ) ) ;
Check ( " environment: a text or doc key in another environment is its own, and a slot job has no key " , TruthKeys ( src , " supabase " ) ! = tbase & & AllChanged ( TruthKeys ( src , " supabase " ) , tbase )
& & ! Plan : : BlockReuseKey ( { { " kind " , " slot " } , { " unit " , " whole:order " } , { " unitKind " , " slot " } } , Plan : : FactsLens , " " , c0 , { } , " c " , 1 ) ) ;
test(pipeline): the checks of the pure pipeline
Stream, Normalize, Merge, Dispositions, Config, CodeKeys and the pure half
of CommitsMode, each a test of its own (131 checks). The fixture rewrites
are checked in (code-keys/<name>/, commits3/), so the suite reads fixtures
and edits nothing. The allowlist, command-line and MCP checks of
CommitsMode come with the pool they test.
Among them: this binary's `<exe> sql` spelling counts as a SQL call, and a
result line with a raw U+2028 in a JSON string is still the result line.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 06:56:09 +01:00
const Plan : : CommitCode cc = Plan : : CommitCodeOf ( Artifact : : PatchTexts ( src ) ) ;
Check ( " whole key: both wholes have keys and differ; a block never; the bug-prover has none " , WholeKey ( src ) & & WholeKey ( src , Fn ) & & WholeKey ( src ) ! = WholeKey ( src , Fn )
& & ! WholeKey ( src , " repo-bug-prover.md " ) & & ! Plan : : WholeCodeKey ( { { " kind " , " block " } , { " unit " , " x " } } , " repo-better-solution.md " , cc , { } , " c " , 1 ) ) ;
const Json job = { { " kind " , " whole " } , { " unit " , nullptr } } ;
const std : : vector < std : : string > w1 = { " w1 " } ;
Json withModel = job ;
withModel [ " model " ] = " m " ;
const std : : set < std : : optional < std : : string > > wholes = {
WholeKey ( src ) , Plan : : WholeCodeKey ( job , " repo-better-solution.md " , cc , w1 , " c " , 1 ) , Plan : : WholeCodeKey ( job , " repo-better-solution.md " , cc , { } , " c2 " , 1 ) ,
Plan : : WholeCodeKey ( job , " repo-better-solution.md " , cc , { } , " c " , 2 ) , Plan : : WholeCodeKey ( withModel , " repo-better-solution.md " , cc , { } , " c " , 1 ) ,
} ;
Check ( " whole key: dispositions, the charter, the prompt version and the model are in it " , wholes . size ( ) = = 5 ) ;
Plan : : CommitCode two ;
two . base = " b " ;
two . range = " r " ;
two . code = { { 3 , Plan : : Sha ( " " ) } , { 4 , Plan : : Sha ( " " ) } } ;
two . body = { { 3 , true } , { 4 , true } } ;
two . docs = { { 3 , { " h " } } , { 4 , { " h " } } } ;
two . upto = { { 3 , " u " } , { 4 , " u " } } ;
Plan : : CommitCode renamed = two ;
renamed . docs = { { 3 , { " h2 " } } , { 4 , { " h " } } } ;
Check ( " slot keys: two documentation-only commits do not share a slot key (the position is in it); a renamed doc file re-asks the slots of its commit " ,
Plan : : CodeKeyParts ( " p3:absent " , two ) ! = Plan : : CodeKeyParts ( " p4:absent " , two )
& & Plan : : CodeKeyParts ( " p3:outside " , two ) ! = Plan : : CodeKeyParts ( " p3:outside " , renamed ) & & Plan : : CodeKeyParts ( " p3:absent " , two ) ! = Plan : : CodeKeyParts ( " p3:absent " , renamed ) ) ;
Check ( " a hunk is keyed on its file and text, not on its number or its commit; the functional ident is its own " , Plan : : CodeKeyParts ( " p2:hello.py#2 " , cc ) = = Plan : : CodeKeyParts ( " p7:hello.py#5 " , cc )
& & Plan : : CodeKeyParts ( " p2:hello.py#2 " , cc ) . first ! = Plan : : CodeKeyParts ( " p2:other.py#2 " , cc ) . first
& & Plan : : CodeKeyParts ( " p2:hello.py#hdr " , cc ) . first ! = Plan : : CodeKeyParts ( " p2:hello.py#1 " , cc ) . first ) ;
const std : : vector < std : : string > parts = { " repo-bug-prover.md " , " U " , Plan : : Sha ( " T " ) , Plan : : Sha ( " d " ) , " w1 " , " cs " , " 1 " , " " , " max " } ;
Check ( " reuse key: the pre-2026-10-02 formula with the effort slot frozen at max " , Plan : : ReuseKey ( { { " kind " , " block " } , { " unit " , " U " } } , " repo-bug-prover.md " , " T " , { " d " } , { " w1 " } , " cs " , 1 )
= = Plan : : Sha ( Dyn : : Join ( parts , " | " ) ) . substr ( 0 , 16 ) & & Plan : : ReuseKeyEffortSlot = = " max " ) ;
Check ( " code_norm leaves a hunk body alone " , Plan : : CodeNorm ( " @@ -1,2 +1,2 @@ f \n -- \n +index 1..2 \n +@@ -1 +1 @@ " ) = = " @@ f \n -- \n +index 1..2 \n +@@ -1 +1 @@ " ) ;
const Json e = { { " unit " , " p2:hello.py#2 " } , { " coverage " , { { " item " , " p2:hello.py#2 " } , { " verdict " , " clear " } , { " basis " , " b " } } } , { " findings " , Json : : array ( ) } ,
{ " notes " , { { { " note " , " n " } , { " items " , { " p2:hello.py#2 " , " p2:hello.py#1 " } } } } } } ;
const Json r = Plan : : Rebind ( e , " p2:hello.py#3 " ) ;
Json v = { { " verdict " , " SEND-READY " } , { " findings " , r . at ( " findings " ) } , { " notes " , r . at ( " notes " ) } , { " coverage " , { r . at ( " coverage " ) } } } ;
const std : : vector < std : : string > ids = { " p2:hello.py#3 " } ;
const Json n = Normalize : : NormalizeOutput ( v , { } , " repo-bug-prover.md " , " H " , Json : : array ( { { { " id " , " p2:hello.py#3 " } } } ) , ids ) ;
Check ( " rebind: the stored result under the unit's id of today, and it covers the renumbered unit " , r . at ( " unit " ) = = " p2:hello.py#3 "
& & r . at ( " notes " ) . at ( 0 ) . at ( " items " ) = = Json : : array ( { " p2:hello.py#3 " } ) & & e . at ( " coverage " ) . at ( " item " ) = = " p2:hello.py#2 " & & n . at ( " verdict " ) = = " SEND-READY "
& & n . at ( " coverageMissing " ) . empty ( ) ) ;
return Failures ? 1 : 0 ;
}
