eslint-plugin-test-governance 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -6,6 +6,72 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.13.1] - 2026-11-06
+
+### Fixed
+
+- The `rally` preset no longer takes a prefix with no number, such as `US` or `TC`, as a ticket, so
+  `// SKIP: TC` and, with `allowNotes`, a note that starts with "US" or "DE" need a real ticket.
+- A second `configure()` for some of the same files, such as `{ preset: 'github' }` for a legacy folder after
+  `{ preset: 'jira', projects: ['TRADE'] }` for all files, replaces the earlier ticket format. ESLint merged the
+  two key by key, so linting failed with "ticket.projects is not an option of the github preset".
+- The `github` preset reads Gitea's, Forgejo's and Codeberg's pull request links, `/<owner>/<repo>/pulls/12`.
+- A `pattern` with an unmatched `)`, such as `TRADE-\d+)|(.*`, is a configuration error. It used to close the
+  group that anchors the pattern, so every ticket passed.
+- `plane` checks its `projects` as `jira` does: a key must start with a letter and have two or more characters,
+  since no other key can match.
+- An option named like a built-in object member, such as `customStates: { constructor: ... }`, is checked like
+  any other.
+- A marker in an `eslint-disable` comment, as in `/* eslint-disable jest/no-disabled-tests -- SKIP: TRADE-1 */`,
+  covers every test up to the `eslint-enable`, also when the comment sits directly above a describe or a test that
+  isn't skipped. `no-orphaned-marker` called it left over there, and its suggestion removed the marker the
+  skipped tests below relied on. Such a marker is now reported only when none of the tests it covers is in its
+  state, and `require-ticket-in-comments` no longer reports its note a second time.
+- `require-ticket-for-commented-out-tests` counts only a call that declares a test, describe or step. Everyday
+  lines such as `// test.slow();`, `// test.use({ ... })` and `// test.describe.configure({ ... })` were reported,
+  and in a comment block above a skipped test they took that test's marker, so `require-ticket` reported it too,
+  even with the commented-out rule off.
+- A test function kept in a constant is read when a condition picks it, as
+  `const itUnlessWindows = isWindows ? it.skip : it`, when a call builds it, as `describe.runIf(hasDocker)`,
+  `it.skipIf(true)` or `it.skip.each(table)`, and when the constant is declared inside a describe. A marker above
+  such a test was reported as not directly above a test.
+- With `requireReasonForConditional`, the description of an `eslint-disable` comment that covers a stretch of the
+  file no longer counts as the reason for every conditional skip in it. A reason written as a template literal
+  counts in Vitest's `context.skip(...)` and in node:test's `skip` option, and so does a comment at the end of a
+  one-line `test.skipIf(isMobile)(...)` or after an `if`'s opening line, as `if (isMobile) { // why`.
+- Suggestions edit only the marker's own line: removing a leftover marker from a block comment that says more,
+  such as a doc comment, another marker or an ESLint directive's description, keeps the rest of the comment, and
+  renaming a marker no longer renames the same word in prose above it.
+- With `annotations: { only: true }`, there is no suggestion to move a ticket into the details when it would break
+  the call: a Vitest test with a timeout or options after its function, or details with a computed key such as
+  `['annotation']`.
+- The suggestion to add a marker uses the file's own line breaks, so it no longer leaves a bare line feed in a
+  file with CRLF line endings.
+- Playwright's `test.describe.configure({ retries })` is read, with `states: { retry: true }`, when the options
+  sit in a constant or a spread, and when `describe` comes from `const { describe } = test`.
+- A marker above `test.describe('orders', () => test.skip(...))`, whose arrow body is the test, belongs to the test
+  as well, so `no-orphaned-marker` no longer calls it left over on the describe.
+- node:test's `t.skip(message)` and `t.todo(message)` and Jasmine's `pending(message)` take no condition, so they
+  need a ticket whatever the message is, also one held in a name or built in a template. A message in a name was
+  read as a condition.
+- A tag constant used in several titles, as `` `buys ${TAG}` ``, is reported once, where it is written.
+- The example in the `missingReason` message is written on one line, also when the call is split over lines.
+- With `requireReasonForConditional`, a comment above the declaration of a constant that picks a test function,
+  as `const posixTest = isWindows ? test.skip : test`, or at the end of its line, is the reason for every test
+  that uses it.
+- A link whose `id` query is zero, such as `https://www.wrike.com/open.htm?id=0`, is a placeholder, as any ticket
+  numbered 0 is. Other zero queries, such as `?page=0`, are left alone.
+- A placeholder written with a leading `#`, such as `#TBD`, also matches `TBD`: a leading `#` is ignored on both
+  the ticket and the placeholder.
+- A link whose scheme isn't in lowercase, such as `HTTPS://...`, is read as a link.
+- Linear, Trello, Shortcut and YouTrack links that end in a slash after the title, as
+  `.../ENG-1/fix-rounding/`, are accepted.
+- A lowercase Jira or Plane project in `projects` is reported once instead of twice.
+- `numeric` with a `minLength` above its `maxLength`, and a `pattern` or `flags` that isn't a valid regex, are
+  reported in the list of invalid options. Without `maxLength`, the message names its default of 20.
+- The ticket format of a state that is off, or that the framework doesn't have, such as `states.fixme.ticket`
+  with Jest, is checked too, so a mistake in it shows up at once.
+
 ## [0.13.0] - 2026-11-05
 
 ### Added
@@ -507,7 +573,8 @@ First release.
 - Support for ESLint 9 and 10 flat config, JavaScript and TypeScript test files, `.extend()`
   fixtures, describe blocks, runtime skips and tags in titles or the `tag` option.
 
