@fprad0/skill-master-mcp 0.0.10 → 0.0.12

package/docs/skill-candidates/v0.0.11/typescript-expert/scripts/ts_diagnostic.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+TypeScript Project Diagnostic Script
+Analyzes TypeScript projects for configuration, performance, and common issues.
+"""
+
+import subprocess
+import sys
+import os
+import json
+from pathlib import Path
+
+def run_cmd(cmd: str) -> str:
+    """Run shell command and return output."""
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        return result.stdout + result.stderr
+    except Exception as e:
+        return str(e)
+
+def check_versions():
+    """Check TypeScript and Node versions."""
+    print("\n📦 Versions:")
+    print("-" * 40)
+    
+    ts_version = run_cmd("npx tsc --version 2>/dev/null").strip()
+    node_version = run_cmd("node -v 2>/dev/null").strip()
+    
+    print(f"  TypeScript: {ts_version or 'Not found'}")
+    print(f"  Node.js: {node_version or 'Not found'}")
+
+def check_tsconfig():
+    """Analyze tsconfig.json settings."""
+    print("\n⚙️ TSConfig Analysis:")
+    print("-" * 40)
+    
+    tsconfig_path = Path("tsconfig.json")
+    if not tsconfig_path.exists():
+        print("⚠️ tsconfig.json not found")
+        return
+    
+    try:
+        with open(tsconfig_path) as f:
+            config = json.load(f)
+        
+        compiler_opts = config.get("compilerOptions", {})
+        
+        # Check strict mode
+        if compiler_opts.get("strict"):
+            print("✅ Strict mode enabled")
+        else:
+            print("⚠️ Strict mode NOT enabled")
+        
+        # Check important flags
+        flags = {
+            "noUncheckedIndexedAccess": "Unchecked index access protection",
+            "noImplicitOverride": "Implicit override protection",
+            "skipLibCheck": "Skip lib check (performance)",
+            "incremental": "Incremental compilation"
+        }
+        
+        for flag, desc in flags.items():
+            status = "✅" if compiler_opts.get(flag) else "⚪"
+            print(f"  {status} {desc}: {compiler_opts.get(flag, 'not set')}")
+        
+        # Check module settings
+        print(f"\n  Module: {compiler_opts.get('module', 'not set')}")
+        print(f"  Module Resolution: {compiler_opts.get('moduleResolution', 'not set')}")
+        print(f"  Target: {compiler_opts.get('target', 'not set')}")
+        
+    except json.JSONDecodeError:
+        print("❌ Invalid JSON in tsconfig.json")
+
+def check_tooling():
+    """Detect TypeScript tooling ecosystem."""
+    print("\n🛠️ Tooling Detection:")
+    print("-" * 40)
+    
+    pkg_path = Path("package.json")
+    if not pkg_path.exists():
+        print("⚠️ package.json not found")
+        return
+    
+    try:
+        with open(pkg_path) as f:
+            pkg = json.load(f)
+        
+        all_deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+        
+        tools = {
+            "biome": "Biome (linter/formatter)",
+            "eslint": "ESLint",
+            "prettier": "Prettier",
+            "vitest": "Vitest (testing)",
+            "jest": "Jest (testing)",
+            "turborepo": "Turborepo (monorepo)",
+            "turbo": "Turbo (monorepo)",
+            "nx": "Nx (monorepo)",
+            "lerna": "Lerna (monorepo)"
+        }
+        
+        for tool, desc in tools.items():
+            for dep in all_deps:
+                if tool in dep.lower():
+                    print(f"  ✅ {desc}")
+                    break
+                    
+    except json.JSONDecodeError:
+        print("❌ Invalid JSON in package.json")
+
+def check_monorepo():
+    """Check for monorepo configuration."""
+    print("\n📦 Monorepo Check:")
+    print("-" * 40)
+    
+    indicators = [
+        ("pnpm-workspace.yaml", "PNPM Workspace"),
+        ("lerna.json", "Lerna"),
+        ("nx.json", "Nx"),
+        ("turbo.json", "Turborepo")
+    ]
+    
+    found = False
+    for file, name in indicators:
+        if Path(file).exists():
+            print(f"  ✅ {name} detected")
+            found = True
+    
+    if not found:
+        print("  ⚪ No monorepo configuration detected")
+
+def check_type_errors():
+    """Run quick type check."""
+    print("\n🔍 Type Check:")
+    print("-" * 40)
+    
+    result = run_cmd("npx tsc --noEmit 2>&1 | head -20")
+    if "error TS" in result:
+        errors = result.count("error TS")
+        print(f"  ❌ {errors}+ type errors found")
+        print(result[:500])
+    else:
+        print("  ✅ No type errors")
+
+def check_any_usage():
+    """Check for any type usage."""
+    print("\n⚠️ 'any' Type Usage:")
+    print("-" * 40)
+    
+    result = run_cmd("grep -r ': any' --include='*.ts' --include='*.tsx' src/ 2>/dev/null | wc -l")
+    count = result.strip()
+    if count and count != "0":
+        print(f"  ⚠️ Found {count} occurrences of ': any'")
+        sample = run_cmd("grep -rn ': any' --include='*.ts' --include='*.tsx' src/ 2>/dev/null | head -5")
+        if sample:
+            print(sample)
+    else:
+        print("  ✅ No explicit 'any' types found")
+
+def check_type_assertions():
+    """Check for type assertions."""
+    print("\n⚠️ Type Assertions (as):")
+    print("-" * 40)
+    
+    result = run_cmd("grep -r ' as ' --include='*.ts' --include='*.tsx' src/ 2>/dev/null | grep -v 'import' | wc -l")
+    count = result.strip()
+    if count and count != "0":
+        print(f"  ⚠️ Found {count} type assertions")
+    else:
+        print("  ✅ No type assertions found")
+
+def check_performance():
+    """Check type checking performance."""
+    print("\n⏱️ Type Check Performance:")
+    print("-" * 40)
+    
+    result = run_cmd("npx tsc --extendedDiagnostics --noEmit 2>&1 | grep -E 'Check time|Files:|Lines:|Nodes:'")
+    if result.strip():
+        for line in result.strip().split('\n'):
+            print(f"  {line}")
+    else:
+        print("  ⚠️ Could not measure performance")
+
+def main():
+    print("=" * 50)
+    print("🔍 TypeScript Project Diagnostic Report")
+    print("=" * 50)
+    
+    check_versions()
+    check_tsconfig()
+    check_tooling()
+    check_monorepo()
+    check_any_usage()
+    check_type_assertions()
+    check_type_errors()
+    check_performance()
+    
+    print("\n" + "=" * 50)
+    print("✅ Diagnostic Complete")
+    print("=" * 50)
+
+if __name__ == "__main__":
+    main()

package/docs/skill-candidates/v0.0.11/ui-component-primitives/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: ui-component-primitives
+description: "Design and implement reusable UI primitives and interaction components such as buttons, inputs, cards, modals, dropdowns, icons, toasts and navigation with accessibility and state clarity."
+---
+
+# UI Component Primitives
+
+Use this skill when the task is about reusable UI building blocks rather than page-level layout alone.
+
+## Workflow
+
+- Start from the interaction contract: trigger, focus, keyboard, dismissal and state changes.
+- Define component API, variants and states before styling details.
+- Treat modal, dropdown, popover and navigation primitives as accessibility-sensitive systems.
+- Keep icons, labels, spacing and motion consistent with the design system.
+- Validate both mouse and keyboard behavior.
+
+## Coverage
+
+- Components, primitives, modals, dropdowns, popovers, icons, buttons, forms and feedback.
+- Variants, states, accessibility, composition and design-system reuse.
+- Desktop and mobile interaction expectations.
+
+## Reference Anchors
+
+- WAI-ARIA APG: `https://www.w3.org/WAI/ARIA/apg/`
+- Material Design components: `https://m3.material.io/components`
+
+## Guardrails
+
+- Do not ship inaccessible focus, escape or keyboard behavior.
+- Do not let visual styling outrun interaction correctness.
+- Do not duplicate primitives without a strong reason.
+- Do not ignore empty, loading, disabled or error states.

package/docs/skill-candidates/v0.0.11/web-mobile-design-systems/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: web-mobile-design-systems
+description: "Shape coherent web, mobile and app-facing design systems with attention to layout, hierarchy, navigation, responsive behavior, visual language and product-level usability."
+---
+
+# Web Mobile Design Systems
+
+Use this skill when the task spans layout, visual systems and product interaction across desktop and mobile surfaces.
+
+## Workflow
+
+- Begin from information hierarchy, navigation and user goal flow.
+- Design responsive layout behavior before polishing isolated screens.
+- Keep typography, spacing, surface hierarchy and motion consistent across breakpoints.
+- Reuse patterns deliberately across web and mobile contexts while respecting platform differences.
+- Validate readability, rhythm and interaction clarity on both narrow and wide layouts.
+
+## Coverage
+
+- Layout, web design, mobile, app surfaces, UX/UI systems and responsive behavior.
+- Navigation, forms, cards, sections, density, hierarchy, motion and visual consistency.
+- Design-system framing for product teams.
+
+## Reference Anchors
+
+- Material Design 3: `https://m3.material.io/`
+- Apple Human Interface Guidelines: `https://developer.apple.com/design/human-interface-guidelines/`
+
+## Guardrails
+
+- Do not confuse visual complexity with product quality.
+- Do not force desktop structure onto mobile flows.
+- Do not treat responsiveness as a late patch.
+- Do not sacrifice clarity for novelty.

package/docs/skill-candidates/v0.0.11/windows-linux-platform-ops/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: windows-linux-platform-ops
+description: "Operate Windows and Linux developer environments with focus on filesystems, PATH, permissions, services, shells, package managers and cross-platform reliability."
+---
+
+# Windows Linux Platform Ops
+
+Use this skill when the task depends on OS-specific environment behavior across Windows or Linux.
+
+## Workflow
+
+- Identify the target OS, shell, path conventions and permission model first.
+- Treat filesystem, service, environment and package-manager differences explicitly.
+- Prefer cross-platform instructions only when they are truly equivalent.
+- Keep operator-facing paths, config locations and restart steps concrete.
+- Validate on the real platform path when possible.
+
+## Coverage
+
+- Windows and Linux paths, permissions, PATH, services, package managers and shells.
+- Config-file locations, CLI registration, restart/reload behavior and troubleshooting.
+- Cross-platform readiness for developer tooling.
+
+## Reference Anchors
+
+- Windows docs: `https://learn.microsoft.com/windows/`
+- Linux kernel docs: `https://www.kernel.org/doc/html/latest/`
+
+## Guardrails
+
+- Do not assume Linux semantics on Windows paths or permissions.
+- Do not give cross-platform instructions that are only half-true.
+- Do not omit restart/reload requirements for service or shell config changes.
+- Do not hide elevated-privilege requirements.

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/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.