jobcompat 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c7ba60ac1a983ea795999572de4a8e670986f6b8ed6d5a05433f21a81ca8d03
-  data.tar.gz: ba82835508ec2d1e056eeb71a94ec51af5cf5696aa53046b6912c50281640221
+  metadata.gz: 47c2a0eafb9ae4ced87a7e13389e1ebd043a281d5b711f79bf668179592fea33
+  data.tar.gz: a2447a5027360b6bf7843c6c7766b6b8af1977a1e8308700d298e956b428d87e
 SHA512:
-  metadata.gz: bc94f38e9c059633c5701bc11982298f0d4786b8b58ff11494b0233a6de9f8f5a11e7e3e05ddae563a16773094be3ff410eff881e319cd3b1d8d8a0b336518a1
-  data.tar.gz: bb16e4959a69dde9a1aac0fbaff894aa3291009d538927a83a721d7a64bfee67ef804a978d5044ed7c4f7ed8fda66aa09b4a7a8caccf2da1bb1b25a44a5c89c3
+  metadata.gz: f6d44307647aed53748ca8b429ecf7469bb79fac73644a9f559a4b7c89c97bb6c52d60da03edd604b787e4959366e775579fa7a140341f1153902eefda90f528
+  data.tar.gz: e338de388c16b907edcd05377460bbb741bc268033821a952e0e1ce65e49cc46bbe45348ca30414e65faddb3d9c7d179e15c5538c92373a07ae76e294c787f31

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.2.1 - 2026-10-04
+
+Canonical worker-name consistency:
+
+- Accept canonical Unicode worker names, such as names with combining marks and qualified `Admin::ÁJob`, in targeted `.jobcompat.yml` suppressions. Matching stays exact and is not Unicode-normalized.
+- Share one Prism-based canonical worker-name validator between Client String producer analysis and Config.
+- Report malformed, non-constant, or invalid-byte `ignore[].worker` names as normal config errors (exit 2). Names that are not Ruby constants, such as `管理::輸出`, were previously accepted but could never match a finding.
+
+## 0.2.0 - 2026-10-02
+
+Broader native Sidekiq producer coverage:
+
+- Recognize `perform_bulk`, Setter `perform_in` / `perform_at` / `perform_bulk`, and `Sidekiq::Client.push` / `push_bulk`.
+- Normalize mixed bulk arities into distinct producer facts while retaining unknown rows.
+- Emit JSON schema version 2 with producer uncertainty reasons for bulk and Client payloads.
+- Resolve Client Hash splats and dynamic keys per key in source order, preserving known workers when only `"args"` is uncertain and preventing false JC005 when a later entry may replace `"class"`.
+- Validate Client class Strings with Prism's Ruby constant syntax, preserving Unicode identities and reporting malformed or invalid-byte names as JC007.
+
 ## 0.1.0 - 2026-09-26
 
 - Extract positional `perform` contracts from native `Sidekiq::Job` and `Sidekiq::Worker` classes, including reopened classes.

data/README.md

@@ -27,7 +27,7 @@ Sidekiq persists a worker `class` and an `args` array. The worker receives those
 
 ## Installation
 
-Ruby 3.3 or newer is required. After release, install with `gem install jobcompat`, or add `gem "jobcompat", require: false` to your Gemfile, run `bundle install`, and use `bundle exec jobcompat`. `prism` is the only runtime dependency; jobcompat does not require the Sidekiq gem to inspect source.
+Ruby 3.3 or newer is required. Install with `gem install jobcompat`, or add `gem "jobcompat", require: false` to your Gemfile, run `bundle install`, and use `bundle exec jobcompat`. `prism` is the only runtime dependency; jobcompat does not require the Sidekiq gem to inspect source.
 
 ## Quick Start
 
@@ -54,11 +54,11 @@ ERROR JC001 ExportJob
   Risk: Jobs queued by the base revision may fail after deployment.
 ```
 
-The second direction appears only when HEAD also has a one-argument producer. Output includes source locations, suggested migration steps, resolved commit SHAs, and a summary. JSON output uses `schema_version: 1` and includes per-worker compatibility matrices.
+The second direction appears only when HEAD also has a one-argument producer. Output includes source locations, suggested migration steps, resolved commit SHAs, and a summary. JSON output uses `schema_version: 2` and includes per-worker compatibility matrices.
 
 ## How it works
 
-jobcompat reads committed Ruby blobs through Git, parses each selected file with Prism, groups reopened class fragments by canonical name, discovers direct Sidekiq includes and enqueue calls, then compares positional-arity intervals. Application code is never loaded or executed.
+jobcompat reads committed Ruby blobs through Git, parses each selected file with Prism, groups reopened class fragments by canonical name, normalizes supported Sidekiq producer syntax into worker/arity facts, then compares positional-arity intervals. Application code is never loaded or executed.
 
 Its separate `DefinedConstantIndex` checks tracked Ruby class declarations and named bindings before declaring a worker class absent. A class that remains in an excluded file or stops using a direct Sidekiq include produces a warning rather than a removal error.
 
@@ -111,7 +111,7 @@ ignore:
     reason: "Enqueue starts after deployment completes"
 ```
 
-Each configured `include` or `exclude` list **replaces** its default list, so copy the defaults you still want. `--config PATH` selects another YAML file; a relative path is resolved from the invocation directory. Unknown keys and unsafe YAML aliases fail with exit 2. An ignore entry must have an exact rule, canonical worker name, and non-blank reason. Matched suppressions appear in text and JSON audit output.
+Each configured `include` or `exclude` list **replaces** its default list, so copy the defaults you still want. `--config PATH` selects another YAML file; a relative path is resolved from the invocation directory. Unknown keys and unsafe YAML aliases fail with exit 2. An ignore entry must have an exact rule, canonical worker name, and non-blank reason. `ignore[].worker` uses the same canonical Ruby constant-name rules as exact Client String worker targets, including valid Unicode identifiers; matching is exact and not Unicode-normalized. Matched suppressions appear in text and JSON audit output.
 
 ## CI usage
 
@@ -119,13 +119,30 @@ Run `jobcompat check --base origin/main --format json` after fetching the compar
 
 ## Supported Sidekiq patterns
 
-Direct `include Sidekiq::Job` and legacy `include Sidekiq::Worker` are recognized in top-level and supported namespaced classes. Reopened fragments may split the include and `perform` across files. The producer forms are `Job.perform_async(...)`, `Job.perform_in(schedule, ...)`, `Job.perform_at(time, ...)`, and `Job.set(...).perform_async(...)`. Hash and Array expressions each count as one payload argument. A splat or forwarded producer argument makes arity unknown.
+Direct `include Sidekiq::Job` and legacy `include Sidekiq::Worker` are recognized in top-level and supported namespaced classes. Reopened fragments may split the include and `perform` across files. Supported producer APIs are:
 
-Positional `perform` parameters may be required, optional, rest, post-rest, or forwarding. Keyword parameters make the worker contract unknown for v0.1.
+- `Job.perform_async(...)`, `Job.perform_in(schedule, ...)`, `Job.perform_at(time, ...)`, and `Job.perform_bulk(...)`;
+- `Job.set(...).perform_async(...)`, `.perform_in(...)`, `.perform_at(...)`, and `.perform_bulk(...)`;
+- `Sidekiq::Client.push(...)` and `Sidekiq::Client.push_bulk(...)` with a static Hash payload using string `"class"` and `"args"` keys.
 
-## Limitations and v0.1 non-goals
+Client Hash entries are resolved per key in source order. A later explicit `"class"` or `"args"` overrides earlier writes; a later unknown Hash splat or dynamic key makes only the keys it may replace uncertain. Static unrelated keys do not affect certainty. A statically known worker is preserved when only args may be replaced; an uncertain class is not attributed to an earlier worker and cannot produce JC005 for it.
 
-v0.1 checks **positional arity only**. It does not check value types, Hash internals, keyword compatibility, or JSON serialization. It supports native Sidekiq, not ActiveJob. Only direct includes and the documented direct producer calls are analyzed. `Sidekiq::Client.push`, bulk APIs, wrappers, aliases, inheritance, concerns, arbitrary metaprogramming, feature flags, and general Ruby class/module or superclass conflict analysis are outside scope.
+Hash and Array expressions each count as one ordinary payload argument. Bulk calls produce one fact per distinct statically known inner Array arity:
+
+```ruby
+ExportJob.perform_bulk([
+  [1],
+  [2, "csv"]
+])
+```
+
+jobcompat sees payload arities 1 and 2. A dynamic bulk row is retained as `dynamic_bulk_arguments` uncertainty without discarding known rows from the same callsite. A Client class String is an exact canonical Ruby constant name; it is never resolved relative to the surrounding Ruby namespace or Unicode-normalized. Malformed names produce JC007 warnings.
+
+Positional `perform` parameters may be required, optional, rest, post-rest, or forwarding. Keyword parameters make the worker contract unknown in v0.2.
+
+## Limitations and v0.2 non-goals
+
+v0.2 checks **positional arity only**. It does not check value types, Hash internals, keyword compatibility, or JSON serialization. It supports native Sidekiq, not ActiveJob. Dynamic bulk collections are warning/unknown, Client payload variables are not followed, and custom wrappers are not analyzed. ActiveJob, arbitrary Client instances, Hash internal schemas, aliases, inheritance, concerns, arbitrary metaprogramming, feature flags, and general Ruby class/module or superclass conflict analysis remain outside scope.
 
 No repository producer callsite does **not** prove an empty queue: queued, scheduled, retried, historical, and external jobs may exist. JC004 requires a completed static absence proof across tracked `.rb` source. An excluded or unrecognized declaration warns. JC005 is a structural rolling-deploy error conditional on an old Sidekiq process being able to consume the new job's queue. Queue isolation and feature flags are not analyzed. Dynamic source may warn or be missed. Working-tree edits are ignored.
 
