rusty-biscuit

Expert knowledge for the darkmatter Rust library - Markdown parsing, composition, frontmatter, terminal/HTML/Markdown rendering, style frontmatter, syntax highlighting, document comparison, and disclosure blocks. Use when parsing or composing Markdown, rendering Markdown to terminal/HTML/Markdown, working with DarkmatterPage, `style:` frontmatter, frontmatter hashing, disclosure blocks (`::disclosure` / `::details` / `::end-disclosure`), or comparing documents.

Use when working in the claudine/ package area or with the Claudine library/CLI — normalizing agentic-CLI lifecycle events and hooks, wrapping providers (Claude Code, Codex, Gemini, Goose, Kimi, OpenCode, Qwen, Kilo, Pi, Antigravity), composing Markdown prompts (compose/inline-compose/sequence), managing the MCP catalog, linking skills/commands/agents across providers, or researching agentic CLI platform behavior.

Expert knowledge for the unchained-ai LLM pipeline library including pipeline primitives, provider registry, model catalogs, rig-core integration, code generation, and agent status monitoring. Use when working in unchained-ai/, building LLM pipelines, adding providers/models, implementing pipeline steps, running the model generator, or querying agentic platform limits.

Expert knowledge for the Agent Client Protocol (ACP) and its underlying JSON-RPC standard, with Rust and TypeScript libraries. Use when implementing or integrating ACP, building an ACP client or agent, or devising strategies for interacting with agentic CLI providers (Claude Code, Codex, Kimi Code, OpenCode, Gemini CLI) over ACP.

Configuring models in agentic CLIs — adding local or cloud models to Claude Code, Codex, Gemini CLI, Goose, Kimi Code, OpenCode, Qwen Code, Pi, or Kilo Code. Use when wiring a local runner (Ollama, LM Studio, oMLX, llama.cpp, vLLM) into an agentic CLI, redirecting a provider's base URL (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, model_providers, provider.<id>.options.baseURL), choosing between OpenAI-compatible and Anthropic-compatible endpoints, bridging a CLI to a different cloud vendor's models, or working with per-provider model config file shapes and merge semantics.

Detecting, configuring, and wiring local model runners into agentic CLIs. Use when working with Ollama, LM Studio, oMLX, llama.cpp (llama-server), or vLLM; probing which local runners are installed or running; hitting OpenAI-compatible local endpoints (/v1) or Anthropic-compatible /v1/messages; serving local models; or connecting a local model to OpenCode or Claude Code via base URL, ANTHROPIC_BASE_URL/ANTHROPIC_AUTH_TOKEN, or runner-native launch hooks.

Expert knowledge for the biscuit-terminal Rust library - terminal capability detection, rich terminal rendering, terminal components, inline image rendering, Mermaid/graph adapters, `TerminalRenderable`, `Prose`, and the terminal renderer for the renderable tree. Use when building CLI terminal output, using terminal-aware components, rendering images or diagrams, detecting color/underline/italics support, or folding `renderable::tree` nodes to terminal text.

Expert knowledge for the renderable library, which provides traits and utilities for multi-target rendering (Terminal, Markdown, Browser) from a shared render-tree IR in the rusty-biscuit monorepo. Use when working in the renderable package area, implementing multi-target rendering for a type, adding or targeting a render target (Terminal/Markdown/Browser), working with the render tree (TreeRenderable, RenderNode, Document), or adding the renderable dependency.

Expert knowledge for sniff-lib and sniff-cli, a cross-platform system detection library and CLI for Rust. Use when detecting OS/hardware/network/filesystem info, program detection, service detection, adding new detection capabilities, or optimizing detection performance.

Expert knowledge for the biscuit-tui package area in the rusty-biscuit monorepo. Provides reusable TUI input components (biscuit-tui library) and a CLI (question) for shell-scriptable prompts. Use when building or modifying ratatui-based input widgets, adding new components to the biscuit-tui library, working with the question CLI, or implementing standalone/embedded terminal prompts.

