jolars

Incrementally make Panache's CST shape for HTML-block /

Grow Panache's CommonMark spec conformance under `Flavor::CommonMark` by running every `spec.txt` example through the shared parser, comparing rendered HTML against the spec's expected HTML (byte-equality after `<li>` whitespace normalization), and triaging failures into renderer / parser-shape / flavor-leak / dialect-divergence / missing-feature buckets. Use when asked to advance the CommonMark pass rate, grow the allowlist, or unblock a CommonMark regression.

Incrementally migrate Panache's Pandoc-dialect inline parsing onto the unified inline IR (currently CommonMark-only) one bounded sub-task at a time, verifying every CST divergence against pandoc-native before fixing or deferring.

Add a new built-in lint rule to the Panache linter — wire it into the registry, gate it on the right extension/flavor, add a regression fixture with focused assertions, and document it.

Incrementally build Panache's math parser and formatter — a lossless structural TeX CST for inline/display math, then content-aware reformatting behind an experimental gate — one bounded phase at a time.

Triage and fix panache smoke-test regressions (idempotency, losslessness, parse/format checks) from CI debug-format reports and linked issues.

Profile-driven performance work on the panache parser or formatter. Measure first with perf + the right harness; classify hotspots into one of a small set of buckets; apply the matching cheap fix; verify median wall-time moved before committing.

Use when the user wants to (re)run the formatter/linter speed benchmark or refresh the docs benchmark page — "run the benchmark", "task bench", "update the benchmark numbers", "refresh benchmarks". Regenerates the committed JSON artifact that feeds docs/src/reference/benchmarks.md, then fact-checks that page against the code.

Profile-driven performance work on the badness parser, formatter, or linter. Measure first with the in-process micro-bench + perf/flamegraph on a real document; classify hotspots into a small set of buckets; apply the matching cheap fix; verify the median wall-time moved AND the invariants still hold before committing. Use for "speed up formatting/parsing/linting", "close the gap with tex-fmt on <doc>", "profile the formatter/parser/linter", "why is masters_dissertation slow".

Add a new built-in lint rule to the Badness LaTeX linter — implement the Rule trait (id/severity/description/examples + check), register it in the three lockstep lists, add unit + integration tests with a losslessness-safe fix, and regenerate the living-docs rules reference. Use when asked to add a lint (warning/error/info), with or without an auto-fix.

Use when the user wants to check or analyze badness's LaTeX parse concordance against texlab — "run parse-compat", "parse concordance vs texlab", "analyze parse-compat divergences", or after a parser/CST change that might shift the differential gauge. Runs the soft gauge and triages any unexplained divergence.

Use when the user wants to check or analyze badness's BibTeX parse concordance against texlab — "run bib-parse-compat", "bib parse concordance vs texlab", "analyze bib divergences", or after a `.bib` parser/CST change. Runs the soft gauge and triages any unexplained divergence.

Add a new built-in lint rule to the fatou linter—implement it against the single-walk dispatch, register it in the one source of truth, add TDD behavior tests (plus autofix coverage when the rule ships a fix), and wire up the snapshot-pinned generated docs and the hand-maintained SUMMARY.md index.

Grow Fatou's Julia parser toward JuliaSyntax.jl using the differential oracle. The projector at src/parser/sexpr.rs walks the CST and emits JuliaSyntax's s-expression shape; the harness in tests/juliasyntax_oracle.rs diffs each fixture against pinned expected.sexpr. Use this skill to pick the next gap from the corpus, add the grammar plus projector support, lock it with a fixture, and ratchet the now-passing cases into the allowlists. The projector is a test-only diagnostic: a divergence means the CST (or the projector's encoding translation) is wrong, never patch it in the projector to make the test pass.

Grow Fatou's own Julia formatter, one construct at a time, against hand-authored fixtures. rules::lower (src/formatter/rules.rs) lowers the CST into the layout IR (ir.rs) printed by printer.rs; the gate in tests/formatter.rs diffs each fixture's format(input.jl) against a hand-written expected.jl. There is no external reference formatter: you propose a formatting, the user edits expected.jl to the desired form, you push back if it breaks a tenet or conflicts with an existing rule, then you implement the rule. Parser/lexer blockers stop and hand off to parser-parity.

Add a new built-in lint rule to the arity linter—implement it against the single-walk dispatch, register it in the one source of truth, add TDD fixtures plus the autofix-correctness (parse-clean) case, and wire up the snapshot-pinned generated docs and the two hand-maintained book indexes.

Grow arity's roxygen2 + markdown CST toward roxygen2 itself using a strict differential oracle (parser work, not formatting). roxygen2 renders #' blocks to .Rd. Use this skill to pick the next gap from the corpus, add the grammar plus projector support, lock it with a fixture + pinned tree, and ratchet the now-passing case into the allowlist. The projector at src/roxygen/project_rd.rs walks arity's CST and emits the parser-owned Rd section subtrees; the pure-Rust gate in tests/roxygen_projector.rs diffs that against a pinned <stem>.rdtree (no R, plain cargo test), allowlist-gated. The projector is a test-only faithful diagnostic: a divergence means the CST (or the encoding translation) is wrong—never patch the projector to make a case pass; fix the parser.

Ingest a research paper PDF into references/<name>/ for use as source material when implementing a basin solver. Runs a fast pymupdf4llm pass first, then optionally a slow marker pass on pages where math and figure fidelity matters. Use when the user provides a paper to translate into a solver implementation.