@@ -150,11 +167,11 @@ Analysis reads local Git objects only. It does not connect to Redis, boot Rails,
 
 ## Roadmap
 
-Possible future work includes additional native Sidekiq producer APIs and SARIF output. Other frameworks would be considered only after v0.1 usage evidence; they are not supported now.
+Possible future work includes SARIF output and additional evidence sources. Other frameworks are not supported now.
 
 ## Contributing
 
-Run `bundle exec rake test` and `gem build jobcompat.gemspec` with Ruby 3.3 or newer. Tests create temporary Git repositories and need no Redis or Sidekiq server. See [the normative v0.1 spec](docs/spec-v0.1.md) before changing rule behavior.
+Run `bundle exec rake test` and `gem build jobcompat.gemspec` with Ruby 3.3 or newer. Tests create temporary Git repositories and need no Redis or Sidekiq server. The [v0.1 specification](docs/spec-v0.1.md) remains the baseline; [the normative v0.2 delta](docs/spec-v0.2.md) defines the added producer coverage, and [the v0.2.1 delta](docs/spec-v0.2.1.md) defines shared canonical worker-name validation.
 
 ## License
 

data/docs/architecture.md

@@ -1,7 +1,7 @@
-# jobcompat v0.1 architecture
+# jobcompat v0.2 architecture
 
-Status: implementation design for `0.1.0`
-Date: 2026-09-23
+Status: implemented design for `0.2.0`
+Date: 2026-09-28
 
 ## 1. Architecture principles
 
@@ -9,7 +9,7 @@ Date: 2026-09-23
 2. **No application execution:** parse source; never require, boot, or evaluate it.
 3. **Extraction before semantics:** AST visitors produce facts; a pure engine compares facts.
 4. **Conservative unknowns:** unsupported evidence is explicit and cannot become a pass.
-5. **Small v0.1 surface:** one framework adapter, one parser, one command, two formatters.
+5. **Small native Sidekiq surface:** one framework adapter, one parser, one command, two formatters.
 6. **Determinism:** stable sorting and fully resolved commit SHAs are part of correctness.
 7. **No speculative framework abstraction:** namespaces organize current responsibilities; no generic plugin API ships in v0.1.
 
@@ -187,10 +187,12 @@ It receives source bytes and a revision/path context. It does not open files, in
 
 `WorkerDiscoveryVisitor` owns class/module namespace tracking, direct Sidekiq includes, and direct `perform` definitions.
 
-`ProducerDiscoveryVisitor` owns calls named `perform_async`, `perform_in`, and `perform_at`, supported `.set` chains, syntactic payload counts, lexical namespace capture, and unknown call facts.
+`ProducerDiscoveryVisitor` owns supported worker calls (`perform_async`, `perform_in`, `perform_at`, `perform_bulk`), supported `.set` chains, and exact static `Sidekiq::Client.push` / `push_bulk` calls. Syntax-specific extraction produces normalized producer facts before the compatibility engine. Bulk Array literals become one fact per distinct known inner arity plus at most the required unknown evidence; empty bulk Arrays produce no facts. Client class constants use lexical resolution, while static class Strings use exact canonical resolution. Client Hash entries are ordered evidence: for `"class"` and `"args"` independently, a shared right-to-left scan stops at the first entry capable of writing the key. An explicit string key proves its value; an unknown Hash splat or dynamic/non-static key prevents that proof; static unrelated keys are skipped. Known class evidence remains usable when only args are uncertain, while uncertain class evidence carries no worker attribution into the engine.
 
 `ConstantName` is a small utility that flattens only `ConstantReadNode` and `ConstantPathNode`. It returns a value object with `segments`, `root_qualified`, and `static`; it does not resolve Ruby constants.
 
+Client String targets use the internal `CanonicalWorkerName` validator shared by `push`, `push_bulk`, and `.jobcompat.yml` `ignore[].worker` validation (since v0.2.1). After safe UTF-8 conversion and encoding validation, Prism parses the value in isolation. Only a single `ConstantReadNode` or static `ConstantPathNode` chain is accepted. Root-qualified Strings are rejected, and the extracted canonical name must equal the complete original text, excluding whitespace, comments, and extra syntax. This preserves Ruby's Unicode identifiers without normalization or lexical prefixing. Expected encoding failures and invalid syntax become `unsupported_client_payload`; unexpected parser failures remain tool failures. No source is executed.
+
 `DefinedConstantIndex` records exact or plausible canonical class/module declarations and statically named constant bindings, source locations, and normal-scan membership. It is distinct from supported Sidekiq worker recognition. For a name missing from one revision's recognized workers, it returns `recognized_worker`, `defined_unrecognized`, `outside_scan_scope`, `absent`, or `unverified` using the formal proof in the spec. A present-but-unrecognized class or incomplete presence pass blocks JC004/JC005 ERROR.
 
 `SemanticEvidence` builds the revision-free JC007 fingerprint from uncertainty kind/reason, canonical worker when known, sorted relative paths, syntactic enclosing scope, trivia-free relevant token stream and enclosing statement, plus deterministic group size and occurrence ordinal. It retains every revision-tagged root location. Same-fingerprint roots pair one-to-one across snapshots; distinct roots remain separate.
@@ -212,7 +214,7 @@ The engine MUST be pure with respect to filesystem, Git, environment, clock, and
 Formatters receive a completed or failed result envelope. They MUST NOT recalculate compatibility or suppression. They render already matched suppression audit records without reconstructing omitted findings.
 
 - `Formatter::Text` renders concise human remediation.
-- `Formatter::Json` constructs schema-version-1 primitive Hash/Array data, including each finding's `revisions`, `directions`, and `unknown_reason` and each worker's base/head presence status, calls `JSON.pretty_generate`, and appends exactly one newline. The formal specification fixes two-space pretty JSON; exact-output tests lock it.
+- `Formatter::Json` constructs schema-version-2 primitive Hash/Array data, preserving the v1 shape while extending producer `unknown_reason` values. It includes each finding's `revisions`, `directions`, and `unknown_reason` and each worker's base/head presence status, calls `JSON.pretty_generate`, and appends exactly one newline.
 
 Both consume already sorted results.
 
@@ -317,6 +319,8 @@ Presence-only blobs reuse this parser with a narrower visitor. A candidate-beari
 | keywords | `ParametersNode#keywords/#keyword_rest` | unsupported status, except forwarding node |
 | forwarding | `ForwardingParameterNode` | unbounded positional acceptance |
 | enqueue call | `CallNode#name/#receiver/#arguments/#block` | method, receiver fact, argument nodes, location |
+| bulk rows | `ArrayNode#elements`, `SplatNode` | distinct known inner arities and dynamic-row evidence |
+| Client payload | `HashNode` / `KeywordHashNode`, `AssocNode`, `AssocSplatNode` | exact string keys, worker target mode, args shape, dynamic payload evidence |
 | safe navigation | `CallNode#call_operator_loc` whose source slice is `&.` | unknown receiver evidence |
 | call arguments | `ArgumentsNode#arguments` | syntactic count |
 | splat | `SplatNode` | unknown producer arity |
@@ -354,12 +358,13 @@ UnresolvedEnqueueCall
   lexical_namespace   Array<String>
   payload_arity       Integer | nil
   arity_known         true | false
-  method              perform_async | perform_in | perform_at
+  method              perform_async | perform_in | perform_at | perform_bulk | push | push_bulk
+  resolution_mode     lexical_constant | client_constant | exact_string
   location
 unknown_reason      Symbol | nil
 ```
 
-The symbol values map one-to-one to the schema-v1 strings enumerated in `docs/spec-v0.1.md`; visitors do not invent free-form reason text.
+The reason values map one-to-one to the frozen baseline strings in `docs/spec-v0.1.md` plus the schema-v2 producer additions in `docs/spec-v0.2.md`; visitors do not invent free-form reason text.
 
 Only after both revisions' worker names are known does the engine resolve these facts. This avoids ordering dependence between files and enables head calls to removed base workers.
 
@@ -410,7 +415,7 @@ The JSON formatter serializes both classes as a contract object with `status: kn
 worker_name    : String | nil
 payload_arity  : Integer | nil
 arity_known    : Boolean
