# Decisions log — HolyCyber dataset The plan asks that every choice (source, filter, label rule, split) is written down so another person can reproduce the dataset. This is that log. Each entry states the decision, why it was taken, and what it cost. --- ## D1 — Task and threat model (step 1) **Decision.** The deliverable is an instruction-tuning corpus for a *defensive* cybersecurity assistant. One row = one entity of one domain, asked one question, answered with a long-form grounded briefing of at least 2,000 tokens (user + assistant, `cl100k_base`). **Why.** The brief asks for "every point of cybersecurity", a 2,000-token floor and at least 1,000 (now 2,000) rows per domain. A per-entity briefing is the only row shape that can reach 2,000 tokens without padding a fact with invented text: the framework records themselves are that long. **Metric.** Row count per domain, token floor per row, duplicate rate, decontamination rate, split integrity. No accuracy metric — the dataset is not a classifier training set. --- ## D2 — Layering: one dataset per domain (step 2, 8) **Decision.** The corpus is partitioned into 17 datasets, one per taxonomy domain (`scripts/taxonomy.py`), each built from its own sources only, plus a global dataset that is their concatenation. **Why.** A user asked for one focused dataset per domain with the others frozen. It also makes the coverage auditable: `dataset/layers/INDEX.md` shows rows, groups, splits and tokens per domain, and a domain that is thin is visible rather than hidden inside a global average. **Cost.** The same framework record (an ATT&CK technique, a CWE) appears in several domains, because a technique is simultaneously a threat, a detection opportunity, a mitigation and a pentest step. Each appearance is a different question; the *source text* is shared, the *rows* are not. --- ## D3 — How a domain reaches 2,000 rows without inventing anything Three mechanisms, in order of how much new material each contributes: 1. **Task shapes** (`scripts/shapes.py`). One record, up to 11 different defensive questions asked of it: what it is, where it sits in the framework, who uses it, how it nests in the tree, how to detect it, how to mitigate it, what it needs as a precondition, how it maps to other frameworks, which weaknesses it relates to, what follows from it, what the code looks like. Each shape is built from a *disjoint* set of sections of that record, so two shapes never repeat the same text. 2. **Reference pack.** A record too short to fill a 2,000-token row is topped up with compact descriptions of other entities *of the same domain*, taken from that domain's own source text. The window rotates per row, so two rows never carry the same padding. 3. **More sources** (step 2). For the domains the existing corpus cannot carry, new public material is fetched and parsed (see `SOURCE_TABLE.md`). **Guard against duplication.** A shape is only emitted if its sections are *not* already present in the entity's base rows (`shapes.build_shape_rows` drops any section whose normalised text already appears in the base cell). A record that is entirely covered by its base row therefore produces one row, not five copies of the same paragraph. **Measured result.** 70–98 % of a row's tokens are the entity's own content; the rest is the shared index material. Across the whole corpus no two rows share an answer (checked by `scripts/verify_layers.py`). --- ## D4 — Decontamination happens at entity level (step 5) **Decision.** Before a domain is built, every entity is checked against the benchmark corpora in `decontam/`: a 25-word shared span, or a CVE id the benchmark uses, disqualifies the entity. Disqualified entities are dropped and never enter the reference pack. **Why.** The first version filtered *rows* only, after packing. A clean row was then dragged into the benchmark by its own padding — the pack was full of records that the benchmark also contains — and 40–60 % of the rows in the KEV-heavy domains were thrown away for text that had nothing to do with the row's subject. Filtering entities first makes the pack clean by construction and the loss is limited to the entities that genuinely appear in the benchmark. **Cost.** The KEV entities that the benchmark also lists are gone from the `vulnerability_management` layer. That is the intended behaviour of the rule (the benchmark must not be trained on), and the loss is recorded per layer in `build/layers/stats.json`. --- ## D5 — Duplicates are removed before splitting (step 5) **Order:** parse → quality gate → exact duplicate removal → near-duplicate removal (MinHash-LSH, 5-word shingles, 112 permutations, 14 bands, Jaccard ≥ 0.90, compared **within a task type only**) → decontamination → split. **Why.** The plan is explicit: "remove exact and near-duplicate rows *before* splitting, so copies cannot land on both sides". Comparing only within a task type is deliberate — a detection row and a mitigation row about the same entity answer different questions and are not duplicates of each other. **Global merge.** After the layers are built, the global dataset drops rows whose answer already appears in another layer, and re-cuts the split on `group_key` across the whole corpus. Result: 0 duplicate ids, 0 repeated answers, 0 groups spanning two splits. --- ## D6 — The split is by source, not at random (step 6) **Decision.** The split unit is `group_key` — the source entity (an ATT&CK technique, a CWE, a KEV entry, a Sigma rule, a paper, a document). All rows about one entity land in the same split. **Why.** This is "split by source" from the plan's checklist, and it is the only split that is meaningful for a corpus of framework records: a random split would put the same technique's detection row in train and its mitigation row in test, which is exactly the leakage the plan warns about. **Time split.** The plan asks for a time split where the data has a time axis. The framework corpora (ATT&CK, CWE, CAPEC, D3FEND, ATLAS, KEV, Sigma) are versioned catalogues, not a time series, so there is no time axis to cut on; the "vintage" of each record is carried in the row metadata instead. The paper corpus does have a time axis (arXiv versions), and its rows are split by paper, so a paper's sections never straddle the split. **Test set.** Locked: the split is computed once from `group_key` with a fixed seed (1337) and every transform (dedup, decontamination, quality) runs *before* it. --- ## D7 — Labels come from the source, not from a model (step 4) **Decision.** Every row's answer is either a verbatim section of a source record or a deterministic re-assembly of such sections. No row is written by a language model; there is no model in the pipeline at all. **Ground-truth check.** `scripts/validate_ground_truth.py` re-derives the source text for a sample of rows and measures how much of each answer is present in that source. The result is reported in `research/GROUND_TRUTH.md`. **Uncertain bucket.** Nothing in the corpus is inferred: a weakness with no stated consequence produces a row about what the catalogue *does* state, and the `CWE` "not specified" fields are rendered as "not specified" rather than guessed. --- ## D8 — No synthetic data, no attack generation (step 3) **Decision.** The plan allows generating data in an isolated lab, and names generators (NetSecBed, LMDG, MalDataGen). This dataset contains **no generated or synthetic rows**: every row is a quote of a public source. **Why.** The owner controls no lab, and generated attack traffic would have to be labelled by a log the plan itself has to be trusted on. Everything here is traceable to a cited public document, which is the stronger property. **Consequence.** The plan's stage 7 ("validate on a second, independent dataset") is answered differently: the second dataset is the *source* — every row is checked against the record it claims to come from — rather than another lab's captures. --- ## D9 — Privacy and secrets (step 5) **Decision.** The corpus is built from public framework catalogues and public standards. CISA KEV entries name products and CVE ids, which are public vulnerability metadata, not personal data. No credentials, keys, personal names, or real IP addresses are present in the sources, and nothing is synthesised into them. The decontamination filter also drops any row that mentions a benchmark CVE id. **Personal data.** The paper corpus is the one place where author names appear; they are part of the scholarly record and are not removed (removing them would corrupt the citation). No email addresses, affiliations of private individuals, or dataset content of private citizens is included. --- ## D10 — Defensive framing (plan's "stay defensive and isolated") **Decision.** Rows describe how to *detect, prevent, scope and remediate*. They contain no functional exploit code, no malware, no weaponised jailbreak prompts, and no operational attack tooling. Where a row names an attack technique, the answer is about the defender's side of it. **The pentest layer** is the one that needs care: its questions are about *authorised* testing ("how do I validate this in an authorised engagement, and what evidence does the report need?"), and the answers are the technique's own defensive record. No exploitation procedure is written. --- ## D12 — Expanding the corpus to reach 2,000 rows per domain (step 2) **Decision.** The corpus was grown from 82 papers to **2,700+ documents**: 2,383 arXiv preprints, 81 IETF RFCs, 137 OWASP cheat sheets and 45 NIST publications. Every fetch is logged in `research/fetch_manifest.csv` with its url, retrieval date and licence. **Why.** At the 1,000-row target the corpus was adequate. At 2,000 rows per domain it was not: the framework catalogues alone give 3,000-8,000 rows in the deep domains and 150-200 in the thin ones, and the only honest way to close a 2,000-row gap is more source material. The arXiv API was queried per domain (`scripts/fetch_sources.py`), and each paper's *sections* are routed to the domain its content is about — a jailbreak-defence section lands in `safety_boundary`, an evaluation-protocol section in `ml_security_methodology` — so the new material lands where it belongs instead of piling up in one domain. **Rejected instead:** paraphrasing the framework records into more rows. It produces rows that read like more data but say the same thing, which is exactly the duplication the brief forbids. **Cost.** 137 MB of source text, ~2,400 HTTP requests, and a corpus that is now dominated by paper-derived rows in the AI, methodology and safety domains. Those rows are quoted verbatim from the paper and carry its arXiv id in `references`, so the citation chain is intact. --- ## D13 — Papers carry only the sections their domain owns **Decision.** A paper usually contributes sections to several domains. When a domain builds its rows, the paper's "record" is built from *that domain's own rows* for that paper, not from the whole file. **Why.** The first implementation used the whole paper as the padding pool, which meant the same paragraph appeared in the `ai_ml_security` layer and the `safety_boundary` layer with two different questions. That is duplication across the corpus, and the global merge was dropping 2,070 rows because of it. **Cost.** A paper's rows are now its own sections plus padding from the same domain's other sections — slightly less context per row, and no repeated text between domains. --- ## D11 — Versioning and reproduction (step 8) **Decision.** The dataset is versioned (`dataset/VERSION`), every layer has a datasheet (`dataset/layers//DATASET_CARD.md`), the global dataset has one (`dataset/DATASET_CARD.md`), and the whole corpus is rebuilt by: ``` python scripts/domains.py # parse -> compose -> gates -> split -> write python scripts/verify_layers.py # independent verification python scripts/validate_ground_truth.py ``` The build is deterministic (seed 1337) and resumable: a layer that already exists in `build/layers/stats.json` is skipped unless `FORCE=1` is set. **Source audit trail.** Every fetched document is recorded in `research/fetch_manifest.csv` with its url, retrieval date and licence, and `research/SOURCE_TABLE.md` is generated from it. --- # Audit round (v2.1.0) Version 2.0.0 met every structural requirement (17 layers, 52,856 rows, floor, splits, no benchmark overlap) and still read badly. An independent audit (`scripts/audit_dataset.py`) measured what the builder could not see about its own output. The findings and their fixes are recorded here and in `research/AUDIT_REPORT.md`. ## D14 — The audit is a separate, replayable stage **Decision.** Auditing is a first-class stage with its own code path (`core`, `dup`, `meta`, `contam`), not an assertion inside the builder. It re-reads the written files and reports counts and examples. **Why.** The builder checks what it enforces (floor, ids, splits). It cannot see, for example, that 80% of rows repeat a heading, because no rule forbids it. The audit found defects the build had no concept of. ## D15 — Questions are built from core sections only **Decision.** The bullet list in the user question is drawn only from the entity's own sections. When a row needed the reference appendix, the question says so in one sentence instead of listing the appendix headings. **Why.** In v2.0.0 the question enumerated every heading of the answer, including the 5–8 appendix records. 80% of rows asked a question that was partly "summarise these unrelated records", and the bullet list leaked the padding. Two rows of one domain could also share a user text. **Cost.** Padded rows now carry one extra sentence, which is a modest amount of additional text and is true: the appendix is requested, not disguised. ## D16 — One labelled block per reference entity **Decision.** A reference-pack entry is flattened into a single block (`## Reference: `); nested headings become bold labels inside it. **Why.** The pack used to paste the neighbour record with all its headings, so a row could contain `## Aliases` twice, or a heading followed by one word (62,981 near-empty sections in v2.0.0). A reader could not tell answer from appendix. ## D17 — A document is parsed once **Decision.** `parse_papers.py` accepts only arXiv ids; RFCs, OWASP sheets and NIST publications go through `parse_docs.py` only. **Why.** 675 rows were produced by parsing a document a second time as if it were a paper (`paper:nist_...`), with a different question. That inflated the row count and duplicated text across two entities. ## D18 — A reference must resolve **Decision.** `common.norm_reference()` normalises every reference: a bare or `arXiv:` id becomes `https://arxiv.org/abs/`; strings that are not URLs are dropped. **Why.** 12,015 rows carried `arXiv:2401.01234`-style strings (and malformed ones such as `arXiv:rfc9000`) in a field a consumer would try to dereference. ## D19 — Difficulty follows the task, not the parser **Decision.** `dossier.difficulty_for()` maps task types to a level (definition/identification → beginner, mapping/analysis → advanced, review/remediation → intermediate). **Why.** v2.0.0 was 0.3% beginner, 47% intermediate and 53% advanced because each parser passed its own constant. A beginner asking for a definition got an "advanced" row. ## D20 — The corpus is cleaned at the boundary **Decision.** `common.clean()` decodes HTML entities twice, unwraps LaTeX text commands, removes `\ref`/`\cite`/`\begin`, joins PDF hyphenation, and drops U+FFFD, zero-width and control characters. `parse_papers.py` removes the arXiv landing-page block (title, stamp, authors, affiliations, thanks), repeated page furniture and bibliographies. `parse_docs.py` removes the per-page RFC header and footer. **Why.** The audit found the arXiv stamp inside answers, `\url` fragments, `<` in prose, `[Page 5]` running footers, U+FFFD in 140 rows and mojibake. ## D21 — Every corpus file has provenance **Decision.** `scripts/fix_manifest.py` removes the duplicate copies of papers that were fetched both under a bare id and a versioned id, and adds a manifest row for every file that lacked one. The manifest is now exactly one row per corpus file. **Why.** 17 papers were parsed twice (16 byte-identical) and 65 files had no provenance row, so a row's `license` field could not be traced. ## D22 — A long cell is delivered in numbered parts **Decision.** When one cell is split into several rows, each question says "This is part N of M". **Why.** The chunks of one cell shared an identical user text (2,331 rows in the v2.1 draft), so a consumer would see the same question with different answers. ## D23 — Reuse is measured, not denied **Decision.** Each layer card reports the share of a row's tokens that is the entity's own material, and the appendix is always labelled. The README no longer claims a quotation percentage that was never measured. **Why.** With a 2,000-token floor, 2,000 rows per domain and a source corpus only about twice the size of the output, some text must be reused. The honest answer is to make the reuse visible and measure it, not to claim it does not happen. ## D24 — Four defects the audit found, fixed at the source **Decision.** The v2.2 build fixes four classes of defect rather than patching the files: 1. A heading that occurs twice inside one answer is marked as a continuation (`## Introduction (continued)`), because a repeated heading reads like a build error. 2. Structural labels (`Answer`, `Context`, `Role note`, `Direct answer`) are no longer used as question bullets: asking a model to "cover Answer" is noise. 3. A block larger than the row ceiling is split at sentence boundaries, not at a token boundary, so a row does not end mid-sentence. 4. Two cells of one entity that share a question now get an explicit `Angle:` line naming the cell's subdomain and task — a duplicate question in an instruction set is a defect even when the answers differ. Publisher stamps (`©`, `ISBN`, `ISSN`) are stripped from paper text, and U+FFFD/mojibake residue is removed as a final pass. **Second pass (same version).** Re-reading the written rows found four more, so the fix is bigger than the first list: 5. A structural label was also used as a *heading*: 6,476 rows opened with `## Answer`, `## Context` or `## Role note`. The renderer now renames the two that carry meaning (`Answer`/`Direct answer` → `Summary`, `Context` → `Background`, `Role note` → `Scope note`) and drops the rest. A shaped row now opens with `## Summary` instead of a bare framing sentence. 6. A trailing fragment of at most 25 words with no sentence end is dropped (`_trim_tail`). Paper text arrives from PDF extraction and can stop mid-sentence or on a figure caption; the checker went from 38 % of rows in a paper layer to 5 %, and the remainder is table rows, citations and page numbers. 7. Duplicate questions are handled where they occur: within a layer, at the entity (not the cell) level, with an `Angle:` line that names the subdomain, the task and the entity; across layers, the global merge drops the second copy. A question is unique in the delivered dataset. 8. A one-word section (`## Platforms` / `Windows`) is not an empty section — only `n/a`-style bodies are. The audit's definition was corrected rather than the data. **What this cost.** Four full rebuilds (each ~20 minutes) and the audit re-run with them. What it bought is measurable in `research/AUDIT_REPORT.md` §2.13 and §5. ## D25 — Reviewing a comparable public dataset, and taking only its presentation **Decision.** `Vyber07/cyber-security` (gated, ~95 GB, Apache-2.0, 5,203 downloads/month) was reviewed structurally. Its data organisation was **not** adopted: 264 of 965 files carry a `__dup` marker, the same file is stored at the root and in a per-domain folder, there are no train/val/test splits, no per-record provenance, and the licence is asserted over scraped text it cannot cover. What was adopted is its **notation**: a per-domain card that opens with an overview and a coverage table, an explicit record format with a JSON example and a field table, a "what a record contains" section, a sources table, a statistics table, a usage section, and a licence section. This dataset adds what that one lacks: verified splits, measured duplication, per-row provenance and a limitations section. See `research/EXTERNAL_REVIEW.md`. **Why.** Presentation is what makes a dataset readable; substance is what makes it usable. Copying the first without the second is how a 95 GB file dump gets 5,203 downloads a month, and copying neither is how a good dataset stays unread. ## D26 — Measuring four public cyber instruction datasets, and adopting metadata not prose **Decision.** Four public sets were downloaded in full and measured (`scripts/external_compare.py`, results in `build/external/compare.json`): Trendyol (53,201 rows), Fenrir (99,870), Kimi (997), WhiteHatMom (2,040). The fifth proposed link, `cyberagent/crello`, is a graphic-design dataset and was excluded. What was **adopted**: per-row measured metadata (`tokens`, plus `core_share` and `appendix` that are specific to this design), a dated changelog, a `## Using the metadata` section with filter and mask snippets, and rendered sample rows (`dataset/SAMPLES.md`). What was **rejected**: LLM-distilled reasoning traces without a source (Kimi), instruction-hierarchy override prompts (Kimi), slot-filled question templates (Fenrir: 9,214 duplicate questions), literal `\n` stored as text (95.4% of Trendyol, 91.2% of Fenrir), split claims that the files do not contain (Trendyol), and blanket Apache-2.0 over harvested text. **Why.** The measurements show the two largest sets are one lineage: every one of Trendyol's 52,526 unique questions appears in Fenrir, so training on both double-counts them while appearing to offer 153k rows. Copying their prose would copy their defects; copying their *presentation* and adding measurements is what makes this dataset checkable. Verbatim paragraph overlap between HolyCyber and all four is 0, which rules out text-level contamination in either direction. ## D27 — Repairing text after a build: id, stats and metadata must move together **Decision.** A post-build text repair (`scripts/fix_part1_phrase.py`, 2,073 global rows that said "part 1 of N ... continuing where the previous part stopped") recomputes the row `id` (it hashes user + assistant), then `scripts/add_row_metadata.py` recomputes `tokens` / `core_share`, then `scripts/recompute_stats.py` recomputes the aggregates in `build/stats.json` and `build/layers/stats.json`, then cards and README are re-rendered. **Why.** Without the id recompute the content hash would silently lie; without the stats recompute the cards would keep reporting the pre-repair token total (127,661,406) and floor. The measured post-repair figures are 51,805 rows / 127,643,325 tokens / min 2,050 / 0 rows under the floor. ## D28 — A question must not name a section the answer does not cover **Decision.** The document lead read "The section "1. Introduction" is the part I need", but a long document is split into parts: 1,010 part rows carried that pointer and 971 of them named a section the part does not start with (105 named page furniture such as `100 Bureau Drive`). The pointer is now removed for part rows (builder: `dossier.lead_for_part`; written files: `scripts/fix_lead_section.py`, 2,020 rows including layer copies, ids recomputed). Quoting the part's own first heading was tried and rejected: the headings are often resource-record dumps, so it would swap one wrong pointer for another. **Why.** A wrong pointer is worse than no pointer: it tells the reader to check a section the answer is not about, and it is the kind of defect that survives a token-floor check because it does not change length. The bullet list already names the headings the part covers. **Known residue.** The same parsing weakness still turns a few RFC record dumps into headings and question bullets; fixing it needs a page-furniture filter in the document parser and is listed as open in `research/AUDIT_REPORT.md` (2.14).