← all plugins

1. ▌
   ntfy · jasoncarreira

   Send a phone-push notification to the operator via ntfy.sh. Use ONLY for genuine algedonic alarms — events the operator needs to know about within minutes, not hours. The push lands on their phone; the cost of misuse is operator desensitization (they mute the topic and the channel goes dark). Do not use for routine surfacing, status updates, or things that can wait for the next chat turn.
   6
   repo stars
2. ▌
   tmux · jasoncarreira bundle

   Remote-control tmux sessions for interactive CLIs by sending keystrokes and scraping pane output. Use when you need an interactive TTY (REPLs, agents that prompt) or want to run multiple long-lived processes in parallel and poll their state. For non-interactive long-running jobs prefer the long-running-jobs skill.
   6
   repo stars
3. ▌
   wiki · jasoncarreira

   Maintain a structured wiki under state/wiki/ — ingest raw sources from state/raw/, synthesize cross-linked pages, and lint for health. Use this skill whenever you need to build durable, graph-shaped knowledge with cross-references (entities with relationships, topics that recur, concepts you trace across many sources).
   6
   repo stars
4. ▌
   alert · jasoncarreira

   Use when a high-priority signal needs to reach the operator but doesn't fit the current conversation (off-hours wake, urgent error needing eyes, scheduled-tick discovery worth surfacing now). Routes via MIMIR_OPERATOR_ALERT_CHANNEL.
   6
   repo stars
5. ▌
   github · jasoncarreira

   Interact with GitHub via the `gh` CLI. Use for issues (read, comment, file), pull requests (view, comment, check CI status), workflow runs, and `gh api` for queries the subcommands don't cover. Authentication is via the bot's GITHUB_TOKEN (already wired through `gh auth setup-git` at container start).
   6
   repo stars
6. ▌
   memory · jasoncarreira bundle

   Criteria for deciding when, where and how to remember information. Use this skill whenever you might need to update a core memory block, file something under memory/, or write to a state file. It is CRITICAL that you use this skill.
   6
   repo stars
7. ▌
   review · jasoncarreira

   Review a pull request and POST the review to GitHub via `gh pr review`. Use when asked to review a PR, or when the github-activity poller fires a PR-opened / PR-review-requested event. Always submits after drafting — a review that stays in turn output and never reaches GitHub is a non-review.
   6
   repo stars
8. ▌
   pollers · jasoncarreira bundle

   Mechanics for building and managing pollers — subprocess scripts that check external services on a schedule and emit events when something has changed. Use when authoring a new poller (a `pollers.json` manifest plus a script in any language), debugging why a poller isn't firing, or extending an existing one. Pollers run on cron, emit JSONL events when there's something to report, and stay silent otherwise (silence-as-filter). The framework discovers `<home>/skills/<name>/pollers.json` files at startup and via `reload_pollers`; each emitted event becomes a fresh turn on a `poller:<name>` synthetic channel. Companion to the `world-scanning` skill, which catalogs *what's worth polling*. Distinct from `async-tasks` (one-shot wake-up via bash_async, not recurring) and from in-process scheduler callables (saga-consolidate, oauth-usage-poll — those mutate mimir-internal state and aren't subprocess-isolated).
   6
   repo stars
9. ▌
   weather · jasoncarreira bundle

   Get current conditions and 5-day forecast for a city via OpenWeatherMap. Requires `OPENWEATHER_API_KEY` in the environment. Use when the user asks about weather or when planning anything where weather is load-bearing (outdoor events, travel, watering schedules).
   6
   repo stars
10. ▌
    chainlink · jasoncarreira bundle

    Local CLI issue tracker for todos, follow-ups, structured records, and the canonical pattern for decomposing multi-step work into a parent + subissues with acceptance criteria, dependency edges, and priority. Use when the user mentions a task to remember, a bug to track, an open question, anything that needs to outlive the current turn, or when planning multi-heartbeat work that needs `chainlink issue ready`-driven pickup across sessions. Includes guidance on writing descriptions future-you can act on (handles, success path, failure path) and idempotency tactics for actions that might fire twice (boundary firing, overlapping heartbeats, retried subagent completion). Pairs with five-whys (chainlink is the storage backend for RCA trees). Storage is local — issues live under a `.chainlink/` directory in the operator's repo.
    6
    repo stars
11. ▌
    five-whys · jasoncarreira bundle

    Structured root cause analysis for arriving at a concrete action. Use when something went wrong, a pattern keeps recurring, behavior has drifted, or you catch yourself resolving to "do better" / "remember to X" without a concrete artifact. Five-whys forces behavioral resolutions into file edits, config changes, memory block updates, or scheduled jobs — the action item must produce a diff someone else can verify. Do not use for simple debugging with an obvious cause.
    6
    repo stars
12. ▌
    onboarding · jasoncarreira bundle

    Guide for the first days with a new human. Use when: the `init` memory block exists (pointing you here), you have no persona/communication blocks yet, or a human explicitly asks about setup. This skill is about having good conversations — not filling out forms.
    6
    repo stars
13. ▌
    try-harder · jasoncarreira

    The menu of non-grit moves available when you'd otherwise reach for "I'll do better next time." Use when you catch yourself resolving to "be more careful," "remember to X," or "try harder" — those resolutions die at the turn boundary. The right shape is always a structural change with a verifiable diff: edit a memory file, edit a skill that misled you, log a chainlink interest item, add a poller for the missed signal, file a five-whys. The artifact must outlive the turn.
    6
    repo stars
