flonat-research 0.1.0

package/skills/shared/intercoder-reliability.md

@@ -0,0 +1,256 @@
+# Inter-Coder Reliability & LLM Annotation Validation
+
+> Shared reference for content analysis, LLM annotation, and coding studies. Covers both human-coder and multi-model reliability assessment. Adapted from CommDAAF AgentAcademy protocol (Xu 2026).
+
+## Principle
+
+**Always report reliability per category, not just aggregate.** A global κ of 0.7 can hide the fact that one frame has κ = 0.3 — which means that frame's results are unreliable. Frame-specific (or category-specific) reliability is the minimum standard.
+
+---
+
+## When This Applies
+
+- Any content analysis with 2+ coders (human or LLM)
+- LLM annotation studies using multiple models
+- Survey coding or qualitative coding with multiple raters
+- Any study reporting inter-coder or inter-model agreement
+
+---
+
+## Metrics to Report
+
+### For 2 coders
+
+| Metric | When to use | Interpretation |
+|--------|------------|----------------|
+| **Cohen's κ** | Two coders, nominal categories | Chance-corrected agreement |
+| **Weighted κ** | Two coders, ordinal categories | Accounts for degree of disagreement |
+| **% Agreement** | Supplement only | Not chance-corrected; report alongside κ |
+
+### For 3+ coders (including multi-model LLM)
+
+| Metric | When to use | Interpretation |
+|--------|------------|----------------|
+| **Fleiss' κ** | 3+ coders, nominal categories | Multi-rater chance-corrected agreement |
+| **Three-way agreement** | 3 models, quick check | Proportion where all 3 agree |
+| **Majority agreement** | 3 models, voting | Proportion where ≥2/3 agree |
+| **Pairwise κ** | 3+ coders, diagnostic | Which pairs agree/disagree |
+| **Krippendorff's α** | Any number of coders, any scale | Most general; handles missing data |
+
+---
+
+## Thresholds
+
+| κ range | Interpretation | Action |
+|---------|---------------|--------|
+| < 0.20 | Poor | Do not use this category. Redefine or merge. |
+| 0.20–0.40 | Fair | Flag. Consider retraining or revising codebook. |
+| 0.40–0.60 | Moderate | Acceptable for exploratory. Report limitation. |
+| 0.60–0.80 | Substantial | Acceptable for publication. |
+| > 0.80 | Excellent | Strong agreement. |
+
+**Publication threshold:** κ ≥ 0.7 (or α ≥ 0.7 for Krippendorff's α).
+
+**LLM annotation minimum:** Human validation sample N ≥ 200, κ ≥ 0.7 between LLM and human.
+
+---
+
+## Category-Specific Reliability
+
+### Why aggregate isn't enough
+
+```
+Aggregate Fleiss' κ = 0.72  ← looks fine
+
+Per-category:
+  SOLIDARITY:    κ = 0.89  ✅
+  INJUSTICE:     κ = 0.81  ✅
+  MOBILISATION:  κ = 0.74  ✅
+  HUMANITARIAN:  κ = 0.31  ⚠️  ← this category's results are unreliable
+  CULTURAL:      κ = 0.65  ⚠️  ← borderline
+```
+
+If HUMANITARIAN has κ = 0.31, any finding about that category should be treated as exploratory regardless of the aggregate score.
+
+### Implementation
+
+```python
+from sklearn.metrics import cohen_kappa_score
+import itertools
+
+def category_specific_reliability(coded_data, code_var='frame', coders=None):
+    """
+    Calculate reliability per category across all coders.
+
+    coded_data: list of dicts, each with '{coder}_{code_var}' keys
+    coders: list of coder names (e.g., ['claude', 'glm', 'kimi'] or ['coder1', 'coder2'])
+    """
+    # Collect all categories
+    categories = set()
+    for d in coded_data:
+        for c in coders:
+            categories.add(d.get(f'{c}_{code_var}'))
+
+    results = {}
+    for cat in categories:
+        # For each item, create binary: did coder assign this category?
+        binary_codes = {c: [] for c in coders}
+        for d in coded_data:
+            for c in coders:
+                binary_codes[c].append(1 if d.get(f'{c}_{code_var}') == cat else 0)
+
+        # Three-way agreement (for 3 coders)
+        if len(coders) == 3:
+            n_relevant = sum(1 for i in range(len(coded_data))
+                           if any(binary_codes[c][i] for c in coders))
+            if n_relevant < 5:
+                results[cat] = {'n': n_relevant, 'kappa': None, 'flag': 'Too few cases'}
+                continue
+
+            three_way = sum(
+                1 for i in range(len(coded_data))
+                if all(binary_codes[c][i] == binary_codes[coders[0]][i] for c in coders)
+                and any(binary_codes[c][i] for c in coders)
+            ) / max(n_relevant, 1)
+
+            results[cat] = {
+                'n': n_relevant,
+                'agreement': three_way,
+                'flag': '✅' if three_way >= 0.6 else '⚠️ Low reliability'
+            }
+
+        # Pairwise kappa
+        kappas = []
+        for c1, c2 in itertools.combinations(coders, 2):
+            try:
+                k = cohen_kappa_score(binary_codes[c1], binary_codes[c2])
+                kappas.append(k)
+            except ValueError:
+                pass
+
+        if kappas:
+            results[cat]['mean_pairwise_kappa'] = sum(kappas) / len(kappas)
+
+    return results
+```
+
+### R
+
+```r
+library(irr)
+
+category_reliability <- function(coded_data, code_var, coders) {
+  categories <- unique(unlist(coded_data[paste0(coders, "_", code_var)]))
+
+  results <- list()
+  for (cat in categories) {
+    binary <- sapply(coders, function(c) {
+      as.integer(coded_data[[paste0(c, "_", code_var)]] == cat)
+    })
+
+    n_relevant <- sum(rowSums(binary) > 0)
+    if (n_relevant < 5) next
+
+    k <- kappam.fleiss(binary)
+    results[[cat]] <- list(
+      n = n_relevant,
+      fleiss_kappa = k$value,
+      flag = ifelse(k$value >= 0.6, "OK", "Low")
+    )
+  }
+  results
+}
+```
+
+---
+
+## LLM Annotation Protocol
+
+When using LLMs as annotators (a growing practice):
+
+### Multi-Model Design
+
+| Requirement | Standard |
+|-------------|----------|
+| **Number of models** | ≥ 2 (ideally 3 from different providers) |
+| **Human validation** | N ≥ 200, κ ≥ 0.7 between LLM majority vote and human gold standard |
+| **Prompt documentation** | Full prompt text in appendix or replication package |
+| **Disagreement analysis** | Report which categories models disagree on most |
+| **Temperature** | 0 or near-0 for reproducibility |
+
+### Majority Vote
+
+For 3-model annotation, use majority vote (2/3 agreement):
+
+```python
+from collections import Counter
+
+def majority_vote(codes_by_model):
+    """codes_by_model: {'claude': 'X', 'gpt': 'Y', 'gemini': 'X'} → 'X'"""
+    counter = Counter(codes_by_model.values())
+    majority, count = counter.most_common(1)[0]
+    return majority, count  # count = 2 or 3
+```
+
+### When Models Disagree
+
+| Agreement level | Action |
+|----------------|--------|
+| 3/3 agree | High confidence — use the label |
+| 2/3 agree | Moderate confidence — use majority, flag for spot-check |
+| 0/3 agree (three-way split) | Low confidence — requires human adjudication |
+
+---
+
+## Reporting Template
+
+```markdown
+## Inter-Coder Reliability
+
+### Overall
+- Fleiss' κ = X.XX (N = XXX items, K = X coders)
+- Three-way agreement: XX.X%
+- Majority agreement (≥2/3): XX.X%
+
+### Per Category
+| Category | N | Three-way | Fleiss' κ | Status |
+|----------|---|-----------|-----------|--------|
+| X        | XX | XX.X%    | X.XX      | ✅/⚠️  |
+| Y        | XX | XX.X%    | X.XX      | ✅/⚠️  |
+
+### Low-Reliability Categories
+⚠️ [Category] had κ = X.XX (below 0.60 threshold).
+Findings involving this category should be interpreted with caution.
+
+### Human Validation (if LLM-annotated)
+- Gold standard sample: N = XXX
+- LLM majority vs. human: κ = X.XX
+- Model-specific: Claude κ = X.XX, GPT κ = X.XX, Gemini κ = X.XX
+```
+
+---
+
+## Integration
+
+### In `/data-analysis`
+
+When the dataset includes coded/annotated variables:
+1. Check if reliability metrics are reported
+2. If multi-model LLM annotation, verify human validation exists
+3. Flag categories below κ = 0.6 threshold
+
+### In review agents
+
+Check whether content analysis papers:
+- Report per-category reliability (not just aggregate)
+- Flag low-reliability categories as limitations
+- Include human validation for LLM annotations
+- Missing reliability → Major issue; aggregate-only → Minor issue
+
+### Validation tier interaction
+
+| Tier | Requirement |
+|------|------------|
+| 🟢 Exploratory | Multi-model agreement reported; human validation optional |
+| 🟡 Pilot | Multi-model agreement + spot-check (N ≥ 50) |
+| 🔴 Publication | Full reliability battery + human validation (N ≥ 200, κ ≥ 0.7) |

package/skills/shared/mcp-degradation.md

@@ -0,0 +1,81 @@
+# MCP Degradation Pattern
+
+> Shared reference for skills that depend on MCP servers. Gracefully degrade when a server is unreachable instead of failing silently or blocking the workflow.
+
+## The 5-Step Pattern
+
+### Step 1: Probe at Start
+
+Before any MCP-dependent work, test connectivity:
+
+```
+Try a lightweight read operation (e.g., mcp__taskflow__search_tasks with a known term,
+openalex_search_works with a trivial query). If it times out or errors,
+mark that server as unavailable for the session.
+```
+
+Do this **once**, at the beginning of the skill — not before every call.
+
+### Step 2: Report Availability
+
+After probing, state clearly:
+
+```
+MCP status:
+- Vault: ✓ available
+- OpenAlex: ✗ unavailable (timeout)
+```
+
+This sets expectations before the user sees skipped steps.
+
+### Step 3: Skip Dependent Phases
+
+When a server is unavailable, skip phases that depend on it entirely — do not attempt them, do not retry. Mark skipped phases clearly in the output:
+
+```
+Step 5: Update vault research pipeline — SKIPPED (vault unavailable)
+```
+
+### Step 4: Offer Fallbacks
+
+For each skipped phase, suggest what the user can do manually:
+
+| Unavailable | Fallback |
+|-------------|----------|
+| taskflow MCP | "Run `vault sync (edit vault files directly)` later when vault is accessible" |
+| OpenAlex MCP | "Use `/literature` with web search mode instead" |
+| Scholarly MCP | "Use `/literature` with web search mode instead" |
+
+### Step 5: Summarize at End
+
+Close with a clean summary of what completed vs. what was skipped:
+
+```
+Completed: Steps 1-4 (local context updates)
+Skipped: Step 5 (vault sync — server unavailable)
+Action needed: Run `vault sync (edit vault files directly)` when vault is accessible
+```
+
+## MCP-Consuming Skills
+
+These skills should reference this pattern:
+
+| Skill | MCP Server | What depends on it |
+|-------|------------|-------------------|
+| `vault sync` | vault | Steps 3, 5 (search + update) |
+| `task-management` | vault | Daily planning, task creation, pipeline queries |
+| `init-project-research` | vault | Pipeline entry creation |
+| `literature` | OpenAlex, Scholarly | Citation search, DOI verification |
+| `atlas-review` | vault | Pipeline cross-reference |
+
+## When to Apply
+
+- Always when a skill's workflow includes MCP tool calls
+- Especially in background agents (where MCP tools may auto-deny due to permission constraints)
+- When network issues are suspected (slow responses, recent timeouts)
+
+## When to Skip
+
+- Skills that don't use MCP tools
+- When the user explicitly says "skip vault" or "offline mode"
+- Interactive sessions where the user can retry immediately

package/skills/shared/method-probing-questions.md

@@ -0,0 +1,163 @@
+# Method-Specific Probing Questions
+
+> Shared reference for analysis skills and review agents. Mandatory questions before running any empirical analysis. Adapted from CommDAAF (Xu 2026), generalised beyond communication research.
+
+## Principle
+
+**Never run a method with default parameters.** Before executing any analysis, ask the method-specific probing questions. Do NOT proceed without explicit answers. Vague answers trigger the [escalation protocol](escalation-protocol.md).
+
+## Expert Fast-Track
+
+Experienced researchers can bypass probing by providing complete specs upfront:
+
+```
+DiD: treatment = policy_change_2020, control = neighbouring_states,
+parallel trends tested 2015-2019, Callaway-Sant'Anna estimator,
+clustered SEs at state level, 3 pre-treatment periods
+```
+
+If the spec is complete, acknowledge and proceed. If anything is missing, probe only the gaps.
+
+---
+
+## Probing Questions by Method
+
+### Regression / OLS / Panel
+
+1. What is your **estimand**? (ATE? ATT? Conditional mean?)
+2. What is the **unit of analysis**? (Individual? Firm? Country-year?)
+3. What is the **identification strategy**? (Selection on observables? IV? DiD? RDD?)
+4. What **controls** and why? (Justify each — no kitchen sink)
+5. How do you handle **standard errors**? (Clustered? HAC? At what level and why?)
+6. What are the **key threats to validity**? (Omitted variables, reverse causality, measurement error)
+
+### Difference-in-Differences
+
+1. What is the **treatment** and when does it occur?
+2. What are **treatment and control groups**? How defined?
+3. Is treatment timing **staggered**? (If yes: TWFE is biased — use CS, Sun-Abraham, or similar)
+4. **Parallel trends** evidence? (Pre-treatment dynamics, placebo tests)
+5. Any **anticipation effects**? (Treatment effects before official treatment date)
+6. Are there **spillovers** between treated and control units?
+7. What is the **relevant pre-treatment window**?
+
+### Instrumental Variables
+
+1. What is the **instrument** and what is the **theoretical argument** for relevance?
+2. What is the **exclusion restriction** argument? (Why does Z affect Y only through X?)
+3. **Weak instrument** diagnostics? (First-stage F-statistic, Anderson-Rubin CIs)
+4. Is the instrument **plausibly exogenous**? (What could violate this?)
+5. Are there **multiple instruments**? (Over-identification tests)
+6. What is the **LATE** you're estimating? (Who are the compliers?)
+
+### Regression Discontinuity
+
+1. What is the **running variable** and **cutoff**?
+2. Is it **sharp or fuzzy**? (Compliance rate at cutoff)
+3. **Bandwidth selection** method? (MSE-optimal? Cross-validation?)
+4. Evidence against **manipulation** at cutoff? (McCrary test, density plot)
+5. **Functional form**? (Local linear? Polynomial order? Sensitivity to choice)
+6. Are there **multiple cutoffs** or **geographic boundaries**?
+
+### Experiments / RCTs
+
+1. What is the **randomisation unit**? (Individual? Cluster?)
+2. **Power analysis**? (Effect size assumption, desired power, required N)
+3. Was the experiment **pre-registered**? (Where? What deviations?)
+4. How do you handle **attrition** and **non-compliance**?
+5. **Multiple testing**? (How many outcomes? Correction method?)
+6. **Demand effects**? (Can participants guess the hypothesis?)
+7. Is there a **pre-analysis plan**?
+
+### Survey / Psychometrics
+
+1. What **scales** are you using? (Validated or ad hoc?)
+2. **Common method variance** — single source, single method?
+3. **Response rate** and non-response bias assessment?
+4. **Sampling strategy**? (Probability? Convenience? Online panel?)
+5. How do you handle **missing data**? (Listwise deletion? MI? FIML?)
+6. **Measurement invariance** across groups? (If comparing subgroups)
+
+### MCDM / Multi-Criteria Analysis
+
+1. What **method** and **why this one**? (AHP? TOPSIS? PROMETHEE? ELECTRE?)
+2. How are **criteria weights** determined? (Expert elicitation? Pairwise comparison? Equal?)
+3. **Sensitivity analysis** on weights? (How much do rankings change?)
+4. **Rank reversal** check? (Does adding/removing alternatives change the ranking?)
+5. How many **decision-makers** and how are judgements aggregated?
+6. Are criteria **independent**? (If not, how is correlation handled?)
+7. **Normalisation method** and sensitivity to that choice?
+
+### Topic Modeling / NLP
+
+1. Why topic modeling specifically? (Exploratory? No predetermined categories?)
+2. How many topics (K) and **how will you select K**? (Coherence score? Held-out likelihood?)
+3. What **preprocessing**? (Stopwords, stemming, frequency thresholds — justify each)
+4. What counts as one **document**? (Post? Paragraph? Article?)
+5. How will you **validate topics are meaningful**? (Read 20+ docs per topic)
+6. Who will **name topics** and how?
+
+### Machine Learning / Classification
+
+1. What is the **ground truth** and how was it generated?
+2. **Train/test split** strategy? (Random? Temporal? Stratified?)
+3. How do you prevent **data leakage**?
+4. What **baselines** are you comparing against? (Are they serious or strawmen?)
+5. **Evaluation metrics** and why? (Accuracy? F1? AUC? — justify for your class balance)
+6. **Human validation** sample? (Required for any LLM annotation: N≥200, κ≥0.7)
+
+### Simulation / Agent-Based Models
+
+1. What is the **purpose** of the simulation? (Theoretical exploration? Mechanism testing? Calibration?)
+2. How are **parameters chosen**? (Empirically calibrated? Assumed? Swept?)
+3. **Sensitivity analysis** plan? (Which parameters vary? Over what range?)
+4. How many **replications** per parameter configuration?
+5. Does the model **validate against empirical data**? (Or is it purely theoretical?)
+6. What **simplifying assumptions** are made and what do they rule out?
+7. **Convergence check** — how do you know the simulation has run long enough?
+
+### Content Analysis / Coding
+
+1. Where is your **codebook**? (Must exist before coding)
+2. How many **coders** and what is the reliability plan?
+3. **Sampling strategy** for content to code?
+4. **Training protocol** for coders?
+5. How will you handle **ambiguous cases**?
+6. **Inter-coder reliability** metric and threshold? (Fleiss' κ ≥ 0.7 for publication)
+
+---
+
+## How Skills and Agents Use This
+
+### In analysis skills (`/data-analysis`, `/causal-design`, `/experiment-design`)
+
+1. Detect the method type from user's request
+2. Present the relevant probing questions
+3. Wait for answers before proceeding
+4. If answers are vague → [escalation protocol](escalation-protocol.md)
+5. Expert fast-track: if user provides complete spec, acknowledge and proceed
+
+### In review agents (`referee2-reviewer`, `domain-reviewer`)
+
+1. Check whether the paper addresses these questions for its stated method
+2. Flag unanswered questions as issues in the review report
+3. Missing identification strategy → Critical; missing sensitivity analysis → Major
+
+### In project agents (`data-engineer`, `econometrician`)
+
+1. Before implementing any estimation, verify the probing questions are answered
+2. Reference the answers from `.planning/state.md` or the paper's methodology section
+3. If no answers exist, probe the user before writing code
+
+---
+
+## Adding New Methods
+
+When a research project uses a method not covered above, create a method-specific question set following the pattern:
+
+1. **What** — define the exact variant/specification
+2. **Why** — justify the choice over alternatives
+3. **How** — implementation details that affect validity
+4. **Threats** — what could go wrong
+5. **Validation** — how you'll know it's correct
+6. **Sensitivity** — what happens when assumptions change

package/skills/shared/multi-language-conventions.md

@@ -0,0 +1,143 @@
+# Multi-Language Conventions
+
+> Code style, packages, and output patterns for R, Python, Stata, and Julia.
+> Referenced by `/data-analysis`, `/synthetic-data`, `/replication-package`.
+
+## Language Detection
+
+Detect from project context in this order:
+
+1. Existing scripts in `code/` or `src/` → match language
+2. `CLAUDE.md` or `MEMORY.md` mentions → follow stated preference
+3. User request → explicit language choice
+4. Default → R for econometrics/causal inference, Python for ML/simulation
+
+## R Conventions
+
+### Style
+- Assignment: `<-` (never `=`)
+- Pipe: `|>` (base R) preferred; `%>%` acceptable if tidyverse already loaded
+- Naming: `snake_case` for variables and functions
+- Line width: 80 characters
+
+### Core Packages
+
+| Task | Package |
+|------|---------|
+| Data wrangling | `dplyr`, `tidyr`, `data.table` |
+| Estimation | `fixest`, `estimatr`, `lme4`, `survival` |
+| Causal inference | `did`, `didimputation`, `synthdid`, `rdrobust`, `MatchIt` |
+| Tables | `modelsummary`, `kableExtra`, `stargazer` |
+| Figures | `ggplot2` + `ggthemes`, `patchwork` |
+| Reporting | `rmarkdown`, `knitr` |
+| Power analysis | `DeclareDesign`, `pwr`, `simr` |
+| Survey | `survey`, `srvyr`, `qualtRics` |
+
+### Output Pattern
+```r
+# Tables → LaTeX
+modelsummary(models, output = "paper/tables/table1.tex",
+             stars = c("*" = 0.10, "**" = 0.05, "***" = 0.01))
+
+# Figures → PDF
+ggsave("paper/figures/fig1.pdf", width = 6, height = 4)
+```
+
+## Python Conventions
+
+### Style
+- **Always use `uv`** — never bare `python` or `pip`
+- Naming: `snake_case` for variables/functions, `PascalCase` for classes
+- Type hints encouraged but not required for analysis scripts
+- Line width: 88 characters (Black default)
+
+### Core Packages
+
+| Task | Package |
+|------|---------|
+| Data wrangling | `pandas`, `polars` |
+| Estimation | `statsmodels`, `linearmodels`, `scikit-learn` |
+| Causal inference | `econml`, `causalml`, `doubleml` |
+| Tables | `stargazer` (via statsmodels), custom `.tex` export |
+| Figures | `matplotlib`, `seaborn`, `plotnine` |
+| Power analysis | `statsmodels.stats.power`, `numpy` simulation |
+| Survey | `pandas` + manual parsing |
+
+### Output Pattern
+```python
+import pandas as pd
+
+# Tables → LaTeX
+df.to_latex("paper/tables/table1.tex", index=False,
+            caption="Descriptive Statistics", label="tab:desc")
+
+# Figures → PDF
+fig.savefig("paper/figures/fig1.pdf", bbox_inches="tight", dpi=300)
+```
+
+## Stata Conventions
+
+### Style
+- Use `//` for inline comments, `/* */` for blocks
+- Naming: lowercase with underscores
+- Always set `version` at script top
+- Use `capture log close` / `log using` pattern
+
+### Core Commands
+
+| Task | Command |
+|------|---------|
+| Data wrangling | `gen`, `replace`, `reshape`, `merge`, `collapse` |
+| Estimation | `reg`, `ivregress`, `xtreg`, `areg`, `ppmlhdfe` |
+| Causal inference | `did_multiplegt`, `csdid`, `rdrobust`, `eventstudyinteract` |
+| Tables | `esttab`, `outreg2`, `estout` |
+| Figures | `twoway`, `coefplot`, `graph export` |
+| Power analysis | `power`, `simulate` |
+
+### Output Pattern
+```stata
+// Tables → LaTeX
+esttab m1 m2 m3 using "paper/tables/table1.tex", ///
+    replace booktabs label se star(* 0.10 ** 0.05 *** 0.01)
+
+// Figures → PDF
+graph export "paper/figures/fig1.pdf", replace
+```
+
+## Julia Conventions
+
+### Style
+- Naming: `snake_case` for functions/variables, `PascalCase` for types
+- Use `using` not `import` for standard packages
+- Line width: 92 characters
+
+### Core Packages
+
+| Task | Package |
+|------|---------|
+| Data wrangling | `DataFrames.jl`, `CSV.jl` |
+| Estimation | `GLM.jl`, `FixedEffectModels.jl`, `MixedModels.jl` |
+| Causal inference | `CausalInference.jl` (limited — often custom) |
+| Tables | `PrettyTables.jl` (LaTeX backend) |
+| Figures | `Makie.jl`, `AlgebraOfGraphics.jl`, `Plots.jl` |
+| Power analysis | Custom simulation with `Distributions.jl` |
+
+### Output Pattern
+```julia
+using PrettyTables
+# Tables → LaTeX
+open("paper/tables/table1.tex", "w") do io
+    pretty_table(io, df, backend=Val(:latex))
+end
+
+# Figures → PDF
+save("paper/figures/fig1.pdf", fig)
+```
+
+## Cross-Language Rules
+
+1. **Output routing:** All `.tex` table files and figure files go to `paper/tables/` or `paper/figures/` per the `overleaf-separation` rule. Scripts stay in `code/` or `src/`.
+2. **Reproducibility header:** Every script should start with a comment block stating purpose, inputs, outputs, and dependencies.
+3. **Seed setting:** Always set random seeds explicitly (`set.seed()`, `np.random.seed()`, `set seed`, `Random.seed!`).
+4. **Path convention:** Use project-relative paths, never absolute paths. Assume scripts run from project root.
+5. **Data flow:** `data/raw/` → script → `data/processed/` → script → `paper/` output. Never write to `data/raw/`.