93 skills published by runxhq across 1 repository. Together they weigh 5 890 449 tokens — that is what loading all of them at once would cost you in context.
93 skills 5 890 449 tokens total
Run a standing team with a mandate, advanced one governed case-turn at a time: a fixed roster, a persistent objective, a multi-turn case, member dispatch under a scoped grant, escalation gates, a measurable done-check, and a sealed receipt trail.
Answer one question strictly from a small, caller-supplied documentation corpus, with exact supporting quotations or an explicit account of what the corpus cannot answer.
Audit a sealed runx receipt for governance, comparing the authority a run exercised against what it was granted, and flag over-reach, ungated mutation, unrecorded refusals, or exposed secret material.
Build a scoped brand voice packet from source material so downstream agents can write, review, and adapt content without inventing brand claims.
Route one business signal through a replayable governed ops graph: classify, docs, release, work, outreach, spend, and proof, with consequential actions stopping at the right gate.
Prepare a provider-side paid-call challenge and exact credential-verification handoff; forwarding requires a real settlement adapter.
Bind a provider price to a deterministic replay-safe challenge natively.
Derive a provider-side price and bounded payment request natively.
Prepare an exact provider-verifier request from an opaque credential reference natively.
Convert bounded mailbox and calendar evidence into a reviewable executive action packet.
Turn governed source evidence into a citation-bound reader-facing draft, channel package, and provider-neutral publication handoff.
Audit exact npm dependency versions against OSV through Runx native HTTP and emit replay-verified evidence with no unverified findings.
Govern provider-agnostic data reads and state transitions through declared data-source operations, not model-authored raw queries.
Produce a decision-ready deep-research brief from bounded governed evidence and preserve every material source binding.
Prepare and explicitly file an evidence-bound payment dispute response using native receipt proof, approval, provider execution, and independent readback.
Produce a decision-ready ecosystem briefing from fresh governed evidence without claiming publication.
Extract schema-validated JSON from messy HTML or text fixtures with digest-bound provenance.
Turn validated evidence and operator intent into publication-ready drafts, deterministic channel packages, and provider-neutral handoffs.
Plan or execute a scoped GitHub issue, thread, or pull-request synchronization through a configured Runx Connect grant, with approval and readback on writes.
Read and normalize GA4 properties, metadata, standard reports, and realtime reports through any compatible Runx connector, preserving the measurement caveats an operator needs before turning analytics into action.
Read and normalize Google Search Console performance, indexing, site, and sitemap evidence through any compatible Runx connector; plan and govern sitemap submission without coupling the skill to credential custody or a connector vendor.
Fetch one allowlisted external source, scrub personal data, obtain human authorization for the exact safe plan, and seal a provider-neutral outbound handoff without claiming delivery. Use when external content must cross a trust boundary through a separate delivery adapter.
Classify a bounded support request, choose the safe next path, and draft a customer-ready reply only when a human-gated send is appropriate.
Advance one declared incident through a fixed roster, approval-bound communications planning, and receipt-backed resolution while canonical agency owns durable state.
Turn a noisy inbound request into a bounded intake artifact and an explicit next runx lane.
Govern a scafld-backed issue-to-PR lane with native scafld review and handoff surfaces.
Publish issue-to-PR outbox entries through the governed Rust thread-outbox-provider front.
Internal GitHub provider boundary for a prepared issue-to-PR outbox push.
Read, analyze, and draft high-signal GitHub issue responses from bounded provider evidence without silently mutating the repository.
Route one question or source event through a supplied knowledge catalog to validated source, owner, escalation, and follow-up skill references. Use for evidence discovery and ownership routing, not broad business-action fanout or answering the question itself.
Enrich a lead from supplied account signals and produce a consent-aware, evidence-bound outreach recommendation.
Route a validated lead to direct outreach planning, nurture planning, or a recorded hold, preserving why that path was chosen.
Verify the receipt ids behind a normalized authority-usage summary, compare that evidence with granted scopes, and propose the narrowest grant the evidence supports.
Answer a cross-run audit question against the receipt ledger, returning matched receipts and a chain-verification result.
Turn one bounded meeting transcript into evidence-bound decisions, action items, a reviewable follow-up message, and provider-neutral task proposals without inventing owners, dates, approval, or live effects.
Govern a bounty-style messageboard from post through moderation, claim, delivery, acceptance, payout authorization, and trial take evidence.
Route the mock provider-charge plan through canonical charge.
Route the mock payment rail through canonical spend authority and finality.
Route the mock refund plan through canonical receipt- and authority-bound refund.
Scan Moltbook for credible opportunities, prepare evidence-bound posts, and publish an exact approved payload through Runx Connect with readback.
Route the mpp provider-charge plan through canonical charge.
Route the mpp payment rail through canonical spend authority and finality.
Route the mpp refund plan through canonical receipt- and authority-bound refund.
Validate a runx execution context and hand off a governed payload to an n8n workflow webhook with scoped auth, idempotency, and receipt expectations.
Operate a Nitrosend account through one governed Runx skill: inspect readiness and analytics, plan and apply campaign/flow/template/segment drafts, import consented contacts through inline or bulk CSV paths, and approve or deliver campaign, flow, and transactional email operations with provider readback.
Execute one bounded Nitrosend MCP operation through Runx native HTTP.
Fetch National Weather Service forecast evidence through the governed HTTP front, producing a sealed provider packet for downstream weather planning.
Resolve a place and fetch global forecast and air-quality evidence through governed, keyless Open-Meteo HTTP calls.
Maintain a provider-neutral local action queue from bounded provider observations and explicit human dispositions.
Operate a project, workspace, or account from an agent or manager dashboard: inspect state, triage risks, prepare governed actions, route to the right skill lane, require approvals for consequential acts, and verify receipts after execution.
Deterministic fixture lane for the business-ops graph example.
Turn bounded search, analytics, site, and market evidence into an evidence-bound SEO and answer-engine growth brief with prioritized actions and a measurement plan, without claiming execution or guaranteed visibility.
Turn a pinned local upstream SKILL.md into an exact native Runx binding bundle, with deterministic source digests, a bounded execution profile, isolated harness proof, and no publication claim. Use when adopting a third-party skill; use skill-lab for first-party Runx skills.
Fulfill a reserved payment challenge through one rail under attenuated runx authority.
Deterministically normalize one structured payment signal into a bounded quote and requested payment authority derived from the caller's real parent authority.
Reconcile an idempotent payment attempt before retrying or sealing.
Deterministically mint and prove one single-use child payment authority from a native quote and the caller's real parent authority.
Draft or tighten a Runx operational policy from a governance brief, then validate the exact runx.operational_policy.v1 contract with the native policy engine. Use for repository/source/runner/owner policy design, fail-closed policy linting, or authority attenuation; never use this lane to widen an existing policy.
Inspect bounded local repository and Runx catalog evidence before a design, draft, or operator decision, then produce citation-bound findings and a reuse, amendment, new-work, or stop recommendation. Use when existing tools, skills, standards, or project patterns must constrain downstream work; use research or web-fetch first for external sources.
Govern one GitHub pull-request review comment through Runx Connect or the canonical MCP pattern, with exact approval, retry safety, and independent readback.
Detect and remove personal data before content crosses a trust boundary, returning usable scrubbed content only when a deterministic residual scan passes. Use for exports, prompts, logs, support material, or outbound handoffs that need a pass, review, or block verdict; it does not move content or handle credentials.
Read durable reflect projections, group repeated signals by skill, and emit validated handoffs to skill-lab improve when the evidence clears configured floors.
Prepare a sealed-receipt-linked refund handoff under bounded authority without claiming money moved.
Prepare, approve, execute, and independently verify a versioned release through a project-owned exact-command profile.
Produce bounded, source-backed research packets for product, ecosystem, and operator decisions.
Internal evidence-index analysis and verification stage for the canonical research skill.
Review receipts and harness failures to propose bounded skill improvements.
Inspect, safely test, and assess one Runx skill package for capability, trust, and operator readiness. Use when deciding whether to adopt, improve, reject, install, or publish a skill; its evidence-only assess runner is available when native test evidence already exists.
Read Runx's native receipt history and skill catalog, then return deterministic run outcomes, catalog test coverage, and governance follow-ups without model-authored metrics.
Governed runtime for agent skills: discover and install portable skills, run bounded skill graphs with explicit authority, and inspect signed receipts for what happened.
Run existing scafld v2 lifecycle commands under runx governance.
Plan and authorize a provider-neutral message or campaign send; this skill never delivers, so use a provider adapter for the actual send and its delivery evidence.
Validate one invoice against a real payment authority and prepare an executable canonical spend handoff without moving money.
Bind an off-runtime action claim to opaque evidence references in a signed Runx receipt without pretending Runx verified the external action.
Canonical Runx skill-authoring implementation. Use for designing, creating, updating, improving, or adding harness coverage to a Runx skill package; it combines bounded agent judgment with native file writes, inspection, and safe harness validation. When a host skill-creator also triggers, use its general guidance but execute Runx work through this skill.
Read bounded Slack search and thread evidence, plan an exact reply, and deliver an approved reply through Runx Connect with stable-message readback.
Plan a digest-bound Slack notification, then deliver the exact approved channel post through a configured Runx Connect grant with provider readback.
Generate documentation for a project using Sourcey.
Execute one governed outbound payment through deterministic quote, authority reservation, approval, rail fulfillment, and provider evidence.
Produce a schema-validated, read-only SQL analysis plan and explicit governed execution handoff without running raw SQL.
Route the stripe provider-charge plan through canonical charge.
Execute a governed stripe-spt payment by delegating to the canonical spend authority and finality lane.
Route the stripe refund plan through canonical receipt- and authority-bound refund.
Build a scoped taste profile packet from examples, preferences, and explicit dislikes so downstream agents can make style decisions without inventing the user's taste.
>- act plans for posting and account hygiene, and gated execution with per-act provider evidence. Nothing reaches a live timeline or mutates an account without an explicit approval recorded in the receipt.
Plan or execute a scoped, time-bounded vault-unseal request through Runx Connect, returning only opaque handle metadata and provider readback.
Prepare an evidence-bound vulnerability publication and publish the exact approved advisory through Runx Connect with independent provider readback.
Turn verified exact-version vulnerability evidence into bounded remediation and advisory packets without inventing exposure or claiming publication.
Normalize supplied provider weather evidence into a provenance-bound forecast packet with uncertainty and stop conditions. Use when a downstream planning workflow needs provider-neutral weather context; do not use it to fetch forecasts, make life-safety decisions, or perform downstream actions.
Fetch and extract one web source within an explicit allowlist, returning the content by digest with full provenance.
Compile a bounded objective or issue-intake change set into a dependency-safe Runx execution plan, with deterministic checks for evidence preservation, mutation boundaries, catalog references, and skill-package ownership. Use before multi-step or cross-surface work; this skill plans but does not execute.
Validate an x402 payment challenge against bounded Runx payment authority and prepare the canonical spend quote without pretending a wallet adapter or settlement exists.
Validate a runx execution context and hand off a governed payload to a Zapier Catch Hook with scoped auth, idempotency, and receipt expectations.