SCHEMA.md

# psyche — data dictionary

Every table and every column in `psyche.duckdb`, explained once.

- built: `2026-08-06T04:28:26+00:00`
- from: `psyche-org/psyche-private` @ `03b277d00f92`
- verification policy: recheck decides: CORRECT|CORRECT_WITH_NOTES; self-check: VALID with no hard errors

Generated at build time from the registries in `buildDB/` — see the last section. Do not edit by hand.

## What is published here

| file | what it is |
|---|---|
| `psyche.duckdb` | this database |
| `paper_index.json.gz` | keyword index over every study's paper (`term -> {study: count}`, non-positional) |
| `source_manifest.json.gz` | content hash of every input the build read |
| `metadata_cache.json.gz` | answers already fetched from outside the corpus |
| `SCHEMA.md` | this document |

## How to read this

**Keys.** An *experiment* is `(datasource, study_id, experiment_id)` — that triple identifies one
experiment everywhere in the database. A *study* is `(datasource, study_id)`. `study_id` is the
study's slug, and slugs are unique across datasources with one known exception
(`gershman-bhui-2020` appears under both `openalex` and `opencogdata`), which is why the
datasource is always part of the key.

**Naming.** The column name tells you its shape:

| pattern | meaning |
|---|---|
| `n_*` | a count — integer, never null unless the underlying column is absent from the corpus |
| `*_rate` | a proportion in 0–1, `DOUBLE`; null when the denominator was zero |
| `max_* / min_* / mean_* / median_*` | a statistic over the rows one grain below |
| `*_spec` | the full specification as released upstream, usually high-cardinality text |
| `is_* / has_*` | boolean |
| `*_id` | an identifier, compared for equality only — never ordered or arithmetic |

**Null vs `unknown`.** They mean different things and are not interchangeable:

- `NULL` — not applicable, or genuinely absent from the released data.
- `'unknown'` — *we looked and there was no record*. Used where a row must exist for every
  experiment or study even though the upstream file does not cover it. `has_agent_profile` and
  `studies.record_status` say which case you are in.

**Missing values in `trials`.** The upstream corpus encodes "nothing happened" both as `NULL` and
as the sentinel strings `'none'` and `'psyche_sentinel'`. Anything derived here normalises all
three away; raw `trials` columns still carry them, so filter accordingly.

**Which column means what.** Several columns describe "what the participant did" and they are
**not** interchangeable — `action` is populated in 99% of experiments, `response` in only 55%, and
`keypress` is frequently a placeholder. Derived columns are built on `action`, restricted to
`decision_freedom = 'free'` so that filler trials (press space to continue) cannot be mistaken for
choices. The same split applies to `stimulus_id` (identity), `stimulus_type` (category) and
`stimulus_spec` (unique per trial). See the `trials` table below.

**Sequences and switches.** A *transition* is a consecutive pair of trials within **one
participant's one block** — never across a block boundary and never across participants. It is a
**switch** when the value changed and a **repeat** when it did not. Trials whose value is missing
are skipped rather than breaking the chain, so filler trials interleaved with real ones cannot
hide a switch. At experiment level, counts pool every participant's transitions, so
`response_switch_rate` is over all transitions while `mean_response_switch_rate` averages the
participants' individual rates.

**Only verified experiments are here.** `trials` never contains an experiment that failed
verification, so there is nothing to filter out. `experiment_verification` explains every
experiment, including the ones that were excluded and why.

**New columns.** Task-data columns are declared in `buildDB/postprocessing.py` and metadata
columns in `buildDB/metadata_sources.py`, each with the description reproduced here. This document
and the `column_dictionary` table are regenerated from those declarations on every build, so a
column added upstream of this file appears here automatically — with the conventions above, which
is what a new column is expected to follow. `SELECT * FROM column_dictionary` is the same content,
queryable.


## Tables

### `experiments`

*one row per VERIFIED experiment (view)* — 956 rows

