v2.2.4

Arid 2.2.4 — Identify stale suppressions in normal scan output

Arid 2.2.4 is a narrow usability patch for suppression-health reporting.

When a normal text scan performs a suppression audit, Arid already reported aggregate Total / Active / Stale counts. If the audit found stale suppressions, however, the developer still had to run a second command to discover which suppression regions were stale.

This release closes that gap.

Actionable stale-suppression output

When --suppression-summary or normal-scan --fail-on-stale finds stale suppressions, the human text report now lists only the stale regions immediately after the Suppressions table:

Suppressions

┌────────┬─────┐
│ Total  │ 317 │
│ Active │ 316 │
│ Stale  │   1 │
└────────┴─────┘

Stale suppressions

  src/example.py:120-134

Run with --suppression-status for the full suppression audit.

EOF-terminated regions are rendered as START-EOF.

The locations are project-relative and follow the same deterministic path/line ordering used by the suppression audit. Active suppressions remain summarized by count so normal scan output stays focused on the maintenance action that is actually required.

When no stale suppressions exist, the extra section is omitted entirely.

Existing workflows remain intact

--suppression-summary remains informational: stale suppressions do not affect the process exit status unless --fail-on-stale is also requested.

--fail-on-stale keeps its existing exit semantics, but a text-mode failure now identifies the stale region or regions that caused the policy failure.

Use the existing detailed command when you need the complete lifecycle view of all suppression regions:

arid . --suppression-status

Compatibility

Arid's duplicate-detection behavior and duplicate identity are unchanged in 2.2.4.

This patch does not change any versioned machine contract or machine-oriented output shape, including:

• report-v4;
• summary-v1;
• suppression-status-v1;
• SARIF;
• Markdown;
• supplemental normal-scan reports.

The change is limited to human text presentation plus the corresponding regression and integration validation.

Install

With uv:

uv tool install --upgrade "arid==2.2.4"
arid --version

Or with pip:

python -m pip install --upgrade "arid==2.2.4"
arid --version

Expected version output:

arid 2.2.4

GitHub Action

The existing GitHub Action remains compatible. Stable examples should use the 2.2.4 tag after publication:

- uses: sponge-b0b/arid@v2.2.4
  with:
    paths: .

Arid v2.2.3

Arid 2.2.3 — Prepare the GitHub Action for Marketplace

Arid 2.2.3 is a small integration and packaging release that prepares Arid's existing GitHub Action for publication in GitHub Marketplace.

The Action remains part of the main sponge-b0b/arid repository and continues to use normal Arid release tags such as v2.2.3. This release does not create a separate Action repository or introduce a separate Action versioning scheme.

GitHub Marketplace metadata

The root action.yml now uses Marketplace-facing metadata:

name: Arid duplicate-code check
description: Detect duplicate Python code with Arid and expose findings, metrics, and CI outputs.

branding:
  icon: layers
  color: orange

GitHub Marketplace supports only its predefined Feather icons and branding colors, so the Action correctly uses the supported layers icon and orange color.

This release makes the tagged Action source Marketplace-ready. It does not mean the Action has already been published to GitHub Marketplace; Marketplace publication is a separate GitHub UI step after this release.

Arid brand assets

The repository also includes approved Feather-style Arid assets:

• assets/arid-feather-solid.svg
• assets/arid-feather-solid.png

The custom assets use Arid's brand amber #F39E0A. They remain repository branding assets; GitHub Marketplace does not accept arbitrary custom Action icons or colors in action.yml.

Compatibility

Arid's duplicate-detection behavior, output contracts, suppression semantics, and existing user-facing analysis behavior are unchanged in 2.2.3. The changes in this patch are limited to Marketplace preparation, release/integration metadata, documentation, and release-process housekeeping already present on main.

Existing GitHub Action inputs and outputs remain unchanged.

Install

With uv:

uv tool install --upgrade "arid==2.2.3"
arid --version

Or with pip:

python -m pip install --upgrade "arid==2.2.3"
arid --version

Expected version output:

arid 2.2.3

Official GitHub Action

Pin the patch release directly:

- uses: sponge-b0b/arid@v2.2.3
  with:
    paths: .

After the release is published and verified, v2.2.3 is the tag intended for the subsequent GitHub Marketplace publication step.

v2.2.2

Arid 2.2.2 — Surface Suppression Health in Normal Scans

Arid 2.2.2 makes suppression health available as part of an ordinary duplication workflow without changing Arid's default fast path or existing machine contracts.

Source-level suppressions already distinguish intentional duplication from stale maintenance state. Previously, however, that lifecycle information was available only through the standalone --suppression-status administrative command, and --fail-on-stale required a status mode.

Arid 2.2.2 integrates that maintenance signal into normal scans when explicitly requested.

Suppression summary in normal scans

Use:

arid . --suppression-summary

to run the normal duplication scan and append aggregate suppression health to human text output:

Suppressions

┌────────┬───┐
│ Total  │ 4 │
│ Active │ 3 │
│ Stale  │ 1 │
└────────┴───┘

This mode is informational. Stale suppressions do not change the normal scan exit status unless stale enforcement is also requested.

Ordinary:

arid .

continues to use the existing fast path and does not pay for the additional suppression audit.

Fail normal scans on stale suppressions

--fail-on-stale is now a normal-scan exit policy:

arid . --fail-on-stale

Arid performs the ordinary duplicate scan, audits suppressions, and returns findings exit 1 when either normal duplicate findings are reportable or stale suppression state is enforced.

A stale-only project therefore exits 1 even when the duplication scan itself has no reportable findings.

In normal text output, --fail-on-stale also includes the aggregate Suppressions block automatically.

The existing detailed administrative workflow remains available:

arid . --suppression-status
arid . --suppression-status --fail-on-stale

Machine-contract compatibility

This release does not widen Arid's existing machine contracts.

--suppression-summary is human text presentation only.

During normal JSON, Markdown, or SARIF scans, --fail-on-stale changes only exit policy. Suppression state is not added to:

• report-v4;
• summary-v1;
• Markdown output;
• SARIF output;
• supplemental normal-scan reports.

The existing deterministic suppression-status-v1 contract remains the detailed machine-readable suppression audit.

Validation

The release adds focused unit and CLI regression coverage for:

• ordinary scans remaining suppression-audit-free;
• aggregate Total / Active / Stale suppression health;
• informational --suppression-summary behavior;
• stale-only normal scans failing under --fail-on-stale;
• active suppressions not causing stale-policy failure;
• normal JSON retaining the existing report-v4 shape while stale policy affects only process status.

The complete locked Rust checks, Clippy gate, release build, and validation/v2.2.sh passed before release preparation.

Release workflow housekeeping

