envoydev

@envoydev source repo

79 skills
0 followers
10 hours ago last updated

▌
Nx · envoydev
Use when working in an Nx monorepo - an `nx.json` / `project.json` workspace, or `nx` commands - for the token-efficient way to navigate the project graph and scope work. Orient through the CLI's derived graph (`nx show projects`, `nx graph`, `nx show project`) rather than reading config, scope every build/test/lint to `nx affected` instead of the whole tree, scaffold with `nx generate`, and enforce module boundaries with tags. Draws the line against serena - Nx answers project-graph and affected questions, serena answers symbol-level code questions. For the Angular code conventions themselves see `angular-conventions`; this is the workspace/monorepo layer above them.

0
installs
▌
NPM · envoydev bundle
Professional npm usage for consuming and publishing packages: lockfile + npm ci discipline, the supply-chain baseline (ignore-scripts, the min-release-age cooldown, allow-git=none, OIDC publishing, scoped internal packages), honest npm-audit gating, overrides vs --legacy-peer-deps, exports maps and ESM-first publishing, update-bot cooldowns. Fires on package.json / package-lock.json / .npmrc work, npm install/ci/publish questions, dependency updates or vulnerability reports, supply-chain concerns, 'set up npm for this repo'. NOT for TS language style (typescript skill), Angular framework conventions (angular-conventions), or authoring CI pipelines beyond npm's own steps (the devops family).

0
installs
▌
Ionic · envoydev bundle
Ionic / Capacitor mobile + hybrid app conventions - house rules for Ionic Angular UI (standalone + signals, IonRouterOutlet, page-caching view lifecycle, CSS-variable theming), Capacitor lifecycle + platform guards, runtime permissions, and Capacitor plugin sourcing (official -> Capawesome -> capacitor-community) + typed-service wrapping. Targets Ionic 8+ (9 current) / Angular 17+ / Capacitor 6+ (8 current). Load before building or editing an Ionic/Capacitor app - anywhere ionic.config.json or capacitor.config.* lives. Companions: angular-conventions, typescript. Do NOT load for plain web Angular with no native shell.

0
installs
▌
Csharp · envoydev bundle
C# conventions (.NET 8 / C# 12 floor) - style/structure (file layout, naming, member/ctor ordering, methods, types, visibility, design-pattern (GoF) awareness, modern C# 12/13/14 syntax, forbidden patterns, XML doc) and runtime behavior (DateTime/TimeProvider, async, dispose, exceptions + Result, structured logging, secrets/config, LINQ, System.Text.Json, decoupling + DI lifetimes). Load before creating or editing any `.cs` file - writing, reviewing, or refactoring C#; do not lean on recalled conventions. The always-load baseline; specialist areas (performance, EF, web, messaging, hosted workers) route out through the .NET companion router when your skill list has one, not here.

0
installs
▌
Devops · envoydev bundle
DevOps reference for the .NET/Angular house, by the delivery surface a change touches: container builds (multi-stage, cache-ordered layers, non-root, digest-pinned base images), Compose local topology, GitHub Actions CI/CD (SHA-pinned actions, masked secrets, least-privilege permissions, OIDC, real service containers), and safe deploys (immutable artifact promotion, gated expand-contract migrations, health-gated cutover with rollback). Load when authoring or reviewing a Dockerfile, a compose file, a workflow, a deploy pipeline, an env/secret template, or the Aspire AppHost - or when the devops vertical or security-auditor sweeps the delivery stack. Points at dotnet-aspire, dotnet-migrate, and dotnet-security / database-security. Do NOT load for application or schema code.

0
installs
▌
Dotnet · envoydev
Router and complete index for .NET / C# specialist skills - maps a concrete work area (a construct, command, file, or task) to the one focused skill to load, across language & types, architecture & structure, ASP.NET Core & web, cross-cutting hardening, data & EF, messaging & orchestration, hosting & background work, testing & quality, diagnostics & performance, and desktop (WPF / WinForms). Routes per area, does not restate the skills. Load when starting or navigating any .NET / C# backend or desktop work - typed asks like 'add an endpoint to the orders API', 'my BackgroundService stopped overnight', or 'which skill covers EF Core queries' all start here. Companion: csharp (always, for any C#). For web front-end see frontend; for Ionic/Capacitor see mobile.

0
installs
▌
Mobile · envoydev
Router and index for Ionic / Capacitor mobile + hybrid app work - maps a mobile area (Ionic Angular UI, the Capacitor native layer, native plugins, the store/release/signing pipeline, mobile security hardening) to the focused leaf skill via the body's routing table. Load when starting mobile work and unsure which area applies - 'add a camera feature', 'why does the back button close the app', 'get this build into TestFlight' - or when orienting in a codebase with ionic.config.json or capacitor.config.*; go straight to the leaf skill when the area is known. Companions: angular-conventions, typescript. For plain web frontend see frontend; for .NET backend see dotnet.

0
installs
▌
Sqlite · envoydev
SQLite engine specialist - the SQLite-specific delta on top of the cross-engine database-conventions hub: when SQLite fits, the single-writer / WAL concurrency model and busy-timeout, PRAGMAs (foreign_keys, journal_mode, synchronous), type affinity vs STRICT tables and date/bool storage, limited ALTER TABLE and the table-rebuild, connection-per-thread and in-memory test DBs, B-tree-only indexing, FTS5, and backup. Load for a SQLite .db, a PRAGMA, an embedded/desktop/mobile/test store, or an EF Core SQLite provider quirk. Not the cross-engine schema/transaction rules (-> database-conventions) or a server-class concurrent-writer workload (-> postgres). Companions: database-conventions (cross-engine hub - load first), dotnet-data-access (the EF Core / ORM side), postgres (the other engine).

0
installs
▌
Webpack · envoydev bundle
Webpack 5 build engineering, library-in-monorepo focus (TS + JS): the transpile/type-check split (swc-loader + fork-ts-checker + tsc --emitDeclarationOnly), externals from package.json, the tree-shaking preconditions, ESM output state and the fullySpecified/extensionAlias resolution traps, filesystem-cache pitfalls, the shared config-factory pattern. Fires on webpack.config work, loader/plugin choices, 'bundle this library', tree-shaking or 'failed to resolve as fully specified' errors, slow webpack builds. NOT for Vite/Rollup projects, Angular CLI builds (angular-conventions), or package publishing mechanics (npm skill).

0
installs
▌
Frontend · envoydev
Router and index for web frontend work - maps a frontend area (Angular framework code, TypeScript/JavaScript language, Material/CDK components, CSS/SCSS styling, client-side security, library docs) to the focused skill to load, plus the in-skill Design quality bar. Load when starting web UI work where the right skill is not yet obvious - a feature spanning components, styles, and security, or orienting in an unfamiliar frontend codebase; asks like 'add a profile page with a form and avatar upload' or 'make this dashboard look less generic' start here. Do NOT load when the leaf skill is already known - go straight to it (typescript is always the companion for TS/JS). For Ionic/Capacitor mobile see mobile; for .NET backend see dotnet.

