eslint-plugin-copilot 1.0.8 → 1.1.2

package/dist/plugin.cjs

@@ -35,12 +35,13 @@ __export(plugin_exports, {
 module.exports = __toCommonJS(plugin_exports);
 var import_json = __toESM(require("@eslint/json"), 1);
 var import_markdown = __toESM(require("@eslint/markdown"), 1);
+var import_ts_extras56 = require("ts-extras");
 
 // package.json
 var package_default = {
   $schema: "https://www.schemastore.org/package.json",
   name: "eslint-plugin-copilot",
-  version: "1.0.8",
+  version: "1.1.2",
   private: false,
   description: "ESLint rules for GitHub Copilot repository customization files.",
   keywords: [
@@ -187,7 +188,7 @@ var package_default = {
     "lint:quiet": 'cross-env ESLINT_PROGRESS=nofile NODE_OPTIONS=--max_old_space_size=16384 eslint --cache --cache-strategy content --cache-location .cache/.eslintcache && echo "Eslint done!"',
     "lint:remark": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail "*.{md,mdx}" "docs/**/*.{md,mdx}" --quiet',
     "lint:remark:fix": 'prettier --log-level warn --ignore-path prettierignore.remark --cache --cache-location=.cache/.prettier-cache --cache-strategy=content --no-error-on-unmatched-pattern --write "*.{md,mdx}" "docs/**/*.{md,mdx}" && npm run remark:fix',
-    "lint:secretlint": 'secretlint --secretlintrc .secretlintrc.json --secretlintignore .secretlintignore "./*" ".vscode/**" "assets/**" "src/**" "electron/**" "shared/**" "config/**" "scripts/**" "playwright/**" "storybook/**" ".storybook" "tests/**" "benchmarks/**" ".devin/**" "public/**" ".github/**" "docs/Architecture/**" "docs/*" "docs/assets/**" "docs/Guides/**" "docs/Testing/**" "docs/TSDoc/**" "docs/docusaurus/src/**" "docs/docusaurus/static/**" "docs/docusaurus/blog/**" "docs/docusaurus/docs/**" "docs/docusaurus/docs/*"',
+    "lint:secretlint": 'secretlint --secretlintrc .secretlintrc.cjs --secretlintignore .secretlintignore "./*" ".vscode/**" "assets/**" "src/**" "electron/**" "shared/**" "config/**" "scripts/**" "playwright/**" "storybook/**" ".storybook" "tests/**" "benchmarks/**" ".devin/**" "public/**" ".github/**" "docs/Architecture/**" "docs/*" "docs/assets/**" "docs/Guides/**" "docs/Testing/**" "docs/TSDoc/**" "docs/docusaurus/src/**" "docs/docusaurus/static/**" "docs/docusaurus/blog/**" "docs/docusaurus/docs/**" "docs/docusaurus/docs/*"',
     "lint:secrets": "detect-secrets scan",
     "lint:unused": "npm run knip -- --include unlisted,unresolved,duplicates",
     "lint:unused-deps": "depcheck --ignores='@types/*,@testing-library/*,@vitest/*'",
@@ -207,6 +208,7 @@ var package_default = {
     "sync:presets-rules-matrix": "node scripts/sync-presets-rules-matrix.mjs",
     "sync:readme-rules-table": "node scripts/sync-readme-rules-table.mjs",
     "sync:readme-rules-table:write": "node scripts/sync-readme-rules-table.mjs --write",
+    "sync:rules:write": "npm run sync:readme-rules-table:write && npm run sync:presets-rules-matrix",
     pretest: "npm run build",
     test: "vitest run",
     "test:ci": "cross-env CI=true vitest run --reporter=default",
@@ -230,61 +232,31 @@ var package_default = {
     typecheck: "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.build.json --noEmit && tsc -p tsconfig.eslint.json --noEmit && tsc -p tsconfig.js.json --noEmit && npm run --workspace docs/docusaurus typecheck",
     "typecheck:all": "npm run typecheck",
     "types:update": "typesync",
-    "update-deps": "npx ncu -i --install never && npm run sync:peer-eslint-range && npm install --force",
+    "update-deps": "npx ncu -i --install never && npm update --workspaces --force && npm install --force && npm run sync:peer-eslint-range && npm run sync:node-version-files && npm run sync:rules:write",
     "verify:readme-rules-table": "npm run build && npm run sync:readme-rules-table"
   },
   overrides: {
     "jsonc-eslint-parser": "$jsonc-eslint-parser"
   },
   dependencies: {
-    "@typescript-eslint/parser": "^8.58.1",
-    "@typescript-eslint/type-utils": "^8.58.1",
-    "@typescript-eslint/utils": "^8.58.1"
+    "@eslint/json": "^1.2.0",
+    "@eslint/markdown": "^8.0.1",
+    "@typescript-eslint/type-utils": "^8.59.1",
+    "@typescript-eslint/utils": "^8.59.1",
+    "ts-extras": "^1.0.0",
+    "type-fest": "^5.6.0"
   },
   devDependencies: {
     "@arethetypeswrong/cli": "^0.18.2",
     "@csstools/stylelint-formatter-github": "^2.0.0",
-    "@docusaurus/eslint-plugin": "^3.10.0",
     "@double-great/remark-lint-alt-text": "^1.1.1",
-    "@double-great/stylelint-a11y": "^3.4.9",
-    "@eslint-community/eslint-plugin-eslint-comments": "^4.7.1",
-    "@eslint-react/eslint-plugin": "^4.2.3",
     "@eslint/compat": "^2.0.5",
-    "@eslint/config-helpers": "^0.5.5",
-    "@eslint/config-inspector": "^1.5.0",
-    "@eslint/css": "^1.1.0",
-    "@eslint/js": "^10.0.1",
-    "@eslint/json": "^1.2.0",
-    "@eslint/markdown": "^8.0.1",
-    "@html-eslint/eslint-plugin": "^0.59.0",
-    "@html-eslint/parser": "^0.59.0",
-    "@microsoft/eslint-plugin-sdl": "^1.1.0",
+    "@eslint/config-inspector": "^2.0.0",
     "@microsoft/tsdoc-config": "^0.18.1",
-    "@secretlint/secretlint-rule-anthropic": "^11.6.0",
-    "@secretlint/secretlint-rule-aws": "^11.6.0",
-    "@secretlint/secretlint-rule-database-connection-string": "^11.6.0",
-    "@secretlint/secretlint-rule-gcp": "^11.6.0",
-    "@secretlint/secretlint-rule-github": "^11.6.0",
-    "@secretlint/secretlint-rule-no-dotenv": "^11.6.0",
-    "@secretlint/secretlint-rule-no-homedir": "^11.6.0",
-    "@secretlint/secretlint-rule-npm": "^11.6.0",
-    "@secretlint/secretlint-rule-openai": "^11.6.0",
-    "@secretlint/secretlint-rule-pattern": "^11.6.0",
-    "@secretlint/secretlint-rule-preset-recommend": "^11.6.0",
-    "@secretlint/secretlint-rule-privatekey": "^11.6.0",
-    "@secretlint/secretlint-rule-secp256k1-privatekey": "^11.6.0",
-    "@secretlint/types": "^11.6.0",
-    "@softonus/prettier-plugin-duplicate-remover": "^1.1.2",
     "@stryker-ignorer/console-all": "^0.3.2",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/typescript-checker": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
-    "@stylelint-types/stylelint-order": "^7.0.1",
-    "@stylelint-types/stylelint-stylistic": "^5.0.0",
-    "@stylistic/eslint-plugin": "^5.10.0",
-    "@stylistic/stylelint-plugin": "^5.1.0",
-    "@types/eslint-plugin-jsx-a11y": "^6.10.1",
-    "@types/eslint-plugin-security": "^3.0.1",
     "@types/htmlhint": "^1.1.5",
     "@types/madge": "^5.0.3",
     "@types/node": "^25.6.0",
@@ -296,287 +268,76 @@ var package_default = {
     "@types/postcss-normalize": "^9.0.4",
     "@types/postcss-reporter": "^7.0.5",
     "@types/sloc": "^0.2.3",
-    "@typescript-eslint/eslint-plugin": "^8.58.1",
-    "@typescript-eslint/rule-tester": "^8.58.1",
-    "@vitest/coverage-v8": "^4.1.4",
-    "@vitest/eslint-plugin": "^1.6.15",
-    "@vitest/ui": "^4.1.4",
+    "@typescript-eslint/rule-tester": "^8.59.1",
+    "@vitest/coverage-v8": "^4.1.5",
+    "@vitest/ui": "^4.1.5",
     actionlint: "^2.0.6",
     "all-contributors-cli": "^6.26.1",
     "cognitive-complexity-ts": "^0.8.1",
-    commitlint: "^20.5.0",
+    commitlint: "^20.5.3",
     "commitlint-config-gitmoji": "^2.3.1",
     "cross-env": "^10.1.0",
     depcheck: "^1.4.7",
     "detect-secrets": "^1.0.6",
-    eslint: "^10.2.0",
-    "eslint-config-flat-gitignore": "^2.3.0",
-    "eslint-config-prettier": "^10.1.8",
+    eslint: "^10.3.0",
+    "eslint-config-nick2bad4u": "^1.0.11",
     "eslint-formatter-unix": "^9.0.1",
-    "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-array-func": "^5.1.1",
-    "eslint-plugin-canonical": "^5.1.3",
-    "eslint-plugin-case-police": "^2.2.0",
-    "eslint-plugin-comment-length": "^2.3.0",
-    "eslint-plugin-css-modules": "^2.12.0",
-    "eslint-plugin-de-morgan": "^2.1.1",
-    "eslint-plugin-depend": "^1.5.0",
-    "eslint-plugin-eslint-plugin": "^7.3.2",
-    "eslint-plugin-etc": "^2.0.3",
-    "eslint-plugin-etc-misc": "^1.0.6",
-    "eslint-plugin-file-progress-2": "^5.0.0",
-    "eslint-plugin-html": "^8.1.4",
-    "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^62.9.0",
-    "eslint-plugin-jsonc": "^3.1.2",
-    "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-listeners": "^1.5.1",
-    "eslint-plugin-loadable-imports": "^1.0.1",
-    "eslint-plugin-math": "^0.13.1",
-    "eslint-plugin-module-interop": "^0.3.1",
-    "eslint-plugin-n": "^17.24.0",
-    "eslint-plugin-nitpick": "^0.12.0",
-    "eslint-plugin-no-barrel-files": "^1.3.0",
-    "eslint-plugin-no-explicit-type-exports": "^0.12.1",
-    "eslint-plugin-no-function-declare-after-return": "^1.1.0",
-    "eslint-plugin-no-lookahead-lookbehind-regexp": "^0.4.0",
-    "eslint-plugin-no-only-tests": "^3.3.0",
-    "eslint-plugin-no-secrets": "^2.3.3",
-    "eslint-plugin-no-unsanitized": "^4.1.5",
-    "eslint-plugin-no-use-extend-native": "^0.7.2",
-    "eslint-plugin-node-dependencies": "^2.2.0",
-    "eslint-plugin-package-json": "^0.91.1",
-    "eslint-plugin-perfectionist": "^5.8.0",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
-    "eslint-plugin-prettier": "^5.5.5",
-    "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-redos": "^4.5.0",
-    "eslint-plugin-regexp": "^3.1.0",
-    "eslint-plugin-require-jsdoc": "^1.0.4",
-    "eslint-plugin-security": "^4.0.0",
-    "eslint-plugin-sonarjs": "^4.0.2",
-    "eslint-plugin-sort-class-members": "^1.22.1",
-    "eslint-plugin-testing-library": "^7.16.2",
-    "eslint-plugin-toml": "^1.3.1",
-    "eslint-plugin-total-functions": "^7.1.0",
-    "eslint-plugin-tsdoc": "^0.5.2",
-    "eslint-plugin-tsdoc-require-2": "^1.0.9",
-    "eslint-plugin-undefined-css-classes": "^0.1.5",
-    "eslint-plugin-unicorn": "^64.0.0",
-    "eslint-plugin-unused-imports": "^4.4.1",
-    "eslint-plugin-write-good-comments": "^0.2.0",
-    "eslint-plugin-yml": "^3.3.1",
     "eslint-rule-benchmark": "^0.8.0",
-    "fast-check": "^4.6.0",
-    "git-cliff": "^2.12.0",
+    "fast-check": "^4.7.0",
+    "git-cliff": "^2.13.1",
     "gitleaks-secret-scanner": "^2.1.1",
-    globals: "^17.5.0",
     htmlhint: "^1.9.2",
     jscpd: "^4.0.9",
-    "jsonc-eslint-parser": "^3.1.0",
-    knip: "^6.4.0",
+    knip: "^6.11.0",
     leasot: "^14.4.0",
     madge: "^8.0.0",
     "markdown-link-check": "^3.14.2",
-    "npm-check-updates": "^20.0.1",
-    "npm-package-json-lint": "^10.2.0",
+    "npm-check-updates": "^22.1.0",
+    "npm-package-json-lint": "^10.4.0",
     picocolors: "^1.1.1",
-    postcss: "^8.5.9",
+    postcss: "^8.5.13",
     "postcss-assets": "^6.0.0",
     "postcss-clamp": "^4.1.0",
     "postcss-combine-duplicated-selectors": "^10.0.3",
     "postcss-flexbugs-fixes": "^5.0.2",
-    "postcss-html": "^1.8.1",
     "postcss-import": "^16.1.1",
     "postcss-inline-svg": "^6.0.0",
     "postcss-logical": "^9.0.0",
     "postcss-normalize": "^13.0.1",
     "postcss-reporter": "^7.1.0",
     "postcss-round-subpixels": "^2.0.0",
-    "postcss-scss": "^4.0.9",
-    "postcss-sort-media-queries": "^6.4.4",
-    "postcss-styled-jsx": "^1.0.1",
-    "postcss-styled-syntax": "^0.7.1",
+    "postcss-sort-media-queries": "^6.5.0",
     "postcss-viewport-height-correction": "^1.1.1",
-    prettier: "^3.8.2",
-    "prettier-plugin-ini": "^1.3.0",
-    "prettier-plugin-interpolated-html-tags": "^2.0.1",
-    "prettier-plugin-jsdoc": "^1.8.0",
-    "prettier-plugin-jsdoc-type": "^0.2.0",
-    "prettier-plugin-merge": "^0.10.1",
-    "prettier-plugin-multiline-arrays": "^4.1.5",
-    "prettier-plugin-packagejson": "^3.0.2",
-    "prettier-plugin-properties": "^0.3.1",
-    "prettier-plugin-sort-json": "^4.2.0",
-    "prettier-plugin-toml": "^2.0.6",
+    prettier: "^3.8.3",
+    "prettier-config-nick2bad4u": "^1.0.9",
     publint: "^0.3.18",
-    "recheck-jar": "^4.5.0",
     "rehype-katex": "^7.0.1",
     remark: "^15.0.1",
     "remark-cli": "^12.0.1",
-    "remark-directive": "^4.0.0",
-    "remark-frontmatter": "^5.0.0",
-    "remark-gfm": "^4.0.1",
-    "remark-ignore": "^3.0.0",
-    "remark-inline-links": "^7.0.0",
-    "remark-lint": "^10.0.1",
-    "remark-lint-blockquote-indentation": "^4.0.1",
-    "remark-lint-check-toc": "^1.0.0",
-    "remark-lint-checkbox-character-style": "^5.0.1",
-    "remark-lint-checkbox-content-indent": "^5.0.1",
-    "remark-lint-code-block-split-list": "^1.0.0",
-    "remark-lint-code-block-style": "^4.0.1",
-    "remark-lint-correct-media-syntax": "^1.0.1",
-    "remark-lint-definition-case": "^4.0.1",
-    "remark-lint-definition-sort": "^1.0.1",
-    "remark-lint-definition-spacing": "^4.0.1",
-    "remark-lint-directive-attribute-sort": "^1.0.1",
-    "remark-lint-directive-collapsed-attribute": "^1.0.1",
-    "remark-lint-directive-quote-style": "^1.0.1",
-    "remark-lint-directive-shortcut-attribute": "^1.0.1",
-    "remark-lint-directive-unique-attribute-name": "^1.0.1",
-    "remark-lint-emphasis-marker": "^4.0.1",
-    "remark-lint-fenced-code-flag": "^4.2.0",
-    "remark-lint-fenced-code-flag-case": "^3.0.0",
-    "remark-lint-fenced-code-marker": "^4.0.1",
-    "remark-lint-file-extension": "^3.0.1",
-    "remark-lint-final-definition": "^4.0.2",
-    "remark-lint-final-newline": "^3.0.1",
-    "remark-lint-first-heading-level": "^4.0.1",
-    "remark-lint-frontmatter-schema": "^3.15.4",
-    "remark-lint-hard-break-spaces": "^4.1.1",
-    "remark-lint-heading-capitalization": "^1.3.0",
-    "remark-lint-heading-increment": "^4.0.1",
-    "remark-lint-heading-style": "^4.0.1",
-    "remark-lint-heading-whitespace": "^1.0.0",
-    "remark-lint-linebreak-style": "^4.0.1",
-    "remark-lint-link-title-style": "^4.0.1",
-    "remark-lint-list-item-bullet-indent": "^5.0.1",
-    "remark-lint-list-item-content-indent": "^4.0.1",
-    "remark-lint-list-item-indent": "^4.0.1",
-    "remark-lint-list-item-spacing": "^5.0.1",
-    "remark-lint-maximum-heading-length": "^4.1.1",
-    "remark-lint-maximum-line-length": "^4.1.1",
-    "remark-lint-mdx-jsx-attribute-sort": "^1.0.1",
-    "remark-lint-mdx-jsx-no-void-children": "^1.0.1",
-    "remark-lint-mdx-jsx-quote-style": "^1.0.1",
-    "remark-lint-mdx-jsx-self-close": "^1.0.1",
-    "remark-lint-mdx-jsx-shorthand-attribute": "^1.0.1",
-    "remark-lint-mdx-jsx-unique-attribute-name": "^1.0.1",
-    "remark-lint-media-style": "^1.0.1",
-    "remark-lint-no-blockquote-without-marker": "^6.0.1",
-    "remark-lint-no-consecutive-blank-lines": "^5.0.1",
-    "remark-lint-no-dead-urls": "^2.0.1",
-    "remark-lint-no-duplicate-defined-urls": "^3.0.1",
-    "remark-lint-no-duplicate-definitions": "^4.0.1",
-    "remark-lint-no-duplicate-headings": "^4.0.1",
-    "remark-lint-no-duplicate-headings-in-section": "^4.0.1",
-    "remark-lint-no-emphasis-as-heading": "^4.0.1",
-    "remark-lint-no-empty-sections": "^4.0.0",
-    "remark-lint-no-empty-url": "^4.0.1",
-    "remark-lint-no-file-name-articles": "^3.0.1",
-    "remark-lint-no-file-name-consecutive-dashes": "^3.0.1",
-    "remark-lint-no-file-name-irregular-characters": "^3.0.1",
-    "remark-lint-no-file-name-mixed-case": "^3.0.1",
-    "remark-lint-no-file-name-outer-dashes": "^3.0.1",
-    "remark-lint-no-heading-content-indent": "^5.0.1",
-    "remark-lint-no-heading-indent": "^5.0.1",
-    "remark-lint-no-heading-like-paragraph": "^4.0.1",
-    "remark-lint-no-heading-punctuation": "^4.0.1",
-    "remark-lint-no-hidden-table-cell": "^1.0.1",
-    "remark-lint-no-html": "^4.0.1",
-    "remark-lint-no-literal-urls": "^4.0.1",
-    "remark-lint-no-missing-blank-lines": "^4.0.1",
-    "remark-lint-no-multiple-toplevel-headings": "^4.0.1",
-    "remark-lint-no-paragraph-content-indent": "^5.0.1",
-    "remark-lint-no-reference-like-url": "^4.0.1",
-    "remark-lint-no-shell-dollars": "^4.0.1",
-    "remark-lint-no-shortcut-reference-image": "^4.0.1",
-    "remark-lint-no-shortcut-reference-link": "^4.0.1",
-    "remark-lint-no-table-indentation": "^5.0.1",
-    "remark-lint-no-tabs": "^4.0.1",
-    "remark-lint-no-undefined-references": "^5.0.2",
-    "remark-lint-no-unneeded-full-reference-image": "^4.0.1",
-    "remark-lint-no-unneeded-full-reference-link": "^4.0.1",
-    "remark-lint-no-unused-definitions": "^4.0.2",
-    "remark-lint-ordered-list-marker-style": "^4.0.1",
-    "remark-lint-ordered-list-marker-value": "^4.0.1",
-    "remark-lint-rule-style": "^4.0.1",
-    "remark-lint-strikethrough-marker": "^3.0.1",
-    "remark-lint-strong-marker": "^4.0.1",
-    "remark-lint-table-cell-padding": "^5.1.1",
-    "remark-lint-table-pipe-alignment": "^4.1.1",
-    "remark-lint-table-pipes": "^5.0.1",
-    "remark-lint-unordered-list-marker-style": "^4.0.1",
-    "remark-lint-write-good": "^1.2.0",
-    "remark-math": "^6.0.0",
-    "remark-preset-lint-consistent": "^6.0.1",
-    "remark-preset-lint-markdown-style-guide": "^6.0.1",
-    "remark-preset-lint-recommended": "^7.0.1",
-    "remark-preset-prettier": "^2.0.2",
-    "remark-toc": "^9.0.0",
-    "remark-validate-links": "^13.1.0",
-    "remark-wiki-link": "^2.0.1",
+    "remark-config-nick2bad4u": "^1.0.1",
     rimraf: "^6.1.3",
-    secretlint: "^11.6.0",
+    secretlint: "^12.3.1",
+    "secretlint-config-nick2bad4u": "^1.0.3",
     sloc: "^0.3.2",
     "sort-package-json": "^3.6.1",
-    stylelint: "^17.7.0",
-    "stylelint-actions-formatters": "^16.3.1",
-    "stylelint-checkstyle-formatter": "^0.1.2",
-    "stylelint-codeframe-formatter": "^1.2.0",
-    "stylelint-config-alphabetical-order": "^2.0.0",
-    "stylelint-config-idiomatic-order": "^10.0.0",
-    "stylelint-config-inspector": "^2.0.3",
-    "stylelint-config-recess-order": "^7.7.0",
-    "stylelint-config-recommended": "^18.0.0",
-    "stylelint-config-sass-guidelines": "^13.0.0",
-    "stylelint-config-standard": "^40.0.0",
-    "stylelint-config-standard-scss": "^17.0.0",
-    "stylelint-config-tailwindcss": "^1.0.1",
-    "stylelint-declaration-block-no-ignored-properties": "^3.0.0",
-    "stylelint-declaration-strict-value": "^1.11.1",
-    "stylelint-define-config": "^17.5.0",
-    "stylelint-find-new-rules": "^6.0.0",
-    "stylelint-formatter-gitlab-code-quality-report": "^1.1.0",
-    "stylelint-formatter-pretty": "^4.0.1",
-    "stylelint-gamut": "^2.0.0",
-    "stylelint-group-selectors": "^1.0.10",
-    "stylelint-high-performance-animation": "^2.0.0",
-    "stylelint-media-use-custom-media": "^4.1.0",
-    "stylelint-no-browser-hacks": "^2.0.0",
-    "stylelint-no-indistinguishable-colors": "^2.3.1",
-    "stylelint-no-restricted-syntax": "^2.2.1",
-    "stylelint-no-unresolved-module": "^2.5.2",
-    "stylelint-no-unsupported-browser-features": "^8.1.1",
-    "stylelint-order": "^8.1.1",
-    "stylelint-plugin-defensive-css": "^2.9.0",
-    "stylelint-plugin-logical-css": "^2.1.0",
-    "stylelint-plugin-use-baseline": "^1.4.1",
-    "stylelint-prettier": "^5.0.3",
-    "stylelint-react-native": "^2.7.0",
-    "stylelint-scales": "^5.0.0",
-    "stylelint-selector-bem-pattern": "^4.0.1",
-    "stylelint-use-nesting": "^6.0.2",
-    "stylelint-value-no-unknown-custom-properties": "^6.1.1",
-    "toml-eslint-parser": "^1.0.3",
+    stylelint: "^17.10.0",
+    "stylelint-config-nick2bad4u": "^1.0.5",
     "ts-unused-exports": "^11.0.1",
     typedoc: "^0.28.19",
-    typescript: "^6.0.2",
-    "typescript-eslint": "^8.58.1",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.59.1",
     typesync: "^0.14.3",
     vfile: "^6.0.3",
-    vite: "^8.0.8",
+    vite: "^8.0.10",
     "vite-tsconfig-paths": "^6.1.1",
-    vitest: "^4.1.4",
-    "yaml-eslint-parser": "^2.0.0",
+    vitest: "^4.1.5",
     "yamllint-js": "^0.2.4"
   },
   peerDependencies: {
-    eslint: "^9.0.0 || ^10.2.0",
+    eslint: "^9.0.0 || ^10.3.0",
     typescript: ">=5.0.0"
   },
-  packageManager: "npm@11.12.1",
+  packageManager: "npm@11.13.0",
   engines: {
     node: ">=22.0.0"
   },
@@ -600,6 +361,7 @@ var package_default = {
 };
 
 // dist/_internal/copilot-config-references.js
+var import_ts_extras = require("ts-extras");
 var copilotConfigMetadataByName = {
   all: {
     icon: "\u{1F7E3}",
@@ -630,6 +392,7 @@ var copilotConfigMetadataByName = {
 // dist/_internal/copilot-file-kind.js
 var fs = __toESM(require("node:fs"), 1);
 var path = __toESM(require("node:path"), 1);
+var import_ts_extras2 = require("ts-extras");
 var normalizeFilePath = (filePath) => path.resolve(filePath).replaceAll("\\", "/");
 var isLegacyChatmodeFilePath = (filePath) => {
   const normalizedFilePath = normalizeFilePath(filePath);
@@ -689,11 +452,11 @@ var getCopilotFileKind = (filePath) => {
 };
 var findRepositoryRoot = (filePath) => {
   const normalizedFilePath = path.resolve(filePath);
-  const pathSegments = normalizeFilePath(normalizedFilePath).split("/");
+  const pathSegments = (0, import_ts_extras2.stringSplit)(normalizeFilePath(normalizedFilePath), "/");
   const githubDirectoryIndex = pathSegments.lastIndexOf(".github");
   if (githubDirectoryIndex > 0) {
     const rootSegments = pathSegments.slice(0, githubDirectoryIndex);
-    const candidateRoot = rootSegments.join(path.sep);
+    const candidateRoot = (0, import_ts_extras2.arrayJoin)(rootSegments, path.sep);
     if (candidateRoot.length > 0) {
       return candidateRoot;
     }
@@ -725,6 +488,7 @@ var getRepositoryInstructionsPaths = (filePath) => {
 var import_utils = require("@typescript-eslint/utils");
 
 // dist/_internal/rule-catalog.js
+var import_ts_extras3 = require("ts-extras");
 var orderedRuleNames = [
   "require-instructions-apply-to",
   "require-prompt-file-metadata",
@@ -808,9 +572,7 @@ var copilotRuleCatalogEntries = orderedRuleNames.map((ruleName, index) => {
 var copilotRuleCatalogByRuleName = new Map(copilotRuleCatalogEntries.map((entry) => [entry.ruleName, entry]));
 var getRuleCatalogEntryForRuleName = (ruleName) => {
   const entry = copilotRuleCatalogByRuleName.get(ruleName);
-  if (entry === void 0) {
-    throw new TypeError(`Rule '${ruleName}' is missing from the stable rule catalog.`);
-  }
+  (0, import_ts_extras3.assertDefined)(entry);
   return entry;
 };
 
@@ -869,6 +631,7 @@ var createCopilotRule = (ruleDefinition) => {
 };
 
 // dist/_internal/frontmatter.js
+var import_ts_extras4 = require("ts-extras");
 var isAsciiLetter = (character) => character >= "A" && character <= "Z" || character >= "a" && character <= "z";
 var isYamlIdentifierCharacter = (character) => isAsciiLetter(character) || character >= "0" && character <= "9" || character === "-";
 var isSupportedFrontmatterFieldName = (value) => {
@@ -984,12 +747,15 @@ var stripQuotes = (value) => {
 function normalizeScalarValue(value) {
   return stripQuotes(value.trim()).trim();
 }
-var setObjectEntryField = (target, source) => {
+var withObjectEntryField = (target, source) => {
   const property = parseFieldLine(source.trim());
   if (property === null) {
-    return;
+    return { ...target };
   }
-  target[property.key] = normalizeScalarValue(property.value);
+  return {
+    ...target,
+    [property.key]: normalizeScalarValue(property.value)
+  };
 };
 var parseInlineList = (value) => {
   const trimmedValue = value.trim();
@@ -1000,7 +766,7 @@ var parseInlineList = (value) => {
   if (innerValue.length === 0) {
     return [];
   }
-  return innerValue.split(",").map((item) => normalizeScalarValue(item)).filter((item) => item.length > 0);
+  return (0, import_ts_extras4.stringSplit)(innerValue, ",").map((item) => normalizeScalarValue(item)).filter((item) => item.length > 0);
 };
 var parseBlockList = (lines) => lines.map((line) => {
   const trimmedLine = line.trim();
@@ -1010,7 +776,7 @@ var parseBlockList = (lines) => lines.map((line) => {
   return normalizeScalarValue(trimmedLine.slice(1));
 }).filter((value) => value.length > 0);
 var parseFrontmatterFields = (content) => {
-  const lines = content.replaceAll("\r\n", "\n").split("\n");
+  const lines = (0, import_ts_extras4.stringSplit)(content.replaceAll("\r\n", "\n"), "\n");
   const fields = /* @__PURE__ */ new Map();
   let index = 0;
   while (index < lines.length) {
@@ -1092,134 +858,145 @@ var getFrontmatterList = (document, key) => {
   return field?.kind === "list" && field.values.length > 0 ? field.values : void 0;
 };
 var hasFrontmatterField = (document, key) => document.fields.has(key);
-var getFrontmatterObjectList = (document, key) => {
-  const lines = document.content.replaceAll("\r\n", "\n").split("\n");
-  let index = 0;
-  while (index < lines.length) {
-    const currentLine = lines[index] ?? "";
+var getFrontmatterContentLines = (document) => (0, import_ts_extras4.stringSplit)(document.content.replaceAll("\r\n", "\n"), "\n");
+var getTopLevelFrontmatterFieldBlock = (document, key) => {
+  const lines = getFrontmatterContentLines(document);
+  for (const [index, currentLine] of lines.entries()) {
     if (currentLine.startsWith(" ") || currentLine.startsWith("	")) {
-      index += 1;
       continue;
     }
     const field = parseFieldLine(currentLine.trimEnd());
-    if (field === null) {
-      index += 1;
-      continue;
-    }
-    if (field.key !== key) {
-      index += 1;
+    if (field?.key !== key) {
       continue;
     }
-    const rawValue = field.value.trim();
-    if (rawValue === "[]") {
-      return [];
-    }
-    if (rawValue.length > 0) {
-      return void 0;
-    }
-    const { blockLines } = collectIndentedBlockLines(lines, index + 1);
-    const entries = [];
-    let currentEntry = null;
-    for (const blockLine of blockLines) {
-      const trimmedLine = blockLine.trim();
-      if (trimmedLine.startsWith("-")) {
-        if (currentEntry !== null) {
-          entries.push(currentEntry);
-        }
-        currentEntry = {};
-        const inlineProperty = trimmedLine.slice(1).trim();
-        if (inlineProperty.length > 0) {
-          setObjectEntryField(currentEntry, inlineProperty);
-        }
-        continue;
-      }
-      if (currentEntry === null) {
-        continue;
-      }
-      setObjectEntryField(currentEntry, trimmedLine);
-    }
-    if (currentEntry !== null) {
-      entries.push(currentEntry);
-    }
-    return entries;
+    return {
+      blockLines: collectIndentedBlockLines(lines, index + 1).blockLines,
+      rawValue: field.value.trim()
+    };
   }
   return void 0;
 };
-var getFrontmatterObjectListGroups = (document, key) => {
-  const lines = document.content.replaceAll("\r\n", "\n").split("\n");
-  let index = 0;
-  while (index < lines.length) {
-    const currentLine = lines[index] ?? "";
-    if (currentLine.startsWith(" ") || currentLine.startsWith("	")) {
-      index += 1;
+var parseFrontmatterObjectListEntries = (blockLines) => {
+  const entries = [];
+  let currentEntry = null;
+  for (const blockLine of blockLines) {
+    const trimmedLine = blockLine.trim();
+    if (trimmedLine.startsWith("-")) {
+      if (currentEntry !== null) {
+        entries.push(currentEntry);
+      }
+      const inlineProperty = trimmedLine.slice(1).trim();
+      currentEntry = inlineProperty.length === 0 ? {} : withObjectEntryField({}, inlineProperty);
       continue;
     }
-    const field = parseFieldLine(currentLine.trimEnd());
-    if (field === null) {
-      index += 1;
+    if (currentEntry === null) {
       continue;
     }
-    if (field.key !== key) {
-      index += 1;
+    currentEntry = withObjectEntryField(currentEntry, trimmedLine);
+  }
+  if (currentEntry !== null) {
+    entries.push(currentEntry);
+  }
+  return entries;
+};
+var flushGroupedObjectListEntry = (groups, state) => {
+  if (state.currentGroupName === null || state.currentEntry === null) {
+    return state;
+  }
+  const groupEntries = groups.get(state.currentGroupName) ?? [];
+  groupEntries.push(state.currentEntry);
+  groups.set(state.currentGroupName, groupEntries);
+  return {
+    ...state,
+    currentEntry: null
+  };
+};
+var isGroupedObjectListHeaderLine = (indentationWidth, trimmedLine) => !trimmedLine.startsWith("-") && indentationWidth <= 4;
+var createGroupedObjectListEntry = (trimmedLine) => {
+  const inlineProperty = trimmedLine.slice(1).trim();
+  return inlineProperty.length === 0 ? {} : withObjectEntryField({}, inlineProperty);
+};
+var handleGroupedObjectListHeaderLine = (groups, state, trimmedLine) => {
+  const flushedState = flushGroupedObjectListEntry(groups, state);
+  const groupField = parseFieldLine(trimmedLine);
+  if (groupField === null) {
+    return {
+      ...flushedState,
+      currentGroupName: null
+    };
+  }
+  groups.set(groupField.key, groups.get(groupField.key) ?? []);
+  return {
+    ...flushedState,
+    currentGroupName: groupField.key
+  };
+};
+var handleGroupedObjectListEntryStartLine = (groups, state, trimmedLine) => {
+  const flushedState = flushGroupedObjectListEntry(groups, state);
+  if (flushedState.currentGroupName === null) {
+    return flushedState;
+  }
+  return {
+    ...flushedState,
+    currentEntry: createGroupedObjectListEntry(trimmedLine)
+  };
+};
+var handleGroupedObjectListPropertyLine = (state, trimmedLine) => {
+  if (state.currentEntry === null) {
+    return state;
+  }
+  return {
+    ...state,
+    currentEntry: withObjectEntryField(state.currentEntry, trimmedLine)
+  };
+};
+var parseFrontmatterObjectListGroups = (blockLines) => {
+  const groups = /* @__PURE__ */ new Map();
+  let state = {
+    currentEntry: null,
+    currentGroupName: null
+  };
+  for (const blockLine of blockLines) {
+    const indentationWidth = getIndentationWidth(blockLine);
+    const trimmedLine = blockLine.trim();
+    if (trimmedLine.length === 0) {
       continue;
     }
-    const rawValue = field.value.trim();
-    if (rawValue.length > 0) {
-      return void 0;
+    if (isGroupedObjectListHeaderLine(indentationWidth, trimmedLine)) {
+      state = handleGroupedObjectListHeaderLine(groups, state, trimmedLine);
+      continue;
     }
-    const { blockLines } = collectIndentedBlockLines(lines, index + 1);
-    const groups = /* @__PURE__ */ new Map();
-    let currentGroupName = null;
-    let currentEntry = null;
-    const flushCurrentEntry = () => {
-      if (currentGroupName === null || currentEntry === null) {
-        return;
-      }
-      const groupEntries = groups.get(currentGroupName) ?? [];
-      groupEntries.push(currentEntry);
-      groups.set(currentGroupName, groupEntries);
-      currentEntry = null;
-    };
-    for (const blockLine of blockLines) {
-      const indentationWidth = getIndentationWidth(blockLine);
-      const trimmedLine = blockLine.trim();
-      if (trimmedLine.length === 0) {
-        continue;
-      }
-      if (!trimmedLine.startsWith("-") && indentationWidth <= 4) {
-        flushCurrentEntry();
-        const groupField = parseFieldLine(trimmedLine);
-        if (groupField === null) {
-          currentGroupName = null;
-          continue;
-        }
-        currentGroupName = groupField.key;
-        if (currentGroupName !== null && !groups.has(currentGroupName)) {
-          groups.set(currentGroupName, []);
-        }
-        continue;
-      }
-      if (trimmedLine.startsWith("-")) {
-        flushCurrentEntry();
-        if (currentGroupName === null) {
-          continue;
-        }
-        currentEntry = {};
-        const inlineProperty = trimmedLine.slice(1).trim();
-        if (inlineProperty.length > 0) {
-          setObjectEntryField(currentEntry, inlineProperty);
-        }
-        continue;
-      }
-      if (currentEntry === null) {
-        continue;
-      }
-      setObjectEntryField(currentEntry, trimmedLine);
+    if (trimmedLine.startsWith("-")) {
+      state = handleGroupedObjectListEntryStartLine(groups, state, trimmedLine);
+      continue;
     }
-    flushCurrentEntry();
-    return groups;
+    state = handleGroupedObjectListPropertyLine(state, trimmedLine);
   }
-  return void 0;
+  flushGroupedObjectListEntry(groups, state);
+  return groups;
+};
+var getFrontmatterObjectList = (document, key) => {
+  const fieldBlock = getTopLevelFrontmatterFieldBlock(document, key);
+  if (!(0, import_ts_extras4.isDefined)(fieldBlock)) {
+    return void 0;
+  }
+  if (fieldBlock.rawValue === "[]") {
+    return [];
+  }
+  if (fieldBlock.rawValue.length > 0) {
+    return void 0;
+  }
+  return parseFrontmatterObjectListEntries(fieldBlock.blockLines);
+};
+var getFrontmatterObjectListGroups = (document, key) => {
+  const fieldBlock = getTopLevelFrontmatterFieldBlock(document, key);
+  if (!(0, import_ts_extras4.isDefined)(fieldBlock)) {
+    return void 0;
+  }
+  if (fieldBlock.rawValue.length > 0) {
+    return void 0;
+  }
+  return parseFrontmatterObjectListGroups(fieldBlock.blockLines);
 };
 var getMeaningfulMarkdownBody = (text) => stripHtmlComments(text).trim();
 
@@ -1269,7 +1046,8 @@ var noBlankCustomizationBodyRule = createCopilotRule({
       description: "disallow blank bodies in Copilot customization files other than repository-wide instructions.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-blank-customization-body")
     },
     messages: {
       blankBody: "Copilot customization files should include meaningful Markdown instructions in the document body, not only frontmatter or comments."
@@ -1309,7 +1087,8 @@ var noBlankRepositoryInstructionsRule = createCopilotRule({
       description: "disallow empty repository-wide Copilot instructions files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-blank-repository-instructions")
     },
     messages: {
       blankInstructions: "Repository-wide Copilot instructions should contain actionable Markdown guidance instead of being blank."
@@ -1349,7 +1128,8 @@ var noBlankSkillBodyRule = createCopilotRule({
       description: "disallow blank Copilot skill definition bodies.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-blank-skill-body")
     },
     messages: {
       blankSkillBody: "Copilot skill definition files should include a non-empty Markdown body with instructions, examples, or guidance."
@@ -1388,7 +1168,8 @@ var noDeprecatedAgentInferRule = createCopilotRule({
       description: "disallow deprecated `infer` frontmatter in Copilot custom agent files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-deprecated-agent-infer")
     },
     messages: {
       deprecatedInfer: "Copilot custom agent files should replace deprecated `infer` frontmatter with `user-invocable` and/or `disable-model-invocation`."
@@ -1403,6 +1184,7 @@ var no_deprecated_agent_infer_default = noDeprecatedAgentInferRule;
 // dist/rules/no-duplicate-agent-names.js
 var fs3 = __toESM(require("node:fs"), 1);
 var path4 = __toESM(require("node:path"), 1);
+var import_ts_extras6 = require("ts-extras");
 
 // dist/_internal/copilot-customization-names.js
 var path2 = __toESM(require("node:path"), 1);
@@ -1459,6 +1241,7 @@ var collectDuplicateNameGroups = (entries, normalizeName) => {
 // dist/_internal/file-system.js
 var fs2 = __toESM(require("node:fs"), 1);
 var path3 = __toESM(require("node:path"), 1);
+var import_ts_extras5 = require("ts-extras");
 var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[/\\]/u;
 var URI_SCHEME_PATTERN = /^[A-Za-z][+\-.0-9A-Za-z]*:/u;
 var normalizeAbsolutePath = (filePath) => path3.resolve(filePath).replaceAll("\\", "/");
@@ -1467,7 +1250,7 @@ var stripPathFragmentAndQuery = (value) => {
   const queryIndex = value.indexOf("?");
   const fragmentIndex = value.indexOf("#");
   const cutIndexCandidates = [queryIndex, fragmentIndex].filter((index) => index >= 0);
-  if (cutIndexCandidates.length === 0) {
+  if ((0, import_ts_extras5.isEmpty)(cutIndexCandidates)) {
     return value;
   }
   return value.slice(0, Math.min(...cutIndexCandidates));
@@ -1491,6 +1274,30 @@ var isRelativeWorkspacePath = (value) => {
 };
 var resolveRelativeWorkspacePath = (currentFilePath, relativePath) => path3.resolve(path3.dirname(currentFilePath), stripPathFragmentAndQuery(relativePath));
 var resolveRepositoryRelativePath = (repositoryRootPath, relativePath) => path3.resolve(repositoryRootPath, stripPathFragmentAndQuery(relativePath));
+var collectDirectoryFiles = (currentDirectory, predicate) => {
+  const discoveredFiles = [];
+  const pendingDirectories = [];
+  for (const entry of fs2.readdirSync(currentDirectory, {
+    withFileTypes: true
+  })) {
+    const absoluteEntryPath = path3.join(currentDirectory, entry.name);
+    if (entry.isDirectory()) {
+      pendingDirectories.push(absoluteEntryPath);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if ((0, import_ts_extras5.isDefined)(predicate) && !predicate(absoluteEntryPath)) {
+      continue;
+    }
+    discoveredFiles.push(absoluteEntryPath);
+  }
+  return {
+    discoveredFiles,
+    pendingDirectories
+  };
+};
 var listFilesRecursively = (directoryPath, predicate) => {
   if (!pathExists(directoryPath)) {
     return [];
@@ -1499,25 +1306,12 @@ var listFilesRecursively = (directoryPath, predicate) => {
   const pendingDirectories = [directoryPath];
   while (pendingDirectories.length > 0) {
     const currentDirectory = pendingDirectories.pop();
-    if (currentDirectory === void 0) {
+    if (!(0, import_ts_extras5.isDefined)(currentDirectory)) {
       continue;
     }
-    for (const entry of fs2.readdirSync(currentDirectory, {
-      withFileTypes: true
-    })) {
-      const absoluteEntryPath = path3.join(currentDirectory, entry.name);
-      if (entry.isDirectory()) {
-        pendingDirectories.push(absoluteEntryPath);
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      if (predicate !== void 0 && !predicate(absoluteEntryPath)) {
-        continue;
-      }
-      discoveredFiles.push(absoluteEntryPath);
-    }
+    const currentDirectoryContents = collectDirectoryFiles(currentDirectory, predicate);
+    pendingDirectories.push(...currentDirectoryContents.pendingDirectories);
+    discoveredFiles.push(...currentDirectoryContents.discoveredFiles);
   }
   return discoveredFiles.toSorted((left, right) => left.localeCompare(right));
 };
@@ -1542,12 +1336,12 @@ var noDuplicateAgentNamesRule = createCopilotRule({
       }), normalizeNameForComparison);
       const currentAgentName = getAgentName(context.filename, extractFrontmatter(context.sourceCode.text));
       const duplicateGroup = duplicateGroups.get(normalizeNameForComparison(currentAgentName));
-      if (duplicateGroup === void 0) {
+      if (!(0, import_ts_extras6.isDefined)(duplicateGroup)) {
         return;
       }
       reportAtDocumentStart(context, {
         data: {
-          files: duplicateGroup.map((entry) => normalizeRelativeFilePath(repositoryRoot, entry.filePath)).join(", "),
+          files: (0, import_ts_extras6.arrayJoin)(duplicateGroup.map((entry) => normalizeRelativeFilePath(repositoryRoot, entry.filePath)), ", "),
           name: currentAgentName
         },
         messageId: "duplicateAgentName"
@@ -1565,7 +1359,8 @@ var noDuplicateAgentNamesRule = createCopilotRule({
       description: "disallow duplicate effective custom-agent names across workspace custom-agent files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-duplicate-agent-names")
     },
     messages: {
       duplicateAgentName: "Copilot custom-agent name `{{name}}` is duplicated across agent files: {{files}}."
@@ -1580,6 +1375,7 @@ var no_duplicate_agent_names_default = noDuplicateAgentNamesRule;
 // dist/rules/no-duplicate-prompt-names.js
 var fs4 = __toESM(require("node:fs"), 1);
 var path5 = __toESM(require("node:path"), 1);
+var import_ts_extras7 = require("ts-extras");
 var normalizeRelativeFilePath2 = (repositoryRoot, filePath) => path5.relative(repositoryRoot, filePath).replaceAll("\\", "/");
 var noDuplicatePromptNamesRule = createCopilotRule({
   create(context) {
@@ -1599,12 +1395,12 @@ var noDuplicatePromptNamesRule = createCopilotRule({
       }), normalizeNameForComparison);
       const currentPromptName = getPromptName(context.filename, extractFrontmatter(context.sourceCode.text));
       const duplicateGroup = duplicateGroups.get(normalizeNameForComparison(currentPromptName));
-      if (duplicateGroup === void 0) {
+      if (!(0, import_ts_extras7.isDefined)(duplicateGroup)) {
         return;
       }
       reportAtDocumentStart(context, {
         data: {
-          files: duplicateGroup.map((entry) => normalizeRelativeFilePath2(repositoryRoot, entry.filePath)).join(", "),
+          files: (0, import_ts_extras7.arrayJoin)(duplicateGroup.map((entry) => normalizeRelativeFilePath2(repositoryRoot, entry.filePath)), ", "),
           name: currentPromptName
         },
         messageId: "duplicatePromptName"
@@ -1622,7 +1418,8 @@ var noDuplicatePromptNamesRule = createCopilotRule({
       description: "disallow duplicate effective prompt names across workspace prompt files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-duplicate-prompt-names")
     },
     messages: {
       duplicatePromptName: "Copilot prompt name `{{name}}` is duplicated across prompt files: {{files}}."
@@ -1637,6 +1434,7 @@ var no_duplicate_prompt_names_default = noDuplicatePromptNamesRule;
 // dist/rules/no-duplicate-skill-names.js
 var fs5 = __toESM(require("node:fs"), 1);
 var path6 = __toESM(require("node:path"), 1);
+var import_ts_extras8 = require("ts-extras");
 var normalizeRelativeFilePath3 = (repositoryRoot, filePath) => path6.relative(repositoryRoot, filePath).replaceAll("\\", "/");
 var noDuplicateSkillNamesRule = createCopilotRule({
   create(context) {
@@ -1658,12 +1456,12 @@ var noDuplicateSkillNamesRule = createCopilotRule({
       }), normalizeNameForComparison);
       const currentSkillName = getSkillName(context.filename, extractFrontmatter(context.sourceCode.text));
       const duplicateGroup = duplicateGroups.get(normalizeNameForComparison(currentSkillName));
-      if (duplicateGroup === void 0) {
+      if (!(0, import_ts_extras8.isDefined)(duplicateGroup)) {
         return;
       }
       reportAtDocumentStart(context, {
         data: {
-          files: duplicateGroup.map((entry) => normalizeRelativeFilePath3(repositoryRoot, entry.filePath)).join(", "),
+          files: (0, import_ts_extras8.arrayJoin)(duplicateGroup.map((entry) => normalizeRelativeFilePath3(repositoryRoot, entry.filePath)), ", "),
           name: currentSkillName
         },
         messageId: "duplicateSkillName"
@@ -1681,7 +1479,8 @@ var noDuplicateSkillNamesRule = createCopilotRule({
       description: "disallow duplicate effective skill names across project skill definition files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-duplicate-skill-names")
     },
     messages: {
       duplicateSkillName: "Copilot skill name `{{name}}` is duplicated across skill files: {{files}}."
@@ -1696,6 +1495,7 @@ var no_duplicate_skill_names_default = noDuplicateSkillNamesRule;
 // dist/rules/no-duplicate-slash-command-names.js
 var fs6 = __toESM(require("node:fs"), 1);
 var path7 = __toESM(require("node:path"), 1);
+var import_ts_extras9 = require("ts-extras");
 var isPromptOrSkillCommandFile = (filePath) => filePath.endsWith(".prompt.md") || isSkillFilePath(filePath);
 var normalizeRelativeFilePath4 = (repositoryRoot, filePath) => path7.relative(repositoryRoot, filePath).replaceAll("\\", "/");
 var noDuplicateSlashCommandNamesRule = createCopilotRule({
@@ -1721,12 +1521,12 @@ var noDuplicateSlashCommandNamesRule = createCopilotRule({
       const frontmatter = extractFrontmatter(context.sourceCode.text);
       const currentCommandName = context.filename.endsWith(".prompt.md") ? getPromptName(context.filename, frontmatter) : getSkillName(context.filename, frontmatter);
       const duplicateGroup = duplicateGroups.get(normalizeNameForComparison(currentCommandName));
-      if (duplicateGroup === void 0) {
+      if (!(0, import_ts_extras9.isDefined)(duplicateGroup)) {
         return;
       }
       reportAtDocumentStart(context, {
         data: {
-          files: duplicateGroup.map((entry) => normalizeRelativeFilePath4(repositoryRoot, entry.filePath)).join(", "),
+          files: (0, import_ts_extras9.arrayJoin)(duplicateGroup.map((entry) => normalizeRelativeFilePath4(repositoryRoot, entry.filePath)), ", "),
           name: currentCommandName
         },
         messageId: "duplicateSlashCommandName"
@@ -1744,7 +1544,8 @@ var noDuplicateSlashCommandNamesRule = createCopilotRule({
       description: "disallow duplicate slash-command names across prompt files and skills.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-duplicate-slash-command-names")
     },
     messages: {
       duplicateSlashCommandName: "Slash command name `{{name}}` is duplicated across prompt or skill files: {{files}}."
@@ -1756,7 +1557,11 @@ var noDuplicateSlashCommandNamesRule = createCopilotRule({
 });
 var no_duplicate_slash_command_names_default = noDuplicateSlashCommandNamesRule;
 
+// dist/rules/no-empty-repository-hook-arrays.js
+var import_ts_extras11 = require("ts-extras");
+
 // dist/_internal/repository-hooks-json.js
+var import_ts_extras10 = require("ts-extras");
 var DEFAULT_REPOSITORY_HOOK_TIMEOUT_SECONDS = 30;
 var VALID_REPOSITORY_HOOK_EVENT_NAMES = /* @__PURE__ */ new Set([
   "agentStop",
@@ -1769,15 +1574,15 @@ var VALID_REPOSITORY_HOOK_EVENT_NAMES = /* @__PURE__ */ new Set([
   "userPromptSubmitted"
 ]);
 var VALID_REPOSITORY_HOOK_TYPES = /* @__PURE__ */ new Set(["command", "prompt"]);
-var isRepositoryHookEventName = (value) => VALID_REPOSITORY_HOOK_EVENT_NAMES.has(value);
-var isRepositoryHookType = (value) => VALID_REPOSITORY_HOOK_TYPES.has(value);
+var isRepositoryHookEventName = (value) => (0, import_ts_extras10.setHas)(VALID_REPOSITORY_HOOK_EVENT_NAMES, value);
+var isRepositoryHookType = (value) => (0, import_ts_extras10.setHas)(VALID_REPOSITORY_HOOK_TYPES, value);
 var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isJsonArray = (value) => Array.isArray(value);
 var isJsonString = (value) => typeof value === "string";
-var isJsonNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var isJsonNumber = (value) => typeof value === "number" && (0, import_ts_extras10.isFinite)(value);
 var parseJsonText = (text) => {
   try {
-    return JSON.parse(text);
+    return (0, import_ts_extras10.safeCastTo)(JSON.parse(text));
   } catch {
     return void 0;
   }
@@ -1786,7 +1591,7 @@ var getRepositoryHooksValue = (root) => isJsonObject(root) ? root["hooks"] : voi
 var getRepositoryHooksVersionValue = (root) => isJsonObject(root) ? root["version"] : void 0;
 var getRepositoryHookEventEntries = (root) => {
   const hooksValue = getRepositoryHooksValue(root);
-  return isJsonObject(hooksValue) ? Object.entries(hooksValue) : [];
+  return isJsonObject(hooksValue) ? (0, import_ts_extras10.objectEntries)(hooksValue) : [];
 };
 var getRepositoryHookObjects = (root) => {
   const hookEntries = [];
@@ -1808,7 +1613,7 @@ var getRepositoryHookObjects = (root) => {
   return hookEntries;
 };
 var formatJsonValue = (value) => {
-  if (value === void 0) {
+  if (!(0, import_ts_extras10.isDefined)(value)) {
     return "(missing)";
   }
   if (typeof value === "string") {
@@ -1826,13 +1631,13 @@ var noEmptyRepositoryHookArraysRule = createCopilotRule({
           return;
         }
         const root = parseJsonText(context.sourceCode.text);
-        const emptyEntry = getRepositoryHookEventEntries(root).find(([, eventValue]) => isJsonArray(eventValue) && eventValue.length === 0);
-        if (emptyEntry === void 0) {
+        const emptyEntry = getRepositoryHookEventEntries(root).find(([, eventValue]) => isJsonArray(eventValue) && (0, import_ts_extras11.isEmpty)(eventValue));
+        if (!(0, import_ts_extras11.isDefined)(emptyEntry)) {
           return;
         }
         reportAtDocumentStart(context, {
           data: {
-            eventName: emptyEntry[0]
+            eventName: (0, import_ts_extras11.arrayFirst)(emptyEntry)
           },
           messageId: "emptyRepositoryHookArray"
         });
@@ -1846,7 +1651,8 @@ var noEmptyRepositoryHookArraysRule = createCopilotRule({
       description: "disallow empty repository hook arrays that opt into an event without any hook definitions.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-empty-repository-hook-arrays")
     },
     messages: {
       emptyRepositoryHookArray: "Repository hook event `{{eventName}}` should not be declared with an empty array."
@@ -1881,7 +1687,8 @@ var noLegacyChatmodeFilesRule = createCopilotRule({
       description: "disallow legacy Copilot `.chatmode.md` files in favor of modern `.agent.md` custom agents.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("no-legacy-chatmode-files")
     },
     messages: {
       legacyChatmodeFile: "Legacy Copilot `.chatmode.md` files should be migrated to `.github/agents/*.agent.md` custom agents."
@@ -1925,7 +1732,8 @@ var preferCustomInstructionsUnderCodeReviewLimitRule = createCopilotRule({
       description: "enforce repository and path-specific Copilot instruction files staying within the 4,000-character code-review instruction budget.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("prefer-custom-instructions-under-code-review-limit")
     },
     messages: {
       exceedsCodeReviewLimit: "Copilot code review only reads roughly the first {{maxCharacters}} characters of custom instructions; this file is {{characterCount}} characters long."
@@ -1938,6 +1746,7 @@ var preferCustomInstructionsUnderCodeReviewLimitRule = createCopilotRule({
 var prefer_custom_instructions_under_code_review_limit_default = preferCustomInstructionsUnderCodeReviewLimitRule;
 
 // dist/rules/prefer-fast-repository-hooks.js
+var import_ts_extras12 = require("ts-extras");
 var preferFastRepositoryHooksRule = createCopilotRule({
   create(context) {
     return {
@@ -1950,7 +1759,7 @@ var preferFastRepositoryHooksRule = createCopilotRule({
           const timeout2 = hook["timeoutSec"];
           return isJsonNumber(timeout2) && timeout2 > DEFAULT_REPOSITORY_HOOK_TIMEOUT_SECONDS;
         });
-        if (slowHook === void 0) {
+        if (!(0, import_ts_extras12.isDefined)(slowHook)) {
           return;
         }
         const timeout = slowHook.hook["timeoutSec"];
@@ -1974,7 +1783,8 @@ var preferFastRepositoryHooksRule = createCopilotRule({
       description: "enforce repository hooks staying at or below the default 30-second timeout unless a slower hook is truly necessary.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("prefer-fast-repository-hooks")
     },
     messages: {
       slowRepositoryHookTimeout: "Repository hook `timeoutSec` for `{{eventName}}` is {{timeout}} seconds, which exceeds the default 30-second timeout budget."
@@ -1987,8 +1797,10 @@ var preferFastRepositoryHooksRule = createCopilotRule({
 var prefer_fast_repository_hooks_default = preferFastRepositoryHooksRule;
 
 // dist/rules/prefer-qualified-tools.js
+var import_ts_extras13 = require("ts-extras");
 var isQualifiedToolName = (toolName) => toolName.includes("/");
 var allowedUnqualifiedToolNames = /* @__PURE__ */ new Set(["agent", "runSubagent"]);
+var isAllowedUnqualifiedToolName = (toolName) => (0, import_ts_extras13.setHas)(allowedUnqualifiedToolNames, toolName);
 var preferQualifiedToolsRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2001,11 +1813,11 @@ var preferQualifiedToolsRule = createCopilotRule({
         return;
       }
       const tools = getFrontmatterList(frontmatter, "tools");
-      if (tools === void 0) {
+      if (!(0, import_ts_extras13.isDefined)(tools)) {
         return;
       }
-      const firstUnqualifiedTool = tools.find((toolName) => !isQualifiedToolName(toolName) && !allowedUnqualifiedToolNames.has(toolName));
-      if (firstUnqualifiedTool === void 0) {
+      const firstUnqualifiedTool = tools.find((toolName) => !isQualifiedToolName(toolName) && !isAllowedUnqualifiedToolName(toolName)) ?? null;
+      if (firstUnqualifiedTool === null) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -2021,7 +1833,8 @@ var preferQualifiedToolsRule = createCopilotRule({
       description: "enforce fully-qualified tool names in Copilot prompt files, custom agents, and legacy chat modes.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("prefer-qualified-tools")
     },
     messages: {
       preferQualifiedTool: "Prefer fully-qualified Copilot tool names in `tools` metadata when a documented built-in alias is not required. `{{toolName}}` should include a provider or tool-set prefix such as `search/codebase`."
@@ -2034,7 +1847,8 @@ var preferQualifiedToolsRule = createCopilotRule({
 var prefer_qualified_tools_default = preferQualifiedToolsRule;
 
 // dist/rules/require-agent-tool-for-subagents.js
-var hasAgentTool = (tools) => tools?.some((toolName) => toolName.split("/").at(-1) === "agent") ?? false;
+var import_ts_extras14 = require("ts-extras");
+var hasAgentTool = (tools) => tools?.some((toolName) => (0, import_ts_extras14.arrayAt)((0, import_ts_extras14.stringSplit)(toolName, "/"), -1) === "agent") ?? false;
 var requireAgentToolForSubagentsRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2050,7 +1864,7 @@ var requireAgentToolForSubagentsRule = createCopilotRule({
       }
       const allowedAgents = getFrontmatterList(frontmatter, "agents");
       const agentsScalar = getFrontmatterScalar(frontmatter, "agents");
-      if (agentsScalar !== "*" && (allowedAgents === void 0 || allowedAgents.length === 0)) {
+      if (agentsScalar !== "*" && (!(0, import_ts_extras14.isDefined)(allowedAgents) || (0, import_ts_extras14.isEmpty)(allowedAgents))) {
         return;
       }
       const tools = getFrontmatterList(frontmatter, "tools");
@@ -2073,7 +1887,8 @@ var requireAgentToolForSubagentsRule = createCopilotRule({
       description: "require custom agents that declare subagents to also include the `agent` tool.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-agent-tool-for-subagents")
     },
     messages: {
       missingAgentTool: "Copilot custom agent files that declare `agents` must include the `agent` tool in `tools`.",
@@ -2117,7 +1932,8 @@ var requireAgentsMdForCrossSurfaceAgentInstructionsRule = createCopilotRule({
       description: "require `CLAUDE.md` and `GEMINI.md` agent-instructions files to be paired with a sibling `AGENTS.md` for broader cross-surface support.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-agents-md-for-cross-surface-agent-instructions")
     },
     messages: {
       missingAgentsMdSibling: "`{{basename}}` is less portable across Copilot surfaces without a sibling `AGENTS.md` file in the same directory."
@@ -2130,6 +1946,7 @@ var requireAgentsMdForCrossSurfaceAgentInstructionsRule = createCopilotRule({
 var require_agents_md_for_cross_surface_agent_instructions_default = requireAgentsMdForCrossSurfaceAgentInstructionsRule;
 
 // dist/rules/require-chatmode-file-metadata.js
+var import_ts_extras15 = require("ts-extras");
 var requireChatmodeFileMetadataRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2144,7 +1961,7 @@ var requireChatmodeFileMetadataRule = createCopilotRule({
         return;
       }
       const description = getFrontmatterScalar(frontmatter, "description");
-      if (description !== void 0) {
+      if ((0, import_ts_extras15.isDefined)(description)) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -2164,7 +1981,8 @@ var requireChatmodeFileMetadataRule = createCopilotRule({
       description: "require custom Copilot agent files and legacy chat mode files to declare a non-empty description in frontmatter.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-chatmode-file-metadata")
     },
     messages: {
       emptyDescription: "Copilot custom agent and legacy chat mode files must define a non-empty `description` frontmatter value.",
@@ -2179,6 +1997,7 @@ var requireChatmodeFileMetadataRule = createCopilotRule({
 var require_chatmode_file_metadata_default = requireChatmodeFileMetadataRule;
 
 // dist/rules/require-existing-agent-hook-cwd.js
+var import_ts_extras16 = require("ts-extras");
 var requireExistingAgentHookCwdRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2187,7 +2006,7 @@ var requireExistingAgentHookCwdRule = createCopilotRule({
       }
       const frontmatter = extractFrontmatter(context.sourceCode.text);
       const hookGroups = frontmatter === null ? void 0 : getFrontmatterObjectListGroups(frontmatter, "hooks");
-      if (hookGroups === void 0 || hookGroups.size === 0) {
+      if (!(0, import_ts_extras16.isDefined)(hookGroups) || hookGroups.size === 0) {
         return;
       }
       const repositoryRoot = findRepositoryRoot(context.filename);
@@ -2196,7 +2015,7 @@ var requireExistingAgentHookCwdRule = createCopilotRule({
           const cwd = entry["cwd"]?.trim();
           return typeof cwd === "string" && cwd.length > 0 && isRelativeWorkspacePath(cwd) && !pathExists(resolveRepositoryRelativePath(repositoryRoot, cwd));
         })?.["cwd"];
-        if (missingCwd === void 0) {
+        if (!(0, import_ts_extras16.isDefined)(missingCwd)) {
           continue;
         }
         reportAtDocumentStart(context, {
@@ -2216,7 +2035,8 @@ var requireExistingAgentHookCwdRule = createCopilotRule({
       description: "require Copilot custom-agent hook `cwd` entries to resolve to existing repository directories.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-agent-hook-cwd")
     },
     messages: {
       missingAgentHookCwd: "Copilot custom-agent hook `cwd` value `{{cwd}}` does not resolve to an existing repository path."
@@ -2229,6 +2049,7 @@ var requireExistingAgentHookCwdRule = createCopilotRule({
 var require_existing_agent_hook_cwd_default = requireExistingAgentHookCwdRule;
 
 // dist/rules/require-existing-agent-mcp-servers.js
+var import_ts_extras17 = require("ts-extras");
 var requireExistingAgentMcpServersRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2237,12 +2058,12 @@ var requireExistingAgentMcpServersRule = createCopilotRule({
       }
       const frontmatter = extractFrontmatter(context.sourceCode.text);
       const mcpServers = frontmatter === null ? void 0 : getFrontmatterList(frontmatter, "mcp-servers");
-      if (mcpServers === void 0) {
+      if (!(0, import_ts_extras17.isDefined)(mcpServers)) {
         return;
       }
       const repositoryRoot = findRepositoryRoot(context.filename);
       const missingServer = mcpServers.find((serverPath) => !pathExists(resolveRepositoryRelativePath(repositoryRoot, serverPath)));
-      if (missingServer === void 0) {
+      if (!(0, import_ts_extras17.isDefined)(missingServer)) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -2263,7 +2084,8 @@ var requireExistingAgentMcpServersRule = createCopilotRule({
       description: "require Copilot custom-agent `mcp-servers` entries to resolve to existing repository files.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-agent-mcp-servers")
     },
     messages: {
       missingAgentMcpServer: "Copilot custom-agent `mcp-servers` entry `{{mcpServer}}` does not resolve to an existing repository file."
@@ -2286,6 +2108,7 @@ var getCustomizationBodyWithOffset = (sourceText) => {
 };
 
 // dist/_internal/markdown-links.js
+var import_ts_extras18 = require("ts-extras");
 var FENCED_BACKTICK_CODE_BLOCK_PATTERN = /```[\s\S]*?```/gu;
 var FENCED_TILDE_CODE_BLOCK_PATTERN = /~~~[\s\S]*?~~~/gu;
 var INLINE_CODE_PATTERN = /`[^\n\r`]+`/gu;
@@ -2295,7 +2118,8 @@ var extractMarkdownLinkDestination = (rawDestination) => {
   if (trimmedDestination.startsWith("<") && trimmedDestination.endsWith(">")) {
     return trimmedDestination.slice(1, -1).trim();
   }
-  const [destination] = trimmedDestination.split(/\s+/u, 1);
+  const normalizedDestination = trimmedDestination.replaceAll(/\s+/gu, " ");
+  const [destination] = (0, import_ts_extras18.stringSplit)(normalizedDestination, " ");
   return destination?.trim() ?? "";
 };
 var extractMarkdownLinks = (text, offset = 0) => {
@@ -2387,7 +2211,8 @@ var requireExistingRelativeAgentLinksRule = createCopilotRule({
       description: "require relative Markdown links in Copilot custom agents to resolve to existing workspace targets.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-relative-agent-links")
     },
     messages: {
       missingAgentLinkTarget: "Copilot custom-agent relative link `{{destination}}` does not resolve to an existing workspace path."
@@ -2439,7 +2264,8 @@ var requireExistingRelativeInstructionsLinksRule = createCopilotRule({
       description: "require relative Markdown links in path-specific Copilot instructions files to resolve to existing workspace targets.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-relative-instructions-links")
     },
     messages: {
       missingInstructionsLinkTarget: "Copilot instructions relative link `{{destination}}` does not resolve to an existing workspace path."
@@ -2491,7 +2317,8 @@ var requireExistingRelativePromptLinksRule = createCopilotRule({
       description: "require relative Markdown links in Copilot prompt files to resolve to existing workspace targets.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-relative-prompt-links")
     },
     messages: {
       missingPromptLinkTarget: "Copilot prompt-file relative link `{{destination}}` does not resolve to an existing workspace path."
@@ -2543,7 +2370,8 @@ var requireExistingRelativeSkillLinksRule = createCopilotRule({
       description: "require relative Markdown links in Copilot skill definition files to resolve to existing workspace resources.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-relative-skill-links")
     },
     messages: {
       missingSkillLinkTarget: "Copilot skill relative link `{{destination}}` does not resolve to an existing workspace path."
@@ -2556,6 +2384,7 @@ var requireExistingRelativeSkillLinksRule = createCopilotRule({
 var require_existing_relative_skill_links_default = requireExistingRelativeSkillLinksRule;
 
 // dist/rules/require-existing-repository-hook-cwd.js
+var import_ts_extras19 = require("ts-extras");
 var requireExistingRepositoryHookCwdRule = createCopilotRule({
   create(context) {
     return {
@@ -2569,7 +2398,7 @@ var requireExistingRepositoryHookCwdRule = createCopilotRule({
           const cwd2 = hook["cwd"];
           return isJsonString(cwd2) && cwd2.trim().length > 0 && isRelativeWorkspacePath(cwd2) && !pathExists(resolveRepositoryRelativePath(repositoryRoot, cwd2));
         });
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras19.isDefined)(invalidHook)) {
           return;
         }
         const cwd = invalidHook.hook["cwd"];
@@ -2596,7 +2425,8 @@ var requireExistingRepositoryHookCwdRule = createCopilotRule({
       description: "require repository hook `cwd` values to resolve to existing repository paths.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-existing-repository-hook-cwd")
     },
     messages: {
       missingRepositoryHookCwd: "Repository hook `cwd` value `{{cwd}}` for `{{eventName}}` does not resolve to an existing repository path."
@@ -2609,6 +2439,7 @@ var requireExistingRepositoryHookCwdRule = createCopilotRule({
 var require_existing_repository_hook_cwd_default = requireExistingRepositoryHookCwdRule;
 
 // dist/rules/require-github-copilot-target-for-mcp-servers.js
+var import_ts_extras20 = require("ts-extras");
 var requireGithubCopilotTargetForMcpServersRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2623,7 +2454,7 @@ var requireGithubCopilotTargetForMcpServersRule = createCopilotRule({
       if (target === "github-copilot") {
         return;
       }
-      if (target === void 0) {
+      if (!(0, import_ts_extras20.isDefined)(target)) {
         reportAtDocumentStart(context, {
           messageId: hasFrontmatterField(frontmatter, "target") ? "emptyTarget" : "missingTarget"
         });
@@ -2646,7 +2477,8 @@ var requireGithubCopilotTargetForMcpServersRule = createCopilotRule({
       description: "require custom agents that declare `mcp-servers` to set `target: github-copilot`.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-github-copilot-target-for-mcp-servers")
     },
     messages: {
       emptyTarget: "Copilot custom agent files that declare `mcp-servers` must define a non-empty `target: github-copilot` frontmatter value.",
@@ -2661,6 +2493,7 @@ var requireGithubCopilotTargetForMcpServersRule = createCopilotRule({
 var require_github_copilot_target_for_mcp_servers_default = requireGithubCopilotTargetForMcpServersRule;
 
 // dist/rules/require-instructions-apply-to.js
+var import_ts_extras21 = require("ts-extras");
 var requireInstructionsApplyToRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2676,7 +2509,7 @@ var requireInstructionsApplyToRule = createCopilotRule({
       }
       const applyToScalar = getFrontmatterScalar(frontmatter, "applyTo");
       const applyToList = getFrontmatterList(frontmatter, "applyTo");
-      if (applyToScalar !== void 0 || applyToList !== void 0) {
+      if ((0, import_ts_extras21.isDefined)(applyToScalar) || (0, import_ts_extras21.isDefined)(applyToList)) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -2696,7 +2529,8 @@ var requireInstructionsApplyToRule = createCopilotRule({
       description: "require path-specific Copilot instructions files to declare a non-empty `applyTo` frontmatter glob.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-instructions-apply-to")
     },
     messages: {
       emptyApplyTo: "Copilot instructions files must define a non-empty `applyTo` frontmatter value.",
@@ -2711,6 +2545,7 @@ var requireInstructionsApplyToRule = createCopilotRule({
 var require_instructions_apply_to_default = requireInstructionsApplyToRule;
 
 // dist/rules/require-json-agent-mcp-servers.js
+var import_ts_extras22 = require("ts-extras");
 var JSON_FILE_EXTENSION_PATTERN = /\.json$/iu;
 var requireJsonAgentMcpServersRule = createCopilotRule({
   create(context) {
@@ -2720,11 +2555,11 @@ var requireJsonAgentMcpServersRule = createCopilotRule({
       }
       const frontmatter = extractFrontmatter(context.sourceCode.text);
       const mcpServers = frontmatter === null ? void 0 : getFrontmatterList(frontmatter, "mcp-servers");
-      if (mcpServers === void 0) {
+      if (!(0, import_ts_extras22.isDefined)(mcpServers)) {
         return;
       }
       const invalidServer = mcpServers.find((serverPath) => !JSON_FILE_EXTENSION_PATTERN.test(serverPath.trim()));
-      if (invalidServer === void 0) {
+      if (!(0, import_ts_extras22.isDefined)(invalidServer)) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -2746,7 +2581,8 @@ var requireJsonAgentMcpServersRule = createCopilotRule({
       description: "require Copilot custom-agent `mcp-servers` entries to reference JSON config files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-json-agent-mcp-servers")
     },
     messages: {
       nonJsonAgentMcpServer: "Copilot custom-agent `mcp-servers` entry `{{mcpServer}}` should reference a `.json` config file."
@@ -2759,11 +2595,41 @@ var requireJsonAgentMcpServersRule = createCopilotRule({
 var require_json_agent_mcp_servers_default = requireJsonAgentMcpServersRule;
 
 // dist/rules/require-prompt-file-metadata.js
+var import_ts_extras23 = require("ts-extras");
 var VALID_BUILT_IN_PROMPT_AGENTS = /* @__PURE__ */ new Set([
   "agent",
   "ask",
   "plan"
 ]);
+var getRequiredPromptScalar = (context, frontmatter, key, emptyMessageId, missingMessageId) => {
+  const value = getFrontmatterScalar(frontmatter, key);
+  if ((0, import_ts_extras23.isDefined)(value)) {
+    return value;
+  }
+  reportAtDocumentStart(context, {
+    messageId: hasFrontmatterField(frontmatter, key) ? emptyMessageId : missingMessageId
+  });
+  return void 0;
+};
+var reportAgentToolsRequirement = (context, frontmatter, agent, tools) => {
+  if (agent === "agent") {
+    if ((0, import_ts_extras23.isDefined)(tools)) {
+      return false;
+    }
+    reportAtDocumentStart(context, {
+      messageId: hasFrontmatterField(frontmatter, "tools") ? "emptyTools" : "missingTools"
+    });
+    return true;
+  }
+  if ((0, import_ts_extras23.setHas)(VALID_BUILT_IN_PROMPT_AGENTS, agent) && hasFrontmatterField(frontmatter, "tools")) {
+    reportAtDocumentStart(context, {
+      data: { agent },
+      messageId: "unexpectedTools"
+    });
+    return true;
+  }
+  return false;
+};
 var requirePromptFileMetadataRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -2777,11 +2643,8 @@ var requirePromptFileMetadataRule = createCopilotRule({
         });
         return;
       }
-      const description = getFrontmatterScalar(frontmatter, "description");
-      if (description === void 0) {
-        reportAtDocumentStart(context, {
-          messageId: hasFrontmatterField(frontmatter, "description") ? "emptyDescription" : "missingDescription"
-        });
+      const description = getRequiredPromptScalar(context, frontmatter, "description", "emptyDescription", "missingDescription");
+      if (!(0, import_ts_extras23.isDefined)(description)) {
         return;
       }
       if (hasFrontmatterField(frontmatter, "mode")) {
@@ -2790,29 +2653,12 @@ var requirePromptFileMetadataRule = createCopilotRule({
         });
         return;
       }
-      const agent = getFrontmatterScalar(frontmatter, "agent");
-      if (agent === void 0) {
-        reportAtDocumentStart(context, {
-          messageId: hasFrontmatterField(frontmatter, "agent") ? "emptyAgent" : "missingAgent"
-        });
+      const agent = getRequiredPromptScalar(context, frontmatter, "agent", "emptyAgent", "missingAgent");
+      if (!(0, import_ts_extras23.isDefined)(agent)) {
         return;
       }
       const tools = getFrontmatterList(frontmatter, "tools");
-      if (agent === "agent") {
-        if (tools !== void 0) {
-          return;
-        }
-        reportAtDocumentStart(context, {
-          messageId: hasFrontmatterField(frontmatter, "tools") ? "emptyTools" : "missingTools"
-        });
-        return;
-      }
-      if (VALID_BUILT_IN_PROMPT_AGENTS.has(agent) && hasFrontmatterField(frontmatter, "tools")) {
-        reportAtDocumentStart(context, {
-          data: { agent },
-          messageId: "unexpectedTools"
-        });
-      }
+      reportAgentToolsRequirement(context, frontmatter, agent, tools);
     });
   },
   meta: {
@@ -2827,7 +2673,8 @@ var requirePromptFileMetadataRule = createCopilotRule({
       description: "require reusable Copilot prompt files to declare description, agent, and built-in agent-mode tools metadata.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-prompt-file-metadata")
     },
     messages: {
       deprecatedMode: "Copilot prompt files should use `agent` instead of the deprecated `mode` frontmatter key.",
@@ -2848,6 +2695,7 @@ var requirePromptFileMetadataRule = createCopilotRule({
 var require_prompt_file_metadata_default = requirePromptFileMetadataRule;
 
 // dist/rules/require-qualified-agent-handoff-models.js
+var import_ts_extras24 = require("ts-extras");
 var isQualifiedModelName = (value) => {
   const trimmedValue = value.trim();
   if (!trimmedValue.endsWith(")")) {
@@ -2871,12 +2719,12 @@ var requireQualifiedAgentHandoffModelsRule = createCopilotRule({
         return;
       }
       const handoffs = getFrontmatterObjectList(frontmatter, "handoffs");
-      if (handoffs === void 0 || handoffs.length === 0) {
+      if (!(0, import_ts_extras24.isDefined)(handoffs) || (0, import_ts_extras24.isEmpty)(handoffs)) {
         return;
       }
       for (const [index, handoff] of handoffs.entries()) {
         const model = handoff["model"]?.trim();
-        if (model === void 0 || model.length === 0 || isQualifiedModelName(model)) {
+        if (!(0, import_ts_extras24.isDefined)(model) || model.length === 0 || isQualifiedModelName(model)) {
           continue;
         }
         reportAtDocumentStart(context, {
@@ -2901,7 +2749,8 @@ var requireQualifiedAgentHandoffModelsRule = createCopilotRule({
       description: "require Copilot custom-agent handoff models to use qualified `Model Name (vendor)` names.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-qualified-agent-handoff-models")
     },
     messages: {
       unqualifiedHandoffModel: "Copilot custom agent handoff #{{handoffNumber}} should use a qualified `handoffs.model` name like `GPT-5 (copilot)`, not `{{model}}`."
@@ -2914,6 +2763,7 @@ var requireQualifiedAgentHandoffModelsRule = createCopilotRule({
 var require_qualified_agent_handoff_models_default = requireQualifiedAgentHandoffModelsRule;
 
 // dist/rules/require-relative-agent-hook-cwd.js
+var import_ts_extras25 = require("ts-extras");
 var isValidRelativeHookCwd = (cwd) => {
   const trimmedCwd = cwd.trim();
   return trimmedCwd.length > 0 && isRelativeWorkspacePath(trimmedCwd);
@@ -2929,13 +2779,13 @@ var requireRelativeAgentHookCwdRule = createCopilotRule({
         return;
       }
       const hookGroups = getFrontmatterObjectListGroups(frontmatter, "hooks");
-      if (hookGroups === void 0 || hookGroups.size === 0) {
+      if (!(0, import_ts_extras25.isDefined)(hookGroups) || hookGroups.size === 0) {
         return;
       }
       for (const [eventName, hooks] of hookGroups) {
         for (const [index, hook] of hooks.entries()) {
           const cwd = hook["cwd"]?.trim();
-          if (cwd === void 0 || isValidRelativeHookCwd(cwd)) {
+          if (!(0, import_ts_extras25.isDefined)(cwd) || isValidRelativeHookCwd(cwd)) {
             continue;
           }
           reportAtDocumentStart(context, {
@@ -2962,7 +2812,8 @@ var requireRelativeAgentHookCwdRule = createCopilotRule({
       description: "require Copilot custom-agent hook `cwd` values to stay relative to the repository root.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-relative-agent-hook-cwd")
     },
     messages: {
       invalidHookCwd: "Copilot custom agent hook #{{hookNumber}} in `{{eventName}}` must use a non-empty repository-relative `cwd` value, not `{{currentValue}}`."
@@ -3012,7 +2863,8 @@ var requireRelativeAgentLinksRule = createCopilotRule({
       description: "require Copilot custom agents to use relative Markdown links for workspace files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-relative-agent-links")
     },
     messages: {
       nonRelativeAgentLink: "Copilot custom agents should reference workspace files with relative Markdown links, not `{{destination}}`."
@@ -3062,7 +2914,8 @@ var requireRelativeInstructionsLinksRule = createCopilotRule({
       description: "require path-specific Copilot instructions files to use relative Markdown links for workspace files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-relative-instructions-links")
     },
     messages: {
       nonRelativeInstructionsLink: "Copilot instructions files should reference workspace files with relative Markdown links, not `{{destination}}`."
@@ -3130,7 +2983,8 @@ var requireRelativePromptLinksRule = createCopilotRule({
       description: "require Copilot prompt files to use relative Markdown links for workspace files.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-relative-prompt-links")
     },
     messages: {
       nonRelativePromptLink: "Copilot prompt files should reference workspace files with relative Markdown links, not `{{destination}}`."
@@ -3143,6 +2997,7 @@ var requireRelativePromptLinksRule = createCopilotRule({
 var require_relative_prompt_links_default = requireRelativePromptLinksRule;
 
 // dist/rules/require-relative-repository-hook-cwd.js
+var import_ts_extras26 = require("ts-extras");
 var requireRelativeRepositoryHookCwdRule = createCopilotRule({
   create(context) {
     return {
@@ -3155,7 +3010,7 @@ var requireRelativeRepositoryHookCwdRule = createCopilotRule({
           const cwd2 = hook["cwd"];
           return isJsonString(cwd2) && isNonRelativeWorkspacePath(cwd2);
         });
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras26.isDefined)(invalidHook)) {
           return;
         }
         const cwd = invalidHook.hook["cwd"];
@@ -3183,7 +3038,8 @@ var requireRelativeRepositoryHookCwdRule = createCopilotRule({
       description: "require repository hook `cwd` values to use repository-relative paths.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-relative-repository-hook-cwd")
     },
     messages: {
       nonRelativeRepositoryHookCwd: "Repository hook `cwd` values for `{{eventName}}` should use repository-relative paths, not `{{cwd}}`."
@@ -3233,7 +3089,8 @@ var requireRelativeSkillLinksRule = createCopilotRule({
       description: "require Copilot skill definition files to use relative Markdown links for workspace resources.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-relative-skill-links")
     },
     messages: {
       nonRelativeSkillLink: "Copilot skill definition files should reference workspace resources with relative Markdown links, not `{{destination}}`."
@@ -3246,6 +3103,7 @@ var requireRelativeSkillLinksRule = createCopilotRule({
 var require_relative_skill_links_default = requireRelativeSkillLinksRule;
 
 // dist/rules/require-repository-hook-arrays.js
+var import_ts_extras27 = require("ts-extras");
 var requireRepositoryHookArraysRule = createCopilotRule({
   create(context) {
     return {
@@ -3254,13 +3112,13 @@ var requireRepositoryHookArraysRule = createCopilotRule({
           return;
         }
         const root = parseJsonText(context.sourceCode.text);
-        const invalidEntry = getRepositoryHookEventEntries(root).find(([, eventValue]) => !isJsonArray(eventValue));
-        if (invalidEntry === void 0) {
+        const invalidEntry = getRepositoryHookEventEntries(root).find(([, eventValue]) => !isJsonArray(eventValue)) ?? null;
+        if (invalidEntry === null) {
           return;
         }
         reportAtDocumentStart(context, {
           data: {
-            eventName: invalidEntry[0],
+            eventName: (0, import_ts_extras27.arrayFirst)(invalidEntry),
             value: formatJsonValue(invalidEntry[1])
           },
           messageId: "invalidRepositoryHookArray"
@@ -3279,7 +3137,8 @@ var requireRepositoryHookArraysRule = createCopilotRule({
       description: "require each repository hook event entry in `hooks` to be an array.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-repository-hook-arrays")
     },
     messages: {
       invalidRepositoryHookArray: "Repository hook event `{{eventName}}` must map to an array of hook definitions (current value: `{{value}}`)."
@@ -3292,6 +3151,7 @@ var requireRepositoryHookArraysRule = createCopilotRule({
 var require_repository_hook_arrays_default = requireRepositoryHookArraysRule;
 
 // dist/rules/require-repository-hook-command-shell.js
+var import_ts_extras28 = require("ts-extras");
 var hasHookShellCommand = (value) => typeof value === "string" && value.trim().length > 0;
 var requireRepositoryHookCommandShellRule = createCopilotRule({
   create(context) {
@@ -3302,7 +3162,7 @@ var requireRepositoryHookCommandShellRule = createCopilotRule({
         }
         const root = parseJsonText(context.sourceCode.text);
         const invalidHook = getRepositoryHookObjects(root).find(({ hook }) => isJsonString(hook["type"]) && hook["type"] === "command" && !hasHookShellCommand(hook["bash"]) && !hasHookShellCommand(hook["powershell"]));
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras28.isDefined)(invalidHook)) {
           return;
         }
         reportAtDocumentStart(context, {
@@ -3325,7 +3185,8 @@ var requireRepositoryHookCommandShellRule = createCopilotRule({
       description: "require repository `command` hook definitions to declare at least one shell command under `bash` or `powershell`.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-repository-hook-command-shell")
     },
     messages: {
       missingRepositoryHookShellCommand: "Repository `command` hooks for `{{eventName}}` must declare a non-empty `bash` or `powershell` command."
@@ -3367,7 +3228,8 @@ var requireRepositoryHooksObjectRule = createCopilotRule({
       description: "require repository hook configuration files to declare a top-level `hooks` object.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-repository-hooks-object")
     },
     messages: {
       invalidRepositoryHooksObject: "Repository hook configuration files must declare a top-level `hooks` object."
@@ -3407,7 +3269,8 @@ var requireRepositoryInstructionsFileRule = createCopilotRule({
       description: "require repositories that define Copilot customization assets to also provide repository instructions via `.github/copilot-instructions.md` or `.github/instructions/copilot-instructions.md`.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-repository-instructions-file")
     },
     messages: {
       missingRepositoryInstructions: "Repositories that define Copilot prompts, custom agents, legacy chat modes, agent instructions, or path-specific instructions should also provide baseline repository guidance in `.github/copilot-instructions.md` or `.github/instructions/copilot-instructions.md`."
@@ -3455,7 +3318,8 @@ var requireSkillFileLocationRule = createCopilotRule({
       description: "require project skill definition files to live at a documented `.github/skills/<skill>/SKILL.md` or `.claude/skills/<skill>/SKILL.md` path.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-skill-file-location")
     },
     messages: {
       invalidSkillLocation: "Copilot skill definition files should live at `.github/skills/<skill>/SKILL.md` or `.claude/skills/<skill>/SKILL.md`."
@@ -3468,6 +3332,7 @@ var requireSkillFileLocationRule = createCopilotRule({
 var require_skill_file_location_default = requireSkillFileLocationRule;
 
 // dist/rules/require-skill-file-metadata.js
+var import_ts_extras29 = require("ts-extras");
 var requireSkillFileMetadataRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -3481,13 +3346,13 @@ var requireSkillFileMetadataRule = createCopilotRule({
         });
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "name") === void 0) {
+      if (!(0, import_ts_extras29.isDefined)(getFrontmatterScalar(frontmatter, "name"))) {
         reportAtDocumentStart(context, {
           messageId: "missingSkillName"
         });
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "description") === void 0) {
+      if (!(0, import_ts_extras29.isDefined)(getFrontmatterScalar(frontmatter, "description"))) {
         reportAtDocumentStart(context, {
           messageId: "missingSkillDescription"
         });
@@ -3505,7 +3370,8 @@ var requireSkillFileMetadataRule = createCopilotRule({
       description: "require Copilot skill definition files to declare `name` and `description` frontmatter.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-skill-file-metadata")
     },
     messages: {
       missingSkillDescription: "Copilot skill definition files must declare a non-empty `description` frontmatter value.",
@@ -3553,7 +3419,8 @@ var requireSkillMdFilenameRule = createCopilotRule({
       description: "require markdown files that declare skill-definition frontmatter to use the documented `SKILL.md` filename.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-skill-md-filename")
     },
     messages: {
       invalidSkillDefinitionFilename: "Skill-definition markdown files should be named `SKILL.md`, not `{{basename}}`."
@@ -3566,6 +3433,7 @@ var requireSkillMdFilenameRule = createCopilotRule({
 var require_skill_md_filename_default = requireSkillMdFilenameRule;
 
 // dist/rules/require-skill-name-match-directory.js
+var import_ts_extras30 = require("ts-extras");
 var requireSkillNameMatchDirectoryRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -3574,7 +3442,7 @@ var requireSkillNameMatchDirectoryRule = createCopilotRule({
       }
       const frontmatter = extractFrontmatter(context.sourceCode.text);
       const explicitSkillName = frontmatter === null ? void 0 : getFrontmatterScalar(frontmatter, "name");
-      if (explicitSkillName === void 0) {
+      if (!(0, import_ts_extras30.isDefined)(explicitSkillName)) {
         return;
       }
       const skillName = getSkillName(context.filename, frontmatter);
@@ -3601,7 +3469,8 @@ var requireSkillNameMatchDirectoryRule = createCopilotRule({
       description: "require Copilot skill `name` metadata to match the skill directory name.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-skill-name-match-directory")
     },
     messages: {
       skillNameDoesNotMatchDirectory: "Copilot skill `name` value `{{name}}` should match its directory name `{{directoryName}}`."
@@ -3614,6 +3483,7 @@ var requireSkillNameMatchDirectoryRule = createCopilotRule({
 var require_skill_name_match_directory_default = requireSkillNameMatchDirectoryRule;
 
 // dist/rules/require-string-repository-hook-env-values.js
+var import_ts_extras31 = require("ts-extras");
 var requireStringRepositoryHookEnvValuesRule = createCopilotRule({
   create(context) {
     return {
@@ -3624,9 +3494,9 @@ var requireStringRepositoryHookEnvValuesRule = createCopilotRule({
         const root = parseJsonText(context.sourceCode.text);
         const invalidHook = getRepositoryHookObjects(root).find(({ hook }) => {
           const env2 = hook["env"];
-          return isJsonObject(env2) && Object.values(env2).some((value) => !isJsonString(value));
+          return isJsonObject(env2) && (0, import_ts_extras31.objectValues)(env2).some((value) => !isJsonString(value));
         });
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras31.isDefined)(invalidHook)) {
           return;
         }
         const env = invalidHook.hook["env"];
@@ -3651,7 +3521,8 @@ var requireStringRepositoryHookEnvValuesRule = createCopilotRule({
       description: "require repository hook `env` objects to use string values.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-string-repository-hook-env-values")
     },
     messages: {
       nonStringRepositoryHookEnvValue: "Repository hook `env` for `{{eventName}}` must use string values only (current value: `{{env}}`)."
@@ -3664,6 +3535,7 @@ var requireStringRepositoryHookEnvValuesRule = createCopilotRule({
 var require_string_repository_hook_env_values_default = requireStringRepositoryHookEnvValuesRule;
 
 // dist/rules/require-valid-agent-argument-hint.js
+var import_ts_extras32 = require("ts-extras");
 var requireValidAgentArgumentHintRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -3674,7 +3546,7 @@ var requireValidAgentArgumentHintRule = createCopilotRule({
       if (frontmatter === null || !hasFrontmatterField(frontmatter, "argument-hint")) {
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "argument-hint") !== void 0) {
+      if ((0, import_ts_extras32.isDefined)(getFrontmatterScalar(frontmatter, "argument-hint"))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -3693,7 +3565,8 @@ var requireValidAgentArgumentHintRule = createCopilotRule({
       description: "require Copilot custom-agent `argument-hint` metadata to be a non-empty scalar when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-argument-hint")
     },
     messages: {
       invalidAgentArgumentHint: "Copilot custom-agent `argument-hint` metadata must be a non-empty scalar when present."
@@ -3706,6 +3579,7 @@ var requireValidAgentArgumentHintRule = createCopilotRule({
 var require_valid_agent_argument_hint_default = requireValidAgentArgumentHintRule;
 
 // dist/rules/require-valid-agent-handoff-send.js
+var import_ts_extras33 = require("ts-extras");
 var VALID_BOOLEAN_FIELD_VALUES = /* @__PURE__ */ new Set(["false", "true"]);
 var requireValidAgentHandoffSendRule = createCopilotRule({
   create(context) {
@@ -3718,16 +3592,16 @@ var requireValidAgentHandoffSendRule = createCopilotRule({
         return;
       }
       const handoffs = getFrontmatterObjectList(frontmatter, "handoffs");
-      if (handoffs === void 0 || handoffs.length === 0) {
+      if (!(0, import_ts_extras33.isDefined)(handoffs) || (0, import_ts_extras33.isEmpty)(handoffs)) {
         return;
       }
       for (const [index, handoff] of handoffs.entries()) {
         const rawSend = handoff["send"];
-        if (rawSend === void 0) {
+        if (!(0, import_ts_extras33.isDefined)(rawSend)) {
           continue;
         }
         const normalizedSend = rawSend.trim().toLowerCase();
-        if (VALID_BOOLEAN_FIELD_VALUES.has(normalizedSend)) {
+        if ((0, import_ts_extras33.setHas)(VALID_BOOLEAN_FIELD_VALUES, normalizedSend)) {
           continue;
         }
         reportAtDocumentStart(context, {
@@ -3752,7 +3626,8 @@ var requireValidAgentHandoffSendRule = createCopilotRule({
       description: "require Copilot custom-agent handoff `send` values to use documented boolean metadata when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-handoff-send")
     },
     messages: {
       invalidHandoffSend: "Copilot custom agent handoff #{{handoffNumber}} must use a boolean `send` value (`true` or `false`), not `{{sendValue}}`."
@@ -3765,6 +3640,7 @@ var requireValidAgentHandoffSendRule = createCopilotRule({
 var require_valid_agent_handoff_send_default = requireValidAgentHandoffSendRule;
 
 // dist/rules/require-valid-agent-handoffs.js
+var import_ts_extras34 = require("ts-extras");
 var requireValidAgentHandoffsRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -3776,7 +3652,7 @@ var requireValidAgentHandoffsRule = createCopilotRule({
         return;
       }
       const handoffs = getFrontmatterObjectList(frontmatter, "handoffs");
-      if (handoffs === void 0 || handoffs.length === 0) {
+      if (!(0, import_ts_extras34.isDefined)(handoffs) || (0, import_ts_extras34.isEmpty)(handoffs)) {
         return;
       }
       for (const [index, handoff] of handoffs.entries()) {
@@ -3820,7 +3696,8 @@ var requireValidAgentHandoffsRule = createCopilotRule({
       description: "require Copilot custom-agent handoffs to define the metadata needed for usable guided transitions.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-handoffs")
     },
     messages: {
       missingAgent: "Copilot custom agent handoff #{{handoffNumber}} must define a non-empty `agent` target.",
@@ -3835,6 +3712,7 @@ var requireValidAgentHandoffsRule = createCopilotRule({
 var require_valid_agent_handoffs_default = requireValidAgentHandoffsRule;
 
 // dist/rules/require-valid-agent-hook-events.js
+var import_ts_extras35 = require("ts-extras");
 var VALID_HOOK_EVENT_NAMES = /* @__PURE__ */ new Set([
   "PostToolUse",
   "PreCompact",
@@ -3856,11 +3734,11 @@ var requireValidAgentHookEventsRule = createCopilotRule({
         return;
       }
       const hookGroups = getFrontmatterObjectListGroups(frontmatter, "hooks");
-      if (hookGroups === void 0 || hookGroups.size === 0) {
+      if (!(0, import_ts_extras35.isDefined)(hookGroups) || hookGroups.size === 0) {
         return;
       }
       for (const eventName of hookGroups.keys()) {
-        if (VALID_HOOK_EVENT_NAMES.has(eventName)) {
+        if ((0, import_ts_extras35.setHas)(VALID_HOOK_EVENT_NAMES, eventName)) {
           continue;
         }
         reportAtDocumentStart(context, {
@@ -3882,7 +3760,8 @@ var requireValidAgentHookEventsRule = createCopilotRule({
       description: "require Copilot custom-agent hooks to use supported VS Code hook event names.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-hook-events")
     },
     messages: {
       invalidHookEvent: "Copilot custom agent hooks should use a supported event name, not `{{eventName}}`."
@@ -3895,6 +3774,7 @@ var requireValidAgentHookEventsRule = createCopilotRule({
 var require_valid_agent_hook_events_default = requireValidAgentHookEventsRule;
 
 // dist/rules/require-valid-agent-hook-timeouts.js
+var import_ts_extras36 = require("ts-extras");
 var isNumericTimeoutValue = (value) => {
   let decimalPointCount = 0;
   for (const character of value) {
@@ -3922,13 +3802,13 @@ var requireValidAgentHookTimeoutsRule = createCopilotRule({
         return;
       }
       const hookGroups = getFrontmatterObjectListGroups(frontmatter, "hooks");
-      if (hookGroups === void 0 || hookGroups.size === 0) {
+      if (!(0, import_ts_extras36.isDefined)(hookGroups) || hookGroups.size === 0) {
         return;
       }
       for (const [eventName, hooks] of hookGroups) {
         for (const [index, hook] of hooks.entries()) {
           const timeout = hook["timeout"]?.trim();
-          if (timeout === void 0 || timeout.length === 0 || isNumericTimeoutValue(timeout)) {
+          if (!(0, import_ts_extras36.isDefined)(timeout) || timeout.length === 0 || isNumericTimeoutValue(timeout)) {
             continue;
           }
           reportAtDocumentStart(context, {
@@ -3955,7 +3835,8 @@ var requireValidAgentHookTimeoutsRule = createCopilotRule({
       description: "require Copilot custom-agent hook `timeout` values to be numeric seconds when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-hook-timeouts")
     },
     messages: {
       invalidHookTimeout: "Copilot custom agent hook #{{hookNumber}} in `{{eventName}}` should use a numeric `timeout` value in seconds, not `{{timeout}}`."
@@ -3968,6 +3849,7 @@ var requireValidAgentHookTimeoutsRule = createCopilotRule({
 var require_valid_agent_hook_timeouts_default = requireValidAgentHookTimeoutsRule;
 
 // dist/rules/require-valid-agent-hooks.js
+var import_ts_extras37 = require("ts-extras");
 var hasAnyHookCommand = (hook) => [
   "command",
   "windows",
@@ -3977,6 +3859,29 @@ var hasAnyHookCommand = (hook) => [
   const value = hook[key];
   return typeof value === "string" && value.trim().length > 0;
 });
+var getInvalidHookReport = (eventName, hook, hookNumber) => {
+  const type = hook["type"]?.trim() ?? "";
+  if (type !== "command") {
+    return {
+      data: {
+        eventName,
+        hookNumber,
+        type: type.length === 0 ? "(missing)" : type
+      },
+      messageId: "invalidHookType"
+    };
+  }
+  if (hasAnyHookCommand(hook)) {
+    return void 0;
+  }
+  return {
+    data: {
+      eventName,
+      hookNumber
+    },
+    messageId: "missingHookCommand"
+  };
+};
 var requireValidAgentHooksRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -3988,34 +3893,17 @@ var requireValidAgentHooksRule = createCopilotRule({
         return;
       }
       const hookGroups = getFrontmatterObjectListGroups(frontmatter, "hooks");
-      if (hookGroups === void 0 || hookGroups.size === 0) {
+      if (!(0, import_ts_extras37.isDefined)(hookGroups) || hookGroups.size === 0) {
         return;
       }
       for (const [eventName, hooks] of hookGroups) {
         for (const [index, hook] of hooks.entries()) {
           const hookNumber = String(index + 1);
-          const type = hook["type"]?.trim() ?? "";
-          if (type !== "command") {
-            reportAtDocumentStart(context, {
-              data: {
-                eventName,
-                hookNumber,
-                type: type.length === 0 ? "(missing)" : type
-              },
-              messageId: "invalidHookType"
-            });
-            return;
-          }
-          if (hasAnyHookCommand(hook)) {
+          const invalidHookReport = getInvalidHookReport(eventName, hook, hookNumber);
+          if (!(0, import_ts_extras37.isDefined)(invalidHookReport)) {
             continue;
           }
-          reportAtDocumentStart(context, {
-            data: {
-              eventName,
-              hookNumber
-            },
-            messageId: "missingHookCommand"
-          });
+          reportAtDocumentStart(context, invalidHookReport);
           return;
         }
       }
@@ -4032,7 +3920,8 @@ var requireValidAgentHooksRule = createCopilotRule({
       description: "require Copilot custom-agent hooks to use `type: command` and define at least one command property.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-hooks")
     },
     messages: {
       invalidHookType: "Copilot custom agent hook #{{hookNumber}} in `{{eventName}}` must use `type: command` (current value: `{{type}}`).",
@@ -4046,6 +3935,7 @@ var requireValidAgentHooksRule = createCopilotRule({
 var require_valid_agent_hooks_default = requireValidAgentHooksRule;
 
 // dist/rules/require-valid-agent-invocation-controls.js
+var import_ts_extras38 = require("ts-extras");
 var VALID_BOOLEAN_FIELD_VALUES2 = /* @__PURE__ */ new Set(["false", "true"]);
 var INVOCATION_CONTROL_FIELDS = [
   "disable-model-invocation",
@@ -4067,12 +3957,12 @@ var requireValidAgentInvocationControlsRule = createCopilotRule({
         }
         const fieldValue = getFrontmatterScalar(frontmatter, fieldName);
         const normalizedValue = fieldValue?.trim().toLowerCase();
-        if (normalizedValue !== void 0 && VALID_BOOLEAN_FIELD_VALUES2.has(normalizedValue)) {
+        if ((0, import_ts_extras38.isDefined)(normalizedValue) && (0, import_ts_extras38.setHas)(VALID_BOOLEAN_FIELD_VALUES2, normalizedValue)) {
           continue;
         }
         reportAtDocumentStart(context, {
           data: {
-            currentValue: fieldValue === void 0 || fieldValue.trim().length === 0 ? "(empty)" : fieldValue,
+            currentValue: !(0, import_ts_extras38.isDefined)(fieldValue) || fieldValue.trim().length === 0 ? "(empty)" : fieldValue,
             fieldName
           },
           messageId: "invalidInvocationControl"
@@ -4092,7 +3982,8 @@ var requireValidAgentInvocationControlsRule = createCopilotRule({
       description: "require Copilot custom-agent invocation-control flags to use documented boolean values when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-invocation-controls")
     },
     messages: {
       invalidInvocationControl: "Copilot custom agent `{{fieldName}}` must use a boolean `true` or `false` value (current value: `{{currentValue}}`)."
@@ -4105,12 +3996,13 @@ var requireValidAgentInvocationControlsRule = createCopilotRule({
 var require_valid_agent_invocation_controls_default = requireValidAgentInvocationControlsRule;
 
 // dist/rules/require-valid-agent-mcp-servers.js
+var import_ts_extras39 = require("ts-extras");
 var formatMcpServersValue = (scalarValue, listValue) => {
-  if (scalarValue !== void 0) {
+  if ((0, import_ts_extras39.isDefined)(scalarValue)) {
     return scalarValue;
   }
-  if (listValue !== void 0) {
-    return `[${listValue.join(", ")}]`;
+  if ((0, import_ts_extras39.isDefined)(listValue)) {
+    return `[${(0, import_ts_extras39.arrayJoin)(listValue, ", ")}]`;
   }
   return "(empty)";
 };
@@ -4125,7 +4017,7 @@ var requireValidAgentMcpServersRule = createCopilotRule({
         return;
       }
       const mcpServers = getFrontmatterList(frontmatter, "mcp-servers");
-      if (mcpServers !== void 0 && mcpServers.length > 0) {
+      if ((0, import_ts_extras39.isDefined)(mcpServers) && mcpServers.length > 0) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4147,7 +4039,8 @@ var requireValidAgentMcpServersRule = createCopilotRule({
       description: "require Copilot custom-agent `mcp-servers` metadata to be a non-empty list when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-mcp-servers")
     },
     messages: {
       invalidMcpServersField: "Copilot custom agent `mcp-servers` metadata must be a non-empty list of MCP server config names (current value: `{{mcpServersValue}}`)."
@@ -4160,6 +4053,7 @@ var requireValidAgentMcpServersRule = createCopilotRule({
 var require_valid_agent_mcp_servers_default = requireValidAgentMcpServersRule;
 
 // dist/rules/require-valid-agent-model.js
+var import_ts_extras40 = require("ts-extras");
 var INLINE_LIST_LITERAL_PATTERN = /^\s*\[.*\]\s*$/u;
 var requireValidAgentModelRule = createCopilotRule({
   create(context) {
@@ -4172,16 +4066,16 @@ var requireValidAgentModelRule = createCopilotRule({
         return;
       }
       const modelList = getFrontmatterList(frontmatter, "model");
-      if (modelList !== void 0 && modelList.length > 0) {
+      if ((0, import_ts_extras40.isDefined)(modelList) && modelList.length > 0) {
         return;
       }
       const model = getFrontmatterScalar(frontmatter, "model");
-      if (model !== void 0 && model.length > 0 && !INLINE_LIST_LITERAL_PATTERN.test(model)) {
+      if ((0, import_ts_extras40.isDefined)(model) && model.length > 0 && !INLINE_LIST_LITERAL_PATTERN.test(model)) {
         return;
       }
       reportAtDocumentStart(context, {
         data: {
-          modelValue: model === void 0 || model.trim().length === 0 ? "(empty)" : model
+          modelValue: !(0, import_ts_extras40.isDefined)(model) || model.trim().length === 0 ? "(empty)" : model
         },
         messageId: "invalidAgentModel"
       });
@@ -4198,7 +4092,8 @@ var requireValidAgentModelRule = createCopilotRule({
       description: "require Copilot custom-agent `model` metadata to be a non-empty model name or non-empty prioritized model list when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-model")
     },
     messages: {
       invalidAgentModel: "Copilot custom agent `model` must be a non-empty model name or non-empty prioritized list of model names (current value: `{{modelValue}}`)."
@@ -4211,6 +4106,7 @@ var requireValidAgentModelRule = createCopilotRule({
 var require_valid_agent_model_default = requireValidAgentModelRule;
 
 // dist/rules/require-valid-agent-name.js
+var import_ts_extras41 = require("ts-extras");
 var requireValidAgentNameRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -4221,7 +4117,7 @@ var requireValidAgentNameRule = createCopilotRule({
       if (frontmatter === null || !hasFrontmatterField(frontmatter, "name")) {
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "name") !== void 0) {
+      if ((0, import_ts_extras41.isDefined)(getFrontmatterScalar(frontmatter, "name"))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4240,7 +4136,8 @@ var requireValidAgentNameRule = createCopilotRule({
       description: "require Copilot custom-agent `name` metadata to be a non-empty scalar when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-name")
     },
     messages: {
       invalidAgentName: "Copilot custom-agent `name` metadata must be a non-empty scalar when present."
@@ -4253,6 +4150,7 @@ var requireValidAgentNameRule = createCopilotRule({
 var require_valid_agent_name_default = requireValidAgentNameRule;
 
 // dist/rules/require-valid-agent-subagents.js
+var import_ts_extras42 = require("ts-extras");
 var EMPTY_ARRAY_LITERAL = "[]";
 var WILDCARD_AGENTS_LITERAL = "*";
 var isValidExplicitAgentName = (value) => {
@@ -4260,11 +4158,11 @@ var isValidExplicitAgentName = (value) => {
   return trimmedValue.length > 0 && trimmedValue !== EMPTY_ARRAY_LITERAL && trimmedValue !== WILDCARD_AGENTS_LITERAL;
 };
 var formatAgentsValue = (scalarValue, listValue) => {
-  if (scalarValue !== void 0) {
+  if ((0, import_ts_extras42.isDefined)(scalarValue)) {
     return scalarValue;
   }
-  if (listValue !== void 0) {
-    return `[${listValue.join(", ")}]`;
+  if ((0, import_ts_extras42.isDefined)(listValue)) {
+    return `[${(0, import_ts_extras42.arrayJoin)(listValue, ", ")}]`;
   }
   return "(empty)";
 };
@@ -4283,7 +4181,7 @@ var requireValidAgentSubagentsRule = createCopilotRule({
       if (agentsScalar === WILDCARD_AGENTS_LITERAL || agentsScalar === EMPTY_ARRAY_LITERAL) {
         return;
       }
-      if (allowedAgents !== void 0 && allowedAgents.length > 0 && allowedAgents.every((agentName) => isValidExplicitAgentName(agentName))) {
+      if ((0, import_ts_extras42.isDefined)(allowedAgents) && allowedAgents.length > 0 && allowedAgents.every((agentName) => isValidExplicitAgentName(agentName))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4305,7 +4203,8 @@ var requireValidAgentSubagentsRule = createCopilotRule({
       description: "require Copilot custom-agent `agents` metadata to be `*`, `[]`, or a non-empty list of explicit agent names.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-subagents")
     },
     messages: {
       invalidAgentsField: "Copilot custom agent `agents` metadata must be `*`, `[]`, or a non-empty list of agent names (current value: `{{agentsValue}}`)."
@@ -4318,6 +4217,7 @@ var requireValidAgentSubagentsRule = createCopilotRule({
 var require_valid_agent_subagents_default = requireValidAgentSubagentsRule;
 
 // dist/rules/require-valid-agent-target.js
+var import_ts_extras43 = require("ts-extras");
 var VALID_AGENT_TARGETS = /* @__PURE__ */ new Set(["github-copilot", "vscode"]);
 var requireValidAgentTargetRule = createCopilotRule({
   create(context) {
@@ -4330,13 +4230,13 @@ var requireValidAgentTargetRule = createCopilotRule({
         return;
       }
       const target = getFrontmatterScalar(frontmatter, "target");
-      if (target === void 0) {
+      if (!(0, import_ts_extras43.isDefined)(target)) {
         reportAtDocumentStart(context, {
           messageId: "emptyTarget"
         });
         return;
       }
-      if (VALID_AGENT_TARGETS.has(target)) {
+      if ((0, import_ts_extras43.setHas)(VALID_AGENT_TARGETS, target)) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4356,7 +4256,8 @@ var requireValidAgentTargetRule = createCopilotRule({
       description: "require Copilot custom-agent `target` metadata to use a documented target value when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-target")
     },
     messages: {
       emptyTarget: "Copilot custom agent files that declare `target` must use a non-empty documented value (`vscode` or `github-copilot`).",
@@ -4370,12 +4271,13 @@ var requireValidAgentTargetRule = createCopilotRule({
 var require_valid_agent_target_default = requireValidAgentTargetRule;
 
 // dist/rules/require-valid-agent-tools.js
+var import_ts_extras44 = require("ts-extras");
 var formatToolsValue = (scalarValue, listValue) => {
-  if (scalarValue !== void 0) {
+  if ((0, import_ts_extras44.isDefined)(scalarValue)) {
     return scalarValue;
   }
-  if (listValue !== void 0) {
-    return `[${listValue.join(", ")}]`;
+  if ((0, import_ts_extras44.isDefined)(listValue)) {
+    return `[${(0, import_ts_extras44.arrayJoin)(listValue, ", ")}]`;
   }
   return "(empty)";
 };
@@ -4390,7 +4292,7 @@ var requireValidAgentToolsRule = createCopilotRule({
         return;
       }
       const tools = getFrontmatterList(frontmatter, "tools");
-      if (tools !== void 0 && tools.length > 0) {
+      if ((0, import_ts_extras44.isDefined)(tools) && tools.length > 0) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4412,7 +4314,8 @@ var requireValidAgentToolsRule = createCopilotRule({
       description: "require Copilot custom-agent `tools` metadata to be a non-empty list of tool or tool-set names when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-agent-tools")
     },
     messages: {
       invalidAgentTools: "Copilot custom agent `tools` metadata must be a non-empty list of tool or tool-set names when present (current value: `{{toolsValue}}`)."
@@ -4425,6 +4328,7 @@ var requireValidAgentToolsRule = createCopilotRule({
 var require_valid_agent_tools_default = requireValidAgentToolsRule;
 
 // dist/rules/require-valid-instructions-apply-to-globs.js
+var import_ts_extras45 = require("ts-extras");
 var isValidApplyToGlob = (value) => {
   const trimmedValue = value.trim();
   const lowercaseValue = trimmedValue.toLowerCase();
@@ -4444,11 +4348,11 @@ var requireValidInstructionsApplyToGlobsRule = createCopilotRule({
         ...getFrontmatterList(frontmatter, "applyTo") ?? []
       ];
       const applyToScalar = getFrontmatterScalar(frontmatter, "applyTo");
-      if (applyToScalar !== void 0) {
+      if ((0, import_ts_extras45.isDefined)(applyToScalar)) {
         applyToValues.push(applyToScalar);
       }
-      const invalidValue = applyToValues.find((value) => !isValidApplyToGlob(value));
-      if (invalidValue === void 0) {
+      const invalidValue = applyToValues.find((value) => !isValidApplyToGlob(value)) ?? null;
+      if (invalidValue === null) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4470,7 +4374,8 @@ var requireValidInstructionsApplyToGlobsRule = createCopilotRule({
       description: "require path-specific Copilot instructions `applyTo` metadata to use repository-relative glob patterns.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-instructions-apply-to-globs")
     },
     messages: {
       invalidApplyToGlob: "Copilot instructions `applyTo` metadata should use repository-relative glob patterns, not `{{applyTo}}`."
@@ -4483,6 +4388,7 @@ var requireValidInstructionsApplyToGlobsRule = createCopilotRule({
 var require_valid_instructions_apply_to_globs_default = requireValidInstructionsApplyToGlobsRule;
 
 // dist/rules/require-valid-prompt-argument-hint.js
+var import_ts_extras46 = require("ts-extras");
 var requireValidPromptArgumentHintRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -4493,7 +4399,7 @@ var requireValidPromptArgumentHintRule = createCopilotRule({
       if (frontmatter === null || !hasFrontmatterField(frontmatter, "argument-hint")) {
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "argument-hint") !== void 0) {
+      if ((0, import_ts_extras46.isDefined)(getFrontmatterScalar(frontmatter, "argument-hint"))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4512,7 +4418,8 @@ var requireValidPromptArgumentHintRule = createCopilotRule({
       description: "require Copilot prompt-file `argument-hint` metadata to be a non-empty scalar when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-prompt-argument-hint")
     },
     messages: {
       invalidPromptArgumentHint: "Copilot prompt-file `argument-hint` metadata must be a non-empty scalar when present."
@@ -4525,13 +4432,14 @@ var requireValidPromptArgumentHintRule = createCopilotRule({
 var require_valid_prompt_argument_hint_default = requireValidPromptArgumentHintRule;
 
 // dist/rules/require-valid-prompt-model.js
+var import_ts_extras47 = require("ts-extras");
 var INLINE_LIST_LITERAL_PATTERN2 = /^\s*\[.*\]\s*$/u;
 var formatPromptModelValue = (scalarValue, listValue) => {
-  if (scalarValue !== void 0) {
+  if ((0, import_ts_extras47.isDefined)(scalarValue)) {
     return scalarValue;
   }
-  if (listValue !== void 0) {
-    return `[${listValue.join(", ")}]`;
+  if ((0, import_ts_extras47.isDefined)(listValue)) {
+    return `[${(0, import_ts_extras47.arrayJoin)(listValue, ", ")}]`;
   }
   return "(empty)";
 };
@@ -4546,7 +4454,7 @@ var requireValidPromptModelRule = createCopilotRule({
         return;
       }
       const modelList = getFrontmatterList(frontmatter, "model");
-      if (modelList !== void 0) {
+      if ((0, import_ts_extras47.isDefined)(modelList)) {
         reportAtDocumentStart(context, {
           data: {
             modelValue: formatPromptModelValue(void 0, modelList)
@@ -4556,7 +4464,7 @@ var requireValidPromptModelRule = createCopilotRule({
         return;
       }
       const model = getFrontmatterScalar(frontmatter, "model");
-      if (model !== void 0 && model.length > 0 && !INLINE_LIST_LITERAL_PATTERN2.test(model)) {
+      if ((0, import_ts_extras47.isDefined)(model) && model.length > 0 && !INLINE_LIST_LITERAL_PATTERN2.test(model)) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4578,7 +4486,8 @@ var requireValidPromptModelRule = createCopilotRule({
       description: "require Copilot prompt-file `model` metadata to be a non-empty single model name when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-prompt-model")
     },
     messages: {
       invalidPromptModel: "Copilot prompt-file `model` metadata must be a non-empty single model name when present (current value: `{{modelValue}}`)."
@@ -4591,6 +4500,7 @@ var requireValidPromptModelRule = createCopilotRule({
 var require_valid_prompt_model_default = requireValidPromptModelRule;
 
 // dist/rules/require-valid-prompt-name.js
+var import_ts_extras48 = require("ts-extras");
 var requireValidPromptNameRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -4601,7 +4511,7 @@ var requireValidPromptNameRule = createCopilotRule({
       if (frontmatter === null || !hasFrontmatterField(frontmatter, "name")) {
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "name") !== void 0) {
+      if ((0, import_ts_extras48.isDefined)(getFrontmatterScalar(frontmatter, "name"))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4620,7 +4530,8 @@ var requireValidPromptNameRule = createCopilotRule({
       description: "require Copilot prompt-file `name` metadata to be a non-empty scalar when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-prompt-name")
     },
     messages: {
       invalidPromptName: "Copilot prompt-file `name` metadata must be a non-empty scalar when present."
@@ -4633,12 +4544,13 @@ var requireValidPromptNameRule = createCopilotRule({
 var require_valid_prompt_name_default = requireValidPromptNameRule;
 
 // dist/rules/require-valid-prompt-tools.js
+var import_ts_extras49 = require("ts-extras");
 var formatToolsValue2 = (scalarValue, listValue) => {
-  if (scalarValue !== void 0) {
+  if ((0, import_ts_extras49.isDefined)(scalarValue)) {
     return scalarValue;
   }
-  if (listValue !== void 0) {
-    return `[${listValue.join(", ")}]`;
+  if ((0, import_ts_extras49.isDefined)(listValue)) {
+    return `[${(0, import_ts_extras49.arrayJoin)(listValue, ", ")}]`;
   }
   return "(empty)";
 };
@@ -4653,7 +4565,7 @@ var requireValidPromptToolsRule = createCopilotRule({
         return;
       }
       const tools = getFrontmatterList(frontmatter, "tools");
-      if (tools !== void 0 && tools.length > 0) {
+      if ((0, import_ts_extras49.isDefined)(tools) && tools.length > 0) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4675,7 +4587,8 @@ var requireValidPromptToolsRule = createCopilotRule({
       description: "require Copilot prompt-file `tools` metadata to be a non-empty list of tool or tool-set names when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-prompt-tools")
     },
     messages: {
       invalidPromptTools: "Copilot prompt-file `tools` metadata must be a non-empty list of tool or tool-set names when present (current value: `{{toolsValue}}`)."
@@ -4688,6 +4601,7 @@ var requireValidPromptToolsRule = createCopilotRule({
 var require_valid_prompt_tools_default = requireValidPromptToolsRule;
 
 // dist/rules/require-valid-repository-hook-command-type.js
+var import_ts_extras50 = require("ts-extras");
 var requireValidRepositoryHookCommandTypeRule = createCopilotRule({
   create(context) {
     return {
@@ -4700,7 +4614,7 @@ var requireValidRepositoryHookCommandTypeRule = createCopilotRule({
           const typeValue = hook["type"];
           return !isJsonString(typeValue) || !isRepositoryHookType(typeValue);
         });
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras50.isDefined)(invalidHook)) {
           return;
         }
         reportAtDocumentStart(context, {
@@ -4724,7 +4638,8 @@ var requireValidRepositoryHookCommandTypeRule = createCopilotRule({
       description: "require repository hook definitions to declare a supported `type` value such as `command` or `prompt`.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-repository-hook-command-type")
     },
     messages: {
       invalidRepositoryHookType: "Repository hook definitions for `{{eventName}}` must declare a supported `type` such as `command` or `prompt` (current value: `{{type}}`)."
@@ -4737,6 +4652,7 @@ var requireValidRepositoryHookCommandTypeRule = createCopilotRule({
 var require_valid_repository_hook_command_type_default = requireValidRepositoryHookCommandTypeRule;
 
 // dist/rules/require-valid-repository-hook-env.js
+var import_ts_extras51 = require("ts-extras");
 var requireValidRepositoryHookEnvRule = createCopilotRule({
   create(context) {
     return {
@@ -4747,9 +4663,9 @@ var requireValidRepositoryHookEnvRule = createCopilotRule({
         const root = parseJsonText(context.sourceCode.text);
         const invalidHook = getRepositoryHookObjects(root).find(({ hook }) => {
           const env = hook["env"];
-          return env !== void 0 && !isJsonObject(env);
+          return (0, import_ts_extras51.isDefined)(env) && !isJsonObject(env);
         });
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras51.isDefined)(invalidHook)) {
           return;
         }
         reportAtDocumentStart(context, {
@@ -4773,7 +4689,8 @@ var requireValidRepositoryHookEnvRule = createCopilotRule({
       description: "require repository hook `env` values to be JSON objects when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-repository-hook-env")
     },
     messages: {
       invalidRepositoryHookEnv: "Repository hook `env` for `{{eventName}}` must be a JSON object when present (current value: `{{env}}`)."
@@ -4786,6 +4703,7 @@ var requireValidRepositoryHookEnvRule = createCopilotRule({
 var require_valid_repository_hook_env_default = requireValidRepositoryHookEnvRule;
 
 // dist/rules/require-valid-repository-hook-events.js
+var import_ts_extras52 = require("ts-extras");
 var requireValidRepositoryHookEventsRule = createCopilotRule({
   create(context) {
     return {
@@ -4795,7 +4713,7 @@ var requireValidRepositoryHookEventsRule = createCopilotRule({
         }
         const root = parseJsonText(context.sourceCode.text);
         const invalidEventName = getRepositoryHookEventEntries(root).map(([eventName]) => eventName).find((eventName) => !isRepositoryHookEventName(eventName));
-        if (invalidEventName === void 0) {
+        if (!(0, import_ts_extras52.isDefined)(invalidEventName)) {
           return;
         }
         reportAtDocumentStart(context, {
@@ -4818,7 +4736,8 @@ var requireValidRepositoryHookEventsRule = createCopilotRule({
       description: "require repository hook configuration files to use supported hook event names.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-repository-hook-events")
     },
     messages: {
       invalidRepositoryHookEvent: "Repository hook configuration files should use a supported hook event name, not `{{eventName}}`."
@@ -4831,7 +4750,8 @@ var requireValidRepositoryHookEventsRule = createCopilotRule({
 var require_valid_repository_hook_events_default = requireValidRepositoryHookEventsRule;
 
 // dist/rules/require-valid-repository-hook-timeouts.js
-var isValidTimeoutSeconds = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+var import_ts_extras53 = require("ts-extras");
+var isValidTimeoutSeconds = (value) => typeof value === "number" && (0, import_ts_extras53.isInteger)(value) && value > 0;
 var requireValidRepositoryHookTimeoutsRule = createCopilotRule({
   create(context) {
     return {
@@ -4842,9 +4762,9 @@ var requireValidRepositoryHookTimeoutsRule = createCopilotRule({
         const root = parseJsonText(context.sourceCode.text);
         const invalidHook = getRepositoryHookObjects(root).find(({ hook }) => {
           const timeout = hook["timeoutSec"];
-          return timeout !== void 0 && !isValidTimeoutSeconds(timeout);
+          return (0, import_ts_extras53.isDefined)(timeout) && !isValidTimeoutSeconds(timeout);
         });
-        if (invalidHook === void 0) {
+        if (!(0, import_ts_extras53.isDefined)(invalidHook)) {
           return;
         }
         reportAtDocumentStart(context, {
@@ -4868,7 +4788,8 @@ var requireValidRepositoryHookTimeoutsRule = createCopilotRule({
       description: "require repository hook `timeoutSec` values to be positive integers when present.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-repository-hook-timeouts")
     },
     messages: {
       invalidRepositoryHookTimeout: "Repository hook `timeoutSec` for `{{eventName}}` must be a positive integer when present (current value: `{{timeout}}`)."
@@ -4913,7 +4834,8 @@ var requireValidRepositoryHookVersionRule = createCopilotRule({
       description: "require repository hook configuration files to declare `version: 1`.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-repository-hook-version")
     },
     messages: {
       invalidRepositoryHookVersion: "Repository hook configuration files must declare `version: 1` (current value: `{{version}}`)."
@@ -4955,7 +4877,8 @@ var requireValidSkillDirectoryNameRule = createCopilotRule({
       description: "require Copilot skill directory names to use the documented lowercase-hyphen form.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-skill-directory-name")
     },
     messages: {
       invalidSkillDirectoryName: "Copilot skill directory names must use lowercase letters, digits, and hyphens only (current directory: `{{directoryName}}`)."
@@ -4968,6 +4891,7 @@ var requireValidSkillDirectoryNameRule = createCopilotRule({
 var require_valid_skill_directory_name_default = requireValidSkillDirectoryNameRule;
 
 // dist/rules/require-valid-skill-license.js
+var import_ts_extras54 = require("ts-extras");
 var requireValidSkillLicenseRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -4978,7 +4902,7 @@ var requireValidSkillLicenseRule = createCopilotRule({
       if (frontmatter === null || !hasFrontmatterField(frontmatter, "license")) {
         return;
       }
-      if (getFrontmatterScalar(frontmatter, "license") !== void 0) {
+      if ((0, import_ts_extras54.isDefined)(getFrontmatterScalar(frontmatter, "license"))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -4993,7 +4917,8 @@ var requireValidSkillLicenseRule = createCopilotRule({
       description: "require optional Copilot skill `license` metadata to be a non-empty scalar when present.",
       frozen: false,
       recommended: false,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-skill-license")
     },
     messages: {
       invalidSkillLicense: "Copilot skill `license` metadata must be a non-empty scalar when present."
@@ -5006,6 +4931,7 @@ var requireValidSkillLicenseRule = createCopilotRule({
 var require_valid_skill_license_default = requireValidSkillLicenseRule;
 
 // dist/rules/require-valid-skill-name.js
+var import_ts_extras55 = require("ts-extras");
 var requireValidSkillNameRule = createCopilotRule({
   create(context) {
     return createMarkdownDocumentListener(() => {
@@ -5017,7 +4943,7 @@ var requireValidSkillNameRule = createCopilotRule({
         return;
       }
       const skillName = getFrontmatterScalar(frontmatter, "name");
-      if (skillName !== void 0 && isValidSkillIdentifier(getSkillName(context.filename, frontmatter))) {
+      if ((0, import_ts_extras55.isDefined)(skillName) && isValidSkillIdentifier(getSkillName(context.filename, frontmatter))) {
         return;
       }
       reportAtDocumentStart(context, {
@@ -5039,7 +4965,8 @@ var requireValidSkillNameRule = createCopilotRule({
       description: "require Copilot skill `name` metadata to use the documented lowercase-hyphen identifier form.",
       frozen: false,
       recommended: true,
-      requiresTypeChecking: false
+      requiresTypeChecking: false,
+      url: createRuleDocsUrl("require-valid-skill-name")
     },
     messages: {
       invalidSkillName: "Copilot skill `name` values must use lowercase letters, digits, and hyphens only (current value: `{{name}}`)."
@@ -5167,7 +5094,7 @@ var getPackageVersion = (pkg) => {
 var eslintRules = copilotRules;
 var markdownPlugin = import_markdown.default;
 var jsonPlugin = import_json.default;
-var copilotRuleEntries = Object.entries(copilotRules).toSorted(([left], [right]) => left.localeCompare(right));
+var copilotRuleEntries = (0, import_ts_extras56.safeCastTo)((0, import_ts_extras56.objectEntries)(copilotRules).toSorted(([left], [right]) => left.localeCompare(right)));
 var createEmptyPresetRuleMap = () => ({
   all: [],
   minimal: [],
@@ -5200,8 +5127,8 @@ var errorRulesFor = (ruleNames) => {
 };
 var presetRuleNamesByConfig = derivePresetRuleNamesByConfig();
 var partitionRuleNamesByPresetLayer = (ruleNames) => ({
-  jsonRuleNames: ruleNames.filter((ruleName) => REPOSITORY_HOOK_JSON_RULE_NAMES.has(ruleName)),
-  markdownRuleNames: ruleNames.filter((ruleName) => !REPOSITORY_HOOK_JSON_RULE_NAMES.has(ruleName))
+  jsonRuleNames: ruleNames.filter((ruleName) => (0, import_ts_extras56.setHas)(REPOSITORY_HOOK_JSON_RULE_NAMES, ruleName)),
+  markdownRuleNames: ruleNames.filter((0, import_ts_extras56.not)((ruleName) => (0, import_ts_extras56.setHas)(REPOSITORY_HOOK_JSON_RULE_NAMES, ruleName)))
 });
 var createPresetConfig = (configName, plugin2) => {
   const presetName = copilotConfigMetadataByName[configName].presetName;