Shared real-terminal test harness crate (L2/L3): backend selection (tmux/WezTerm/Kitty/Apple Terminal/cliclick), `SpawnVisibility`, `SharedHarness`, `available()` gating, and the "which terminal am I running inside" gotcha. Load when picking a backend or using the harness API; for *assertion patterns* against captured frames, load the `rust-testing` skill instead.

Monorepo testing guide: L1/L2/L3 taxonomy, canonical just recipes, `require_level!` gating, nextest filtersets, and fuzzing. Load this before writing or reviewing tests in the rusty-biscuit workspace.

Expert knowledge for designing and building high-quality Rust CLI applications. Use when creating CLI tools, parsing arguments, structuring output formats, implementing shell completions, handling signals, or following CLI best practices. Covers clap, output formatting, testing strategies, and UNIX conventions.

Expert knowledge for the biscuit-visualized Rust library - the authority for diagram and graph visualization rendering in the rusty-biscuit monorepo. Provides Mermaid diagram rendering (flowcharts, sequence, pie, quadrant, gantt, ER, and more), graph/network diagram rendering (expression syntax and DOT format), SVG-to-PNG rasterization via resvg, content-addressed file caching, and dark/light theming. Use when rendering diagrams or graphs to SVG/PNG, working with Mermaid syntax, parsing graph expressions or DOT, building graphs programmatically, configuring visualization themes, or debugging cache behavior. biscuit-terminal depends on this for all diagram artifact generation.

Details on the `worktree` package area of the **rusty-biscuit** repo

Expert knowledge for the biscuit-contract Rust library - the shared, provider-neutral contract for one text-inference operation. Use when working in the biscuit-contract package area, depending on or implementing the InferenceAdapter trait, building a provider (Claudine, Unchained AI) or consumer (Reaper, Darkmatter) adapter, or adding the biscuit-contract dependency.

Expert knowledge for building and designing terminal user interfaces (TUIs) covering design systems (layout paradigms, color palettes, keyboard navigation, data visualization), framework-agnostic best practices, real-world app pattern analysis, Ratatui (Rust) with immediate-mode rendering and constraint-based layouts, and Bubble Tea (Go) with Elm architecture and Charm.sh ecosystem

details on the Reaper library and CLI

