yannelli/js-ts-code-review-decisions

JS/TS Code Review Decisions

Training data and a benchmark for a small decision model that flags bad JavaScript and TypeScript code in real time.

The dataset contains 12,000 synthetic code snippets and 27,450 line-level findings. Each snippet has 10 Boolean flaw labels: unclear naming, noise comments, dead code, inconsistent style, over-abstraction, too-clever code, duplicated logic, error handling problems, type safety holes, and unsafe input. Each of the 3,000 tasks has 4 variants: one with no labeled flaws and three with flaws.

The decisions config poses the same data as typed decisions: a snippet is the state, and a model answers 13 typed questions about it at once, each with a probability. The schema follows the System One primitives (noul, choice, score), so a row replays against any API with that shape.

Leaderboard

Results cover the test split of the decisions config: 300 tasks, 1,200 cases, and 15,600 decisions. score_decisions.py evaluates answers to each complete case: state plus all 13 questions. Specialist models are fitted on train and ranked separately from zero-shot general models. This release includes specialist and reference baselines.

Metric	TF-IDF	Prior	Uniform
Macro F1 @ 0.5	0.502	0.000	0.237
Accuracy	0.830	0.766	0.189
Log loss	0.449	0.636	0.895
Brier	0.172	0.230	0.343
ECE	0.030	0.005	0.319

• TF-IDF: TF-IDF + logistic regression, a specialist fitted on train. Implementation: baseline_decisions.py. Local p50 latency: 1.2 ms; local execution rather than API pricing.
• Prior: reference baseline using train label frequencies, without the input.
• Uniform: reference baseline assigning equal probability to every option.

Higher is better for macro F1 and accuracy; lower is better for log loss, Brier, and ECE. 95% intervals for the TF-IDF row: macro F1 0.476 to 0.525, accuracy 0.824 to 0.836, log loss 0.434 to 0.462, Brier 0.167 to 0.176. Latency was measured locally, one case at a time, on 16 Neoverse V3 cores without a GPU. By question type its accuracy is 0.895 on the 11 nouls, 0.482 on primary_flaw, and 0.459 on quality, and it judges 31% of clean test cases clean.

The Prior baseline has the lowest ECE but a macro F1 of 0: it predicts no flaw at the 0.5 cutoff. Report calibration metrics alongside F1 and accuracy.

Metrics

score_decisions.py reports all five metrics, scored and total case counts, and probability mass assigned to unknown options. Partial runs are scored on completed cases.

• Macro F1 at 0.5: F1 for each of the 10 flaw nouls with yes meaning P(yes) at or above 0.5, averaged. This follows the Jev evaluation paper's method for multi-label tasks posed as one yes/no question per label.
• Accuracy: share of the 15,600 decisions where the top answer is the gold one. Nouls use the 0.5 cutoff; choice and score use the most probable option.
• Log loss: minus the natural log of the probability given to the gold answer, floored at 0.000001. Because the gold is a single label, this equals the KL divergence from the gold distribution.
• Brier: (P(yes) minus truth) squared for nouls; the sum over options of (probability minus one-hot gold) squared for choice and score.
• ECE: expected calibration error with 15 equal-width bins, averaged over the 13 questions. Nouls bin P(yes) against the truth; choice and score bin the top probability against whether that option was right.

Intervals are 95% bootstrap intervals from 500 resamples of test tasks; a task's 4 variants move together.

Evaluation reference: Evaluating and Benchmarking the System One Model Jev, §3.4, arXiv 2609.37647. The paper describes Jev's evaluation methodology, not this dataset.

Reading a score

Gold labels come from blind model review, with a separate finding-level audit that accepted 98.3% of findings. Each finding includes its audit_verdict.

The TF-IDF baseline's per-flag F1 ranges from 0.023 on duplicated_logic to 0.880 on noise_comments. Report per-question results and breakdowns by difficulty alongside aggregate scores.

Adding a model

Answer every test case of the decisions config and write one line per case, {"id": ..., "answers": ..., "latency_ms": ...}, where answers is the map the API returned, with full distributions. Then:

uv run --no-project --with pyarrow==26.0.0 --with numpy==2.5.4 python3 score_decisions.py ANSWERS.jsonl

