@fprad0/skill-master-mcp 0.0.11 → 1.0.0

package/docs/skill-candidates/v0.0.12/csharp-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: csharp-senior-master-engineering
+description: "Senior master C# and .NET engineering for clean, fast, secure and maintainable C# applications, ASP.NET Core services, CLIs, libraries, data access and background workers. Use when writing, organizing, refactoring, optimizing, testing or hardening C# code."
+---
+
+# C# Senior Master Engineering
+
+Use this skill for C# and .NET work with production-grade expectations.
+
+## Workflow
+
+- Inspect solution structure, target framework, project files, dependency injection, configuration and test projects.
+- Keep domain logic separate from controllers, transport, persistence and infrastructure.
+- Use nullable reference types, async/await, cancellation tokens and dependency lifetimes deliberately.
+- Prefer simple services and explicit models before complex inheritance or reflection.
+- Validate with `dotnet test`, `dotnet build`, analyzers or targeted smoke execution.
+
+## Optimization Rules
+
+- Avoid sync-over-async, unnecessary allocations, repeated serialization, N+1 data access and overbroad service lifetimes.
+- Use spans, pooling or low-level optimizations only when profiling or hot path evidence supports them.
+- Keep LINQ readable and check generated database behavior when using ORMs.
+
+## Security Rules
+
+- Validate request/input boundaries, preserve auth/authorization, avoid injection and protect secrets in configuration.
+- Use parameterized queries and safe serializers.
+- Keep logging useful without exposing tokens, passwords or personal data.
+
+## Completion Standard
+
+- State behavior, validation, performance reasoning and remaining operational risks.

package/docs/skill-candidates/v0.0.12/css-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: css-senior-master-engineering
+description: "Senior master CSS engineering for layout, responsive behavior, design systems, performance, accessibility and maintainable styling. Use when writing, organizing, refactoring, optimizing or hardening CSS, SCSS, modules, utility styles or component styling."
+---
+
+# CSS Senior Master Engineering
+
+Use this skill when styling must remain responsive, maintainable and efficient.
+
+## Workflow
+
+- Inspect the styling model: global CSS, modules, utility classes, CSS-in-JS, tokens or design system.
+- Fix layout structure before adding decorative overrides.
+- Use stable sizing constraints, logical properties, container-aware layouts and accessible focus states.
+- Keep selectors predictable and avoid specificity escalation.
+- Validate in relevant viewport sizes and interaction states.
+
+## Optimization Rules
+
+- Remove duplicate declarations, dead selectors, overbroad transitions and layout thrashing triggers.
+- Prefer CSS variables and tokens for repeated design decisions.
+- Avoid one-off hacks when a reusable component or layout primitive is clearer.
+
+## Security Rules
+
+- Avoid rendering untrusted content into CSS values.
+- Do not use remote assets or fonts without considering privacy, reliability and CSP.
+- Keep hidden content and focus order accessible.
+
+## Completion Standard
+
+- State layout impact, responsive behavior and validation evidence.

package/docs/skill-candidates/v0.0.12/go-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: go-senior-master-engineering
+description: "Senior master Go engineering for clean package design, services, CLIs, concurrency, performance, security and maintainability. Use when writing, refactoring, organizing, testing or hardening Go code, APIs, workers or command-line tools."
+---
+
+# Go Senior Master Engineering
+
+Use this skill for Go work that must be simple, explicit and reliable.
+
+## Workflow
+
+- Inspect `go.mod`, package boundaries, commands, tests and runtime entrypoints.
+- Keep errors wrapped with context and returned deliberately.
+- Treat `context.Context`, goroutine lifecycle, channels and cancellation as design concerns.
+- Prefer concrete types until an interface removes real coupling.
+- Validate with `go test ./...`, `go test -race` when concurrency changed, `go vet` or targeted command execution.
+
+## Optimization Rules
+
+- Avoid unnecessary allocations, reflection, global state, goroutine leaks and repeated network/database work.
+- Keep packages small and cohesive; avoid deep folder taxonomies.
+- Use benchmarks only when performance claims matter.
+
+## Security Rules
+
+- Validate external input, file paths, HTTP parameters and SQL arguments.
+- Avoid command injection, unsafe temporary files and silent auth failures.
+- Keep timeouts and cancellation explicit around external calls.
+
+## Completion Standard
+
+- Explain validation run, concurrency assumptions and operational risks.

