foxy-skills

Complete reference for the Graphviz DOT language — grammar, statements, identifiers, graph/node/edge/subgraph attributes, colors, ports, engines, and lexical edge cases — as accepted by the pure-Hoon %graph-viz renderer.

API reference for the %graph-viz Gall agent — the stateless subscribe-then-poke protocol, %gviz-command/%gviz-result marks, $command/$render-opts/$result/$err/$diag types, the run:lib gate, and the positioned-graph noun.

Practical recipes and best practices for %graph-viz — rendering from Hoon, building graphs programmatically, worked diagram templates (org charts, dependency/architecture/state/data-flow/UML), styling and accessibility guidance, performance limits, pitfalls, integration (clay/caching), and debugging with verbose diagnostics.

High-level orientation to the tlaplus/tlaplus repository (TLA+ CLI tools + Eclipse Toolbox IDE), its tool entrypoints, and which sibling skill to use for a given task. Use when first interacting with the TLA+ toolchain repo, deciding between CLI/editor/build paths, or routing to the right tlaplus-* skill. Points to the shared external-link inventory and source-map for the whole pack.

Build, package, test, and develop the TLA+ tools and Toolbox locally or in CI - Ant targets for tla2tools.jar, Maven/Tycho for the Toolbox, the test-set/test targets, the devcontainer, and the GitHub CI matrix. Use to compile the jar, run the test suite or a single test, set up a dev environment, or understand the CI pipeline. Owns every ant/mvn command line for the pack.

Follow the tlaplus/tlaplus contribution conventions - engage maintainers early, make surgical diffs, write tests first, split PRs, use commit categorization tags and DCO sign-off. Use before any edit or PR, when authoring tests/docs, or crafting commit messages for this repo. For the mechanics of building/running tests see tlaplus-build-workflow.

Diagnose and recover from TLA+ failures - parse/level errors, config (.cfg) errors, TLC runtime errors, safety (invariant) and liveness violations, deadlock, and out-of-memory; analyze counterexample traces. Use for any SANY/TLC failure, opaque error, or trace/counterexample work. Owns the TLC/SANY error-code taxonomy for the pack.

Configure and run the TLC model checker (exhaustive or simulation), write .cfg model files, and interpret run statistics and outcomes. Use for any model-checking task - running a spec, adding a regression model, choosing INVARIANT vs PROPERTY, reading state counts/diameter, or exporting traces as JSON/DOT. For diagnosing failures see tlaplus-debugging.

The TLA+ parser front-end - the JavaCC grammar (tla+.jj), the generated + hand-written parser, XML AST export (XMLExporter + sany.xsd), and the syntax-conformance corpus tests. Use when regenerating/modifying the parser, extending syntax, consuming the AST via XML, fixing parser bugs, or maintaining sany.xsd and corpus tests. For the broader SANY/TLC internals see tlaplus-tools-internals.

Work with large-scale / real-world TLA+ models and TLC performance measurement - the general/performance case studies (Paxos, Bookkeeper, SwarmKit, ...), the measure.tla/measure.sh harness, the perf.yml regression job, the JMH benchmark target, and state-explosion tuning. Use when scaling TLC, studying perf case studies, or running performance measurements. For routine checking see tlaplus-model-checking.

Write and debug PlusCal algorithms and run the pcal.trans translator that compiles them into TLA+ inside the same .tla file. Use when authoring/translating PlusCal, choosing fairness options, understanding the parse/label/translate pipeline, or maintaining the translator. For checking the generated TLA+ see tlaplus-model-checking.

Understand and extend the TLA+ StandardModules and the Java override mechanism by which TLC replaces their TLA+ definitions with native methods. Use when adding/modifying a StandardModule, writing a TLC-specific operator override, or understanding operators like d:>e, @@, Permutations, SortSeq, RandomElement. For consuming these operators in specs see tlaplus-syntax; for broader engine internals see tlaplus-tools-internals.

Read, write, and validate TLA+ modules and standard usage patterns - modules/EXTENDS/INSTANCE, operators, actions with primed variables, invariants vs temporal properties, and level checking. Use when inspecting or editing any .tla file, authoring specs/extensions, or predicting whether SANY will accept a module. Owns the canonical module-example reference for the pack.

The Eclipse-RCP-based TLA+ Toolbox IDE - its ~30 OSGi plugins/features, the product definition, the Tycho/Maven build, update sites, Oomph dev setup, and its unmaintained status and JDK limitations. Use when working on or understanding the IDE surface, packaging Toolbox distributables, plugin development, or reproducing Toolbox-specific build/CI issues. For the tools jar build see tlaplus-build-workflow.

Understand and modify the core Java implementation of the TLA+ toolchain - the SANY parser/semantic/level-checking/AST pipeline, the TLC engine architecture (tool/value/util/module/output), the Java<->TLA+ override mechanism, and the PlusCal translator. Use when changing tool behavior at the implementation level, adding/debugging language features in the tools, or tracing how a spec is processed internally. For grammar/XML front-end detail see tlaplus-parser-xml-tooling.

Complete workflow for developing, testing, and distributing Urbit applications including Gall agent development, React front-ends, desk packaging, local development with fake ships, testing, and peer-to-peer distribution. Use when developing Urbit apps, setting up development environments, testing agents, or publishing desks.

Quick reference for Hoon syntax fundamentals including rune forms, data types, gates, and common idioms. Use when needing fast syntax lookups, verifying rune usage, or resolving common gotchas for developers with working Hoon knowledge.

Master Hoon's built-in data structures including lists, sets, maps, mops (ordered maps), jars, jugs, and trees with their operations and performance characteristics. Use when choosing data structures, optimizing algorithms, building complex applications, or understanding standard library collections.

Hoon error diagnosis expert for systematic debugging, error interpretation, and root cause analysis. Use when encountering compilation errors, runtime failures, type mismatches, or cryptic Hoon error messages.

Expert Hoon development assistant for implementing complex features, debugging issues, and writing production-ready Hoon code. Use when needing help with Hoon implementation, type errors, performance optimization, or understanding idiomatic patterns.

Safe state migration workflow for Gall agents covering versioning, backwards compatibility, and zero-downtime upgrades

Comprehensive style guide for writing clean, idiomatic, and maintainable Hoon code following community conventions including naming, formatting, documentation, and idiomatic patterns. Use when writing new code, reviewing code, establishing team standards, or ensuring code quality.

Comprehensive testing workflow for Hoon code covering unit tests, integration tests, property-based tests, and test-driven development

Master Hoon's powerful structural type system including auras, molds, validation, type inference, generics, and variance. Use when designing types, debugging type errors, building robust type-safe code, or working with nest-fail issues and type casting.