How it works

01T1/T2 clone detection — winnowing fingerprint index

Finds exact and parameterized duplicate token runs: renamed variables and changed constants are clones, changed syntax is not.

t = window + kgram - 1 = 26 + 25 - 1 = 50 tokens

Any common run of at least t normalized tokens holds t - k + 1 = w consecutive k-grams, one complete window, whose minimum depends only on its contents, so both copies select it: at least one shared fingerprint, always, the Schleimer et al. SIGMOD'03 no-miss bound held as a correctness contract. The rolling hash is Rabin-Karp, h = (h - t[i-k]*top)*BASE + t[i], over FNV-1a leaf hashes.

02T3 near-miss clones — tree edit distance (TSED)

Judges units whose ASTs are almost the same but whose token streams are not: reshaped and rewritten copies.

TSED(a, b) = (max(n1, n2) - ted(a, b)) / max(n1, n2)
clone      ⇔ TSED >= 0.85

cloneDecidesWith (num, den) t n1 n2 = (mx - t) * den >= num * mx  where mx = max n1 n2

ted is Zhang-Shasha with unit costs (delete = insert = 1, relabel = 0 on matching kind codes, else 1), always integral, so the comparison is an exact cross-multiplication decidable both ways: at max = 100, ted 15 is a clone and ted 16 is not. Two O(1) prefilters, q · tsedDen < tsedNum · max for q ∈ {min(n1,n2), I} with I = Σ_label min(c1, c2), cut pairs before any TED runs; they are admissible because they use the same 85/100.

03Documentation duplication — shingling + MinHash/LSH

Decides whether two documentation blocks (markdown paragraphs, HTML text, plain-text paragraphs, comment blocks, docstrings) are near-duplicates.

dupDecidesWith num den inter union  =  inter * den >= num * union

dupVerdictWith (num, den, vfloor) inter union run
  =  dupDecidesWith num den inter union  ||  run >= vfloor

Bound to (80, 100, 50): Jaccard ≥ 0.80 decided in integers, or a verbatim run of at least 50 words. The core computes inter and union itself from the ascending deduped shingle sets, so raw counts cross the wire, never a ratio. MinHash/LSH is an RNG-free coarse filter (the permutation index is the salt); a run of R shingles spans R + k - 1 words.

04Structure judgment — tree-scale entropy, eight axes

Judges the tree rather than the file: directory geometry, naming distributions, reference locality, documentation coverage, doc staleness, redundancy, modularity.

tsallis2 cs     = 1 - Σ (c/N)^2            -- and = 0 when N == 0
tsallis2Norm cs = tsallis2 cs / (1 - 1/n)  -- n = nonzero bins, n > 1
chi2 pairs      = Σ_{r > 0} (p - q)^2 / q  -- p = o/Σo, q = r/Σr
perMille r      = floor (r * 1000)

charge_i = floor(scale * v_i / (v_i + N))   -- v = flagged dirs, N = dir total
raw      = Σ_axes (charge_i * violCost)
score    = max 0 (scale - raw `div` (structViolCostNeutral * judgedAxisCount))

Shannon entropy and KL divergence need logarithms, not exactly decidable, so the family uses their rational-closed relatives, Tsallis-2 diversity and the χ² f-divergence, over Data.Ratio. Observed mass on a zero-reference bin makes χ² Nothing, a refusal that names those directories. An axis's mass v is its flagged-directory count, charged into ‰ of scale and folded through structViolCostNeutral = 10; judgedAxisCount is 5 to 8, by which optional fact tables rode the wire.

05Scoring and the ADR-006 ratchet

Folds seven axes into one 0–1000 score and gates it against a banked baseline that may only tighten.

raw     = sum_i (w_i * p_i * violCost)
wTotal  = sum_i w_i                            -- derived, never a literal
score   = max 0 (scoreScale - raw `div` (violCostNeutral * wTotal))

p(x) = 0                              if x <= S
     = pMax                           if H <= S          -- degenerate fallback
     = pMax * ((x - S) / (H - S))^2   if S < x <= H
     = pMax * (1 + 2*(x - H)/(H - S)) if x > H           -- C¹ linear arm

m = median(x)
r = median( max(x/m, m/x) )                    -- >= 1 by construction
S = clamp(floor(m * r^k), [softMin, softMax])