Expert knowledge for the biscuit-icon Rust library and `icon` CLI — curated offline domain icons plus on-demand Iconify (https://iconify.design/) lookup, cached in a local SQLite database. Use when working in the `biscuit-icon/` package area, using `biscuit_icon::Icon` or any of the domain enums (`Os`, `Emoji`, `File`, `Brand`, ...), assembling styled `<svg>` from an `IconBody`, calling `Icon::iconify` for network/cache lookup, rendering icons through the `renderable` tree (terminal ladder, browser inline SVG, markdown), or using the `icon` CLI for listing sets/icons and dynamic shell completions.

Use when deploying a Rust project to package managers (cargo, brew, apt, nixos, uv, npm), speeding up Rust builds with compilation caching (kache, RUSTC_WRAPPER, local/remote S3 caches, CI build cache), or interacting with Git from Rust (git2/libgit2 bindings, gitoxide/gix pure-Rust). Covers release distribution, build-time tooling, and programmatic Git access for Rust projects.

Expert knowledge for multi-language symbol extraction using Tree-sitter. Use when working with tree-hugger-lib or tree-hugger-cli (hug), extracting symbols/imports/exports, implementing lint diagnostics, adding new language support, writing tree-sitter queries, or troubleshooting the underlying tree-sitter runtime (grammar versions, ABI mismatches, query debugging).

Expert knowledge for Rust systems programming — ownership, borrowing, type safety, error handling, async patterns, performance optimization, and 2024-edition improvements. Use when writing or reviewing idiomatic Rust, resolving borrow-checker or lifetime issues, structuring error handling, or optimizing performance.

Reference for `just`, the command runner. Use when working in a project with a `justfile` or when the user mentions `just` or `justfile`.

Expert knowledge for the biscuit-file Rust library and CLI (`bf`) providing format conversion (TOML/YAML/JSON/JSON5), PDF extraction, file type detection, and file reference resolution. Use when working in the `biscuit-file/` package area, using biscuit-file types (Toml, Yaml, Json5, Pdf, FileReference, PathPosition, FileType, DataFormat, FileReferenceError), adding the biscuit-file dependency, implementing file resolution, resolving file references, converting between data formats, extracting PDF content, reading markdown frontmatter, or detecting file types.

Expert knowledge for agentic-CLI observability — leading open-source and commercial offerings and how they integrate with Claudine. Use when evaluating agent observability tooling, instrumenting agentic CLIs, or integrating observability with Claudine as an agent wrapper or as a client in an ACP-based interaction.

Expert knowledge for the Rust async-trait crate — the

Expert knowledge for programmatic audio across macOS, Linux, Windows, iOS, and Android, with Rust and TypeScript examples. Use when choosing platform audio backends, implementing playback or capture, or troubleshooting cross-platform audio behavior.

Expert knowledge for the biscuit-clipboard Rust library and CLI for cross-platform clipboard access. Use when working in the biscuit-clipboard package area, reading or writing the system clipboard, adding the biscuit-clipboard dependency, or using its CLI.

Expert knowledge for the crossterm crate — cross-platform terminal manipulation (cursor control, styling, event handling, mouse support) on Windows and UNIX. Use when building TUIs or CLI apps that need raw mode, styled output, key/mouse events, or alternate-screen handling.

Expert knowledge for Hugging Face REST APIs — the Hub API (model search and downloads), the Inference API (serverless model execution), and programmatic access from Python/Rust. Use when searching or downloading models, calling hosted inference, or integrating Hugging Face into Rust or Python tooling.

Expert knowledge for the Rust indicatif crate — progress bars, spinners, multi-progress, download tracking, and async/Tokio integration. Use when adding progress indicators to a CLI, tracking long-running or concurrent tasks, or troubleshooting redraw and throughput issues.

Expert knowledge for building and managing monorepos across JavaScript, TypeScript, Rust, Go, and JVM — workspace standards (npm, pnpm, Yarn, Cargo, Go workspaces, Gradle, Maven), task-orchestration tools (Nx, Turborepo, Bazel, Pants, Rush, Lerna, moon), and versioning (Changesets). Use when structuring a monorepo, choosing task-orchestration tooling, or setting up workspace versioning and release flows.

Expert knowledge for Ollama — running LLMs locally, the native and OpenAI-compatible APIs, model storage, and custom models via Modelfiles. Use when running local models, calling the Ollama API, managing model storage, or authoring Modelfiles.

Expert knowledge for rendering static SVG to raster formats with the resvg Rust crate (a pure-Rust Linebender library offering cross-platform consistency and memory safety). Use when rasterizing SVGs, converting SVG to PNG, generating icons or thumbnails, or doing server-side SVG rendering.

Expert knowledge for building LLM-powered Rust applications with Rig — type-safe agents, tool calling, RAG patterns, vector-store integration, and a unified interface across 20+ providers (OpenAI, Anthropic, Cohere, Gemini). Use when implementing completions or embeddings, building agents or tools, integrating vector DBs, or switching model providers.

Expert knowledge for building Rust system-tray apps with tray-icon, winit, and egui — platform-specific setup, native menus, auto-launch, and GUI integration. Use when adding a tray or menu-bar icon, wiring tray menus, configuring auto-launch, or integrating a tray with a winit/egui app.

Expert knowledge for the Rust serial_test crate — isolating tests that share global state such as environment variables, files, and singletons. Use when parallel tests interfere via shared state, tests pass alone but fail together, or you need

Expert knowledge for syntax highlighting in Rust with syntect — Sublime Text syntax definitions and TextMate themes producing ANSI-terminal and HTML output, including TypeScript support and modern themes. Use when highlighting code for terminal or HTML output, loading custom syntaxes or themes, or troubleshooting highlighting performance.

Expert knowledge for Rust error handling with thiserror — derive macros for custom error types,

Expert knowledge for parsing and serializing TOML in Rust with the toml crate and serde, including defaults and helpful error messages. Use when reading or writing TOML config files, mapping TOML to serde structs, or producing user-friendly TOML parse errors.