package/docs/skill-candidates/v0.0.12/html-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: html-senior-master-engineering
+description: "Senior master HTML engineering for semantic structure, accessibility, forms, metadata, SEO-safe markup, security and maintainability. Use when writing, organizing, refactoring, validating or hardening HTML documents, templates, components or generated markup."
+---
+
+# HTML Senior Master Engineering
+
+Use this skill when markup structure determines usability, accessibility or integration quality.
+
+## Workflow
+
+- Inspect the document, template system, framework and generated output path.
+- Prefer semantic elements, clear heading order, labels, landmarks and valid nesting.
+- Keep forms explicit: labels, names, autocomplete, validation messages and error associations.
+- Preserve existing component conventions and server/client rendering assumptions.
+- Validate with browser inspection, accessibility checks, tests or generated markup review when available.
+
+## Optimization Rules
+
+- Remove redundant wrapper elements, inaccessible clickable divs and invalid nesting.
+- Keep markup readable and stable for styling and automation selectors.
+- Avoid text or layout structures that break on small screens.
+
+## Security Rules
+
+- Escape untrusted text and attributes.
+- Avoid unsafe inline script/style injection.
+- Treat links, forms and embedded content as trust boundaries.
+
+## Completion Standard
+
+- State semantic, accessibility and validation impact.

package/docs/skill-candidates/v0.0.12/javascript-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: javascript-senior-master-engineering
+description: "Senior master JavaScript and Node.js engineering for clean runtime behavior, async correctness, performance, security and maintainability. Use when writing, organizing, refactoring, optimizing, testing or hardening JavaScript in browser, Node.js, workers or tooling."
+---
+
+# JavaScript Senior Master Engineering
+
+Use this skill for JavaScript work where runtime behavior matters more than type-level design.
+
+## Workflow
+
+- Identify runtime first: browser, Node.js, worker, edge, CLI or test harness.
+- Inspect `package.json`, module mode, bundler/test setup and current style.
+- Keep async flows explicit: promises, retries, cancellation, streams, events and shutdown paths.
+- Separate domain logic from transport, DOM, filesystem, database and process boundaries.
+- Validate with existing one-shot scripts, tests, build or direct execution.
+
+## Optimization Rules
+
+- Remove avoidable promise waterfalls, duplicated serialization, repeated DOM queries, needless deep cloning and unused dependencies.
+- Avoid hidden shared mutable state unless lifecycle is clear.
+- Prefer platform APIs and existing utilities over new dependencies.
+
+## Security Rules
+
+- Avoid `eval`, unsafe HTML injection, unsafe shell composition and unvalidated JSON or URL input.
+- Keep secrets out of client bundles, logs and error surfaces.
+- Preserve CORS, auth, CSRF and permission boundaries.
+
+## Completion Standard
+
+- Report behavior, validation and compatibility risks plainly.

package/docs/skill-candidates/v0.0.12/json-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: json-senior-master-engineering
+description: "Senior master JSON contract engineering for schemas, API payloads, config files, events, validation, compatibility, naming and integration safety. Use when designing, refactoring, validating or hardening JSON structures and machine-readable contracts."
+---
+
+# JSON Senior Master Engineering
+
+Use this skill for JSON contracts where compatibility and validation matter.
+
+## Workflow
+
+- Identify producers, consumers, versioning expectations and failure behavior.
+- Define required, optional, nullable and deprecated fields explicitly.
+- Keep names, casing, enum values, timestamps and identifiers consistent.
+- Prefer JSON Schema or runtime validation where payloads cross trust boundaries.
+- Validate with realistic examples, edge cases and backwards compatibility checks.
+
+## Optimization Rules
+
+- Remove redundant nesting, ambiguous duplicate fields and oversized payload fragments.
+- Keep config files readable and stable for diffs.
+- Avoid schemas that are stricter than the real producer or looser than the consumer can handle.
+
+## Security Rules
+
+- Reject unexpected fields when trust boundaries require it.
+- Do not accept unsafe URLs, paths, commands or serialized code through JSON.
+- Avoid leaking secrets in examples and fixtures.
+
+## Completion Standard
+
+- State compatibility impact, schema behavior and validation examples.