-method         : :perform_async | :perform_in | :perform_at
+method         : :perform_async | :perform_in | :perform_at | :perform_bulk | :push | :push_bulk
 location       : SourceLocation
 unknown_reason : Symbol | nil
 ```
@@ -565,7 +570,7 @@ The v0.1 security posture is a product characteristic:
 
 Threat boundary: the repository and config may be untrusted input. Prism and Git process those bytes, but jobcompat never evaluates Ruby. JSON/text escaping MUST prevent control characters in paths/excerpts from corrupting output framing. Text formatter should escape non-printable path characters; JSON handles them through the JSON encoder.
 
-## 14. Future extension points without v0.1 over-engineering
+## 14. Future extension points without over-engineering
 
 The following seams are sufficient:
 
@@ -578,10 +583,10 @@ The following seams are sufficient:
 
 Potential roadmap order:
 
-1. more native Sidekiq producer forms (`Client.push`, bulk) after precision research;
+1. more native Sidekiq producer forms only after precision research;
 2. SARIF/GitHub integration;
 3. optional changed-path performance hints without weakening whole-snapshot facts;
 4. ActiveJob as a separately specified adapter;
 5. other ecosystems only after defining their serialization/deployment contracts.
 
-Do not add an adapter registry, dependency injection container, generic AST facade, or rule plugin system in v0.1.
+Do not add an adapter registry, dependency injection container, generic AST facade, or rule plugin system without a concrete second implementation.

data/docs/implementation-plan-v0.2.1.md

@@ -0,0 +1,17 @@
+# jobcompat v0.2.1 implementation plan
+
+Status: implemented
+
+## Delivery sequence
+
+1. Extract the Prism-based Client String worker-name check into the internal `Jobcompat::CanonicalWorkerName.parse` (`lib/jobcompat/canonical_worker_name.rb`), which requires `prism` itself and depends on neither Analyzer nor Config.
+2. Migrate `Analyzer#client_worker` to the shared validator, keeping `exact_string` and `unsupported_client_payload` behavior unchanged.
+3. Migrate `Config.validate` `ignore[].worker` to the shared validator, removing the handwritten regex grammar and keeping the existing `ignore[N].worker is invalid` config error.
+4. Add a focused validator unit matrix (accepted names, rejected syntax, invalid bytes, no normalization, standalone loading) and a producer/Config agreement check; extend Config unit tests for Unicode acceptance, invalid bytes, duplicates, and exact matching.
+5. Add temporary-Git integration coverage for decomposed Unicode JC003 suppression with JSON and text audit, precomposed/decomposed exact-match guards, qualified Unicode names, non-canonical and invalid-byte config errors, and byte determinism.
+6. Raise the gem version to 0.2.1 (JSON schema 2 and config version 1 unchanged) and synchronize README, CHANGELOG, architecture, and the normative delta.
+7. Run the full suite on the supported Ruby matrix with Prism 1.9.0, syntax checks, gem build/contents/isolated install, CLI exit-code smoke scenarios, and diff self-review.
+
+## Scope boundaries
+
+No rule, finding field, uncertainty reason, config key, dependency, or release operation is added. Constant AST resolution, `DefinedConstantIndex`, the engine, formatter, and Git access are unchanged.

data/docs/implementation-plan-v0.2.md

@@ -0,0 +1,29 @@
+# jobcompat v0.2 implementation plan
+
+Status: implemented
+
+## Delivery sequence
+
+1. Reconfirm the public Sidekiq Job/Setter and Client producer shapes from upstream source and documentation.
+2. Extend syntax extraction while keeping the existing `Call` fact and compatibility engine semantics.
+3. Share one pure bulk-arity extractor across worker, Setter, and Client bulk calls.
+4. Add exact-string versus lexical-constant Client target resolution and explicit v2 uncertainty reasons.
+5. Raise the gem version to 0.2.0 and JSON schema to 2 while leaving config version 1.
+6. Add unit coverage for AST shapes, deduplication, mixed known/unknown rows, options, false positives, and 1,000-row fact bounds.
+7. Add temporary-Git integration coverage for JC001, JC002, JC003, JC005, JC006 witness behavior, JC007, schema v2, and byte determinism.
+8. Synchronize README, architecture, changelog, and this normative delta specification.
+9. Run the full suite, syntax checks, gem build/contents/install, CLI and exit-code smoke scenarios, and diff review.
+
+## Scope boundaries
+
+The compatibility rules and their precedence are not changed. No Sidekiq dependency, dataflow, source execution, Client instance inference, wrapper inference, ActiveJob support, keyword compatibility, payload type/schema analysis, or release operation is added.
+
+## Verification inventory
+
+- Existing v0.1 suite remains green.
+- Bulk extraction covers known, duplicate, zero-argument, empty, dynamic, mixed, splat, option, namespace, root-qualified, safe-navigation, and large-literal cases.
+- Setter scheduled calls exclude their schedule argument.
+- Client tests cover exact receivers, constant and String classes, empty and multi-argument payloads, options, dynamic/missing shapes, per-key final-write certainty for splats and dynamic keys, duplicate explicit keys, mixed splat/dynamic ordering, parentheses, and non-Sidekiq receivers. BASE/HEAD guards prove unknown class evidence cannot create JC005, while known class / unknown args still can, for both `push` and `push_bulk`.
+- Client String validation reuses Prism's constant syntax and the existing constant extractor. Tests cover decomposed Unicode and qualified names, exact namespace matching, distinct precomposed/decomposed identities, non-canonical complete inputs, valid source encodings, and invalid bytes that warn without crashing. Both Client APIs exercise Unicode JC001/JC002/JC003/JC005 and deterministic Unicode/unsupported output.
+- Integration tests prove new producer facts flow through JC001–JC007 without a new rule.
+- Repeated text and JSON outputs are byte-identical.

data/docs/release-checklist-v0.1.0.md

@@ -1,6 +1,6 @@
 # jobcompat v0.1.0 release checklist
 
-This checklist is for the future gem release. The public repository is `https://github.com/cottondesu/jobcompat`; initial publication of `main` is authorized, but tagging, publishing a gem, and creating a GitHub Release are reserved for the release phase. Gem version `0.1.0` uses tag `v0.1.0`; JSON `schema_version: 1` is a separate contract.
+This checklist records preparation for the published v0.1.0 gem release. The public repository is `https://github.com/cottondesu/jobcompat`; gem version `0.1.0` uses tag `v0.1.0`; JSON `schema_version: 1` is a separate contract. Unchecked items remain external follow-ups and are not assertions that their gates were completed.
 
 ## Local, machine executable checks
 
@@ -13,7 +13,7 @@ This checklist is for the future gem release. The public repository is `https://
 - [x] Repeat the secret and personal path scan; review README, CHANGELOG, LICENSE, release notes, and workflow against the built gem.
 - [x] Verify every GitHub Action reference is a pinned commit SHA and inspect the diff before the initial commit.
 
-## Manual gates before publication
+## Pre-publication manual gates
 
 - [x] Create the public [`cottondesu/jobcompat`](https://github.com/cottondesu/jobcompat) repository with default branch `main`.
 - [x] Set the real repository URL in gemspec `homepage`, `source_code_uri`, `changelog_uri`, and `bug_tracker_uri`.
@@ -21,12 +21,12 @@ This checklist is for the future gem release. The public repository is `https://
 - [ ] Configure a `main` ruleset or branch protection that blocks force pushes and deletion and requires successful CI; avoid unnecessary review gates for a single maintainer.
 - [ ] Confirm GitHub two factor authentication and RubyGems MFA.
 - [ ] Protect the GitHub `release` environment with appropriate approval or deployment restrictions.
