eslint-plugin-test-governance 0.10.1 → 0.11.1

package/CHANGELOG.md

@@ -6,6 +6,37 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.11.1] - 2026-11-03
+
+### Fixed
+
+- A skip declared through `Function.prototype.call`, `apply` or `bind`, such as
+  `test.skip.call(null, 'places an order', fn)` or `test.skip.bind(null)('places an order', fn)`, is
+  checked like the plain call, so it needs its ticket.
+
+## [0.11.0] - 2026-11-01
+
+### Added
+
+- Ticket presets for six more trackers: `openproject` (classic `#4821` work package IDs, per-project IDs
+  such as `AGILE-1`, and work package links once `host` is set), `bugzilla` (bug numbers, and
+  `show_bug.cgi?id=4821` links once `host` is set), `phabricator` (task monograms such as `T4821`, and
+  `/T4821` links once `host` is set; Phorge shares the format), `rally` (formatted IDs `US4821`, `DE4821`,
+  `TA4821`, `TC4821`), `servicenow` (record numbers such as `STRY0010001` for the `prefixes` you list) and
+  `plane` (work-item IDs such as `WEB-142`, and work-item links on `app.plane.so` or a `host`). The
+  `rally` preset rejects zero-padded IDs, which is how MITRE ATT&CK writes its technique IDs (`TA0006`).
+- Tickets from test annotations: with `annotations` (default `{ type: 'issue' }`), a valid ticket in
+  Playwright's `annotation` of that type or Vitest's `meta` key of that name satisfies the ticket
+  requirement, on tests and describes; an invalid one is reported, and `annotations: false` turns it
+  off. Comments stay the form that works everywhere; Jest, Mocha, Jasmine, node:test and Cypress have
+  no annotations.
+
+### Changed
+
+- A `host` value with a scheme, port or path, such as `https://jira.example.com` or `tracker.io:8080`, is
+  now a configuration error on every preset that takes `host`, not only on `notion`, `redmine` and
+  `youtrack`. Such a value never matched a URL hostname, so it already rejected every link silently.
+
 ## [0.10.1] - 2026-10-31
 
 ### Fixed