package/docs/skill-candidates/v0.0.12/prompt-budget-gate/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: prompt-budget-gate
+description: "Run a preflight budget check before sending a large prompt. Use when a task includes long context, many files, logs, screenshots, docs, tool schemas, or when the user asks for token savings."
+---
+
+# Prompt Budget Gate
+
+Use this skill before expensive prompts.
+
+## Preflight Checklist
+
+- Objective in one sentence.
+- Required output format.
+- Risk level.
+- Maximum useful answer length.
+- Required files or source URLs.
+- Context that can be referenced by path instead of pasted.
+- Logs that can be summarized.
+- Repeated instructions that belong in a skill/rule file.
+- Tools that are necessary for this turn.
+
+## Budget Recommendations
+
+- Tiny task: one paragraph answer, no extra research.
+- Normal coding task: targeted reads, concise summary, tests only when useful.
+- Research task: official sources first, short synthesis, source list.
+- Handoff task: create `.md` artifact instead of filling chat.
+- High-risk task: preserve evidence; economy is secondary.
+
+## Output Template
+
+```text
+Token budget mode: light | balanced | aggressive
+Context to keep:
+Context to drop/summarize:
+Files/sources to inspect:
+Expected answer size:
+Risk notes:
+```
+
+## Guardrails
+
+- Do not block the user for tiny tasks.
+- Do not ask for clarification when a safe assumption is obvious.
+- Do not estimate provider-specific token counts as exact unless using the provider tokenizer/API.
+- Do not store secrets or private content in summaries.

package/docs/skill-candidates/v0.0.12/python-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: python-senior-master-engineering
+description: "Senior master Python engineering for clean, fast, secure and maintainable Python services, CLIs, scripts, APIs, automation, packages and data workflows. Use when writing, refactoring, organizing, typing, optimizing, testing or hardening Python code."
+---
+
+# Python Senior Master Engineering
+
+Use this skill for Python work that needs production-grade clarity and safety.
+
+## Workflow
+
+- Inspect runtime version, dependency manager, entrypoints, package layout and test commands.
+- Keep imports, I/O, environment reads, file access, subprocess calls and network calls explicit.
+- Use type hints where they clarify contracts; avoid type noise inside obvious local code.
+- Prefer standard library tools unless a dependency is already established or clearly justified.
+- Validate with focused tests, direct script execution, `pytest`, type checks or package build when available.
+
+## Optimization Rules
+
+- Remove unnecessary loops, repeated I/O, repeated parsing, hidden global state and expensive work at import time.
+- Use generators, streaming or batching where data size makes it useful.
+- Keep error handling precise; never hide import/runtime failures behind broad `except`.
+
+## Security Rules
+
+- Validate untrusted input, file paths, JSON, YAML, subprocess args and database parameters.
+- Avoid shell interpolation, unsafe pickle use and logging secrets.
+- Keep permissions, tokens and environment assumptions visible.
+
+## Completion Standard
+
+- State what was validated and what runtime assumptions remain.