14. ▌
    async-tasks · jasoncarreira

    Turn "block until condition X is met" into an agent wake-up via the bash_async tool. Use when you need to wait for a one-shot event without burning context — a webhook arriving, a CI pipeline finishing, a file appearing, a long shell command completing — AND you want this conversation to resume with full context when the event fires. Distinct from pollers (recurring) and the synchronous Bash tool (blocks the turn). The completion event lands as a fresh turn on the spawning channel; no polling needed.
    6
    repo stars
15. ▌
    commitments · jasoncarreira

    How to read, resolve, and reason about commitments — durable records of future obligations (your own promises and the operator's requests). Use whenever the `## Upcoming commitments` prompt block surfaces something you might act on, or when you want to inspect what's pending beyond what the block shows.
    6
    repo stars
16. ▌
    find-skills · jasoncarreira

    Discover what bundled skills exist in this mimir install and what each one does. Use when you're not sure if a capability is already covered by a skill ("can I X?", "is there a skill for Y?", "what skills do I have?"). Reads SKILL.md frontmatter from each skill directory and surfaces names + descriptions.
    6
    repo stars
17. ▌
    predictions · jasoncarreira bundle

    Use when making a forward-looking claim with a checkable outcome (reply within 24h, error rate will drop, this skill will see more use) — record to state/predictions.jsonl with a review horizon so reflection can grade you later. Closes the in-the-moment double-loop.
    6
    repo stars
18. ▌
    introspection · jasoncarreira bundle

    Diagnose your own behavior by reading the structured logs you leave behind — turns.jsonl, events.jsonl, chat_history.jsonl, scheduler.yaml. Use when something has gone wrong (a message didn't land, a scheduled job isn't firing, a communication pattern feels off), when you need to understand a pattern over many turns, or when cost / token usage needs auditing. Covers jq query recipes and points at the debugging-jobs / debugging-communication / debugging-drift companion guides for specific failure modes.
    6
    repo stars
19. ▌
    skill-creator · jasoncarreira

    Create or update reusable skills for this agent. Use this skill ONLY when the user asks to create a new skill, edit an existing skill, improve a SKILL.md, or capture a repeated workflow as a reusable skill. Do not use this skill for one-off tasks.
    6
    repo stars
20. ▌
    tool-pin-drift · jasoncarreira bundle

    Check pinned external tool versions against npm and GitHub releases. Use for the weekly heartbeat tool-pin drift scan.
    6
    repo stars
21. ▌
    world-scanning · jasoncarreira

    A catalog of pollers worth building — the underused half of being a long-running agent. Use when something you care about could change without anyone telling you (a CI pipeline, a competitor's release, a friend's status, a config drift, a dependency CVE) and you want to be the first to notice. Companion to the `pollers` skill, which covers mechanics. This file is the menu of *what's worth polling.*
    6
    repo stars
22. ▌
    circuit-breaker · jasoncarreira

    Recognize when you're in a runaway loop and stop yourself. Use when the same tool call has repeated 3× with the same args, when the same error class has fired 3× in a turn, when you've been told the same correction twice, when "let me try one more variation" is the third small variation, or when a refinement loop is orbiting rather than converging. The right move on a trip is to switch from action to inquiry — read events.jsonl, list assumptions, look for contradictions, ask the human, file a chainlink — not to retry harder.
    6
    repo stars
23. ▌
    fallback-chains · jasoncarreira

    Layer alternative channels / scrapers / data sources with explicit fall-through, where each rung covers a different failure mode. Use when interacting with the world (sending a notification, fetching from a third party, detecting a state change, authenticating) and the single canonical path could fail in known ways. Distinct from retrying — retries handle transient failures; fallback chains handle modal ones (channel down, API gone, cookie expired). Three layers tops; the terminal rung is loud.
    6
    repo stars
24. ▌
    identity-lookup · jasoncarreira

    Look up who an alias belongs to (people) or what a channel id is (channels) using state/identities.yaml. Use when the operator or a turn-context refers to a platform-prefixed id ("who is discord-100000000000000001?", "what channel is slack-C100?") or you need to resolve aliases the other direction (canonical → display name + aliases). Read-side only — the populator (mimir.identities_populator) maintains the registry.
    6
    repo stars
25. ▌
    view-attachment · jasoncarreira

    View image or file attachments that you can't directly see. Use this skill when you receive a message with attachments listed as file paths and you need to understand their contents. Especially useful for text-only models that cannot process images natively.
    6
    repo stars
26. ▌
    mermaid-diagrams · jasoncarreira bundle

    Comprehensive guide for creating software diagrams using Mermaid syntax. Use when users need to create, visualize, or document software through diagrams including class diagrams (domain modeling, object-oriented design), sequence diagrams (application flows, API interactions, code execution), flowcharts (processes, algorithms, user journeys), entity relationship diagrams (database schemas), C4 architecture diagrams (system context, containers, components), state diagrams, git graphs, pie charts, gantt charts, or any other diagram type. Triggers include requests to "diagram", "visualize", "model", "map out", "show the flow", or when explaining system architecture, database design, code structure, or user/application flows.
    6
    repo stars
27. ▌
    long-running-jobs · jasoncarreira

    Run shell commands in the background with output capture and completion callbacks. Use when a command might take more than ~30 seconds (builds, tests, deployments, data processing) and you want to keep working while it runs.
    6
    repo stars
28. ▌
    skill-acquisition · jasoncarreira bundle

    Discover, evaluate, install, and wrap external agent skills from ClawHub registry, skillflag-compliant CLI tools, and GitHub repos. Use when asked to find new capabilities, install a skill, browse what's available, or package a local skill for sharing.
    6
    repo stars