Remove all em dashes from docs, vignettes, and site

Plain hyphens throughout the prose; pkgdown's title separator
post-processed in docs/ (regenerated on rebuild - re-run the
replacement after pkgdown::build_site()).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: mattyoreilly

R/atlas.R

@@ -18,8 +18,8 @@
 #'   this many consecutive attempts without improvement.
 #' @param stopping_tolerance Stopping rule: an attempt only counts as an improvement
 #'   if it beats the best validation metric so far by at least this relative
-#'   fraction, between 0 and 1 — e.g. `0.05` for 5%.
-#' @param exclude Columns the models must not use — because they won't be
+#'   fraction, between 0 and 1 - e.g. `0.05` for 5%.
+#' @param exclude Columns the models must not use - because they won't be
 #'   available at prediction time in deployment, or they leak the outcome.
 #'   They are removed from the data before the agent sees it. Predictors that
 #'   survive are additionally screened with [atlas_leakage_screen()], and the
@@ -36,8 +36,8 @@
 #' @param max_fix_rounds How many automatic constraint-repair rounds to allow
 #'   after the initial build.
 #' @param refine After the winning algorithm is found (and constraints pass),
-#'   keep iterating on its feature selection and engineering — one change per
-#'   attempt, same validation scheme — until the stopping rules trigger
+#'   keep iterating on its feature selection and engineering - one change per
+#'   attempt, same validation scheme - until the stopping rules trigger
 #'   (`stopping_rounds` consecutive attempts without a relative gain of at least
 #'   `stopping_tolerance`). The refined model lands in the results as
 #'   `<winner>_refined`, alongside the original.
@@ -56,13 +56,13 @@
 #' @param autonomous Run with no human in the loop: the agent states its plan
 #'   and proceeds instead of waiting for approval, and never asks questions.
 #'   Combine with a generous `n_models`/`stopping_rounds` and `test_prop` for
-#'   unattended experimentation runs — e.g.
+#'   unattended experimentation runs - e.g.
 #'   `atlas(d, "y", autonomous = TRUE, n_models = 10, stopping_rounds = 8,
-#'   test_prop = 0.2)` — where the agent iterates keep/discard experiments
+#'   test_prop = 0.2)` - where the agent iterates keep/discard experiments
 #'   and the survivors are judged on the held-out test set at the end.
 #' @param test_prop Proportion of rows (0 to <1) to hold out as a final test
 #'   set the agent never sees. After the run, Atlas itself evaluates every
-#'   final model on it (RMSE for continuous outcomes, accuracy otherwise) —
+#'   final model on it (RMSE for continuous outcomes, accuracy otherwise) -
 #'   a ranking the agent can't overfit. Reported as `test_leaderboard` in
 #'   the results and saved to `test_leaderboard.csv` in the run directory.
 #'   `0` (default) disables the split.

R/constraints.R

@@ -2,7 +2,7 @@
 #'
 #' Constraints carry domain knowledge into the build: the description is put
 #' in front of the agent as a hard requirement, and if `check` is supplied the
-#' constraint is *verified* — every final model is tested after the build, and
+#' constraint is *verified* - every final model is tested after the build, and
 #' violations are sent back to the agent to fix (see `max_fix_rounds` in
 #' [atlas()]). Plain strings passed to `constraints` are shorthand for
 #' `constraint(<string>)`: enforced via instructions only.