tolerated(c) = max (c * tolNum `div` tolDen) (c + tolAbs)

added   = current \ baseline        -- non-empty => fail
removed = baseline \ current        -- informational; drives the shrink

Axis 0, the only one that is not a count, is a convex penalty on file size in exact Rational, monotone past the hard line; pMax is the value at H, not a ceiling. The soft line S is the repository's own frozen LOC statistic, S = clamp(median + k·MAD, …) rewritten multiplicatively so no logarithm is taken, derived at establish and frozen into the baseline. The fail bit is a disjunction of six named conditions, ratchet_over, discrete_added, floor, dedup_budget, knobs_digest, rows_dropped, printed after FAIL in that order.

06Graph liveness and dead-code verdicts

Answers "which files does nothing live reach?" over a reference graph whose node identity is the row index, with no text on the wire.

arcs  = { (s,d) | [s,d,kind,rung] ∈ edges,  rung <= minRung,  kind ∉ inert }
reach = ⋃ { reachable(G, s) | s ∈ entries(entryMask, flags) }

public     = testBit flags 0
referenced = indeg >= 1 over kept arcs
judged     = i ∉ reach
code       = 1 + public + 2*referenced    -- the lookup table is the authority

Four codes keep an exported-but-unreferenced API from collapsing into plain dead: 1 unref_private, 2 unref_public, 3 unreach_private, 4 unreach_public. A site walks its language's rungs in order and the first rung yielding exactly one in-scope candidate wins; more is Unresolved, and External is a correct answer, not a miss. Cycles are reported, never judged; a cyclic island with no entry seed is dead by reachability alone.

07The three-signal join

Combines similarity × graph position × churn into one of four candidate codes, then deliberately declines to act on it.

(1, sev 2, [1,2,3,4], [])    -- merge_candidate:  sim + graph + both referenced + distinct SCCs
(2, sev 3, [1,2,5],   [6])   -- delete_candidate: sim + graph + dead flank, RG10 guard clear
(3, sev 1, [1,2,7,8], [])    -- churn_hotspot:    sim + graph + cochange + rewrite

rewriteHot  = total > 0 && (rewrote_a + rewrote_b) * rewriteDen >= total * rewriteNum
cochangeHot = cochange >= cochangeFloor
legsMask    = legSim .|. (if graphBoth then legGraph else 0) .|. legChurn

Priority is data, not guard order: the first row whose required bits hold and forbidden bits stay clear wins, else code 0, so the property battery can falsify the order by rotating the table. Every gating row requires the graph bit: mask 5 (graph leg absent) carries only code 0 rather than pretending indegree 0.

08Split-ROI seam pricing (four legs)

Prices "is this long file worth splitting, and where?" as a number, an advisory outside the structure score and the fail bit.

benefitMilli(u) = max 0 (floor (1000 * (p(total) - p(end_u) - p(total - end_u))))

costMilli(u)    = crossRefs(u)      * roiRefMilli
                + cutClones(end_u)  * roiCloneMilli
                + crossChurn(u)     * roiChurnMilli
                + roiPhiMilli

viable          ⇔ b >= c            -- ROI >= 1, evaluated without division

Benefit is the graded-zone penalty a split returns, on the same convex curve the verdict family uses (imported, not re-derived); p is convex with p(0) = 0, hence superadditive, so the bracket is non-negative. The best seam is the exact rational argmax over ROI, compared by cross-multiplied b % c; n top-level units give n - 1 seams. Long-and-cohesive gets an exemption with numbers attached, long-and-splittable a cut line.

09Edit four-classification (update supervision)

Reduces every supervised edit to four integer counts per file pair (matched, novel, moved, deleted), so "stacked, not applied" becomes a measurement.

siteOpens s n  =  n * movedCost + s  <  n * plainCost

destFloor      =  least n with siteOpens siteCostCross n   =  2

accepted   = isStart && distinctEvidence >= destFloor && anchored
anchored   = any (\(_,_,w) -> w >= anchorFloor) evidence

The cross-file evidence floor is derived: siteCostCross = 2 makes a single cross line a tie (1*1 + 2 = 3 = 1*3), ties do not open, so destFloor is 2, and that tie is the coincidence rejection. Only anchorFloor = 19 is decided: in the dual-corpus shadow ablation the invented station's widest anchor measured 16 alnum characters and the thinnest real anchor 19, so 19 tops the window that kills every measured coincidence and keeps every real site. The L2 delta moves one way: plain lines may become moved, never the reverse.