The release workflow also preserves manual workflow_dispatch as a pre-publication build/verification path. Published-action verification remains tag-gated after PyPI and GitHub release publication, avoiding the pre-release circular check identified during the 2.2.1 process.

Install

With uv:

uv tool install --upgrade "arid==2.2.2"
arid --version

Or with pip:

python -m pip install --upgrade "arid==2.2.2"
arid --version

Expected version output:

arid 2.2.2

Official GitHub Action

Pin the patch release directly:

- uses: sponge-b0b/arid@v2.2.2
  with:
    paths: .

v2.2.1

Arid 2.2.1 — Correct Project Exclusions for Dot Scan Roots

Arid 2.2.1 is a narrowly scoped correctness patch for configured project exclusions during directory discovery.

Arid 2.2.0 could load a project configuration such as:

[tool.arid]
exclude = ["legacy/**"]

and still discover files under legacy/ when invoked from the project root with the common command:

arid .

The same path could correctly report Decision: exclude through --explain-path while still appearing in --list-files and normal scan results.

Fix

Relative scan inputs are converted to absolute paths before discovery. For arid ., that can preserve a lexical /. component in the walk root and descendant paths.

Arid 2.2.0 passed those absolute walker paths directly to the configured ignore matcher. A project-relative pattern such as legacy/** could therefore fail to match a walker path whose matcher-relative form retained ./legacy/....

Arid 2.2.1 now derives the project-relative path with Rust Path semantics before evaluating configured exclusions. The matcher therefore receives legacy/... rather than an absolute path containing the lexical dot component.

The fix deliberately does not use filesystem canonicalization, so Arid's existing symlink behavior remains unchanged.

Regression coverage

The patch adds both layers that were missing from the 2.2 qualification suite:

• a discovery unit regression using an absolute scan root containing /. with a configured generated/** exclusion;
• a real CLI validation that changes into a configured project and runs arid . --list-files, proving the excluded directory is absent.

The corrected build passed the established Rust checks and validation/v2.sh. It was also reproduced against the Polaris repository that exposed the defect: the configured legacy/** tree disappeared from discovery, findings, and hotspots.

Compatibility

Arid 2.2.1 changes no duplicate-detection semantics.

The following remain unchanged:

• exact normalized duplicate identity;
• DUP001;
• finding fingerprints;
• report-v4, summary-v1, baseline-v1, and other machine contracts;
• normalization behavior;
• baseline and focus behavior;
• worker behavior;
• ordinary scan exit meanings;
• hidden-file and ignore-file policy;
• explicit-file behavior;
• symlink traversal policy.

The only product behavior corrected by this patch is enforcement of existing configured exclude patterns when directory discovery begins from paths such as ..

Install

With uv:

uv tool install --upgrade "arid==2.2.1"
arid --version

Or with pip:

python -m pip install --upgrade "arid==2.2.1"
arid --version

Expected version output:

arid 2.2.1

Official GitHub Action

Pin the patch release directly:

- uses: sponge-b0b/arid@v2.2.1
  with:
    paths: .

v2.2.0

Arid 2.2.0 — High-Signal Duplicate Intelligence

Arid 2.2 keeps the focused exact duplicate detector from 2.1 and makes its existing evidence substantially easier to understand and consume.

The detector itself remains intentionally unchanged: Arid still finds exact normalized Python duplicate code and reports DUP001. The 2.2 release adds a richer aggregate view for developers, a compact deterministic machine summary for tools and coding agents, expanded GitHub Action outputs, and bounded adaptive file-preparation parallelism by default.

Highlights

Rich human summary

Normal text scans now end with three aggregate sections:

• Summary — files analyzed, files with duplicates, source/analyzed lines, duplicate groups, occurrences, duplicate lines, and duplication percentage
• Breakdown — duplicate-group counts and shares by Context, Scope, and Distribution
• Hotspots — up to five files ranked objectively by duplicate-group participation, then occurrence count, then path

These metrics are descriptive. Arid does not assign severity, health scores, quality grades, or percentage-based quality thresholds.

Hotspots are intentionally objective participation counts rather than an opinionated refactoring score. Generated or data-heavy paths can therefore dominate a scan when they genuinely contain the most duplicate participation; normal Arid exclusions remain the mechanism for removing such paths from the analyzed corpus.

--summary-only

Use:

arid . --summary-only

to suppress individual DUP001 finding blocks while preserving the same detection, filtering, worker behavior, metrics, and exit policy.

For JSON:

arid . --summary-only --json

emits the compact deterministic summary-v1 contract.

Markdown and SARIF remain full finding-oriented primary formats. Supplemental --report files also remain full existing report formats even when primary output is summary-only.

summary-v1

Arid 2.2 publishes:

• schemas/summary-v1.schema.json

The contract includes:

• completeness and structured errors
• effective analysis metadata
• files analyzed
• files with duplicates
• source and analyzed lines
• duplicate groups
• occurrences
• duplicate lines
• duplication percentage
• fixed Context counts
• fixed Scope counts
• fixed Distribution counts
• deterministic top-five hotspots

It intentionally excludes worker count, elapsed timing, color state, terminal layout, and human-formatted number strings so logically identical scans remain deterministic across execution environments.

summary-v1 is derived from the final reportable findings after normal baseline and focus policy. It does not create a second detector or a second definition of duplication.

Expanded GitHub Action outputs

The official Action now exposes:

• occurrences
• files-with-duplicates
• summary-json

alongside the existing outputs.

summary-json follows the same logical summary-v1 contract as the CLI. The Action still performs one Arid scan and derives its outputs and optional reports from that same scan.

Adaptive parallelism by default

Omitting --workers is now equivalent to:

arid . --workers auto

Automatic selection uses available parallelism clamped to 1..=4, with a fallback to one worker when available parallelism cannot be determined.

Explicit numeric values remain exact:

arid . --workers 1
arid . --workers 2
arid . --workers 4
arid . --workers 8

The automatic cap does not apply to explicit numeric values.

Parallelism remains confined to file preparation: reading, parsing, and normalization. Duplicate identity, finding order, fingerprints, metrics, baseline/focus behavior, machine contracts, and exit status remain deterministic.

Compatibility

Arid 2.2 preserves the 2.1 detector and compatibility surfaces, including:

• exact duplicate semantics
• DUP001
• finding fingerprints
• report-v4 schema and meaning
• baseline-v1 schema and meaning
• error-v1
• suppression-status-v1
• path-explanation-v1
• suppression semantics
• discovery semantics
• focus semantics
• baseline filtering semantics
• normalization semantics
• [tool.arid] behavior
• explicit --workers 1
• explicit numeric worker behavior
• --workers auto semantics
• ordinary scan exit meanings 0 / 1 / 2
• --no-fail-on-findings
• Markdown report semantics
• SARIF semantics
• supplemental --report semantics
• supported platform set

The intentional 2.2 changes are:

• normal text now ends with Summary, Breakdown, and Hotspots;
• --summary-only provides concise text or summary-v1 JSON;
• the Action exposes compact summary outputs;
• implicit worker selection now uses bounded automatic parallelism rather than serial execution.

Beta qualification

The published 2.2.0-beta.1 artifact passed the full stabilization campaign without requiring any product, packaging, compatibility, deterministic-output, machine-contract, or platform correction.

Published artifact qualification

The beta passed:

• exact GitHub prerelease and five-asset verification
• published SHA-256 verification for the Linux x86-64 standalone archive
• exact PyPI arid==2.2.0b1 installation
• complete validation/v2.2.sh qualification from both standalone and PyPI artifacts
• byte-identical standalone/PyPI summary-v1
• byte-identical standalone/PyPI report-v4
• exact tagged Action version pinning

Real-world detector validation

The exact published beta passed the established real-world campaign against:

• Black
• Django
• mypy
• Rich
• Unicode, spaces, non-ASCII filenames, relative paths, and source-location path cases

Detector behavior remained compatible with the established 2.1 expectations.

Real-world summary validation

Summary, Breakdown, and Hotspots were inspected on repositories ranging from 69 to 2,927 analyzed files.

The aggregate presentation remained compact and legible across those sizes and exposed materially different duplicate profiles without changing detector semantics. For example, the real-world campaign surfaced predominantly executable/function/same-file duplication in Black and Django, a much larger mixed/hybrid component in mypy, and data-heavy declarative/cross-file duplication in Rich.

Excluding Rich's generated Unicode data with normal Arid exclusion policy produced application-focused hotspots immediately, confirming that hotspot ranking correctly describes the selected corpus rather than embedding hidden generated-code heuristics.

Color qualification also passed: semantic color output contained ANSI styling, and stripping the styling produced the same visible content as --color never after excluding the intentionally volatile elapsed-time footer.

summary-v1 qualification

The exact published beta's Django summary-v1 output:

• validated against schemas/summary-v1.schema.json
• remained byte-identical for implicit default, --workers auto, and explicit workers 1, 2, 4, and 8
• matched independently reconstructed aggregate counts from report-v4
• matched Context, Scope, and Distribution group counts from report-v4
• reproduced hotspot ranking independently from report-v4
• excluded worker, timing, and color state as required

This validates summary-v1 as a deterministic compact contract for CI, tools, and coding-agent consumption on a real repository rather than only synthetic fixtures.

GitHub Action qualification

The beta publication workflow successfully exercised the official Action against the exact published PyPI package.

Beta stabilization identified one release-process coverage gap: the production Action E2E assertion step verified existing outputs but did not explicitly assert the three new 2.2 outputs. The release workflow was corrected to verify occurrences, files-with-duplicates, and the logical contents of summary-json.

A non-publishing five-platform Release workflow then passed with the corrected Action-output gate. This was a release-process-only correction; it did not change Arid product behavior, package contents, the published beta artifact, or the Action implementation.

Published-to-published performance

The final beta qualification compared the exact published Arid 2.1.0 Linux x86-64 standalone artifact with the exact published Arid 2.2.0-beta.1 artifact.

Each corpus used two Hyperfine passes with reversed command order, three warmups per pass, and ten measured runs per pass. Reported means average both passes.

Corpus	2.1 implicit	2.2 implicit	2.2 --workers 1	2.2 --workers auto	implicit change
requests	16.9 ms	15.4 ms	16.3 ms	15.6 ms	-9.1%
pydantic	239.7 ms	129.6 ms	237.2 ms	126.6 ms	-45.9%
polaris	501.5 ms	293.9 ms	497.6 ms	295.7 ms	-41.4%
duplicate-heavy	61.2 ms	40.6 ms	59.3 ms	38.4 ms	-33.8%

The published beta was faster than published 2.1.0 on every canonical corpus under the new implicit default. Forced serial 2.2 remained effectively at the 2.1 performance level, while bounded automatic parallelism delivered the intended improvement on larger corpora.

No material unexplained performance regression remains.

Install

With uv:

uv tool install "arid==2.2.0"
arid --version

Or with pip:

python -m pip install "arid==2.2.0"
arid --version

Expected version output:

arid 2.2.0

Official GitHub Action

Pin the stable release:

- uses: sponge-b0b/arid@v2.2.0
  with:
    paths: .

Upgrade from 2.1

For ordinary CLI users, 2.2 is intended to be a straightforward upgrade. Existing duplicate semantics and report-v4 consumers remain unchanged.

Review the new behavior if you depend on:

• exact human text output, because normal text now includes the aggregate Summary/Breakdown/Hotspots view;
• implicit serial execution, because the default now uses bounded automatic file preparation;
• GitHub Action outputs, wh...

v2.2.0-rc.1

Arid 2.2.0-rc.1 — High-Signal Duplicate Intelligence Release Candidate

Arid 2.2.0-rc.1 is the final frozen prerelease candidate for Arid 2.2.

The product behavior is unchanged from the fully qualified 2.2.0-beta.1 artifact. The detector still finds exact normalized Python duplicate code and reports DUP001; the v2.2 release surface remains the rich human Summary/Breakdown/Hotspots view, --summary-only, deterministic summary-v1, expanded GitHub Action summary outputs, and bounded adaptive file-preparation parallelism by default.

This RC exists because beta stabilization identified a release-process coverage gap after v2.2.0-beta.1 was published: the production Action E2E job exercised the Action successfully but did not explicitly assert the three new v2.2 outputs. The workflow has been corrected to verify occurrences, files-with-duplicates, and the logical contents of summary-json, while preserving the qualification-visible job identity.

No product, detector, packaging, compatibility, deterministic-output, machine-contract, Action-implementation, or platform correction was required after beta.

Frozen v2.2 behavior

Rich human summary

Normal text scans end with:

• Summary — files analyzed, files with duplicates, source/analyzed lines, duplicate groups, occurrences, duplicate lines, and duplication percentage
• Breakdown — duplicate-group counts and percentages by Context, Scope, and Distribution
• Hotspots — up to five files ranked by duplicate-group participation, then occurrences, then path

Hotspots are objective participation counts, not severity or quality scores.

--summary-only

Use:

arid . --summary-only

for concise human aggregate output without individual DUP001 blocks.

Use:

arid . --summary-only --json

for deterministic summary-v1 JSON.

Summary-only mode changes presentation, not detection, filtering, metrics, worker behavior, or exit policy. Supplemental --report files remain full report formats.

summary-v1

The compact machine contract includes completeness/error state, effective analysis metadata, aggregate duplicate metrics, fixed Context/Scope/Distribution counts, and deterministic top-five hotspots.

It intentionally excludes worker count, elapsed timing, color state, terminal layout, and human-formatted number strings.

The contract is derived from the final reportable findings after baseline and focus policy and does not introduce another detector path.

GitHub Action outputs

The official Action exposes:

• occurrences
• files-with-duplicates
• summary-json

alongside the existing outputs.

The Action performs one scan and derives its outputs and optional reports from that same scan.

The production Release workflow now explicitly verifies all three v2.2 outputs, including the logical contents of summary-json.

Adaptive parallelism

Omitting --workers is equivalent to:

arid . --workers auto

Automatic selection uses available parallelism clamped to 1..=4, with fallback to one worker when parallelism cannot be determined.

Explicit numeric worker counts remain exact and are not subject to the automatic cap. Parallelism remains confined to file preparation and does not change duplicate semantics or deterministic machine output.

Beta stabilization evidence

The exact published 2.2.0-beta.1 artifact passed the complete real-world stabilization campaign.

Published artifacts

• exact GitHub prerelease verification passed;
• all five supported standalone assets were present;
• the published Linux x86-64 archive digest matched the GitHub release digest;
• exact PyPI arid==2.2.0b1 installed successfully;
• standalone and PyPI artifacts both passed validation/v2.2.sh;
• standalone/PyPI summary-v1 output was byte-identical;
• standalone/PyPI report-v4 output was byte-identical.

Real-world detector validation

The published beta passed the established campaign against:

• Black
• Django
• mypy
• Rich
• Unicode, space, non-ASCII filename, relative-path, and source-location path cases

Detector behavior remained compatible with the established Arid 2.1 expectations.

Human summary validation

Summary, Breakdown, and Hotspots remained compact and legible across repositories ranging from 69 to 2,927 analyzed files.

Hotspot behavior was useful on real repositories. Rich also demonstrated the intended objective behavior: generated/data-heavy Unicode tables dominated the unfiltered hotspot list because they genuinely dominated duplicate participation, while ordinary --exclude policy immediately produced application-focused hotspots without introducing special generated-code heuristics.

Semantic color was visually reviewed as restrained, readable, and semantically sensible. Stripping ANSI styling produced the same visible content as --color never after excluding the intentionally volatile elapsed-time footer.

Machine contract and determinism

Real Django summary-v1:

• validated against schemas/summary-v1.schema.json;
• was byte-identical across implicit default, --workers auto, and explicit workers 1, 2, 4, and 8;
• matched independently reconstructed aggregate counts from report-v4;
• matched independently reconstructed Context, Scope, Distribution, and Hotspots;
• excluded worker, timing, and color state as required.

GitHub Action gate

The published beta Action executed successfully in the production release workflow.

After identifying the missing assertions, non-publishing Release workflow run 33296962210 passed with explicit verification of:

• occurrences
• files-with-duplicates
• summary-json

The correction changed release-process verification only; it did not change the Action implementation or Arid product behavior.

Published-to-published performance

The final beta campaign compared the exact published Arid 2.1.0 Linux x86-64 standalone artifact with the exact published 2.2.0-beta.1 artifact using two reversed-order Hyperfine passes, three warmups per pass, and ten measured runs per pass.

Corpus	2.1 implicit	2.2 implicit	2.2 --workers 1	2.2 --workers auto	implicit change
requests	16.9 ms	15.4 ms	16.3 ms	15.6 ms	-9.1%
pydantic	239.7 ms	129.6 ms	237.2 ms	126.6 ms	-45.9%
polaris	501.5 ms	293.9 ms	497.6 ms	295.7 ms	-41.4%
duplicate-heavy	61.2 ms	40.6 ms	59.3 ms	38.4 ms	-33.8%

No material unexplained performance regression remains.

Compatibility

Arid 2.2 preserves the 2.1 detector and existing machine/report compatibility surfaces, including report-v4, finding fingerprints, baseline-v1, suppression/discovery/focus behavior, normalization semantics, ordinary exit meanings, Markdown, SARIF, and supplemental reports.

The intentional v2.2 changes remain limited to the new aggregate presentation and summary contract, expanded Action outputs, and adaptive implicit worker selection.

Install the RC

With uv:

uv tool install --prerelease allow "arid==2.2.0rc1"
arid --version

Or with pip:

python -m pip install --pre "arid==2.2.0rc1"
arid --version

Expected version output:

arid 2.2.0-rc.1

Official GitHub Action

For this RC:

- uses: sponge-b0b/arid@v2.2.0-rc.1
  with:
    paths: .

Qualification target

This RC is intended to pass the complete published-release-candidate qualification campaign with no product-code changes afterward. If it passes, stable 2.2.0 promotion must be the exact metadata/documentation transition produced by release.sh from this qualified RC.

v2.2.0-beta.1

Arid 2.2.0-beta.1 — High-Signal Duplicate Intelligence Beta

Arid 2.2.0-beta.1 marks the feature-freeze point for the Arid 2.2 release line.

The detector remains intentionally unchanged from 2.1: Arid still finds exact normalized Python duplicate code and reports DUP001. V2.2 adds richer human summaries, objective duplicate hotspots, concise summary-only scans, the deterministic summary-v1 machine contract, expanded GitHub Action outputs, and bounded adaptive parallelism by default around that same focused detector.

This beta is for broader real-world and integration validation before stable-readiness qualification. New product features are not planned after this point. Fixes are limited to correctness defects, compatibility regressions, deterministic-output defects, platform inconsistencies, documentation defects, or release-process defects inside the approved v2.2 contract.

What is frozen

The beta carries forward the complete v2.2 surface introduced in alpha.1.

Rich human summary

Normal text scans end with a compact Summary containing:

• files analyzed
• files with duplicates
• source lines
• analyzed lines
• duplicate groups
• total occurrences
• duplicate lines
• duplication percentage

Detailed and summary-only human output can also include:

• Context breakdown
• Scope breakdown
• Distribution breakdown
• deterministic top-five Hotspots

These metrics are descriptive. Arid does not assign severity, health scores, quality grades, or percentage-based quality thresholds.

Objective Hotspots

Hotspots rank files by:

1. duplicate groups descending
2. occurrences descending
3. path ascending

A finding contributes at most one hotspot group count per path. Every reported location still contributes to hotspot occurrences.

The public list remains limited to five files.

--summary-only

--summary-only is frozen as a presentation modifier over the normal scan pipeline.

For text:

arid . --summary-only

suppresses individual DUP001 finding blocks while preserving the same logical Summary, Breakdown, Hotspots, filtering, worker behavior, and exit policy.

For JSON:

arid . --summary-only --json

or:

arid . --summary-only --format json

emits summary-v1.

Markdown and SARIF remain unsupported as primary summary-only formats.

Supplemental reports remain full existing formats. For example:

arid . \
  --summary-only \
  --report json=artifacts/full-report.json

writes full report-v4 while keeping primary text concise.

summary-v1

The compact deterministic machine contract remains:

• schemas/summary-v1.schema.json

It includes:

• completeness and structured errors
• effective analysis metadata
• files analyzed
• files with duplicates
• source and analyzed lines
• duplicate groups
• occurrences
• duplicate lines
• duplication percentage
• fixed Context counts
• fixed Scope counts
• fixed Distribution counts
• deterministic top-five hotspots

It intentionally excludes:

• elapsed timing
• worker count
• color state
• terminal layout
• human number formatting

summary-v1 is derived from the final typed report after baseline and focus filtering. It does not create another detector pass or another definition of duplication.

GitHub Action outputs

The official Action includes:

• occurrences
• files-with-duplicates
• summary-json

alongside the existing outputs.

summary-json follows the same logical summary-v1 contract as the CLI.

The Action continues to perform one Arid scan.

Adaptive parallelism by default

Implicit worker selection remains equivalent to:

--workers auto

Automatic selection uses available parallelism clamped to 1..=4, falling back to 1 when available parallelism cannot be determined.

Explicit values remain exact:

--workers 1
--workers 2
--workers 4
--workers 8

Explicit numeric values are not capped by the automatic-worker limit.

Parallelism remains confined to file preparation. Detection semantics and deterministic machine output are unchanged.

Compatibility

The following remain unchanged from Arid 2.1:

• exact duplicate semantics
• DUP001
• finding fingerprints
• report-v4 schema and meaning
• baseline-v1 schema and meaning
• error-v1
• suppression-status-v1
• path-explanation-v1
• suppression semantics
• discovery semantics
• focus semantics
• baseline filtering semantics
• normalization semantics
• [tool.arid] behavior
• explicit --workers 1
• explicit numeric worker behavior
• --workers auto semantics
• ordinary scan exit meanings 0 / 1 / 2
• --no-fail-on-findings
• Markdown report semantics
• SARIF semantics
• supplemental --report semantics
• supported platform set

The intentional v2.2 changes remain:

• normal text uses the rich Summary + Breakdown + Hotspots presentation;
• implicit worker selection uses bounded automatic parallelism rather than serial execution.

Alpha qualification results

Published 2.2.0-alpha.1 passed the complete pre-publication and published-artifact qualification path.

Before alpha publication, the v2.2 branch passed:

• the complete locked Rust test suite
• Clippy across all targets and features with warnings denied
• pinned Rust/rustfmt reproducibility checks
• Action and release Python unit tests
• locked release build qualification
• the inherited v2 and v2.1 validation suites
• the dedicated v2.2 contract suite
• real-world validation against Black, Django, mypy, and Rich
• Django determinism at workers 1, 2, 4, and 8
• Unicode, space-path, non-ASCII filename, relative-path, and source-location validation
• the full non-publishing supported-platform Release workflow
• stable 2.1.0 → v2.2 performance qualification

The pre-publication performance campaign measured the implicit v2.2 default versus stable 2.1:

Corpus	2.1 implicit	2.2 implicit	change
requests	17.0 ms	16.4 ms	-3.6%
pydantic	251.2 ms	134.9 ms	-46.3%
polaris	521.4 ms	303.2 ms	-41.8%
duplicate-heavy	61.6 ms	39.2 ms	-36.3%

Explicit --workers 1 remained effectively at stable 2.1 performance.

After alpha publication:

• the tag-triggered production Release workflow passed;
• all five supported standalone assets were published;
• exact PyPI arid==2.2.0a1 installed successfully;
• the published Linux x86-64 standalone archive passed its published SHA-256 check;
• the published standalone binary passed the complete validation/v2.2.sh suite;
• the exact PyPI-installed binary passed the complete validation/v2.2.sh suite;
• standalone and PyPI summary-v1 output was byte-identical;
• standalone and PyPI report-v4 output was byte-identical;
• the published GitHub Action verification job passed;
• the tagged Action pinned exact PyPI version 2.2.0a1.

No alpha qualification defect required a product or packaging correction before beta.

Install the beta

With uv:

uv tool install --prerelease allow "arid==2.2.0b1"
arid --version

Or with pip:

python -m pip install --pre "arid==2.2.0b1"
arid --version

Expected version output:

arid 2.2.0-beta.1

Official GitHub Action

For this beta:

- uses: sponge-b0b/arid@v2.2.0-beta.1
  with:
    paths: .

The release workflow verifies the published Action against the exact PyPI package version encoded in the tagged Action metadata.

What to test

Beta validation should focus on defects and integration friction in the frozen v2.2 surface, especially:

• rich summary usefulness on small, medium, and large repositories
• Context, Scope, and Distribution breakdown accuracy and legibility
• hotspot usefulness on real repositories
• --summary-only in local development and CI
• summary-v1 consumption by scripts, tools, and agents
• summary determinism across worker modes
• baseline and focus interactions
• outside-focus retained occurrence context
• incomplete keep-going summaries
• GitHub Action occurrences, files-with-duplicates, and summary-json
• implicit adaptive worker behavior on different machines
• explicit --workers 1 as the serial control path
• compatibility with report-v4 consumers
• Unicode and terminal presentation behavior
• platform-specific installation, packaging, and Action behavior

Any incompatible change to summary-v1, hotspot ranking, top-five behavior, or summary-only JSON semantics after this point requires an explicit versioned contract decision rather than silent mutation.

Next steps

After beta publication, Arid 2.2 enters full real-world beta stabilization.

The beta artifact will be qualified through:

• the established real-world detector campaign
• real rich-summary and hotspot inspection
• summary-only developer and CI use
• machine-contract consumption
• published Action verification
• worker determinism
• Unicode and supported-platform checks
• published-to-published performance comparison against stable 2.1
• documentation reconciliation

A release candidate is created only if beta qualification identifies a correction that requires another frozen published build. Otherwise the qualified beta may proceed directly to stable-readiness qualification under the v2.2 roadmap.

v2.2.0-alpha.1

Arid 2.2.0-alpha.1 — High-Signal Duplicate Intelligence Alpha

Arid 2.2.0-alpha.1 is the first public build of the Arid 2.2 release line.

The duplicate detector remains intentionally unchanged from 2.1: Arid still finds exact normalized Python duplicate code and reports DUP001. V2.2 focuses on making the evidence Arid already produces substantially easier for developers to understand at a glance and easier for CI systems, tools, and coding agents to consume compactly.

This is an alpha release. The intended v2.2 functionality is code complete and has passed pre-publication source, real-world, performance, and supported-platform qualification. Published package and artifact behavior now needs validation before the release line advances toward beta.

What is new

Rich human scan summary

Normal text scans now end with an information-dense summary instead of the previous minimal duplicate totals.

The summary includes:

• files analyzed
• files with duplicates
• source lines
• analyzed lines
• duplicate groups
• total occurrences
• duplicate lines
• duplication percentage

Detailed scans also include fixed categorical breakdowns for:

• Context: executable, declarative, mixed
• Scope: function, module, class, mixed
• Distribution: cross-file, same-file, hybrid

The percentages in these tables describe group share only. They are not quality grades or severity scores.

Objective duplicate hotspots

Normal text output now includes the five files participating in the most reportable duplicate groups.

Hotspots are ranked deterministically by:

1. duplicate groups descending
2. occurrences descending
3. path ascending

A finding contributes at most one group count to a path even when that finding has multiple locations in the same file. Every reported location still contributes to the path's occurrence count.

Hotspots are intentionally descriptive rather than evaluative. Arid does not assign severity, health, or quality grades.

Concise --summary-only scans

--summary-only suppresses individual DUP001 finding blocks while preserving the same scan, filtering, metrics, worker behavior, and exit policy.

For human text output:

arid . --summary-only

prints the Summary, Breakdown, and Hotspots sections without detailed finding blocks.

For JSON:

arid . --summary-only --json

or:

arid . --summary-only --format json

emits the new compact summary-v1 machine contract instead of report-v4.

Markdown and SARIF are intentionally not primary --summary-only formats.

Supplemental reports remain full existing report formats. For example:

arid . \
  --summary-only \
  --report json=artifacts/full-report.json

prints the concise human summary while writing the complete report-v4 document to the supplemental file.

New deterministic summary-v1 contract

Compact machine-readable summaries use:

• schemas/summary-v1.schema.json

The contract includes:

• scan completeness and structured errors
• effective analysis metadata
• files analyzed
• files with duplicates
• source and analyzed lines
• duplicate groups
• total occurrences
• duplicate lines
• duplication percentage
• fixed Context counts
• fixed Scope counts
• fixed Distribution counts
• deterministic top-five hotspots

The summary is derived exactly once from the final typed report after baseline and focus filtering.

Worker count, elapsed timing, color state, terminal layout, and other runtime presentation details are intentionally absent.

Better GitHub Action outputs

The official GitHub Action now exposes three additional outputs:

• occurrences
• files-with-duplicates
• summary-json

summary-json follows the same logical summary-v1 contract as the CLI.

The Action still performs one Arid scan. The new outputs are derived from that same scan rather than by running the detector again.

Adaptive parallelism by default

Ordinary scans now use the same bounded automatic preparation-worker policy previously available through:

--workers auto

Therefore:

arid .

is equivalent in worker selection to:

arid . --workers auto

Automatic selection uses available parallelism clamped to the range 1..=4, with a fallback of 1 when available parallelism cannot be determined.

Explicit worker controls remain available:

--workers 1
--workers 2
--workers 4
--workers 8

Explicit numeric values are honored as requested and are not capped by the automatic-worker limit.

Parallelism remains limited to file preparation. Duplicate detection semantics and deterministic machine output are unchanged.

Compatibility

Arid 2.2 preserves the focused exact detector introduced before this release.

The following remain unchanged from 2.1:

• exact duplicate semantics
• DUP001
• finding fingerprints
• report-v4 schema and meaning
• baseline-v1 schema and meaning
• error-v1
• suppression-status-v1
• path-explanation-v1
• suppression semantics
• discovery semantics
• focus semantics
• baseline filtering semantics
• normalization semantics
• [tool.arid] behavior
• explicit --workers 1 behavior
• explicit numeric worker behavior
• --workers auto semantics
• ordinary scan exit meanings 0 / 1 / 2
• --no-fail-on-findings
• Markdown report semantics
• SARIF semantics
• supplemental --report semantics
• supported platform set

The intentional compatibility changes are:

• the normal human text footer is now the rich Summary + Breakdown + Hotspots presentation;
• the implicit worker default changes from serial execution to bounded automatic worker selection.

Pre-publication validation

Before this alpha, the v2.2 branch passed:

• the complete locked Rust test suite
• Clippy across all targets and features with warnings denied
• pinned Rust/rustfmt reproducibility checks
• Action and release Python unit tests
• locked release build qualification
• the complete inherited v2.1 validation suite
• the dedicated validation/v2.2.sh contract suite
• summary-v1 complete, zero-finding, and incomplete schema validation
• summary-only mode and output composition validation
• baseline and focus summary parity checks
• supplemental report-v4 preservation
• plain/color visible-text equivalence
• worker determinism checks
• real-world validation against Black, Django, mypy, and Rich
• Unicode, spaces, non-ASCII filename, relative-path, and source-location validation
• the full supported-platform non-publishing Release workflow matrix
• stable 2.1.0 → v2.2 performance qualification

The supported-platform workflow passed on:

• Linux x86-64
• Linux aarch64
• macOS aarch64
• macOS x86-64
• Windows x86-64

Performance qualification

The pre-publication performance campaign used two Hyperfine passes per corpus with reversed command order, three warmups per pass, and ten measured runs per pass.

Corpus	2.1 implicit	2.2 implicit	2.2 --workers 1	2.2 --workers auto	implicit change
requests	17.0 ms	16.4 ms	17.2 ms	15.0 ms	-3.6%
pydantic	251.2 ms	134.9 ms	244.9 ms	132.2 ms	-46.3%
polaris	521.4 ms	303.2 ms	518.8 ms	305.9 ms	-41.8%
duplicate-heavy	61.6 ms	39.2 ms	62.1 ms	42.1 ms	-36.3%

The explicit v2.2 serial path remained effectively at stable 2.1 performance, while the new implicit bounded automatic default materially improved medium, large, and duplicate-heavy workloads.

Install the alpha

With pip:

python -m pip install --pre "arid==2.2.0a1"
arid --version

Expected version output:

arid 2.2.0-alpha.1

The official GitHub Action can be pinned to the alpha tag:

- uses: sponge-b0b/arid@v2.2.0-alpha.1
  with:
    paths: .

What to test

Useful alpha feedback includes:

• whether the rich Summary makes large scans easier to interpret
• whether Context, Scope, and Distribution breakdowns surface useful duplicate patterns
• whether Hotspots identify the files developers naturally inspect first
• --summary-only in local development, CI logs, and coding-agent workflows
• parsing and schema assumptions for summary-v1
• summary determinism across worker modes
• baseline and focus interactions with summary metrics and hotspots
• GitHub Action consumption of occurrences, files-with-duplicates, and summary-json
• automatic worker behavior on machines with different available parallelism
• confirmation that explicit --workers 1 remains a reliable serial escape hatch
• platform-specific packaging, PyPI installation, standalone binaries, and the GitHub Action

Detector-semantic regressions remain important: equivalent 2.1 and 2.2 scans with equivalent analysis settings should identify the same exact normalized duplicate code.

Known release stage

This alpha freezes summary-v1, hotspot ranking and top-five semantics, and summary-only JSON behavior for the 2.2 release line.

Product fixes are allowed during prerelease stabilization. New product scope is not. Any incompatible correction to the published summary-v1 contract requires an explicit versioned contract decision rather than silent schema mutation.

v2.1.0

Arid 2.1.0 — Auditable Maintenance

Arid 2.1 makes maintenance and discovery decisions auditable without changing the detector itself.

Auditable maintenance. Explainable discovery. Same focused detector.

Arid still finds exact normalized Python duplicate code and reports DUP001. V2.1 adds suppression lifecycle auditing, stale-maintenance enforcement, targeted path explanation, an ignore-file traversal override, deterministic administrative machine contracts, and a concise human-facing total scan-time footer around that same detector.

Highlights

Suppression lifecycle auditing

--suppression-status audits every effective Arid suppression region and classifies it as exactly one of:

• active — removing the suppression would expose otherwise-reportable duplicate code or allow a duplicate to cross the suppression boundary
• stale — the suppression is no longer needed under the current analysis settings

arid . --suppression-status
arid . --suppression-status --json

Suppression directives are idempotent state setters:

• # arid: disable while already disabled is a valid no-op
• # arid: enable while already enabled is a valid no-op
• # arid: disable through EOF is valid and does not require a matching enable

The audit uses one suppression-disabled preparation view and one normal detector pass rather than rerunning duplicate detection once per region.

Stale-maintenance enforcement

--fail-on-stale can turn obsolete accepted state into exit status 1 for both suppression and baseline maintenance:

arid . --suppression-status --fail-on-stale
arid . --baseline-status arid-baseline.json --fail-on-stale

This supports a maintenance ratchet of:

zero new duplication + zero obsolete suppression

Existing baseline comparison, pruning, serialization, fingerprints, and baseline-v1 compatibility remain unchanged.

Explainable discovery

--explain-path <PATH> explains why one path is included or excluded by the effective Arid discovery policy:

arid . --explain-path src/generated/example.py
arid . --explain-path src/generated/example.py --json

Path explanation reuses the same discovery policy as real traversal. It does not parse Python, run duplicate detection, or recursively enumerate a directory tree merely to explain one target.

The deterministic path-explanation-v1 contract reports the path, kind, symlink/explicit state, include/exclude decision, and stable reason vocabulary.

Ignore-file traversal override

--no-ignore-files disables ignore-file-derived filtering for one invocation:

arid . --no-ignore-files
arid . --list-files --no-ignore-files

It bypasses ignore-file sources such as .ignore, .gitignore, global Git ignores, parent ignore files, and .git/info/exclude.

It does not bypass Arid's own configured/CLI exclude rules, hidden-path policy, .py / .pyi source selection, or symlink policy.

Deterministic administrative JSON

V2.1 adds two versioned machine contracts:

schemas/suppression-status-v1.schema.json
schemas/path-explanation-v1.schema.json

Both administrative modes can write direct JSON files with:

--report json=PATH

For the same invocation, JSON stdout and the direct administrative JSON file are rendered from the same typed model and are byte-equivalent.

The existing 2.0 machine contracts remain unchanged, including:

• report-v4
• error-v1
• baseline-v1
• capabilities-v1
• finding fingerprint identity
• SARIF 2.1.0 integration

Human-facing total scan time

Completed normal text scans now end with a concise timing footer:

Total time: 18.7 ms

Timing is deliberately presentation-only.

It is absent from:

• JSON
• Markdown
• SARIF
• supplemental report files
• exit-2/incomplete output
• report-v4 and every other versioned machine contract

The footer uses adaptive microsecond, millisecond, or second units and does not introduce a profiling, telemetry, or per-stage timing framework.

Compatibility with Arid 2.0

V2.1 is additive and preserves the qualified 2.0 detector and contracts.

Unchanged behavior includes:

• exact normalized duplicate semantics
• DUP001
• report schema v4
• finding fingerprints
• baseline schema v1 and existing baseline files
• error schema v1
• normal suppression effect
• normalization semantics
• [tool.arid] configuration
• normal CLI invocation
• serial default execution
• numeric --workers N
• --workers auto
• ordinary scan exit meanings 0 / 1 / 2
• supported release platforms

The new CLI controls are:

--suppression-status
--fail-on-stale
--explain-path <PATH>
--no-ignore-files

The only intentional ordinary text-output addition is the Total time: footer on completed normal text scans.

Qualification

Arid 2.1 was qualified through source, prerelease, published-artifact, real-world, and performance validation.

The release line passed:

• the full inherited v2 integration suite
• the focused v2.1 suppression, stale-policy, discovery, path-explanation, administrative-output, and timing suite
• Black, Django, mypy, Rich, Unicode/space-path, malformed-source, and worker-determinism validation
• the production release build matrix on Linux x86-64, Linux aarch64, macOS arm64, macOS x86-64, and Windows x86-64
• exact published GitHub standalone validation
• exact published PyPI installation validation
• suppression-status-v1 and path-explanation-v1 schema validation against published executable output
• administrative JSON stdout/direct-file byte-equivalence validation

The published 2.1.0-beta.1 artifact also passed the full real-world detector campaign directly, rather than only a repository build.

A disposable real-Polaris-layout beta exercise verified:

• one suppression around a real Polaris duplicate classified active
• one deliberately unnecessary disable-through-EOF suppression classified stale
• suppression JSON was byte-deterministic across workers 1 and 4
• --fail-on-stale enforced stale maintenance with exit 1
• an ignored Python path was explained as ignore-file
• repeated path explanation was byte-deterministic
• --no-ignore-files made the ignored Python path includable
• --explain-path agreed with actual --list-files traversal
• normal text contained exactly one Total time: footer
• machine JSON remained timing-free

No product, packaging, machine-contract, or detector-semantic defect was found during beta stabilization.

Performance

The final release qualification compared the published Linux x86-64 2.0.0 artifact directly against the published Linux x86-64 2.1.0-beta.1 artifact on the same machine, using the same pinned Requests, Pydantic, and Polaris corpora with Hyperfine.

Corpus       v2.0.0       v2.1 beta    Delta
requests      17.08 ms      16.57 ms    -3.03%
pydantic     239.69 ms     238.80 ms    -0.37%
polaris      503.95 ms     503.59 ms    -0.07%

No measurable performance regression was found.

Install

With uv:

uv tool install "arid==2.1.0"
arid --version

Or with pip:

python -m pip install "arid==2.1.0"
arid --version

Expected output:

arid 2.1.0

Official GitHub Action

- uses: sponge-b0b/arid@v2.1.0
  with:
    paths: .

The tagged Action installs the exact released PyPI package version encoded in its release metadata.

Machine-readable contracts

Published Arid-owned schemas are under schemas/:

• report-v4.schema.json
• error-v1.schema.json
• capabilities-v1.schema.json
• baseline-v1.schema.json
• suppression-status-v1.schema.json
• path-explanation-v1.schema.json

Arid 2.1 keeps duplicate detection focused and familiar while making accepted duplication state maintainable, filesystem discovery explainable, automation contracts deterministic, and normal scan speed visible to humans.

v2.1.0-beta.1

Arid 2.1.0-beta.1 — Auditable Maintenance Beta

Arid 2.1.0-beta.1 marks the feature-freeze point for the Arid 2.1 release line.

The detector remains intentionally unchanged from 2.0: Arid still finds exact normalized Python duplicate code and reports DUP001. V2.1 adds auditable suppression maintenance, explainable discovery, stale-maintenance enforcement, and a human-facing total scan-time footer around that same detector.

This beta is for broader real-world and integration validation before release-candidate qualification. New product features are not planned after this point. Fixes are limited to correctness defects, compatibility regressions, deterministic-output defects, platform inconsistencies, documentation defects, or release-process defects inside the approved v2.1 contract.

What is frozen

The beta carries forward the complete v2.1 surface introduced in alpha.1:

• --suppression-status with deterministic active / stale classification
• idempotent suppression directives
• valid # arid: disable through EOF
• --fail-on-stale for suppression status and baseline status
• --explain-path <PATH> using the same effective discovery policy as real traversal
• --no-ignore-files for bypassing ignore-file-derived filtering without bypassing Arid exclude, hidden-path, source-type, or symlink policy
• suppression-status-v1
• path-explanation-v1
• direct administrative --report json=PATH output rendered from the same typed model as JSON stdout
• the always-on human-facing Total time: footer for completed normal text scans
• timing excluded from JSON, Markdown, SARIF, supplemental report files, and all versioned machine contracts

The existing 2.0 contracts remain unchanged, including report-v4, error-v1, baseline-v1, capabilities-v1, finding identity, ordinary exit meanings, normalization behavior, and duplicate semantics.

Alpha qualification results

The published 2.1.0-alpha.1 release passed the complete pre-publication and published-artifact qualification path.

Before publication, Arid passed:

• the full inherited v2 integration suite
• the focused v2.1 suppression, stale-policy, discovery, path-explanation, administrative-output, and timing suite
• Black, Django, mypy, Rich, and Unicode/space-path real-world validation
• Django worker determinism at workers 1, 2, 4, and 8
• malformed-source validation
• a v2.0.0 → v2.1 performance regression comparison on Requests, Pydantic, and Polaris with no measurable regression
• the production release build matrix on Linux x86-64, Linux aarch64, macOS arm64, macOS x86-64, and Windows x86-64

After publication, both the exact GitHub Linux x86-64 standalone artifact and the exact PyPI arid==2.1.0a1 installation passed the full durable validation/v2.1.sh contract suite.

Published-artifact validation confirmed:

• the new CLI controls execute correctly
• normal text scans display exactly one Total time: footer when appropriate
• exit-2, JSON, Markdown, SARIF, and supplemental reports remain timing-free
• suppression-status-v1 and path-explanation-v1 outputs validate against the tagged schemas
• administrative JSON stdout and direct JSON report files are byte-equivalent

No detector-semantic regression or material performance regression was found during alpha qualification.

Suppression lifecycle maintenance

--suppression-status treats effective suppression regions as lifecycle state rather than permanent lint graffiti.

Each effective region is exactly one of:

• active — removing the suppression would expose otherwise-reportable duplicate code or allow a duplicate to cross the suppression boundary
• stale — the suppression is no longer needed under the current analysis settings

Repeated same-state directives are valid no-ops, and # arid: disable through EOF is valid without a matching # arid: enable.

--fail-on-stale can turn stale suppression or baseline state into exit status 1, supporting a maintenance ratchet of:

zero new duplication + zero obsolete suppression

Explainable discovery

--explain-path <PATH> explains one inclusion or exclusion decision without parsing Python, running duplicate detection, or recursively tracing a directory tree.

--no-ignore-files disables ignore-file-derived traversal filtering for one invocation while preserving Arid's own exclusion policy, hidden-path behavior, source-type selection, and symlink policy.

Together these controls make discovery decisions inspectable without introducing a second discovery implementation.

Human-facing timing

Completed normal text scans include a concise footer such as:

Total time: 18.7 ms

Timing is presentation-only. It is intentionally absent from deterministic machine contracts and does not change report-v4 or any other versioned schema.

Install the beta

With uv:

uv tool install --prerelease allow "arid==2.1.0b1"
arid --version

Or with pip:

python -m pip install --pre "arid==2.1.0b1"
arid --version

Expected version output:

arid 2.1.0-beta.1

Official GitHub Action

For this beta:

- uses: sponge-b0b/arid@v2.1.0-beta.1
  with:
    paths: .

The release workflow verifies the published Action against the exact PyPI package version encoded in the tagged Action metadata.

What to test

Beta feedback should focus on defects and integration friction in the frozen v2.1 surface, especially:

• active/stale suppression classification on real repositories
• stale-policy enforcement in CI
• ignore-file and Arid-exclude interactions
• path explanation in monorepos and unusual repository layouts
• symlink and hidden-path behavior
• direct administrative JSON output
• machine-contract determinism
• timing-footer presentation across normal text scans
• absence of timing from machine-oriented output
• compatibility with existing report-v4 and baseline-v1 consumers
• platform-specific installation, packaging, and GitHub Action behavior

Any change to suppression-status-v1 or path-explanation-v1 after this point requires an explicit versioned contract decision rather than silent schema mutation.

Next steps

After beta publication, Arid 2.1 enters real-world beta stabilization. The release candidate will be prepared only after published beta artifacts pass the real-world validation campaign, machine contracts remain stable, ordinary detector behavior continues to match 2.0 expectations, timing behavior remains correct, and no material unexplained performance regression appears.