Open a discussion with the tables it prints, the model and version, the date, the mode (specialist or general), the request shape if it was not the whole case in one request, the hardware or endpoint behind the latency, and the price. Keep the answers file so the row can be rescored.

Flaw definitions

These are the definitions used during annotation. A snippet can have several flags; counts are snippets with the flag set to true.

The short names below are used in the results tables.

Naming

unclear_naming · 1,414 positive snippets.

Single letters outside short callbacks, names like data/temp/obj/handle, misleading names, abbreviations a new teammate could not expand.

Comments

noise_comments · 1,743 positive snippets.

Any comment, including JSDoc blocks, comments that explain why, and banners; code should explain itself through names, types and structure. Tool directives such as // @ts-check or // eslint-disable-next-line do not count, and commented-out code is dead_code.

Dead code

dead_code · 2,340 positive snippets.

Commented-out code, unused variables, imports, or parameters, unreachable branches, leftover console.log or debugger. Unused exports do not count, because callers are not visible.

Style

inconsistent_style · 1,437 positive snippets.

camelCase next to snake_case, async/await mixed with .then chains, var next to const, mixed quotes or semicolon use, all inside one snippet.

Abstraction

over_abstracted · 1,337 positive snippets.

An interface with one implementation, a factory or strategy for one case, generic parameters only ever used with one type, options that never vary, wrappers that only forward.

Clever code

too_clever · 1,622 positive snippets.

Nested ternaries, one reduce doing three jobs, bitwise tricks, comma operators, side effects hidden in short-circuit expressions, a regex doing a parser's work.

Duplication

duplicated_logic · 1,757 positive snippets.

The same logic appears two or more times with small variations.

Errors

error_handling_problem · 1,472 positive snippets.

Empty catch, catch that logs and carries on as if the call succeeded, promise with no rejection handling, errors converted to null or false with the cause lost, thrown strings.

Types

type_safety_hole · 1,447 positive snippets.

any, non-null !, as casts on unchecked values, @ts-ignore. In plain JS: loose equality where types can differ, property access on values that can be undefined.

Input

unsafe_input · 1,622 positive snippets.

Request bodies, query params, env vars, file contents, or API responses used unchecked. String-built SQL, innerHTML, eval, file paths built from user input.

For error handling, an awaited or returned promise propagates errors; a local catch is not required.

Example

This training row has two flags. Its code value:

const { CartLineItem, ProductVariant } = require('../models');
const cartReaders = {
    active: async (cartId) => await CartLineItem.findAll({
        where: { cartId, active: true },
        attributes: ['id', 'variantId', 'quantity', 'unitPrice'],
        include: [{ model: ProductVariant, as: 'variant', required: true, attributes: ['id', 'sku', 'color', 'size'] }],
        order: [['id', 'ASC']]
    })
};
const selectCartReader = (mode) => cartReaders[mode];
async function fetchActiveCartItems(cartId = Number(process.env.CART_ID)) {
    return await selectCartReader('active')(cartId);
}
module.exports = { fetchActiveCartItems };

The rest of the row:

{
  "snippet_slug": "query-the-relational-database-to-fetch-active-cart-line-items-and-join-product-variant-attributes-js-cfa9c2b0c6f9",
  "task_slug": "query-the-relational-database-to-fetch-active-cart-line-items-and-join-product-variant-attributes",
  "domain": "shopping-cart",
  "context": "database-access",
  "description": "Query the relational database to fetch active cart line items and join product variant attributes",
  "lang": "js",
  "line_count": 14,
  "unclear_naming": false,
  "noise_comments": false,
  "dead_code": false,
  "inconsistent_style": false,
  "over_abstracted": true,
  "too_clever": false,
  "duplicated_logic": false,
  "error_handling_problem": false,
  "type_safety_hole": false,
  "unsafe_input": true,
  "primary_flaw": "over_abstracted",
  "quality": 3,
  "difficulty": "subtle",
  "uncertain_flags": [],
  "findings": [
    {
      "finding_slug": "over-abstracted-cfa9c2b0c6f9-l2-l12-8521f090",
      "flag": "over_abstracted",
      "start_line": 2,
      "end_line": 12,
      "excerpt": "const cartReaders = {",
      "explanation": "The reader registry and mode selector implement only one strategy, and the sole call always selects 'active', so put the query directly in fetchActiveCartItems rather than routing through a single-case dispatch layer.",
      "audit_verdict": "valid"
    },
    {
      "finding_slug": "unsafe-input-cfa9c2b0c6f9-l11-l11-789284ad",
      "flag": "unsafe_input",
      "start_line": 11,
      "end_line": 11,
      "excerpt": "async function fetchActiveCartItems(cartId = Number(process.env.CART_ID)) {",
      "explanation": "The environment-derived cart ID reaches the database query after numeric conversion alone, which does not validate an identifier and can produce NaN or turn empty input into zero.",
      "audit_verdict": "valid"
    }
  ]
}