package/docs/skill-candidates/v0.0.12/react-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: react-senior-master-engineering
+description: "Senior master React engineering for component architecture, rendering performance, state design, accessibility, security and maintainability. Use when writing, organizing, refactoring, optimizing, testing or hardening React components, hooks, pages and UI systems."
+---
+
+# React Senior Master Engineering
+
+Use this skill for React code that must be ergonomic, fast and predictable.
+
+## Workflow
+
+- Inspect framework, React version, routing, state model, component system and test setup.
+- Keep rendering data flow explicit: props, state, effects, server/client boundaries and async loading.
+- Prefer composition over prop drilling and avoid global state unless the shared lifecycle is real.
+- Preserve existing design-system conventions.
+- Validate with typecheck, tests, build and browser or Playwright checks when UI behavior changed.
+
+## Optimization Rules
+
+- Fix unnecessary re-renders by improving state shape, component boundaries and derived data flow before adding memoization.
+- Avoid effects for pure derivation; keep side effects idempotent and cleanup-safe.
+- Use `useDeferredValue`, transitions or framework-native data loading only when they match the user experience.
+
+## Security Rules
+
+- Avoid unsafe HTML injection and untrusted URL rendering.
+- Preserve auth, route guards, CSRF assumptions and server/client data boundaries.
+- Keep secrets out of client bundles.
+
+## Completion Standard
+
+- State UI behavior changed, accessibility impact, render/performance reasoning and validation evidence.

package/docs/skill-candidates/v0.0.12/ruby-senior-master-engineering/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: ruby-senior-master-engineering
+description: "Senior master Ruby engineering for clean, expressive, secure and maintainable Ruby scripts, gems, CLIs, services and Rails-adjacent code. Use when writing, organizing, refactoring, optimizing, testing or hardening Ruby code."
+---
+
+# Ruby Senior Master Engineering
+
+Use this skill for Ruby work that needs clear behavior and runtime safety.
+
+## Workflow
+
+- Inspect Ruby version, Gemfile, entrypoints, tests and app style first.
+- Preserve idiomatic Ruby readability without hiding behavior behind excessive metaprogramming.
+- Keep side effects, filesystem access, shell calls, network calls and database calls isolated.
+- Prefer small objects or functions when they reduce coupling; avoid ceremony for small scripts.
+- Validate with existing tests, `bundle exec`, direct CLI execution or targeted smoke checks.
+
+## Optimization Rules
+
+- Remove repeated queries, repeated parsing, hidden global mutation and unnecessary gem additions.
+- Keep allocation-heavy loops and string building intentional in hot paths.
+- Match project style instead of importing patterns from other ecosystems.
+
+## Security Rules
+
+- Validate file paths, shell args, params and serialized data.
+- Avoid unsafe `eval`, unsafe YAML loading and shell interpolation.
+- Keep secrets out of logs and exceptions.
+
+## Completion Standard
+
+- Report behavior, runtime version assumptions and validation evidence.

