HOMI

Open and drive a REAL Chromium browser pane inside anu's tmux session. Use this whenever you need to actually SEE or interact with a web page — check a localhost dev preview after starting a dev server, verify a deploy looks right, read a docs/page that needs JavaScript, reproduce a UI bug, or fill out / click through a web form. Renders a real page (JS/CSS/Canvas/WebGL) via the kitty graphics protocol, in the same Chromium the human sees, so they watch your actions live. Drive it with the `browser` command or the browser_* MCP tools (open/navigate/screenshot/read/snapshot/eval/click/crop/type).

Generate a repo dossier as one fixed-template black-and-white HTML page in the anu atlas (~/.anu/atlas/<repo>): summary, component tree, dependency graph, choices made, divergences, open questions. Fans out reader agents via the Workflow tool; archives each run for diffing. Invoked by /map. Use when the user runs /map or asks to map, explain, or explore this repo as a dossier.

Understand a repository — a black-and-white, table-first Load-Bearing Ledger that ranks every file by structural importance and explains why. Personalized PageRank over the bash-call + python-import graph (utility-down-weighted, entry-point-seeded) is the rank; each row carries a reason vector (imported-by, churn/hotspot, ownership, entry-point, cycle) so no number is bare. Deterministic, reproducible, no LLM — the same parse→JSON→fixed-template→~/.anu/grok/<repo> pattern as scene/trail/git. Use when the user runs `grok` or asks to understand/see the shape of a repo, what files matter, what's load-bearing, what's linked most, or what to read first.

You back a chat as a persistent working agent. Do the turn's work in your terminal (it's shown live to the person); write only your concise final answer to $ANU_CHAT_REPLY, which they read as your reply.

Produce a live rendered artifact (a chart, a computation, a small notebook) that flows inline into your chat answer — when, and only when, running code or plotting would genuinely serve the answer. You decide; writing the file is the only signal.

Git for agents — the cockpit that composes the commit DAG (scene) with the commitments (trail) into ONE graph joined by commit SHA, rendered as four lenses — Evolution (the commit DAG carrying the why, with counterfactual edges = the road not taken), Research (the commitment/hypothesis map), Commitments (what governs each scope), Live (agents now). One surface, lenses not modes; the commit is the truth, the rest decorates it. Run `gfa` (provisional command) → ~/.anu/git/<repo>/index.html. Use when the user wants to see a project evolving WITH its decisions and roads-not-taken, runs `gfa`, or asks for the git-for-agents view.

Record decisions as commit-message trailers — Commitment (Type hypothesis|decision|constraint|goal) with Scope/Caused/Predicts/Alternatives/Resolves/Outcome; Hypothesis:/Decision: are grandfathered aliases — so reasoning reconstructs from git log (no LLM) and renders as a black-and-white decision graph plus tempo timeline in ~/.anu/trail/<repo>. `trail active --scope <path>` surfaces the commitments governing a file; `trail check`/`trail gate` flag edits to governed scope that don't honor them; trail swarm merges per-worktree trails into a disagreement matrix. Use when working as a long-running agent; whenever a commit embodies a hypothesis, a chosen direction, or the resolution of an earlier one; before editing code a commitment governs; or when the user runs `trail` or asks to see or record the decision trail.

Render the commit scene — a black-and-white network graph of a repo's whole git DAG (branches, worktrees, merges, tags) as one fixed-template HTML page in ~/.anu/scene/<repo>. The trunk is the left lane, each divergent branch/worktree gets its own, time flows down, old history collapses into ▸N pills, and a frontier rail lists every branch with ahead/behind + dirty so you can see "every direction the work is going" at a glance. No LLM — pure git plumbing. Use when the user runs `scene` or asks to see/visualize the git graph, commit network, branches, or what's diverging in this repo.

Push a tmux pane — your own, a specific one, a whole window, or a swarm — onto the anu wall, the system wall provider's browser display (default system.aadarwal.com, served across your own Tailscale devices, not the open internet), and list or pull panes off it. Use when asked to show / put / push / mirror a pane or your work on the wall / screen / display / system.aadarwal.com, to surface an agent's pane on the big screen, or to take something off the wall. Tools — spane (pushes focused/window/swarm, opens the wall) and the wall backend ${SYSTEM_CMD_NS}.pane (ls and rm; default aadarwal.system.pane) — both on your PATH.