Load the dataset

Two configs hold the same 12,000 snippets. default is the flat snippet table with line-level findings. decisions is the same data as typed decisions: one row per snippet with a state, 13 typed questions, and the gold answers.

from datasets import load_dataset
import json

snippets = load_dataset("yannelli/js-ts-code-review-decisions", "default")
example = snippets["train"][0]
print(example["code"])
print(example["findings"])

decisions = load_dataset("yannelli/js-ts-code-review-decisions", "decisions", split="test")
row = decisions[0]
state, questions, gold = (json.loads(row[k]) for k in ("state", "questions", "gold"))
print(gold["dead_code"]["noul"], gold["primary_flaw"]["label"], gold["quality"]["score"])

Both configs have train, validation, and test splits stored as Parquet files. A local copy loads the same way when you pass its folder path to load_dataset.

Decisions config

The schema follows the System One primitives (noul, choice, score) of the TypeSafe API, so a row replays against any API with that shape. state and questions together are the body of a POST /v1/systemone request, minus model. The dataset is independent of TypeSafe.

state is a JSON object with task (the one-sentence task description), language, and code. questions is a JSON map of 13 questions, identical for every row and listed in manifest.json:

• The 10 flaw questions (noul): Does this code have this flaw? Each question is named after its flag, and its criteria carry the flaw definition.
• has_flaw (noul): Does this code have at least one code review flaw?
• primary_flaw (choice): Which problem matters most? 11 options: none plus the 10 flaws.
• quality (score): How mergeable is this code? 5 levels, from "Should not merge." to "Exemplary. Merge as is."

gold stores one answer per question: noul for yes/no questions, label plus one-hot probabilities for choice and score, and score for the score question. Score levels are indexed from 0, so level i is quality i + 1 in the default config. Flat <question>__label, <question>__probability_true, <question>__probabilities, and quality__score columns repeat the same answers for convenience.

Each gold answer is a hard label encoded as a one-hot distribution. One blind model reviewer set each label, and a second model audited every finding. task_slug, lang, difficulty, and uncertain_flags are metadata, not model input.

To replay a case against a System One API and keep its answers in the scorer's format:

import json, time, requests

body = {"state": state, "questions": questions, "model": "jev-latest"}
started = time.perf_counter()
answers = requests.post("https://api.typesafe.ai/v1/systemone", json=body, headers=headers).json()["answers"]
line = {"id": row["id"], "answers": answers, "latency_ms": 1000 * (time.perf_counter() - started)}
print(json.dumps(line))

Write one such line per test case to a JSONL file and score it with python3 score_decisions.py FILE.jsonl from this folder, as described under Leaderboard.

Train and evaluate

Use code as input and the 10 flaw labels as independent binary targets. Include description if the model needs to know the task's intended behavior. Several labels can be true for the same snippet.

A snippet is the training example. Its findings identify individual flaws, with line ranges and explanations. They support label inspection and training for flaw localization. Clean snippets have an empty findings list and all 10 labels set to false.

Keep the labels, findings, primary_flaw, quality, difficulty, and uncertain_flags out of the input. They reveal the answers: every snippet with quality 5 is a clean variant. Report macro F1 over the 10 flags at a 0.5 cutoff as the primary score, then per-flag F1, false positives on clean code, and inference latency on the test split. A threshold for each flag can be tuned on the validation split. To get a leaderboard row, answer the decisions config instead and run score_decisions.py.

Flag baseline

The flag baseline uses the same multi-label metrics: macro F1 with each flag's probability cut at 0.5 is the primary score, with macro F1 at thresholds tuned on validation, threshold-free AUROC and AUPRC, and calibration (Brier score and ECE over 15 equal-width bins). Intervals are 95% bootstrap intervals from 500 resamples of test tasks, with a task's 4 variants resampled together.