package/docs/skill-candidates/v0.0.12/senior-master-code-optimizer/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: senior-master-code-optimizer
+description: "Senior master code optimization and hardening across languages. Use when asked to write, refactor, organize, simplify, speed up, secure, test, reduce complexity, or improve code quality in TypeScript, JavaScript, Python, Go, SQL, JSON, Ruby, React, HTML, CSS, C# or mixed systems."
+---
+
+# Senior Master Code Optimizer
+
+Use this skill as the general engineering gate before making broad code quality changes.
+
+## Operating Standard
+
+- Inspect the real project structure, entrypoints, dependency model, tests and conventions before editing.
+- Optimize for correctness first, then simplicity, then performance, then cleverness.
+- Remove accidental complexity: duplicated branches, needless wrappers, broad abstractions, dead code and unclear naming.
+- Keep behavior stable unless the user explicitly asked for behavior change.
+- Treat security as part of code quality: validate inputs, isolate side effects, avoid secret exposure and preserve auth boundaries.
+- Prefer smaller functions with explicit responsibilities, but do not split code into noisy fragments without a real readability or testability gain.
+- Validate with the narrowest trustworthy commands available: typecheck, lint, tests, build, query plan, smoke script or direct execution.
+
+## Language Routing
+
+- TypeScript: use `typescript-senior-master-engineering` with `typescript-expert` when type safety or build behavior matters.
+- JavaScript: use `javascript-senior-master-engineering` for runtime, async, Node.js or browser behavior.
+- Python: use `python-senior-master-engineering` for services, scripts, CLIs, APIs and automation.
+- Go: use `go-senior-master-engineering` for package design, concurrency, services and CLIs.
+- SQL: use `sql-senior-master-engineering` for schemas, queries, migrations and data integrity.
+- JSON: use `json-senior-master-engineering` for contracts, schemas, config and integration payloads.
+- Ruby: use `ruby-senior-master-engineering` for Ruby scripts, gems, services and Rails-adjacent code.
+- React: use `react-senior-master-engineering` for components, state, rendering, accessibility and frontend performance.
+- HTML: use `html-senior-master-engineering` for semantic markup, accessibility and document structure.
+- CSS: use `css-senior-master-engineering` for layout, responsive behavior, maintainable styling and performance.
+- C#: use `csharp-senior-master-engineering` for .NET, ASP.NET Core, services, CLIs and libraries.
+
+## Change Discipline
+
+- Start with the smallest coherent patch that resolves the issue.
+- Prefer project-native utilities, style and test commands over introducing new tools.
+- Avoid speculative rewrites. Refactor only where it reduces risk, duplication, latency, memory use or maintenance cost.
+- Keep public contracts stable unless migration is part of the task.
+- Explain residual risks plainly. Do not claim code is bug-free; report what was actually validated.
+
+## Review Checklist
+
+- Behavior: inputs, outputs, errors, edge cases and backwards compatibility remain clear.
+- Performance: avoid unnecessary allocations, repeated I/O, repeated parsing, N+1 queries and avoidable re-renders.
+- Security: sanitize boundaries, preserve permissions, avoid injection, avoid unsafe deserialization and never leak secrets.
+- Maintainability: names, modules, functions and tests make future changes easier.
+- Validation: one-shot checks passed or the reason they were not run is explicit.

package/docs/skill-candidates/v0.0.12/sql-senior-master-engineering/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: sql-senior-master-engineering
+description: "Senior master SQL engineering for schemas, queries, migrations, indexes, transactions, data integrity, performance and safety. Use when writing, reviewing, optimizing or hardening SQL, PostgreSQL, relational data access or database migrations."
+---
+
+# SQL Senior Master Engineering
+
+Use this skill for SQL and relational database work with production impact.
+
+## Workflow
+
+- Start from the real schema, data volume, access pattern and transaction path.
+- Separate read query tuning, write path cost, migration safety and data integrity concerns.
+- Prefer explicit constraints, keys and reversible migrations.
+- Validate with realistic samples, `EXPLAIN`, tests, migration dry-runs or smoke queries when available.
+
+## Optimization Rules
+
+- Check joins, filters, sort keys, indexes, N+1 access, lock scope and transaction duration.
+- Do not add indexes without explaining read benefit and write/storage cost.
+- Avoid query changes that alter cardinality or null semantics without proof.
+
+## Security Rules
+
+- Use parameters for untrusted values.
+- Avoid dynamic SQL unless identifiers are allowlisted and quoted safely.
+- Never run destructive data changes without explicit approval and rollback reasoning.
+
+## Completion Standard
+
+- State expected query behavior, migration risk and validation evidence.

