milosand1/sec-filings-tone

S&P 500 10-K topic tone profiles, FY2019–FY2026

Data version 0.4.0 (exported 2026-10-18; changes since 0.1.0 under Versioning). provenance.json records the version, the code commit, the model, hashes of the prompt and output schema, and the row count of every table.

Tone scores for passages of S&P 500 10-K filings on five dimensions, toward 13 topics, by Claude Haiku 5.5 (claude-haiku-5-5). The release also has FinBERT and Loughran-McDonald baselines on the same passages, a 40-item human-labeled gold set with its adjudication, and every table the project's published results are computed from. With these files, the project's events.py, diff.py report, comove.py, charts.py and sentiment.py gold-report run with no SEC download, no embeddings and no API calls. Since 0.4.0 the release also has the whole corpus (every chunk, not only the scored ones), its embeddings and the topic query vectors, so the retrieval itself can be redone and extended without fetching filings or calling an embedding API. Results and method: the project's RESULTS.md and PLAN.md.

At a glance (2,683.6 MB in all; every file and column under Files):

Part	Files	Rows	Size
Tone scores and analysis tables	passages, s_passages, q_passages, cells, q_cells, baselines, carryover, rerun, masked, gold_scores (.parquet), plus labels, event definitions and results	126,051 scored 10-K passages, 42,017 cells	25.5 MB
Corpus	chunks.parquet	674,816 chunks	158.5 MB
Embeddings	embeddings.parquet, queries.parquet	674,816 vectors (1,024 floats each), 13 queries	2,499.5 MB

For the scores alone, download only the first part; passages.parquet is the main table.

Source and method

• Companies: the current S&P 500 constituents (498 after merging share classes), with GICS sector and sub-industry from the Wikipedia S&P 500 list.
• Filings: from SEC EDGAR. 10-K Item 1A (Risk Factors) and Item 7 (MD&A), 3,458 10-Ks for fiscal years 2019–2026. FY2026 has only the 74 companies whose fiscal year doesn't end in December. Also 10-Q MD&A for the 76 Financials companies, 1,700 10-Qs with quarters ending 2019-02-28 to 2026-06-30. Sections are split into chunks; a passage is one chunk.
• Cells and retrieval: a cell is one company, one 10-K and one topic (42,017 cells). Its passages are hybrid search's top 3 within that 10-K, with no reranking. Hybrid search fuses vector search (OpenAI text-embedding-3-large, 1,024 dimensions) and BM25, the top 20 of each, by reciprocal rank fusion (k = 60). Each topic has one fixed query (provenance.json, topic_queries). Every topic is scored for every company; "Deposits and liquidity" is scored for Financials only. For AI, each 10-K's MD&A also has its own top 3, searched within it (s_passages.parquet).
• Scorer: claude-haiku-5-5, one call per passage and topic, through the Message Batches API. The prompt quotes the labeling rules (labels/guidelines.md) word for word. The model quotes its evidence before each score and sets an off-topic flag. The dimensions are:
  • polarity, −2 to +2: does the topic help or hurt?
  • magnitude, 0–3: how big is the effect?
  • realization, 0–2: has it happened?
  • uncertainty, 0–3: how unpredictable are the effects?
  • specificity, 0–2: how concrete?
• Baselines: FinBERT (ProsusAI/finbert), the Loughran-McDonald Master Dictionary 1993–2025 and rule-based counts. They score the whole passage, not the topic. The dictionary itself is not included, only each passage's word shares.
• Human labels: 40 passages labeled by one person, blind, then adjudicated (below).

Files

Row counts are for version 0.4.0; provenance.json has them for whichever version you hold. Dates are ISO strings. ticker is the company's ticker in the current S&P 500 list, and fy is the fiscal year as the company labels it.