0
installs
▌
Postgres · envoydev bundle
PostgreSQL engine specialist - the Postgres-specific delta on top of the cross-engine database-conventions hub: identifier folding and idempotent DDL, index-type selection (B-tree/GIN/GiST/BRIN/hash), JSONB and full-text indexing, SARGable predicate rewrites, the planner (EXPLAIN ANALYZE, pg_stat_statements, autovacuum/ANALYZE, work_mem), connection pooling modes, and array-batching/ON CONFLICT/COPY. Load for any hand-written Postgres SQL, an .sql file on a Postgres project, an EXPLAIN plan, a slow query, or an index/pooling decision. Not the cross-engine schema/transaction rules (-> database-conventions), the ORM side (-> dotnet-data-access), or another engine's SQL. Companions: database-conventions (cross-engine hub - load first), database-security (RLS/privileges), dotnet-data-access (the EF Core / ORM side).

0
installs
▌
Dotnet Wpf · envoydev bundle
WPF conventions - strict MVVM with a one-way View-knows-ViewModel dependency, CommunityToolkit.Mvvm source generators over hand-rolled INotifyPropertyChanged, async commands carrying a CancellationToken, explicit binding modes, generic-host composition, off-UI-thread work via IProgress, list virtualization, styling/theming with the .NET 9 Fluent ThemeMode, and resx localization. Floors at .NET 8 / C# 12. Load before editing any XAML, code-behind, or ViewModel. Do NOT load for WinForms, UWP, WinUI 3, MAUI, Avalonia, or Uno - different frameworks; orchestration routes to csharp-design-patterns, tests to dotnet-testing, a paired Windows-Service worker to dotnet-hosted-services.

0
installs
▌
Javascript · envoydev bundle
JavaScript language conventions, framework-agnostic - the base layer for all JS-family code: ES modules only, named exports and boundary barrels, async/await discipline with cancellation, the two failure channels (returned result vs thrown Error), modern-feature adoption (structuredClone, iterator helpers, Temporal), untrusted-input rules, naming and shape. Load before writing or editing any .js, .jsx, .mjs, or .cjs file in any runtime - browser, Node, build script, service worker, extension. The type layer (TypeScript, and checked JS via JSDoc) is the `typescript` skill, which stacks on this baseline; frameworks add their own layer above that. Not for C#/.NET or other languages.

0
installs
▌
Typescript · envoydev bundle
The TypeScript type layer over the `javascript` baseline - lean on the compiler (full strict plus the extra safety flags), model data with types, narrow unknown instead of any, brand look-alike primitives, and treat plain JS as checked JS via JSDoc and checkJs. Baseline is TypeScript 5+. Load before writing or editing any .ts or .tsx file - and load `javascript` with it, the base-language layer this stacks on. In an Angular project also load the Angular framework-conventions skill, when your skill list has one. Also fires for tsconfig work and for typing questions in checked .js files. Not for base-language rules alone (javascript) or C#/.NET.

0
installs
▌
Dotnet Grpc · envoydev bundle
.NET gRPC conventions - the .proto is the contract and Grpc.Tools generates from it at build, host with Grpc.AspNetCore (AddGrpc + MapGrpcService), consume through typed clients (AddGrpcClient over IHttpClientFactory) with a reused multiplexing channel, the four call shapes with a deadline and CancellationToken on every one, JWT-bearer or mTLS auth, interceptors for cross-cutting work, the gRPC health protocol, and gRPC-Web for browsers. Floors at .NET 8 / C# 12. Load when defining, implementing, or calling a gRPC service, or weighing gRPC against REST. Companions: dotnet-web-backend, dotnet-authentication, csharp. Do NOT load for plain REST or minimal APIs - that is dotnet-minimal-api.

0
installs
▌
Docs As Code · envoydev bundle
Authoring conventions for documentation as versioned text artifacts - the docs-as-code practice: Mermaid diagrams (sequenceDiagram for interaction flows, erDiagram for schema sketches), decision records (ADR - Nygard + MADR 4), and C4 model views (context/container). Load before writing or reviewing ANY documentation artifact of these types, whatever the subject - a sequence/ER/C4 diagram in Markdown, an ADR or decision-log entry, or a diagram-tooling choice (Mermaid vs DBML vs Structurizr). Routes per doc type to references/. Triggers on sequence diagram, ER diagram, entity relationship, ADR, decision record, decision log, C4, container diagram, context diagram, docs-as-code - and on mermaid for those diagram types (other Mermaid forms get only the generic ground rules here). NOT the repo's committed architecture capture (project-architecture-analyzer owns <docs-path>/architecture/), not Markdown prose style (markdown-style), and not DB design itself (database-conventions).

0
installs
▌
Create Ticket · envoydev bundle
Writes a ticket in English from a raw description for any tracker (Jira, Azure DevOps, GitHub, GitLab, YouTrack): bug, user story, epic, or technical task - detects the type, routes to its template. Use whenever the user wants a ticket written or a not-yet-filed draft reworked (shorter, different focus), even casually or in Ukrainian - 'create a bug/story/epic/task ticket', 'create user story', 'create jira ticket', 'file a bug'. Do NOT fire to write code or fix the bug instead of filing it, to touch a ticket already in the tracker (query / update / comment / close), or for a commit / PR message.

0
installs
▌
Dotnet Aspire · envoydev
.NET Aspire conventions for local cloud-native orchestration - the AppHost that declares the topology, the shared ServiceDefaults extension every service calls once, name-based service discovery, AppHost-injected connection strings, and the developer dashboard. This is the local run, NOT production deployment or container publishing. Floors at .NET 8 / C# 12. Load when scaffolding or editing an AppHost or ServiceDefaults, declaring resources and references, wiring discovery, or when the user says Aspire, AppHost, AddProject, WithReference, service discovery, or Aspire dashboard. Companions: dotnet-web-backend, dotnet-testing. Do NOT load for non-Aspire projects, production deployment, or publishing images.

0
installs
▌
TS JS Testing · envoydev bundle
Plain TypeScript/JavaScript testing hub - practices and tooling only, no coverage numbers (the % bar is user-set via project-test-coverage-analyzer): runner routing (Vitest the house default, Jest where the workspace signals it, node:test the zero-dependency floor - detect, never install), a test strategy keyed off role (pure module / boundary seam / DOM-adjacent / Node-runtime / published types), fake timers vs real async, the mock-masking smoke spec, and the TS/JS exclusion catalog. Covers libraries, Node CLIs/tooling, framework-free web code, and the browser-extension unit layer (the chrome.* seam and extension E2E live in browser-extension). Load before writing, modifying, or reviewing TS/JS tests outside a framework harness, auditing suite quality, running mutation testing, or configuring coverage - do not rely on recall. Do NOT load for Angular/Ionic (angular-testing) or .NET (dotnet-testing).

0
installs
▌
Dotnet Migrate · envoydev bundle
safe-migration playbook for .NET - the disciplined way to evolve a schema with EF Core, lift a solution onto a newer target framework, and refresh NuGet dependencies without breaking production. A process skill, version-neutral with a .NET 8 floor. Load when you run a database migration, raise the target framework or SDK, or bump packages - trigger words migrate, upgrade, update packages. Companions: `dotnet-data-access` for query and migration mechanics, `dotnet-project-setup` for central package management, `dotnet-web-backend` for the surrounding service. Skip it for ordinary feature work that touches no schema, no version, and no package.