package/docs/skill-candidates/v0.0.12/token-economy-orchestrator/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: token-economy-orchestrator
+description: "Orchestrate token-saving strategy before and during AI work across Codex, Claude, Gemini and Antigravity. Use when prompts are long, repetitive, multi-file, multi-agent, research-heavy, transfer-oriented, or when the user asks to economize tokens."
+---
+
+# Token Economy Orchestrator
+
+Use this skill to reduce token waste while preserving enough context to do the work correctly.
+
+## Decision Modes
+
+- `light`: remove repetition, ask for concise output, keep normal workflow.
+- `balanced`: run prompt preflight, define input/output budget, load only relevant files.
+- `aggressive`: create a compressed handoff and avoid raw logs/docs; use only with explicit or low-risk context.
+
+## Workflow
+
+1. Classify task risk: low, normal, high.
+2. Identify stable context that belongs in skills, project rules, AGENTS.md, CLAUDE.md, Gemini context files, or Antigravity rules/workflows.
+3. Identify volatile context that should stay in the current prompt only.
+4. Choose the smallest useful evidence set: paths, snippets, source links, commands and expected outputs.
+5. Prefer search and targeted reads over dumping whole files.
+6. Set output budget: short status, focused plan, implementation summary, or detailed research.
+7. Use `context-compression-handoff` before long transfers or phase changes.
+
+## Provider Notes
+
+- Codex/OpenAI: use project instructions and AGENTS.md for durable rules; rely on targeted file reads and concise final answers.
+- Claude/Anthropic: use prompt caching and token counting for large stable context; keep memory files factual and compact.
+- Gemini/Google: use token counting and context caching for repeated large inputs; control thinking budget when appropriate.
+- Antigravity: keep rules/workflows small and task-specific; use compact handoffs for cross-agent work.
+
+## Guardrails
+
+- Do not remove safety-critical context to save tokens.
+- Do not hide uncertainty caused by compression.
+- Do not use aggressive compression for legal, medical, financial, auth, release or destructive operations without confirmation.
+- Do not claim exact token savings unless measured by the provider tokenizer/API.

package/docs/skill-candidates/v0.0.12/typescript-senior-master-engineering/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: typescript-senior-master-engineering
+description: "Senior master TypeScript engineering for writing, organizing, refactoring, optimizing and securing TypeScript code, types, functions, modules, APIs, CLIs, frontend or backend systems. Use with typescript-expert for type safety, build correctness, performance and maintainability."
+---
+
+# TypeScript Senior Master Engineering
+
+Use this skill for TypeScript code that must be clean, fast, safe and maintainable.
+
+## Workflow
+
+- Read `package.json`, `tsconfig.json`, source layout, imports and existing scripts before editing.
+- Preserve the project's module style, path aliases, formatting and test strategy.
+- Model data with explicit types at boundaries and inference inside implementation details.
+- Prefer `unknown` plus validation over `any`; use `satisfies`, discriminated unions and branded types where they reduce real bugs.
+- Keep functions small enough to test and reason about, but avoid abstraction for its own sake.
+- Validate with `npm run typecheck`, `npx tsc --noEmit`, tests or build according to available scripts.
+
+## Optimization Rules
+
+- Remove duplicate branches, repeated parsing, repeated object creation in hot paths and avoidable async waterfalls.
+- Avoid deep generic machinery unless it protects a public API or removes duplicated unsafe code.
+- Use type-only imports where appropriate and keep runtime imports intentional.
+- Keep API contracts stable and make breaking changes explicit.
+
+## Security Rules
+
+- Validate external input at process, HTTP, CLI, file and database boundaries.
+- Avoid unsafe dynamic property access, `eval`, shell interpolation and untrusted deserialization.
+- Keep secrets out of logs, errors, snapshots and generated examples.
+
+## Completion Standard
+
+- Summarize behavior changed, files touched, validation run and remaining risks.
+- Do not claim zero bugs; report evidence.

package/docs/skill-candidates/v0.0.9/ai-ethics-human-dignity/SKILL.md