Grow the jnanin knowledge map by talking. Runs the capture loop — knowledge log → candidates → resolve within candidates → apply → build — turning a free-text sentence about what you studied into evidence that moves mastery and the frontier. Use when the user says what they learned/reviewed/are shaky on/forgot, or invokes /knowledge-log "...". The pane stays read-only; the resolver only ever picks from the candidate set; structure changes are parked for a separate gated pass.

You are one AI agent in a tmux pane inside anu; other agents (claude/codex/opencode/pi) may be running in sibling panes right now. Use this whenever you need to find, message, read, or spawn another agent or pane — when the user refers to another pane or agent ("the codex pane next to you", a pane id like %82, agent-2, "the claude in window 2"), asks you to talk to / coordinate with another agent, or asks you to create panes running specific agents. Gives the one-command way to drive a pane (`pane send`), names the agent vocabulary (cx/cxx/cxc/cdx/cdxx/cdxxs/c/pi), and routes to anu-talk (message a pane) and anu-spawn (create panes).

Message another agent's tmux pane and get its reply — reliably, with one command. Use to talk to / prompt / relay to / coordinate with another agent or pane ("tell the codex pane to…", "ask the claude in %82…", relaying between agents), to get an answer back from a sibling agent, or when a pane received text but did not act on it (staged "[Pasted Content]" / unsubmitted). The tool is `pane` (send / ask / read / wait / ls / id); this covers it, how to pass messages containing awkward characters safely, finding panes, and the swarm send / swarm read wrappers.

Use when an agent hits friction with anu itself or is asked to capture, triage, or act on an anu rough edge with `anu recurse`. Covers the recurse backlog, the safety rule for live config, and when to auto-fix versus propose only.

The quantitative research ledger — the twin of `trail`. trail records *that* a hypothesis was confirmed; the ledger records *by how much*. A long-running agent logs each experimental run as commit-message trailers (Metric / Config / Artifact / Runtime), so the runs reconstruct from `git log` with no database, and the ledger mechanically checks every machine-readable `Predicts:` against the recorded `Metric:` — flagging the dangerous case where the written `Outcome: confirmed` disagrees with the number. Renders a fixed-template black-and-white run table / sweep / leaderboard in ~/.anu/atlas/ledger/<repo>, no LLM in the loop. Use when running experiments whose numbers matter, when recording a measured result, when comparing runs or a parameter sweep, or when the user runs /ledger or asks to see the run ledger / leaderboard / sweep.

Create one or more agent panes running specific AI agents. Use when the user asks to spawn / open / add / create panes running agents ("one codex and one claude", "give me 4 contained claude agents", "add a codex next to me"), or asks what an agent alias means (cx/cxx/cxc/cdx/cdxx/cdxxs/c/pi) or which to use. As an agent you spawn with `pane spawn` (a bin on your PATH); the taa/tsl/tslm/al family are interactive-shell functions for the human and are NOT callable from your Bash tool. Covers the vocabulary, host vs contained (box), and which alias fits which autonomy level.

Run a research question as a swarm. Frame it (or a /study gap) into falsifiable hypotheses, test each as a contained cxc agent in its own git worktree (swarm wt), verify outcomes adversarially against their evidence, and render one fixed-template HTML investigation to ~/.anu/atlas/investigations/<slug>. Launcher investigate with a live investigate watch cockpit. Composes trail, swarm, box. Use when the user runs /investigate or asks to test / pursue / run experiments on / settle a question.

Rigorous, skeptical statistics on result data — the anti-p-hacking workflow between do (experiments make data) and write (claims about data). Point /analyze at a data file (CSV/TSV/parquet/json) or a results directory (e.g. from /investigate) and the question; it profiles the real data, picks the CORRECT test for THIS data shape and checks its assumptions, reports effect sizes WITH confidence intervals (never a p-value alone), corrects for multiple comparisons (or says why none is needed), fits/compares models, makes B&W publication figures, and runs an adversarial threats-to-validity pass — then renders one fixed-template HTML analysis in the atlas (~/.anu/atlas/analyses/<slug>). Use when the user runs /analyze or asks to analyze / run statistics on / find the effect in / test for significance in / check the assumptions of / make figures from result data, or asks whether a result is real or over-claimed.