The baseline uses TF-IDF over code tokens and one logistic regression per flag, with code as the only input:

• Tokens: identifiers and single punctuation characters, as unigrams and bigrams (min_df=2, sublinear term frequency, case kept).
• Model: scikit-learn 1.9.1 LogisticRegression (C=4, balanced class weights, liblinear, random_state=0), trained on train.
• Tuned thresholds: for each flag, the validation threshold with the best F1, applied unchanged to test.

Test results:

Score	Value	95% interval
Macro F1 @ 0.5	0.574	0.554–0.595
Macro F1, tuned	0.583	0.562–0.602
Micro F1 @ 0.5	0.563	0.542–0.586
Macro AUROC	0.848	0.837–0.860
Macro AUPRC	0.635	0.618–0.659

Per-flag F1

F1 @ 0.5 uses a fixed cutoff; tuned F1 uses per-flag validation thresholds. Short names map to the flaw definitions. Test-positive counts are listed under Label statistics.

Flag	F1 @ 0.5	Tuned F1
Naming	0.848	0.854
Comments	0.920	0.930
Dead code	0.419	0.422
Style	0.418	0.425
Abstraction	0.524	0.532
Clever code	0.590	0.606
Duplication	0.302	0.348
Errors	0.694	0.696
Types	0.521	0.519
Input	0.500	0.496

Ranking

Flag	AUROC	AUPRC
Naming	0.969	0.912
Comments	0.997	0.979
Dead code	0.702	0.469
Style	0.793	0.480
Abstraction	0.868	0.550
Clever code	0.880	0.655
Duplication	0.706	0.337
Errors	0.937	0.808
Types	0.811	0.588
Input	0.818	0.569

Calibration

Flag	Brier	ECE
Naming	0.036	0.089
Comments	0.027	0.097
Dead code	0.169	0.181
Style	0.140	0.217
Abstraction	0.107	0.157
Clever code	0.096	0.136
Duplication	0.130	0.118
Errors	0.072	0.148
Types	0.104	0.159
Input	0.117	0.141

Mean Brier score is 0.100 and mean ECE is 0.144. The balanced class weights push probabilities up for rare flags, which shows in the ECE. At the 0.5 cutoff the baseline flags at least one problem on 178 of the 300 clean test snippets, and on 197 at the tuned thresholds. Naming and comment flags score highest; duplicated logic, dead code, and inconsistent style score lowest.

The leaderboard's TF-IDF row uses the same tokens with one unweighted regression per question and C chosen by validation log loss. That trade is visible in the two sets of numbers: the balanced weights here score 0.574 macro F1 at 0.5 with an ECE of 0.144, while the unweighted row scores 0.502 with an ECE of 0.030, because an unweighted model rarely crosses 0.5 on flags that are true in 11% to 20% of snippets.

Splits

Val denotes the validation split in the tables below.

Count	Train	Val	Test
Snippets	9,600	1,200	1,200
Tasks	2,400	300	300
Clean	2,400	300	300
Findings	22,005	2,746	2,699

All 4 variants of a task share a task_slug and stay in the same split. The supplied splits assign 80% of tasks to training, 10% to validation, and 10% to testing. Keep these splits when training; splitting individual variants can put versions of the same task in both training and evaluation. Packaging refuses to build if a task appears in two splits, if any code value repeats, or if a task does not have 4 variants with exactly one clean.

The snippets cover 40 domains and 13 code contexts. Languages: 4,559 JavaScript, 516 JSX, 6,209 TypeScript, and 716 TSX snippets. manifest.json lists the SHA-256 and row count of every data file to identify the dataset version used in an evaluation.

Label statistics

Positive snippets per flag and split:

Flag	Train	Val	Test
Naming	1,140	135	139
Comments	1,382	183	178
Dead code	1,882	235	223
Style	1,146	144	147
Abstraction	1,061	131	145
Clever code	1,313	145	164
Duplication	1,422	164	171
Errors	1,182	150	140
Types	1,165	134	148
Input	1,290	167	165

Test has 139 to 223 positives per flag, so one snippet moves a flag's test recall by less than 1 percentage point.

Flags per flawed snippet:

Flags	Snippets
1	3,996
2	3,438
3	1,089
4	347
5	116
6	14

Quality scores:

Quality	Snippets	Clean
1	1,250	0
2	3,118	0
3	3,612	0
4	1,100	80
5	2,920	2,920

Difficulty: 3,652 obvious, 7,422 subtle, and 926 borderline snippets.

Class declarations appear in 28.8% of over_abstracted snippets, 29.4% of other flawed snippets, and 27.2% of clean snippets.

Fields

default config

• snippet_slug (string): Unique snippet identifier: task slug, language, and a code hash suffix.
• task_slug (string): Descriptive task name shared by its 4 variants. Use for grouping, not as model input.
• domain (string): Business domain of the task.
• context (string): Code context of the task, such as http-handler or react-hook.
• description (string): One-sentence task description all 4 variants implement.
• lang (string): js, jsx, ts, or tsx.
• code (string): Source code. Lines are split on \n.
• line_count (int64): len(code.split("\n")).
• unclear_naming (bool): True when the snippet has an unclear_naming finding.
• noise_comments (bool): True when the snippet has a noise_comments finding.
• dead_code (bool): True when the snippet has a dead_code finding.
• inconsistent_style (bool): True when the snippet has an inconsistent_style finding.
• over_abstracted (bool): True when the snippet has an over_abstracted finding.
• too_clever (bool): True when the snippet has a too_clever finding.
• duplicated_logic (bool): True when the snippet has a duplicated_logic finding.
• error_handling_problem (bool): True when the snippet has an error_handling_problem finding.
• type_safety_hole (bool): True when the snippet has a type_safety_hole finding.
• unsafe_input (bool): True when the snippet has an unsafe_input finding.
• primary_flaw (string): The most important flag, or none for the clean variant.
• quality (int64): Mergeability from 1 (should not merge) to 5 (exemplary).
• difficulty (string): obvious, subtle, or borderline, defined below.
• uncertain_flags (list<string>): Flags with a defensible competing interpretation. Can name a flag that is false. Empty for most snippets.
• findings (list<struct>): Line-level annotations, using the nested fields below. Empty for clean snippets.

Each item in findings has these fields:

• finding_slug (string): Unique finding identifier: flag name, snippet code hash, line range, and explanation hash.
• flag (string): One of the 10 flag names.
• start_line (int64): First line of the flaw, 1-indexed.
• end_line (int64): Last line of the flaw, 1-indexed and at least start_line.
• excerpt (string): Exact text of start_line, including indentation.
• explanation (string): One sentence explaining the flaw.
• audit_verdict (string): Audit result: valid, invalid, wrong_flag, or wrong_lines.

Line numbers start at 1 and include both endpoints. A flag is true exactly when at least one finding uses that flag.

Difficulty describes how hard the snippet is to judge. obvious means a quick scan is enough; subtle requires closer inspection; borderline means a reviewer could defend a different answer under a plausible reading of a flag definition. Borderline snippets have at least one entry in uncertain_flags.

decisions config

• id (string): The snippet's snippet_slug.
• task_slug (string): Task shared by the 4 variants; the bootstrap unit. Not model input.
• split (string): train, validation, or test.
• lang (string): js, jsx, ts, or tsx.
• difficulty (string): As in default.
• uncertain_flags (list<string>): As in default.
• state (string): JSON object with task, language, and code.
• questions (string): JSON map of the 13 questions, identical for every row.
• gold (string): JSON map of the gold answers, one per question, in the API answer shape.
• n_questions (int64): 13.
• <noul>__label (string): true or false, for the 10 flaws and has_flaw.
• <noul>__probability_true (float64): 1.0 or 0.0.
• primary_flaw__label (string): none or a flaw name.
• primary_flaw__probabilities (string): JSON one-hot over the 11 options.
• quality__label (string): Level index 0 to 4.
• quality__probabilities (string): JSON one-hot over the 5 levels.
• quality__score (float64): The level index as a number.

Files

• data/: train.parquet, validation.parquet, and test.parquet contain the default config: snippets, labels, and findings.
• decisions/: the same three split filenames contain the decisions config: state, questions, and gold.
• manifest.json: SHA-256 and row count of every data file, and the 13 questions.
• eval.yaml: The leaderboard metrics, config, and split.
• score_decisions.py: Scores an answers file on a split; also prints the Prior and Uniform rows.
• baseline_decisions.py: Fits and writes the TF-IDF leaderboard row.
• baselines/: tfidf-logreg.test.jsonl contains that row's test answers, so the row can be rescored.
• LICENSE: CC BY 4.0.