-[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.0...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.1...HEAD
+[0.13.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.0...v0.13.1
 [0.13.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.12.1...v0.13.0
 [0.12.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.12.0...v0.12.1
 [0.12.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.11.1...v0.12.0

package/README.md

@@ -242,7 +242,7 @@ and markers. To turn a rule off, set it to `'off'` as usual.
 | ----------------------------- | --------------------------------------------------------------------------------------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `framework`                   | `'playwright' \| 'jest' \| 'vitest' \| 'mocha' \| 'cypress' \| 'webdriverio' \| 'node-test' \| 'jasmine'` | required                          | The test framework of the files the config applies to. Each framework's config, such as `configs.playwright`, sets it, and `configure()` needs it. See [Frameworks](#frameworks).                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `ticket`                      | `TicketSpec \| TicketSpec[]`                                                                              | `{ preset: 'any' }`               | Accepted ticket formats. An array accepts a ticket that matches any entry. See [Ticket presets](#ticket-presets).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `placeholders`                | `string[]`                                                                                                | see above                         | Tickets rejected as placeholders. `*` matches any characters. Case-insensitive; a leading `#` is ignored. Your list replaces the default one, so repeat the defaults you want to keep. Tickets numbered 0 are always rejected.                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `placeholders`                | `string[]`                                                                                                | see above                         | Tickets rejected as placeholders. `*` matches any characters. Case-insensitive, and a leading `#` on the ticket or the placeholder is ignored. Your list replaces the default one, so repeat the defaults you want to keep. Tickets numbered 0 are always rejected.                                                                                                                                                                                                                                                                                                                                                             |
 | `lifecycleTags`               | `boolean`                                                                                                 | `false`                           | Turns on the `new` (`@new`) and `quarantined` (`@quarantined`) states.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `states`                      | `{ [state]: boolean \| { enabled?, tag?, marker?, ticket? } }`                                            | `skip`, `fixme` and `todo` on     | Turns built-in states (`skip`, `fixme`, `fail`, `slow`, `todo`, `retry`, `new`, `quarantined`) on or off, renames their tag or marker, or gives them their own ticket format. `fail`, `slow` and `retry` are off by default; a setting for `new` or `quarantined` here wins over `lifecycleTags`. Only `new` and `quarantined` have a tag to rename; see [Tag names](#tag-names). `fixme` and `slow` exist only in Playwright, `todo` in every framework but Playwright, `fail` in Playwright, Jest, Vitest and node:test, and `retry` in every framework but node:test and Jasmine, so turning one on elsewhere has no effect. |
 | `customStates`                | `{ [name]: { when, marker, ticket? } }`                                                                   | `{}`                              | Adds a state for a tag, e.g. `{ 'needs-data': { when: '@needs-data', marker: 'NEEDS-DATA' } }`. `when` is a tag and `marker` an uppercase keyword; neither can be shared with another state.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
@@ -253,7 +253,7 @@ and markers. To turn a rule off, set it to `'off'` as usual.
 | `allowNotes`                  | `boolean`                                                                                                 | `false`                           | Allow free text after the tickets, e.g. `// SKIP: TRADE-123 flaky on CI`. Applies to markers and to `FIXME` / `TODO` comments.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `comments`                    | `false \| { keywords?: string[] }`                                                                        | `{ keywords: ['FIXME', 'TODO'] }` | Comment keywords that must start with a ticket anywhere in a test file, e.g. `// TODO: TRADE-123`. Your keywords replace the default ones. `false` allows free-form comments.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `annotations`                 | `false \| { type?: string, only?: boolean }`                                                              | `{ type: 'issue' }`               | Accept the ticket from a test annotation as well: Playwright's `annotation` of the given type or Vitest's `meta` key of that name. One valid annotation covers every state the test is in, and a describe's covers its tests. `only: true` makes it the only place for a test's or describe's ticket. See [Tickets from annotations](#tickets-from-annotations).                                                                                                                                                                                                                                                                |
-| `testFunctions`               | `string[]`                                                                                                | `['test']`                        | Names treated as the framework's `test`. Jest and Vitest default to `['test', 'it']`, Mocha, Cypress and WebdriverIO to `['it', 'specify', 'test']`, and Jasmine to `['it']`. Your list replaces the default one, so include those names if you still need them. See below.                                                                                                                                                                                                                                                                                                                                                     |
+| `testFunctions`               | `string[]`                                                                                                | `['test']`                        | Names treated as the framework's `test`. Jest, Vitest and node:test default to `['test', 'it']`, Mocha, Cypress and WebdriverIO to `['it', 'specify', 'test']`, and Jasmine to `['it']`. Your list replaces the default one, so include those names if you still need them. See below.                                                                                                                                                                                                                                                                                                                                          |
 | `reportUnreadableTags`        | `boolean`                                                                                                 | `false`                           | When a tag state is on, report titles that aren't static text, and tags or details that can't be read in the file, such as ones imported from another module, since their tags can't be checked.                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
 ### Tag names
@@ -330,8 +330,9 @@ run on their own servers.
 
 For a tracker without a preset, use `url` with its host, for example
 `{ preset: 'url', hosts: ['www.wrike.com'] }` for Wrike links such as
-`https://www.wrike.com/open.htm?id=4821`. It works the same for Microsoft Planner (`tasks.office.com`),
-Airtable (`airtable.com`), Smartsheet (`app.smartsheet.com`) and trackers of your own. For another
+`https://www.wrike.com/open.htm?id=4821`; a link with `?id=0`, or a path that ends in `/0`, is a
+placeholder. It works the same for Microsoft Planner (`tasks.office.com`), Airtable (`airtable.com`),
+Smartsheet (`app.smartsheet.com`) and trackers of your own. For another
 tracker's keys, such as `WEB-12`, `any` or `pattern` works. Gitea, Forgejo and Codeberg use GitHub's link layout,
 so the `github` preset with their `host` covers them. Bitbucket has no issue tracker since August 2026,
 so it has no preset.

package/dist/index.js

@@ -32,6 +32,28 @@ const plugin = {
     configs: {},
     configure,
 };
+/** `ticket` as a list, so ESLint replaces it whole when it merges two configs' settings. */
+function ticketAsList(options) {
+    const { ticket } = options;
+    return ticket === undefined || Array.isArray(ticket) ? options : { ...options, ticket: [ticket] };
+}
+/**
+ * ESLint merges the settings of configs that apply to the same file key by key and replaces arrays. Merged
+ * key by key, a later config's `{ preset: 'github' }` would keep an earlier `projects` that github doesn't take,
+ * so every ticket format goes in a list.
+ */
+function ticketsAsLists(options) {
+    const { states, customStates } = options;
+    return {
+        ...ticketAsList(options),
+        ...(states && {
+            states: Object.fromEntries(Object.entries(states).map(([name, state]) => [name, typeof state === 'object' ? ticketAsList(state) : state])),
+        }),
+        ...(customStates && {
+            customStates: Object.fromEntries(Object.entries(customStates).map(([name, state]) => [name, ticketAsList(state)])),
+        }),
+    };
+}
 /**
  * Returns the config of `options.framework` with shared options in `settings['test-governance']`,
  * so all rules read the same ticket formats and states.
@@ -42,7 +64,7 @@ export function configure(options) {
         name: `${PLUGIN_NAME}/${options.framework}`,
         plugins: { [PLUGIN_NAME]: plugin },
         rules: { ...configRules },
-        settings: { [SETTINGS_KEY]: options },
+        settings: { [SETTINGS_KEY]: ticketsAsLists(options) },
     };
 }
 // Each sets its framework, so it wins over a `configure()` that applies to all files when listed after it.

package/dist/rules/marker-matches-state.js

@@ -1,6 +1,6 @@
 import { appliesTo, describeSubject, directiveOf, isStateMarker, missingStates, strayMarkers, } from "../utils/analyze.js";
 import { createRule } from "../utils/create-rule.js";
-import { indentOf, keywordRange } from "../utils/fix.js";
+import { indentOf, keywordRange, lineBreakAfter } from "../utils/fix.js";
 export default createRule({
     meta: {
         type: 'problem',
@@ -39,7 +39,7 @@ export default createRule({
                     suggest: missing.map((state) => ({
                         messageId: 'renameMarker',
                         data: { expected: state.marker },
-                        fix: (fixer) => fixer.replaceTextRange(keywordRange(sourceCode, marker.comment, marker.keyword), state.marker),
+                        fix: (fixer) => fixer.replaceTextRange(keywordRange(marker), state.marker),
                     })),
                 });
             }
@@ -75,9 +75,12 @@ export default createRule({
                             {
                                 messageId: 'addMarker',
                                 data: { expected: state.marker, tickets },
-                                fix: (fixer) => directive
-                                    ? fixer.insertTextBeforeRange(present.comment.range, `${added}\n${indent}`)
-                                    : fixer.insertTextAfterRange(present.comment.range, `\n${indent}${added}`),
+                                fix: (fixer) => {
+                                    const lineBreak = lineBreakAfter(sourceCode, present.comment);
+                                    return directive
+                                        ? fixer.insertTextBeforeRange(present.comment.range, `${added}${lineBreak}${indent}`)
+                                        : fixer.insertTextAfterRange(present.comment.range, `${lineBreak}${indent}${added}`);
+                                },
                             },
                         ]
                         : [],

package/dist/rules/no-conflicting-states.js

@@ -24,6 +24,7 @@ export default createRule({
         const checkedTags = [...options.states.filter(isTagState).map((s) => s.tag), ...options.knownTags];
         const newTag = options.states.find((s) => s.name === 'new')?.tag;
         const quarantinedTag = options.states.find((s) => s.name === 'quarantined')?.tag;
+        const spelled = new Set();
         for (const subject of analysis.subjects) {
             for (const occurrence of subject.tags)
                 checkSpelling(occurrence);
@@ -52,6 +53,11 @@ export default createRule({
         }
         function checkSpelling(occurrence) {
             const { tag, range } = occurrence;
+            // A constant used in several titles, as `` `buys ${TAG}` ``, is one place to fix, so one report.
+            const key = `${occurrence.node.range[0]}:${range?.[0]}:${tag}`;
+            if (spelled.has(key))
+                return;
+            spelled.add(key);
             // A Vitest tag name is written without its `@`, so show it, and fix it, the same way.
             const written = (name) => (occurrence.plain ? name.slice(1) : name);
             if (checkedTags.includes(tag))

package/dist/rules/no-orphaned-marker.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../utils/create-rule.ts").Rule<"orphaned" | "detached" | "removeMarker">;
+declare const _default: import("../utils/create-rule.ts").Rule<"orphaned" | "orphanedRegion" | "detached" | "removeMarker">;
 export default _default;

package/dist/rules/no-orphaned-marker.js

@@ -13,6 +13,7 @@ export default createRule({
         schema: [],
         messages: {
             orphaned: "`{{marker}}:` is left over: {{subject}} is not in the '{{state}}' state.",
+            orphanedRegion: "`{{marker}}:` is left over: no test up to the `eslint-enable` of this comment is in the '{{state}}' state.",
             detached: '`{{marker}}:` is not directly above a test, describe or skip call, so it has no effect.',
             removeMarker: 'Remove this comment.',
         },
@@ -29,17 +30,21 @@ export default createRule({
                 continue;
             markers.push({ marker, messageId: 'detached', subject: '' });
         }
+        // TODO is the everyday work-comment keyword, so `// TODO: TRADE-12` above a test that isn't a todo
+        // is a tracked note about it far more often than a todo test's forgotten marker.
+        const trackedNote = (marker) => marker.state.name === 'todo' && options.workCommentKeywords.has(marker.keyword.toUpperCase());
+        for (const marker of analysis.idleRegionMarkers) {
+            if (!trackedNote(marker))
+                markers.push({ marker, messageId: 'orphanedRegion', subject: '' });
+        }
         for (const subject of analysis.subjects) {
             // A stray marker next to a missing one is a mismatch, reported by marker-matches-state.
             if (missingStates(subject, options).length > 0)
                 continue;
             const name = describeSubject(subject).replace(/^This/, 'this');
             for (const marker of strayMarkers(subject, options)) {
-                // TODO is the everyday work-comment keyword, so `// TODO: TRADE-12` above a test that isn't a todo
-                // is a tracked note about it far more often than a todo test's forgotten marker.
-                if (marker.state.name === 'todo' && options.workCommentKeywords.has(marker.keyword.toUpperCase()))
-                    continue;
-                markers.push({ marker, messageId: 'orphaned', subject: name });
+                if (!trackedNote(marker))
+                    markers.push({ marker, messageId: 'orphaned', subject: name });
             }
         }
         for (const { marker, messageId, subject } of markers) {
@@ -50,7 +55,7 @@ export default createRule({
                 loc: marker.comment.loc,
                 messageId,
                 data: { marker: marker.keyword, state: marker.state.name, subject },
-                suggest: [{ messageId: 'removeMarker', fix: () => removeMarkerComment(sourceCode, marker.comment) }],
+                suggest: [{ messageId: 'removeMarker', fix: () => removeMarkerComment(sourceCode, marker) }],
             });
         }
     },

package/dist/rules/require-ticket-in-comments.js

@@ -34,7 +34,7 @@ export default createRule({
         // in the wrong case.
         const owned = new Set();
         for (const subject of analysis.subjects) {
-            for (const marker of subject.markers) {
+            for (const marker of [...subject.markers, ...subject.regionMarkers]) {
                 const state = marker.state ?? marker.caseOf;
                 if (state && appliesTo(subject, state.name))
                     owned.add(marker.comment);

package/dist/rules/require-ticket.js

@@ -70,7 +70,7 @@ export default createRule({
         const reportReason = (subject, state) => {
             if (evaluate(subject, state).kind === 'ok' || hasAnnotationTicket(subject, state, options))
                 return;
-            const callee = context.sourceCode.getText(subject.node.callee);
+            const callee = context.sourceCode.getText(subject.node.callee).replace(/\s+/g, '');
             const first = subject.node.arguments.at(0);
             const where = options.framework.reasonArgument;
             // Vitest's `context.skip()` takes either a reason alone or a condition and then the reason.

package/dist/utils/analyze.d.ts

@@ -22,6 +22,10 @@ export interface Marker {
         text: string;
         range: TSESTree.Range;
     };
+    /** The index of the marker's line in `commentLines(comment)`. */
+    line: number;
+    /** Where the keyword starts in the source. */
+    keywordStart: number;
 }
 /** A marker whose keyword is exactly a state's marker. */
 export type StateMarker = Marker & {
@@ -87,6 +91,11 @@ export interface Subject {
      * Vitest's option states when its options object can't. Includes those of enclosing describes.
      */
     unknownStates: Set<string>;
+    /**
+     * States of other subjects whose comment block is this one's, as a test that is the arrow body of a
+     * describe, `describe('d', () => test.skip(...))`, so a marker for them isn't left over here.
+     */
+    sharedStates: Set<string>;
     /** True when this node is skipped or fixme'd by any means, whether or not those states are on. */
     skipped: boolean;
     ownSkip: boolean;
@@ -115,6 +124,8 @@ export interface Analysis {
     subjects: Subject[];
     /** Markers that are not in the comment block of any test, describe or runtime call. */
     detachedMarkers: StateMarker[];
+    /** Markers of `eslint-disable` regions that cover tests, none of them in the marker's state. */
+    idleRegionMarkers: StateMarker[];
     /** Commented-out tests; their comments are left out of the comment blocks of the tests around them. */
     commentedOutTests: CommentedOutTest[];
     /** Whether the file uses the test framework at all: an import from it or a call to a test function. */

package/dist/utils/analyze.js

@@ -32,14 +32,16 @@ export function directiveOf(comment) {
     return { kind, rules, description: { separator: separator.index, start: separator.index + separator[0].length } };
 }
 // A call at the start of a comment line, as `test('...'`, `test.describe.skip(` or `await test.step(`. Code has
-// no space before a call's `(`, and a sentence such as `// it (see above) ...` has one.
-const COMMENTED_CALL_RE = /^(\s*\*?\s*)(?:await\s+)?([A-Za-z_$][\w$]*)(?:\.[A-Za-z_$][\w$]*)*\(/;
+// no space before a call's `(`, and a sentence such as `// it (see above) ...` has one. An empty call, as
+// `test.skip()`, changes a test at runtime and declares none.
+const COMMENTED_CALL_RE = /^(\s*\*?\s*)(?:await\s+)?([A-Za-z_$][\w$]*)((?:\.[A-Za-z_$][\w$]*)*)\((?!\))/;
 /**
  * Blocks of comments that hold a test or describe written out as code: comments on consecutive lines with
- * no code before them, one of whose lines starts with a call of `names`. A JSDoc comment is documentation,
- * so a test in its example doesn't count.
+ * no code before them, one of whose lines starts with a call of `names` whose members all declare tests,
+ * as `test.describe.skip(`, unlike `test.use(`. A JSDoc comment is documentation, so a test in its example
+ * doesn't count.
  */
-function findCommentedOutTests(sourceCode, comments, names, states) {
+function findCommentedOutTests(sourceCode, comments, names, members, states) {
     const blocks = [];
     for (const comment of comments) {
         if (sourceCode.getTokenBefore(comment)?.loc.end.line === comment.loc.start.line)
@@ -59,7 +61,13 @@ function findCommentedOutTests(sourceCode, comments, names, states) {
             .flatMap(commentLines)
             .flatMap(({ text, start }) => {
             const match = COMMENTED_CALL_RE.exec(text);
-            return match && names.has(match[2]) ? [[start + match[1].length, start + text.trimEnd().length]] : [];
+            const declares = match !== null &&
+                names.has(match[2]) &&
+                match[3]
+                    .split('.')
+                    .slice(1)
+                    .every((member) => members.has(member));
+            return declares ? [[start + match[1].length, start + text.trimEnd().length]] : [];
         })
             .at(0);
         if (range === undefined)
@@ -389,8 +397,15 @@ function isLocalVariable(sourceCode, id) {
     }
     return false;
 }
+/** Values a constant can hold a test function in: `it.skip`, `it.skipIf(...)`, `` it.each`...` `` or `a ? b : c`. */
+const ALIAS_VALUES = new Set([
+    'MemberExpression',
+    'CallExpression',
+    'TaggedTemplateExpression',
+    'ConditionalExpression',
+]);
 const STATEMENT_CONTAINERS = new Set(['Program', 'BlockStatement', 'StaticBlock', 'SwitchCase', 'TSModuleBlock']);
-/** The statement a call belongs to; its marker block sits above that statement. */
+/** The statement a call, or a value, belongs to; its marker block sits above that statement. */
 /**
  * The declaration a call makes through `Function.prototype.call`, `apply` or `bind`, read as if it were
  * written plainly: `it.skip.call(null, 'title', fn)`, `it.skip.apply(null, ['title', fn])` and
@@ -516,20 +531,21 @@ export function commentLines(comment) {
 }
 function parseMarkers(comment, states) {
     const markers = [];
-    for (const { text, start } of commentLines(comment)) {
+    for (const [line, { text, start }] of commentLines(comment).entries()) {
         const match = MARKER_LINE_RE.exec(text);
         if (!match)
             continue;
         const [, keyword, rest] = match;
         const restOffset = start + match[0].length - rest.length;
+        const at = { comment, keyword, line, keywordStart: start + text.indexOf(keyword) };
         const state = states.find((s) => s.marker === keyword);
         if (state) {
-            markers.push({ comment, keyword, state, ...parseTickets(rest, restOffset, state.ticket) });
+            markers.push({ ...at, state, ...parseTickets(rest, restOffset, state.ticket) });
             continue;
         }
         const caseOf = states.find((s) => s.marker === keyword.toUpperCase());
         if (caseOf)
-            markers.push({ comment, keyword, caseOf, ...parseTickets(rest, restOffset, caseOf.ticket) });
+            markers.push({ ...at, caseOf, ...parseTickets(rest, restOffset, caseOf.ticket) });
     }
     return markers;
 }
@@ -983,9 +999,13 @@ const OPTION_VALUES = new Set([
  * Whether a runtime call always applies: it has no condition, or `true`, or with `notes` only a note, as
  * Vitest's `context.skip('Broker sandbox is down')`, and nothing around it makes it conditional.
  */
-function isUnconditional(call, notes) {
+function isUnconditional(call, framework) {
     const first = call.arguments.at(0);
-    const always = first === undefined || booleanOf(first) === true || (notes && isStaticText(first));
+    const always = first === undefined ||
+        booleanOf(first) === true ||
+        // node:test's `t.skip(message)` and Jasmine's `pending(message)` take no condition, so any argument is a note.
+        framework.reasonArgument === 'only' ||
+        (framework.skipNotes && isStaticText(first));
     return always && !isGuarded(call);
 }
 /**
@@ -1006,9 +1026,13 @@ function saysWhy(sourceCode, node) {
     const value = unwrap(node);
     return value.type !== 'Literal' && !(value.type === 'Identifier' && value.name === 'undefined');
 }
-/** Whether `node` is text that isn't blank. */
+/**
+ * Whether `node` is text that isn't blank, or a template with values in it, as `` `${browserName} has no
+ * clipboard` ``, which is taken on trust.
+ */
 function isReasonText(sourceCode, node) {
-    return Boolean(staticText(sourceCode, node)?.trim());
+    const text = staticText(sourceCode, node);
+    return text === undefined ? unwrap(node).type === 'TemplateLiteral' : text.trim() !== '';
 }
 /** Whether a runtime call gives the reason for its state where its framework takes one (see `reasonArgument`). */
 function callReason(sourceCode, call, where) {
@@ -1017,7 +1041,8 @@ function callReason(sourceCode, call, where) {
     if (where === 'only')
         return first !== undefined && saysWhy(sourceCode, first);
     // Vitest's `context.skip(isMobile)` takes a condition, so only text first is a reason.
-    if (where === 'either' && first !== undefined && staticText(sourceCode, first) !== undefined) {
+    const text = first !== undefined && (staticText(sourceCode, first) !== undefined || unwrap(first).type === 'TemplateLiteral');
+    if (where === 'either' && text) {
         return isReasonText(sourceCode, first);
     }
     return second !== undefined && saysWhy(sourceCode, second);
@@ -1140,9 +1165,11 @@ function runAnalysis(sourceCode, options) {
     const commentedOut = findCommentedOutTests(sourceCode, allComments, new Set([
         ...options.testFunctions,
         ...[...framework.exports, ...framework.globals].flatMap(([name, root]) => (root.kind === 'hook' ? [] : [name])),
-    ]), states);
+    ]), new Set([...framework.testMembers, ...framework.describeMembers, 'describe', 'step'].map((m) => m.replace('()', ''))), states);
     const comments = allComments.filter((comment) => !commentedOut.comments.has(comment));
     const regions = disableRegions(comments, states);
+    // A region's marker covers every test up to its `eslint-enable`, so it is never the own marker of the first.
+    const regionComments = new Set(regions.map((r) => r.comment));
     // `test.skip(...); // eslint-disable-line rule -- SKIP: TRADE-1` holds its marker on the test's own line.
     const lineDirectives = new Map();
     for (const comment of comments) {
@@ -1162,12 +1189,12 @@ function runAnalysis(sourceCode, options) {
     /** Describe bodies written as a `function`, whose `this` is Mocha's suite, which `this.retries()` acts on. */
     const suiteBodies = new Set();
     /**
-     * Whether a statement around `anchor` has a comment that says something above it, as `// why` above an `if`,
-     * up to `owner`, the test or describe the call acts on. The walk goes on through a callback passed to another
+     * Whether `anchor` or a statement around it has a comment that says something above it or at the end of its
+     * first line, as `// why` above an `if` or after its `{`, up to `owner`, the test or describe the call acts on. The walk goes on through a callback passed to another
      * call, such as a hook's or a step's, but stops at a function declared some other way.
      */
     const commentedAround = (anchor, owner) => {
-        for (let node = anchor.parent; node; node = node.parent) {
+        for (let node = anchor; node; node = node.parent) {
             if (FUNCTIONS.has(node.type)) {
                 const call = node.parent;
                 if (call?.type !== 'CallExpression' || call === owner || !call.arguments.includes(node)) {
@@ -1179,7 +1206,11 @@ function runAnalysis(sourceCode, options) {
             if (!container || !STATEMENT_CONTAINERS.has(container.type))
                 continue;
             const block = commentBlock(sourceCode, node, options.allowBlankLine);
-            if (block.some((comment) => !commentedOut.comments.has(comment) && hasText(comment)))
+            if (block.some((c) => !commentedOut.comments.has(c) && !regionComments.has(c) && hasText(c)))
+                return true;
+            // `if (isMobile) { // why`: a comment at the end of the line the statement starts on.
+            const first = sourceCode.getCommentsInside(node).at(0);
+            if (first?.loc.start.line === node.loc.start.line && hasText(first))
                 return true;
         }
         return false;
@@ -1200,17 +1231,18 @@ function runAnalysis(sourceCode, options) {
             block.push(...commentBlock(sourceCode, call, options.allowBlankLine).filter((c) => !commentedOut.comments.has(c)));
         }
         block.push(...(lineDirectives.get(call.loc.start.line) ?? []));
-        const inRegions = regions.filter((r) => r.start <= call.range[0] && call.range[0] < r.end && !block.includes(r.comment));
+        const inRegions = regions.filter((r) => r.start <= call.range[0] && call.range[0] < r.end);
         for (const comment of [...block, ...inRegions.map((r) => r.comment)])
             claimed.add(comment);
-        const commented = [...block, ...inRegions.map((r) => r.comment)].some(hasText);
-        // A runtime call can also say why above the statements around it in its function, above its test, or in
-        // its arguments.
-        const reasonedCall = () => kind === 'runtime' &&
-            ((framework.reasonArgument !== undefined && callReason(sourceCode, call, framework.reasonArgument)) ||
-                parent?.commented === true ||
-                trailingText(anchor) ||
-                commentedAround(anchor, parent?.node));
+        // A region's description says why a rule is off, not why a test is skipped; its marker's ticket counts.
+        const commented = block.some((comment) => !regionComments.has(comment) && hasText(comment));
+        // A comment at the end of the line also says why. A runtime call can also say why above the statements
+        // around it in its function, above its test, or in its arguments.
+        const reasonedCall = () => trailingText(anchor) ||
+            (kind === 'runtime' &&
+                ((framework.reasonArgument !== undefined && callReason(sourceCode, call, framework.reasonArgument)) ||
+                    parent?.commented === true ||
+                    commentedAround(anchor, parent?.node)));
         const ownTags = new Set(tagInfo.tags.map((t) => t.tag));
         const sources = [];
         for (const state of states) {
@@ -1266,9 +1298,10 @@ function runAnalysis(sourceCode, options) {
             inheritedTags,
             unreadTags: tagInfo.unread,
             unknownStates,
+            sharedStates: new Set(),
             skipped: ownSkip || (kind !== 'runtime' && parent?.skipped === true),
             ownSkip,
-            markers: block.flatMap((comment) => parseMarkers(comment, states)),
+            markers: block.flatMap((comment) => (regionComments.has(comment) ? [] : parseMarkers(comment, states))),
             regionMarkers: inRegions.flatMap((r) => r.markers),
             annotationTickets: tagInfo.annotations,
             unreadTickets: tagInfo.unreadAnnotations,
@@ -1386,8 +1419,8 @@ function runAnalysis(sourceCode, options) {
      * `(isCI ? describe.skip : describe)('order entry', ...)`: a test or describe whose function is picked by
      * a condition. A state that only one side has depends on the condition, like `test.skip(isCI)`.
      */
-    const pickedDeclaration = (call) => {
-        const callee = unwrap(call.callee);
+    const pickedDeclaration = (call, picker) => {
+        const callee = unwrap(picker);
         if (callee.type !== 'ConditionalExpression')
             return undefined;
         const [yes, no] = [callee.consequent, callee.alternate].map((side) => {
@@ -1456,22 +1489,52 @@ function runAnalysis(sourceCode, options) {
             ? declare(call, declaration, bodyInfos(call.arguments, []))
             : undefined;
     };
+    /**
+     * The value of a constant that holds a test function the collected names can't: one a condition picks, as
+     * `const itIf = isCI ? it.skip : it`, one a factory builds, as `const d = describe.runIf(hasDocker)`, or any
+     * declared inside a function.
+     */
+    const aliasValue = (callee) => {
+        if (callee.type !== 'Identifier' || testNames.roots.has(callee.name))
+            return undefined;
+        const value = declaredValue(sourceCode, callee);
+        return value && ALIAS_VALUES.has(unwrap(value).type) ? value : undefined;
+    };
+    /**
+     * Whether the declaration of a constant that holds a test function says why above it or at the end of its
+     * line, as `// no symlinks on Windows` above `const posixTest = isWindows ? test.skip : test`.
+     */
+    const aliasCommented = (value) => {
+        const statement = anchorOf(value);
+        const block = commentBlock(sourceCode, statement, options.allowBlankLine);
+        return (block.some((c) => !commentedOut.comments.has(c) && !regionComments.has(c) && hasText(c)) ||
+            trailingText(statement));
+    };
     const visitCall = (original) => {
+        const alias = aliasValue(throughFunctionMethods(original).callee);
+        const visited = visitDeclaredCall(original, alias);
+        if (alias && visited.subject && aliasCommented(alias)) {
+            for (const source of visited.subject.states)
+                if (source.reasoned === false)
+                    source.reasoned = true;
+        }
+        return visited;
+    };
+    const visitDeclaredCall = (original, alias) => {
         const call = throughFunctionMethods(original);
-        const callee = target(chainOf(call.callee, framework.factories));
+        const written = alias ?? call.callee;
+        const callee = target(chainOf(written, framework.factories));
         if (callee === undefined) {
-            return subtestOf(call) ?? pickedDeclaration(call) ?? { subject: runtimeCall(call) ?? retryCall(call) };
+            return subtestOf(call) ?? pickedDeclaration(call, written) ?? { subject: runtimeCall(call) ?? retryCall(call) };
         }
         usesTest = true;
         const args = call.arguments;
         const { path } = callee;
-        if (framework.retryCall === 'describe.configure' && path.join('.') === 'describe.configure') {
-            const options = args.at(0);
-            const object = options && unwrap(options);
-            const count = object?.type === 'ObjectExpression'
-                ? object.properties.find((p) => p.type === 'Property' && propertyName(p) === 'retries')
-                : undefined;
-            return { subject: retrySubject(call, count?.type === 'Property' ? count.value : undefined, 'configure') };
+        // `test.describe.configure(...)`, or `describe.configure(...)` with `const { describe } = test`.
+        const configure = path.join('.') === 'describe.configure' || (callee.root === DESCRIBE && path.join('.') === 'configure');
+        if (framework.retryCall === 'describe.configure' && configure) {
+            const count = detailsOf(sourceCode, call, true).entries.findLast(([key]) => key === 'retries');
+            return { subject: retrySubject(call, count?.[1], 'configure') };
         }
         const declaration = declarationOf(callee);
         // Vitest's `beforeEach((context) => context.skip())` and Mocha's `before(function () { this.skip(); })`
@@ -1635,7 +1698,7 @@ function runAnalysis(sourceCode, options) {
         return subject;
     };
     /** `step` is set for `step.skip()`, which skips only its step; the other calls act on the whole test. */
-    const runtimeSubject = (call, modifier, step, always = isUnconditional(call, framework.skipNotes)) => {
+    const runtimeSubject = (call, modifier, step, always = isUnconditional(call, framework)) => {
         if (!states.some((s) => s.modifier === modifier))
             return undefined;
         const subject = makeSubject('runtime', call, new Map([[modifier, always]]), NO_TAGS, step ?? stack.findLast((s) => s.kind !== 'step'));
@@ -1676,7 +1739,36 @@ function runAnalysis(sourceCode, options) {
         .filter((comment) => !claimed.has(comment))
         .flatMap((comment) => parseMarkers(comment, states))
         .filter(isStateMarker);
-    return { subjects, detachedMarkers, commentedOutTests: commentedOut.found, isTestFile: usesTest };
+    const byAnchor = new Map();
+    for (const subject of subjects)
+        byAnchor.set(subject.anchor, [...(byAnchor.get(subject.anchor) ?? []), subject]);
+    for (const subject of subjects) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every subject's anchor is a key
+        for (const other of byAnchor.get(subject.anchor)) {
+            if (other === subject)
+                continue;
+            for (const marker of subject.markers) {
+                if (marker.state && appliesTo(other, marker.state.name))
+                    subject.sharedStates.add(marker.state.name);
+            }
+        }
+    }
+    const idleRegionMarkers = regions
+        .flatMap((region) => region.markers)
+        .filter(isStateMarker)
+        .filter((marker) => {
+        const covered = subjects.filter((subject) => subject.regionMarkers.includes(marker));
+        return (covered.length > 0 &&
+            !isWorkComment(marker, options) &&
+            !covered.some((s) => appliesTo(s, marker.state.name) || s.unknownStates.has(marker.state.name)));
+    });
+    return {
+        subjects,
+        detachedMarkers,
+        idleRegionMarkers,
+        commentedOutTests: commentedOut.found,
+        isTestFile: usesTest,
+    };
 }
 /** Whether `subject` is in `stateName` at all, required or not, including inherited and runtime states. */
 export function appliesTo(subject, stateName) {
@@ -1701,7 +1793,7 @@ function candidateMarkers(subject, state) {
 export function evaluate(subject, state) {
     const markers = candidateMarkers(subject, state);
     if (markers.length === 0) {
-        const marker = subject.markers.find((m) => m.caseOf === state);
+        const marker = [...subject.markers, ...subject.regionMarkers].find((m) => m.caseOf === state);
         return marker ? { kind: 'case', marker } : { kind: 'missing' };
     }
     const isValid = (m) => m.tickets.length > 0 && m.tickets.every((t) => t.result === 'ok');
@@ -1775,8 +1867,12 @@ function isWorkComment(marker, options) {
 export function strayMarkers(subject, options) {
     return subject.markers.flatMap((marker) => {
         const state = marker.state ?? (marker.tickets.at(0)?.result === 'ok' ? marker.caseOf : undefined);
-        if (state === undefined || appliesTo(subject, state.name) || subject.unknownStates.has(state.name))
+        if (state === undefined ||
+            appliesTo(subject, state.name) ||
+            subject.unknownStates.has(state.name) ||
+            subject.sharedStates.has(state.name)) {
             return [];
+        }
         return isWorkComment(marker, options) ? [] : [{ ...marker, state }];
     });
 }

package/dist/utils/create-rule.js

@@ -7,7 +7,6 @@ import { resolveOptions } from "./options.js";
 export function createRule(definition) {
     return {
         meta: definition.meta,
-        defaultOptions: [],
         create(context) {
             const options = resolveOptions(context.settings);
             return {

package/dist/utils/fix.d.ts

@@ -1,13 +1,16 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { type Marker } from './analyze.ts';
 type SourceCode = Readonly<TSESLint.SourceCode>;
-/** Range of `keyword` where it is used as a marker (`KEYWORD:`) inside `comment`. */
-export declare function keywordRange(sourceCode: SourceCode, comment: TSESTree.Comment, keyword: string): TSESTree.Range;
+/** Range of a marker's keyword on the marker's own line. */
+export declare function keywordRange(marker: Marker): TSESTree.Range;
 /**
- * Removes a marker comment, and its whole line when nothing else is on it. From an ESLint directive it
- * removes only the description, so the directive keeps working.
+ * Removes a marker. From a comment that says more, it removes only the marker's line. Otherwise it removes
+ * the comment, and its whole line when nothing else is on it, or from an ESLint directive only the
+ * description, so the directive keeps working.
  */
-export declare function removeMarkerComment(sourceCode: SourceCode, comment: TSESTree.Comment): TSESLint.RuleFix;
+export declare function removeMarkerComment(sourceCode: SourceCode, marker: Marker): TSESLint.RuleFix;
+/** The line break that ends the line `comment` ends on. */
+export declare function lineBreakAfter(sourceCode: SourceCode, comment: TSESTree.Comment): string;
 /** Indentation of the line `comment` starts on. */
 export declare function indentOf(sourceCode: SourceCode, comment: TSESTree.Comment): string;
 /**

package/dist/utils/fix.js

@@ -1,21 +1,26 @@
-import { directiveOf, isFunction } from "./analyze.js";
-function escapeRegExp(text) {
-    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/** Range of `keyword` where it is used as a marker (`KEYWORD:`) inside `comment`. */
-export function keywordRange(sourceCode, comment, keyword) {
-    const text = sourceCode.getText(comment);
-    // Only called with a keyword that was parsed from this comment, so it always matches.
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
-    const match = new RegExp(`(^|[^\\w-])(${escapeRegExp(keyword)})\\s*:`).exec(text);
-    const start = comment.range[0] + match.index + match[1].length;
-    return [start, start + keyword.length];
+import { commentLines, directiveOf, isFunction } from "./analyze.js";
+/** Range of a marker's keyword on the marker's own line. */
+export function keywordRange(marker) {
+    return [marker.keywordStart, marker.keywordStart + marker.keyword.length];
 }
 /**
- * Removes a marker comment, and its whole line when nothing else is on it. From an ESLint directive it
- * removes only the description, so the directive keeps working.
+ * Removes a marker. From a comment that says more, it removes only the marker's line. Otherwise it removes
+ * the comment, and its whole line when nothing else is on it, or from an ESLint directive only the
+ * description, so the directive keeps working.
  */
-export function removeMarkerComment(sourceCode, comment) {
+export function removeMarkerComment(sourceCode, marker) {
+    const { comment, line: index } = marker;
+    const lines = commentLines(comment);
+    if (lines.some(({ text }, i) => i !== index && /[^\s*]/.test(text))) {
+        const { start, text } = lines[index];
+        if (index === 0) {
+            // A JSDoc comment keeps the `*` of its `/**`.
+            return { range: [start + text.search(/[^*]/), start + text.length], text: '' };
+        }
+        const previous = lines[index - 1];
+        const end = index === lines.length - 1 ? text.trimEnd().length : text.length;
+        return { range: [previous.start + previous.text.length, start + end], text: '' };
+    }
     const description = directiveOf(comment)?.description;
     if (description) {
         // `//` and `/*` are both two characters; a block comment keeps the space before its `*/`.
@@ -29,6 +34,12 @@ export function removeMarkerComment(sourceCode, comment) {
     const aloneOnLine = text.slice(lineStart, comment.range[0]).trim() === '' && text.slice(comment.range[1], lineEnd).trim() === '';
     return { range: aloneOnLine ? [lineStart, lineEnd] : comment.range, text: '' };
 }
+/** The line break that ends the line `comment` ends on. */
+export function lineBreakAfter(sourceCode, comment) {
+    // A line comment above a test always ends at a line break.
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
+    return /^(?:\r\n|[\r\n\u2028\u2029])/.exec(sourceCode.text.slice(comment.range[1]))[0];
+}
 /** Indentation of the line `comment` starts on. */
 export function indentOf(sourceCode, comment) {
     const line = sourceCode.lines[comment.loc.start.line - 1];
@@ -63,14 +74,18 @@ export function moveToAnnotation(sourceCode, call, marker, source, type) {
     const details = call.arguments.at(1);
     if (isFunction(title))
         return undefined;
-    const remove = removeMarkerComment(sourceCode, comment);
+    const remove = removeMarkerComment(sourceCode, marker);
     if (isFunction(details)) {
+        // Vitest reads a timeout or options after the function only as the third argument.
+        if (call.arguments.length > 2)
+            return undefined;
         return (fixer) => [remove, fixer.insertTextAfter(title, `, { ${property} }`)];
     }
     if (details?.type !== 'ObjectExpression')
         return undefined;
     const taken = details.properties.some((prop) => prop.type === 'SpreadElement' ||
-        (!prop.computed && (prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value)) === source.key));
+        prop.computed ||
+        (prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value)) === source.key);
     if (taken)
         return undefined;
     const last = details.properties.at(-1);

package/dist/utils/options.d.ts

@@ -26,15 +26,17 @@ export interface GovernanceOptions {
     framework: FrameworkName;
     /**
      * Names that are treated as the framework's `test` function. Defaults to `['test']` for Playwright,
-     * `['test', 'it']` for Jest and Vitest, and `['it', 'specify', 'test']` for Mocha, Cypress and
-     * WebdriverIO. Your list replaces the default one, so include those names if you still need them.
+     * `['test', 'it']` for Jest, Vitest and node:test, `['it', 'specify', 'test']` for Mocha, Cypress and
+     * WebdriverIO, and `['it']` for Jasmine. Your list replaces the default one, so include those names if you
+     * still need them.
      */
     testFunctions?: string[];
     /** Accepted ticket formats. Defaults to `{ preset: 'any' }`. */
     ticket?: TicketSpec | TicketSpec[];
     /**
-     * Tickets that are rejected as placeholders. `*` matches any characters. Your list replaces the default
-     * one (`TODO`, `TBD`, `XXX-*`, ...); tickets numbered 0 are always rejected.
+     * Tickets that are rejected as placeholders. `*` matches any characters. Case-insensitive, and a leading `#`
+     * on the ticket or the placeholder is ignored. Your list replaces the default one (`TODO`, `TBD`, `XXX-*`,
+     * ...); tickets numbered 0 are always rejected.
      */
     placeholders?: string[];
     /** Turns on the `@new` and `@quarantined` states. */

package/dist/utils/options.js

@@ -1,8 +1,8 @@
 import { BUILTIN_STATE_NAMES, DEFAULT_COMMENT_KEYWORDS, HOST_ENTRY_RE, } from "./constants.js";
 import { ConfigError } from "./errors.js";
 import { FRAMEWORKS } from "./frameworks.js";
-import { optionsSchema } from "./schema.js";
-import { compileTicketSpec, DEFAULT_PLACEHOLDERS } from "./tickets.js";
+import { optionsSchema, PROJECT_PATTERN } from "./schema.js";
+import { compileTicketSpec, DEFAULT_PLACEHOLDERS, NUMERIC_MAX_LENGTH, ticketPattern, } from "./tickets.js";
 import { validate } from "./validate.js";
 export const SETTINGS_KEY = 'test-governance';
 export function isTagState(state) {
@@ -83,13 +83,17 @@ const STRICT_HOST_PRESETS = new Set([
     'phabricator',
     'plane',
 ]);
+const PROJECT_RE = new RegExp(PROJECT_PATTERN);
 /** Option values the schema allows for every preset but this one can't use. */
 function ownOptionProblems(spec, at) {
     const problems = [];
-    if (spec.preset === 'jira' && Array.isArray(spec.projects)) {
+    // The schema lets YouTrack's `4DM` through; Jira and Plane keys start with a letter and match nothing else.
+    // A key the schema rejects, such as a lowercase one, is reported there.
+    if ((spec.preset === 'jira' || spec.preset === 'plane') && Array.isArray(spec.projects)) {
+        const tracker = spec.preset === 'jira' ? 'Jira' : 'Plane';
         for (const [i, key] of spec.projects.entries()) {
-            if (typeof key !== 'string' || !/^[A-Z][A-Z0-9_]+$/.test(key)) {
-                problems.push(`${at}.projects[${i}] must start with a letter and have at least two characters, as Jira keys do (got "${key}")`);
+            if (typeof key === 'string' && PROJECT_RE.test(key) && !/^[A-Z][A-Z0-9_]+$/.test(key)) {
+                problems.push(`${at}.projects[${i}] must start with a letter and have at least two characters, as ${tracker} keys do (got "${key}")`);
             }
         }
     }
@@ -103,6 +107,25 @@ function ownOptionProblems(spec, at) {
     if (spec.preset === 'servicenow' && spec.prefixes === undefined) {
         problems.push(`${at}.prefixes is required by the "servicenow" preset: the record-number prefixes it accepts, such as STRY`);
     }
+    if (spec.preset === 'numeric') {
+        const { minLength, maxLength = NUMERIC_MAX_LENGTH } = spec;
+        if (typeof minLength === 'number' && typeof maxLength === 'number' && minLength > maxLength) {
+            problems.push(spec.maxLength === undefined
+                ? `${at}.minLength (${minLength}) is greater than the default maxLength (${maxLength}); set maxLength as well`
+                : `${at}.minLength (${minLength}) is greater than maxLength (${maxLength})`);
+        }
+    }
+    if (spec.preset === 'pattern') {
+        const { pattern, flags } = spec;
+        if (typeof pattern === 'string' && (flags === undefined || typeof flags === 'string')) {
+            try {
+                ticketPattern(pattern, flags);
+            }
+            catch (error) {
+                problems.push(`${at}.pattern is not a valid regex: ${error.message}`);
+            }
+        }
+    }
     return problems;
 }
 /** A spec the cross-field checks can read: an object whose `preset` names one of the presets. */
@@ -182,14 +205,12 @@ export function compileOptions(options) {
         const raw = overrides[name];
         const override = typeof raw === 'boolean' ? { enabled: raw } : (raw ?? {});
         const enabled = override.enabled ?? (def.lifecycle ? (options.lifecycleTags ?? def.enabled) : def.enabled);
+        // Compiled even for a state that is off, so a mistake in its ticket format shows before it is turned on.
+        const ticket = override.ticket === undefined ? defaultMatcher : compile(override.ticket);
         // A state the framework has no way to enter, such as `fixme` in Jest, stays off.
         if (!enabled || !framework.states.has(name))
             continue;
-        const base = {
-            name,
-            marker: override.marker ?? def.marker,
-            ticket: override.ticket === undefined ? defaultMatcher : compile(override.ticket),
-        };
+        const base = { name, marker: override.marker ?? def.marker, ticket };
         states.push(def.modifier === undefined ? { ...base, tag: override.tag ?? def.tag } : { ...base, modifier: def.modifier });
     }
     for (const [name, custom] of Object.entries(options.customStates ?? {})) {

package/dist/utils/schema.d.ts

@@ -1,3 +1,5 @@
 import type { Schema } from './validate.ts';
+/** YouTrack project IDs may also start with a digit, as `4DM` in `4DM-12`; `jira` checks its own in options.ts. */
+export declare const PROJECT_PATTERN = "^(?=[A-Z0-9_]*[A-Z])[A-Z0-9_]+$";
 /** The shape of `settings['test-governance']`, the options of `configure()`. */
 export declare const optionsSchema: Schema;

package/dist/utils/schema.js

@@ -7,7 +7,7 @@ const KEY_HINT = 'an uppercase key as it appears in tickets, such as WEB for WEB
 /** Linear teams and the prefixes of Notion, ClickUp and monday.com keys have at least two characters. */
 const LONG_KEY_HINT = 'an uppercase key of two or more characters as it appears in tickets, such as WEB for WEB-123';
 /** YouTrack project IDs may also start with a digit, as `4DM` in `4DM-12`; `jira` checks its own in options.ts. */
-const PROJECT_PATTERN = '^(?=[A-Z0-9_]*[A-Z])[A-Z0-9_]+$';
+export const PROJECT_PATTERN = '^(?=[A-Z0-9_]*[A-Z])[A-Z0-9_]+$';
 /** `['"a"', '"b"', '"c"']` as `"a", "b" or "c"`. */
 const orList = (items) => `${items.slice(0, -1).join(', ')} or ${items.slice(-1).join('')}`;
 /** How code reads a framework's config: `configs.mocha`, or `configs['node-test']` for a name with a dash. */

package/dist/utils/tickets.d.ts

@@ -80,4 +80,8 @@ export interface TicketMatcher {
     example: string;
 }
 export declare const DEFAULT_PLACEHOLDERS: string[];
+/** The `numeric` preset's `maxLength` when it isn't set. */
+export declare const NUMERIC_MAX_LENGTH = 20;
+/** The regex a `pattern` spec matches whole tickets with. Throws a SyntaxError when the pattern or flags are invalid. */
+export declare function ticketPattern(pattern: string, flags: string | undefined): RegExp;
 export declare function compileTicketSpec(specs: TicketSpec[], placeholders: string[]): TicketMatcher;

package/dist/utils/tickets.js

@@ -1,5 +1,7 @@
 import { ConfigError } from "./errors.js";
 export const DEFAULT_PLACEHOLDERS = ['TODO', 'TBD', 'XXX-*', '0'];
+/** The `numeric` preset's `maxLength` when it isn't set. */
+export const NUMERIC_MAX_LENGTH = 20;
 // Every pattern below is anchored and has no nested or overlapping quantifiers, so matching is
 // linear in the token length. URLs are parsed with `new URL` rather than a regex.
 const KEY_RE = /^([A-Z][A-Z0-9_]+)-\d+$/;
@@ -10,11 +12,12 @@ const AZURE_REF_RE = /^AB#\d+$/;
 const DIGITS_RE = /^\d+$/;
 // Jira Server and Data Center can run under a path, as in https://issues.example.com/jira/browse/TRADE-1.
 const JIRA_PATH_RE = /\/browse\/([A-Z][A-Z0-9_]+-\d+)\/?$/;
-const GITHUB_PATH_RE = /^\/[^/]+\/[^/]+\/(?:issues|pull)\/(\d+)\/?$/;
+// Gitea, Forgejo and Codeberg write a pull request as `/pulls/N`, GitHub as `/pull/N`.
+const GITHUB_PATH_RE = /^\/[^/]+\/[^/]+\/(?:issues|pulls?)\/(\d+)\/?$/;
 const GITLAB_PATH_RE = /\/-\/(?:issues|merge_requests|work_items)\/(\d+)\/?$/;
-const LINEAR_PATH_RE = /^\/[^/]+\/issue\/([A-Z][A-Z0-9]*-\d+)(?:\/[^/]*)?$/;
+const LINEAR_PATH_RE = /^\/[^/]+\/issue\/([A-Z][A-Z0-9]*-\d+)(?:\/[^/]+)?\/?$/;
 const AZURE_PATH_RE = /\/_workitems\/edit\/(\d+)\/?$/;
-const TRELLO_PATH_RE = /^\/c\/([A-Za-z0-9]{8})(?:\/[^/]*)?$/;
+const TRELLO_PATH_RE = /^\/c\/([A-Za-z0-9]{8})(?:\/[^/]+)?\/?$/;
 // A Notion page ID is 32 hex digits, plain or dashed as a UUID, at the end of the page's last path segment.
 const NOTION_ID = '[0-9a-f]{32}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
 const NOTION_PAGE_RE = new RegExp(`(?:^|-)(${NOTION_ID})$`);
@@ -33,10 +36,10 @@ const MONDAY_PATH_RE = /^\/boards\/\d+\/pulses\/(\d+)(?:\/.*)?$/;
 // YouTrack project IDs may start with a digit (4DM-12) but can't be digits only.
 const YOUTRACK_KEY_RE = /^([A-Z0-9_]+)-\d+$/;
 // `/issue/KT-1` and the newer `/projects/KT/issues/KT-1`, with an optional title after the key.
-const YOUTRACK_PATH_RE = /\/(?:issue|projects\/[^/]+\/issues)\/([A-Z0-9_]+-\d+)(?:\/[^/]*)?$/;
+const YOUTRACK_PATH_RE = /\/(?:issue|projects\/[^/]+\/issues)\/([A-Z0-9_]+-\d+)(?:\/[^/]+)?\/?$/;
 const BASECAMP_PATH_RE = /^\/\d+\/buckets\/\d+\/(?:todos|card_tables\/cards)\/(\d+)\/?$/;
 const SHORTCUT_REF_RE = /^(?:sc-(\d+)|\[sc-(\d+)\])$/i;
-const SHORTCUT_PATH_RE = /^\/[^/]+\/story\/(\d+)(?:\/[^/]*)?$/;
+const SHORTCUT_PATH_RE = /^\/[^/]+\/story\/(\d+)(?:\/[^/]+)?\/?$/;
 // OpenProject work packages: the canonical `/projects/<identifier>/work_packages/<id or AGILE-1>` with any
 // tab path after it, and the `/wp/<id>` short form its changelog links use.
 const OPENPROJECT_PATH_RE = /\/projects\/[^/]+\/work_packages\/([A-Z][A-Z0-9_]+-\d+|\d+)(?:\/.*)?\/?$/;
@@ -50,7 +53,7 @@ const PHABRICATOR_PATH_RE = /^\/T(\d+)\/?$/;
 // Rally numbers its work items per workspace from 1 without padding (US42, US41048), so a zero-padded ID is
 // no Rally ticket: it is how MITRE ATT&CK writes its technique IDs (TA0001 to TA0043), which security suites
 // put above tests. An all-zero ID such as TA0000 is a placeholder, as in every preset.
-const RALLY_REF_RE = /^(?:US|DE|TA|TC)([1-9]\d*|0*)$/;
+const RALLY_REF_RE = /^(?:US|DE|TA|TC)([1-9]\d*|0+)$/;
 // Plane work items: `/<workspace>/<project>/issues/<WEB-142 or uuid>`, unanchored for a self-hosted path.
 const PLANE_PATH_RE = /\/[^/]+\/[^/]+\/issues\/([A-Z][A-Z0-9_]+-\d+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\/?$/;
 // No tracker issues number 0. A preset hands back the ID it finds, and an ID of zeros (0, 000, or a
@@ -61,7 +64,7 @@ const ZERO_ID_RE = /(?:^|[-#/])0+[/\]]?$/;
 // The number at the end of a link to an unknown tracker, as in `/issues/123`.
 const LINK_NUMBER_RE = /\/(\d+)\/?$/;
 function parseUrl(ticket) {
-    if (!/^https?:\/\//.test(ticket))
+    if (!/^https?:\/\//i.test(ticket))
         return undefined;
     try {
         return new URL(ticket);
@@ -107,15 +110,18 @@ function keyId(key, ok) {
 }
 /**
  * A link's ID when the preset doesn't know the tracker: the keys in its path, `#/route` or query (Jira's
- * `?selectedIssue=TRADE-1`) and the number its path or route ends in. A zero among them makes the link a
- * placeholder, as in 0.9.0; with none, the link itself stands for the ID.
+ * `?selectedIssue=TRADE-1`), the number its path or route ends in, and its `id` query (Wrike's
+ * `?id=4821`). A zero among them makes the link a placeholder, as in 0.9.0; with none, the link itself
+ * stands for the ID.
  */
 function linkId(url) {
     const route = /^#!?\//.test(url.hash) ? url.hash.replace(/^#!?/, '') : '';
-    const parts = [...url.pathname.split('/'), ...route.split('/'), ...[...url.searchParams.values()].map(trimSlash)];
+    const query = [...url.searchParams].map(([key, value]) => [key, trimSlash(value)]);
+    const parts = [...url.pathname.split('/'), ...route.split('/'), ...query.map(([, value]) => value)];
     const keys = parts.filter((part) => KEY_RE.test(part));
     const ends = [url.pathname, route].flatMap((path) => LINK_NUMBER_RE.exec(path)?.[1] ?? []);
-    const numbers = [...keys, ...ends].map(numberOf);
+    const ids = query.flatMap(([key, value]) => (key.toLowerCase() === 'id' && DIGITS_RE.test(value) ? [value] : []));
+    const numbers = [...keys, ...ends, ...ids].map(numberOf);
     return numbers.find((id) => ZERO_RE.test(id)) ?? numbers.at(0) ?? url.href;
 }
 /** `TRADE, RISK or OPS` for `['TRADE', 'RISK', 'OPS']`. */
@@ -126,6 +132,15 @@ function orList(list) {
 function describeList(words, list) {
     return list === undefined ? '' : ` ${words} ${orList(list)}`;
 }
+/** The regex a `pattern` spec matches whole tickets with. Throws a SyntaxError when the pattern or flags are invalid. */
+export function ticketPattern(pattern, flags) {
+    // `g` and `y` make `test()` resume from the last match, so the same ticket would pass and fail
+    // in turn. A ticket is matched whole, so they never change what matches; drop them.
+    const kept = flags?.replace(/[gy]/g, '');
+    // Compiled alone first: a stray `)` in it would otherwise close the anchoring group and match anything.
+    new RegExp(pattern, kept);
+    return new RegExp(`^(?:${pattern})$`, kept);
+}
 function compilePreset(spec) {
     switch (spec.preset) {
         case 'any':
@@ -476,10 +491,7 @@ function compilePreset(spec) {
         }
         case 'numeric': {
             const min = spec.minLength ?? 1;
-            const max = spec.maxLength ?? 20;
-            if (min > max) {
-                throw new ConfigError(`numeric ticket minLength (${min}) is greater than maxLength (${max}).`);
-            }
+            const max = spec.maxLength ?? NUMERIC_MAX_LENGTH;
             return {
                 find: (t) => (DIGITS_RE.test(t) && t.length >= min && t.length <= max ? t : undefined),
                 expected: min === max ? `a ${min}-digit number` : `a number with ${min} to ${max} digits`,
@@ -493,9 +505,7 @@ function compilePreset(spec) {
             }
             let re;
             try {
-                // `g` and `y` make `test()` resume from the last match, so the same ticket would pass and fail
-                // in turn. A ticket is matched whole, so they never change what matches; drop them.
-                re = new RegExp(`^(?:${spec.pattern})$`, spec.flags?.replace(/[gy]/g, ''));
+                re = ticketPattern(spec.pattern, spec.flags);
             }
             catch (error) {
                 throw new ConfigError(`invalid ticket pattern "${spec.pattern}": ${error.message}`);
@@ -546,10 +556,11 @@ function matchesGlob(glob, value) {
 }
 export function compileTicketSpec(specs, placeholders) {
     const presets = specs.map(compilePreset);
+    const globs = placeholders.map((glob) => glob.replace(/^#/, ''));
     return {
         check(ticket) {
             const bare = ticket.replace(/^#/, '');
-            if (placeholders.some((glob) => matchesGlob(glob, ticket) || matchesGlob(glob, bare)))
+            if (globs.some((glob) => matchesGlob(glob, ticket) || matchesGlob(glob, bare)))
                 return 'placeholder';
             for (const generic of [false, true]) {
                 const ids = presets.flatMap((preset) => Boolean(preset.generic) === generic ? (preset.find(ticket) ?? []) : []);

package/dist/utils/validate.js

@@ -109,7 +109,7 @@ export function validate(value, schema, path = '') {
         for (const [key, item] of Object.entries(object)) {
             if (item === undefined)
                 continue;
-            const propertySchema = properties[key] ?? schema.additionalProperties;
+            const propertySchema = Object.hasOwn(properties, key) ? properties[key] : schema.additionalProperties;
             if (typeof propertySchema === 'object') {
                 problems.push(...validate(item, propertySchema, join(path, key)));
             }

package/docs/rules/no-orphaned-marker.md

@@ -11,7 +11,9 @@
 When a test is promoted from `@new`, or a skipped test is fixed, its marker is often left behind.
 A leftover marker makes searches for open tickets lie. This rule reports:
 
-- a marker above a test, describe or skip call that is not in that marker's state, and
+- a marker above a test, describe or skip call that is not in that marker's state,
+- a marker in the description of an `eslint-disable` block comment, which covers the tests up to the
+  `eslint-enable`, when none of those tests is in that marker's state, and
 - a marker that is not directly above a test, describe or skip call at all, so it has no effect.
 
 `FIXME:` and `TODO:` are also everyday work comments, so this rule leaves them to
@@ -45,7 +47,8 @@ and checked as usual.
 
 Files without tests, such as application code, are not checked.
 
-The rule offers a suggestion to delete the comment.
+The rule offers a suggestion to delete the comment. From a block comment that says more, such as a doc
+comment above the test, it deletes only the marker's line.
 
 ## Examples
 

package/docs/rules/require-ticket-for-commented-out-tests.md

@@ -23,6 +23,8 @@ How comments are read:
 
 - A commented-out test is a comment line that starts with a call of a test or describe function of the
   framework, such as `test(`, `test.describe(`, `it.skip(` or `xit(`, after any `*` of a block comment.
+  A call that declares no test, such as `test.use({ ... })`, `test.describe.configure(...)` or an empty
+  `test.slow()`, doesn't count.
 - Comments on consecutive lines, with no code before them on their line, form one block. The block is
   reported once, at its first test line, and a `SKIP:` marker anywhere in it covers it. A blank line starts a
   new block.

package/docs/rules/require-ticket.md

@@ -114,14 +114,19 @@ If one test or describe has several markers for the same state, each must be val
 With `requireReasonForConditional: true`, a conditional skip needs a reason but no ticket, so nobody has
 to guess later why it doesn't run. Any of these counts:
 
-- a comment above it or at the end of its line, above a statement around it, such as the `if`, or above
-  the hook, step or test it is in. Commented-out code, a marker keyword alone such as `// SKIP:`, and an
-  `eslint-disable` comment without a description after `--` say nothing, so they don't count;
+- a comment above it or at the end of its line, above a statement around it, such as the `if`, or at the
+  end of that statement's first line, as `if (isMobile) { // why`, or above the hook, step or test it is in.
+  Commented-out code, a marker keyword alone such as `// SKIP:`, and an `eslint-disable` comment without a
+  description after `--` say nothing, so they don't count. The description of an `eslint-disable` block
+  comment that turns a rule off for a stretch of the file says why the rule is off, so it doesn't count either;
+- for a test or describe whose function a constant picks, as `const posixTest = isWindows ? test.skip : test`,
+  a comment above that declaration or at the end of its line, which says why once for every test that uses it;
 - the reason its call takes, where the runner has one: Playwright's `test.skip(condition, 'why')` and
   `testInfo.skip(condition, 'why')`, Vitest's `context.skip(condition, 'why')` or `context.skip('why')`,
   node:test's `t.skip('why')` and Jasmine's `pending('why')`. A reason held in a name or built in a
   template is taken on trust;
-- in node:test, text in the option, as `{ skip: isWindows && 'No symlinks' }`, which Node reports;
+- in node:test, text or a template in the option, as `{ skip: isWindows && 'No symlinks' }`, which Node
+  reports;
 - a ticket, from a marker or an annotation.
 
 The same goes for the other states a condition can set, such as `test.fixme(condition)`. With

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "ESLint rules that require a ticket for skipped, fixme, todo, retried, tagged and commented-out Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO, node:test and Jasmine tests.",
   "keywords": [
     "eslint",