Assemble a project's research artefacts into an evidence-grounded IMRaD draft whose hero is a claims↔evidence ledger, then self-audit. The seam between the DOING track (/investigate, /analyze) and the PUBLISHING track (science-writing). /draft ASSEMBLES, it never fabricates — every claim it writes traces to a real artefact (a figure, a number, a citation, a trail outcome, a /study or /survey card); any claim without support is FLAGGED for the human, never invented. Auto-discovers atlas artefacts (study/survey/investigation/analysis) and the git decision trail, builds the ledger + a grounded outline + scaffold prose with [NEEDS:] placeholders, and writes a deliverable draft.md plus a META-view (ledger + outline + audit) in the atlas. The prose is SCAFFOLD to verify, not a finished paper. Use when the user runs /draft or asks to draft / write up / assemble a paper / manuscript / write-up from their results. Next track: science-writing (/check-claims, /verify-citations, /peer-review).

Synthesize a whole literature into one fixed-template HTML page in the anu atlas (~/.anu/atlas/surveys/<slug>) — the understand-the-FIELD twin of /study (which understands one paper). Assemble a grounded corpus around a topic, seed paper, or a /study dossier's neighborhood, cold-read each paper in parallel, then synthesize a comparison matrix, the schools of thought, consensus vs OPEN disputes, the field arc, and the collective gap. Every paper comes from the `scholar` engine or a source actually fetched — never named from memory; evidence quoted. Its gap[]/disputes[] feed /investigate. Use when the user runs /survey or asks to survey / review the literature / map a field / synthesize the work on / give the lay of the land for a topic.

Use when inferring a codebase's design choices for the explore report: the archaeological-ADR card schema, the evidence-source hierarchy, the confidence ladder, and the rules that keep inferred decisions honest (no evidence-free claims, no strawman alternatives, consequences phrased as editing advice).

Use when generating the explore plugin's HTML codebase report. Holds the fixed design system (template.html) and the content rules: two-pass prose-then-visuals discipline, node budgets, evidence requirements, confidence labels, and how to fill every slot. The report's look and structure never vary between repos; only the content does.

Discipline for finding and reasoning about prior art, related papers, intellectual lineage, and similar codebases without fabricating. Use whenever assessing whether a research idea is novel, what work is nearest to it, what a paper builds on or influenced, or what code already does something, including the /prior-art, /similar-code, and /lineage commands. Centers on the `scholar` retrieval engine and the rule that no paper or claim is ever asserted from memory.

Generate a paper dossier. Study one paper (or idea with a seed paper) into a fixed-template HTML page in the anu atlas (~/.anu/atlas/papers/<id>): what it claims, what it stands on and led to, the nearest work classified by closeness, code that implements it, and the bounded gap. Fans out reader/lineage/neighborhood/code agents via the Workflow tool and screens neighbors cold. Use when the user runs /study or asks to catch me up on / understand / situate a paper. The /map of an idea.

The experimenter's discipline for a long-running research agent: hold one hypothesis, design the cheapest experiment that could refute it, run it in your contained box, and record the trail (Hypothesis/Predicts/Alternatives to Resolves/Outcome/Evidence) as commit trailers so the run reconstructs from git. Be your own skeptic; a clean refutation is a result, record it. Use when an agent is briefed to test a hypothesis as part of an /investigate swarm, or whenever you are running an experiment whose outcome should land in the decision trail.

Use when creating 3D scenes in Manim Community Edition. Covers ThreeDScene, camera angles (phi, theta), ThreeDAxes, Surface and ParametricFunction for parametric 3D objects, ambient rotation, and the limitations (manim 3D is perspective-projected vector graphics: no lighting, no shadows, no z-buffer).

Use when composing Manim animations: choosing between Create/Write/FadeIn/Transform, sequencing animations with AnimationGroup/LaggedStart/Succession, controlling timing with run_time and rate_func, pacing (how long things stay on screen), ValueTracker-driven continuous animation, semantic color discipline, and animating between TeX expressions with TransformMatchingTex.