File	Rows	Size	What it is
passages.parquet	126,051	14.4 MB	Every scored 10-K passage
s_passages.parquet	10,308	0.4 MB	AI's top 3 within each 10-K's MD&A, scored
cells.parquet	84,034	1.7 MB	Every 10-K cell's mean scores, in two versions (42,017 each)
q_passages.parquet	10,196	1.2 MB	Every scored 10-Q passage (Financials)
q_cells.parquet	3,400	0.1 MB	Every 10-Q cell's mean scores
rerun.parquet	5,000	0.9 MB	5,000 random 10-K passages scored a second time
masked.parquet	1,904	0.3 MB	Event-test passages scored again without the company and year
baselines.parquet	85,993	3.1 MB	FinBERT, LM and rule-based scores, one row per chunk
carryover.parquet	223,636	2.6 MB	Share of each 10-K chunk copied from the year before
gold_scores.parquet	40	0.02 MB	The model's scores of the 40 labeled items
chunks.parquet	674,816	158.5 MB	The corpus: text and metadata of every chunk, scored or not
embeddings.parquet	674,816	2,499.5 MB	Every chunk's embedding (1,024 floats), in chunks.parquet's order
queries.parquet	13	0.04 MB	The topic queries and their embeddings
labels/		0.4 MB	Labeling rules, label sheets, adjudication
events.csv, events_quarterly.csv	6, 2		Event definitions, fixed before results
companies.csv	503	0.03 MB	Company list: ticker, name, sector, sub_industry, cik
results/		0.2 MB	The result tables the project's code writes
provenance.json, SHA256SUMS			Versions and hashes; shasum -a 256 -c SHA256SUMS checks every file