Creation and validation

Language models generated the snippets against a fixed set of tasks and flaw definitions, in three rounds of 1,000 tasks. Model reviewers read the code without seeing the planned labels, recorded findings, and sent failed examples back for repair and another review.

In the second and third rounds, the writer and reviewer were different models, and each flawed variant is a small edit of its task's clean variant, so the planted flaws are the main difference between them. Each of those tasks was also planned around either classes or plain functions, so that declaring a class is about as common with over_abstracted as without it. These rounds also plan dead_code and duplicated_logic more often. The third round used a writer model from a different developer than the first two.

Validation checked JavaScript/TypeScript syntax, unique code, task grouping, field types, label/finding agreement, and finding locations and excerpts. All 12,000 snippets passed those checks.

A separate model audited all 27,450 findings, and audit_verdict records its result.

The noise_comments rule changed after the first round: comments that explained why used to be exempt. First-round snippets were brought under the current rule. A model added 349 comment findings to 220 flawed snippets (120 of which had no noise_comments label before), and comments were removed from 84 clean snippets so they stay clean. The audit accepted all 349 added findings.

For the first-round tasks, a language model later edited task descriptions and finding explanations for clarity. That edit did not change code, labels, line ranges, or excerpts.

Annotation audit

Labels follow the supplied flaw definitions. uncertain_flags records disputed cases.

The audit accepted 26,984 findings (98.30%) and challenged 466: 455 invalid, 6 wrong flag, and 5 wrong line range. Challenged findings remain in the labels; 185 invalid verdicts concern unclear_naming, and 166 positive flag labels rely entirely on challenged findings. Use audit_verdict to select an annotation subset.

The audit proposed 284 additional findings, which are excluded from the released labels. All but one concern snippets already labeled as flawed. The remaining proposal concerns a rejection handler that prints the error and sets exit code 1; its clean label was retained.

Limitations

noise_comments follows a deterministic rule: any comment other than a tool directive or commented-out code sets the flag. A comment detector can classify this label.

Later rounds have fewer borderline snippets: 600 in the first round, 244 in the second, and 82 in the third.

Validation covers syntax and annotation consistency, not execution or type-checking.

Class balance is fixed at 25% clean snippets rather than sampled from production code. Evaluate false positives on code from the deployment environment.

Near-duplicate detection across tasks and public-benchmark overlap checks were not performed.

Privacy

The snippets contain synthetic names and records. A regex scan of all code, descriptions and explanations found 234 email-like strings (35 distinct, on 11 domains, mostly acme.test, example.com and client.test) and 32 IPv4 addresses: the loopback address 127.0.0.1 and addresses in the 198.51.100.0/24 and 203.0.113.0/24 documentation ranges. It found no matches for the phone-number, API-key, access-token, or private-key patterns checked. Privacy screening used these regex checks only.

License and attribution

This dataset is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You can copy, share, and adapt it, including commercially. When sharing it or an adaptation, credit Ryan Yannelli, link to the license, and indicate any changes. The full terms are in LICENSE.

Suggested attribution: Ryan Yannelli (2026), JS/TS Code Review Decisions, CC BY 4.0.

Citation

@misc{yannelli2026jstscodereviewdecisions,
  title        = {JS/TS Code Review Decisions},
  author       = {Ryan Yannelli},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/yannelli/js-ts-code-review-decisions}}
}

Maintainer

Ryan Yannelli | 10/11/2026 | GitHub: @yannelli | Hugging Face: yannelli

Appendix: slug format

task_slug comes from the task description: Unicode NFKD normalization, ASCII conversion, lowercase letters, and hyphens between runs of letters or digits. It has no leading or trailing hyphen.

snippet_slug appends the language and the first 12 hexadecimal characters of the code's SHA-256 hash to the task slug, separated by hyphens. finding_slug combines the hyphenated flag name, that code hash, l<start_line>-l<end_line>, and the first 8 hexadecimal characters of the explanation's SHA-256 hash. Hashes use UTF-8 text.

The hash suffixes distinguish variants and separate findings on the same lines. Slugs depend on their source text and change when that text changes. All slug fields are metadata; exclude them from model inputs.