@@ -1,32 +1,32 @@
----
-name: ai-ethics-human-dignity
-description: "Candidate skill for evaluating AI, automation, data and algorithmic decisions against human dignity, transparency, privacy, bias, accountability and the common good."
----
-
-# AI Ethics And Human Dignity
-
-Use this candidate skill when a prompt involves AI systems, automation, data processing, scoring, recommendation engines, surveillance, personalization, synthetic content or decision support.
-
-## Workflow
-
-- Identify affected people and groups.
-- Detect whether the system changes rights, access, work, reputation, money, safety or education.
-- Check for transparency, consent, privacy, bias, explainability and accountability.
-- Require human oversight for sensitive decisions.
-- Reject uses that manipulate, deceive, exploit or dehumanize.
-- Recommend evals and monitoring before deployment.
-
-## Boundaries
-
-- Do not treat efficiency as the highest good.
-- Do not hide responsibility behind "the algorithm".
-- Do not allow automated categorization to replace human dignity.
-- Do not approve weaponization or coercive surveillance.
-
-## Evidence Required
-
-- Intended users.
-- Data categories.
-- Decision impact.
-- Human oversight plan.
-- Bias and failure-mode evaluation.
+---
+name: ai-ethics-human-dignity
+description: "Candidate skill for evaluating AI, automation, data and algorithmic decisions against human dignity, transparency, privacy, bias, accountability and the common good."
+---
+
+# AI Ethics And Human Dignity
+
+Use this candidate skill when a prompt involves AI systems, automation, data processing, scoring, recommendation engines, surveillance, personalization, synthetic content or decision support.
+
+## Workflow
+
+- Identify affected people and groups.
+- Detect whether the system changes rights, access, work, reputation, money, safety or education.
+- Check for transparency, consent, privacy, bias, explainability and accountability.
+- Require human oversight for sensitive decisions.
+- Reject uses that manipulate, deceive, exploit or dehumanize.
+- Recommend evals and monitoring before deployment.
+
+## Boundaries
+
+- Do not treat efficiency as the highest good.
+- Do not hide responsibility behind "the algorithm".
+- Do not allow automated categorization to replace human dignity.
+- Do not approve weaponization or coercive surveillance.
+
+## Evidence Required
+
+- Intended users.
+- Data categories.
+- Decision impact.
+- Human oversight plan.
+- Bias and failure-mode evaluation.

package/docs/skill-candidates/v0.0.9/broad-domain-router/SKILL.md

@@ -1,41 +1,41 @@
----
-name: broad-domain-router
-description: "Candidate skill for routing prompts across broad knowledge domains and recommending approved local or global skills without pretending unsupported expertise."
----
-
-# Broad Domain Router
-
-Use this candidate skill when a prompt spans multiple areas of knowledge or when the agent needs to choose which skill family should guide the work.
-
-## Domains
-
-- Catholic doctrine and moral discernment.
-- Science.
-- Philosophy.
-- Sociology.
-- Law.
-- Mathematics.
-- Portuguese.
-- English.
-- French.
-- Computer engineering.
-- Software engineering.
-- Network engineering.
-- AI engineering.
-- Security.
-- Product and documentation.
-
-## Workflow
-
-- Classify the primary and secondary domains.
-- Identify whether the topic is stable or requires current research.
-- Recommend approved skills first.
-- Mark missing skills as roadmap candidates.
-- Add professional-boundary gates when appropriate.
-- Ask for sources or validation when the prompt has high stakes.
-
-## Boundaries
-
-- Do not invent sources.
-- Do not activate unapproved web skills.
-- Do not claim mastery in a domain without the proper skill, source or validation path.
+---
+name: broad-domain-router
+description: "Candidate skill for routing prompts across broad knowledge domains and recommending approved local or global skills without pretending unsupported expertise."
+---
+
+# Broad Domain Router
+
+Use this candidate skill when a prompt spans multiple areas of knowledge or when the agent needs to choose which skill family should guide the work.
+
+## Domains
+
+- Catholic doctrine and moral discernment.
+- Science.
+- Philosophy.
+- Sociology.
+- Law.
+- Mathematics.
+- Portuguese.
+- English.
+- French.
+- Computer engineering.
+- Software engineering.
+- Network engineering.
+- AI engineering.
+- Security.
+- Product and documentation.
+
+## Workflow
+
+- Classify the primary and secondary domains.
+- Identify whether the topic is stable or requires current research.
+- Recommend approved skills first.
+- Mark missing skills as roadmap candidates.
+- Add professional-boundary gates when appropriate.
+- Ask for sources or validation when the prompt has high stakes.
+
+## Boundaries
+
+- Do not invent sources.
+- Do not activate unapproved web skills.
+- Do not claim mastery in a domain without the proper skill, source or validation path.