")
+ src, out = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2])
+ template = (pathlib.Path(__file__).resolve().parent / "template.html").read_text()
+ # block early; escape it inside strings.
+ data = json.dumps(json.loads(src.read_text())).replace("
+
+
+
+
+atlas
+
+
+
+atlas
+
+
+frontier
+every open gap, question and next-step across the corpus: the queue the next investigation pulls from
+
+
+
+
+
+
+
diff --git a/plugins/modeling/.claude-plugin/plugin.json b/plugins/modeling/.claude-plugin/plugin.json
new file mode 100644
index 0000000..ce3e49a
--- /dev/null
+++ b/plugins/modeling/.claude-plugin/plugin.json
@@ -0,0 +1,11 @@
+{
+ "name": "modeling",
+ "version": "0.1.0",
+ "description": "Do the quantitative science, don't just describe it: turn data (a file, a simulation, or a digitized figure) into a fitted, model-selected, uncertainty-quantified result. Frame candidate models, fit them with parameter covariance, select on evidence (AIC/BIC + cross-validation rather than in-sample fit), and discover the functional form when it's unknown (symbolic regression). Composes the Axiomatic model-fitting/equation-discovery tools, ncn for heavy compute, and trail/present to record and show. Use when the user wants to fit a model, find a scaling law or equation, do model selection, quantify parameter uncertainty, digitize a plot into data, or test whether a proposed law holds.",
+ "author": {
+ "name": "Aadarsh Agarwal",
+ "url": "https://github.com/aadarwal"
+ },
+ "license": "MIT",
+ "keywords": ["anu", "modeling", "model-fitting", "curve-fitting", "model-selection", "symbolic-regression", "equation-discovery", "uncertainty", "axiomatic", "ncn", "research", "physics"]
+}
diff --git a/plugins/modeling/commands/modeling.md b/plugins/modeling/commands/modeling.md
new file mode 100644
index 0000000..742daa3
--- /dev/null
+++ b/plugins/modeling/commands/modeling.md
@@ -0,0 +1,22 @@
+---
+description: Do the quantitative science: turn data (a file, a simulation, or a digitized figure) into a fitted, model-selected, uncertainty-quantified law. Frame candidate models, fit with covariance, select on AIC/BIC + cross-validation, and discover the form when it's unknown.
+---
+
+Model the data / question in `$ARGUMENTS`.
+
+Follow the **modeling** skill (`~/.local/share/anu/plugins/modeling/skills/modeling/SKILL.md`) end to end:
+
+1. **Get the data honestly:** a file, a simulation you run, or digitize a figure
+ with `AxPlotToData`. Label digitized data as digitized; never invent points.
+2. **Frame 2-5 candidate models**, each with a reason, never a single curve.
+3. **Fit each with parameter covariance:** value ± uncertainty for every parameter.
+4. **Select on evidence:** `compare_models` + AIC/BIC + `cross_validate_model` +
+ residual diagnostics, not in-sample fit. Prefer the simplest model that survives.
+5. **If no candidate is defensible, discover the form** with `AxEquationExplorer`
+ (symbolic regression), then make it earn its keep against simpler models.
+6. **Deliver the verdict:** chosen model, parameters ± uncertainty, the
+ alternatives ruled out and why, a data+fit figure, and (inside `/investigate`)
+ the outcome recorded via `trail`.
+
+Heavy fits/sweeps run on the right compute via `ncn` (GPU mesh box or the cluster).
+Don't fabricate data or fits; always an error bar; always more than one model.
diff --git a/plugins/modeling/skills/modeling/SKILL.md b/plugins/modeling/skills/modeling/SKILL.md
new file mode 100644
index 0000000..2f5a4a4
--- /dev/null
+++ b/plugins/modeling/skills/modeling/SKILL.md
@@ -0,0 +1,112 @@
+---
+name: modeling
+description: Do the quantitative science, don't just describe it: turn data (a file, a simulation, or a figure you digitize) into a fitted, model-selected, uncertainty-quantified result. Frame candidate models, fit them with parameter covariance, select by evidence (AIC/BIC + cross-validation, not in-sample fit), and discover the functional form when it's unknown (symbolic regression). Composes the Axiomatic model-fitting/equation-discovery tools, ncn for heavy compute, and trail/present to record and show. Use when the user wants to fit a model, find a scaling law or equation, do model selection, quantify uncertainty on parameters, digitize a plot into data, or test whether a proposed law holds.
+---
+
+# modeling: data → a law that holds, with its error bars
+
+This is the quantitative **do** stage made literal: anu's other research plugins
+*write* and *animate* science (`science-writing`, `tikz`, `manim`); this one
+**does** it. You take data and produce a *result that holds*: a model chosen on
+evidence, parameters with uncertainty, and the alternatives you ruled out.
+
+You are a careful experimentalist, not a curve-fitter. Anyone can fit one curve
+and declare victory. Your job is to fit several, quantify how well each is
+actually supported, and report the one that survives, including the honest case
+where nothing does.
+
+This plugin **composes** rather than reinvents:
+- **The Axiomatic model-fitting tools:** `AxModelFitter` (fit, compare,
+ information criteria, cross-validation, parameter covariance, R²),
+ `AxModelFitterV2` (generate + execute fitting code), `AxEquationExplorer`
+ (discover a functional form; check a proposed equation), `AxArgmin`
+ (optimization), `AxPlotToData` (digitize a figure into numbers). These are MCP
+ tools; load them with ToolSearch (`axiomatic model fitter`, `equation
+ explorer`, `plot to data`) when you need them.
+- **`ncn`:** run a heavy fit / large sweep / symbolic-regression search on the
+ right compute (GPU mesh box or the Slurm cluster), not the laptop.
+- **`trail`** + **`present`:** record the chosen model and the roads not taken
+ as the decision record, and show the fitted law as a figure.
+
+## The seam with the arc
+
+A quantitative **`/investigate` hypothesis** ("insertion loss falls
+exponentially with taper length") or a **`/study` gap** that is really a
+measurement is a modeling task. Frame it here, fit it, and the result,
+*the law plus its uncertainty plus the rejected forms*, is the evidence that
+`/investigate` records and `/present` shows. Modeling is where a hypothesis
+becomes a number with an error bar.
+
+## Moves
+
+### 1. Get the data, honestly
+Never invent data points. Acquire them one of three ways:
+- **A file / array** the user already has.
+- **A simulation** you write and run (small ones locally; heavy ones via `ncn`).
+- **A figure** from a paper: digitize it with `AxPlotToData`
+ (`extract_numerical_series`; `split_multi_plot` first if several series share
+ axes). State that the data is digitized and roughly how accurate that is.
+
+If the data is too sparse or noisy to support any conclusion, say so and stop.
+A null result is a result; a fabricated one is misconduct.
+
+### 2. Frame candidate models, not one
+Like `/investigate` frames hypotheses, list **2-5 functional forms**, each with
+a *reason* it's plausible (a mechanism, a limiting behaviour, a known scaling).
+Fitting a single model can only confirm what you assumed. Competing models are
+what make the answer falsifiable.
+
+### 3. Fit, and quantify uncertainty
+Fit each candidate (`AxModelFitter.fit_model`, or `AxModelFitterV2` to
+generate/execute custom code for awkward models). For every fit get the
+**parameter covariance** (`compute_parameter_covariance`): *a parameter without
+an error bar is not a result.* Report each parameter as value ± uncertainty.
+
+### 4. Select by evidence, adversarially
+The best in-sample fit is **not** the best model; more parameters always fit
+better. Choose on out-of-sample evidence:
+- `compare_models` + `calculate_information_criteria` (AIC/BIC) to penalize
+ complexity,
+- `cross_validate_model` to check it predicts data it didn't see,
+- residual diagnostics: structure left in the residuals means the model is
+ wrong however high its R².
+
+Prefer the simplest model that survives. When two are statistically tied, the
+honest report is "the data don't distinguish them," not a coin flip.
+
+### 5. Discover the form when it's unknown
+If you have no defensible candidate, find one: `AxEquationExplorer.find_functional_form`
+(symbolic regression) proposes a form *from the data*; then treat it as a
+candidate and run it back through steps 3-4; discovered forms still must earn
+their keep against simpler ones. To test a law someone proposed, use
+`check_equation`.
+
+### 6. Verdict + artifact
+Produce, not a wall of chat, a result:
+- the **chosen model** and its parameters ± uncertainty,
+- the **alternatives ruled out** and *why* (the roads not taken),
+- residual / goodness diagnostics and the data provenance (measured / simulated /
+ digitized),
+- a **figure** of data + fit + uncertainty band (hand to `/present`),
+- and, when running inside `/investigate`, the outcome recorded via `trail`
+ (the fit is the evidence behind a `Hypothesis:`/`Outcome:` pair).
+
+## Compute: where `ncn` earns its keep
+- **Light** (a handful of parameters, modest data) → fit locally / in a `box`.
+- **Heavy** (large datasets, global optimization with `AxArgmin`, a wide
+ symbolic-regression search, k-fold cross-validation over big models) → `ncn`
+ to a GPU mesh box or `ncn --cluster` (Slurm + Apptainer); pull the fit and
+ the figure back. Sweeps are embarrassingly parallel; fan them with `mesh
+ spawn` when there are many.
+
+## Rules
+- **Never fabricate data or a fit.** Digitized data is labelled as digitized.
+- **Always an error bar.** A parameter or a prediction without uncertainty is
+ incomplete, not done.
+- **Always more than one model.** Report what you rejected and why; a single fit
+ is an assumption wearing the costume of a result.
+- **Evidence over R².** Selection is AIC/BIC + cross-validation; in-sample fit
+ alone never decides.
+- **The law is the deliverable:** the chosen model, its parameters ±
+ uncertainty, the alternatives ruled out, and one figure. Cheap fits before
+ expensive searches.
diff --git a/plugins/tend/.claude-plugin/plugin.json b/plugins/tend/.claude-plugin/plugin.json
new file mode 100644
index 0000000..bb2f09d
--- /dev/null
+++ b/plugins/tend/.claude-plugin/plugin.json
@@ -0,0 +1,11 @@
+{
+ "name": "tend",
+ "version": "0.1.0",
+ "description": "Keep work healthy over time: anu's continuity layer. Register checks that should keep passing (tests, a built artifact, an invariant, a benchmark, a deploy, or a research frontier going stale), run them on a cadence, record the drift, and, when armed, spawn a contained agent (cxc) to self-heal the moment one breaks. Turns the find→understand→do→show arc from commands a human re-invokes into a loop that keeps running, with a B&W health dashboard (autonomy you can see) and a headless cron heartbeat. The shell command `tend` does the work; this skill teaches what is worth tending and when to heal vs surface to a human. Use when the user wants something watched/maintained over time, a self-healing check, a periodic verification, scheduled re-runs, or to keep a long-running result from rotting.",
+ "author": {
+ "name": "Aadarsh Agarwal",
+ "url": "https://github.com/aadarwal"
+ },
+ "license": "MIT",
+ "keywords": ["anu", "tend", "continuity", "autonomy", "self-healing", "cron", "verification", "watch", "monitoring", "research", "frontier"]
+}
diff --git a/plugins/tend/commands/tend.md b/plugins/tend/commands/tend.md
new file mode 100644
index 0000000..7ed3250
--- /dev/null
+++ b/plugins/tend/commands/tend.md
@@ -0,0 +1,32 @@
+---
+description: Keep work healthy over time: register checks that should keep passing, run them on a cadence, record drift, and (armed) spawn a contained agent to self-heal when one breaks. The continuity layer that turns the research arc into a loop.
+---
+
+Set up or review tended checks for the work in `$ARGUMENTS` (default: this repo).
+
+The fast path is the shell command. Run it directly:
+
+```bash
+tend # status: every watch, its last result, its drift
+tend add --every 6h -- tests/run.sh # register a check
+tend add --every 1d --heal cxc --auto -- # self-healing (armed)
+tend run # run all due watches now
+tend watch # live cockpit (re-run due watches on a loop)
+tend dash # B&W health dashboard
+tend cron on # headless heartbeat (cron runs `tend run`)
+```
+
+Then follow the **tend** skill
+(`~/.local/share/anu/plugins/tend/skills/tend/SKILL.md`) for the judgment:
+
+1. **Pick what's worth tending:** a suite/build that must stay green, an
+ invariant or benchmark a result depends on, a served demo, or a stale research
+ frontier the arc should re-open.
+2. **Heal vs surface.** Arm `--auto` only for safe, reversible, well-scoped fixes
+ (flaky test, formatting, re-render) that land as a reviewable commit in a
+ contained box. Surface, never auto-heal, anything with judgment or
+ irreversibility; a refuted claim is a result to look at, not a bug to patch.
+3. **Keep checks deterministic:** a watch that flaps teaches nothing.
+
+Healers run contained (`cxc`); the conductor stays on the host. Drift over time is
+the signal; the recorded history matters more than any single run.
diff --git a/plugins/tend/skills/tend/SKILL.md b/plugins/tend/skills/tend/SKILL.md
new file mode 100644
index 0000000..601bdc8
--- /dev/null
+++ b/plugins/tend/skills/tend/SKILL.md
@@ -0,0 +1,71 @@
+---
+name: tend
+description: Keep work healthy over time: anu's continuity layer. Register checks that should keep passing (tests, a built artifact, an invariant, a benchmark, a deploy, or a research frontier going stale), run them on a cadence, record the drift, and, when armed, spawn a contained agent to self-heal the moment one breaks. Turns the find→understand→do→show arc from commands a human re-invokes into a loop that keeps running. Use when the user wants something watched/maintained over time, a self-healing check, a periodic verification, scheduled re-runs, or to keep a long-running result from rotting.
+---
+
+# tend: the loop that keeps running
+
+anu's research arc is otherwise a *line*: a human runs `/study`, then
+`/investigate`, then `/present`, each by hand. `tend` is the layer that makes it
+a **loop**: work that stays healthy and re-opens itself without a human in the
+hot path. It is the answer to "who runs the check next week, and who fixes it
+when it breaks?"
+
+A **watch** is the unit: *a check that should keep passing* + *what to do when it
+doesn't*. Run it on a cadence, record every result (so drift is visible), and,
+if armed, heal it in a **contained box** the moment it fails.
+
+```
+tend status: every watch, its last result, its drift
+tend add --every 1h --heal ""|cxc [--auto] --
+tend run [name] run all due watches now (or one)
+tend watch live cockpit: re-run due watches on a loop
+tend heal spawn the healer for a failing watch now
+tend dash the B&W health dashboard (autonomy you can see)
+tend cron on|off the headless heartbeat (cron runs `tend run`)
+```
+
+## What is worth tending
+- **Tests / builds:** a green suite that must stay green; a build artifact that
+ must keep building. `tend add tests --every 6h -- tests/run.sh`.
+- **Invariants & claims:** a property a result depends on (a benchmark number, a
+ fixture, an external API contract). When it drifts, you want to know *that day*.
+- **Served things:** a `/present` demo or an `ncn` endpoint that should stay up.
+- **The research frontier:** the deepest use is an investigation's `frontier` or a
+ `/study` gap that is sitting *stale*. A watch can re-open the arc by surfacing the
+ oldest open frontier item, or (armed) spawning an `/investigate` on it, so the
+ corpus keeps moving even when no one is driving. This is `tend` closing the
+ loop with `atlas` and `trail`.
+
+## Heal vs. surface: the judgment
+Healing is powerful and contained (`cxc` = a Claude agent in a disposable box),
+but autonomy needs a leash:
+- **`--auto` only for safe, reversible, well-scoped fixes:** a flaky test, a
+ formatting drift, a regenerated lockfile, a re-render. The blast radius is one
+ worktree and the change is reviewable as a commit.
+- **Surface, don't auto-heal, anything with judgment or irreversibility:** a
+ failing scientific claim, a schema change, anything that touches data or deploys
+ or money. `tend` should ping a human, not "fix" the science. The session logs
+ call the human-in-the-loop the real bottleneck; respect it. A refuted claim is a
+ *result to look at*, not a bug to patch away.
+- The conductor stays on the host; **healers run contained** (`cxc`), never with
+ host credentials.
+
+## How it works
+- State is one JSON per watch under `~/.local/share/anu/tend/`. The history is
+ capped, so drift stays legible. No database; no LLM in the scheduler.
+- `tend watch` is the attended heartbeat (a live pane, the trail/investigate-watch
+ twin); `tend cron on` is the unattended one (cron calls the `bin/tend` wrapper
+ so it works without an interactive shell).
+- `tend dash` renders the same fixed B&W template grammar as map/atlas/trail:
+ every watch with a pass/fail sparkline, failing ones flagged. Autonomy you can
+ *see*.
+
+## Rules
+- **Contained by default.** Healers are `cxc`; never auto-heal with host creds.
+- **Don't auto-heal the irreversible or the judgment-heavy.** Surface it.
+- **A check must be deterministic:** a watch that flaps teaches nothing. Make the
+ command return clean pass/fail.
+- **Drift is the signal.** The value is the recorded history, not any single run.
+ A check that silently started failing three days ago is exactly what tend exists
+ to catch.
diff --git a/plugins/tend/skills/tend/build.py b/plugins/tend/skills/tend/build.py
new file mode 100644
index 0000000..c8958e6
--- /dev/null
+++ b/plugins/tend/skills/tend/build.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Build the tend health index: scan the watch JSONs, emit tend.json.
+
+Usage: build.py
+
+No LLM: the health view IS the recorded watch state. Each watch contributes its
+last status and a sparkline of its recent run history, so drift over time is
+visible at a glance.
+"""
+import json
+import pathlib
+import sys
+
+
+def load(p):
+ try:
+ x = json.loads(pathlib.Path(p).read_text())
+ return x if isinstance(x, dict) else None
+ except Exception:
+ return None
+
+
+def main():
+ if len(sys.argv) != 3:
+ sys.exit("usage: build.py ")
+ d, out = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2])
+ watches = []
+ for wf in sorted(d.glob("*.json")):
+ if wf.name == "tend.json":
+ continue
+ w = load(wf)
+ if not w or "name" not in w:
+ continue
+ hist = [h for h in (w.get("history") or []) if isinstance(h, dict)]
+ watches.append({
+ "name": w.get("name"), "repo": w.get("repo"), "cmd": w.get("cmd"),
+ "status": w.get("last_status", "unknown"), "last_run": w.get("last_run"),
+ "every": w.get("every"), "heal": w.get("heal", ""),
+ "auto": bool(w.get("auto", False)),
+ "runs": len(hist),
+ "passes": sum(1 for h in hist if h.get("status") == "pass"),
+ "spark": [h.get("status") for h in hist][-40:],
+ })
+ counts = {
+ "watches": len(watches),
+ "passing": sum(1 for w in watches if w["status"] == "pass"),
+ "failing": sum(1 for w in watches if w["status"] == "fail"),
+ }
+ out.parent.mkdir(parents=True, exist_ok=True)
+ out.write_text(json.dumps({"counts": counts, "watches": watches}, indent=2))
+ print(out)
+
+
+main()
diff --git a/plugins/tend/skills/tend/render.py b/plugins/tend/skills/tend/render.py
new file mode 100644
index 0000000..250b26c
--- /dev/null
+++ b/plugins/tend/skills/tend/render.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Render tend.json into index.html using the fixed template.
+
+Usage: render.py
+
+Same contract as map/atlas/trail: the template never varies, all per-run content
+is one injected JSON blob the page renders client-side.
+"""
+import json
+import pathlib
+import sys
+
+
+def main():
+ if len(sys.argv) != 3:
+ sys.exit("usage: render.py ")
+ src, out = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2])
+ template = (pathlib.Path(__file__).resolve().parent / "template.html").read_text()
+ data = json.dumps(json.loads(src.read_text())).replace("
+
+
+
+
+tend
+
+
+
+tend
+
+
+
+
+
+
diff --git a/tests/bash/atlas_test.sh b/tests/bash/atlas_test.sh
new file mode 100644
index 0000000..b132085
--- /dev/null
+++ b/tests/bash/atlas_test.sh
@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# atlas — the corpus index. build.py scans the atlas + trail JSON into one
+# record set and one frontier queue; render.py injects it into the fixed
+# template. The frontier (gaps + open questions + investigation frontiers) is
+# the compounding mechanism, so it gets the most coverage.
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$here/../lib/harness.sh"
+source "$here/../lib/helpers.bash"
+
+t_suite "atlas"
+
+SKILL="$ANU_ROOT/plugins/atlas/skills/atlas"
+atlas=$(mktmp); trail=$(mktmp)
+mkdir -p "$atlas/papers/W123/present" "$atlas/investigations/inv-1" "$atlas/demo-repo" "$trail/demo-repo"
+
+cat > "$atlas/papers/W123/study.json" <<'JSON'
+{"paper":{"title":"A test paper"},"summary":"sum","gap":["the open gap"],"open_questions":["an open q"],"neighbors":[1,2,3]}
+JSON
+: > "$atlas/papers/W123/present/index.html"
+cat > "$atlas/investigations/inv-1/investigation.json" <<'JSON'
+{"investigation":{"question":"does X beat Y?"},"verdict":"X wins","funnel":{"weighed":5,"hypotheses":3,"confirmed":2},"frontier":["try Z next"]}
+JSON
+: > "$atlas/investigations/inv-1/trail.html"
+# repo is an object {name, path, ...} in real map.json / trail.json, not a string.
+cat > "$atlas/demo-repo/map.json" <<'JSON'
+{"repo":{"name":"demo-repo","path":"/x","branch":"master"},"summary":"a repo","components":[1,2],"open_questions":["map question"]}
+JSON
+cat > "$trail/demo-repo/trail.json" <<'JSON'
+{"repo":{"name":"demo-repo","goal":"the goal"},"nodes":[1,2,3,4]}
+JSON
+
+t_section "build.py assembles one record per artifact kind"
+python3 "$SKILL/build.py" "$atlas" "$trail" "$atlas/atlas.json" >/dev/null
+assert_ok $? "build.py runs"
+assert_file "$atlas/atlas.json" "atlas.json written"
+assert_jq "$atlas/atlas.json" '.counts.study' "1" "one study"
+assert_jq "$atlas/atlas.json" '.counts.investigation' "1" "one investigation"
+assert_jq "$atlas/atlas.json" '.counts.map' "1" "one repo map"
+assert_jq "$atlas/atlas.json" '.counts.trail' "1" "one trail"
+assert_jq "$atlas/atlas.json" '[.records[]|select(.kind=="study")][0].href' "papers/W123/index.html" "study links to its dossier"
+assert_jq "$atlas/atlas.json" '[.records[]|select(.kind=="investigation")][0].summary' "X wins" "investigation summary is its verdict"
+assert_jq "$atlas/atlas.json" '[.records[]|select(.kind=="investigation")][0].title' "does X beat Y?" "investigation title is its question"
+# repo is an object in real artifacts — title must coerce to the name, not stringify the object.
+assert_jq "$atlas/atlas.json" '[.records[]|select(.kind=="map")][0].title' "demo-repo" "map title coerces repo.name"
+assert_jq "$atlas/atlas.json" '[.records[]|select(.kind=="trail")][0].title' "demo-repo" "trail title coerces repo.name"
+assert_jq "$atlas/atlas.json" '[.records[]|select(.kind=="trail")][0].summary' "the goal" "trail summary falls back to repo.goal"
+
+t_section "frontier collects gaps, open questions and frontiers across kinds"
+assert_jq "$atlas/atlas.json" '.frontier | length' "4" "gap + open_q + inv frontier + map question = 4"
+assert_jq "$atlas/atlas.json" 'any(.frontier[]; .text=="try Z next")' "true" "investigation frontier included"
+assert_jq "$atlas/atlas.json" 'any(.frontier[]; .text=="the open gap")' "true" "study gap included"
+assert_jq "$atlas/atlas.json" 'any(.frontier[]; .text=="map question")' "true" "map open-question included"
+
+t_section "only real edges are recorded (no inferred gap->hypothesis)"
+assert_jq "$atlas/atlas.json" 'any(.edges[]; .kind=="study→present")' "true" "study→present edge"
+assert_jq "$atlas/atlas.json" 'any(.edges[]; .kind=="investigation→trail")' "true" "investigation→trail edge"
+assert_jq "$atlas/atlas.json" '.edges | length' "2" "exactly the two real edges"
+
+t_section "render.py injects the corpus into the fixed template"
+python3 "$SKILL/render.py" "$atlas/atlas.json" "$atlas/index.html" >/dev/null
+assert_ok $? "render.py runs"
+assert_file "$atlas/index.html" "index.html written"
+html=$(cat "$atlas/index.html")
+assert_contains "$html" "does X beat Y?" "a record title is embedded"
+assert_not_contains "$html" "__ATLAS__" "placeholder fully replaced"
+
+t_section "atlas fn wires through core (deps guarded, no silent fail)"
+source "$(anu_fns atlas)" 2>/dev/null
+assert_contains "$(declare -f atlas)" "_anu_require" "atlas() guards python3"
+
+t_done
diff --git a/tests/bash/core_test.sh b/tests/bash/core_test.sh
new file mode 100644
index 0000000..744a6a8
--- /dev/null
+++ b/tests/bash/core_test.sh
@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# core — the shared diagnostic/dependency primitives every other fn leans on.
+# These are load-bearing for unattended agents: a missing tool or a dead pane
+# must surface as one clear line, not a symptom three calls deep.
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$here/../lib/harness.sh"
+source "$here/../lib/helpers.bash" # sources config/bash/fns/core
+
+t_suite "core"
+
+t_section "_anu_require names missing tools, passes present ones"
+_anu_require bash 2>/dev/null; assert_ok $? "single present tool → 0"
+_anu_require bash sh 2>/dev/null; assert_ok $? "multiple present → 0"
+_anu_require 2>/dev/null; assert_ok $? "no args → 0"
+_anu_require __anu_no_such__ 2>/dev/null; assert_fail $? "missing tool → nonzero"
+err=$(_anu_require __anu_no_such__ 2>&1)
+assert_contains "$err" "__anu_no_such__" "names the missing tool"
+assert_contains "$err" "anu:" "uses the anu: prefix"
+err=$(_anu_require __nope_a__ __nope_b__ 2>&1)
+assert_contains "$err" "__nope_a__" "lists every missing tool (1/2)"
+assert_contains "$err" "__nope_b__" "lists every missing tool (2/2)"
+
+t_section "diagnostics go to stderr and _anu_die returns 1"
+out=$(_anu_die "boom" 2>/dev/null); assert_eq "" "$out" "_anu_die silent on stdout"
+err=$(_anu_die "boom" 2>&1 >/dev/null); assert_contains "$err" "boom" "_anu_die → stderr"
+_anu_die "x" 2>/dev/null; assert_fail $? "_anu_die returns 1"
+err=$(_anu_warn "heads up" 2>&1 >/dev/null); assert_contains "$err" "heads up" "_anu_warn → stderr"
+
+t_section "swarm wires its guards through core"
+# Static wiring checks — no live tmux needed. Sourcing swarm alone must still
+# succeed (the smoke test proves it) and the guards must be present in the body.
+source "$(anu_fns swarm)" 2>/dev/null
+assert_contains "$(declare -f swarm)" "_anu_require" "swarm() guards jq/tmux"
+assert_contains "$(declare -f _swarm_send)" "injection failed" "swarm send reports a failed injection"
+assert_contains "$(declare -f _swarm_agents_hint)" "available:" "agents-hint helper exists"
+
+t_section "_swarm_agents_hint turns a bad id into a self-correcting list"
+sd=$(mktmp); mkdir -p "$sd/agents"
+: > "$sd/agents/agent-1.json"; : > "$sd/agents/agent-2.json"
+hint=$(_swarm_agents_hint "$sd")
+assert_contains "$hint" "agent-1" "hint lists agent-1"
+assert_contains "$hint" "agent-2" "hint lists agent-2"
+assert_eq "" "$(_swarm_agents_hint "$(mktmp)" 2>/dev/null)" "no agents → empty hint"
+
+t_section "bin wrappers source core so the new guards resolve (the agent path)"
+# Regression: bin/swarm sourced fns/swarm but not fns/core, so swarm()'s
+# _anu_require guard died with "_anu_require: command not found" on every
+# non-interactive call. Both wrappers must source core before their fn.
+for w in swarm tend; do
+ out=$(ANU_PATH="$ANU_ROOT" XDG_DATA_HOME="$(mktmp)" bash "$(anu_bin "$w")" status 2>&1)
+ assert_not_contains "$out" "command not found" "bin/$w runs without an undefined-function error"
+done
+
+t_done
diff --git a/tests/bash/smoke_test.sh b/tests/bash/smoke_test.sh
index 12b9b64..c6983d4 100644
--- a/tests/bash/smoke_test.sh
+++ b/tests/bash/smoke_test.sh
@@ -29,7 +29,7 @@ declare -A entry=(
[review]=review [swarmext]=swarmx [configmap]=cfgmap [dashboard]=pd
[agentlog]=agentlog [map]=map [dynlayout]=taa [agentlaunch]=al
[meshsync]=meshsync [tile]=tile [init_project]=anu_init [relink]=relink
- [delve]=delve
+ [delve]=delve [atlas]=atlas [tend]=tend
)
for file in "${!entry[@]}"; do
fn="${entry[$file]}"
diff --git a/tests/bash/tend_test.sh b/tests/bash/tend_test.sh
new file mode 100644
index 0000000..b67fbde
--- /dev/null
+++ b/tests/bash/tend_test.sh
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# tend — the continuity layer: register checks, run them, record drift, render
+# the health dashboard. The scheduler is pure bash + jq (no LLM); the heal path
+# spawns a contained agent and is covered at the brief-construction level.
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$here/../lib/harness.sh"
+source "$here/../lib/helpers.bash" # sources config/bash/fns/core
+export XDG_DATA_HOME="$(mktmp)" # isolate ~/.local/share/anu/tend
+source "$(anu_fns tend)"
+
+t_suite "tend"
+
+t_section "duration parsing"
+assert_eq "1800" "$(_tend_secs 30m)" "30m → 1800s"
+assert_eq "3600" "$(_tend_secs 1h)" "1h → 3600s"
+assert_eq "86400" "$(_tend_secs 1d)" "1d → 86400s"
+assert_eq "90" "$(_tend_secs 90s)" "90s → 90s"
+assert_eq "3600" "$(_tend_secs junk)" "garbage → 1h default"
+assert_eq "3600" "$(_tend_secs 1.5h)" "fractional → 1h default (no arithmetic crash)"
+assert_eq "3600" "$(_tend_secs 2hh)" "malformed suffix → 1h default"
+assert_eq "2h" "$(_tend_human 7200)" "7200s → 2h"
+
+t_section "add registers a watch JSON"
+tend add ci --every 30m -- true >/dev/null
+f="$(_tend_file ci)"
+assert_file "$f" "watch json written"
+assert_jq "$f" '.name' "ci" "name"
+assert_jq "$f" '.cmd' "true" "cmd"
+assert_jq "$f" '.every' "1800" "cadence in seconds"
+assert_jq "$f" '.last_status' "unknown" "starts unknown"
+
+t_section "run records pass/fail and grows history"
+tend run ci >/dev/null
+assert_jq "$f" '.last_status' "pass" "true → pass"
+assert_jq "$f" '.history|length' "1" "history has one entry"
+tend add broken -- false >/dev/null
+tend run broken >/dev/null
+bf="$(_tend_file broken)"
+assert_jq "$bf" '.last_status' "fail" "false → fail"
+assert_jq "$bf" '.last_output|type' "string" "output captured"
+
+t_section "status lists every watch"
+out="$(tend status 2>&1)"
+assert_contains "$out" "ci" "status shows ci"
+assert_contains "$out" "broken" "status shows broken"
+
+t_section "heal brief carries the failing command and success condition"
+tend add needsheal --heal cxc -- false >/dev/null
+tend run needsheal >/dev/null
+brief="$(_tend_heal_brief needsheal)"
+assert_contains "$brief" "false" "brief names the failing check"
+assert_contains "$brief" "must pass" "brief states the success condition"
+
+t_section "rm removes a watch"
+tend rm ci >/dev/null
+assert_eq "0" "$([[ -f "$f" ]] && echo 1 || echo 0)" "watch file gone"
+
+t_section "dash builds and renders the health view"
+SKILL="$ANU_ROOT/plugins/tend/skills/tend"
+python3 "$SKILL/build.py" "$(_tend_dir)" "$(_tend_dir)/tend.json" >/dev/null
+assert_file "$(_tend_dir)/tend.json" "tend.json built"
+assert_jq "$(_tend_dir)/tend.json" '.counts.failing >= 1' "true" "failing count reflects broken watch"
+python3 "$SKILL/render.py" "$(_tend_dir)/tend.json" "$(_tend_dir)/index.html" >/dev/null
+html="$(cat "$(_tend_dir)/index.html")"
+assert_contains "$html" "broken" "watch embedded in dash"
+assert_not_contains "$html" "__TEND__" "placeholder replaced"
+
+t_section "add rejects a value-less flag instead of looping forever"
+( tend add hangy --every >/dev/null 2>&1 ); assert_fail $? "trailing --every fails fast (no infinite loop)"
+( tend add hangy --heal >/dev/null 2>&1 ); assert_fail $? "trailing --heal fails fast"
+
+t_section "watch command round-trips through bash -c with quoting intact"
+tend add spacey -- printf '[%s]' 'a b' >/dev/null
+assert_eq "[a b]" "$(bash -c "$(jq -r '.cmd' "$(_tend_file spacey)")" 2>&1)" "a space-containing arg survives (not flattened)"
+
+t_section "armed --auto runs the literal heal command and marks the heal in flight"
+tend add healme --heal "touch $XDG_DATA_HOME/HEALED" --auto -- false >/dev/null
+tend run healme >/dev/null 2>&1
+assert_file "$XDG_DATA_HOME/HEALED" "auto --heal '' actually executed on failure"
+assert_ne "null" "$(jq -r '.healing_since' "$(_tend_file healme)")" "healing_since set (debounce marker)"
+
+t_section "tend wires through core"
+assert_contains "$(declare -f tend)" "_anu_require" "tend() guards jq"
+
+t_done
diff --git a/tests/lib/helpers.bash b/tests/lib/helpers.bash
index 2d85a63..322978b 100644
--- a/tests/lib/helpers.bash
+++ b/tests/lib/helpers.bash
@@ -11,6 +11,12 @@ export ANU_ROOT
# Many fns resolve sibling files via $ANU_PATH; point it at the repo under test.
export ANU_PATH="$ANU_ROOT"
+# Shared primitives (_anu_require/_anu_die/_anu_warn/...) that swarm, ncn, and
+# the rest call at runtime. The real shell loads this first via the fns/* glob;
+# tests load it explicitly so functions-under-test resolve their helpers.
+# shellcheck source=/dev/null
+source "$ANU_ROOT/config/bash/fns/core"
+
# Path to a function file under config/bash/fns (or bin).
anu_fns() { printf '%s/config/bash/fns/%s' "$ANU_ROOT" "$1"; }
anu_bin() { printf '%s/config/bash/bin/%s' "$ANU_ROOT" "$1"; }