Use whenever Manim code contains manimgl / 3b1b idioms (`from manimlib import *`, manim_imports_ext, ShowCreation, TexMobject, TextMobject, CONFIG dicts, GraphScene, InteractiveScene, PiCreature, self.frame), or when porting 3b1b video code to Manim Community Edition, or when valid-looking manim code errors in ways that suggest the wrong fork is installed. Maps every GL API to its CE equivalent.

Use when authoring or editing Manim Community Edition (manim-ce) scenes. Covers the Scene/Mobject model, the construct() lifecycle, the add/play distinction, coordinate system and direction constants, common Mobjects (Text, MathTex, geometric shapes), MathTex/LaTeX error triage, project workflow for multi-scene videos, and the gotchas that distinguish manim-ce from 3b1b's manimgl.

Use when authoring, editing, or debugging marimo notebooks (.py files containing @app.cell decorators or import marimo as mo). Covers reactive execution, cell anatomy, PEP 723 inline dependencies, mo.ui widgets, SQL cells via mo.sql, plotting rules, script mode, pytest integration, sharing/WASM export, and the `marimo check` lint contract, plus the Jupyter differences that trip up new users.

ncn apple profile. Connect to a Mac on the mesh over SSH and work inside a contained box (apple/container disposable Linux VM) instead of on the bare host. Used by the ncn conductor when the chosen node is a Mac; also use when the user asks to reach a Mac device safely or run contained work on another Mac.

ncn box profile. A disposable Linux container (apple/container) on THIS machine, worktree mounted at its real path. Used by the ncn conductor when the chosen node is localhost; also use when the user wants a contained local Linux session to build/test/validate before shipping to a remote node.

ncn cluster profile. Stand up a live link from this host into an HPC cluster (MIT Engaging / Slurm). Submit a Slurm job that runs Jupyter-on-GPU inside Apptainer on a compute node, then reach it through an ssh -L tunnel so the node's port appears at localhost. Used by the ncn conductor when the chosen node is a cluster; also use when the user asks to connect to the cluster, a compute node, or to get a remote GPU kernel.

Node connection. nc/ncn open a two-pane window: a host conductor (cxx) drives a live link to an execution node, adapting to its type. cluster: Slurm Jupyter-on-GPU in Apptainer over an ssh -L tunnel. apple/box: a contained box. ssh: a remote Linux shell. ncn also forwards a node program to localhost. Router skill for the ncn-<profile> skills. Use when the user runs `nc`/`ncn`, asks to connect to a node/device/cluster, or wants to pick where to run work.

ncn ssh profile. A live remote shell on a Linux device on the mesh. Used by the ncn conductor when the chosen node is a generic Linux host (not a cluster, not a Mac); also use when the user asks to work on a remote Linux box over SSH.

Use when orchestrating agents inside anu: deciding which swarm topology fits a task, writing worker briefs, running contained (cxc) agents for unattended work, and collecting/merging results. Covers the judgment the command tables don't: when each topology pays off, how to brief a worker, the conductor/worker protocol, and the common failure modes.

Turn a research exploration (or a /study dossier) into a served visual presentation: choose a medium per result (Manim animation, marimo app, static figure, or served notebook), render on the right compute via ncn, assemble one landing page, and serve it over Tailscale. Composes manim, marimo, ncn. Invoked by /present. Use when the user wants to present/show/demo what an exploration found, build a talk or interactive demo from notebooks, or animate a result.

Use when writing or revising the abstract of a scientific paper. Covers structured vs unstructured abstracts, word budgets, the canonical five-move pattern, sentence-by-sentence templates, and the rule that the abstract must be self-contained (no abbreviations, no citations, no figure references).

Use when formatting citations or bibliographies in a scientific document. Covers the four dominant styles (APA, Chicago author-date, IEEE, Vancouver), in-text citation patterns, and the pitfalls of each (page numbers, et al. thresholds, DOI inclusion, ordering of references).

Use when verifying that citations in a manuscript are real, correctly attributed, and actually support the claims they're attached to. Covers existence/metadata verification against Crossref, OpenAlex, and Semantic Scholar; detecting hallucinated and chimeric references (real title, wrong authors); retraction checking; and claim-support auditing (does the cited paper say what the manuscript says it says).

Use when drafting, restructuring, or reviewing an empirical scientific paper. Covers the IMRaD format (Introduction, Methods, Results, Discussion): what each section contains, the rhetorical move set, common failure modes, and section-by-section editing checks.