@@ -77,8 +77,8 @@ con_uses <- function(var) {
 #'
 #' Monotonicity is non-strict, so a model that does not use `var` at all
 #' passes trivially (a flat response is monotone). This makes the constraint
-#' conditional — "if the model responds to `var`, the effect must be
-#' monotone" — without forcing the variable in. Pair with [con_uses()] when
+#' conditional - "if the model responds to `var`, the effect must be
+#' monotone" - without forcing the variable in. Pair with [con_uses()] when
 #' the variable must also be used.
 #'
 #' @param var Column name (numeric) the response must be monotonic in.
@@ -180,7 +180,7 @@ atlas_leakage_screen <- function(data, outcome, threshold = 0.95,
 #' [con_uses()], "mpg should never increase with weight" becomes
 #' [con_monotone()], and anything else becomes a prompt-enforced
 #' [constraint()]. Returns the list for you to inspect (print it!) before
-#' passing to [atlas()] — the parse is a judgment call, so review it.
+#' passing to [atlas()] - the parse is a judgment call, so review it.
 #'
 #' @param text The brief, in plain language. Sentences, bullets, whatever.
 #' @param data Optional data.frame the constraints are about; its column

R/session.R

@@ -8,10 +8,10 @@
 #' the console when it needs a decision (interactive sessions only).
 #'
 #' @section Run directory contents:
-#' * `data.rds`, `meta.rds` — inputs, so the session can be rebuilt cold
-#' * `code.R` / `code.rds` — every code chunk the agent executed
-#' * `turns.rds` — the full conversation
-#' * `report.md`, `leaderboard.csv`, `models.rds` — final artifacts
+#' * `data.rds`, `meta.rds` - inputs, so the session can be rebuilt cold
+#' * `code.R` / `code.rds` - every code chunk the agent executed
+#' * `turns.rds` - the full conversation
+#' * `report.md`, `leaderboard.csv`, `models.rds` - final artifacts
 #'
 #' @examples
 #' \dontrun{
@@ -56,7 +56,7 @@ atlas_session <- R6::R6Class("atlas_session",
     #'   `ellmer::chat_anthropic()`. Any ellmer provider works.
     #' @param dir Run directory for checkpoints and all output (reports,
     #'   validation plots, model bundles). Defaults to a timestamped folder
-    #'   under `getOption("atlas.dir", ".atlas")` — set
+    #'   under `getOption("atlas.dir", ".atlas")` - set
     #'   `options(atlas.dir = "~/atlas-runs")` once to send every run to a
     #'   location of your choosing, or pass `dir` explicitly per run.
     #' @param on_ask Optional handler for the agent's questions:
@@ -98,7 +98,7 @@ atlas_session <- R6::R6Class("atlas_session",
     #'   own history. Set to `Inf` to disable.
     #' @param max_steps Hard budget: the maximum number of code executions
     #'   the agent gets in this session. Unlike the stopping rules (which the
-    #'   agent applies itself), this is mechanically enforced — past the
+    #'   agent applies itself), this is mechanically enforced - past the
     #'   limit the `run_r_code` tool refuses to execute and instructs the
     #'   agent to finalise from what it has. `Inf` (default) disables.
     #' @param max_runtime Hard budget: wall-clock seconds for this session
@@ -192,8 +192,8 @@ atlas_session <- R6::R6Class("atlas_session",
     #' @param verbose Show the agent's narration, code, and output live.
     #' @param max_fix_rounds How many constraint-repair rounds to allow.
     #' @param refine After the winning algorithm is found (and constraints
-    #'   pass), iterate on its feature selection and engineering — one change
-    #'   per attempt, same validation scheme — until the session's stopping
+    #'   pass), iterate on its feature selection and engineering - one change
+    #'   per attempt, same validation scheme - until the session's stopping
     #'   rules trigger (`stopping_rounds` attempts without a `stopping_tolerance` gain).
     #'   The refined model is added to the results alongside the original.
     #' @param validate Produce reviewable validation output (gain,
@@ -300,7 +300,7 @@ atlas_session <- R6::R6Class("atlas_session",
     #' @description Compact the conversation to save tokens: archive the
     #'   transcript to the run directory, clear the context window, and
     #'   re-orient the agent with a state briefing on the next message. The
-    #'   R environment (models, data) and code log are untouched — they are
+    #'   R environment (models, data) and code log are untouched - they are
     #'   the durable memory. Called automatically when the context exceeds
     #'   `compact_at`; call it yourself before a long follow-up to start
     #'   from a lean window.

README.Rmd

@@ -12,7 +12,7 @@ Atlas builds models for you, and shows its work. Give it a data frame and a
 target; an LLM agent (via [ellmer](https://ellmer.tidyverse.org)) explores
 the data, proposes a modeling plan for your approval, then writes and runs R
 code to fit, compare, and refine candidate models. You get back fitted
-models ready for `predict()`, a leaderboard, a written report — and, because
+models ready for `predict()`, a leaderboard, a written report - and, because
 the agent works by writing R, the complete script of everything it did.
 
 Three ideas separate atlas from "ask a chatbot for model code":
@@ -24,7 +24,7 @@ Three ideas separate atlas from "ask a chatbot for model code":
 
 * **Sessions are persistent.** Every code chunk and conversation turn is
   checkpointed to disk as it happens. A crash, a restart, or a deliberate
-  interruption loses nothing — resume and keep going.
+  interruption loses nothing - resume and keep going.
 
 * **Your data stays on your machine.** The LLM sees column names, types,
   and printed summaries, never the rows. All fitting happens locally in
@@ -43,7 +43,7 @@ pak::pkg_install("mattyoreilly/Atlas")
 You also need an API key for an LLM provider. atlas defaults to Anthropic:
 run `usethis::edit_r_environ()`, add a line `ANTHROPIC_API_KEY=sk-ant-...`,
 save, and restart R. Any tool-capable ellmer provider works via the `chat`
-argument — OpenAI, Gemini, Bedrock, or a local model through Ollama.
+argument - OpenAI, Gemini, Bedrock, or a local model through Ollama.
 
 ## Usage
 
@@ -54,14 +54,14 @@ res <- atlas(mtcars, outcome = "mpg", goal = "prioritise interpretability")
 ```
 
 The agent narrates as it works. It profiles the data (flagging suspected
-target leakage), proposes a plan — model families chosen to match the
+target leakage), proposes a plan - model families chosen to match the
 outcome's distribution, a seeded validation scheme, any monotone effects it
-believes the domain implies — and **waits for your approval in the
+believes the domain implies - and **waits for your approval in the
 console**. You can answer "yes", or redirect it: "only linear models, and
 don't use qsec". Then it builds up to `n_models` candidates, compares them
 on held-out data, refines the winner's features until improvement stalls,
-verifies any constraints, and — with
-[modelblueprint](https://mattyoreilly.github.io/modelblueprint/) installed —
+verifies any constraints, and - with
+[modelblueprint](https://mattyoreilly.github.io/modelblueprint/) installed -
 writes a full validation workup (gain, calibration, grouped residuals,
 one-ways, PDPs) to the run directory.
 
@@ -76,18 +76,18 @@ res$session$tell("why did the refined model win?")   # keep talking
 
 Every run walks the same six stages, and you hold the pen at stage 2:
 
-1. **Explore** — dimensions, types, missingness, the outcome's
+1. **Explore** - dimensions, types, missingness, the outcome's
    distribution; automatic leakage screening.
-2. **Plan, then stop for you** — candidate families matched to the
+2. **Plan, then stop for you** - candidate families matched to the
    outcome's distribution, a validation scheme, suggested monotone
    constraints. Approval is a conversation: whatever you type is folded
    into the plan.
-3. **Build** — up to `n_models` candidates, compared on held-out data.
-4. **Refine** — the winner's features are iterated one change at a time
+3. **Build** - up to `n_models` candidates, compared on held-out data.
+4. **Refine** - the winner's features are iterated one change at a time
    until the stopping rules call convergence.
-5. **Verify** — machine-checked constraints run against every final model;
+5. **Verify** - machine-checked constraints run against every final model;
    violations trigger repair rounds.
-6. **Document** — report, leaderboard, reproducible script, validation
+6. **Document** - report, leaderboard, reproducible script, validation
    plots, all in the run directory.
 
 Two kinds of dial control how long this takes. The *statistical* stopping
@@ -114,13 +114,13 @@ res$constraints    # one row per model x constraint: passed, detail
 ```
 
 Columns that won't exist at prediction time don't belong in the data at
-all — `exclude` removes them before the agent ever sees it, and
+all - `exclude` removes them before the agent ever sees it, and
 `atlas_leakage_screen()` automatically flags predictors that alone explain
 almost all of the outcome. See `vignette("constraints")`.
 
 ## Unattended runs
 
-For hands-off experimentation — overnight, in a script, on a schedule —
+For hands-off experimentation - overnight, in a script, on a schedule -
 set `autonomous = TRUE`: the agent states its plan and proceeds instead of
 waiting for approval, iterating keep/discard experiments under the stopping
 rules. Pair it with `test_prop` to hold out rows the agent **never sees**;
@@ -139,8 +139,8 @@ res$test_leaderboard   # held-out performance, best first
 ```
 
 Long runs stay affordable: past a token budget (`compact_at`) the
-conversation is compacted — transcript archived to disk, context cleared,
-agent re-oriented from session state at no extra LLM cost — and every
+conversation is compacted - transcript archived to disk, context cleared,
+agent re-oriented from session state at no extra LLM cost - and every
 results object reports the session's total dollar `cost`. See
 `vignette("autonomous")`.
 
@@ -162,26 +162,26 @@ Runs land in `.atlas/<timestamp>` by default; set
 ## Limitations
 
 * **Columns are the scaling limit, not rows.** Fitting is local, so a
-  million rows just take the time they take — but the agent reasons about
+  million rows just take the time they take - but the agent reasons about
   variables by name, and past a few dozen columns that reasoning degrades.
   Pre-select features for wide data.
 * **Cost scales with agent steps**, not data size: more candidates, more
   repair rounds, more follow-ups mean more LLM calls. `print(res)` shows
   what a session cost.
 * **The statistical stopping rules are agent-applied.** For guarantees,
-  use the mechanical budgets (`max_steps`, `max_runtime`) — those are
+  use the mechanical budgets (`max_steps`, `max_runtime`) - those are
   enforced by atlas, not the model.
 * **An agent is not a statistician.** atlas verifies what you tell it to
   verify; judgment about what the model is *for* stays with you. Read the
   report, check `res$code`, and look at the validation output.
 
 ## Learn more
 
-* `vignette("atlas")` — a full walkthrough: setup, the build lifecycle,
+* `vignette("atlas")` - a full walkthrough: setup, the build lifecycle,
   what you get back, what it costs
-* `vignette("constraints")` — encoding domain knowledge that can't be
+* `vignette("constraints")` - encoding domain knowledge that can't be
   ignored
-* `vignette("sessions")` — persistence, resuming, steering mid-build, and
+* `vignette("sessions")` - persistence, resuming, steering mid-build, and
   token stewardship
-* `vignette("autonomous")` — unattended runs with hard budgets and a
+* `vignette("autonomous")` - unattended runs with hard budgets and a
   protected test set