@@ -416,7 +447,9 @@ 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.10.1...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.11.1...HEAD
+[0.11.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.11.0...v0.11.1
+[0.11.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.10.1...v0.11.0
 [0.10.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.10.0...v0.10.1
 [0.10.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.1...v0.9.0

package/README.md

@@ -242,6 +242,7 @@ and markers. To turn a rule off, set it to `'off'` as usual.
 | `allowBlankLine`              | `boolean`                                                                                                 | `false`                           | Let blank lines separate a marker from its test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `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 }`                                                                              | `{ 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. 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.                                                                                                                                                                                                                                                                  |
 | `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.                                                                                                                                                                                                                                                                                                                                             |
 
@@ -274,37 +275,48 @@ a `customStates` entry.
 
 ### Ticket presets
 
-| Preset         | Accepts                                                                                                                                                                       | Options                                                                                                                            |
-| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| `any`          | `PROJ-123`, `#123`, `owner/repo#123`, any http(s) URL                                                                                                                         |                                                                                                                                    |
-| `jira`         | `TRADE-123`, `https://<host>/browse/TRADE-123` (also under a path, as in `/jira/browse/TRADE-123`), board URLs with `selectedIssue=TRADE-123`                                 | `projects`; `host` (any host by default)                                                                                           |
-| `github`       | `#123`, `owner/repo#123`, `https://github.com/owner/repo/issues/123` (or `/pull/`)                                                                                            | `host` for GitHub Enterprise (`github.com` by default)                                                                             |
-| `gitlab`       | `#123`, `group/project#123`, `https://gitlab.com/group/project/-/issues/123`                                                                                                  | `host` for self-managed (`gitlab.com` by default)                                                                                  |
-| `linear`       | `RISK-123`, `https://linear.app/<workspace>/issue/RISK-123/...`                                                                                                               | `teams`                                                                                                                            |
-| `azure-devops` | `AB#123`, `#123`, `https://dev.azure.com/<org>/<project>/_workitems/edit/123`                                                                                                 | `host` for Azure DevOps Server (`dev.azure.com` and `*.visualstudio.com` by default)                                               |
-| `trello`       | card links, `https://trello.com/c/nqPiDKmw` with or without the `/9-title` after it                                                                                           |                                                                                                                                    |
-| `notion`       | Unique IDs such as `TASK-123`, `https://www.notion.so/TASK-123`, page links that end in the page ID (also `https://app.notion.com/p/...`), database links with `?p=<page ID>` | `prefixes`; `host` for a custom domain (`notion.so`, `www.notion.so`, `app.notion.com` and `*.notion.site` by default)             |
-| `asana`        | task links, `https://app.asana.com/0/<project>/<task>` and the newer `https://app.asana.com/1/<workspace>/.../task/<task>`                                                    |                                                                                                                                    |
-| `clickup`      | `CU-86abc123`, `#86abc123`, custom IDs such as `DEV-123`, `https://app.clickup.com/t/86abc123` or `/t/<workspace>/DEV-123`, view links with `?p=<task>`                       | `prefixes` for custom IDs                                                                                                          |
-| `redmine`      | `#123`, `#123-4` and `#123#note-4` (a note), `##123`; with `host`, `https://<host>/issues/123` (also under a path)                                                            | `host`, needed for links                                                                                                           |
-| `monday`       | item links, `https://<account>.monday.com/boards/<board>/pulses/<item>`, and custom keys such as `TIX-001`                                                                    | `prefixes` for custom keys                                                                                                         |
-| `youtrack`     | `KT-123`, `https://<host>/issue/KT-123/...` or `/projects/KT/issues/KT-123` (also under a path, as in `/youtrack/issue/KT-123`)                                               | `projects`; `host` for Server or a custom domain (`youtrack.jetbrains.com`, `*.youtrack.cloud` and `*.myjetbrains.com` by default) |
-| `basecamp`     | to-do and card links, `https://3.basecamp.com/<account>/buckets/<project>/todos/<id>` or `/card_tables/cards/<id>`                                                            |                                                                                                                                    |
-| `shortcut`     | `sc-123`, `[sc-123]`, `https://app.shortcut.com/<workspace>/story/123/...`                                                                                                    |                                                                                                                                    |
-| `url`          | links to the hosts you list, and nothing else                                                                                                                                 | `hosts`, required: host names such as `tasks.example.com`, with no scheme, port or path; `*.example.com` matches its subdomains    |
-| `numeric`      | `4821`                                                                                                                                                                        | `minLength` (1), `maxLength` (20)                                                                                                  |
-| `pattern`      | anything matching your regex, anchored at both ends                                                                                                                           | `pattern`, `flags`                                                                                                                 |
-
-`projects` (Jira, YouTrack), `teams` (Linear) and `prefixes` (Notion, ClickUp, monday.com) are keys as
-they appear in tickets, in uppercase: `TRADE` for `TRADE-123`. YouTrack project IDs may also start with a digit, as `4DM`. Without them, any key passes. `host` is a host name such as `jira.example.com`, or
-`*.example.com` for every subdomain, as in `{ preset: 'jira', host: '*.atlassian.net' }`. Each preset
+| Preset         | Accepts                                                                                                                                                                        | Options                                                                                                                            |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `any`          | `PROJ-123`, `#123`, `owner/repo#123`, any http(s) URL                                                                                                                          |                                                                                                                                    |
+| `jira`         | `TRADE-123`, `https://<host>/browse/TRADE-123` (also under a path, as in `/jira/browse/TRADE-123`), board URLs with `selectedIssue=TRADE-123`                                  | `projects`; `host` (any host by default)                                                                                           |
+| `github`       | `#123`, `owner/repo#123`, `https://github.com/owner/repo/issues/123` (or `/pull/`)                                                                                             | `host` for GitHub Enterprise (`github.com` by default)                                                                             |
+| `gitlab`       | `#123`, `group/project#123`, `https://gitlab.com/group/project/-/issues/123`                                                                                                   | `host` for self-managed (`gitlab.com` by default)                                                                                  |
+| `linear`       | `RISK-123`, `https://linear.app/<workspace>/issue/RISK-123/...`                                                                                                                | `teams`                                                                                                                            |
+| `azure-devops` | `AB#123`, `#123`, `https://dev.azure.com/<org>/<project>/_workitems/edit/123`                                                                                                  | `host` for Azure DevOps Server (`dev.azure.com` and `*.visualstudio.com` by default)                                               |
+| `trello`       | card links, `https://trello.com/c/nqPiDKmw` with or without the `/9-title` after it                                                                                            |                                                                                                                                    |
+| `notion`       | Unique IDs such as `TASK-123`, `https://www.notion.so/TASK-123`, page links that end in the page ID (also `https://app.notion.com/p/...`), database links with `?p=<page ID>`  | `prefixes`; `host` for a custom domain (`notion.so`, `www.notion.so`, `app.notion.com` and `*.notion.site` by default)             |
+| `asana`        | task links, `https://app.asana.com/0/<project>/<task>` and the newer `https://app.asana.com/1/<workspace>/.../task/<task>`                                                     |                                                                                                                                    |
+| `clickup`      | `CU-86abc123`, `#86abc123`, custom IDs such as `DEV-123`, `https://app.clickup.com/t/86abc123` or `/t/<workspace>/DEV-123`, view links with `?p=<task>`                        | `prefixes` for custom IDs                                                                                                          |
+| `redmine`      | `#123`, `#123-4` and `#123#note-4` (a note), `##123`; with `host`, `https://<host>/issues/123` (also under a path)                                                             | `host`, needed for links                                                                                                           |
+| `monday`       | item links, `https://<account>.monday.com/boards/<board>/pulses/<item>`, and custom keys such as `TIX-001`                                                                     | `prefixes` for custom keys                                                                                                         |
+| `youtrack`     | `KT-123`, `https://<host>/issue/KT-123/...` or `/projects/KT/issues/KT-123` (also under a path, as in `/youtrack/issue/KT-123`)                                                | `projects`; `host` for Server or a custom domain (`youtrack.jetbrains.com`, `*.youtrack.cloud` and `*.myjetbrains.com` by default) |
+| `basecamp`     | to-do and card links, `https://3.basecamp.com/<account>/buckets/<project>/todos/<id>` or `/card_tables/cards/<id>`                                                             |                                                                                                                                    |
+| `shortcut`     | `sc-123`, `[sc-123]`, `https://app.shortcut.com/<workspace>/story/123/...`                                                                                                     |                                                                                                                                    |
+| `openproject`  | `#4821` and per-project IDs such as `AGILE-1`; with `host`, `https://<host>/projects/<identifier>/work_packages/AGILE-1` (also `/work_packages/4821` and the short `/wp/4821`) | `host`, needed for links                                                                                                           |
+| `bugzilla`     | bug numbers `4821`; with `host`, `https://<host>/show_bug.cgi?id=4821`, also under a path as in `/bugzilla/show_bug.cgi`                                                       | `host`, needed for links                                                                                                           |
+| `phabricator`  | task monograms `T4821`; with `host`, `https://<host>/T4821`. Phorge, Phabricator's maintained fork, shares the format                                                          | `host`, needed for links                                                                                                           |
+| `rally`        | formatted IDs `US4821`, `DE4821`, `TA4821`, `TC4821`, never zero-padded (so MITRE ATT&CK's `TA0006` isn't one)                                                                 |                                                                                                                                    |
+| `servicenow`   | record numbers `STRY0010001` for the prefixes you list, any digit count                                                                                                        | `prefixes`, required: record-number prefixes such as `STRY`                                                                        |
+| `plane`        | `WEB-142`; `https://app.plane.so/<workspace>/<project>/issues/WEB-142` (or a UUID), and the same on a `host` for self-hosted                                                   | `projects`; `host` for self-hosted (`app.plane.so` by default)                                                                     |
+| `url`          | links to the hosts you list, and nothing else                                                                                                                                  | `hosts`, required: host names such as `tasks.example.com`, with no scheme, port or path; `*.example.com` matches its subdomains    |
+| `numeric`      | `4821`                                                                                                                                                                         | `minLength` (1), `maxLength` (20)                                                                                                  |
+| `pattern`      | anything matching your regex, anchored at both ends                                                                                                                            | `pattern`, `flags`                                                                                                                 |
+
+`projects` (Jira, YouTrack, Plane), `teams` (Linear) and `prefixes` (Notion, ClickUp, monday.com,
+ServiceNow) are keys as they appear in tickets, in uppercase: `TRADE` for `TRADE-123`, `STRY` for
+`STRY0010001`. YouTrack project IDs may also start with a digit, as `4DM`. Without them, any key passes;
+ServiceNow's list is required. `host` is a host name such as `jira.example.com`, or `*.example.com` for
+every subdomain, as in `{ preset: 'jira', host: '*.atlassian.net' }`. Every preset that takes `host`
+requires a plain host name: a value with a scheme, port or path never matched a link, so it is an error.
+Each preset
 takes only its own options, so `host` on the `any` preset fails with a clear message instead of being
 ignored. A `pattern` always matches the whole ticket, so the `g` and `y` flags make no difference and are
 ignored.
 
 A preset rejects links that aren't one ticket in its tracker, such as a Trello board, an Asana project or
 a Notion database view. Redmine runs on your own server, and `/issues/123` is also GitHub's path, so its
-links pass only once `host` is set.
+links pass only once `host` is set. The same holds for OpenProject, Bugzilla and Phabricator, which also
+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
@@ -329,6 +341,34 @@ testGovernance.configure({
 The built-in presets are written to run in linear time. A `pattern` preset runs your regex as given,
 so keep it free of nested quantifiers.
 
+### Tickets from annotations
+
+A comment never reaches a test report. Playwright and Vitest can carry the ticket in data that does, so
+`annotations` accepts it from there as well:
+
+```js
+test.skip(
+  'rejects a margin order above the buying power',
+  {
+    annotation: { type: 'issue', description: 'TRADE-123' },
+  },
+  async () => {},
+);
+```
+
+```js
+// Vitest: the ticket is the `issue` key of `meta`.
+test.skip('rejects a margin order above the buying power', { meta: { issue: 'TRADE-123' } }, () => {});
+```
+
+The `type` names Playwright's annotation type and Vitest's `meta` key; `'issue'` by default, matched
+exactly. The value must be the ticket and nothing else, as in a marker. One valid annotation covers every
+state the test is in, and a describe's annotation covers its tests. An annotation of another type is
+left alone, and an annotation whose ticket isn't static text is reported with `reportUnreadableTags`.
+`annotations: false` turns it off. A marker comment still works everywhere, and when both are written,
+both must be valid. Jest, Mocha, Jasmine, node:test and Cypress have no annotations, so for them it is
+comments only.
+
 ### Which functions count as `test`
 
 In Playwright files:

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

@@ -21,7 +21,7 @@ export default createRule({
     create(context, analysis, options) {
         const { sourceCode } = context;
         for (const subject of analysis.subjects) {
-            const missing = missingStates(subject);
+            const missing = missingStates(subject, options);
             if (missing.length === 0)
                 continue;
             const stray = strayMarkers(subject, options);

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

@@ -31,7 +31,7 @@ export default createRule({
         }
         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).length > 0)
+            if (missingStates(subject, options).length > 0)
                 continue;
             const name = describeSubject(subject).replace(/^This/, 'this');
             for (const marker of strayMarkers(subject, options)) {

package/dist/rules/require-ticket.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../utils/create-rule.ts").Rule<"missingTicket" | "invalidTicket" | "placeholderTicket" | "extraText" | "removeExtraText" | "missingMarker" | "markerCase" | "dynamicTitle" | "dynamicTags">;
+declare const _default: import("../utils/create-rule.ts").Rule<"missingTicket" | "invalidTicket" | "placeholderTicket" | "extraText" | "removeExtraText" | "missingMarker" | "markerCase" | "dynamicTitle" | "dynamicTags" | "invalidAnnotation" | "unreadAnnotation">;
 export default _default;

package/dist/rules/require-ticket.js

@@ -1,4 +1,4 @@
-import { appliesTo, describeSubject, evaluate, headLoc } from "../utils/analyze.js";
+import { annotationTicketsOf, appliesTo, describeSubject, evaluate, hasAnnotationTicket, headLoc, unreadAnnotationsOf, } from "../utils/analyze.js";
 import { createRule } from "../utils/create-rule.js";
 export default createRule({
     meta: {
@@ -20,6 +20,8 @@ export default createRule({
             removeExtraText: 'Remove `{{text}}`.',
             dynamicTitle: "This title isn't static text, so its tags can't be checked. Use a string or template literal.",
             dynamicTags: "These tags can't be read in this file, so they can't be checked. Use strings, or constants declared in this file.",
+            invalidAnnotation: "'{{ticket}}' is not a valid ticket for the '{{state}}' state. Expected {{expected}}.",
+            unreadAnnotation: "This annotation's ticket isn't static text, so it can't be checked. Use a string, or a constant declared in this file.",
         },
     },
     create(context, analysis, options) {
@@ -28,16 +30,37 @@ export default createRule({
         const reported = new Set();
         const reportOnce = (key) => !reported.has(key) && Boolean(reported.add(key));
         for (const subject of analysis.subjects) {
+            const needsTicket = subject.states.some((s) => s.required);
             if (options.reportUnreadableTags && hasTagStates) {
                 if (subject.dynamicTitle)
                     context.report({ node: subject.node.arguments[0], messageId: 'dynamicTitle' });
                 for (const node of subject.unreadTags)
                     context.report({ node, messageId: 'dynamicTags' });
             }
+            // An annotation whose ticket can't be read may be the one that was supposed to cover the test.
+            if (options.reportUnreadableTags && needsTicket) {
+                for (const node of unreadAnnotationsOf(subject)) {
+                    if (reportOnce(`annotation-unread:${node.range[0]}`)) {
+                        context.report({ node, messageId: 'unreadAnnotation' });
+                    }
+                }
+            }
             for (const { state, required } of subject.states) {
                 if (!required)
                     continue;
                 const result = evaluate(subject, state);
+                // Annotations are checked whenever a ticket is needed, whatever the markers say.
+                for (const ticket of annotationTicketsOf(subject)) {
+                    if (state.ticket.check(ticket.text) !== 'ok' && reportOnce(`annotation:${ticket.node.range[0]}`)) {
+                        context.report({
+                            node: ticket.node,
+                            messageId: 'invalidAnnotation',
+                            data: { ticket: ticket.text, state: state.name, expected: state.ticket.expected },
+                        });
+                    }
+                }
+                if (result.kind === 'missing' && hasAnnotationTicket(subject, state, options))
+                    continue;
                 if (result.kind !== 'ok' &&
                     result.kind !== 'missing' &&
                     !reportOnce(`${result.marker.comment.range[0]}:${state.name}`)) {

package/dist/utils/analyze.d.ts

@@ -72,6 +72,13 @@ export interface Subject {
     skipped: boolean;
     ownSkip: boolean;
     markers: Marker[];
+    /** Tickets read from annotations of the configured type on this call, with the node to report at. */
+    annotationTickets: {
+        text: string;
+        node: Node;
+    }[];
+    /** Annotation values of the configured type on this call whose ticket can't be read. */
+    unreadTickets: Node[];
     dynamicTitle: boolean;
     /** For a runtime function such as Jasmine's `pending()`, its name; messages call the others by their state. */
     functionName?: string;
@@ -112,8 +119,20 @@ export declare function analyze(sourceCode: SourceCode, options: ResolvedOptions
 /** Whether `subject` is in `stateName` at all, required or not, including inherited and runtime states. */
 export declare function appliesTo(subject: Subject, stateName: string): boolean;
 export declare function evaluate(subject: Subject, state: StateDef): Evaluation;
-/** Required states on `subject` that have no marker at all (not even a broken one). */
-export declare function missingStates(subject: Subject): StateDef[];
+/** Annotation tickets that can cover `subject`: its own and those of enclosing describes and tests. */
+export declare function annotationTicketsOf(subject: Subject): {
+    text: string;
+    node: Node;
+}[];
+/** Annotation values whose ticket can't be read, `subject`'s own and those of enclosing describes and tests. */
+export declare function unreadAnnotationsOf(subject: Subject): Node[];
+/** Whether a valid annotation ticket covers `state` for `subject`. */
+export declare function hasAnnotationTicket(subject: Subject, state: StateDef, options: ResolvedOptions): boolean;
+/**
+ * Required states on `subject` that have no ticket at all: no marker, not even a broken one, and no
+ * valid annotation.
+ */
+export declare function missingStates(subject: Subject, options: ResolvedOptions): StateDef[];
 /**
  * Whether a marker reads as an ordinary comment rather than a ticket reference, such as
  * `// FIXME: this breaks on slow machines`: it starts with something that is not a ticket and goes on

package/dist/utils/analyze.js

@@ -312,6 +312,46 @@ function isLocalVariable(sourceCode, id) {
 }
 const STATEMENT_CONTAINERS = new Set(['Program', 'BlockStatement', 'StaticBlock', 'SwitchCase', 'TSModuleBlock']);
 /** The statement a call 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
+ * `it.skip.bind(null)('title', fn)` all declare the test that `it.skip('title', fn)` declares. A call that
+ * isn't read this way, such as an `apply` with a list this file can't see, comes back unchanged.
+ */
+function throughFunctionMethods(original) {
+    let call = original;
+    // `it.skip.bind(null).call(null, 'title', fn)` unwraps twice; two more steps cost nothing and end the loop.
+    for (let step = 0; step < 4; step += 1) {
+        const callee = unwrap(call.callee);
+        // `it.skip.call(null, ...)`: the first argument is the receiver the method is called on.
+        if (callee.type === 'MemberExpression' && memberName(callee) === 'call') {
+            call = { ...call, callee: callee.object, arguments: call.arguments.slice(1) };
+            continue;
+        }
+        // `it.skip.apply(null, ['title', fn])`: the arguments are the elements of an array written here.
+        if (callee.type === 'MemberExpression' && memberName(callee) === 'apply') {
+            const list = call.arguments.at(1);
+            const elements = list === undefined ? undefined : unwrap(list);
+            if (elements?.type !== 'ArrayExpression' ||
+                elements.elements.some((e) => e === null || e.type === 'SpreadElement')) {
+                return call;
+            }
+            call = { ...call, callee: callee.object, arguments: elements.elements.filter((e) => e !== null) };
+            continue;
+        }
+        // `it.skip.bind(null, 'title', fn)()` and `it.skip.bind(null)('title', fn)`: `bind` returns the test
+        // function with the arguments it was given already in place.
+        if (callee.type === 'CallExpression') {
+            const bind = unwrap(callee.callee);
+            if (bind.type !== 'MemberExpression' || memberName(bind) !== 'bind')
+                return call;
+            call = { ...call, callee: bind.object, arguments: [...callee.arguments.slice(1), ...call.arguments] };
+            continue;
+        }
+        return call;
+    }
+    return call;
+}
 function anchorOf(call) {
     let node = call;
     // A call always sits inside a statement container, so the walk stops before it runs out of parents.
@@ -592,7 +632,128 @@ function detailsOf(sourceCode, call, optionsFirst) {
     const unread = [];
     return { entries: objectDetails(sourceCode, object, unread), unread };
 }
-const NO_TAGS = { tags: [], dynamic: false, unread: [], opaqueDetails: false };
+/** The static text a value gives: a string literal, a template with no expressions, or one of those held in a constant declared in this file. */
+function staticText(sourceCode, node) {
+    const read = (value) => {
+        if (value.type === 'Literal')
+            return typeof value.value === 'string' ? value.value : undefined;
+        if (value.type !== 'TemplateLiteral' || value.expressions.length !== 0)
+            return undefined;
+        // `cooked` is only null in tagged templates, which no annotation value is.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
+        return value.quasis[0].value.cooked;
+    };
+    const target = unwrap(node);
+    const own = read(target);
+    if (own !== undefined)
+        return own;
+    const constant = constantValue(sourceCode, target);
+    return constant === undefined ? undefined : read(unwrap(constant));
+}
+/**
+ * The object or array a details value is, following a constant declared in this file: a carrier for
+ * annotations. Undefined for a value that plainly can't hold one, `'unread'` for one that can't be read.
+ */
+function annotationCarrier(sourceCode, node) {
+    const target = unwrap(node);
+    if (target.type === 'ObjectExpression' || target.type === 'ArrayExpression')
+        return target;
+    const constant = constantValue(sourceCode, target);
+    const resolved = constant === undefined ? undefined : unwrap(constant);
+    if (resolved?.type === 'ObjectExpression' || resolved?.type === 'ArrayExpression')
+        return resolved;
+    // A scalar that can be read holds no annotation; a value that can't be read might.
+    return target.type === 'Literal' || resolved !== undefined ? undefined : 'unread';
+}
+/**
+ * Tickets from annotations of the configured type in a declaration's details: Playwright's `annotation`
+ * option, whose value is one `{ type, description }` or an array of them, and Vitest's `meta` object,
+ * with the ticket under the key named by the type. Only literal text is read; a value of the right
+ * type whose ticket can't be read is returned as unread, since it may carry the ticket.
+ */
+function collectAnnotations(sourceCode, details, source, annotations) {
+    const tickets = [];
+    const unread = [];
+    const readPlaywright = (object) => {
+        const unreadKeys = [];
+        const entries = objectDetails(sourceCode, object, unreadKeys);
+        const type = entries.find(([key]) => key === 'type');
+        if (type === undefined)
+            return;
+        const written = staticText(sourceCode, type[1]);
+        if (written === undefined) {
+            // The type might be the configured one, so the whole annotation may carry the ticket.
+            unread.push(type[1], ...unreadKeys);
+            return;
+        }
+        if (written !== annotations.type)
+            return;
+        const description = entries.find(([key]) => key === 'description');
+        if (description === undefined) {
+            // A key that can't be read may be the description.
+            unread.push(...unreadKeys);
+            return;
+        }
+        const text = staticText(sourceCode, description[1]);
+        if (text === undefined) {
+            unread.push(...unreadKeys, description[1]);
+            return;
+        }
+        tickets.push({ text, node: description[1] });
+    };
+    const readValue = (value) => {
+        const carrier = annotationCarrier(sourceCode, value);
+        if (carrier === 'unread') {
+            unread.push(value);
+            return;
+        }
+        if (carrier === undefined)
+            return;
+        if (source.shape === 'meta') {
+            if (carrier.type === 'ObjectExpression') {
+                const unreadKeys = [];
+                const entries = objectDetails(sourceCode, carrier, unreadKeys);
+                const entry = entries.find(([key]) => key === annotations.type);
+                if (entry === undefined)
+                    unread.push(...unreadKeys);
+                else {
+                    const text = staticText(sourceCode, entry[1]);
+                    if (text !== undefined)
+                        tickets.push({ text, node: entry[1] });
+                    else
+                        unread.push(...unreadKeys, entry[1]);
+                }
+            }
+            return;
+        }
+        if (carrier.type === 'ObjectExpression')
+            readPlaywright(carrier);
+        else {
+            for (const element of carrier.elements) {
+                if (element === null || element.type === 'SpreadElement')
+                    continue;
+                const inner = annotationCarrier(sourceCode, element);
+                if (inner === 'unread')
+                    unread.push(element);
+                else if (inner?.type === 'ObjectExpression')
+                    readPlaywright(inner);
+            }
+        }
+    };
+    for (const [key, value] of details.entries) {
+        if (key === source.key)
+            readValue(value);
+    }
+    return { annotations: tickets, unreadAnnotations: unread };
+}
+const NO_TAGS = {
+    tags: [],
+    dynamic: false,
+    unread: [],
+    opaqueDetails: false,
+    annotations: [],
+    unreadAnnotations: [],
+};
 function collectTags(sourceCode, call, hasTitle, framework, details) {
     if (!hasTitle)
         return NO_TAGS;
@@ -617,7 +778,15 @@ function collectTags(sourceCode, call, hasTitle, framework, details) {
     const unread = [...values.unread];
     if (details.unread.length > 0 && framework.tagKey !== undefined)
         unread.push(...details.unread);
-    return { tags, dynamic: title.unread.size > 0, unread, opaqueDetails: details.unread.length > 0 };
+    // headOf replaces these with the annotations it reads, since collectTags has no options.
+    return {
+        tags,
+        dynamic: title.unread.size > 0,
+        unread,
+        opaqueDetails: details.unread.length > 0,
+        annotations: [],
+        unreadAnnotations: [],
+    };
 }
 /** Whether `node` is an object written out or held in a constant declared in this file. */
 function isObject(sourceCode, node) {
@@ -885,6 +1054,8 @@ function runAnalysis(sourceCode, options) {
             skipped: ownSkip || (kind !== 'runtime' && parent?.skipped === true),
             ownSkip,
             markers: block.flatMap((comment) => parseMarkers(comment, states)),
+            annotationTickets: tagInfo.annotations,
+            unreadTickets: tagInfo.unreadAnnotations,
             dynamicTitle: tagInfo.dynamic,
         };
         subjects.push(subject);
@@ -1019,12 +1190,18 @@ function runAnalysis(sourceCode, options) {
         const infos = yes.kind === 'test' ? bodyInfos(args, yes.members) : [];
         return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos };
     };
-    /** The details and tags of a declaration; node:test lets it leave out its title. */
+    /** The details, tags and annotations of a declaration; node:test lets it leave out its title. */
     const headOf = (call) => {
         const args = call.arguments;
         const untitled = leavesOutTitle(sourceCode, framework, args);
         const details = detailsOf(sourceCode, call, untitled && !isFunction(args[0]));
-        return { details, tagInfo: collectTags(sourceCode, call, !untitled, framework, details) };
+        const annotations = options.annotations === undefined || framework.annotations === undefined
+            ? { annotations: [], unreadAnnotations: [] }
+            : collectAnnotations(sourceCode, details, framework.annotations, options.annotations);
+        return {
+            details,
+            tagInfo: { ...collectTags(sourceCode, call, !untitled, framework, details), ...annotations },
+        };
     };
     const declare = (call, { kind, members, args: conditions }, infos) => {
         const args = call.arguments;
@@ -1047,7 +1224,8 @@ function runAnalysis(sourceCode, options) {
             ? declare(call, declaration, bodyInfos(call.arguments, []))
             : undefined;
     };
-    const visitCall = (call) => {
+    const visitCall = (original) => {
+        const call = throughFunctionMethods(original);
         const callee = target(chainOf(call.callee, framework.factories));
         if (callee === undefined)
             return subtestOf(call) ?? pickedDeclaration(call) ?? { subject: runtimeCall(call) };
@@ -1262,9 +1440,40 @@ export function evaluate(subject, state) {
     const bad = marker.tickets.find((t) => t.result !== 'ok');
     return bad ? { kind: 'bad-ticket', marker, ticket: bad } : { kind: 'no-ticket', marker };
 }
-/** Required states on `subject` that have no marker at all (not even a broken one). */
-export function missingStates(subject) {
-    return subject.states.filter((s) => s.required && evaluate(subject, s.state).kind === 'missing').map((s) => s.state);
+/** Annotation tickets that can cover `subject`: its own and those of enclosing describes and tests. */
+export function annotationTicketsOf(subject) {
+    const found = [...subject.annotationTickets];
+    let current = subject.parent;
+    while (current) {
+        found.push(...current.annotationTickets);
+        current = current.parent;
+    }
+    return found;
+}
+/** Annotation values whose ticket can't be read, `subject`'s own and those of enclosing describes and tests. */
+export function unreadAnnotationsOf(subject) {
+    const found = [...subject.unreadTickets];
+    let current = subject.parent;
+    while (current) {
+        found.push(...current.unreadTickets);
+        current = current.parent;
+    }
+    return found;
+}
+/** Whether a valid annotation ticket covers `state` for `subject`. */
+export function hasAnnotationTicket(subject, state, options) {
+    if (options.annotations === undefined)
+        return false;
+    return annotationTicketsOf(subject).some((ticket) => state.ticket.check(ticket.text) === 'ok');
+}
+/**
+ * Required states on `subject` that have no ticket at all: no marker, not even a broken one, and no
+ * valid annotation.
+ */
+export function missingStates(subject, options) {
+    return subject.states
+        .filter((s) => s.required && evaluate(subject, s.state).kind === 'missing' && !hasAnnotationTicket(subject, s.state, options))
+        .map((s) => s.state);
 }
 /**
  * Whether a marker reads as an ordinary comment rather than a ticket reference, such as

package/dist/utils/constants.d.ts

@@ -12,6 +12,6 @@ export type TagStateName = (typeof TAG_STATE_NAMES)[number];
 /** The test frameworks the rules understand. */
 export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest", "mocha", "cypress", "webdriverio", "node-test", "jasmine"];
 export type FrameworkName = (typeof FRAMEWORK_NAMES)[number];
-export declare const TICKET_PRESETS: readonly ["any", "jira", "github", "gitlab", "linear", "azure-devops", "trello", "notion", "asana", "clickup", "redmine", "monday", "youtrack", "basecamp", "shortcut", "url", "numeric", "pattern"];
+export declare const TICKET_PRESETS: readonly ["any", "jira", "github", "gitlab", "linear", "azure-devops", "trello", "notion", "asana", "clickup", "redmine", "monday", "youtrack", "basecamp", "shortcut", "openproject", "bugzilla", "phabricator", "rally", "servicenow", "plane", "url", "numeric", "pattern"];
 /** Comment keywords that must reference a ticket by default (`// TODO: TRADE-123`). */
 export declare const DEFAULT_COMMENT_KEYWORDS: string[];

package/dist/utils/constants.js

@@ -36,6 +36,12 @@ export const TICKET_PRESETS = [
     'youtrack',
     'basecamp',
     'shortcut',
+    'openproject',
+    'bugzilla',
+    'phabricator',
+    'rally',
+    'servicenow',
+    'plane',
     'url',
     'numeric',
     'pattern',

package/dist/utils/frameworks.d.ts

@@ -69,6 +69,15 @@ export interface Framework {
     tagKey?: string;
     /** Whether that key holds names without their `@`, as Vitest's `tags: ['flaky']`, which stand for `@flaky`. */
     plainTags: boolean;
+    /**
+     * How a ticket is read from an annotation: the details key it sits under and how the ticket is reached
+     * in its value, as Playwright's `annotation` or Vitest's `meta`. Unset for frameworks without
+     * annotations.
+     */
+    annotations?: {
+        key: string;
+        shape: 'annotation' | 'meta';
+    };
     /**
      * The parameter of a test's body that can change its state at runtime, such as Playwright's
      * `testInfo` or Vitest's test context, and the methods it has for that.

package/dist/utils/frameworks.js

@@ -43,6 +43,7 @@ const playwright = {
     optionalTitle: false,
     tagKey: 'tag',
     plainTags: false,
+    annotations: { key: 'annotation', shape: 'annotation' },
     info: { param: 1, methods: RUNTIME_MODIFIERS },
     subtests: false,
     skipWithoutBody: false,
@@ -130,6 +131,7 @@ const vitest = {
     optionalTitle: false,
     tagKey: 'tags',
     plainTags: true,
+    annotations: { key: 'meta', shape: 'meta' },
     info: { param: 0, methods: new Set(['skip']) },
     subtests: false,
     skipWithoutBody: true,

package/dist/utils/options.d.ts

@@ -61,6 +61,16 @@ export interface GovernanceOptions {
     comments?: false | {
         keywords?: string[];
     };
+    /**
+     * Accept the ticket from a test annotation as well: Playwright's `annotation` of the given type or
+     * Vitest's `meta` key of that name, as in
+     * `test.skip('title', { annotation: { type: 'issue', description: 'TRADE-123' } }, fn)`. One valid
+     * annotation covers every state the test is in, and a describe's covers its tests. Defaults to
+     * `{ type: 'issue' }`; `false` turns it off. Comments stay the form that works everywhere.
+     */
+    annotations?: false | {
+        type?: string;
+    };
     /** Allow free text after the tickets, e.g. `// SKIP: TRADE-1 flaky on CI`. Off by default: details belong in the ticket. */
     allowNotes?: boolean;
     /**
@@ -94,6 +104,13 @@ export interface ResolvedOptions {
     allowBlankLine: boolean;
     allowNotes: boolean;
     reportUnreadableTags: boolean;
+    /**
+     * How annotation tickets are accepted, for frameworks that have annotations: the type Playwright's
+     * `annotation` must have and the Vitest `meta` key that holds the ticket.
+     */
+    annotations?: {
+        type: string;
+    };
     /** Keywords checked by `require-ticket-in-comments`; empty when `comments: false`. */
     commentKeywords: string[];
     /**

package/dist/utils/options.js

@@ -55,15 +55,33 @@ const PRESET_OPTIONS = {
     youtrack: ['projects', 'host'],
     basecamp: [],
     shortcut: [],
+    openproject: ['host'],
+    bugzilla: ['host'],
+    phabricator: ['host'],
+    rally: [],
+    servicenow: ['prefixes'],
+    plane: ['projects', 'host'],
     url: ['hosts'],
     numeric: ['minLength', 'maxLength'],
     pattern: ['pattern', 'flags'],
 };
 /**
- * Presets whose `host` must be a plain host name. The older presets still take any string, since
- * rejecting one now would break configs whose short forms, such as `#123`, already work.
+ * Every preset that takes `host` requires a plain host name: a value with a scheme, port or path can never
+ * match a URL hostname, so before 0.11.0 it silently rejected every link.
  */
-const STRICT_HOST_PRESETS = new Set(['notion', 'redmine', 'youtrack']);
+const STRICT_HOST_PRESETS = new Set([
+    'jira',
+    'github',
+    'gitlab',
+    'azure-devops',
+    'notion',
+    'redmine',
+    'youtrack',
+    'openproject',
+    'bugzilla',
+    'phabricator',
+    'plane',
+]);
 /** Option values the schema allows for every preset but this one can't use. */
 function ownOptionProblems(spec, at) {
     const problems = [];
@@ -81,6 +99,9 @@ function ownOptionProblems(spec, at) {
     if (spec.preset === 'url' && spec.hosts === undefined) {
         problems.push(`${at}.hosts is required by the "url" preset: the hosts its links may point to`);
     }
+    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`);
+    }
     return problems;
 }
 /** A spec the cross-field checks can read: an object whose `preset` names one of the presets. */
@@ -193,6 +214,7 @@ export function compileOptions(options) {
         allowBlankLine: options.allowBlankLine ?? false,
         allowNotes: options.allowNotes ?? false,
         reportUnreadableTags: options.reportUnreadableTags ?? false,
+        annotations: options.annotations === false ? undefined : { type: options.annotations?.type ?? 'issue' },
         commentKeywords,
         workCommentKeywords: new Set([...DEFAULT_COMMENT_KEYWORDS, ...commentKeywords]),
         commentTicket: defaultMatcher,

package/dist/utils/schema.js

@@ -108,6 +108,12 @@ export const optionsSchema = {
                 },
             ],
         },
+        annotations: {
+            anyOf: [
+                { type: 'boolean', enum: [false] },
+                { type: 'object', properties: { type: { type: 'string' } }, additionalProperties: false },
+            ],
+        },
         requireTicketForConditional: { type: 'boolean' },
         allowBlankLine: { type: 'boolean' },
         allowNotes: { type: 'boolean' },

package/dist/utils/tickets.d.ts

@@ -41,6 +41,24 @@ export type TicketSpec = {
     preset: 'basecamp';
 } | {
     preset: 'shortcut';
+} | {
+    preset: 'openproject';
+    host?: string;
+} | {
+    preset: 'bugzilla';
+    host?: string;
+} | {
+    preset: 'phabricator';
+    host?: string;
+} | {
+    preset: 'rally';
+} | {
+    preset: 'servicenow';
+    prefixes: string[];
+} | {
+    preset: 'plane';
+    projects?: string[];
+    host?: string;
 } | {
     preset: 'url';
     hosts: string[];

package/dist/utils/tickets.js

@@ -36,6 +36,22 @@ 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+)(?:\/[^/]*)?$/;
+// 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+)(?:\/.*)?\/?$/;
+const OPENPROJECT_SHORT_RE = /^\/(?:work_packages|wp)\/(\d+)(?:\/.*)?\/?$/;
+// Bugzilla runs under any path, as `/bugzilla/show_bug.cgi`; the bug is in the `id` query value.
+const BUGZILLA_CGI_RE = /\/show_bug\.cgi\/?$/;
+// Phabricator tasks: the `T4821` monogram, and the `/T4821` path its instances use.
+const PHABRICATOR_REF_RE = /^T(\d+)$/;
+const PHABRICATOR_PATH_RE = /^\/T(\d+)\/?$/;
+// Rally's Formatted IDs: a user story, defect, task or test case.
+// 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*)$/;
+// 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
 // Notion page ID of zeros) makes the ticket a placeholder. A ticket no preset reads is a placeholder
 // when it ends in a zero ID, as PROJ-0, #0, AB#0 or .../issues/0 do.
@@ -340,6 +356,101 @@ function compilePreset(spec) {
                 expected: 'a Shortcut story like sc-123, or a story link',
                 example: 'sc-123',
             };
+        case 'openproject': {
+            const { host } = spec;
+            return {
+                find: (t) => {
+                    if (ISSUE_NUMBER_RE.test(t) || KEY_RE.test(t))
+                        return numberOf(t);
+                    const url = parseUrl(t);
+                    if (!url || host === undefined || !hostMatches(url, host))
+                        return undefined;
+                    return OPENPROJECT_PATH_RE.exec(url.pathname)?.[1] ?? OPENPROJECT_SHORT_RE.exec(url.pathname)?.[1];
+                },
+                expected: host === undefined
+                    ? 'an OpenProject work package like #4821 or AGILE-1 (set host to accept work package links)'
+                    : `an OpenProject work package like #4821 or AGILE-1, or a work package URL on ${host}`,
+                example: '#4821',
+            };
+        }
+        case 'bugzilla': {
+            const { host } = spec;
+            return {
+                find: (t) => {
+                    if (DIGITS_RE.test(t))
+                        return t;
+                    const url = parseUrl(t);
+                    if (!url || host === undefined || !hostMatches(url, host))
+                        return undefined;
+                    if (!BUGZILLA_CGI_RE.test(url.pathname))
+                        return undefined;
+                    const id = url.searchParams.get('id');
+                    return id !== null && DIGITS_RE.test(id) ? id : undefined;
+                },
+                expected: host === undefined
+                    ? 'a Bugzilla bug number like 4821 (set host to accept bug links)'
+                    : `a Bugzilla bug number like 4821, or a bug URL on ${host}`,
+                example: '4821',
+            };
+        }
+        case 'phabricator': {
+            const { host } = spec;
+            return {
+                find: (t) => {
+                    const ref = PHABRICATOR_REF_RE.exec(t)?.[1];
+                    if (ref !== undefined)
+                        return ref;
+                    const url = parseUrl(t);
+                    return url && host !== undefined && hostMatches(url, host)
+                        ? PHABRICATOR_PATH_RE.exec(url.pathname)?.[1]
+                        : undefined;
+                },
+                expected: host === undefined
+                    ? 'a Phabricator task like T4821 (set host to accept task links)'
+                    : `a Phabricator task like T4821, or a task URL on ${host}`,
+                example: 'T4821',
+            };
+        }
+        case 'rally':
+            return {
+                find: (t) => RALLY_REF_RE.exec(t)?.[1],
+                expected: 'a Rally formatted ID like US4821, DE4821, TA4821 or TC4821, without a leading zero',
+                example: 'US4821',
+            };
+        case 'servicenow': {
+            // The schema checks `prefixes` when options come from settings; direct use of compileTicketSpec checks it here.
+            const prefixes = spec.prefixes;
+            if (prefixes === undefined ||
+                prefixes.length === 0 ||
+                !prefixes.every((prefix) => /^[A-Z][A-Z0-9_]+$/.test(prefix))) {
+                throw new ConfigError('the "servicenow" ticket preset needs a `prefixes` array of uppercase record-number prefixes, such as ["STRY"].');
+            }
+            const re = new RegExp(`^(?:${prefixes.join('|')})(\\d+)$`);
+            return {
+                find: (t) => re.exec(t)?.[1],
+                expected: `a ServiceNow record number like ${prefixes[0]}0010001${describeList('with prefix', prefixes)}`,
+                example: `${prefixes[0]}0010001`,
+            };
+        }
+        case 'plane': {
+            const { projects, host } = spec;
+            const hosts = host === undefined ? ['app.plane.so'] : [host];
+            const keyOk = (key) => KEY_RE.test(key) && keyInList(key, projects);
+            return {
+                find: (t) => {
+                    if (KEY_RE.test(t))
+                        return keyId(t, keyOk);
+                    const url = parseUrl(t);
+                    if (!url || !hostInList(url, hosts))
+                        return undefined;
+                    const found = PLANE_PATH_RE.exec(url.pathname)?.[1];
+                    // A key link honors `projects` too; a UUID link stands on its own.
+                    return found === undefined ? undefined : KEY_RE.test(found) ? keyId(found, keyOk) : found;
+                },
+                expected: `a Plane work item like ${projects?.[0] ?? 'WEB'}-142${describeList('in project', projects)}, or a Plane work item link${host === undefined ? '' : ` on ${host}`}`,
+                example: `${projects?.[0] ?? 'WEB'}-142`,
+            };
+        }
         case 'url': {
             const { hosts } = spec;
             return {

package/docs/rules/require-ticket.md

@@ -333,5 +333,6 @@ change what it reports:
 - `requireTicketForConditional`: conditional skips need a ticket too.
 - `allowBlankLine`: blank lines may separate a marker from its test.
 - `allowNotes`: text may follow the tickets.
+- `annotations`: the ticket may also come from a Playwright annotation of the configured type or Vitest's `meta` key of that name.
 - `reportUnreadableTags`: report titles and tags that can't be read (see [Titles and tags that can't be read](#titles-and-tags-that-cant-be-read)).
 - `framework` and `testFunctions`: which functions count as the framework's `test`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO, node:test and Jasmine tests.",
   "keywords": [
     "eslint",
@@ -52,7 +52,7 @@
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json",
     "test": "node --test \"tests/**/*.test.ts\"",
-    "test:coverage": "node --test --experimental-test-coverage --test-coverage-include=\"src/**\" --test-coverage-branches=100 --test-coverage-functions=100 --test-coverage-lines=100 \"tests/**/*.test.ts\"",
+    "test:coverage": "node scripts/coverage.mjs",
     "test:pack": "node scripts/pack-smoke.mjs",
     "docs": "npm run build && eslint-doc-generator",
     "docs:check": "npm run build && eslint-doc-generator --check",