Rarity is a property of the corpus.

A stage whose job is to decide what an organisation believes returned two sentences, each citing as many as 41 repositories as having independently arrived at it. None of them had, and nothing raised an error. The weighting that decides which words in a sentence carry its meaning is a statement about a collection, not about the sentence — and the wrong collection runs the measure backwards where the data is most realistic.

§1The failure arrived as a well-formed answer

An organisation's engineering knowledge is written down inside individual repositories, where it stays. A practice several teams arrived at independently is the organisation's, and nothing in the store says so. The stage these notes are about promotes such a practice to an organisation-level statement once it appears in two or more distinct scopes, and what it promotes is later handed to projects that did not exist when any of it was written. It is counting and string comparison.

Re-measured against a corpus built to have the shape an engineering corpus actually has, it returned two groups where twenty conventions had been planted, the larger holding 41 members.^[7] A group elects one sentence and publishes it as something the organisation believes, cited to every scope inside it. Nothing in that result was catchable: no exception, no empty set, no value out of range.

§2A planted corpus, because the real one is private

A claim about a measure needs a corpus the reader can hold too, and the store this was developed against is private. So the experiment was planted: twenty conventions, each written three times, each of the three in a different scope, all twenty sharing one frame and differing in a single word. Around them sit ordinary notes, one per scope, in two shapes. The realistic shape writes those notes about the same nouns the conventions are about — an organisation writes about its migrations constantly and writes the convention down once. The control shares no vocabulary with them.

// 20 conventions × 3 phrasings, each phrasing in its own scope
const SUBJECTS = [
  "migration", "endpoint", "dashboard", "scheduler", "importer",
  "webhook", "renderer", "validator", "exporter", "indexer",
  "gateway", "collector", "publisher", "resolver", "uploader",
  "tokenizer", "planner", "archiver", "notifier", "compiler"
];

const PHRASINGS = [
  (s) => `Every ${s} is reviewed and tested before it reaches production.`,
  (s) => `A ${s} must be reviewed and tested before reaching production.`,
  (s) => `${s}s are reviewed and tested before they reach production.`
];

const corpus = [];
for (const s of SUBJECTS)
  PHRASINGS.forEach((p, i) => corpus.push({ text: p(s), scope: `acme/${s}-service-${i}` }));

// one ordinary note per scope, to give the pool a realistic size
const NOISE = Number(process.argv[2] ?? 3000);   // 0 · 100 · 560 · 3000
const MODE  = process.argv[3] ?? "subjects";     // realistic | control
const OTHER = ["cache", "buffer", "socket", "cursor", "lease",
               "digest", "shard", "replica", "quota", "probe"];

for (let i = 0; i < NOISE; i++) {
  const noun = MODE === "unrelated" ? OTHER[i % 10] : SUBJECTS[i % 20];
  corpus.push({ text: `Note ${i} about ${noun} config value ${i} in build ${i * 7}.`,
                scope: `acme/noise-${i}` });
}

const SIM = 0.55;   // the bar every arm is run at

Two sentences count as the same practice when their content tokens overlap enough — shared tokens over the union of them, against a configured bar of 0.55. One flat number cannot do that job. Unweighted, pairs from inside one convention overlap 0.667 to 1.000, mean 0.778; pairs from two different conventions, 0.429 to 0.667, mean 0.561. The ranges meet at 0.667, and that overlap is the whole reason a weighting exists.^[6]

Neither piece of machinery is this paper's. Weighting a token by how few documents contain it is term specificity, stated in 1972;^[1] single linkage's habit of extending a chain without regard to the shape of the cluster it builds is textbook, and named — "this chaining can occur even when valid clusters exist".^[3][4] Both behave exactly as their literature says. The defect is in the collection the weights were computed over.

§3Recovery tracks one ratio and nothing else

Take one planted convention: every migration is reviewed and tested before it reaches production. migration says which convention this is; production belongs to the frame all twenty share, so for the grouping to hold the first must outweigh the second. Weigh them over the whole candidate pool and the opposite happens as the pool grows, precisely because the corpus is realistic: the subject is common in an organisation's memory and the frame is rare. Pool-wide rarity measures how often a subject is discussed — not all equally frequent words are equally meaningful.^[5]

Four arms were run over each corpus: single linkage unweighted; with pool-wide weights; the same with each group re-formed around a representative, which is the arm that was shipping; and the same with each group judged against weights computed over that group alone. Recovered counts conventions returned as their own three members and nothing else. The table is the realistic shape; the control runs are in Figure 1.^[7]

three records, three scopes — acme/migration-service-0, -1, -2
Every migration is reviewed and tested before it reaches production.
A migration must be reviewed and tested before reaching production.
migrations are reviewed and tested before they reach production.

pool of 60 · idf migration 1.166 · production 0.265 · ratio 4.392
one group of 3 · 20 of 20 conventions recovered, by each of the four arms

pool of 3,060 · idf migration 0.383 · production 0.497 · ratio 0.771
frame outweighs subject
0 of 20 recovered · 2 groups mixing conventions · largest 41 · 748ms
                              (+ idf + refine, the shipping arm)

§4A group judged against itself

The correction leaves the find pass alone: pool-wide weights still drive it, because its job there is recall and over-merging is undone by the step after it. What changes is that the refinement stops inheriting those weights and judges each candidate group against itself.

const idf = idfOf(candidates);                       // find: pool-wide
const grouped = groupBySimilarity(candidates, similarity, idf)
  .flatMap((g) => refineGroup(g, similarity));        // judge: group-local

Inside a group of three statements of one practice the frame is in every member and carries no weight; the subject is what remains. That is the + local idf arm, and it recovers the twenty at each of the eight corpora measured, including the two where the pool-wide ratio has fallen below the boundary. It costs little — 920ms against 748ms at 3,060 records, 10.3s against 10.1s at 10,060 — and it does not fire eagerly: run against the store these notes were developed on, it promoted one convention, cited to three scopes, out of 326 distilled facts.

§5What the planted corpus cannot settle

The second limit is cost: over the range measured the find pass does not scale in proportion to the records, rising from 647ms at 3,060 to 10,129ms at 10,060 in the realistic shape — 3.3× the records for 15.7× the time. The third is the threshold: 0.55 is a configured default, never tuned against labelled data, and the unweighted ranges in §2 overlap.

The fourth is provenance for the claim itself. That rareness does not imply discriminating power was measured in 1975: terms occurring in one, two or three documents had "rather poor average discrimination ranks".^[2] What is added here is the mirror case, where the frequent token is the discriminating one — which arises because this collection is one organisation's repositories, not a general corpus. We looked for a treatment of that case and did not find one, so it is offered as an observation from one planted corpus, not a result standing on prior work.