0
installs
▌
Dotnet Openapi · envoydev
ASP.NET Core OpenAPI conventions - how a service emits a correct, generated OpenAPI document and serves a browsable docs UI from it. Picks the generator by framework floor (Swashbuckle or NSwag on .NET 8; the built-in Microsoft.AspNetCore.OpenApi with AddOpenApi / MapOpenApi on .NET 9 and up), shapes the spec with transformers, declares security schemes, splits versioned documents, and renders with Scalar. Floors at .NET 8 / C# 12. Load before adding API docs, editing the generated spec, declaring a security scheme, or standing up the docs UI. Companions: dotnet-minimal-api (the endpoint metadata feeding the document), dotnet-web-backend, dotnet-authentication. Skip it for non-HTTP code and internal APIs with no published contract.

0
installs
▌
Dotnet Testing · envoydev bundle
.NET testing hub - the architecture-neutral approach for unit / integration / E2E tests, not a single library: AAA structure, a test strategy keyed off responsibility, coverage mechanics (the exclusion catalog + after-exclusions semantics; the % bar itself is user-set via project-test-coverage-analyzer), and runner / substitute / assertion library routing (xUnit, NSubstitute, FluentAssertions 7.x as defaults). Floors at .NET 8 / C# 12. Load before writing, modifying, or reviewing .NET tests, auditing test quality / smells, running mutation testing, or configuring coverage - do not rely on recall. Companions: csharp, dotnet-web-error-handling; Testcontainers, Aspire-orchestrated integration, and Verify/snapshot testing are folded in here as references/. Do NOT load for Angular/Jasmine/Karma/Jest (angular-testing) or plain TS/JS suites (ts-js-testing).

0
installs
▌
Ionic Security · envoydev
Ionic / Capacitor mobile security-hardening reference for the native attack surface a WebView app adds beyond its web risks: secret storage in the Keychain / Keystore (never localStorage or Preferences - plaintext on-device), deep links as untrusted input, least-privilege native permissions, cleartext traffic and WebView debugging off in release, an allowNavigation allowlist and no live-reload server.url in production, FLAG_SECURE and backgrounding snapshots, plugin trust, pinning and biometric gating. Targets Capacitor 6+. Load when hardening or reviewing an Ionic/Capacitor feature - 'is it safe to store the token like this', 'lock the app behind Face ID', 'review our deep links' - or when the security-auditor sweeps the mobile stack. Points at angular-security, dotnet-security, capacitor-release. Do NOT load for non-security work.