2,683.56 MB in all, almost all of it the embeddings. Without the corpus, the embeddings and the *_evidence columns (the project's export --no-text), 10.44 MB.

passages.parquet: the 10-K passages

One row per passage. The key is (ticker, fy, topic, rank, chunk_id).

• ticker, fy, topic: the cell.
• rank: 1–3, the passage's rank in the cell's hybrid search.
• chunk_id: the passage, {ticker}_{form}_{fy}_{item}_{seq}. One chunk can be in several cells.
• pid: the passage's row number in the project's data/tone/passages.parquet, which the project's score files are keyed by. orig_pid in rerun.parquet and masked.parquet points to it. Across data versions, join on the key, not on pid: a new retrieval renumbers it.
• sector: the GICS sector.
• rrf: the passage's fused search score.
• off_topic: the model found nothing about the topic in the passage. Ignore the five scores on these rows. The project's results average over on-topic passages only.
• polarity, magnitude, realization, uncertainty, specificity: integer scores on the scales above.
• polarity_evidence, …, specificity_evidence: the words from the passage the model quoted for each score, or "" if none. This is model output that quotes filing text.
• model: claude-haiku-5-5.
• usd: the call's cost at batch price. The column sums to $18.94.
• item: 1A (Risk Factors) or 7 (MD&A).
• filing_date, report_date (end of the fiscal year), accession (the SEC accession number).
• names_topic: whether the passage passes the word check, the regular expressions in provenance.json (word_check). Only AI, China and tariffs have a word list; every other topic is True. The project's "word-checked" results keep only passages where this is True (see Limitations).

cells.parquet: the 10-K cells

One row per (ticker, fy, topic, version), computed by the project's events.cells().

• sector, filing_date, report_date.
• The five dimensions, plus the baselines finbert_polarity, lm_polarity, lm_uncertainty and details_per_100w: each one's mean over the cell's on-topic passages. They are empty when no passage is on topic.
• discussed: 1.0 if the cell has an on-topic passage, else 0.0. "Not discussed" is kept apart from neutral tone.
• version: model uses every on-topic passage. word-checked uses only those with names_topic.

The cells cover the whole 10-K. Tests limited to one section, such as the section-by-section results, start from passages.parquet and filter on item. For AI in MD&A, the project uses s_passages.parquet instead (next section).

s_passages.parquet: AI within MD&A

The same columns as passages.parquet, for the topic AI only and Item 7 (MD&A) only: each 10-K's top 3 passages searched within its MD&A, not over the whole 10-K. The ranking and query are the same as for passages.parquet. There are 10,308 rows for the 3,436 10-Ks with an Item 7. The key is (ticker, fy, topic, rank, chunk_id).

• Why: a whole-10-K cell has an MD&A passage only where MD&A out-ranks the risk factors, which happened less often as AI risk factors spread.
• Where it's used: the project's MD&A-only analyses of AI use these cells (events.cells): the AI-boom test, the MD&A-alone tests, and the MD&A line of the AI charts. RESULTS.md §3 has the result.
• pid: the row number in the project's data/tone/s_passages.parquet. It is not comparable with passages.parquet's pid.
• Reused scores: 1,572 passages were already scored for the same cell in passages.parquet and copied from there. Their usd is 0 and their batch is the original one. The others cost $0.85, the sum of usd.
• names_topic: as in passages.parquet; 857 rows name AI.

q_passages.parquet and q_cells.parquet: the 10-Q follow-up

The same columns as the 10-K files, for the 76 Financials companies' 10-Q MD&A (item = mdna) and two topics, deposits and liquidity, and interest rates. The key is (ticker, report_date, topic, rank, chunk_id); report_date is the end of the quarter. There is no Q4, because the Q4 report is the 10-K. There is no names_topic column and no word-checked version, since these two topics have no word list.

rerun.parquet: the run-to-run check

The same request, sent again for 5,000 random 10-K passages. It has the same columns as passages.parquet, without names_topic. orig_pid points to the first run's row in passages.parquet (its pid). It is −1 for one passage, which the fiscal-year fix moved out of its cell's top 3; 4,999 still match. Rows are in the order of the project's rerun_passages.parquet.

masked.parquet: the masked-prompt check

1,904 passages from the annual event tests' "before" and "after" cells, scored again with the company and fiscal year taken out of the prompt. The Filing line reads "Filing: a 10-K, Item 1A Risk Factors" instead of naming them (tone.masked_prompt). Its template's hash is masked_user_prompt_template_sha256 in provenance.json, apart from prompt_key. The sample was drawn under the filed "before" rule. It leaves out the 13 companies whose fiscal-year labels were then being fixed. Costs: usd sums to $0.27. RESULTS.md §3 has the result.

• The columns of rerun.parquet, plus:
  • event: the event whose test the passage was drawn for;
  • cell: before or after;
  • group: affected or others.
• orig_pid is −1 for one passage (DOW, FY2022, interest rates), which dropped out of the rankings after the fiscal-year fix; 1,903 still match.
• Rows are in the order of the project's masked_passages.parquet.

baselines.parquet: per chunk

One row per chunk_id in chunks.parquet. Each baseline scores the whole passage, not the topic.

• finbert_polarity: the mean over sentences of P(positive) − P(negative).
• finbert_negative, finbert_positive: the share of sentences whose top label is negative or positive.
• lm_negative, lm_positive, lm_uncertainty, lm_litigious, lm_strong_modal, lm_weak_modal, lm_constraining: each Loughran-McDonald category's share of the passage's words that are in the master dictionary.
• lm_polarity: lm_positive − lm_negative.
• details_per_100w: amounts, percentages, years and product codes per 100 words, a rough specificity proxy.
• hedges_per_100w, realized_per_100w: hedge words and realized-event cues per 100 words.

carryover.parquet: how much is copied from the year before

One row per chunk of every 10-K that has the same company's 10-K for the year before.

• chars: the chunk's characters.
• carried: the characters in sentences that closely match (difflib ratio ≥ 0.9) a sentence of the same item in that earlier 10-K.
• share: carried / chars.
• ticker, sector, fy, item.

It covers all such chunks, not only the scored passages, so the filing-level carryover table can be recomputed.

embeddings.parquet and queries.parquet: for redoing the retrieval

• embeddings.parquet: chunk_id and embedding, a fixed-size list of 1,024 float32 values. One row per row of chunks.parquet, in the same order. These are the vectors the project searched: OpenAI text-embedding-3-large at 1,024 dimensions, embedded as plain text, scaled to unit length. So a dot product is the cosine similarity.
• queries.parquet: topic, query (the fixed text, as in provenance.json) and embedding, the vector each cell was ranked with. Embedding a query again can give a slightly different vector, so use these to reproduce the cells exactly.
• What they let you do: with the corpus, this redoes the project's retrieval with no API call: exact cosine over the embeddings and BM25 (bm25s) over all chunks, each list's top 20 within the filing, fused by RRF (k = 60), top 3. The project's tone.py does this. From this release alone, it reproduced every AI cell of passages.parquet and all of s_passages.parquet exactly (checked 2026-10-18). Searching for a new query needs that query embedded with the same model.

chunks.parquet: the corpus

Every chunk the project searched, scored or not: 10-K Item 1A and Item 7, and the Financials' 10-Q MD&A. Rows are in the project's order, the same as embeddings.parquet. (Until 0.3.0 it held only the chunks of scored passages.) Its columns are those of the project's data/chunks.parquet:

• chunk_id, ticker, sector, form, item, fy, report_date, filing_date, accession.
• period_quarter: the calendar quarter of report_date.
• seq: the chunk's position in its section.
• heading: the heading the chunk falls under.
• text: the passage as extracted from the filing.
• n_tokens: the passage's length in cl100k_base tokens.

gold_scores.parquet and labels/

• gold_scores.parquet: the model's scores (with evidence) of the 40 labeled items, joined on item_id. Same model, prompt, schema and effort as the full run, sent one call at a time rather than batched.
• labels/guidelines.md: the labeling rules, frozen before the gold set was labeled. The scorer's prompt quotes them word for word.
• labels/HOW_TO_LABEL.md: the walkthrough for human labelers.
• labels/practice.csv: 10 hand-picked practice passages (P01–P10) with the labeler's labels.
• labels/practice_blind.csv: the same labels as first made. They differ from practice.csv in one score, which is off the scale (P02's realization of 3), and in how off_topic is written.
• labels/practice_key.csv: the practice sheet's reference scores, with reasons.
• labels/gold_profiles.csv: 30 passages (G01–G30) drawn at random the way the full run picks passages, labeled blind.
• labels/gold_adjudication.csv: one row per item and field where the blind label and the model disagreed (85 rows). It has the labeler's label, the model's label and evidence, the final label after review, and a note.

The sheets include each passage's text (passage column).

companies.csv

The S&P 500 list as fetched once from Wikipedia. It has 503 rows, one per ticker, including both share classes. The columns are ticker, name, GICS sector and sub_industry, and the SEC cik. The event tests read sub_industry to find the affected companies, such as semiconductors for the export controls. In the project it sits at data/companies.csv.

events.csv, events_quarterly.csv and results/

events.csv and events_quarterly.csv define the events. Each row has the event date and, where "after" starts later, an after date. It names the affected sectors and sub_industries, the topics and items, and an expected direction (+, - or empty) per dimension, with a note. All were fixed before the results.

results/ holds the tables the project's code writes, copied unchanged. The annual tests compare each company's last 10-K whose fiscal year ended before the event with its first 10-K whose fiscal year ends on or after it. This is the "one-year rule", primary since 2026-10-17. The earlier rule took the last 10-K filed before the event. Its results are events_filed*.csv.

File	Contents	RESULTS.md section
events.csv, events_named.csv	Event tests, model only and word-checked (one-year rule)	§3, §4
events_filed.csv, events_filed_named.csv	The same, under the filed rule (events.py --filed)	§3
events_1A*.csv, events_7*.csv	The same tests on each section alone	§3
event_study*.csv, event_breaks*.csv	Every fiscal year around each event, and the break check	§3
events_new*.csv	Event tests on new (not copied) passages only	§8
events_whole.csv, events_whole_named.csv	The record of events*.csv before the AI boom used s_passages.parquet: its MD&A cells were the MD&A part of the whole-10-K top 3	§3
events_v1.csv	The first version of the event tests, before the design changes listed in Limitations	Limitations
q_events.csv	The 10-Q event tests: "before" is the last 10-Q filed before the event, as events_quarterly.csv defines	§6
comove.csv	Sector co-movement	§9

Each event-test row covers one event and one measure. It has the expected direction, the companies counted, and for the affected group, the others and their difference (did): the estimate, a 95% bootstrap interval (_lo, _hi) and its sign.

Labels and agreement

Copied from RESULTS.md §1–§2 (2026-10-18).

40 passages (10 hand-picked practice items, 30 drawn at random the way Phase 9 picks passages), labeled by one person, blind, then reviewed where they and the model disagreed.

	Blind labels	After review
Off topic	model flagged 11, person 0; all 11 are off topic on inspection	11 of 11
Polarity (kappa)	−0.08 [−0.39, +0.26]	0.20
Magnitude	0.12 [−0.10, 0.38]	0.72
Realization	0.67 [0.33, 0.88]	0.90
Uncertainty	0.52 [−0.02, 0.78]	0.90
Specificity	0.50 [0.10, 0.81]	1.00

Weighted kappa on the 20 random items both call on topic; 0.6 was the threshold fixed in advance.

• What holds: the off-topic flag, confirmed by hand (none of the 11 passages contains a word for its topic), and realization, which passes on blind labels.
• Why the rest is open: the blind labels scored what each passage says rather than what it says about the topic, which depresses agreement; and in review, 67 of 85 disagreements were settled by adopting the model's label, which raises agreement by construction. Neither column is a clean measure. Polarity can't be judged at all: the model gives −1 to 18 of 20 items.

Full run:

• All 126,051 passages scored, none failed, $18.94 (a smoke test on one company first, $0.05). That includes the fiscal-year fix (2026-10-17): 501 new passages scored and 968 rescored because their request named the wrong fiscal year, for $0.21; $18.94 is what the kept scores cost, and $19.09 was paid in all.

• 24.8% of passages are off topic, and 10% of cells have no on-topic passage ("topic not discussed", kept apart from neutral tone). Rare topics are off topic most often: AI 62%, China 60%, tariffs 53%, against government policy 1% and demand 4%.

• Score spread on on-topic passages:

  Dimension	Distribution
  Polarity	−2: 5%, −1: 86%, 0: 5%, +1: 4%, +2: 1%
  Magnitude	0: 27%, 1: 42%, 2: 29%, 3: 2%
  Realization	0: 47%, 1: 22%, 2: 31%
  Uncertainty	0: 9%, 1: 3%, 2: 78%, 3: 9%
  Specificity	0: 10%, 1: 32%, 2: 58%

  Polarity barely varies, as the project's premise expects for risk language that is negative by design. Realization varies the most.

• Run-to-run stability (B6, 2026-10-17, $0.79): 5,000 random passages scored a second time with the same request (4,999 still match a passage after the fiscal-year fix; recomputed 2026-10-18). The off-topic flag agrees on 97.6%. On passages both runs call on topic:

  Dimension	Identical	Weighted kappa
  Polarity	95%	0.89 [0.87, 0.91]
  Magnitude	75%	0.78 [0.76, 0.79]
  Realization	85%	0.88 [0.87, 0.89]
  Uncertainty	94%	0.89 [0.87, 0.91]
  Specificity	86%	0.84 [0.83, 0.85]

Known limitations

• The off-topic flag is lenient. The gold set confirmed that passages the model flags as off topic are off topic. The reverse error was never measured. RESULTS.md (Limitations) checked it with topic words: of the passages called on topic, those not naming the topic are 52–58% for AI in FY2019–FY2022 (15% in FY2023, 3% in FY2025), 20–23% for tariffs until FY2023 (6% in FY2025) and 20–26% for China in every year (rechecked 2026-10-18). Use names_topic or the word-checked cells for these three topics. The other topics have no clear vocabulary to check.
• Survivorship bias. The companies are today's S&P 500. That leaves out companies that dropped out or went bankrupt, which leans the sample toward companies that did well (PLAN.md, Risks).
• One labeler. One person labeled the gold set, with no second rater. The adjudicated labels lean toward the model, so they can't validate it.
• Magnitude is below the run-to-run bar. Scored twice, the same passage gets the same magnitude 75% of the time (weighted kappa 0.78, under the 0.8 bar set in advance). Averages over many companies absorb that, but single-company magnitude changes are half scorer noise.
• The scorer is told the company and fiscal year, so the event tests are free of labels but not of the model's knowledge of what happened when. The baselines see only the text. Masking both (1,904 event-test passages, $0.27; RESULTS.md §3) leaves realization's changes intact but removes most of COVID's rise in uncertainty (+0.21 → +0.02), which came from FY2019 passages scored as calmer when labeled FY2019. The masked scores are masked.parquet.
• A cell is 3 passages. Which 3 are retrieved can change from year to year (RESULTS.md §9). In the 10-Qs, the top 3 for a fixed topic query favor sections that recur every quarter, so event text is often not scored (RESULTS.md §6).
• Fiscal years are the companies' own. Most end in December; NVDA's ends in January.
• Data versions differ. 0.2.0 corrected 13 companies' fiscal-year labels (Versioning). That changed some cells and renumbered pid: only 0.7% of 0.1.0's pids point to the same passage in 0.2.0. Compare data_version before comparing numbers across releases.
• Extraction gaps. A few sections are missing or cut, such as Deere's 10-K MD&A in every year (PLAN.md, Notes).

How to load

import pandas as pd

p = pd.read_parquet("passages.parquet")
on = p[~p.off_topic]                                   # scores count only on on-topic passages
cell = on.groupby(["ticker", "fy", "topic"])[["polarity", "realization"]].mean()
c = pd.read_parquet("cells.parquet").query("version == 'model'")   # the same cell means, precomputed
text = pd.read_parquet("chunks.parquet", columns=["chunk_id", "text"])
p = p.merge(text, on="chunk_id")

With Hugging Face datasets, by config name from the header:

from datasets import load_dataset

p = load_dataset("milosand1/sec-filings-tone", "passages", split="train")
s = load_dataset("milosand1/sec-filings-tone", "s_passages", split="train")  # AI within MD&A

To rerun the project's code on this release, rebuild its working files from a clone of the repository. Then run the commands in RESULTS.md's "Reproduce" section, from events on. This recipe was checked on version 0.2.0. From it, events (plain, --named, --robust, --filed), diff report and comove rewrote 15 of the 17 files in results/ with identical numbers. On 0.3.0, with s_passages.parquet added to the recipe, events and events --named were rechecked and matched exactly. events_whole*.csv came from code before 0.3.0. On 0.2.0, two files didn't match:

• events_v1.csv came from earlier code.
• q_events.csv differs slightly, with the same verdicts. The project's events.py --quarterly now uses the one-year rule, while the file (and RESULTS.md §6) uses the filed rule that events_quarterly.csv defines. events.report(*events.QUARTERLY[:2], filed=True) reproduces it exactly.

sentiment gold-report (blind and --adjudicated) printed the agreement tables above. tone.masked_report() printed the same output as on the project's own files.

import pandas as pd
from pathlib import Path

R, t = Path("path/to/release"), Path("data/tone")
t.mkdir(parents=True, exist_ok=True)
dims = ["polarity", "magnitude", "realization", "uncertainty", "specificity"]
scores = ["pid", "off_topic", *[c for d in dims for c in (f"{d}_evidence", d)], "model", "usd"]
for pre, cols in [("", ["ticker", "sector", "fy", "topic", "rank", "chunk_id", "rrf"]),
                  ("s_", ["ticker", "sector", "fy", "topic", "rank", "chunk_id", "rrf"]),
                  ("q_", ["ticker", "sector", "fy", "report_date", "topic", "rank", "chunk_id", "rrf"])]:
    x = pd.read_parquet(R / f"{pre}passages.parquet").sort_values("pid")  # pid = row number
    x[cols].to_parquet(t / f"{pre}passages.parquet", index=False)
    x[scores].to_parquet(t / f"{pre}scores.parquet", index=False)
    pd.read_parquet(R / "baselines.parquet").to_parquet(t / f"{pre}baselines.parquet", index=False)
base = ["orig_pid", "ticker", "sector", "fy", "topic", "rank", "chunk_id", "rrf"]
for name, cols in [("rerun", base), ("masked", [*base, "item", "filing_date", "report_date", "cell", "event", "group"])]:
    x = pd.read_parquet(R / f"{name}.parquet").reset_index(names="pid")  # rows in the project file's order
    x[cols].to_parquet(t / f"{name}_passages.parquet", index=False)
    x[scores].to_parquet(t / f"{name}_scores.parquet", index=False)
pd.read_parquet(R / "carryover.parquet").to_parquet(t / "carryover.parquet", index=False)
pd.read_parquet(R / "chunks.parquet").to_parquet("data/chunks.parquet", index=False)
# for sentiment.py gold-report: data/sentiment/gold_scores_claude-haiku-5-5.parquet <- gold_scores.parquet

# optional, to redo the retrieval (tone.py retrieve --section, check): the embeddings and query vectors
import numpy as np, pyarrow.parquet as pq
from sec_filings_tone.tone import QUERIES, VECTOR_ORDER, order_hash
e = pq.read_table(R / "embeddings.parquet")
np.save(t / "vectors.npy", e.column("embedding").combine_chunks().flatten().to_numpy().reshape(len(e), -1))
VECTOR_ORDER.write_text(order_hash(e.column("chunk_id").to_pandas()))
QUERIES.parent.mkdir(parents=True, exist_ok=True)
np.save(QUERIES, np.stack(pd.read_parquet(R / "queries.parquet").embedding))

charts.py writes into the repository's figures/. Since 0.4.0, diff.py carryover can be rerun too, since chunks.parquet has every 10-K chunk.

Versioning

data_version follows MAJOR.MINOR.PATCH. The minor number goes up whenever any score, passage or row changes (0.2.0 for the fiscal-year fix). 1.0.0 is the version frozen for the paper. The same version string is in this card's header, in provenance.json and in the release's name wherever it is published. A later Hugging Face or Zenodo copy names the version it holds, so it can be traced to the GitHub copy.

provenance.json also has a prompt_key: a short hash of the system prompt, the output schema and the user-prompt template. Scores made later with a different prompt will have a different key.

• 0.1.0 (2026-10-17): first export.
• 0.4.0 (2026-10-18):
  • The whole corpus. chunks.parquet now has every chunk, 674,816, not only the 85,993 of scored passages.
  • New tables. embeddings.parquet has every chunk's embedding. queries.parquet has the topic query vectors the cells were ranked with.
  • Nothing else changed. Every other table, score and result is as in 0.3.0.
• 0.3.0 (2026-10-18):
  • New table. s_passages.parquet: AI's top 3 searched within each 10-K's MD&A, 10,308 passages; 8,736 newly scored for $0.85, and 1,572 scores copied from passages.parquet. baselines.parquet and chunks.parquet gain their 6,521 new chunks.
  • Results. In results/events*.csv, event_study*.csv and events_new*.csv, only the AI-boom rows changed. events_whole*.csv keeps the earlier AI-boom results as the record. The other tables are rebuilt from the same project files as 0.2.0.
• 0.2.0 (2026-10-18):
  • Fiscal-year fix. 13 companies' 10-Ks were relabelled: AVY, CDNS, DPZ, ILMN, JNJ, LDOS, LHX, RVTY, SNA, SWK, TDY, TRMB and TXT. 13 10-Ks that had been lost were recovered. The release now has 126,051 passages, 42,017 cells and 3,458 10-Ks; the project's chunks table has 674,816 rows. The usd column now sums to $18.94: 501 passages are new, and 968 were rescored because their prompt had named the wrong fiscal year.
  • Event rule. The one-year "before" rule is now primary for results/events*.csv, event_breaks*, event_study* and events_new*. The filed rule's results are results/events_filed*.csv. The events_fyrule*.csv files are gone, since they were identical to the new primary.
  • New table. masked.parquet, the masked-prompt check.
  • One passage no longer matches. One row of rerun.parquet and one of masked.parquet have orig_pid −1.
  • Smaller fixes. baselines.parquet keeps only chunks in chunks.parquet. The prompt, schema and prompt_key are unchanged.

Licensing

The scores, cells, baselines, labels and result tables are released under CC BY 4.0. Some parts come from third parties and stay under their own terms:

• Filing text (chunks.parquet, the *_evidence columns, the passage column of the label sheets): excerpts of 10-K and 10-Q filings, public documents on SEC EDGAR, written by the filing companies.
• LLM outputs (all scores and quoted evidence): made with Anthropic's API, under its terms.
• Loughran-McDonald: the dictionary is not included, only per-passage word shares derived from it. Its authors make it free for academic use.
• FinBERT (ProsusAI/finbert): only its outputs are included, under the model's license.
• Embeddings (embeddings.parquet, queries.parquet): made with OpenAI's API (text-embedding-3-large), under its terms.
• Sector and sub-industry columns: from Wikipedia's S&P 500 list, under CC BY-SA. GICS is a trademark of MSCI and S&P.

Nothing here is a legal conclusion.