claude-math 0.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,13 @@
+{
+  "name": "vladimirrott",
+  "owner": { "name": "Vladimir Rotariu" },
+  "metadata": { "description": "Vladimir's Claude Code plugins" },
+  "plugins": [
+    {
+      "name": "claude-math",
+      "source": "./",
+      "description": "Renders math as Unicode glyphs in the terminal instead of unrenderable LaTeX",
+      "version": "0.1.0"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "claude-math",
+  "version": "0.1.0",
+  "description": "Render math legibly in Claude Code. Emits Unicode glyphs instead of unrenderable LaTeX in the terminal (works in every terminal). Graphical sixel/kitty rendering is on the roadmap.",
+  "author": { "name": "Vladimir Rotariu", "email": "vladimirrott@users.noreply.github.com" },
+  "license": "MIT",
+  "homepage": "https://github.com/vladimirrott/claude-math",
+  "keywords": ["math", "latex", "katex", "unicode", "rendering", "skill"]
+}

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to `claude-math` documented here. Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [SemVer](https://semver.org/).
+
+## [0.1.0] — 2026-05-20
+
+### Added
+- `math-unicode` skill — auto-triggers on math; instructs Claude to emit math as Unicode glyphs (Greek, operators, relations, logic, sub/super) instead of raw LaTeX dollar-sign syntax.
+- LaTeX → Unicode cheatsheet, style rules, common-forms reference, anti-patterns.
+- `claude-math` CLI (`bin/claude-math.js`) — `install` / `uninstall` / `status` / `prepack` commands. Symlinks plugin into `~/.claude/plugins/local/` and patches `installed_plugins.json` + `settings.json`.
+- **Install safety**: atomic JSON writes (`.tmp` + rename); `.claude-math.bak` backup of `settings.json` and `installed_plugins.json` on first touch; refuses to overwrite a foreign symlink or non-plugin directory without `--force`.
+- **Install modes**: auto-copy when invoked from an npx cache path (ephemeral location); junction on Windows; symlink elsewhere. `--copy` flag forces copy.
+- **Tests**: `node --test` suite covering install/uninstall round-trip, idempotency, atomicity, backups, copy mode, foreign-symlink refusal, and prepack version sync.
+- **CI**: `.github/workflows/ci.yml` (matrix: ubuntu/macos × node 18/20/22) and `.github/workflows/publish.yml` (tag-triggered `npm publish --provenance`).
+- `prepack` script auto-syncs `.claude-plugin/plugin.json` version from `package.json` so the two never drift.
+- Roadmap notes for opt-in graphical rendering (sixel / kitty graphics via a `claude-math-render` MCP server).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladimir Rotariu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# claude-math
+
+Make math in Claude Code legible.
+
+<p align="center">
+  <img src="assets/demo.svg" alt="Without claude-math, LaTeX prints as raw dollar-sign noise; with it, the same answer renders as clean Unicode math." width="760">
+</p>
+
+Claude Code's terminal does not render LaTeX. Without help, a formula like
+`$f(x) = \sum_{i=1}^n x_i$` appears as raw dollar signs and backslashes,
+exactly the noise you wanted formatting to remove. This plugin ships a single
+skill (`math-unicode`) that instructs Claude to emit math as Unicode glyphs
+inline, which every terminal already renders.
+
+## Before / after
+
+```
+Before:  The qualifying cohort is $Q = \{ (s,r) \in T : n_{s,r} \geq 18 \wedge p^0_{s,r} < 0.9 \}$,
+         with $|Q| / |T| \approx 17.3\%$.
+
+After:   The qualifying cohort is Q = { (s,r) ∈ T : n_{s,r} ≥ 18 ∧ p⁰_{s,r} < 0.9 },
+         with |Q| / |T| ≈ 17.3 %.
+```
+
+## Install
+
+The quickest install is through the plugin marketplace (see below). The npm and manual paths also work.
+
+### via npm
+
+```bash
+npm install -g claude-math
+claude-math install
+```
+
+Symlinks the package into `~/.claude/plugins/local/claude-math`, registers it
+in `installed_plugins.json`, and enables it in `settings.json` (atomically;
+both files get a `.claude-math.bak` backup on first touch). Restart Claude
+Code and the skill loads.
+
+`npx claude-math install` also works: the CLI auto-detects an npx-cache
+install path and **copies** rather than symlinks (since the cache directory
+is ephemeral). Prefer the global install if you want updates via
+`npm update -g claude-math` to propagate automatically.
+
+Other commands:
+
+```bash
+claude-math status        # report target, validity, settings state, next-install mode
+claude-math uninstall     # remove symlink/dir, deregister, disable
+claude-math --help        # full flag list, env overrides
+```
+
+Flags: `--force` overrides safety checks (foreign symlinks, non-plugin
+directories at the target). `--copy` forces a real copy instead of symlink.
+
+### Manual install
+
+```bash
+git clone https://github.com/vladimirrott/claude-math \
+  ~/.claude/plugins/local/claude-math
+```
+
+Then add `"claude-math@local": true` under `enabledPlugins` in
+`~/.claude/settings.json` and a matching entry in
+`~/.claude/plugins/installed_plugins.json`. The CLI does both; running it
+once is the easiest path.
+
+### Via Claude Code's plugin marketplace (recommended)
+
+```
+/plugin marketplace add vladimirrott/claude-math
+/plugin install claude-math@vladimirrott
+```
+
+### Codex CLI
+
+The `math-unicode` skill works in [OpenAI Codex CLI](https://developers.openai.com/codex/) too: Codex reads skills from `$CODEX_HOME/skills/<name>/SKILL.md` using the same `name` + `description` frontmatter format, so the exact same skill drops straight in.
+
+```bash
+npm install -g claude-math
+claude-math install --codex
+```
+
+This copies the skill into `$CODEX_HOME/skills/math-unicode/` (default `~/.codex/skills/`). Codex auto-detects new skills (restart Codex if it does not appear); invoke it with `/skills` or by mentioning `$math-unicode`. Use `claude-math status --codex` to check and `claude-math uninstall --codex` to remove.
+
+### Hacking on this repo
+
+Working from a clone (before or after publish):
+
+```bash
+git clone https://github.com/vladimirrott/claude-math && cd claude-math
+node bin/claude-math.js install     # uses the cloned directory directly
+node --test test/                   # run the test suite
+```
+
+`CLAUDE_CONFIG_DIR=/tmp/somewhere claude-math install` lets you test against
+a sandbox without touching your real `~/.claude` state, useful for
+contributing.
+
+The `math-unicode` skill auto-triggers any time Claude writes or explains math.
+No configuration required.
+
+## Graphical rendering (sixel / kitty): not inside the chat
+
+Rendering math as an actual image (sixel or kitty graphics) is **not possible
+inside the Claude Code chat**. The TUI repaints its own screen buffer on every
+update and overwrites any graphics escape sequences a plugin emits, and its
+line accounting does not know an image's height. So in-chat output stays
+Unicode, which is the point of this skill.
+
+Roadmap (not built yet): a standalone `claude-math render "<latex>"` command
+that converts LaTeX to an image and prints it via the terminal's graphics
+protocol in your own graphics-capable terminal (kitty, wezterm, ghostty,
+foot), outside the Claude Code TUI. It would be a convenience for viewing an
+equation on demand, not in-chat rendering.
+
+## Why Unicode by default?
+
+| Path | Works in plain terminal | SSH / tmux | CI logs | Copy-paste | Install cost |
+|---|---|---|---|---|---|
+| Unicode (this skill) | ✓ | ✓ | ✓ | ✓ | 1 file |
+| Sixel / kitty graphics | ✗ (not in chat) | partial | ✗ | ✗ images | separate render CLI (roadmap) |
+| Pipe through external viewer | ✗ TUI breaks | n/a | ✓ if `--print` | ✓ | shell wrapper |
+
+Unicode is the only path that survives every distribution channel a Claude
+Code session ends up in. The graphical path is roadmap-only and, even then,
+would run as a separate terminal command outside the chat.
+
+## Related issues & prior art
+
+- [anthropics/claude-code#44479](https://github.com/anthropics/claude-code/issues/44479): native LaTeX in terminal output (open)
+- [openai/codex#15865](https://github.com/openai/codex/issues/15865): LaTeX in Codex CLI output (claude-math covers this via `claude-math install --codex`)
+- [warpdotdev/warp#9677](https://github.com/warpdotdev/warp/issues/9677): same gap on Warp
+- [`markless`](https://github.com/jvanderberg/markless): terminal Markdown viewer with Typst math and kitty/sixel images
+- [`mdviewer`](https://github.com/aquele-dinho/mdviewer), [`glowm`](https://github.com/atani/glowm), [`mdterm`](https://www.toolhunter.cc/tools/mdterm): adjacent viewers
+
+## License
+
+MIT.

package/bin/claude-math.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+// claude-math — install/uninstall the plugin into Claude Code's local plugin dir.
+
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  renameSync,
+  rmSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PLUGIN_ROOT = resolve(__dirname, "..");
+const PLUGIN_NAME = "claude-math";
+const PLUGIN_ID = `${PLUGIN_NAME}@local`;
+
+const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+const PLUGINS_DIR = join(CLAUDE_DIR, "plugins");
+const LOCAL_DIR = join(PLUGINS_DIR, "local");
+const TARGET = join(LOCAL_DIR, PLUGIN_NAME);
+const SETTINGS = join(CLAUDE_DIR, "settings.json");
+const INSTALLED = join(PLUGINS_DIR, "installed_plugins.json");
+
+// Codex target: Codex reads skills from $CODEX_HOME/skills/<name>/SKILL.md.
+// The SKILL.md format (name + description frontmatter) is identical to Claude Code's,
+// so the same skill directory drops straight in.
+const SKILL_NAME = "math-unicode";
+const SKILL_SRC = join(PLUGIN_ROOT, "skills", SKILL_NAME);
+const CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
+const CODEX_SKILLS_DIR = join(CODEX_HOME, "skills");
+const CODEX_TARGET = join(CODEX_SKILLS_DIR, SKILL_NAME);
+
+const pkg = JSON.parse(readFileSync(join(PLUGIN_ROOT, "package.json"), "utf8"));
+
+const args = process.argv.slice(2);
+const flags = new Set(args.filter((a) => a.startsWith("-")));
+const cmd = args.find((a) => !a.startsWith("-"));
+const FORCE = flags.has("--force") || flags.has("-f");
+const FORCE_COPY = flags.has("--copy");
+const CODEX = flags.has("--codex");
+
+function log(msg) { console.log(`[claude-math] ${msg}`); }
+function die(msg) { console.error(`[claude-math] ${msg}`); process.exit(1); }
+
+function lstatSafe(p) { try { return lstatSync(p); } catch { return null; } }
+
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try { return JSON.parse(readFileSync(path, "utf8")); }
+  catch (e) { die(`could not parse ${path}: ${e.message}`); }
+}
+
+function writeJsonAtomic(path, obj) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(obj, null, 2) + "\n");
+  renameSync(tmp, path);
+}
+
+function backupOnce(path) {
+  const bak = `${path}.claude-math.bak`;
+  if (existsSync(path) && !existsSync(bak)) {
+    copyFileSync(path, bak);
+    log(`backed up ${path} → ${bak}`);
+  }
+}
+
+function isEphemeralPath(p) {
+  return /[\\/](?:_npx|_npm-cache)[\\/]/.test(p);
+}
+
+function looksLikeOurPlugin(path) {
+  return existsSync(join(path, ".claude-plugin", "plugin.json"))
+      && existsSync(join(path, "skills", "math-unicode", "SKILL.md"));
+}
+
+function chooseMode() {
+  if (FORCE_COPY) return "copy";
+  if (isEphemeralPath(PLUGIN_ROOT)) return "copy";
+  if (process.platform === "win32") return "junction";
+  return "symlink";
+}
+
+function clearTarget() {
+  const stat = lstatSafe(TARGET);
+  if (!stat) return;
+
+  if (stat.isSymbolicLink()) {
+    let current = "";
+    try { current = readlinkSync(TARGET); } catch {}
+    if (current === PLUGIN_ROOT || FORCE) {
+      unlinkSync(TARGET);
+      return;
+    }
+    die(`${TARGET} is a symlink to ${current}, not ${PLUGIN_ROOT}. Re-run with --force to overwrite.`);
+  }
+
+  if (stat.isDirectory()) {
+    if (!looksLikeOurPlugin(TARGET) && !FORCE) {
+      die(`${TARGET} is a directory but does not look like a claude-math install. Inspect manually, then re-run with --force.`);
+    }
+    rmSync(TARGET, { recursive: true, force: true });
+    return;
+  }
+
+  die(`${TARGET} exists and is neither symlink nor directory. Refusing to touch.`);
+}
+
+function placePlugin(mode) {
+  mkdirSync(LOCAL_DIR, { recursive: true });
+  if (mode === "copy") {
+    cpSync(PLUGIN_ROOT, TARGET, {
+      recursive: true,
+      filter: (src) => {
+        const rel = relative(PLUGIN_ROOT, src);
+        if (!rel) return true;
+        const top = rel.split(/[\\/]/, 1)[0];
+        return !["node_modules", ".git", "test", "tests"].includes(top);
+      },
+    });
+    log(`copied ${PLUGIN_ROOT} → ${TARGET}`);
+    return;
+  }
+  const linkType = mode === "junction" ? "junction" : "dir";
+  symlinkSync(PLUGIN_ROOT, TARGET, linkType);
+  log(`linked ${PLUGIN_ROOT} → ${TARGET} (${mode})`);
+}
+
+function registerInstalled() {
+  backupOnce(INSTALLED);
+  const data = readJson(INSTALLED, { version: 2, plugins: {} });
+  if (!data.plugins) data.plugins = {};
+  const now = new Date().toISOString();
+  const prev = data.plugins[PLUGIN_ID]?.[0];
+  data.plugins[PLUGIN_ID] = [{
+    scope: "user",
+    installPath: TARGET,
+    version: pkg.version,
+    installedAt: prev?.installedAt ?? now,
+    lastUpdated: now,
+  }];
+  writeJsonAtomic(INSTALLED, data);
+  log(`registered ${PLUGIN_ID}`);
+}
+
+function enableInSettings() {
+  backupOnce(SETTINGS);
+  const data = readJson(SETTINGS, {});
+  if (!data.enabledPlugins) data.enabledPlugins = {};
+  data.enabledPlugins[PLUGIN_ID] = true;
+  writeJsonAtomic(SETTINGS, data);
+  log(`enabled ${PLUGIN_ID}`);
+}
+
+function removeTarget() {
+  const stat = lstatSafe(TARGET);
+  if (!stat) return;
+  if (stat.isSymbolicLink()) {
+    unlinkSync(TARGET);
+    log(`removed symlink ${TARGET}`);
+    return;
+  }
+  if (stat.isDirectory() && (looksLikeOurPlugin(TARGET) || FORCE)) {
+    rmSync(TARGET, { recursive: true, force: true });
+    log(`removed directory ${TARGET}`);
+    return;
+  }
+  log(`${TARGET} exists but is not our plugin — leaving alone (use --force to remove anyway)`);
+}
+
+function unregister() {
+  const installed = readJson(INSTALLED, null);
+  if (installed?.plugins?.[PLUGIN_ID]) {
+    delete installed.plugins[PLUGIN_ID];
+    writeJsonAtomic(INSTALLED, installed);
+    log(`unregistered ${PLUGIN_ID}`);
+  }
+  const settings = readJson(SETTINGS, null);
+  if (settings?.enabledPlugins?.[PLUGIN_ID] !== undefined) {
+    delete settings.enabledPlugins[PLUGIN_ID];
+    writeJsonAtomic(SETTINGS, settings);
+    log(`disabled ${PLUGIN_ID}`);
+  }
+}
+
+function installCodex() {
+  mkdirSync(CODEX_SKILLS_DIR, { recursive: true });
+  const stat = lstatSafe(CODEX_TARGET);
+  if (stat) {
+    const ours = existsSync(join(CODEX_TARGET, "SKILL.md"));
+    if (!ours && !FORCE) {
+      die(`${CODEX_TARGET} exists and is not a math-unicode skill. Inspect it, then re-run with --force.`);
+    }
+    rmSync(CODEX_TARGET, { recursive: true, force: true });
+  }
+  cpSync(SKILL_SRC, CODEX_TARGET, { recursive: true });
+  log(`installed skill → ${CODEX_TARGET}`);
+  log("Codex auto-detects new skills; restart Codex if it doesn't appear. Invoke with /skills or $math-unicode.");
+}
+
+function uninstallCodex() {
+  const stat = lstatSafe(CODEX_TARGET);
+  if (!stat) { log(`nothing to remove at ${CODEX_TARGET}`); return; }
+  if (existsSync(join(CODEX_TARGET, "SKILL.md")) || FORCE) {
+    rmSync(CODEX_TARGET, { recursive: true, force: true });
+    log(`removed skill ${CODEX_TARGET}`);
+    return;
+  }
+  log(`${CODEX_TARGET} exists but is not our skill — leaving alone (use --force to remove anyway)`);
+}
+
+function statusCodex() {
+  const present = existsSync(join(CODEX_TARGET, "SKILL.md"));
+  console.log(`codex skill: ${present ? "✓" : "✗"} ${CODEX_TARGET}`);
+  console.log(`codex home:  ${CODEX_HOME}`);
+}
+
+function install() {
+  if (CODEX) return installCodex();
+  const mode = chooseMode();
+  clearTarget();
+  placePlugin(mode);
+  registerInstalled();
+  enableInSettings();
+  log("done. Restart Claude Code to load the skill.");
+}
+
+function uninstall() {
+  if (CODEX) return uninstallCodex();
+  removeTarget();
+  unregister();
+  log("done. Restart Claude Code to drop the skill.");
+}
+
+function status() {
+  if (CODEX) return statusCodex();
+  const stat = lstatSafe(TARGET);
+  const kind = !stat ? "missing"
+    : stat.isSymbolicLink() ? "symlink"
+    : stat.isDirectory() ? "directory"
+    : "other";
+  const installed = !!readJson(INSTALLED, { plugins: {} }).plugins?.[PLUGIN_ID];
+  const enabled = readJson(SETTINGS, {}).enabledPlugins?.[PLUGIN_ID] === true;
+  const valid = stat ? looksLikeOurPlugin(TARGET) : false;
+  console.log(`target:    ${kind === "missing" ? "✗" : "✓"} ${TARGET} (${kind})`);
+  console.log(`valid:     ${valid ? "✓" : "✗"} plugin files present`);
+  console.log(`installed: ${installed ? "✓" : "✗"} ${INSTALLED}`);
+  console.log(`enabled:   ${enabled ? "✓" : "✗"} ${SETTINGS}`);
+  console.log(`mode:      ${chooseMode()} (would-be on next install)`);
+}
+
+function prepack() {
+  const pluginJsonPath = join(PLUGIN_ROOT, ".claude-plugin", "plugin.json");
+  const pj = JSON.parse(readFileSync(pluginJsonPath, "utf8"));
+  if (pj.version !== pkg.version) {
+    pj.version = pkg.version;
+    writeFileSync(pluginJsonPath, JSON.stringify(pj, null, 2) + "\n");
+    log(`synced plugin.json version → ${pkg.version}`);
+  } else {
+    log(`plugin.json already at ${pkg.version}`);
+  }
+}
+
+function help() {
+  console.log(`claude-math v${pkg.version}
+
+Usage:
+  claude-math install [--force] [--copy] [--codex]
+      Symlink (or copy) the plugin into ~/.claude/plugins/local/ and enable it.
+      Auto-copies if invoked via npx; auto-junctions on Windows.
+        --force   Overwrite an existing install at the target path.
+        --copy    Force copy mode even on supported platforms.
+        --codex   Install the math-unicode skill for Codex CLI instead, into
+                  $CODEX_HOME/skills/math-unicode/ (default ~/.codex/skills/).
+
+  claude-math uninstall [--force] [--codex]
+      Remove the plugin and disable it. --force lets it remove a directory
+      that does not look like a claude-math install. --codex removes the
+      Codex skill instead.
+
+  claude-math status [--codex]
+      Show install state, target kind, and which mode would be used.
+      --codex shows the Codex skill install state instead.
+
+  claude-math prepack
+      Sync .claude-plugin/plugin.json version from package.json. Runs as an
+      npm \`prepack\` hook; safe to run manually.
+
+  claude-math --version
+  claude-math --help
+
+Env:
+  CLAUDE_CONFIG_DIR   Override the Claude config directory (default ~/.claude).
+`);
+}
+
+switch (cmd) {
+  case "install": install(); break;
+  case "uninstall":
+  case "remove": uninstall(); break;
+  case "status": status(); break;
+  case "prepack": prepack(); break;
+  case undefined:
+    if (flags.has("--version") || flags.has("-v")) { console.log(pkg.version); break; }
+    help(); break;
+  default: die(`unknown command: ${cmd}. Run 'claude-math --help'.`);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "claude-math",
+  "version": "0.1.0",
+  "description": "Render math legibly in Claude Code. Emits Unicode glyphs instead of unrenderable LaTeX in the terminal. (Graphical sixel/kitty rendering is on the roadmap.)",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "claude-code-plugin",
+    "skill",
+    "math",
+    "latex",
+    "katex",
+    "unicode",
+    "terminal"
+  ],
+  "homepage": "https://github.com/vladimirrott/claude-math",
+  "bugs": {
+    "url": "https://github.com/vladimirrott/claude-math/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vladimirrott/claude-math.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Vladimir Rotariu",
+    "email": "vladimirrott@users.noreply.github.com"
+  },
+  "type": "module",
+  "bin": {
+    "claude-math": "bin/claude-math.js"
+  },
+  "files": [
+    ".claude-plugin/",
+    "skills/",
+    "bin/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "prepack": "node bin/claude-math.js prepack",
+    "prepublishOnly": "npm test && npm pack --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skills/math-unicode/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: math-unicode
+description: Use whenever you need to express mathematical notation — equations, filters, set-builder, statistics, calculus, logic, ratios, drops, counts. Emit Unicode math glyphs INLINE; never wrap in `$…$`, `\(...\)`, or `$$...$$`. Claude Code terminal does not render LaTeX, so raw delimiters appear as noise. This skill activates automatically when math is involved.
+---
+
+# math-unicode
+
+When emitting mathematical notation in Claude Code, **always use Unicode glyphs inline** — never wrap math in `$…$`, `\(...\)`, or `$$...$$`. Claude Code's terminal does not render LaTeX; raw delimiters appear as plain dollar signs and reduce readability.
+
+## When this skill applies
+
+Triggers (use Unicode math):
+- Equations, formulas, derivations
+- Filter conditions, set-builder notation
+- Statistics: probabilities, expectations, distributions
+- Calculus, linear algebra, logic
+- Counts, ratios, fractions, drops where precision matters
+
+Skip (do not transform):
+- The user explicitly asks for LaTeX or a `.tex` file
+- Math inside fenced code blocks (preserve source syntax)
+- Strings being passed to a system that consumes LaTeX (KaTeX MCP, etc.)
+
+## Glyph cheatsheet
+
+### Greek
+
+```
+lowercase   α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω
+uppercase   Α Β Γ Δ Ε Ζ Η Θ Ι Κ Λ Μ Ν Ξ Ο Π Ρ Σ Τ Υ Φ Χ Ψ Ω
+variants    ϵ ϑ ϕ ϖ ϱ ς
+```
+
+### Operators
+
+```
+arithmetic     + − × ÷ ± ∓ · ∗ ⋅ ∘ ⊕ ⊖ ⊗ ⊘ ⊙
+big            ∑ ∏ ∐ ∫ ∮ ∬ ∭ ⨁ ⨂ ⨅ ⨆
+roots          √ ∛ ∜
+calculus       ∂ ∇ Δ ∆ ⅆ ⅇ
+constants      ∞ ∅ ℵ ℶ
+```
+
+### Relations
+
+```
+equality       =  ≠  ≈  ≅  ≡  ≜  ≝  ≐  ∝  ∼  ≃  ≢
+order          <  >  ≤  ≥  ≪  ≫  ⋘  ⋙  ⊴  ⊵
+set            ∈ ∉ ∋ ∌  ⊂ ⊃ ⊆ ⊇ ⊊ ⊋  ⊏ ⊐ ⊑ ⊒
+set ops        ∪ ∩ ⊎ ⊔ ⊓ ∖
+```
+
+### Logic & arrows
+
+```
+logic          ∧ ∨ ¬ ⊕ ⊻ ⊼ ⊽   ⊢ ⊨ ⊥ ⊤
+quantifiers    ∀ ∃ ∄ ∴ ∵
+arrows         → ← ↔ ⇒ ⇐ ⇔ ↦ ↪ ↩ ↑ ↓ ⇑ ⇓ ⟶ ⟵ ⟷ ⟹ ⟸ ⟺ ⊸
+```
+
+### Number sets & brackets
+
+```
+sets           ℕ ℤ ℚ ℝ ℂ ℙ ℍ 𝔽
+brackets       ⟨ ⟩  ⌈ ⌉  ⌊ ⌋  ‖ ‖  〈 〉
+```
+
+### Sub/superscript glyph blocks
+
+```
+superscript    ⁰ ¹ ² ³ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹  ⁺ ⁻ ⁼ ⁽ ⁾  ⁱ ⁿ ᵃ ᵇ ᶜ ᵈ ᵉ ᶠ ᵍ ʰ ʲ ᵏ ˡ ᵐ ᵒ ᵖ ʳ ˢ ᵗ ᵘ ᵛ ʷ ˣ ʸ ᶻ
+subscript      ₀ ₁ ₂ ₃ ₄ ₅ ₆ ₇ ₈ ₉  ₊ ₋ ₌ ₍ ₎  ₐ ₑ ₕ ᵢ ⱼ ₖ ₗ ₘ ₙ ₒ ₚ ᵣ ₛ ₜ ᵤ ᵥ ₓ
+```
+
+### Common LaTeX → Unicode
+
+| LaTeX | Unicode | LaTeX | Unicode | LaTeX | Unicode |
+|---|---|---|---|---|---|
+| `\alpha` | α | `\sum` | ∑ | `\in` | ∈ |
+| `\beta` | β | `\prod` | ∏ | `\notin` | ∉ |
+| `\gamma` | γ | `\int` | ∫ | `\subset` | ⊂ |
+| `\delta` | δ | `\partial` | ∂ | `\subseteq` | ⊆ |
+| `\epsilon` | ε | `\nabla` | ∇ | `\cup` | ∪ |
+| `\theta` | θ | `\infty` | ∞ | `\cap` | ∩ |
+| `\lambda` | λ | `\emptyset` | ∅ | `\setminus` | ∖ |
+| `\mu` | μ | `\leq` | ≤ | `\wedge` | ∧ |
+| `\pi` | π | `\geq` | ≥ | `\vee` | ∨ |
+| `\sigma` | σ | `\neq` | ≠ | `\neg` | ¬ |
+| `\phi` | φ | `\approx` | ≈ | `\Rightarrow` | ⇒ |
+| `\omega` | ω | `\equiv` | ≡ | `\Leftrightarrow` | ⇔ |
+| `\sqrt` | √ | `\propto` | ∝ | `\forall` | ∀ |
+| `\pm` | ± | `\cdot` | · | `\exists` | ∃ |
+| `\times` | × | `\to` | → | `\mathbb{R}` | ℝ |
+
+## Style rules
+
+### Rule 1 — Inline math: Unicode, no delimiters
+
+Bad:  `The filter $f(T; m) = \{(s,r) : n_{s,r} \geq m\}$ produces the cohort.`
+Good: `The filter f(T; m) = { (s,r) : n_{s,r} ≥ m } produces the cohort.`
+
+### Rule 2 — Block math: own line(s), still no delimiters
+
+Bad:
+
+    $$|Q| / |T| = 5238 / 31075 \approx 16.9\%$$
+
+Good:
+
+    |Q| / |T|  =  5 238 / 31 075  ≈  16.9 %
+
+### Rule 3 — Subscripts
+
+- Single Unicode-renderable index: prefer the glyph (x₁, x₂, xᵢ, xⱼ)
+- Multi-character or non-mappable subscript: keep `_{...}` syntax for clarity
+  - `n_{s,r}` ← (s,r) has no Unicode subscript form
+  - `x_max`, `σ_obs` ← multi-letter
+- Never mix: don't write `x_₁` or `x_{1}` when `x₁` works.
+
+### Rule 4 — Superscripts (powers)
+
+- Integer powers, simple: x², x³, xⁿ, e^x → eˣ
+- Multi-character / non-mappable: `x^{T}`, `x^{(i)}`, `A^{-1}` (or A⁻¹ if the exponent is simple)
+
+### Rule 5 — Big operators with indices
+
+Use Unicode operator + ASCII bounds:
+
+```
+∑_{i=1}^{n} aᵢ
+∏_{k ∈ K} pₖ
+∫_a^b f(x) dx
+```
+
+### Rule 6 — Fractions
+
+- Inline: `a/b`, `(a + b) / (c + d)`
+- Block (only when it aids clarity):
+
+```
+       a + b
+   ─────────────
+     c² + d²
+```
+
+### Rule 7 — Matrices / vectors
+
+ASCII art with corner glyphs:
+
+```
+A  =  ⎡ a  b ⎤        v  =  ( v₁ , v₂ , v₃ )ᵀ
+      ⎣ c  d ⎦
+```
+
+### Rule 8 — Sets and conditions
+
+Prefer set-builder with `|` or `:`:
+
+```
+Q  =  { (s,r) ∈ T  :  n_{s,r} ≥ 18  ∧  p⁰_{s,r} < 0.9 }
+```
+
+### Rule 9 — Numbers
+
+- Thousands: thin space (` `) — `5 238`, `34 601` — not commas (locale ambiguous).
+- Decimal: dot — `16.9 %`.
+- Percent: space before `%` — `16.9 %` (typographic convention; readable).
+- Approximations: ≈, ∼. Order of magnitude: ~. Confidence: `x = 5.2 ± 0.3`.
+
+### Rule 10 — When Unicode hurts, fall back explicitly
+
+If a glyph chain becomes denser than the LaTeX it replaces, switch to readable ASCII pseudo-LaTeX and annotate it. Example:
+
+```
+H(p) = − Σ_{x ∈ X} p(x) · log p(x)        (Σ = sum over the support X)
+```
+
+The reader's comprehension is the only metric. Choose whichever form is clearest, then stay consistent within a passage.
+
+### Rule 11 — Plain letters for variables; never style with math-alphanumeric codepoints
+
+Write variable names and identifiers with ordinary letters (x, A, Var, RSS). Do **not** reach into the Unicode *Mathematical Alphanumeric Symbols* block (𝐀 bold, 𝐴 italic, 𝓐 script, 𝔸 styled double-struck) to *style* ordinary letters. Those codepoints garble on copy/paste, terminal search, and screen readers — the same failure Claude Code hit in issue #61558.
+
+Exception: the standard, semantically meaningful blackboard-bold sets and operators are correct notation, not styling — keep using ℕ ℤ ℚ ℝ ℂ ℙ 𝔽 (number sets) and 𝔼 (expectation). Use those; don't hand-style anything else.
+
+## Quick reference — common forms
+
+```
+Mean / std        μ ± σ                        x̄ ± s
+Probability       P(A | B)                     ℙ(A ∩ B) = ℙ(A) · ℙ(B | A)
+Expectation       𝔼[X] = ∫ x · f(x) dx
+Variance          Var(X) = 𝔼[X²] − 𝔼[X]²
+Gradient          ∇f = ( ∂f/∂x₁ , ... , ∂f/∂xₙ )
+Norm              ‖x‖₂ = √(Σᵢ xᵢ²)
+Big-O             T(n) = O(n log n)
+Limit             lim_{n → ∞} aₙ = L
+Sum bounds        ∑_{i=1}^{n} i  =  n(n+1)/2
+Quantile          q_α = inf{ x : F(x) ≥ α }
+```
+
+## Anti-patterns — never emit these in Claude Code terminal
+
+```
+✗   $f(x) = \sum_{i=1}^{n} x_i$
+✗   \( a^2 + b^2 = c^2 \)
+✗   $$\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}$$
+✗   \[ |Q|/|T| \approx 16.9\% \]
+✗   Let 𝑉𝑎𝑟 = …   or   matrix 𝐀 = …   (math-alphanumeric styling; garbles on copy/search — write Var, A)
+```
+
+If asked to produce raw LaTeX (e.g. for a `.tex` file or a KaTeX-rendering tool downstream), do so — and call it out explicitly: *"Raw LaTeX as requested; this will not render in the terminal."*