The convenience join: verification + study + paradigm + all experiment-level task data. Start here.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the experiment key. |
| `study_id` | VARCHAR | Part of the experiment key. |
| `experiment_id` | VARCHAR | Part of the experiment key. |
| `verdict` | VARCHAR | The verdict that actually decided. |
| `decided_by` | VARCHAR | Which signal decided: `recheck`, `self`, or `none`. |
| `title` | VARCHAR | Study title, 'unknown' where the repo has no record. |
| `year` | BIGINT | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `paper_doi` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `first_author` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `author_list` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `task_type` | VARCHAR | Study task type, 'unknown' where the repo has no record. |
| `paradigm` | VARCHAR | Paradigm from the agent's profile, 'unknown' where it has no entry for this experiment. |
| `paradigm_status` | VARCHAR | Status of that paradigm label, 'unknown' where absent. |
| `has_agent_profile` | BOOLEAN | False when the agent has no entry for this experiment, in which case paradigm and paradigm_status read 'unknown'. |
| `n_congruency_labelled_trials` | BIGINT | Trials carrying a congruency label. Zero for most experiments — see `congruency`. Non-zero is what makes an interference contrast possible at all. |
| `n_trials` | BIGINT | Rows of trial data. |
| `n_subjects` | BIGINT | Participants with at least one trial. |
| `n_free_trials` | BIGINT | Trials that were a real choice rather than filler. |
| `n_unique_stimulus` | BIGINT | Distinct stimuli presented, by identity. |
| `n_unique_stimulus_type` | BIGINT | Distinct stimulus categories. |
| `n_unique_stimulus_spec` | BIGINT | Distinct fully specified stimulus descriptions. |
| `n_unique_response` | BIGINT | Distinct responses the participant actually made — the task's action space on free trials. The one to reach for. |
| `n_unique_action` | BIGINT | Distinct raw `action` values, including on forced trials. |
| `n_unique_response_label` | BIGINT | Distinct raw `response` values — the rawer label, null for ~45% of experiments. Prefer n_unique_response. |
| `n_unique_keypress` | BIGINT | Distinct physical keys. Describes the apparatus, not the behaviour — often a single placeholder value. |
| `n_blocks` | BIGINT | Distinct blocks the trials are grouped into. |
| `max_trials_per_block` | BIGINT | Longest block, in trials. |
| `n_steps` | BIGINT | Distinct within-trial step indices. 1 means every trial is a single stimulus/response exchange; more means multi-step trials. |
| `max_step` | BIGINT | Deepest within-trial step index reached. |
| `mean_steps_per_trial` | DOUBLE | Average number of rows per trial — 1.0 for single-step tasks. |
| `n_experiment_phases` | BIGINT | Distinct experiment phases (practice, main, ...). |
| `n_task_phases` | BIGINT | Distinct task phases within a trial (study, test, ...). |
| `correct_coverage` | VARCHAR | Where in a trial this experiment records correctness: `all_steps`, `first_only`, `later_only`, `none`, or `partial`. Read it before pooling anything built on `prev_correct`, which is EXCHANGE-WISE and therefore heterogeneous in a way the switch columns are not: a step-wise post-error contrast is well defined where correctness is recorded at every step and undefined where it is recorded only at one, and nothing else in the schema distinguishes them. Cross with `n_multi_step_trials` — the classification only bites where trials have more than one row. |
| `n_multi_step_trials` | BIGINT | Trials made of more than one row. Zero in a single-step experiment, where a row IS a trial and every EXCHANGE-WISE column is therefore trial-wise. Non-zero is the signal that `response_switch` and its relatives are comparing steps within a trial as often as trials. |
| `n_unique_feedback` | BIGINT | Distinct feedback values shown. |
| `n_trials_with_reaction_time` | BIGINT | Trials carrying a usable reaction time — the no-response sentinel does not count. |
| `median_reaction_time_ms` | DOUBLE | Median reaction time in milliseconds, comparable across studies. |
| `n_imputed_trials` | BIGINT | Trials the standardisation had to reconstruct. |
| `n_response_transitions` | BIGINT | Consecutive pairs of trials with a response, within one participant's block — the denominator of the switch rate. |
| `n_response_switches` | BIGINT | Transitions where the response changed. |
| `n_response_repeats` | BIGINT | Transitions where the response stayed the same. |
| `response_switch_rate` | DOUBLE | Share of response transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `n_stimulus_transitions` | BIGINT | Consecutive pairs of trials with a stimulus, within one participant's block — the denominator of the switch rate. |
| `n_stimulus_switches` | BIGINT | Transitions where the stimulus changed. |
| `n_stimulus_repeats` | BIGINT | Transitions where the stimulus stayed the same. |
| `stimulus_switch_rate` | DOUBLE | Share of stimulus transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `n_stimulus_category_transitions` | BIGINT | Consecutive pairs of trials with a stimulus category, within one participant's block — the denominator of the switch rate. |
| `n_stimulus_category_switches` | BIGINT | Transitions where the stimulus category changed. |
| `n_stimulus_category_repeats` | BIGINT | Transitions where the stimulus category stayed the same. |
| `stimulus_category_switch_rate` | DOUBLE | Share of stimulus category transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `min_trials_per_subject` | BIGINT | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `median_trials_per_subject` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `max_trials_per_subject` | BIGINT | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_unique_stimulus_per_subject` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_unique_response_per_subject` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_response_switch_rate` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_stimulus_switch_rate` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |

### `trials`

*one response window per row - see below* — 55,569,237 rows

Column meanings and the definition of a row come from `convention.yaml` — **Behavioral Data Standard** — which is the authority, reproduced here rather than paraphrased. The fill and distinct figures are measured from the data.

**What a row is.** Each row represents exactly ONE response window: a period during which the participant can or should produce a behavioral response. A response window exists when the experiment waits for or accepts participant input (keypress, click, slider), OR when the participant may deliberately withhold a response (go/no-go). A row MUST NOT exist for pure display events (fixation cross, blank screen, feedback with auto-advance, reward display with no keypress) or inter-trial intervals — these are presentation details, not behavioral observations. Data from display-only events (reward_value, feedback) attaches to the nearest decision row. If a presentation parameter varies across trials (SOA, ISI, cue duration), it is a feature of the associated decision row, not a separate row. A row MUST NOT contain multiple responses or reaction times for different events. If a trial involves multiple response windows, each window MUST be a separate row with its own step value. The tuple (subject_id, trial_global, step) MUST uniquely identify rows. `step` MUST always be populated: use 0 for every row in single-step trials, or 0, 1, 2, … for multi-step trials.