10Score trajectory — the trend slope verdict

Is the check score going up, flat or down across history, and by how much per day?

x_i   = ts_i % 86400                 -- seconds to days, exact ratio
y_i   = (score_i * 1000000) % scale_i

slope = median{ (y_j - y_i) / (x_j - x_i) : x_i ≠ x_j }   -- Theil-Sen

slope < -band  → 2  (degrading)
slope >  band  → 0  (improving)
otherwise      → 1  (flat)        where band = floorMicro

% is Data.Ratio's exact-ratio constructor, not modulo; y puts every commit on a fixed 10⁶ full-scale grid, so rows under different scoreScale values compare. The slope is the median of pairwise slopes (trend/2): one wild point drags a least-squares mean anywhere and cannot move the median past its neighbors.

11FPR discipline and the guard tier ladder

A deterministic gate over a non-deterministic writer: on PreToolUse for Write|Edit the guard answers each pending write with exact arithmetic, and a rule class enforces only once it has paid for the right.

TIERS = ["observe", "warn", "ask", "deny"]
PROMOTED_DEFAULT = "deny"

cap      = lines_for(file).file_lines_fail     // the file's class table; 750 for class 0
breach   ⇔ cap != 0 && lines > cap

permille = (lines - S) * 1000 / (H - S)
0   ..= 249  →  observe
250 ..= 750  →  warn
751 ..       →  ask

12Deterministic erase — the safety predicate

Judges erase-plan rows for three provable classes (dead_file, verbatim_doc, t1_twin) and refuses every unsafe row with a named reason code.

class  = 0 (retired 4.0.0, refused by name) | 1 verbatim_doc | 2 t1_twin
         3 dead_file (confidence road, 2.32.0)
reason = 0 eraseable | 1 language_unresolved | 2 not_full_segment
         3 bytes_differ | 4 copy_not_dead | 5 unit_not_covered
         6 public_surface (6.1.0)

Rust assembles integer facts from the three source families; Haskell applies a fixed first-failure predicate. Since proto 2.32.0 class 3 trusts the graph family's per-row confidence; since proto 6.1.0 a public dead verdict (2 unref_public, 4 unreach_public) is refused as public_surface before confidence is weighed, so an exported API is never eraseable; only then does an unvouched confidence refuse the row.

13Unmentioned-declaration advisory — the mention veto

Lists every judged declaration whose name no other file spells, with a visibility code: a negative instrument that never judges.

veto  = another file spells it | fold (Rust, ≥2 segments ∧ ≥7 chars)
        | the file's own exception regions spell it
row   = [node, vis, conv]      (integers only — a name never rides the wire)
emit  ⇔ vis ⊇ {exported, scope-exported} ∧ conv has no exempt bit (0..10)
code  = 1 private > 2 restricted > 3 reexported > 0 public

14Tombstone residue — the erased-name conjunction

Catches the change that erases X from the code and writes it back as an absence: a heading (no X), an identifier without_x, a sentence X is no longer needed.

R     = ⋃ names(before) \ ⋃ alive(after)      (structural positions only; keys, never text)
row   = [kind, marks, names]                  kind ∈ {0 bracketed, 1 bare, 2 prose}
site  ⇔ names ≥ 1 ∧ (kind ≠ 2 ∨ marks ≥ 1)    (the conjunction, read per sentence)
over  ⇔ budget declared ∧ |sites| > budget     (spoken at [tombstone] tier; ships observe)

15Same-role advisor — sparse retrieval and in-repo association

Ranks the units most like one unit (or a text) by integer BM25 over six-channel term bags from the index's facts, and asks the core which play the query's role: an offline "code RAG", no model, no float, advisory only.

bag    = six channels N P C D S L        (facts the parse already carries; hashes, never words)
score  = Σ w · idf · 22·tf·avg / (10·tf·avg + 3·avg + 9·len)   (k1 = 6/5, b = 3/4; integer fixed point)
widen  = top-m PPMI neighbours at ≤ ½ weight    (opt-in view; never evidence)
role   ⇔ (N ≥ 1 ∧ C ≥ 1) ∨ (N ≥ 2 ∧ shapeEqual)  (judged in Haskell over similar/1; advisory only)