-- [ ] Confirm Ruby 3.3, 3.4, and 4.0 GitHub CI jobs all pass on the exact release candidate. Ruby 3.3 CI is mandatory because the local runtime has not been tested.
+- [ ] Confirm Ruby 3.3, 3.4, and 4.0 GitHub CI jobs all pass on the exact release candidate. Ruby 3.3 CI was mandatory because Ruby 3.3 was not tested locally during release preparation.
 - [ ] Configure a RubyGems [Pending Trusted Publisher](https://guides.rubygems.org/trusted-publishing/) for the new `jobcompat` gem using GitHub owner `cottondesu`, repository `jobcompat`, workflow file `release.yml`, and environment `release`. Confirm the details match the release workflow. Do not store a long lived RubyGems API key in GitHub Secrets.
 - [ ] Recheck that `jobcompat` is still unregistered on RubyGems immediately before the actual gem publication.
 - [ ] Review the tag triggered release workflow and built gem one final time before pushing `v0.1.0`.
 
-## Exact publication sequence (future manual actions)
+## Historical publication sequence
 
 1. Recheck gem name before every public push and again immediately before gem publication.
 2. Rerun local tests, build, install, smoke checks, package review, and secret scan. Resolve every build warning.

data/docs/release-checklist-v0.2.0.md

@@ -0,0 +1,61 @@
+# jobcompat v0.2.0 release checklist
+
+This is preparation for an update to the already published `jobcompat` gem. Checked boxes record completed preparation checks; unchecked boxes are final release or post-publication gates, not claims of completion. No v0.2.0 tag or publication is authorized by this document.
+
+## Release identity
+
+- Repository: `cottondesu/jobcompat`, branch `main`.
+- Gem version: `0.2.0`; intended annotated tag: `v0.2.0`.
+- Intended release date: `2026-10-02`. If execution is delayed, reconcile the CHANGELOG date with the actual intended date before tagging; never backdate publication.
+- JSON schema: `2`; `.jobcompat.yml` configuration schema: `1`.
+- Implementation commit: `c107c9a9868cf3d29f4b821444fe1e0cfcb86820`.
+- Release candidate commit: to be determined after the `Prepare v0.2.0 release` commit. Record its exact SHA and CI run in the final release execution record; do not select a moving `main` ref without verification.
+
+## Automated validation
+
+- [x] Implementation commit passed [CI run 36875203650](https://github.com/cottondesu/jobcompat/actions/runs/36875203650): Ruby 3.3, 3.4, and 4.0 PASS; each ran 122 tests / 902 assertions and built the Gem.
+- [x] Candidate local `bundle exec rake test` on Ruby 3.4.11 / Prism 1.9.0: 122 tests, 902 assertions, zero failures, errors, and skips.
+- [x] Candidate `git diff --check` and release-only diff review pass; product bytes match the implementation commit.
+- [x] Build the candidate Gem and inspect its 24 entries, including both v0.2.0 release documents. No local tooling state, credentials, caches, scratch files, or nested Gems are included.
+- [x] Install the candidate Gem into a fresh isolated destination; version/help, clean 0, compatibility error 1, warning-only 0, invalid ref 2, and config version 1 pass.
+- [ ] Record the pushed release-preparation SHA and its CI run; require Ruby 3.3, 3.4, and 4.0 success on that exact SHA before tagging. The implementation run above does not substitute for candidate CI.
+
+## Publication prerequisites
+
+- [x] On 2026-10-02, public RubyGems listed `0.1.0` and no `0.2.0`; public owner handle was `cottondesu`, and metadata pointed to this repository.
+- [x] On 2026-10-02, local/remote tags and GitHub Releases contained `v0.1.0` and no `v0.2.0`.
+- [x] GitHub environment `release` exists, requires reviewer `cottondesu`, and permits tag pattern `v*`.
+- [ ] Confirm the current RubyGems Trusted Publisher for `jobcompat` in the maintainer UI: owner `cottondesu`, repository `jobcompat`, workflow file `release.yml`, environment `release`. Public package metadata and earlier publication are not proof of the current publisher settings. See [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/).
+- [x] Release workflow retains tag/version and public metadata gates. Gem homepage, source, changelog, and issue URLs refer to `cottondesu/jobcompat`.
+- [x] Review the v0.2.0 release notes against the normative scope and inspect the built candidate package.
+- [ ] Immediately before release execution, recheck that `0.2.0` is absent on RubyGems and `v0.2.0` is absent locally, remotely, and in GitHub Releases. Stop if any already exists; never overwrite it.
+
+## Tag gate
+
+**Pushing `v0.2.0` triggers the Release workflow and may publish the Gem automatically. Treat tag push as a publication action.**
+
+- [ ] Complete every pre-tag validation and publication prerequisite above, including the manual Trusted Publisher check and exact candidate CI.
+- [ ] Obtain separate final release execution approval. Release preparation alone does not authorize tagging or publication.
+- [ ] Confirm the exact release candidate SHA, product version, intended release date, and unchanged v0.1.0 release identity.
+- [ ] Under that separate approval, create an annotated `v0.2.0` tag on the verified SHA and push only that tag. Do not force or push unrelated tags.
+
+## Release workflow verification
+
+The unchanged `.github/workflows/release.yml` triggers on pushes matching `v*`. Its Ruby 3.3 / 3.4 / 4.0 tests precede the `publish` job through `needs: test`. Publication uses Ruby 4.0, environment `release`, GitHub OIDC `id-token: write`, pinned `rubygems/configure-rubygems-credentials`, and `gem push`.
+
+- [ ] Verify the triggered Release run refers to the approved tag and exact candidate SHA.
+- [ ] Confirm all three test jobs pass and the publication environment approval is satisfied.
+- [ ] Confirm `GITHUB_REF_NAME == "v#{Jobcompat::VERSION}"`, public metadata checks, publication-job tests, build, credentials setup, and push all succeed.
+- [ ] Confirm RubyGems lists `jobcompat` version `0.2.0`; do not infer publication solely from a tag or a partial workflow result.
+
+## After publication
+
+- [ ] Check RubyGems version, ownership, Ruby/dependency requirements, public URLs, and package contents.
+- [ ] Install `jobcompat` 0.2.0 from RubyGems in a clean environment; verify version/help and representative CLI checks.
+- [ ] Under the separate release approval, create or verify the GitHub Release for `v0.2.0` using the reviewed release notes and correct tag.
+- [ ] Record the release workflow URL and publication evidence; monitor issue/security reports.
+- [ ] Track the pre-existing Unicode suppression validator limitation as a possible v0.2.1 follow-up; do not alter v0.2.0 bytes after publication.
+
+## Rollback
+
+Do not overwrite or reuse version `0.2.0` after publication, move the published tag, or alter v0.1.0. Fix forward in `0.2.1`. If necessary, use the official [RubyGems yanking procedure](https://guides.rubygems.org/removing-a-published-gem/) and communicate the affected version; yanking does not remove installed copies.

data/docs/release-checklist-v0.2.1.md

@@ -0,0 +1,76 @@
+# jobcompat v0.2.1 release checklist
+
+This is preparation for a maintenance update to the already published `jobcompat` gem. Checked boxes record completed preparation checks; unchecked boxes are final release or post-publication gates, not claims of completion. No v0.2.1 tag or publication is authorized by this document.
+
+## Release identity
+
+- Repository: `cottondesu/jobcompat`, branch `main`.
+- Gem version: `0.2.1`; intended annotated tag: `v0.2.1`.
+- Intended release date: `2026-10-04`. If execution is delayed, reconcile the CHANGELOG date with the actual intended date before tagging; never backdate publication.
+- JSON schema: `2`; `.jobcompat.yml` configuration schema: `1`.
+- Implementation commit: `fd6d138f229228be8801de9a7ae040cab21c9923` (`Fix Unicode worker suppression validation`), on top of the v0.2.0 release commit `378203731bcc0e4a06a1a3550fbd5605d9760f2e`.
+- Implementation history note: the implementation was first pushed as `0397dc5b7b8eb4acaa975d8d3b628aa4f87aed8a`. At the maintainer's request, before any tag or publication, it was replaced once on `main` by `fd6d138` to correct the commit author and committer and remove a co-author trailer. Both commits have the identical tree `18602325cc75951aee1d078c92c4c7813443f570`, so the reviewed product bytes are unchanged. `0397dc5` is no longer on `main` and must not be tagged.
+- Release candidate commit: to be determined after the `Prepare v0.2.1 release` commit. Record its exact SHA and CI run in the final release execution record; do not select a moving `main` ref without verification.
+
+## Reviewed implementation
+
+- [x] Fresh independent review of the complete v0.2.1 diff: verdict SHIP, no BLOCKER, no MAJOR.
+- [x] Independent validation: 140 tests, 1298 assertions, 0 failures, 0 errors, 0 skips with Prism 1.9.0 under a UTF-8 locale, on Ruby 3.3.6 (reviewer environment), Ruby 3.4.8 (conda-forge build), and Ruby 4.0.6 (conda-forge build). Official GitHub CI below is the release authority.
+- [x] Reviewer MINOR, test-only: under a POSIX / US-ASCII locale, the Unicode suppression text assertion in `test/integration/check_command_test.rb` raises `Encoding::CompatibilityError` in the test itself. Production output is byte-identical between UTF-8 and POSIX locales; no production locale regression was observed. Non-release-blocking; deferred past v0.2.1 and intentionally left unchanged in this release. Canonical local validation uses a UTF-8 locale.
+
+## Automated validation
+
+- [x] Implementation commit `fd6d138` passed [CI run 36992116824](https://github.com/cottondesu/jobcompat/actions/runs/36992116824): Ruby 3.3.12, 3.4.10, and 4.0.6 PASS; each ran 140 tests / 1298 assertions with 0 failures, errors, and skips and built `jobcompat-0.2.1.gem`. (Superseded commit `0397dc5` had passed [CI run 36990271965](https://github.com/cottondesu/jobcompat/actions/runs/36990271965) with the same tree.)
+- [x] Candidate local `LANG=C.UTF-8 bundle exec rake test` on Ruby 3.3.6 / Prism 1.9.0: 140 tests, 1298 assertions, zero failures, errors, and skips.
+- [x] Candidate `git diff --check` and release-only diff review pass; only `CHANGELOG.md` and the two v0.2.1 release documents change, and product bytes match the implementation commit.
+- [x] Build the candidate Gem and inspect its entries, including `lib/jobcompat/canonical_worker_name.rb`, the v0.2.1 spec and implementation plan, and both v0.2.1 release documents. No local tooling state, credentials, caches, scratch files, patches, review files, or nested Gems are included.
+- [x] Install the candidate Gem into a fresh isolated destination under a UTF-8 locale; `jobcompat --version` reports `jobcompat 0.2.1`; clean 0, compatibility error 1, warning-only 0, invalid config 2, invalid ref 2, and Unicode suppression 0 pass.
+- [x] Release-note examples checked with the installed candidate and Prism 1.9.0: a `ÁJob` (`A` + `U+0301` + `Job`) suppression is valid, `管理::輸出` is a `config_error` with exit 2, and `Job管理::E輸出` is valid.
+- [ ] Record the pushed release-preparation SHA and its CI run; require Ruby 3.3, 3.4, and 4.0 success, including the Gem build step, on that exact SHA before tagging. The implementation run above does not substitute for candidate CI.
+
+## Compatibility note
+
+- [x] The v0.2.1 release notes state prominently that v0.2.0 could silently accept `ignore[].worker` names that are not Ruby constant names, that such entries could never match a finding under the canonical worker-name semantics, and that v0.2.1 rejects them as `config_error` with exit 2.
+- [x] The note explains why `管理::輸出` is rejected (not a Ruby constant path) and shows that CJK constant paths such as `Job管理::E輸出` remain accepted.
+- [x] The v0.2.0 limitation about combining-mark suppressions is not repeated, because v0.2.1 fixes it.
+
+## Publication prerequisites
+
+- [x] On 2026-10-02, public RubyGems listed `0.1.0` and `0.2.0` and no `0.2.1`.
+- [x] On 2026-10-02, local and remote tags were `v0.1.0` and `v0.2.0` only, and GitHub Releases contained `v0.1.0` and `v0.2.0` and no `v0.2.1`.
+- [ ] Confirm GitHub environment `release` still exists, requires reviewer `cottondesu`, and permits tag pattern `v*`. The preparation tooling could not read environment settings, so this is a manual gate. Do not weaken these protections.
+- [ ] Confirm the current RubyGems Trusted Publisher for `jobcompat` in the maintainer UI: owner `cottondesu`, repository `jobcompat`, workflow file `release.yml`, environment `release`. Public package metadata and earlier publications are not proof of the current publisher settings. Do not introduce a long-lived RubyGems API key. See [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/).
+- [x] Release workflow retains the tag/version and public metadata gates. Gem homepage, source, changelog, and issue URLs refer to `cottondesu/jobcompat`.
+- [x] Review the v0.2.1 release notes against the normative scope and inspect the built candidate package.
+- [x] On 2026-10-04, current-state recheck: public RubyGems listed `0.2.0` and `0.1.0` and no `0.2.1` (versions API 404); remote tags were `v0.1.0` and `v0.2.0` only, with no local `v0.2.1` tag; GitHub Releases were `v0.2.0` and `v0.1.0`. Repeat this check immediately before release execution.
+- [ ] Immediately before release execution, recheck that `0.2.1` is absent on RubyGems and `v0.2.1` is absent locally, remotely, and in GitHub Releases. Stop if any already exists; never overwrite it.
+
+## Tag gate
+
+**Pushing `v0.2.1` triggers the Release workflow and may publish the Gem automatically. Treat tag push as a publication action.**
+
+- [ ] Complete every pre-tag validation and publication prerequisite above, including the manual environment and Trusted Publisher checks and exact candidate CI.
+- [ ] Obtain separate final release execution approval. Release preparation alone does not authorize tagging or publication.
+- [ ] Confirm the exact release candidate SHA, product version, intended release date, and unchanged v0.1.0 and v0.2.0 release identities.
+- [ ] Under that separate approval, create an annotated `v0.2.1` tag on the verified SHA and push only that tag. Do not force or push unrelated tags.
+
+## Release workflow verification
+
+The unchanged `.github/workflows/release.yml` triggers on pushes matching `v*`. Its Ruby 3.3 / 3.4 / 4.0 tests precede the `publish` job through `needs: test`. Publication uses Ruby 4.0, environment `release`, GitHub OIDC `id-token: write`, the tag/version and public metadata checks, pinned `rubygems/configure-rubygems-credentials`, and `gem push`.
+
+- [ ] Verify the triggered Release run refers to the approved tag and exact candidate SHA.
+- [ ] Confirm all three test jobs pass and the publication environment approval is satisfied.
+- [ ] Confirm `GITHUB_REF_NAME == "v#{Jobcompat::VERSION}"`, public metadata checks, publication-job tests, build, credentials setup, and push all succeed.
+- [ ] Confirm RubyGems lists `jobcompat` version `0.2.1`; do not infer publication solely from a tag or a partial workflow result.
+
+## After publication
+
+- [ ] Check RubyGems version, ownership, Ruby/dependency requirements, public URLs, and package contents.
+- [ ] Install `jobcompat` 0.2.1 from RubyGems in a clean environment; verify version/help and representative CLI checks.
+- [ ] Under the separate release approval, create or verify the GitHub Release for `v0.2.1` using the reviewed release notes and correct tag.
+- [ ] Record the release workflow URL and publication evidence; monitor issue/security reports.
+- [ ] Track the deferred test-only POSIX locale MINOR as a follow-up after v0.2.1; do not alter v0.2.1 bytes after publication.
+
+## Rollback
+
+Do not overwrite or reuse version `0.2.1` after publication, move the published tag, or alter v0.1.0 or v0.2.0. Fix forward in a later patch version. If necessary, use the official [RubyGems yanking procedure](https://guides.rubygems.org/removing-a-published-gem/) and communicate the affected version; yanking does not remove installed copies.

data/docs/release-notes-v0.2.0.md

@@ -0,0 +1,71 @@
+# jobcompat v0.2.0 release notes
+
+jobcompat v0.2.0 broadens native Sidekiq producer coverage while preserving JC001–JC007, the three rolling-deployment directions, and positional-arity analysis.
+
+## Highlights
+
+- Recognize worker bulk calls, scheduled and bulk Setter calls, and direct static Sidekiq Client payloads.
+- Normalize bulk jobs into distinct arity facts without losing known rows when other rows are unknown.
+- Resolve Client Hash evidence independently for `"class"` and `"args"` in source order.
+- Validate exact String worker names with Prism's Ruby constant syntax, preserving Unicode spelling and handling malformed names conservatively.
+- Emit JSON schema version 2; `.jobcompat.yml` remains version 1.
+
+## New producer coverage
+
+The following forms join the existing `perform_async`, `perform_in`, `perform_at`, and `set(...).perform_async` support:
+
+- `Worker.perform_bulk(...)`;
+- `Worker.set(...).perform_in(...)` and `.perform_at(...)`;
+- `Worker.set(...).perform_bulk(...)`;
+- `Sidekiq::Client.push(...)` and `.push_bulk(...)`.
+
+Setter options and the first schedule argument of `perform_in` / `perform_at` do not count as job payload arguments.
+
+## Bulk behavior
+
+```ruby
+ExportJob.perform_bulk([
+  [1],
+  [2, "csv"]
+])
+```
+
+This supplies distinct positional arity facts for 1 and 2. Duplicate arities are collapsed, and an empty bulk Array supplies no producer evidence. Dynamic rows or inner splats remain conservative JC007 evidence without discarding known sibling rows. A dynamic outer collection remains unknown. Bulk calls use the existing compatibility rules; findings still carry one integer or null `payload_arity`.
+
+## Sidekiq::Client support
+
+Direct `Sidekiq::Client.push` and `push_bulk` calls accept statically understandable Hash payloads with string `"class"` and `"args"` keys. `push` counts a static args Array; `push_bulk` applies the same bulk normalization as worker calls.
+
+For each relevant key, the last entry capable of writing it determines certainty. Later explicit keys can restore certainty after earlier splats or dynamic keys. Later unknown writes prevent proof of the affected key. A known worker with unknown args can still supply JC005 presence evidence and worker-attributed JC007; an uncertain class is not attributed to an earlier worker.
+
+Class constants use the existing bounded lexical, qualified, and root-qualified resolution. Class Strings are exact canonical Ruby constant paths accepted by Prism, without leading `::`, namespace prefixing, or Unicode normalization. Malformed syntax and invalid String bytes become unsupported JC007 evidence. Payload variables, general Hash evaluation, Client instances, and wrappers are not inferred. See the [normative v0.2 scope](spec-v0.2.md) for supported options and uncertainty reasons.
+
+## JSON schema 2
+
+v0.1 emitted `schema_version: 1`; v0.2 emits `schema_version: 2`. Schema 2 extends producer uncertainty reasons for bulk and Client APIs while preserving the existing output structure, findings, directions, revisions, and locations.
+
+The added reasons are `dynamic_bulk_arguments`, `dynamic_bulk_options`, `dynamic_client_payload`, `dynamic_client_class`, `dynamic_client_args`, and `unsupported_client_payload`.
+
+The `.jobcompat.yml` configuration schema is separate and remains `version: 1`. Do not change it to version 2.
+
+## Compatibility
+
+JC001–JC007 meanings, severity, JC001/JC003 precedence, static-presence proof, and the base-to-head, head-to-base, and head-to-head directions are unchanged. Exit codes remain 0 for no unsuppressed errors, 1 for compatibility errors, and 2 for tool/config/Git/parser/usage failures. Warnings do not establish compatibility for unknown evidence.
+
+## Known limitations
+
+ActiveJob, keyword compatibility, payload value types, Hash internal schemas, live Redis inspection, wrappers, aliases, general dataflow, and runtime metaprogramming remain outside scope. An undiscovered producer does not prove that a queue is empty. Analysis does not execute application code.
+
+The existing suppression worker-name validator is stricter than producer discovery for some Unicode combining-mark identifiers. Such workers can be analyzed correctly but rejected in `.jobcompat.yml` ignore entries. This pre-existing limitation is a v0.2.1 follow-up candidate; it does not affect general Unicode producer recognition.
+
+## Upgrade notes
+
+Update JSON consumers to accept schema version 2 and the additional producer uncertainty reasons. Keep configuration version 1. Broader producer discovery may surface compatibility errors or JC007 warnings that v0.1 did not report; review those findings before deployment.
+
+Ruby 3.3 or newer and Prism `>= 1.9, < 2` remain required. No Sidekiq runtime dependency is added.
+
+## Installation
+
+After publication, install this version with `gem install jobcompat --version 0.2.0`. Bundler users can specify `gem "jobcompat", "~> 0.2.0", require: false`.
+
+Fetch the intended comparison ref, then run `jobcompat check --base origin/main` or `bundle exec jobcompat check --base origin/main` in the application repository.

data/docs/release-notes-v0.2.1.md

@@ -0,0 +1,61 @@
+# jobcompat v0.2.1 release notes
+
+jobcompat v0.2.1 is a maintenance release. It makes `.jobcompat.yml` suppressions accept exactly the canonical worker names that producer analysis can report, so a worker that jobcompat can find is also a worker you can suppress. It adds no producer API, compatibility rule, or configuration key.
+
+## Highlights
+
+- `ignore[].worker` accepts canonical Unicode worker names, including names with combining marks such as `ÁJob` and qualified names such as `Admin::ÁJob`.
+- Client String worker targets and `ignore[].worker` now use one shared Prism-based canonical worker-name check, so the two can no longer disagree.
+- Worker names keep their exact codepoints. jobcompat performs no Unicode normalization.
+- Malformed, non-constant, and invalid-byte `ignore[].worker` values are reported as configuration errors (exit 2).
+
+## Unicode suppression consistency
+
+In v0.2.0, producer analysis could report a finding for a worker whose name contains a combining mark, but `.jobcompat.yml` rejected a suppression for that same name with `ignore[0].worker is invalid`. v0.2.1 fixes this. For example, with a worker named `A` + `U+0301 COMBINING ACUTE ACCENT` + `Job` (displayed as `ÁJob`):
+
+```yaml
+version: 1
+
+ignore:
+  - rule: JC003
+    worker: ÁJob
+    reason: intentional migration
+```
+
+suppresses the matching JC003 finding, exits 0, and keeps the usual suppression audit record (rule, exact worker, reason, finding count) in text and JSON output.
+
+Matching remains exact. jobcompat applies no NFC, NFD, NFKC, or NFKD normalization and no case folding. `ÁJob` written as the single codepoint `U+00C1` followed by `Job` and `ÁJob` written as `A` + `U+0301` + `Job` look the same but are different worker identities: a suppression for one does not suppress a finding for the other. Write the suppression with the same codepoints as the worker name in your source.
+
+## Configuration compatibility note
+
+**An existing v0.2.0 configuration can now fail with exit 2.**
+
+v0.2.0's configuration validator accepted some `ignore[].worker` strings that Ruby does not treat as constant names. Producer analysis can never report such a name, so those entries could never match a jobcompat finding and were silent no-op suppressions. v0.2.1 rejects them as configuration errors (`ignore[N].worker is invalid`, JSON `status: "failed"`, exit 2) instead of ignoring them.
+
+For example, `管理::輸出` is rejected because neither segment starts with an uppercase letter, so Ruby parses it as method calls rather than a constant path. This does not mean CJK worker names are unsupported: `Job管理::E輸出` is a valid Ruby constant path and remains accepted, and analysis and suppression treat it like any other worker name.
+
+## Contracts unchanged
+
+- JC001–JC007 meanings, severities, and precedence are unchanged.
+- JSON output remains `schema_version: 2`.
+- `.jobcompat.yml` remains `version: 1`.
+- Exit codes are unchanged: 0 for no unsuppressed compatibility errors, 1 for compatibility errors, and 2 for tool, config, Git, parser, or usage failures.
+- Ruby `>= 3.3` and Prism `>= 1.9, < 2` remain required.
+
+No JSON or configuration schema migration is required.
+
+## Known limitations
+
+ActiveJob, keyword compatibility, payload value types, Hash internal schemas, live Redis inspection, wrappers, aliases, general dataflow, and runtime metaprogramming remain outside scope. An undiscovered producer does not prove that a queue is empty. Analysis does not execute application code. See the [normative v0.2.1 delta](spec-v0.2.1.md) for the full canonical worker-name rules.
+
+## Upgrade notes
+
+If your `ignore[].worker` entries are ordinary Ruby constant names, such as `ExportJob` or `Admin::ExportJob`, no configuration change is needed.
+
+If an `ignore[].worker` entry is a string that is not a canonical Ruby constant name, v0.2.1 reports a configuration error and exits 2. That entry never suppressed anything in v0.2.0. Remove it, or correct it to the exact worker name that jobcompat reports in its findings.
+
+## Installation
+
+After publication, install this version with `gem install jobcompat --version 0.2.1`. Bundler users can specify `gem "jobcompat", "~> 0.2.1", require: false`.
+
+Fetch the intended comparison ref, then run `jobcompat check --base origin/main` or `bundle exec jobcompat check --base origin/main` in the application repository.

data/docs/spec-v0.2.1.md

@@ -0,0 +1,65 @@
+# jobcompat v0.2.1 normative delta specification
+
+Status: normative for `0.2.1`
+
+This document is a small delta from [`spec-v0.2.md`](spec-v0.2.md), which remains the normative `0.2.0` delta from [`spec-v0.1.md`](spec-v0.1.md). **All v0.1 and v0.2 rules remain normative unless explicitly overridden here.** v0.2.1 is a maintenance release: it adds no producer syntax, rule, finding field, uncertainty reason, or configuration key.
+
+## 1. Versioned contracts
+
+- Gem and CLI version: `0.2.1`.
+- JSON `schema_version`: `2` (unchanged).
+- `.jobcompat.yml` version: `1` (unchanged; `version: 2` remains a config error).
+
+No user migration is required.
+
+## 2. Canonical worker-name validation
+
+A canonical String worker name is a String that:
+
+1. converts safely to valid UTF-8;
+2. parses with the supported Prism (`>= 1.9, < 2`) without diagnostics;
+3. contains exactly one expression;
+4. is a static `ConstantReadNode` or `ConstantPathNode` chain, not root-qualified with a leading `::`;
+5. when flattened and joined with `::`, equals the complete String exactly.
+
+Prism is the only grammar authority; jobcompat defines no handwritten identifier, case, combining-mark, or Unicode-range rules. Input is never trimmed. Whitespace, comments, newlines, parentheses, calls, operators, extra statements, `self::`, and any other syntax make the String non-canonical.
+
+One internal validator applies this definition to both Client class Strings (`Sidekiq::Client.push` / `push_bulk`) and `.jobcompat.yml` `ignore[].worker`.
+
+**Invariant:** any worker name accepted as an exact canonical String worker name by producer analysis MUST also be valid as `.jobcompat.yml` `ignore[].worker`, subject to the same canonical textual identity rules. Conversely, a configured worker name that producer analysis could not accept as a canonical String is invalid configuration.
+
+Constant AST resolution (for example `"class" => ExportJob`, `ExportJob.perform_async`, and worker declarations) is unchanged and is not governed by this section.
+
+## 3. Suppression semantics
+
+Matching remains exact on `rule_id` plus the worker String. There is no Unicode normalization (no NFC, NFD, NFKC, or NFKD), case folding, namespace inference, partial, glob, or regex matching. Configured names are stored and reported exactly as written.
+
+Visually similar but codepoint-distinct valid names remain different worker identities. For example, `ÁJob` written as `U+00C1 J o b` and as `U+0041 U+0301 J o b` are distinct: a suppression for one does not suppress a finding for the other, and the two entries are not duplicates of each other. Two entries with the same rule and exactly the same worker String remain a duplicate-entry config error.
+
+A qualified name such as `Admin::ÁJob` suppresses only the finding whose worker is exactly that qualified name; `ÁJob` alone does not match it.
+
+A matched suppression keeps the existing audit record (`rule_id`, exact `worker`, `reason`, `finding_count`) in JSON and text output, and a suppressed compatibility ERROR no longer contributes to exit 1.
+
+## 4. Invalid worker-name behavior
+
+The shared validator only decides validity. Each caller owns its failure surface:
+
+- **Config:** a non-canonical, non-String, or invalid-encoding `ignore[].worker` is a `config_error` with the existing message `ignore[N].worker is invalid`, JSON `status: "failed"`, and exit 2. A document whose bytes Psych rejects before validation is also a `config_error` with exit 2. No raw `ArgumentError` or `EncodingError`, `internal_error`, or stack trace is produced.
+- **Producer analysis:** a non-canonical or invalid-encoding Client class String remains `unsupported_client_payload` JC007 evidence, as in v0.2.0.
+
+Inside the validator only expected encoding failures are treated as unsupported input; unexpected parser or implementation failures stay visible as tool failures.
+
+Compatibility note: v0.2.0 also accepted some configured names that Ruby does not parse as constants, such as `管理::輸出` (segments that do not start with an uppercase letter). No finding could ever carry such a worker name, so those entries never suppressed anything; v0.2.1 reports them as `config_error`.
+
+## 5. Compatibility invariants
+
+- JC001–JC007 semantics, severities, and precedence are unchanged; there is no JC008.
+- Exit codes are unchanged: 0 no unsuppressed compatibility ERROR, 1 compatibility ERROR, 2 tool/config/Git/parser/usage failure.
+- JSON schema 2 structure and `unknown_reason` vocabulary are unchanged.
+- Runtime dependencies remain `prism >= 1.9, < 2`; Ruby `>= 3.3`.
+- Validation parses text only: no eval, `const_get`, constantize, application `require`, Rails or Sidekiq boot, Redis, source execution, or analysis-time network.
+- Output remains byte-deterministic, including exact Unicode codepoints.
+
+## 6. Non-goals
+
+New Sidekiq producer APIs, SARIF, ActiveJob, keyword compatibility, payload type or Hash schema checking, Redis inspection, wrapper tracking, aliases, inheritance analysis, general dataflow, feature-flag analysis, new suppression syntax, wildcard suppressions, and regex suppressions.

data/docs/spec-v0.2.md

@@ -0,0 +1,67 @@
+# jobcompat v0.2 normative delta specification
+
+Status: normative for `0.2.0`
+
+This document is a delta from [`spec-v0.1.md`](spec-v0.1.md). **v0.1 rules remain normative unless explicitly overridden here.** JC001–JC007, their severity and precedence, the three deployment directions, immutable Git inputs, source-only Prism analysis, and conservative unknown behavior are unchanged.
+
+## 1. Versioned contracts
+
+- Gem and CLI version: `0.2.0`.
+- JSON `schema_version`: `2`.
+- `.jobcompat.yml` version: `1`.
+- JSON schema v2 preserves the v1 field structure. Its intentional public expansion is the producer `unknown_reason` vocabulary.
+
+## 2. Supported producer syntax
+
+In addition to all v0.1 forms, v0.2 recognizes:
+
+- `Worker.perform_bulk(rows, **options)`;
+- `Worker.set(...).perform_in(schedule, *payload)` and `.perform_at(time, *payload)`;
+- `Worker.set(...).perform_bulk(rows, **options)`;
+- `Sidekiq::Client.push(payload)` and `::Sidekiq::Client.push(payload)`;
+- `Sidekiq::Client.push_bulk(payload)` and its root-qualified form.
+
+Only the exact static Client receiver is recognized. Client instances, `via`, wrappers, similarly named receivers, ActiveJob, inline/sync execution, and other bulk-like method names remain unsupported or ignored as defined by the v0.1 evidence policy.
+
+## 3. Bulk normalization
+
+A static outer Array is inspected without evaluating inner values. Each inner Array with no splat contributes its element count. Duplicate counts are removed and sorted. One callsite therefore emits at most one producer fact per distinct known arity, plus uncertainty evidence. `[]` emits no producer fact and no warning.
+
+Non-Array rows and rows containing a splat emit `dynamic_bulk_arguments`; known sibling rows remain known. A dynamic outer collection emits only that unknown evidence. Explicit `at`, `batch_size`, and `spread_interval` options do not contribute to payload arity. A keyword splat that could override bulk class or args emits `dynamic_bulk_options` and does not prove a known payload.
+
+The engine receives ordinary single-arity `Call` facts. It has no bulk-specific compatibility rule or arity-set type.
+
+## 4. Setter schedules
+
+For Setter `perform_in` and `perform_at`, the first outer call argument is the schedule and is excluded from payload arity. Setter options are not payload arguments. Existing Setter `perform_async` behavior is unchanged.
+
+## 5. Static Client payloads
+
+`push` requires one static Hash payload with runtime-valid string `"class"` and `"args"` keys. `"args"` must be a static Array with no splat; its length is the payload arity. Additional valid string job options do not affect arity.
+
+`push_bulk` uses the same class extraction and bulk normalization for `"args"`. The documented symbol forms of `at`, `batch_size`, and `spread_interval` are accepted because Sidekiq consumes them before normalizing job keys; other non-string keys are unsupported.
+
+A class constant uses the existing root/qualified/lexical worker resolution. A class String must be a canonical Ruby constant path accepted by the supported Prism parser, without leading `::`, and is matched exactly against the base/head worker union. Surrounding namespaces are never prefixed, and Unicode identifiers are not normalized. Both Client APIs share this validation: safely convert the value to valid UTF-8, parse exactly one static constant expression, reuse constant-path extraction, and require the extracted canonical name to equal the complete String value. Malformed bytes, parser diagnostics, whitespace, comments, extra statements, and other non-canonical syntax produce `unsupported_client_payload` JC007 evidence rather than an internal error.
+
+For `"class"` and `"args"` independently, the last Hash entry capable of writing that key determines certainty. A later explicit string key replaces earlier writes; a later unknown Hash splat or dynamic/non-static key makes that key uncertain. Static unrelated keys cannot overwrite it. Parentheses around a single static expression preserve its evidence. Unsupported static non-string keys retain the payload policy above.
+
+A known worker target is retained when only args are uncertain, so JC005 and worker-attributed JC007 can coexist. If class is uncertain, an earlier explicit worker is not retained and cannot create a class-presence request or JC005. A dynamic key that prevents proving either relevant value emits `unsupported_client_payload`; a dynamic key before both final explicit keys does not discard their known evidence.
+
+## 6. Producer uncertainty reasons
+
+Schema v2 adds these deterministic reasons:
+
+- `dynamic_bulk_arguments`;
+- `dynamic_bulk_options`;
+- `dynamic_client_payload`;
+- `dynamic_client_class`;
+- `dynamic_client_args`;
+- `unsupported_client_payload`.
+
+Recognized but unprovable producer evidence maps to JC007. Known and unknown evidence from one bulk expression may coexist, as may ERROR and WARNING findings. Revision is excluded from the semantic evidence fingerprint exactly as in v0.1.
+
+## 7. Determinism and limits
+
+Facts sharing one path/line/column are totally ordered by method, arity, and uncertainty reason. Producer arity arrays remain sorted unique integers; finding `payload_arity` remains an integer or null. No source is evaluated, required, or booted; there is no local-variable dataflow, Redis access, Sidekiq runtime dependency, checkout, or working-tree mutation.
+
+The Prism constraint remains `>= 1.9, < 2`, and Ruby remains `>= 3.3`.

data/lib/jobcompat/analysis.rb

@@ -1,4 +1,5 @@
 require "prism"
+require_relative "canonical_worker_name"
 
 module Jobcompat
   Location = Data.define(:revision, :path, :line, :column, :role, :excerpt) do
@@ -18,7 +19,7 @@ module Jobcompat
        signature_kind: signature_kind, signature: signature, unknown_reason: unknown_reason}
     end
   end
-  Call = Data.define(:revision, :path, :location, :receiver, :root, :namespace, :scope, :method, :arity, :unknown_reason, :fingerprint_parts)
+  Call = Data.define(:revision, :path, :location, :receiver, :resolution_mode, :root, :namespace, :scope, :method, :arity, :unknown_reason, :fingerprint_parts)
   Unknown = Data.define(:revision, :kind, :reason, :worker, :locations, :fingerprint_parts)
   Fragment = Data.define(:name, :declaration, :includes, :include_tokens, :performs, :lexical_scope)
 
@@ -126,6 +127,7 @@ module Jobcompat
     end
 
     def self.constant(node)
+      node = unwrap_parentheses(node)
       case node
       when Prism::ConstantReadNode then [[node.name.to_s.encode(Encoding::UTF_8)], false]
       when Prism::ConstantPathNode, Prism::ConstantPathTargetNode
@@ -138,6 +140,13 @@ module Jobcompat
       end
     end
 
+    def self.unwrap_parentheses(node)
+      while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode) && node.body.body.one?
+        node = node.body.body.first
+      end
+      node
+    end
+
     def self.normalize(source)
       Prism.lex(source).value.filter_map do |pair|
         token = pair.first
@@ -237,14 +246,21 @@ module Jobcompat
 
     def extract_call(node, namespace, scope, statement)
       method = node.name.to_s
-      return unless %w[perform_async perform_in perform_at].include?(method)
-      return if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :set && method != "perform_async"
-      receiver = node.receiver
-      set_call = receiver if receiver.is_a?(Prism::CallNode) && receiver.name == :set && method == "perform_async"
+      if %w[push push_bulk].include?(method) && sidekiq_client?(node.receiver)
+        extract_client_call(node, namespace, scope, statement, method)
+        return
+      end
+      return unless %w[perform_async perform_in perform_at perform_bulk].include?(method)
+      receiver = self.class.unwrap_parentheses(node.receiver)
+      set_call = receiver if receiver.is_a?(Prism::CallNode) && receiver.name == :set
       receiver = set_call.receiver if set_call
       constant = self.class.constant(receiver)
       safe = node.call_operator_loc&.slice == "&." || set_call&.call_operator_loc&.slice == "&."
       arguments = node.arguments&.arguments || []
+      if method == "perform_bulk"
+        extract_worker_bulk(node, namespace, scope, statement, method, receiver, constant, safe, arguments)
+        return
+      end
       reason = if arguments.any? { |arg| arg.is_a?(Prism::SplatNode) }
                  "splat_arguments"
                elsif arguments.any? { |arg| arg.is_a?(Prism::ForwardingArgumentsNode) }
@@ -259,9 +275,130 @@ module Jobcompat
                  "safe_navigation_receiver"
                end
       arity = reason && %w[splat_arguments forwarded_arguments missing_schedule_argument].include?(reason) ? nil : arguments.length - (method == "perform_async" ? 0 : 1)
+      emit_call(node, namespace, scope, statement, method, constant&.first&.join("::"), "lexical_constant", constant&.last, arity, reason)
+    end
+
+    def extract_worker_bulk(node, namespace, scope, statement, method, receiver_node, constant, safe, arguments)
+      reason = if safe
+                 "safe_navigation_receiver"
+               elsif constant.nil? && !receiver_node.is_a?(Prism::ConstantPathNode)
+                 "dynamic_receiver"
+               elsif constant.nil?
+                 "unsupported_constant_path"
+               elsif arguments.empty?
+                 "dynamic_bulk_arguments"
+               elsif arguments.drop(1).any? { |arg| !arg.is_a?(Prism::KeywordHashNode) || arg.elements.any? { |element| element.is_a?(Prism::AssocSplatNode) } }
+                 "dynamic_bulk_options"
+               end
+      receiver = constant&.first&.join("::")
+      if reason
+        emit_call(node, namespace, scope, statement, method, receiver, "lexical_constant", constant&.last, nil, reason)
+        return
+      end
+      arities, unknown = extract_bulk_arities(arguments.first)
+      arities.each do |arity|
+        emit_call(node, namespace, scope, statement, method, receiver, "lexical_constant", constant.last, arity, nil)
+      end
+      if unknown
+        emit_call(node, namespace, scope, statement, method, receiver, "lexical_constant", constant.last, nil, "dynamic_bulk_arguments")
+      end
+    end
+
+    def extract_client_call(node, namespace, scope, statement, method)
+      if node.call_operator_loc&.slice == "&."
+        emit_call(node, namespace, scope, statement, method, nil, nil, nil, nil, "safe_navigation_receiver")
+        return
+      end
+      arguments = node.arguments&.arguments || []
+      payload = arguments.one? ? self.class.unwrap_parentheses(arguments.first) : nil
+      unless payload.is_a?(Prism::HashNode) || payload.is_a?(Prism::KeywordHashNode)
+        emit_call(node, namespace, scope, statement, method, nil, nil, nil, nil, "dynamic_client_payload")
+        return
+      end
+      associations = payload.elements.select { |element| element.is_a?(Prism::AssocNode) }
+      class_node, class_status = client_hash_value(payload.elements, "class")
+      args_node, args_status = client_hash_value(payload.elements, "args")
+      args_node = self.class.unwrap_parentheses(args_node)
+      invalid_keys = associations.any? do |association|
+        key = self.class.unwrap_parentheses(association.key)
+        next false if key.is_a?(Prism::StringNode)
+        next false unless key.static_literal?
+        method != "push_bulk" || !key.is_a?(Prism::SymbolNode) || !%w[at batch_size spread_interval].include?(key.unescaped)
+      end
+      reason = "unsupported_client_payload" if [class_status, args_status].any? { |status| %i[missing unsupported].include?(status) } || invalid_keys
+      reason ||= "dynamic_client_class" if class_status == :unknown
+      receiver, mode, rooted, class_reason = client_worker(class_node)
+      reason ||= class_reason
+      reason ||= method == "push" ? "dynamic_client_args" : "dynamic_bulk_arguments" if args_status == :unknown
+      if reason
+        emit_call(node, namespace, scope, statement, method, receiver, mode, rooted, nil, reason)
+        return
+      end
+      if method == "push"
+        unless args_node.is_a?(Prism::ArrayNode) && args_node.elements.none? { |element| element.is_a?(Prism::SplatNode) }
+          emit_call(node, namespace, scope, statement, method, receiver, mode, rooted, nil, "dynamic_client_args")
+          return
+        end
+        emit_call(node, namespace, scope, statement, method, receiver, mode, rooted, args_node.elements.length, nil)
+      else
+        arities, unknown = extract_bulk_arities(args_node)
+        arities.each { |arity| emit_call(node, namespace, scope, statement, method, receiver, mode, rooted, arity, nil) }
+        if unknown
+          emit_call(node, namespace, scope, statement, method, receiver, mode, rooted, nil, "dynamic_bulk_arguments")
+        end
+      end
+    end
+
+    def extract_bulk_arities(node)
+      node = self.class.unwrap_parentheses(node)
+      return [[], true] unless node.is_a?(Prism::ArrayNode)
+      arities = []
+      unknown = false
+      node.elements.each do |element|
+        element = self.class.unwrap_parentheses(element)
+        if element.is_a?(Prism::ArrayNode) && element.elements.none? { |item| item.is_a?(Prism::SplatNode) }
+          arities << element.elements.length
+        else
+          unknown = true
+        end
+      end
+      [arities.uniq.sort, unknown]
+    end
+
+    def sidekiq_client?(node)
+      constant = self.class.constant(node)
+      constant && constant.first == %w[Sidekiq Client]
+    end
+
+    def client_hash_value(elements, key)
+      elements.reverse_each do |element|
+        return [nil, :unknown] if element.is_a?(Prism::AssocSplatNode)
+        entry_key = self.class.unwrap_parentheses(element.key)
+        if entry_key.is_a?(Prism::StringNode)
+          return [element.value, :known] if entry_key.unescaped == key
+        elsif !entry_key.static_literal?
+          return [nil, :unsupported]
+        end
+      end
+      [nil, :missing]
+    end
+
+    def client_worker(node)
+      node = self.class.unwrap_parentheses(node)
+      constant = self.class.constant(node)
+      return [constant.first.join("::"), "client_constant", constant.last, nil] if constant
+      if node.is_a?(Prism::StringNode)
+        name = CanonicalWorkerName.parse(node.unescaped)
+        return [name, "exact_string", false, nil] if name
+        return [nil, nil, nil, "unsupported_client_payload"]
+      end
+      [nil, nil, nil, "dynamic_client_class"]
+    end
+
+    def emit_call(node, namespace, scope, statement, method, receiver, resolution_mode, root, arity, reason)
       expression = self.class.normalize(node.location.slice)
       enclosing = self.class.normalize((statement || node).location.slice)
-      @calls << Call.new(@revision, @path, loc(node, reason ? "unknown_call" : "producer"), constant&.first&.join("::"), constant&.last,
+      @calls << Call.new(@revision, @path, loc(node, reason ? "unknown_call" : "producer"), receiver, resolution_mode, root,
                          namespace, scope, method, arity, reason, [@path, scope, expression, enclosing])
     end
 

data/lib/jobcompat/canonical_worker_name.rb

@@ -0,0 +1,35 @@
+require "prism"
+
+module Jobcompat
+  # Internal: the single authority for canonical String worker names, shared by
+  # producer analysis (Client String "class" values) and Config (ignore[].worker).
+  # Prism decides what a Ruby constant path is; no handwritten identifier grammar.
+  module CanonicalWorkerName
+    # Returns the canonical UTF-8 name when value is exactly one complete,
+    # non-root-qualified static constant path, or nil otherwise. The input is
+    # never trimmed or Unicode-normalized.
+    def self.parse(value)
+      return unless value.is_a?(String)
+      name = value.encode(Encoding::UTF_8)
+      return unless name.valid_encoding?
+      result = Prism.parse(name)
+      return unless result.errors.empty? && result.value.statements.body.one?
+      segments = segments(result.value.statements.body.first)
+      return unless segments
+      canonical = segments.join("::")
+      canonical if canonical == name
+    rescue EncodingError
+      nil
+    end
+
+    def self.segments(node)
+      case node
+      when Prism::ConstantReadNode then [node.name.to_s.encode(Encoding::UTF_8)]
+      when Prism::ConstantPathNode
+        parent = node.parent && segments(node.parent)
+        parent && parent + [node.name.to_s.encode(Encoding::UTF_8)]
+      end
+    end
+    private_class_method :segments
+  end
+end

data/lib/jobcompat/cli.rb

@@ -98,7 +98,7 @@ module Jobcompat
     end
 
     def envelope(status, findings, suppressions, workers, diagnostics, summary)
-      {schema_version: 1, tool: {name: "jobcompat", version: VERSION}, status: status,
+      {schema_version: 2, tool: {name: "jobcompat", version: VERSION}, status: status,
        comparison: {deployment_model: "rolling", base: {ref: @base, sha: @base_sha}, head: {ref: @head, sha: @head_sha}},
        configuration: {path: @loaded_config}, findings: findings, suppressions: suppressions, workers: workers,
        diagnostics: diagnostics, summary: summary}

data/lib/jobcompat/config.rb

@@ -1,4 +1,5 @@
 require "psych"
+require_relative "canonical_worker_name"
 
 module Jobcompat
   class Config
@@ -36,12 +37,7 @@ module Jobcompat
         fields!(item, %w[rule worker reason], "ignore[#{index}]")
         raise Error.new("ignore[#{index}] must have rule, worker, reason", category: "config_error") unless item.keys.sort == %w[reason rule worker]
         raise Error.new("ignore[#{index}].rule is invalid", category: "config_error") unless RULES.include?(item["rule"])
-        worker = item["worker"]
-        valid_worker = worker.is_a?(String) && !worker.empty? && !worker.start_with?("::") && worker.split("::", -1).all? do |segment|
-          first = segment.each_char.first
-          first && (first.match?(/[A-Z]/) || (first.ord > 127 && first.match?(/\p{L}/))) && segment.match?(/\A[\p{Alnum}_]+\z/)
-        end
-        raise Error.new("ignore[#{index}].worker is invalid", category: "config_error") unless valid_worker
+        raise Error.new("ignore[#{index}].worker is invalid", category: "config_error") unless CanonicalWorkerName.parse(item["worker"])
         raise Error.new("ignore[#{index}].reason must be non-blank", category: "config_error") unless item["reason"].is_a?(String) && !item["reason"].strip.empty?
         key = [item["rule"], item["worker"]]
         raise Error.new("duplicate ignore for #{key.join(' ')}", category: "config_error") if seen[key]

data/lib/jobcompat/engine.rb

@@ -123,10 +123,11 @@ module Jobcompat
     private
 
     def resolve(raw_calls)
-      raw_calls.sort_by { |call| [call.path, call.location.line, call.location.column] }.filter_map do |call|
+      raw_calls.sort_by { |call| [call.path, call.location.line, call.location.column, call.method,
+                                  call.arity.nil? ? Float::INFINITY : call.arity, call.unknown_reason.to_s] }.filter_map do |call|
         worker = nil
         if call.receiver
-          candidates = if call.root
+          candidates = if call.resolution_mode == "exact_string" || call.root
                          [call.receiver]
                        elsif call.namespace.nil?
                          []
@@ -134,9 +135,11 @@ module Jobcompat
                          (call.namespace.reverse.map { |prefix| "#{prefix}::#{call.receiver}" } + [call.receiver]).uniq
                        end
           worker = candidates.find { |name| @names.include?(name) }
-          next unless worker || (!call.root && call.namespace.nil?)
+          client_target = %w[client_constant exact_string].include?(call.resolution_mode)
+          next unless worker || client_target || (!call.root && call.namespace.nil?)
         end
         reason = call.unknown_reason
+        reason ||= "dynamic_client_class" if call.receiver && worker.nil? && %w[client_constant exact_string].include?(call.resolution_mode)
         reason ||= call.namespace.nil? ? "unsupported_constant_path" : "dynamic_receiver" if worker.nil?
         {worker: worker, location: call.location, arity: call.arity, reason: reason, raw: call}
       end

data/lib/jobcompat/version.rb

@@ -1,3 +1,3 @@
 module Jobcompat
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/jobcompat.rb

@@ -1,5 +1,6 @@
 require_relative "jobcompat/version"
 require_relative "jobcompat/errors"
+require_relative "jobcompat/canonical_worker_name"
 require_relative "jobcompat/config"
 require_relative "jobcompat/git_repository"
 require_relative "jobcompat/analysis"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jobcompat
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - jobcompat contributors
@@ -42,13 +42,22 @@ files:
 - SECURITY.md
 - docs/architecture.md
 - docs/competitive-analysis.md
+- docs/implementation-plan-v0.2.1.md
+- docs/implementation-plan-v0.2.md
 - docs/implementation-plan.md
 - docs/release-checklist-v0.1.0.md
+- docs/release-checklist-v0.2.0.md
+- docs/release-checklist-v0.2.1.md
 - docs/release-notes-v0.1.0.md
+- docs/release-notes-v0.2.0.md
+- docs/release-notes-v0.2.1.md
 - docs/spec-v0.1.md
+- docs/spec-v0.2.1.md
+- docs/spec-v0.2.md
 - exe/jobcompat
 - lib/jobcompat.rb
 - lib/jobcompat/analysis.rb
+- lib/jobcompat/canonical_worker_name.rb
 - lib/jobcompat/cli.rb
 - lib/jobcompat/config.rb
 - lib/jobcompat/engine.rb