| column | type | filled | distinct | meaning |
|---|---|---:|---:|---|
| `datasource` | VARCHAR | 100% | 5 | Which upstream collection the study came from. Added by this build. |
| `study_id` | VARCHAR | 100% | 478 | Study slug. Added by this build. |
| `experiment_id` | VARCHAR | 100% | 18 | Experiment within the study, from `exp_<id>.parquet`. Added by this build. |
| `subject_id` | VARCHAR | 100% | 369,533 | Unique subject identifier. |
| `age` | DOUBLE | 44% | 3,958 | Age of the subject (years, unless otherwise specified). |
| `sex` | VARCHAR | 44% | 3 | Reported/recorded sex of the subject. |
| `gender` | VARCHAR | 36% | 4 | Gender of the subject. |
| `trial_global` | BIGINT | 100% | 41,269 | 0-based sequential trial_global index within subject, reflecting global chronological order. |
| `step` | BIGINT | 100% | 47,799 | 0-based index of sub-steps within a trial. MUST always be populated: 0 for every row in single-step trials, 0, 1, 2, … for multi-step trials where each trial involves multiple participant responses or behavioral observations. |
| `trial_block` | DOUBLE | 100% | 2,560 | Within-subject index (0-based) of the **temporal block**: the finest-grain contiguous chunk of trials in chronological order that the paper describes (e.g. separated by instructions, pauses, procedure changes, or learning- criterion resets). When the paper describes multiple levels of temporal structure (e.g. conditions containing learning blocks), trial_block MUST encode the **innermost / most granular** level — not the outermost. This encodes **temporal run structure** only — it is NOT an experimental factor, condition, or manipulation. |
| `trial_within_block` | DOUBLE | 100% | 8,475 | 0-based sequential trial index within the current temporal block (see column `trial_block`). |
| `imputed` | BIGINT | 100% | 2 | Whether this row is a synthetic observation added during standardization rather than recorded in the raw data. 0 == observed trial; 1 == imputed trial (e.g. padding uncompleted learning blocks after a stopping criterion so paper-aligned analyses can use standard trial-level columns). Default 0 when no imputation was applied. |
| `experiment_phase` | VARCHAR | 100% | 244 | The session segment this row belongs to — the coarsest level of the experiment's temporal hierarchy (experiment_phase → block → trial → step). A FREEFORM name (the set of segments is not fixed and varies by study), e.g. consent, instructions, demographics, practice, main_task, debrief. Non-task segments (consent, surveys, instructions) carry no behavioral rows; the task segment(s) contain the blocks/trials/steps. Distinct from `task_phase` (the functional stage WITHIN the task). |
| `task_phase` | VARCHAR | 70% | 3 | Functional stage of the task itself, within a task `experiment_phase` (NOT the session segment — that is `experiment_phase`). 'study' = exposure or encoding of task-relevant information; 'distractor' = intervening task intended to disrupt rehearsal or introduce delay; 'test' = performance measurement phase (retrieval, decision, or response). |
| `subject_spec` | VARCHAR | 100% | 40,425 | JSON-encoded object of factor(s) attached to the SUBJECT: constant within a subject (across all their rows), varying across subjects (a factor that may repeat, not the subject_id). Between- subject manipulations and counterbalancing groups, e.g. {"response_mapping": "B", "reward_layout": "variant_2"}. {} (empty object) when the study has no between-subject factor. Resolves raw ids to the SEMANTIC labels in `action` / `outcome` when the study counterbalances them. Constant within `subject_id`. |
| `block_spec` | VARCHAR | 98% | 137,793 | JSON-encoded object of factor(s) attached to the temporal BLOCK: constant within a block, varying across blocks (e.g. a per-block reward regime or active rule), {"reward_regime": "rich"}. {} when none. Constant within a `trial_block` (per subject). |
| `trial_spec` | VARCHAR | 100% | 1,556,671 | JSON-encoded object of factor(s) attached to the TRIAL: constant within a trial (across its steps), varying across trials (e.g. the trial's latent state, transition type, true category, or cue value), {"transition_type": "common"}. {} when none. Constant within a `trial_global` (per subject). Whether a key is visible to the participant or latent is decided downstream, not here. |
| `step_spec` | VARCHAR | 90% | 411 | JSON-encoded object of factor(s) attached to the STEP position: the same at each step index across trials, e.g. {"stage": "first"} at step 0. {} when none. Constant within `step`. |
| `decision` | BIGINT | 100% | 2 | Whether this step involves a variable behavioral decision. 1 = decision step: the participant's response varies across trials (choice, classification, judgment, or go/no-go). 0 = non-decision step: a response window exists but the response is constant or forced (e.g., spacebar to dismiss feedback, forced acknowledgment). The participant performs an action but has no meaningful alternative. When decision is 0, encoding columns (encoding_applicable, response_type, feature_vector) MUST be null. |
| `decision_freedom` | VARCHAR | 99% | 3 | Whether the response on this decision step was freely chosen. 'free' (default) = participant chose from multiple available options; 'forced' = only one option was available — no meaningful alternative existed (e.g., single-option stimulus, spacebar acknowledgment press). 'instructed' = multiple options were available but the participant was explicitly told which response to make (e.g., instructed sampling trials in bandit tasks, directed training presses). The participant still physically executes the press; they observe the outcome. Both 'forced' and 'instructed' trials still have a response_type and feature_vector (the structure is observable) but the choice itself was constrained: on 'forced' trials a single option was available, while on 'instructed' trials the participant was told which of several options to choose. Null when decision is 0. |
| `correct_response` | VARCHAR | 27% | 137,840 | Task-defined correct response for this observation, in the same coding as response. |
| `feedback` | DOUBLE | 100% | 2 | Whether performance feedback was provided for this observation. |
| `stimulus_id` | VARCHAR | 94% | 8,248,024 | Unique stimulus identifier. |
| `stimulus_type` | VARCHAR | 95% | 6 | Type of stimulus at the experimental/representational level. This describes the kind of object presented to participants (e.g., text string, geometric symbol, image, abstract feature vector), independent of the underlying storage format (e.g., PNG/BMP/JPG). The value determines the expected schema of stimulus_spec. |
| `stimulus_spec` | VARCHAR | 96% | 7,029,051 | JSON-encoded stimulus specification for the row. If step is null, this is the trial-level stimulus; if step is present, this is the step-level stimulus/event for that row. The JSON object must be parseable and consistent with stimulus_type. Minimal schemas by stimulus_type: - text: {'text': <string>} (optional: 'color', 'font', 'language') - symbol: {'shape': <string>} (optional: 'color', 'size', 'orientation', 'fill', '_asset_ref') - feature_vector: {'features': <object\|list>} (optional: 'feature_names') - mixed: {'components': <list of stimulus_spec objects>} (each component should include its own type) When a stable identifier exists in the source data (e.g., filename, item id), include it as 'asset_ref' or 'id' to preserve traceability. |
| `response` | VARCHAR | 60% | 371,260 | Participant response for this observation (e.g., keypress, option id, category label). |
| `correct` | DOUBLE | 39% | 2 | Behavioral accuracy outcome for this observation. 1 == correct response, 0 == incorrect response. |
| `reaction_time` | DOUBLE | 74% | 7,405,232 | Reaction time of the behavioral response for this observation. EXACTLY THREE mutually-exclusive states, each tied to the response space (keypress/response/subject_input/action) so RT-missingness and response-presence can never be conflated: > 0 — the participant RESPONDED and the latency was measured (units in reaction_time_unit). The response space is populated. null — the participant RESPONDED but the latency was NOT recorded: an untimed / self-paced task, or a source with no per-item RT (e.g. a Qualtrics survey, a self-paced rating). The response space is populated; reaction_time_unit is null. Use null — NOT -1 — for a real response with no RT. -1 — the participant DID NOT respond within the deadline (timeout / missing response). The response space MUST be 'none' (no fabricated choice; keypress never holds a fabricated key). A no-response is STILL scored and MAY carry a real outcome — the consequence of not responding: a correctly-withheld Go/No-Go no-go trial is correct, a missed go trial or a deadline miss is incorrect. What it must NOT carry is a choice that was never made, or an outcome/reward contingent on a choice or event that never happened (a reward credited to a phantom choice, a second-stage screen never reached). -1 is RESERVED for no-response; never use it for "RT unavailable" (that is null) or for a synthetic/padding row (imputed=1 carries no real behavior — null + 'none'). `validate_no_response.py` enforces this pairing. |
| `reaction_time_unit` | VARCHAR | 72% | 3 | Unit of measurement for reaction_time (e.g., ms, s). null when reaction_time is null (untimed / RT not recorded) or -1 (no response). |
| `reward` | DOUBLE | 38% | 3 | Scalar reinforcement outcome associated with this observation from the participant perspective. +1 = positive outcome / gain / correct / rewarded. -1 = negative outcome / loss / incorrect / punished. 0 = neutral outcome (no gain, no loss, no correctness signal). This column represents the task-defined feedback signal used for learning or performance evaluation, not necessarily monetary reward. |
| `reward_value` | DOUBLE | 27% | 563,584 | Magnitude of the outcome the participant OBSERVED on this trial, in native task units (e.g., points, coins, dollars). This is the trial-level feedback signal the participant saw and could learn from — NOT the amount of money actually paid out. The two diverge whenever an observed outcome does not translate directly to money: practice/training trials whose points do not count toward the bonus, 'one random trial is paid' designs, or points that are converted to cash only at the end. In all such cases reward_value records the magnitude shown to the participant (the points/coins displayed), never 0 — a phase being unincentivized is not a reason to zero this column, because the participant still saw the outcome and learned from it. Use null (not 0) when NO outcome was shown on the trial (e.g., a decision step with no feedback): 0 means 'an outcome of zero magnitude was observed', whereas null means 'no outcome was observed'. Do not conflate the two. Whether a trial counted toward payment is a separate property — record it in a dedicated column or state it in the preamble, not by altering reward_value. This is the pre-normalization value used to derive `reward` via sign coding, when applicable. |
| `reward_unit` | VARCHAR | 29% | 5 | Unit/scale of reward_value. 'points' = arbitrary task points; 'usd' = US dollars; 'eur' = euros; 'binary' = outcome coded as -1/0/1 only (no magnitude beyond sign); 'other' = known unit not covered above (prefer adding a new level if it becomes common). |
| `response_type` | VARCHAR | 66% | 4 | Computational response type for this trial step. Determines how to interpret feature_vector. 'choice' = select one of N presented options (response is index into options). 'classify' = assign a category label to a stimulus (response is category index). 'judgment' = produce a scalar rating or estimate about a single stimulus. 'press_or_withhold' = binary motor response (press key or withhold). Null when encoding_applicable is 0. |
| `encoding_applicable` | DOUBLE | 95% | 2 | Whether the trial encoding columns (feature_vector, response_type) are applicable for this decision step. 1 = applicable (feature_vector and response_type should be filled). 0 = not applicable because the task fundamentally requires semantic processing (math verification, logical reasoning, lexical decision, etc.); feature_vector and response_type are null by design. Null when decision is 0 (non-decision steps have no encoding). |
| `feature_vector` | VARCHAR | 60% | 5,167,913 | JSON-encoded object describing the abstract decision structure of this trial step. Structure: options[option][dimension][encoding]. Contains an "options" key (array of per-option feature arrays). len(options) matches number of chooseable alternatives for choice, or 1 for classify/judgment/press_or_withhold. Each option is an array of feature dimensions. Each dimension is a list: categorical features are one-hot encoded (length = number of levels), continuous features are single-element lists ([value]). Empty option (identity only): []. Optional keys: "transformed" (bool) and "transform" (string) when features are not raw observable values (see Rule 16). Null when encoding_applicable is 0 or decision is 0. Example: {"options": [[[1, 0], [0, 1], [1, 0]]]} |
| `keypress` | VARCHAR | 99% | 15,722 | The literal key the participant pressed on this decision row, when the raw data records one (e.g. an E-Prime RESP field): the ground-truth physical key (e.g. "f"). "none" when no real key was recorded — this column NEVER holds a fabricated key. Null when decision is 0. |
| `subject_input` | VARCHAR | 99% | 722,857 | What the participant selected on this decision row, in a single response space used for the whole study, abstracted from the input DEVICE and from trial CONTENT — the link between `keypress` and `action`, equal to neither. The value is one of three kinds: a DISCRETE option/position token, a NUMERIC value (a typed number, slider, or estimate), or a FREEFORM value (free text, or any response that is neither an enumerable choice nor a single number). The column always holds the REAL value the participant produced — an actual token, number, or text. For a SMALL positional choice (a fixed handful of slots — left/right, option_1..N) the value is the SLOT/side the response landed on, never the stimulus that happened to sit there (that identity is the `action`); so subject_input stays distinct from `action` and the two are never collapsed. For an OPEN or LARGE positional response — one drawn from a big or CONTENT-DEPENDENT space (a board square, a clicked grid cell, a map location, a drawn point, a selected target) — there is NO small fixed slot set, so the "slot/side" rule above does NOT apply: subject_input is the FREEFORM/positional kind and MUST hold the REAL location token the participant produced (e.g. the coordinate "j6" or "[3,4]" read from the raw click), NEVER a single collapsed placeholder like "board_square" that throws the location away (that discards the very behaviour being studied). Model such a response as a `value` step (response_kind: value): it renders verbatim as `<<j6>>` and is never mapped to a keypress — the keypress response modes are for SMALL enumerable choices only. Render the trial CONTENT (e.g. the board) as the stimulus so the token is meaningful. "none" when the participant produced no valid input (timeout / non-response; reaction_time=-1). Null when decision is 0. |
| `action` | VARCHAR | 99% | 722,857 | The conceptual choice the subject_input corresponds to on this row's option layout: the chosen option identity, arm, or category — NOT the raw token and NOT the screen position. A SEMANTIC label (e.g. "pine_trail", "birch_trail"), resolved per subject from `subject_spec` when the study counterbalances raw ids. The single source of truth for "what the participant chose", independent of where the option sat on screen. Always non-null on a decision row: a non-response is "none" (or a task-defined default action). Null when decision is 0. |
| `outcome` | VARCHAR | 40% | 495,865 | JSON-encoded consequence of THIS row's action, with a kind: {"kind": "state"\|"end_state", "value": <...>} - "state": a NEW state the action transitions into and that the trial continues from (e.g. the second-stage state of a two-step task, a map location). Non-terminal. - "end_state": a TERMINAL outcome (reward, feedback, win/loss, points). Ends the trial's response sequence. The "value" is a SEMANTIC label (e.g. "ridge", "berry"), resolved per subject from `subject_spec` when the study counterbalances raw ids. null when the action produced no observed consequence on this row. A non-response (subject_input="none") usually has a null outcome, but a task may define a real consequence (e.g. an end_state of 0 / a penalty) when non-responses are scored; never fabricate a state/reward the participant did not earn. The value is the outcome the participant ACTUALLY OBSERVED, read from the raw data in whatever format it is stored there (a column, a code, a nested field) — for both kinds (`state` and `end_state`). It is never derived from `action` or from the action→outcome contingency. Row grammar (structural): outcome.kind == "state" -> the next response window is step+1 of the SAME trial; outcome.kind == "end_state" -> the next response window RESETS to step 0 of the NEXT trial. ==================================================================== EXCEPTION — repeated-measures / repeated-sampling trials (READ THIS) ==================================================================== The end_state rule above assumes a trial has exactly ONE terminal outcome, at its last step. That assumption does NOT hold for repeated-measures paradigms — decisions-from-experience / repeated sampling — where the SAME problem is faced for several consecutive responses, each a complete choose->observe event carrying its OWN observed outcome (e.g. CPC-style feedback gambles faced 5 times per problem; peterson2021_using). In that case — and ONLY that case — a single trial MAY carry repeated end_state steps: step 0..k all with outcome.kind == "end_state", each holding the outcome observed on that repetition, and the trial still RESETS to step 0 of the NEXT trial only after its final step. Recognize it by a CONSTANT problem/stimulus across the trial's steps (the grouping key, e.g. problem_id, lives in trial_spec) paired with a FRESH per-step outcome. This is the SOLE situation in which end_state is not the last step of its trial; in every other trial there is exactly one terminal end_state. Do NOT use this exception to mask a misencoded sequential trial: a genuine multi-step task (e.g. a two-step task) still uses "state" for its non-terminal steps and "end_state" only at the end. ==================================================================== Null when decision is 0. |
| `correct_outcome` | VARCHAR | 4% | 56,847 | The correct answer revealed in feedback, expressed in the SAME space as `action` (e.g. "beta", "vowel"). Taken directly from the data whenever the feedback the participant saw revealed the correct answer. null when no correct answer was revealed to the participant (e.g. reward-learning feedback that showed only an outcome, never the right action). Null when decision is 0. |
| `reaction_time_ms` | DOUBLE | 72% | 7,238,701 | Reaction time in milliseconds, on one scale for the whole corpus. `reaction_time` is NOT comparable across studies as released: 401 experiments record it in ms and 127 in seconds, so averaging them raw mixes 691 with 0.62. Negative values are the corpus's no-response sentinel (-1) and become NULL rather than a reaction time of minus one. Rows whose unit is absent are exactly those sentinels. A unit this does not recognise yields NULL rather than a guess. |
| `congruency` | VARCHAR | 3% | 3 | Whether the trial's features pointed to the same response or competing ones: `congruent`, `incongruent`, `neutral`, or NULL where the study did not label it. Lifted out of `trial_spec` and onto the row because interference is one of the most studied effects in the corpus and should not require every consumer to parse JSON — nor to know that the same contrast is spelled congruent/consistent/compatible depending on the literature it came from. IMPORTANT: this is NOT a universal property of a trial. Only the studies that set out to manipulate congruency record it — 33 of 831 experiments — so an analysis over this column is an analysis of the interference literature, not of the corpus. |
| `response_switch` | BOOLEAN | 90% | 2 | EXCHANGE-WISE. Compares this row to the PREVIOUS ROW in (trial_global, step) order — not necessarily the previous trial. TRUE when the response differs, FALSE when it repeats, NULL at a block boundary or where either row lacks a response. In a single-step experiment a row IS a trial, so this is trial-wise. Where `n_multi_step_trials` is non-zero it crosses within-trial step boundaries, and most comparisons are then against another step of the SAME trial. Use `prev_row_same_trial` to separate the two, or `response_switch_trial` for the strictly trial-wise construct. Both are real transitions — a step is a genuine stimulus/response exchange — but they are not interchangeable: median reaction time by step runs 1933 / 715 / 623 / 428 ms, so mixing them compares an encoding step against a response step. |
| `stimulus_switch` | BOOLEAN | 90% | 2 | EXCHANGE-WISE. Compares this row to the PREVIOUS ROW in (trial_global, step) order — not necessarily the previous trial. TRUE when the stimulus differs, FALSE when it repeats, NULL at a block boundary or where either row lacks a stimulus. In a single-step experiment a row IS a trial, so this is trial-wise. Where `n_multi_step_trials` is non-zero it crosses within-trial step boundaries, and most comparisons are then against another step of the SAME trial. Use `prev_row_same_trial` to separate the two, or `stimulus_switch_trial` for the strictly trial-wise construct. Both are real transitions — a step is a genuine stimulus/response exchange — but they are not interchangeable: median reaction time by step runs 1933 / 715 / 623 / 428 ms, so mixing them compares an encoding step against a response step. |
| `stimulus_category_switch` | BOOLEAN | 91% | 2 | EXCHANGE-WISE. Compares this row to the PREVIOUS ROW in (trial_global, step) order — not necessarily the previous trial. TRUE when the stimulus category differs, FALSE when it repeats, NULL at a block boundary or where either row lacks a stimulus category. In a single-step experiment a row IS a trial, so this is trial-wise. Where `n_multi_step_trials` is non-zero it crosses within-trial step boundaries, and most comparisons are then against another step of the SAME trial. Use `prev_row_same_trial` to separate the two, or `stimulus_category_switch_trial` for the strictly trial-wise construct. Both are real transitions — a step is a genuine stimulus/response exchange — but they are not interchangeable: median reaction time by step runs 1933 / 715 / 623 / 428 ms, so mixing them compares an encoding step against a response step. |
| `prev_row_same_trial` | BOOLEAN | 96% | 2 | TRUE when the previous row — the one every EXCHANGE-WISE column compares against — belongs to the same trial as this row. Lets an analysis separate within-trial step transitions from between-trial ones without recomputing any lag. NULL at the start of a sequence. Always FALSE in a single-step experiment; TRUE for 65.5% of comparisons in the multi-step ones. |
| `prev_correct` | DOUBLE | 43% | 2 | EXCHANGE-WISE. Whether the previous ROW was correct, 1 or 0 — the last earlier row that recorded correctness at all, within the same participant and block. In a single-step experiment that is the previous trial. In a multi-step one it is usually a previous STEP of the same trial. Use `prev_trial_correct` for the trial-wise construct. Unlike the switch columns this one is NOT uniformly available: across the 144 multi-step experiments, 41 record correctness at every step, 12 only at step 0, 10 only at later steps, and 81 not at all. Read `correct_coverage` on the experiment before pooling — a step-wise post-error contrast is well defined in 41 of them and undefined in 22. |
| `is_primary_step` | BOOLEAN | 100% | 2 | (undocumented) |
| `response_switch_trial` | BOOLEAN | 66% | 2 | (undocumented) |
| `stimulus_switch_trial` | BOOLEAN | 66% | 2 | (undocumented) |
| `stimulus_category_switch_trial` | BOOLEAN | 68% | 2 | (undocumented) |
| `prev_trial_correct` | DOUBLE | 30% | 2 | (undocumented) |

### `experiment_verification`

*one row per experiment that has trial data* — 1,140 rows

Why each experiment is in the database — or is not. Both verification signals are recorded for every experiment regardless of which one decided, so a different policy can be evaluated without a rebuild.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the experiment key. |
| `study_id` | VARCHAR | Part of the experiment key. |
| `experiment_id` | VARCHAR | Part of the experiment key. |
| `verified` | BOOLEAN | Whether this experiment's rows are in `trials`. |
| `decided_by` | VARCHAR | Which signal decided: `recheck`, `self`, or `none`. |
| `verdict` | VARCHAR | The verdict that actually decided. |
| `self_verdict` | VARCHAR | The standardisation pipeline's own verdict for this experiment: VALID, INVESTIGATE or ERROR. |
| `self_error_count` | INTEGER | Hard errors the pipeline's own reanalysis reported. |
| `recheck_verdict` | VARCHAR | The independent audit's standing verdict for the study: CORRECT, CORRECT_WITH_NOTES or HAS_ERRORS. Null where no audit exists. |
| `recheck_severity` | VARCHAR | Severity the auditor assigned. |
| `recheck_round` | INTEGER | Which audit round the standing verdict comes from. |
| `recheck_pipeline_verdict` | VARCHAR | What the pipeline had said, as recorded by the auditor. |
| `reason` | VARCHAR | One sentence explaining the decision, for a human. |

### `studies`

*one row per ingested study* — 493 rows

The bibliographic record. Title and task type come from the repo; authors and publication year are resolved from OpenAlex by DOI, because the repo's own `authors` field is a placeholder in every study that has one.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the study key. |
| `study_id` | VARCHAR | Part of the study key. |
| `title` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `year` | BIGINT | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `paper_doi` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `openalex_id` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `task_type` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `n_authors` | BIGINT | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `author_list` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `first_author` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `abstract` | VARCHAR | One row per ingested study: title, publication year, DOI and task type. Year and title are completed from OpenAlex by DOI where the repo does not carry them. Studies with no record at all read 'unknown' rather than going missing. |
| `record_status` | VARCHAR | `enriched` (repo record plus OpenAlex), `no_openalex_record`, `repo_only` (no DOI to look up) or `missing` (no repo record at all — title and task_type read 'unknown'). |

### `study_authors`

*one row per author per study* — 3,987 rows

So an author can be queried directly rather than by matching against a joined string. Position 1 is the first author.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the study key. |
| `study_id` | VARCHAR | Part of the study key. |
| `author_position` | BIGINT | 1 for the first author, ascending. |
| `author_name` | VARCHAR | Author's display name as OpenAlex has it. |
| `author_surname` | VARCHAR | Last whitespace-separated part of the name; convenient, not authoritative. |
| `is_first_author` | BOOLEAN | True at position 1. |
| `is_last_author` | BOOLEAN | True at the final position — the senior author, by convention. |
| `openalex_author_id` | VARCHAR | One row per author per study, so authors can be queried individually: WHERE author_name = '...' rather than LIKE over a joined string. Resolved from OpenAlex by DOI — the repo itself has no real author data. |
| `affiliation` | VARCHAR | One row per author per study, so authors can be queried individually: WHERE author_name = '...' rather than LIKE over a joined string. Resolved from OpenAlex by DOI — the repo itself has no real author data. |

### `experiment_capabilities`

*one row per ingested experiment* — 956 rows

The agent's profile of the experiment. Not every experiment has one; those read 'unknown' and have has_agent_profile = false.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the study key. |
| `study_id` | VARCHAR | Part of the study key. |
| `experiment_id` | VARCHAR | Part of the experiment key. |
| `paradigm` | VARCHAR | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `paradigm_status` | VARCHAR | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `has_agent_profile` | BOOLEAN | False when the agent has no entry for this experiment, in which case paradigm and paradigm_status read 'unknown'. |
| `n_subjects` | BIGINT | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `trials_per_subject` | JSON | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `columns_present` | JSON | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `column_values` | JSON | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `demographic_coverage` | JSON | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `applicable_methods` | JSON | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `jingle_jangle_note` | VARCHAR | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `fingerprint` | VARCHAR | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |
| `profiled_at` | VARCHAR | Per-experiment profile written by the agent's dataset profiler: paradigm, subject count, which canonical columns are populated and what values they take. Every ingested experiment gets a row; the agent has no entry for some, and those read 'unknown'. |

### `study_files`

*one row per tracked file per study* — 14,212 rows

The agent's integrity manifest — content hashes that let a consumer verify a local copy. Studies the agent does not track have no rows.

| column | type | meaning |
|---|---|---|
| `study_slug` | VARCHAR | The study's slug. |
| `datasource` | VARCHAR | Part of the study key. |
| `relative_path` | VARCHAR | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |
| `rfilename` | VARCHAR | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |
| `sha256` | VARCHAR | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |
| `remote_id` | VARCHAR | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |
| `remote_scheme` | VARCHAR | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |
| `size_bytes` | BIGINT | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |
| `synced_at` | VARCHAR | Content hash and size of every file the agent tracks per study — the integrity manifest that lets a consumer verify a local copy. Studies the agent does not track simply have no rows here. |

### `task_data_subject`

*one row per participant per experiment* — 498,362 rows

Derived description of what the task looked like for one participant. Every column is declared in postprocessing.py.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the experiment key. |
| `study_id` | VARCHAR | Part of the experiment key. |
| `experiment_id` | VARCHAR | Part of the experiment key. |
| `subject_id` | VARCHAR | Participant, as text — pinned so this table's schema is stable whichever studies are loaded. Join with CAST(trials.subject_id AS VARCHAR). |
| `n_congruency_labelled_trials` | BIGINT | Trials carrying a congruency label. Zero for most experiments — see `congruency`. Non-zero is what makes an interference contrast possible at all. |
| `n_trials` | BIGINT | Rows of trial data. |
| `n_free_trials` | BIGINT | Trials that were a real choice rather than filler. |
| `n_unique_stimulus` | BIGINT | Distinct stimuli presented, by identity. |
| `n_unique_stimulus_type` | BIGINT | Distinct stimulus categories. |
| `n_unique_stimulus_spec` | BIGINT | Distinct fully specified stimulus descriptions. |
| `n_unique_response` | BIGINT | Distinct responses the participant actually made — the task's action space on free trials. The one to reach for. |
| `n_unique_action` | BIGINT | Distinct raw `action` values, including on forced trials. |
| `n_unique_response_label` | BIGINT | Distinct raw `response` values — the rawer label, null for ~45% of experiments. Prefer n_unique_response. |
| `n_unique_keypress` | BIGINT | Distinct physical keys. Describes the apparatus, not the behaviour — often a single placeholder value. |
| `n_blocks` | BIGINT | Distinct blocks the trials are grouped into. |
| `max_trials_per_block` | BIGINT | Longest block, in trials. |
| `n_steps` | BIGINT | Distinct within-trial step indices. 1 means every trial is a single stimulus/response exchange; more means multi-step trials. |
| `max_step` | BIGINT | Deepest within-trial step index reached. |
| `mean_steps_per_trial` | DOUBLE | Average number of rows per trial — 1.0 for single-step tasks. |
| `n_experiment_phases` | BIGINT | Distinct experiment phases (practice, main, ...). |
| `n_task_phases` | BIGINT | Distinct task phases within a trial (study, test, ...). |
| `n_unique_feedback` | BIGINT | Distinct feedback values shown. |
| `n_trials_with_reaction_time` | BIGINT | Trials carrying a usable reaction time — the no-response sentinel does not count. |
| `median_reaction_time_ms` | DOUBLE | Median reaction time in milliseconds, comparable across studies. |
| `n_imputed_trials` | BIGINT | Trials the standardisation had to reconstruct. |
| `n_response_transitions` | BIGINT | Consecutive pairs of trials with a response, within one participant's block — the denominator of the switch rate. |
| `n_response_switches` | BIGINT | Transitions where the response changed. |
| `n_response_repeats` | BIGINT | Transitions where the response stayed the same. |
| `response_switch_rate` | DOUBLE | Share of response transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `n_stimulus_transitions` | BIGINT | Consecutive pairs of trials with a stimulus, within one participant's block — the denominator of the switch rate. |
| `n_stimulus_switches` | BIGINT | Transitions where the stimulus changed. |
| `n_stimulus_repeats` | BIGINT | Transitions where the stimulus stayed the same. |
| `stimulus_switch_rate` | DOUBLE | Share of stimulus transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `n_stimulus_category_transitions` | BIGINT | Consecutive pairs of trials with a stimulus category, within one participant's block — the denominator of the switch rate. |
| `n_stimulus_category_switches` | BIGINT | Transitions where the stimulus category changed. |
| `n_stimulus_category_repeats` | BIGINT | Transitions where the stimulus category stayed the same. |
| `stimulus_category_switch_rate` | DOUBLE | Share of stimulus category transitions that were a switch, 0-1. NULL when there were no transitions at all. |

### `task_data_experiment`

*one row per experiment* — 956 rows

The same, aggregated over the whole experiment, plus statistics over the per-participant rows.

| column | type | meaning |
|---|---|---|
| `datasource` | VARCHAR | Part of the experiment key. |
| `study_id` | VARCHAR | Part of the experiment key. |
| `experiment_id` | VARCHAR | Part of the experiment key. |
| `n_congruency_labelled_trials` | BIGINT | Trials carrying a congruency label. Zero for most experiments — see `congruency`. Non-zero is what makes an interference contrast possible at all. |
| `n_trials` | BIGINT | Rows of trial data. |
| `n_subjects` | BIGINT | Participants with at least one trial. |
| `n_free_trials` | BIGINT | Trials that were a real choice rather than filler. |
| `n_unique_stimulus` | BIGINT | Distinct stimuli presented, by identity. |
| `n_unique_stimulus_type` | BIGINT | Distinct stimulus categories. |
| `n_unique_stimulus_spec` | BIGINT | Distinct fully specified stimulus descriptions. |
| `n_unique_response` | BIGINT | Distinct responses the participant actually made — the task's action space on free trials. The one to reach for. |
| `n_unique_action` | BIGINT | Distinct raw `action` values, including on forced trials. |
| `n_unique_response_label` | BIGINT | Distinct raw `response` values — the rawer label, null for ~45% of experiments. Prefer n_unique_response. |
| `n_unique_keypress` | BIGINT | Distinct physical keys. Describes the apparatus, not the behaviour — often a single placeholder value. |
| `n_blocks` | BIGINT | Distinct blocks the trials are grouped into. |
| `max_trials_per_block` | BIGINT | Longest block, in trials. |
| `n_steps` | BIGINT | Distinct within-trial step indices. 1 means every trial is a single stimulus/response exchange; more means multi-step trials. |
| `max_step` | BIGINT | Deepest within-trial step index reached. |
| `mean_steps_per_trial` | DOUBLE | Average number of rows per trial — 1.0 for single-step tasks. |
| `n_experiment_phases` | BIGINT | Distinct experiment phases (practice, main, ...). |
| `n_task_phases` | BIGINT | Distinct task phases within a trial (study, test, ...). |
| `correct_coverage` | VARCHAR | Where in a trial this experiment records correctness: `all_steps`, `first_only`, `later_only`, `none`, or `partial`. Read it before pooling anything built on `prev_correct`, which is EXCHANGE-WISE and therefore heterogeneous in a way the switch columns are not: a step-wise post-error contrast is well defined where correctness is recorded at every step and undefined where it is recorded only at one, and nothing else in the schema distinguishes them. Cross with `n_multi_step_trials` — the classification only bites where trials have more than one row. |
| `n_multi_step_trials` | BIGINT | Trials made of more than one row. Zero in a single-step experiment, where a row IS a trial and every EXCHANGE-WISE column is therefore trial-wise. Non-zero is the signal that `response_switch` and its relatives are comparing steps within a trial as often as trials. |
| `n_unique_feedback` | BIGINT | Distinct feedback values shown. |
| `n_trials_with_reaction_time` | BIGINT | Trials carrying a usable reaction time — the no-response sentinel does not count. |
| `median_reaction_time_ms` | DOUBLE | Median reaction time in milliseconds, comparable across studies. |
| `n_imputed_trials` | BIGINT | Trials the standardisation had to reconstruct. |
| `n_response_transitions` | BIGINT | Consecutive pairs of trials with a response, within one participant's block — the denominator of the switch rate. |
| `n_response_switches` | BIGINT | Transitions where the response changed. |
| `n_response_repeats` | BIGINT | Transitions where the response stayed the same. |
| `response_switch_rate` | DOUBLE | Share of response transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `n_stimulus_transitions` | BIGINT | Consecutive pairs of trials with a stimulus, within one participant's block — the denominator of the switch rate. |
| `n_stimulus_switches` | BIGINT | Transitions where the stimulus changed. |
| `n_stimulus_repeats` | BIGINT | Transitions where the stimulus stayed the same. |
| `stimulus_switch_rate` | DOUBLE | Share of stimulus transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `n_stimulus_category_transitions` | BIGINT | Consecutive pairs of trials with a stimulus category, within one participant's block — the denominator of the switch rate. |
| `n_stimulus_category_switches` | BIGINT | Transitions where the stimulus category changed. |
| `n_stimulus_category_repeats` | BIGINT | Transitions where the stimulus category stayed the same. |
| `stimulus_category_switch_rate` | DOUBLE | Share of stimulus category transitions that were a switch, 0-1. NULL when there were no transitions at all. |
| `min_trials_per_subject` | BIGINT | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `median_trials_per_subject` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `max_trials_per_subject` | BIGINT | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_unique_stimulus_per_subject` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_unique_response_per_subject` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_response_switch_rate` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |
| `mean_stimulus_switch_rate` | DOUBLE | How the per-subject task data is spread within an experiment — statistics over rows, which a flat aggregate over trials cannot express. The mean switch rates are the average of the PARTICIPANTS' rates, unlike the experiment-level rate, which pools all transitions. |

### `source_manifest`

*one row per input file the build reads* — 4,138 rows

Content hash of every input, which is what lets an update tell exactly what moved. `ingested` marks the Parquet files whose rows are actually in `trials`.

| column | type | meaning |
|---|---|---|
| `source_path` | VARCHAR | Path of the file in psyche-private. |
| `source_hash` | VARCHAR | Content hash — the LFS SHA-256 where there is one, else the git blob id. |
| `source_size` | UBIGINT | Size in bytes. |
| `role` | VARCHAR | What the build reads it as: `trials`, `control` or `metadata`. |
| `ingested` | BOOLEAN | True when this Parquet file's rows are in `trials`. |
| `datasource` | VARCHAR | Parsed from the path, where the path has one. |
| `study_id` | VARCHAR | Parsed from the path, where the path has one. |
| `experiment_id` | VARCHAR | Parsed from the path, where the path has one. |

### `build_info`

*key/value* — 10 rows

Provenance of this database: when it was built, from which revision of psyche-private, under which verification policy, and the fingerprints of the recipes that produced it.

| column | type | meaning |
|---|---|---|
| `key` | VARCHAR | Name of the property. |
| `value` | VARCHAR | Its value, as text. |

## Where this comes from

| part of the database | declared in |
|---|---|
| what a trial row is, and every `trials` column | `buildDB/convention.yaml` (the upstream standard) |
| which experiments are included | `buildDB/verification.py` |
| the metadata tables | `buildDB/metadata_sources.py` |
| the task-data columns | `buildDB/postprocessing.py` |
| this document | `buildDB/schema_doc.py` |

Adding a task-data column is a name and a function in `postprocessing.py`; adding a metadata table is a declaration in `metadata_sources.py`. Either way the column appears here on the next build, with the description given at the declaration. Nothing about this file is maintained by hand except the conventions and the `trials` column notes, which describe data this build does not own.