0
installs
▌
Markdown Style · envoydev bundle
Markdown authoring and review skill - the two-layer rule set (syntax canon = valid, portable Markdown from the Markdown Guide; style overlay = opinionated house form from Google's style guide) plus the review procedure. Load when authoring or restructuring any .md (README, ADR, runbook, how-to, design doc) or on an explicit 'lint / style-check / fix this markdown', 'ATX vs setext', 'should I use a TOC?', or 'fix the headings / list indentation' ask. Markdown form only - not prose clarity (that is Vale) or spelling (codespell / hunspell).

0
installs
▌
Angular Styling · envoydev bundle
Angular CSS and styling conventions for any Angular app, Material or not - component-scoped styles and the ViewEncapsulation choice, :host and :host-context, ::ng-deep discouraged and the sanctioned ways out, design tokens as CSS custom properties, mobile-first responsive with container queries and fluid type, where global vs component styles belong, utility-first vs scoped SCSS, and accessibility-affecting styling (focus-visible, prefers-reduced-motion, contrast). Targets Angular 17+. Load when writing or editing CSS or SCSS in an Angular workspace - in an Ionic app load it WITH ionic and see the shadow-DOM section here, because ion-* components ignore the usual escape hatches. Companions: angular-conventions, angular-material, ionic. Do NOT load for React, Vue, Svelte, plain non-Angular CSS, or Material theme token work which belongs to angular-material.

0
installs
▌
Angular Testing · envoydev bundle
Angular testing hub - practices and tooling only, no coverage numbers (the % bar is user-set via project-test-coverage-analyzer): TestBed + component-harness patterns for standalone components, a test strategy keyed off role (component / service / store / pipe), runner routing (whichever the workspace already runs - Karma/Jasmine, Jest, or Vitest - detect, never install), HttpTestingController, fakeAsync vs real-async timing, and the Angular exclusion catalog. Ionic/Capacitor apps share it. Load before writing, modifying, or reviewing Angular tests, auditing suite quality, running mutation testing, or configuring Angular coverage - do not rely on recall. Do NOT load for .NET (dotnet-testing) or plain TS/JS outside a framework harness (ts-js-testing).

0
installs
▌
Dev Log Convert · envoydev bundle
Converts a day's raw work notes (Ukrainian, English, or mixed) into a structured, past-tense English work log - ticket IDs normalized, time totalled, tasks grouped by project or prefix across one or more days. Fires only on the exact keyword 'dev-log' - do not use it for general note-taking, meeting minutes, commit messages, or status updates, which are not this format.

0
installs
▌
Dotnet Realtime · envoydev bundle
.NET real-time conventions for ASP.NET Core SignalR - server-to-client push over a persistent connection, connection-scoped, not durable. Covers strongly-typed Hub<TClient>, sending via IHubContext, group/user targeting, reconnection, JWT-over-query-string auth, additive client contracts, MessagePack, and scale-out (Redis backplane / Azure SignalR Service). Floors at .NET 8 / C# 12. Load for chat, notifications, live dashboards, or any real-time server push - or when the user names SignalR, hub, server-side WebSocket push, or live updates. Companions: dotnet-messaging, dotnet-authentication, dotnet-hosted-services, dotnet-web-backend. Do NOT load for broker-backed durable messaging (dotnet-messaging), request/response HTTP (dotnet-minimal-api), in-process reactive streams (Rx / System.Reactive), or an outbound ClientWebSocket (dotnet-hosted-services).

0
installs
▌
Dotnet Security · envoydev bundle
.NET application-security hardening reference, organized by the OWASP Top 10 (2021) mapped to concrete ASP.NET Core / .NET 8 mitigations: broken access control (fallback authz policy, resource-based ownership checks against IDOR, CORS lockdown), injection and XSS, cryptographic and integrity failures, insecure deserialization, misconfiguration, vulnerable dependencies, SSRF, and security logging. Owns the do-not-use list for dead-but-tempting APIs (BinaryFormatter, Code Access Security, .NET Remoting). Floors at .NET 8 / C# 12. Load when hardening a feature, threat-modeling an endpoint, or reviewing a change for vulnerabilities. Companions: dotnet-authentication, dotnet-cryptography, database-security. Do NOT load for building the sign-in flow itself (dotnet-authentication) or choosing crypto primitives (dotnet-cryptography) - this skill reviews and hardens; those build.

0
installs
▌
Dotnet Winforms · envoydev bundle
WinForms conventions for maintenance and modernization - logic out of code-behind (MVP passive view for legacy, the .NET 8 MVVM binding engine for new), DI-resolvable forms, async/await with no UI-thread blocking, BindingSource + INotifyPropertyChanged binding, control/component/GDI disposal, PerMonitorV2 high-DPI, virtual-mode grids, presenter unit tests. Floors new work at .NET 8 / C# 12 and covers 4.8 as the supported-but-frozen maintenance surface. Load before editing any Form, UserControl, code-behind, presenter, or .Designer.cs. Do NOT load for WPF (-> dotnet-wpf), WinUI 3, MAUI, Avalonia, or Uno; async baseline -> csharp, MVP/command orchestration -> csharp-design-patterns, tests -> dotnet-testing, upgrade playbook -> dotnet-migrate, a paired Windows-Service worker -> dotnet-hosted-services + dotnet-windows-service.

0
installs
▌
Ilspy Decompile · envoydev
Decompile a compiled .NET assembly to read its real implementation - see how a framework or NuGet API actually works, view source you do not ship, or confirm behavior before a framework upgrade. Uses ilspycmd (via dnx or a pinned global tool). Load when you need ground truth from a .dll instead of guessing at an API, not for source you already have (that is serena / the LSP). Companions: `dotnet-migrate` (upgrade investigation), `csharp`.

0
installs
▌
Angular Material · envoydev bundle
Angular Material and CDK conventions - import only the component modules a standalone component uses (no shared barrel), theme through the M3 mat.theme API and its CSS custom properties rather than hand-edited .mat-* rules, reach for CDK primitives before rolling your own, and test through the official harnesses, not DOM queries on internals. Targets @angular/material 17+. Load when building UI with @angular/material or @angular/cdk. Companions: angular-conventions, typescript, angular-styling. This is the @angular/material library specifically, not generic Material Design 3 or @material/web. Skip for PrimeNG, Spartan UI, Ionic, or apps not using Angular Material.

0
installs
▌
Angular Security · envoydev
Angular / web frontend security-hardening reference mapped to concrete Angular 17+ mitigations: XSS and the DomSanitizer bypassSecurityTrust* escape hatches, innerHTML injection, nonce-based CSP, CSRF via HttpClient's XSRF support, secrets that must never ship in the bundle (environment.ts, source maps), auth-token storage (httpOnly cookie over localStorage), SSR/TransferState leaks, open redirects, target=_blank window.opener, unsafe URL bindings, and vulnerable npm dependencies. Load when hardening or reviewing an Angular web feature, or when the security-auditor sweeps the web stack. Points at dotnet-security for the API side, ionic-security for the Capacitor native shell. Do NOT load for non-security work or the mobile native surface.

0
installs
▌
Dotnet Messaging · envoydev
.NET asynchronous messaging conventions - broker-backed, event-driven communication between modules and services using Wolverine (recommended) over MassTransit, the transactional outbox for exactly-publish-on-commit, idempotent consumers under at-least-once delivery, choreography versus sagas, immutable versioned message contracts, and RabbitMQ or Azure Service Bus transports configured (never hardcoded). Floors at .NET 8 / C# 12. Load when wiring a message bus, an outbox, a saga or process manager, integration events, or background message processing, or when the user names Wolverine, MassTransit, RabbitMQ, Azure Service Bus, queue, or pub/sub. Companions: dotnet-hosted-services (the consumer's host), dotnet-realtime, dotnet-aspire, csharp. Do NOT load for in-process reactive streams or synchronous request/response over HTTP (dotnet-web-backend).

0
installs
▌
Browser Extension · envoydev bundle
Browser-extension engineering (TypeScript/JavaScript, Manifest V3): the ephemeral service-worker model, content-script isolation and MAIN-world boundaries, typed cross-context messaging, storage tiers and quotas, least-privilege permissions, CSP-safe UI frameworks, WXT-first tooling, store review and monetization reality. Fires on manifest.json / MV3 work, content scripts, extension service workers, chrome.* or browser.* APIs, popup/options/side-panel UI, Web Store or AMO publishing, 'build a chrome extension'. NOT for regular browser web apps (angular-conventions / frontend), Electron or VS Code extensions (Node-runtime work), or npm mechanics (npm skill).

0
installs
▌
Capacitor Release · envoydev bundle
release-pipeline conventions for an Ionic / Capacitor app - the gap from a feature-complete build to a signed store submission: cap sync and native build artifacts (.ipa, .aab), iOS and Android code signing, store submission (TestFlight, Play tracks), OTA / live updates and the native-binary boundary, marketing-version vs build-number sync, and the Fastlane / GitHub Actions CI shape with secrets handling and dSYM / sourcemap upload. Targets Capacitor 6+ (8 current). Load when cutting a release, wiring signing, or building the release CI. Companions: ionic, mobile. Do NOT load for in-app feature work with no release or signing concern.

0
installs
▌
Database Security · envoydev
SQL / data-layer security-hardening reference, organized by the persistence threat surface: SQL injection closed at every sink, least-privilege database accounts, row-level security and tenant isolation (the data-layer IDOR), secrets kept out of connection strings, encryption at rest and in transit, sensitive-data exposure and masking, and audit logging that never records the secret. Load when hardening or reviewing a SQL / data-persistence feature, when the security-auditor sweeps the data stack, or on asks like 'is this query injectable' or 'can one tenant read another's rows'. Points at dotnet-security for the app-layer EF and injection surface, dotnet-cryptography for crypto primitives, and dotnet-migrate for safe migration mechanics. Do NOT load for non-security work.

0
installs
▌
Dotnet Data Access · envoydev bundle
The .NET ORM / data-access layer (.NET 8 floor) - ORM-agnostic access principles here, per-ORM mechanics in references/: session or context lifetime and thread-safety, change tracking, loading strategy and N+1, projection to read models, bounded results and no-generic-repository, and the full-ORM-for-writes + micro-ORM-for-reads split. Load when you configure a DbContext or ISession, write or review an ORM query, pick a loading strategy, or design a read/write store; then use references/efcore.md for EF Core or references/nhibernate.md for NHibernate. Not the engine side (raw SQL, index, planner -> postgres / sqlite) nor the migration playbook (-> dotnet-migrate). Companions: csharp (async, mapping), dotnet-testing (integration tests).

0
installs
▌
Dotnet Diagnostics · envoydev bundle
Measure and diagnose a live .NET process - the layer that decides whether to benchmark a hot path or capture a dump. Microbenchmarking: BenchmarkDotNet in a separate Release console project, [MemoryDiagnoser], reading mean/alloc/ratio. Dumps: capture a crash/hang/OOM dump with dotnet-dump or DOTNET_DbgEnableMiniDump, managed-heap-only with dotnet-gcdump, then first-look SOS analysis (clrstack, dumpheap, gcroot). Load when timing a hot path, comparing two implementations, or when a process crashed, hung, or is leaking - CoreCLR only, not .NET Framework or NativeAOT dumps. Do NOT load for CPU/memory profiling, APM, or distributed tracing - this owns benchmarks and dumps. Companions: `csharp`, `dotnet`, `dotnet-performance`, `dotnet-testing`.

0
installs
▌
Dotnet Minimal API · envoydev bundle
ASP.NET Core minimal API mechanics - how an endpoint is shaped and wired, not what surrounds it: feature-grouped registration via extension methods and MapGroup, TypedResults and Results<> outcome unions, IEndpointFilter for per-endpoint cross-cutting, parameter binding (AsParameters, explicit From-attributes, custom BindAsync/TryParse), endpoint metadata, and hardened IFormFile uploads. Floors at .NET 8 / C# 12; later additions are flagged optional. Load before writing or editing minimal API endpoints - MapGet, MapPost, MapGroup, endpoint filters. Companions: dotnet-web-backend (pipeline-wide concerns), dotnet-web-error-handling, dotnet-openapi, dotnet-authentication. Do NOT load for MVC or API controllers, gRPC, SignalR, or non-HTTP code.

0
installs
▌
Dotnet Performance · envoydev bundle
Performance-aware .NET design decisions and where they matter - the layer that decides whether an allocation/memory-layout or serialization-format choice is worth spending on here. Type design: struct vs class, readonly struct, seal by default, fewer allocations, `Span`, `ValueTask`, frozen/immutable returns. Serialization: pick the format - `System.Text.Json` source-gen for JSON, Protobuf for wire, MessagePack for cache/messaging. Load when a type sits on a hot path or high-throughput loop, or when choosing how bytes cross a process boundary. Do NOT start here for 'my app is slow' - that is usually a bad query or an N+1: route to `dotnet-diagnostics` and measure first. Companions: `csharp`, `dotnet`, `dotnet-diagnostics`.

0
installs
▌
Dotnet Web Backend · envoydev bundle
.NET web / HTTP service conventions - the architecture-neutral cross-cutting baseline every ASP.NET Core service shares: IHttpClientFactory, FluentValidation, resilience via Microsoft.Extensions.Http.Resilience, API versioning, OpenAPI, typed options with startup validation (IOptions / ValidateOnStart), observability (structured logging, OpenTelemetry to OTLP, correlation IDs, health checks), and caching (IMemoryCache, HybridCache, Redis). This is the web hub - load it first for any ASP.NET Core / Web API / minimal API / microservice work, then the focused companion for the how. It owns the 'pick exactly one architecture' rule but mandates no specific one. Floors at .NET 8 / C# 12. Do NOT load for console binaries, CLI tools, desktop apps, WPF/MAUI, daemons, or message-only consumers.

0
installs
▌
Explain Code Tutor · envoydev bundle
Explains code, a bug, a concept, or an architecture/approach trade-off like a patient senior engineer for someone new to the stack: walks the real project files with one fitting analogy, numbered steps over short quoted snippets, a marked break-point/key-insight/verdict, the real fix, and a one-line takeaway. Depth adjustable (ELI5, intermediate, expert). Use when the user wants something explained, even casually: 'explain this code', 'walk me through this', 'how does this work', 'which is better X or Y'. Do NOT fire on quick lookups answerable in a sentence (glossary asks, yes/no questions) or for writing new feature code or formal code review.

0
installs
▌
Project Solve Task · envoydev
Use to run a task, feature, or bug through the whole single-chat vertical with a hard user gate between every step: design -> plan audit -> user approval + build-mode choice -> build -> build review (skippable): project-verify-code inline or the verifier seat -> done-gate. Every stop is a real pause - switch model or effort, add context, or edit the plan before saying go - and the plan file plus a serena cycle note make every step resumable after compaction or in a fresh session. Trigger on run the task cycle, build this with approvals, gated implementation, step-by-step with my sign-off. Not the dispatched multi-agent flow (project-solve-cross-task), not greenfield (project-build-from-scratch), not a one-line edit.

0
installs
▌
Claude Stack · envoydev
Route to the right claude-stack action when unsure which fits - inspects the install state and answers with the exact command to run: /claude-stack:setup (fresh install from scratch), /claude-stack:update (no-questions refresh + prune of upstream removals), /claude-stack:configure (adjust an existing install - add or drop), /claude-stack:validate (reconcile an install against THIS project - prune what its frameworks do not use and add the detected stacks' missing artifacts), /claude-stack:status (read-only per-area tables of what is installed). Trigger by invoking /claude-stack.

0
installs
▌
Angular Conventions · envoydev bundle
Angular conventions from v17 up - standalone everything, signals as the default state primitive, OnPush and zoneless, block control flow, signal inputs and outputs, deferred loading, RxJS only where streams earn it, forms, routing, SSR and hydration, accessibility, harness testing, banned patterns, reward-hacking shortcuts to reject. Load when creating or editing a component, service, directive, or template; refactoring to signals; or reviewing Angular code. Companions: typescript, angular-material, angular-styling, angular-security, frontend, mobile. Not for React, Vue, Svelte, Solid, plain DOM, or non-Angular TypeScript.

0
installs
▌
Dotnet Architecture · envoydev bundle
Choose and hold a .NET application architecture - the decision layer here, each style's depth in references/. Two axes plus one additive: topology (single deployable -> modular-monolith -> microservices), internal organization (clean-architecture vs vertical-slice), and DDD tactical patterns layered on when the domain has real invariants. Load when deciding where code belongs, structuring a new app or module, picking a layering/slicing style, drawing a service or module boundary, reviewing architecture drift, or when the user says clean architecture, vertical slice, DDD, modular monolith, microservices, or bounded context. Companions: dotnet-architecture-tests, dotnet-web-backend, dotnet-messaging, csharp. Do NOT load for encoding the boundaries as build-failing tests (dotnet-architecture-tests) or raw SQL / query tuning (postgres).

0
installs
▌
Dotnet Code Quality · envoydev bundle
.NET conventions for mechanically enforcing code quality - making the house style a build gate, not a review opinion. Floors at .NET 8 / C# 12. Load when setting up or fixing formatting, analyzers, .editorconfig, warnings-as-errors, or a CI quality gate, or when the user names CSharpier, dotnet format, Roslynator, editorconfig, analyzer, AnalysisLevel, or NoWarn. Companions: csharp (the conventions this enforces), dotnet-project-setup (Directory.Build.props), dotnet-security (CA3xxx/CA5xxx rules), dotnet-migrate (analyzer churn on upgrades). Do NOT load for authoring Roslyn analyzers/source generators (dotnet-source-generators) or test-suite quality (dotnet-testing).

0
installs
▌
Dotnet Console Apps · envoydev bundle
Conventions for the console app's interface surface - what a .NET console binary IS to the outside world, on top of the generic host that runs it. Two shapes: a one-shot CLI tool (System.CommandLine 2.0 / Spectre.Console.Cli / Cocona, subcommands, exit codes) and a long-running gateway bot or consumer (Telegram.Bot, Discord.Net, SlackNet, CryptoExchange.Net, broker queue-workers) run inside a BackgroundService. Floors at .NET 8 / C# 12. Load when building a CLI tool, a chat or trading bot, or a bot's command surface, or when the user names System.CommandLine, Spectre.Console, Telegram.Bot, Discord.Net, or a bot. Companions: dotnet-hosted-services (host lifecycle + 24/7 hardening), dotnet-messaging, csharp, dotnet-testing. Do NOT load for the host lifecycle itself (dotnet-hosted-services), a web API or webhook endpoint (dotnet-web-backend), or a desktop GUI (dotnet-wpf).

0
installs
▌
Dotnet Cryptography · envoydev bundle
.NET cryptography conventions for System.Security.Cryptography - pick the right primitive and use it the one correct way: SHA-2 for integrity, AES-GCM for authenticated encryption, RSA-OAEP/PSS and ECDsa for asymmetric work, PBKDF2 or Argon2id for password hashing, RandomNumberGenerator for entropy, and FixedTimeEquals for any secret comparison. Carries the dead-algorithm list and notes post-quantum ML-KEM/ML-DSA as a .NET 10+ opt-in. Floors at .NET 8 / C# 12. Load when encrypting, decrypting, hashing, signing, verifying, or deriving a key. Secret STORAGE belongs to your secrets/config layer (never source); sign-in to dotnet-authentication; OWASP categories to dotnet-security. Do NOT load for TLS/HTTPS pipeline config.

0
installs
▌
Project Implementer · envoydev
Use when you have a task plan in hand - from project-solution-design, ideally gated by project-verify-plan - and want to BUILD it in the current chat, task by task: the single-chat form of the implementer seat's execution protocol. Honors each task's contract, builds code + tests per task, gates each task green before the next, resolves every red INLINE (in this chat, dispatching nothing), and hands to the build review (`project-verify-code` inline or the `<stack>-verifier` seat) + the done-gate. Trigger on execute the plan, build the plan, implement the tasks, build task 2, continue the plan. On an agents answer (the run-start ask, or the calling flow's recorded mode) it hands each task to its `<stack>-implementer` seat instead (up to 3 at once, each on its frontmatter model unless you name one); the full multi-agent flow with its own designer and verifier is project-solve-cross-task. Not a plan-less ad-hoc edit - just make that.

0
installs
▌
Project Verify Code · envoydev
Use when a build is assembled and you want to review it in THIS chat with no dispatch - the single-chat, no-agents form of the verifier seat, and the inline alternative to /code-review's fan-out. Loads the stack's trap-list skills, reruns build + tests, gates the code against its plan, RUNS the app on failable inputs (a test can pass under WebApplicationFactory while the live endpoint 500s), traces a changed wire contract to its consumers, and returns a ranked punch-list - all inline, dispatching nothing. Trigger on review the build, review this here, check the code without agents, review before done, verify the build. Not the plan audit (project-verify-plan, before code), not the dispatched verifier seat or /code-review's parallel angles - this is the review you run without spawning anything.

0
installs
▌
Project Verify Plan · envoydev
Use when you have an implementation plan or design in hand and want to audit it BEFORE writing code - a risk-coverage review that checks the plan names the non-obvious traps its stack will actually hit, matches the requirement's scope, covers the edge and safety cases, and stays minimal. The cheapest place to catch a design error, since a flawed plan built perfectly is still wrong. Pairs with writing-plans (which creates the plan) and precedes project-verify-code (which reviews the built code). Trigger on review this plan, is this design sound, does the plan miss anything, before I build.

0
installs
▌
Database Conventions · envoydev bundle
database conventions across Postgres, SQL Server/T-SQL, SQLite, and MongoDB - the engine-neutral rules for schema design, migrations, indexes, foreign keys, transactions, connection management, query safety, N+1 prevention, and secret handling, plus the per-engine pitfalls that bite. Load before designing or modifying a schema, writing SQL raw or through an ORM, modeling a document store, or creating a migration, view, procedure, or index. Deeper work routes out: engine tuning to `postgres` / `sqlite`, .NET data access to `dotnet-data-access`, migration mechanics to `dotnet-migrate`, security posture to `database-security`. Do NOT load for app-only in-memory data structures or a project with no persistence layer.

0
installs
▌
Dotnet Project Setup · envoydev bundle
Set up a new .NET solution's build spine - the canonical src / tests / .config layout, .slnx solution files, Directory.Build.props shared build properties, global.json SDK pinning + rollForward, central package management via Directory.Packages.props, and pinning a dotnet tool in .config/dotnet-tools.json. Load to set up a new .NET solution, add a NuGet package, add a project, or pin a dotnet tool; trigger files .slnx, Directory.Build.props, Directory.Packages.props, global.json, .config/dotnet-tools.json. Companions, where the project installed them: the .NET router, the .NET analyzer/quality-gate skill, the CI-and-deploy skill; schema and version migrations belong to the EF migration skill. Do NOT load for analyzers / TreatWarningsAsErrors / .editorconfig (the .NET quality-gate skill) or CI workflows / packaging / SourceLink (the CI-and-deploy skill).

0
installs
▌
Project Quality Loop · envoydev bundle
Autonomous review-and-fix pipeline driven from a folder of numbered prompt files (the `<docs-path>/loops/` folder of fix-discipline / structure / code-quality / naming / logging / comments). Runs each prompt in numeric order, looping it on a target until its bar is met, then advances - making and logging judgment calls itself, pausing only at the run-start mode ask and each stage-close fresh-session ask. Triggers on 'run the project quality loop' or 'run the loops pipeline'. Code-quality only - architecture restructuring is project-architecture-quality-loop; measuring or raising test coverage is the project-test-coverage-analyzer/-loop pair; a single diff sweep is project-verify-code or /security-review, not this. Do NOT fire for a one-off review pass or when findings should be reported without auto-fixing (a missing or empty loops folder is no blocker - the skill seeds it from a bundled starter set to bootstrap; a folder of custom prompts is the user's, never overwritten).

0
installs
▌
Dotnet Authentication · envoydev bundle
ASP.NET Core auth conventions covering both halves - authentication (who the caller is) and authorization (what they may do). Pick the scheme by surface: JWT bearer for stateless APIs, cookies for server-rendered apps, OpenID Connect for delegated SSO. Validate every token field, lean on ASP.NET Identity as the user store, and gate access with named policies and authorization handlers rather than scattered role strings. Floors at .NET 8 / C# 12. Load before standing up a sign-in flow, wiring JWT or OIDC, writing an authorization policy, or protecting an endpoint. Companions: csharp, dotnet-minimal-api, dotnet-web-backend, dotnet-cryptography, dotnet-security. Do NOT load for the OWASP hardening sweep or secret placement (dotnet-security) or crypto primitives (dotnet-cryptography).

0
installs
▌
Csharp Design Patterns · envoydev bundle
Apply GoF design patterns idiomatically in C#/.NET. Use whenever the user asks to implement, choose, explain, or compare a design pattern in C#, refactor toward a pattern, review for pattern misuse, asks 'which pattern fits this problem' - or describes a recurring design problem (object creation sprawl, switch-on-type logic, tight coupling, notification chains, undo/redo, plugin architecture) without naming a pattern. Covers all 23 GoF patterns with modern .NET 8+ idioms; pair with `csharp` for output style. Do NOT use for architectural patterns (repository, unit of work, CQRS, event sourcing, layering) - those route via `dotnet` to `dotnet-architecture`.

0
installs
▌
Dotnet Hosted Services · envoydev bundle
.NET hosted-service and worker conventions - the long-running background work the generic host runs. Covers the host shapes (worker binary, in-web-app task, Windows Service), IHostedService versus BackgroundService versus IHostedLifecycleService, the ExecuteAsync exception trap, scoped services from the singleton host, PeriodicTimer over Task.Delay, graceful shutdown, and System.Threading.Channels queues - plus references/ for 24/7 I/O hardening, scheduling/leader election, deployment/signals. Floors at .NET 8 / C# 12. Load when writing a worker service, BackgroundService or IHostedService, a periodic job, a bot/daemon host, or any in-process background task hung off the host. Companions: dotnet-messaging, dotnet-web-backend, csharp. Do NOT load for the broker side of a consumer (dotnet-messaging; the consumer's host process is still this skill), HTTP endpoints, or reactive in-memory streams.

0
installs
▌
Dotnet Mvc Controllers · envoydev bundle
ASP.NET Core controller-based Web API mechanics - the mainstream, brownfield alternative to minimal APIs. Covers the ApiController attribute, attribute routing, ActionResult of T versus IActionResult versus typed HttpResults, suppressing the automatic 400 filter (ApiBehaviorOptions, SuppressModelStateInvalidFilter) for the house FluentValidation-in-a-filter convention, binding-source inference and explicit From-attributes, IAsyncActionFilter ordering, and thin controllers delegating to services. Floors at .NET 8 / C# 12; 9/10 deltas flagged optional. Load before writing or editing API controllers and action filters. Companions: dotnet-minimal-api, dotnet-web-backend, dotnet-web-error-handling, dotnet-authentication. Do NOT load for minimal APIs, MVC views, Razor Pages, gRPC, SignalR, or non-HTTP code.

0
installs
▌
Dotnet Windows Service · envoydev bundle
Windows Service conventions - the Service Control Manager layer over the .NET generic host: AddWindowsService and the dual-mode binary, SCM start/stop budgets, non-zero exit codes so recovery actions actually fire, the System32 working-directory trap, scripted sc.exe install with recovery actions, gMSA / least-privilege service accounts, unquoted-path and ACL hardening, event-log source registration, and the maintained .NET Framework ServiceBase shape + migration path. Load when building, installing, hardening, or migrating a Windows Service - AddWindowsService / UseWindowsService, sc.exe, ServiceBase, installutil, service accounts, SCM errors like 1053. Companions: dotnet-hosted-services (the host model this stacks on), csharp. Do NOT load for the generic worker/host model itself with no SCM target (dotnet-hosted-services), Linux daemons/systemd, or containerized workers.

0
installs
▌
Project Related Context · envoydev
The deliberate related-projects capture: given paths or git URLs to sibling repos, fan out related-project-analyzer agents (one per sibling, parallel) and write BOTH tiers from their entries - the always-on awareness rule .claude/rules/baseline-project-related-context.md (lean name / location / relation / seam per sibling) and <docs-path>/related-context/PROJECT-RELATED-CONTEXT.md (the on-demand orientation doc; its related-context/ folder is the one home for ALL sibling-repo docs - cross-repo plans, change requests, run recipes). Re-run to refresh: entries upserted per passed sibling, unlisted entries kept. Args-driven - it analyzes the locations you name, it never scans for siblings. Triggers on 'capture the related projects' or 'map the sibling repos'. NOT for this repo's own architecture (project-architecture-analyzer) or dynamic cross-repo findings (the memory MCP).

0
installs
▌
Project Solution Design · envoydev
Use when you have a feature or change to build in a single chat and want to settle how it fits the existing code before writing any - the single-chat form of the solution-designer seat - orient, judge the fit, decompose into an ordered minimal plan. Trigger on analyse how to integrate this, how does this fit, design this feature, where does this belong, break this into tasks, plan this change. Not for a one-line edit; not the multi-agent flow with its own verifier and fan-out (that is project-solve-cross-task) - in-session it keeps the whole design in your context so you check each step; the run-start ask (or your named mode) decides the designer seat.

0
installs
▌
Project Version Upgrade · envoydev bundle
The deliberate version-upgrade flow for any BREAKING version event - a framework or runtime major, an EOL, a load-bearing package's breaking major: plan in-session (the published breaking-change surface crossed against located usage - applicable changes only), present the staged plan at an approval gate, then drive the execution stage by stage with a green gate after every stage. Auto mode - skipping the approval gate - runs ONLY when the user explicitly asked for it. Routine non-breaking bumps need no skill: just bump. Triggers on 'upgrade to .NET 10', 'ng update to v20', 'this package's new major breaks us', 'plan the framework upgrade'. NOT for a feature that merely needs a newer package (the feature's own flow), or a red CI pipeline (ci-failure-diagnoser, or its single-chat twin project-ci-failure-signatures).

0
installs
▌
Dotnet Source Generators · envoydev bundle
Roslyn source-generator conventions, both sides of the line - reaching first for the framework generators that exist (GeneratedRegex, LoggerMessage, the System.Text.Json context) and authoring your own only when none fits; the authoring mechanics live in references/authoring.md. Floors at .NET 8 / C# 12. Load when writing or reviewing a generator, weighing compile-time codegen against reflection, or when the user says source generator, IIncrementalGenerator, ISourceGenerator, GeneratedRegex, LoggerMessage, or ForAttributeWithMetadataName. Companions: csharp for the generator's language style, dotnet-testing for test setup. Do NOT load for ordinary code that ships no generator.

0
installs
▌
Project Diagnose Failure · envoydev
Use to investigate a failure of any kind in THIS chat, from whatever evidence you actually have - a pasted Sentry event, one log file, several log sources at once, a red CI run, a stack trace, a screenshot, or nothing but a customer saying checkout is slow. Four gated steps: triage the evidence to a tier, gather (inline or evidence-gatherer seats), prove the root cause, then a user fork - write a report, plan the fix as contracted tasks, or add log points and re-run. Read-only throughout: it never writes the fix. Trigger on investigate this bug, diagnose this failure, what is causing this, look into this incident, triage this report. Not the fix build (project-solve-task takes the tasks from here), not a signature lookup you already have the answer for.

0
installs
▌
Project Solve Cross Task · envoydev bundle
The entry-point router for multi-agent engineering work - scope the task IN-SESSION (the generated awareness rules + a bounded serena pass), then ask session-or-agents up front (an invocation naming the mode is the answer) and route to the smallest safe execution mode: single-chat, one implementer, a single-stack design-build-verify trio, or a producer-first cross-domain run (dispatch recommended in the ask) where the producer designer's interface IS the contract and the integration-reviewer gates the assembled feature. Triggers on how should I build or route this work, plan the agents for this, this spans backend and frontend, or investigate-and-fix a bug across the stack; name the stack in the ask ('frontend only', 'just the API') to pin routing straight to it. This skill scopes and routes - it never designs or writes code, and it runs in the MAIN session only: a dispatched seat never re-fires it, its brief already carries its slice of the flow. NOT for greenfield (project-build-from-scratch) or a deliberat

0
installs
▌
Dotnet Architecture Tests · envoydev
.NET conventions for architecture fitness tests - encoding layer/dependency/naming/isolation rules as tests that fail the build on a violation, so the structure dotnet-architecture prescribes cannot erode silently. Floors at .NET 8 / C# 12. Load when adding or reviewing architecture / fitness tests or enforcing layer/dependency rules, or when the user names NetArchTest, ArchUnitNET, fitness function, architecture test, or dependency rule. Companions: dotnet-testing (the test-suite host), dotnet-architecture (the boundaries enforced), dotnet-code-quality (the analyzer/style counterpart). Do NOT load for runtime behavior tests (dotnet-testing) or analyzer/formatter config (dotnet-code-quality).

0
installs
▌
Dotnet Web Error Handling · envoydev
ASP.NET Core error-handling conventions - keep the two failure channels apart (Result/typed errors for expected outcomes, exceptions caught once for the genuinely unexpected), surface everything as RFC 9457 ProblemDetails, centralize one error-to-status map, install a global IExceptionHandler (.NET 8+), and validate input in an endpoint filter with FluentValidation. Floors at .NET 8 / C# 12. Load before deciding how an API reports failures, adding a global handler, shaping error bodies, or wiring request validation, or when the user says ProblemDetails, IExceptionHandler, UseExceptionHandler, Result type, or error envelope. Companions: csharp (the throw-vs-return baseline), dotnet-minimal-api, dotnet-web-backend. Do NOT load for non-HTTP code - model expected failures with the Result half in csharp instead.

0
installs
▌
Project Agent Capabilities · envoydev
The deliberate capabilities capture: inventory what THIS project actually has installed - the slash-only orchestration skills (from .claude/skills frontmatter), the subagent seats (.claude/agents), the MCP servers (.mcp.json), the plugins (best-effort) - and generate the always-on awareness rule .claude/rules/baseline-project-agent-capabilities.md: the fixed house usage policy plus the real inventory, never an assumed stack. Re-run after an install, a stack update, or a manifest trim - the rule is regenerated wholesale. Manual, /-only. Triggers on 'capture the project capabilities', 'refresh the capabilities rule', 'what does this project have installed'. NOT for capturing architecture (project-architecture-analyzer), code style (project-code-style-analyzer), or siblings (project-related-context).

0
installs
▌
Project Build From Scratch · envoydev bundle
Build a new application or major module from scratch - greenfield design, scaffolding, and build orchestration, before code exists. DESIGN runs IN-SESSION on this skill's opus/xhigh pinned turn: the spec becomes 2-3 reasoned architecture options and the user picks - nothing is scaffolded before that pick. Then the stack's real new-project command + baseline wiring, then the build slice by slice - through the domain seats or in-session, per the run-start ask. Not for changing an existing codebase - a feature inside a live app is `project-solve-cross-task`, a new module in an existing repo is the project-architecture-analyzer capture plus that stack's solution-designer. Triggers on build from scratch, new project, greenfield, scaffold, start a new app.

0
installs
▌
Project Test Coverage Loop · envoydev bundle
The deliberate coverage analyze-triage-fix loop. Runs the project-test-coverage-analyzer capture, works COVERAGE.md's weak points by tier - missing tests as scoped implementer briefs, testability refactors designer-led with plan approval first, structural gaps flagged for a user decision and never auto-applied, 'no test infrastructure' as the first substantial fix - re-runs the capture to reconcile the docs, and loops until the requirement holds or the loop plateaus. Manual, /-only. Triggers on 'run the test coverage loop' or 'raise the test coverage'. NOT for a measure-only run with no fixes (/project-test-coverage-analyzer alone), a code-quality polish (project-quality-loop), or architecture weaknesses (project-architecture-quality-loop).

0
installs
▌
Project Code Style Analyzer · envoydev bundle
The deliberate project code-style capture: fan out code-style-analyzer agents (one per detected language), merge their reports into <docs-path>/PROJECT-CODE-STYLE.md, and generate the path-scoped project-code-style rule that auto-attaches the style core whenever a matching file is touched - in the main session AND in dispatched subagents. Re-run to refresh: the same analysis, the doc reconciles in place, the rule regenerates from the fresh reports. Manual, /-only. Triggers on 'capture the project code style' or 'set up the code-style doc and rule'. NOT for architecture (project-architecture-analyzer), one language's style question (@agent-code-style-analyzer alone), or enforcing style (the per-language configs stay the enforced source).

0
installs
▌
Project Stack Usage Analyzer · envoydev
Token/tool usage audit of claude-stack skill runs in THIS project: finds EVERY session transcript with a stack-skill run (or the SESSIONS named), runs the stack's analyze-usage.js over each, and writes a per-session report (tokens, tool calls, waste, protocol check, verdict) plus the raw data for a follow-up agent - and a cross-session SUMMARY.md when several sessions are audited. Manual, /-only. Triggers on 'analyze the stack usage', 'usage report for the skill runs', 'audit all sessions for this project', 'how many tokens did the flow burn'. NOT for live session cost (claude-hud shows that), fixing the findings (route them to the owning skill), or benchmarking model choices.

0
installs
▌
Project Architecture Analyzer · envoydev bundle
The deliberate architecture capture: on a FIRST capture dispatch architecture-analyzer per module (the cheap read-only characterizer) - an UPDATE reconciles inline over the git diff - reason over the digests IN-SESSION - declared vs enforced structure, the stack-keyed hazards, strengths and weaknesses - and write <docs-path>/architecture/ARCHITECTURE.md, <docs-path>/architecture/ASSESSMENT.md, and the generated always-on awareness rule .claude/rules/baseline-project-architecture.md. Re-run to refresh: all three artifacts reconciled in place. Deliberate-only - run via / or as project-architecture-quality-loop's ANALYZE step, never mid-build. Triggers on 'capture the architecture' or 'refresh the architecture docs'. NOT for fixing the weaknesses it finds (project-architecture-quality-loop runs this capture first), one module's characterization (@agent-architecture-analyzer), code style (project-code-style-analyzer), or test-suite/coverage weaknesses (project-test-coverage-analyzer - the assessment keeps only st

0
installs
▌
Project CI Failure Signatures · envoydev
Use when a CI pipeline or PR check goes red and you want to triage it yourself in the current chat - match the failure to a signature, make the call between a real code defect CI surfaced first and an environment / pin / config / workflow failure that never touched the code, and route it. The single-chat form of the ci-failure-diagnoser seat. Trigger on red CI, PR check failing, passes locally but fails in CI, NU1301, ERESOLVE, exit 137, workflow YAML broke, flaky pipeline. Not a crash on your own machine (that is project-runtime-failure-signatures), not authoring CI/CD (that is devops).

0
installs
▌
Project Test Coverage Analyzer · envoydev
The deliberate test-coverage capture: detect each stack's test-and-coverage tooling, run the instrumented suite ONCE per surface in the main session, analyze per surface (seats on a first capture, inline on an update), and judge against the USER's % bar - asked at first capture, recorded in the doc - writing <docs-path>/test-coverage/COVERAGE.md (verdicts, per-module data, weak points tiered small/substantial/structural with a simplify-testing action each) plus the raw results under raw/. Re-run to refresh: both reconciled in place. Triggers on 'measure the test coverage', 'capture the coverage baseline', or 'how covered is this project'. Manual, /-only - or Read-loaded as project-test-coverage-loop's ANALYZE step; never mid-build, never a flow gate. NOT for fixing the gaps it finds (project-test-coverage-loop), writing a task's tests (every build flow's own done bar), or architecture capture (project-architecture-analyzer).

0
installs
▌
Project Architecture Quality Loop · envoydev bundle
The deliberate architecture analyze-assess-improve loop. Runs the project-architecture-analyzer capture, works the ASSESSMENT's weaknesses by tier - small to a domain implementer, substantial through a designer -> implementers -> verifier (plan approved first), structural flagged for a user decision and never auto-applied - prunes the fixed weaknesses from the ASSESSMENT itself (one capture reconcile at stop, not per round), and loops until the fixable cons resolve or plateau. Manual, /-only. Triggers on 'run the architecture quality loop' or 'analyze and improve the architecture'. NOT for a code-quality polish (project-quality-loop), a single feature build (project-solve-cross-task), or a capture-only run with no fixes (/project-architecture-analyzer alone).

0
installs
▌
Project Runtime Failure Signatures · envoydev
Use when something breaks at runtime on your own machine and you have the evidence - a stack trace, an exception, a hang, or a broken screen - and want to know where the real cause lives. A lookup of the common local-runtime failure signatures, each mapped to where to isolate it - usually not the line that threw. The single-chat form of the diagnoser seat's failure catalogue; pairs with the systematic-debugging method. NOT for a CI or build/test-gate failure (the resolvers and ci-failure-diagnoser own those) or a production incident - local-runtime evidence only. Keywords NullReferenceException, Cannot read properties of undefined, Unable to resolve service, NG0201 No provider, ObjectDisposedException, deadlock, hang, IndexOutOfRangeException, 401, 403, config drift.

0
installs

79 published skills