v1.16.1

1.16.1 - 2026-10-01

• CI and publication read the Bun version from package.json. Bundle builds
  reject mismatched Bun runtimes before writing output. This release supersedes
  the unpublished 1.16.0 tag, whose gate rejected a bundle built with another Bun version.

• Bounded evidence scheduling, source selection, local discovery and ecosystem
  acquisition are separated from one common secure remote artifact reader.
  Successful Go, Nix, Zig and Hex integrity checks are retained in artifact receipts.

• Cancelled replay saves no snapshot; replay accepts the supported two MiB
  license-file bound while retaining the overall snapshot size limit.

• Inspection execution, shared scan result summaries, HTML markup and browser
  filtering have separate module owners while retaining existing report contracts.

• A bounded offline benchmark compares cold, warm and offline artifact caches
  in fresh processes, measuring collection, nested gzip decompression, license
  normalization, rendering and peak memory without external network traffic.

• Scan and CI save bounded inspection snapshots and replay their graph and
  extracted evidence under current policies without artifact collection or
  network access. Input and payload digests, rule versions, artifact receipts,
  production-only scope and repository coverage survive offline reevaluation.

• Evidence collection can capture bounded content receipts separately from
  successful declared-integrity checks, including cache, revalidation, network
  and local retrieval. Requested HTTP origins omit credentials, query and fragment.

• Yarn classic inputs receive a bounded token preflight before the external
  parser, rejecting unterminated strings and accepting end-of-file comments
  without entering the dependency's unbounded lexer loops.

• Parser boundary tests cover all registered input kinds with bounded seeded
  mutations, structural graph invariants, and retained synthetic failure inputs
  for deterministic reproduction. Archive readers use the same seeded corpus
  under explicit entry and decompression limits.

• --require-complete-graph and the corresponding Action input independently
  gate scan, CI, and both diff revisions on known dependency relationships.
  Partial-evidence overrides cannot bypass this requirement. Report schema 3.9
  exposes the graph gate in JSON, SARIF and CycloneDX; human reports and step
  summaries preserve the outcome.

• Review decisions use package coordinates, usage profile, production-only
  selection, and dependency type/scope independently of display paths. New
  decisionFingerprint waivers opt into this bounded identity; legacy ID and
  fingerprint waivers retain their existing scope. Diff and baseline checks use
  decision keys when present, while provenance-only changes remain visible
  without introducing risk. Report schema 3.8 and waiver/baseline schema 1.1
  describe this contract. Older baselines remain readable without automatic
  conversion of their reviewed keys; report-configuration changes require review.

• Adapters declare relationship reconstruction, development-scope detection
  and retained artifact pins for every supported input kind. Report schema 3.7
  exposes the support boundary separately from actual inspection completeness
  in scan/diff JSON, SARIF and CycloneDX; scan summaries show it as well. A
  generated support matrix stays synchronized with registered adapters. Baseline
  schema configuration changes require review; summaries still accept 3.5/3.6.

• Finding decisions ignore ordinary evidence-source labels and file renames
  while retaining license meaning, confidence, scope, component terms and
  conflicts. Waivers, diffs and packaged baselines share comparison with older
  semantic fingerprints; opaque legacy fingerprints remain exact. Dependency
  path changes still require review through the existing finding IDs.

• SBOM imports preserve public PURL qualifiers and subpaths in package identity,
  preventing architecture, distribution, and file-specific coordinates from
  collapsing into one finding. Qualifier order is canonical; authentication
  material is omitted from public identity and reports. Unqualified IDs are
  unchanged; waivers for previously collapsed qualified packages require review.

• Held-out release evaluation requires reviewed SPDX semantics, choices,
  exceptions, evidence signals, and package/component scope in addition to
  severity and confidence. Reports distinguish semantic mistakes, risk under-
  and over-classification, and decisions deferred for insufficient evidence.

• npm, pnpm, and uv source edges and reachable package records survive bounded
  display-path truncation. Independent source traversal retains cycles and
  scoped relationships, reports missing pnpm/uv records, and fails explicitly
  at graph resource limits. npm v1 inferred roots and opaque pnpm links remain
  distinguishable from proven complete relationships.

• npm v1 and modern lockfiles retain missing required dependency requests and
  mark name-based installation recovery unproven. These requests survive graph
  merging, input reordering, and bounded display paths, and make CI and gated
  diffs partial even when no package evidence fetch failed. Optional dependencies
  and optional peers may be absent; production scans exclude development-only
  missing requests.

• Inspection completeness separates input, dependency relationships, evidence
  collection, and license identification. JSON scan and diff sides share the
  same contract, with matching state in SARIF and CycloneDX metadata.

• Merged package artifacts no longer select the first input when locations or
  checksums conflict. Unresolved identities are unavailable evidence and produce
  a structured artifact_identity_conflict diagnostic, so strict CI and diff
  gates reject them. Equal supported digest encodings permit deterministic
  mirror collection with normal archive integrity verification.

• Release verification uses the global 82% line and 90% function coverage gate
  consistently across Bun versions. Installed package smoke tests check the
  current report schema 3.9 exports.

• Mixed-ecosystem scans and SBOM inputs now keep packages with the same name
  and version separate, including their paths, license evidence, and findings.
  Existing waivers for formerly colliding package IDs require review.

• npm lockfile resolution checks every ancestor installation before selecting
  a hoisted root package, including scoped packages and npm aliases.

• Gated diffs reject incomplete evidence from either revision unless explicitly
  allowed. Report schema 3.6 records each side's completeness and gate status;
  report summaries retain partial comparison failures.

• The bundled GitHub Action forwards allow-partial-evidence for ci and
  diff, and its documentation describes informational and gated comparisons.

• CycloneDX, SPDX, and Nix inputs retain source dependency edges independently
  of bounded display paths. CycloneDX output distinguishes unknown adjacency
  from explicit leaves, including XML composition declarations. Production
  filtering preserves reachable packages when their saved display paths omit
  the production route.

v1.15.2

1.15.2 - 2026-08-27

• pnpm lockfiles split across multiple YAML documents are now merged without
  dropping importer, package, or snapshot data. Ohrisk accepts compatible
  split importer declarations while conflicting dependency values and
  lockfile versions remain fail-closed.

• Package-scoped MIT-CMU inventories such as Pillow's root license now retain
  the package license ahead of later bundled component notices, avoiding false
  conflicting-evidence findings without suppressing those component terms.

• Concurrent packages pinned to the same Cargo GitHub commit now share one
  checksum-verified archive fetch and index operation instead of repeating the
  same immutable-source work for every package.

• Nix flake.lock inputs may collect root legal files from exact NixOS nixpkgs
  release nixexprs.tar.xz archives under both /nixpkgs/... and
  /nixos/<channel>/... layouts. Ohrisk requires a full commit, matching
  12-character release path, canonical narHash, fixed NixOS host, XZ output
  capped at 320 MiB and 100,000 entries, and a matching extracted NAR tree
  before trusting the evidence. XZ output streams through a uniquely named
  temporary TAR file opened with exclusive creation and restricted mode where
  supported; it is removed on success and failure, avoiding complete decompressed
  archive retention in memory.

• Checksum-identified Go module ZIPs may verify up to 65,535 entries and 512 MiB of expanded
  content without retaining unrelated source files. Per-entry, compression-ratio,
  CRC, work, and cancellation limits remain fail-closed, while retained license
  and go.mod evidence stays capped at 34 MiB.

• Checksum-verified Cargo crates now honor an explicit README declaration that
  offers MIT or Apache-2.0 at the user's option. Matching LICENSE-MIT and
  LICENSE-APACHE files no longer produce a false conflicting-evidence finding,
  while narrower -only metadata still conflicts with broader -or-later text.

• A license file that explicitly declares the package as a whole under MIT now
  keeps that package scope ahead of later contributor-only Apache terms, avoiding
  false conflicts for crates such as libm.

• Standard Maven names used by Apache, Hamcrest, HdrHistogram, and JTS now
  normalize to their SPDX expressions instead of producing malformed-license
  findings.

• Yarn Berry cache checksums are now preserved separately from npm tarball
  integrity, so unavailable evidence explains the verification boundary and
  recovery path instead of claiming the lockfile contains no checksum.

• SPDX identifier lines wrapped in Markdown inline-code delimiters now discard
  the closing delimiter before expression parsing, avoiding false conflicts for
  dual-licensed modules such as github.com/DataDog/dd-trace-go/v2.

• SPDX Creative Commons Attribution licenses such as CC-BY-3.0 are now
  attribution review findings instead of unrecognized-license findings.

• Multiple recognized license files no longer conflict when one metadata
  classifier covers every file choice. Named sibling files such as
  LICENSE_zstd.txt are now treated as bundled-component evidence while
  standard LICENSE-MIT, LICENSE-APACHE, and BSD alternatives remain
  package-license choices.

• License-file recognition now handles the parenthetical notice wording used
  by common MIT packages, explicit BSD one-clause and alternate three-clause
  wording, and the bzip2 grant without reporting false metadata conflicts.
  Canonical MPL 2.0 text is also compatible with an MPL-2.0+ declaration,
  and bzip2-1.0.6 is classified as permissive.

• Common Python metadata aliases PSFL and BSD 3-Clause License now
  normalize to PSF-2.0 and BSD-3-Clause. Canonical GNU version text no
  longer conflicts with matching -or-later package metadata, while the
  narrower metadata / broader file direction remains fail-closed.

• Modern uv.lock files may omit versions for editable workspace packages.
  Ohrisk now accepts those records only for project-contained local sources,
  validates their local package metadata, collects bounded license evidence,
  and uses 0.0.0+local as a stable report identity when the project version
  is dynamic. Versionless remote records still fail closed.

• SPDX TCL and WTFPL expressions are now classified as permissive
  low-risk licenses under both profiles. Distributed TCL packages retain
  the normal license-text obligation, while WTFPL does not invent one.

• BSD 3-clause license files whose endorsement condition says Neither the name Example instead of Neither the name of Example are now recognized
  correctly. A license file that explicitly scopes those terms to
  auto-generated bindings is retained as bundled-component evidence instead
  of conflicting with the package declaration, fixing
  zstd-sys@2.0.16+zstd.1.5.7.

• Canonical MIT license files that use typographic quotes around “AS IS”
  are now recognized like their ASCII-quoted form, removing false missing
  findings for modules such as github.com/felixge/fgprof@v0.9.5.

• SPDX BSL-1.0 and Unicode-DFS-2016 are now classified as permissive
  low-risk licenses under both profiles instead of falling through to
  unknown. This fixes false unknown findings for crates such as
  clipboard-win, error-code, and unicode-ident.

• Root legal files that explicitly declare the package as dual-licensed under
  MIT and Apache-2.0 now keep that package-level choice when a later section
  carries a BSD-3-Clause notice scoped to one source file. This removes false
  conflicting-evidence findings for crates such as minimal-lexical@0.2.1
  without relaxing ordinary metadata-versus-license-file conflicts.

• Nix flake.lock public GitHub inputs now preserve a full locked commit and
  SHA-256 narHash, fetch only the exact fixed-host codeload archive after local
  evidence is unavailable, and trust root legal files only after a bounded
  extracted source tree matches Nix Archive serialization. Short revisions,
  malformed hashes, custom hosts, unsupported archive shapes, and hash
  mismatches remain fail-closed.

• Modern Elixir mix.lock public hexpm records now preserve the outer
  tarball SHA-256 and fetch the exact package from repo.hex.pm when local
  deps/ evidence is unavailable. The outer archive checksum, Hex v3 inner
  checksum, metadata name/version, nested archive bounds, and license files are
  verified before evidence is trusted; private and hashless records stay local-only.

• Haskell Stack locks now preserve the completed Hackage Cabal-file SHA-256
  and use it to verify exact remote .cabal license metadata when no local
  package database evidence is available. Host, response-size, UTF-8, package
  identity, and checksum validation remain fail-closed. When the current public
  Cabal file differs, Ohrisk checks at most 64 numbered historical revisions
  and trusts only the revision matching the completed lock checksum.

• Cabal's legacy BSD3 license value is normalized to SPDX BSD-3-Clause
  instead of being reported as malformed.

• Qualified sibling files such as LICENSE.libyaml are now treated as bundled
  component licenses when a primary LICENSE exists beside them. Their
  obligations are combined with SPDX AND instead of producing a false
  package-license conflict.

• THIRD_PARTY_LICENSES* inventories beside a primary license are likewise
  treated as cumulative bundled-component evidence, preventing their contents
  from creating false package-license conflicts.

• Cargo root path dependencies contained by the workspace are now treated as
  implicit workspace members even when omitted from the explicit members
  list, while exclude entries remain authoritative. This restores license
  metadata for internal crates such as Nushell's nu-glob and nu-path.

• Cargo workspace packages now inherit version and license from
  [workspace.package] when their member manifests opt in with
  version.workspace = true and license.workspace = true, eliminating
  false unknown findings for internal crates in repositories such as Ruff.

• Cargo workspace and contained path packages now collect member-root legal
  files, with a workspace-root fallback when the member has none. Git-ref
  baselines use the same bounded snapshot evidence, eliminating false
  unknown findings such as watt@1.4.0 without trusting same-name registry
  artifacts.

• Cargo Git dependencies pinned to a full GitHub commit now collect bounded
  codeload archive evidence after single-root and unique Cargo.toml
  name/version validation. Mutable, credentialed, non-GitHub, path, and
  ambiguous sources remain unavailable. Git legal-file symlinks are resolved
  only to regular entries contained by the same immutable archive root; other
  links are never materialized.

• Localized HTML reports no longer leave the conflicting-license review action
  in English across Korean and the other supported report languages.

• Public repository scans now read Go local replacement evidence only from
  real paths contained by the validated checkout. Internal submodules without
  legal files of their own inherit bounded root-module license evidence,
  avoiding misleading unknown results for repositories such as Terraform
  without enabling general temporary-checkout package or vendor discovery.

v1.14.1

1.14.1 - 2026-07-28

• Corrected license evidence classification for GNU-family full texts, FreeType
  dual-license declarations, and legacy Python wheels. GPLv3 texts that mention
  AGPL compatibility no longer become AGPL findings; FreeType declarations are
  preserved as FTL OR GPL-2.0-or-later and FTL is treated as permissive; and
  declared .dist-info/LICENSE files can override conflicting legacy PyPI
  classifiers after the verified wheel is inspected, while multiple distinct
  recognized license files now fail closed as conflicting evidence. Report
  evidence labels classifier-derived values as classifiers rather than declared
  metadata licenses. The report schema is now 3.5.0 for the new
  conflicting-evidence signal.

v1.14.0

1.14.0 - 2026-07-27

• Added Zig build.zig.zon dependency manifest support. Ohrisk parses
  .dependencies entries with url/hash and path fields, classifies
  them as zig ecosystem dependencies, and collects license evidence from
  local path dependencies and remote tarballs. Remote URL dependencies are
  downloaded, decompressed, and the Zig package hash is computed via
  per-file SHA-256 (normalized path + [0,0] + contents) then overall
  SHA-256 of concatenated per-file hashes. The .paths field in
  build.zig.zon is respected so only declared files contribute to the
  hash, matching zig fetch behavior. Old multihash (1220 + SHA-256
  hex) and new name-version-hashplus formats are both verified. New hashes
  recover the package ID from the fingerprint field in build.zig.zon,
  while manifestless tarballs use Zig's exact N-V placeholder and reserved
  package ID. PAX global metadata headers are handled like zig fetch, and
  license files (LICENSE, COPYING, NOTICE, etc.) are extracted only from the
  verified tarball.

v1.13.0

1.13.0 - 2026-07-22

• Added exact pub.dev archive evidence for modern pubspec.lock hosted records.
  Ohrisk now uses the lockfile SHA-256 against the fixed pub.dev archive URL,
  verifies the complete download and pubspec.yaml package identity, and reads
  bounded root license files. Custom hosted registries, Git/path sources, and
  hashless legacy lock records remain unavailable instead of being redirected
  to pub.dev.
• Resolved Maven property expressions in project, dependency, and
  dependencyManagement coordinates. Large reactor builds such as Apache Spark
  now match inherited managed versions under their concrete Scala artifact
  names instead of reporting a missing version for the literal ${...} name.
• Added exact public nuget.org evidence after local NuGet cache lookup. Ohrisk
  discovers V3 endpoints from the service index, selects the normalized locked
  version, requires the selected dependency input SHA-512 to match the catalog
  SHA-512, verifies that digest and byte size against the downloaded NUPKG,
  checks package and structurally parsed nuspec identity, and reads bounded
  license evidence. Inputs without a package hash, private feeds, arbitrary
  license URLs, credentials, and cross-host redirects remain outside the adapter
  boundary, while the complete metadata and package chain is reusable from the
  artifact cache in offline mode. Hashless-input warnings now distinguish
  repository URLs from local checkouts and give the matching lockfile or restore
  remediation without weakening the package-integrity requirement.

v1.12.0

1.12.0 - 2026-07-21

• Resolved exact Maven Central parent and imported-BOM POMs when a filesystem
  scan or ci input needs external dependencyManagement versions. Model
  resolution is identity-checked, cached, offline-capable, limited to 32 remote
  POMs of at most 2 MiB each and eight parent/BOM levels, and remains fail-closed
  when the complete model cannot be proven.

• Preserved standard Fetch Response fields while normalizing manually handled
  redirects, so injected or adapter-provided Fetch responses retain their status,
  headers, body, and cache metadata.

• Used package license declarations embedded in composer.lock as local
  evidence. Composer repository scans no longer report every package as
  unknown merely because vendor/ is absent and remote Packagist evidence is
  intentionally unavailable.

• Skipped unresolved vcpkg.json manifests and unpinned Conda environment
  files during repository-wide automatic discovery while preserving strict
  validation for explicit --lockfile selection. Partial native or
  environment manifests no longer abort concrete sibling dependency projects.

• Rendered structured error-detail arrays as JSON values instead of JavaScript
  object coercions such as [object Object], including missing Maven
  parent/BOM diagnostics.

v1.11.1

1.11.1 - 2026-07-20

• Allowed nested uv.lock projects in repository-wide scans to resolve sibling
  local directory sources inside the validated repository root while continuing
  to reject paths that escape it.
• Added checksum- and identity-verified remote crates.io evidence for Cargo
  lockfiles. Registry crates now use the exact Cargo.lock SHA-256 against a
  fixed static.crates.io archive before trusting Cargo.toml license metadata
  or package license files; Git, path, alternate-registry, and checksumless
  crates remain unavailable.
• Terminated timed-out Git clones as complete process trees, including Windows
  remote helpers and pack workers, with a bounded completion fallback. Large
  asset repositories no longer leave git-remote-https or index-pack
  workers behind after the clone deadline.
• Ignored tool-only or otherwise unresolved pyproject.toml,
  requirements.txt, and Gradle version catalog files during automatic
  discovery while preserving explicit --lockfile validation. Concrete sibling
  inputs can now scan without an unrelated formatter-only, range-only Python,
  or partially resolved catalog file aborting the merged project.
• Raised the independently byte-bounded GitHub checkout tree ceiling from
  50,000 to 100,000 entries so large source monorepos remain scannable while
  retaining per-file, total-tree, projected-staging, and final-staging limits.
• Bounded pnpm workspace dependency paths to 64 per package with a typed
  truncation diagnostic. Highly connected workspaces no longer materialize
  millions of equivalent paths and exhaust the Node.js heap during risk
  evaluation.
• Coalesced automatic artifact-cache LRU maintenance into one bounded sweep
  after evidence collection. Large scans no longer launch a complete cache
  inventory and prune after every metadata or tarball write, and simultaneous
  processes coordinate through an atomic maintenance lease and cooldown.
• Applied the configured package-request timeout to initial DNS and SSRF
  preflight resolution. A stalled artifact hostname now becomes unavailable
  evidence for that package instead of permanently consuming an evidence worker
  during large remote scans.

v1.11.0

1.11.0 - 2026-07-20

• Large standalone HTML reports now derive search text from visible cards at
  runtime and encode long fingerprints through shared string and path-prefix
  dictionaries. Expanding a fingerprint reconstructs the exact canonical value,
  preserving waiver compatibility while substantially reducing large-monorepo
  report size.

• Go module ZIP fetching now retries one narrowly classified transient response
  or non-timeout network failure. Permanent responses, full timeouts, security
  rejections, and integrity failures are never retried, while a recovered
  artifact enters the existing verified cache.

• Added checksum-verified Go module ZIP license evidence through the fixed
  public Go proxy. Ohrisk now requires the exact go.sum h1 checksum,
  validates the complete module ZIP and requested module/version root, and
  inspects only root license files without forwarding npm credentials.

• Go 1.17 and later scans now use the complete go.mod requirement graph and
  treat go.sum as a checksum ledger, avoiding historical module downloads that
  previously made large repositories such as Signoz time out.

• The bounded ZIP reader now accepts signed data descriptors and exact empty
  deflate streams used by real Go module archives while rejecting descriptor
  drift, overlaps, malformed archives, and unsupported unsigned descriptors.

• Redirect diagnostics now omit query strings and fragments so signed artifact
  URLs cannot leak through errors.

• Large npm monorepo scans now use exact registry SPDX metadata for transitive
  packages, while direct packages and missing or non-SPDX declarations retain
  integrity-verified tarball inspection. JSON evidence summaries expose the
  new registry source instead of mislabeling metadata-only results.

• Modern package locks now provide valid embedded SPDX license fields
  before remote collection, eliminating thousands of redundant registry calls
  in large npm workspaces while retaining artifact fallback for missing,
  conflicting, or non-SPDX declarations.

• Transitive npm Git sources no longer fall through the registry metadata
  optimization, preventing a VCS artifact integrity hash from being compared
  against unrelated same-name registry tarball bytes.

• Advanced the strict report schema to 3.4.0 for the explicit registry
  evidence-source count.

• .csproj scans now retain exact PackageDownload dependencies and resolve
  exact ranges that reference one unconditional same-file property, covering
  Microsoft UI XAML-style build projects without guessing conditional MSBuild
  evaluation.

• Remote GitHub scans now skip symbolic-link entries without following their
  targets, remove their checkout materializations before project discovery,
  and report bounded incomplete-coverage metadata instead of rejecting the
  entire repository.

• Regular files with Windows-reserved or colliding non-portable paths are
  excluded through a NUL-delimited literal Git pathspec before checkout and
  reported separately, while structural traversal and .git paths still fail.

• Raised the bounded remote tree aggregate ceiling from 256 MiB to 640 MiB and
  the independent temporary staging cap from 512 MiB to 1 GiB while retaining
  a 100 MiB per-blob ceiling and the existing 50,000-entry limit.

• Bounded Cargo dependency provenance to 64 paths per crate with iterative
  traversal and typed truncation diagnostics, preventing combinatorial graph
  expansion on large workspace lockfiles while retaining every reachable crate.

• Applied the same 64-path iterative traversal boundary to modern npm
  package-lock/shrinkwrap graphs, preventing large web workspaces from
  exhausting memory while retaining every reachable package.

• Applied the same 64-path iterative traversal boundary to uv.lock graphs and
  stopped duplicating full finding IDs and fingerprints in HTML search data.
  Large Python dependency fan-out now retains every reachable package while
  producing bounded reports while keeping the complete bounded fingerprint
  visible. Existing uv.lock waivers keyed to an identity containing more than
  64 paths must be reviewed because the bounded identity is intentionally
  different from the former unbounded value.

• Split the former shared two-minute clone/inspection/checkout deadline into
  bounded per-stage budgets: two minutes for clone, 30 seconds for tree
  inspection, and three minutes for checkout. This prevents a valid large clone
  from consuming the Windows materialization budget before checkout starts.

• Replaced the 250 ms full-directory walk during checkout with a pre-checkout
  projected-size gate and one post-checkout size verification, preventing the
  resource monitor from dominating large monorepo materialization time.

• Added fail-closed regression coverage for traversal paths, unexpected
  directory materializations, path-list bounds, and PostHog-style internal
  symbolic links alongside ordinary dependency inputs.

• Replaced the exhaustive NO_SUPPORTED_LOCKFILE dump with a concise
  distinction between a repository that has no dependency project and a
  manifest that is missing a supported lockfile.

• uv.lock remote Git sources whose resolved URL ends in a full immutable
  commit are now retained in the dependency graph as unavailable evidence
  instead of aborting the scan. Ohrisk does not clone those package sources or
  substitute same-name PyPI evidence; unresolved, branch, tag, and short-revision
  records still fail closed.

• A checksum-verified remote Python distribution that exceeds bounded archive
  inspection limits now becomes unavailable evidence for that package instead
  of aborting a large multi-ecosystem scan. The archive limit is unchanged and
  no bytes from the rejected distribution are trusted.

• Remote repository discovery now merges bounded independent nested dependency
  projects into one repository-wide graph, preserving lockfile provenance and
  deduplicating packages by Package URL. Automatic fan-out is capped at 64
  project roots and 128 inputs; --lockfile remains an explicit narrowing
  control for Ente-style monorepos.

• Automatic repository discovery now ignores standalone pyproject.toml
  manifests whose dependencies are ranges or direct references rather than
  resolved pins. Explicit --lockfile pyproject.toml scans remain strict and
  report the unsupported entry.

• Advanced strict machine-readable report schemas to 3.3.0 with separate
  skipped-symbolic-link coverage in JSON, SARIF, and CycloneDX outputs.

v1.10.1

1.10.1 - 2026-07-18

• Fixed commercial-use restriction detection so terms explicitly scoped to
  documentation or data/corpora do not override a separate package-code license.
  Scoped restrictions remain visible in finding evidence, while genuine
  package-level commercial denials continue to produce high findings.
• Added an NLTK 3.9.4 regression fixture covering its Apache-2.0 source code,
  noncommercial documentation license, and separately licensed corpora notice.
• Normalized exact Maven POM names used by FastAsyncWorldEdit, JUnit Jupiter,
  and MySQL Connector/J, including the full Universal FOSS Exception expression,
  so recognized copyleft licenses are reviewed instead of reported as malformed.
• Added opt-in evidence lookup for project-declared HTTPS Maven repositories
  whose exact hosts are allowed by policy or --allow-host, while retaining
  credential isolation, DNS/socket/redirect validation, bounded POM inheritance,
  exact artifact identity checks, caching, and offline behavior.
• Added a bounded Maven JAR license-file fallback that requires a same-repository
  SHA-256 checksum and exact embedded Maven identity. Checksum or identity drift
  fails closed; absent or unusable optional evidence remains unknown.
• Accepted the exact zero-length deflated-directory encoding emitted by Gradle
  JARs without weakening archive path, type, CRC, expansion, or size checks.

v1.10.0

1.10.0 - 2026-07-18

• Added exact-version Maven Central POM license evidence for Maven and Gradle
  coordinates when local POM evidence is unavailable. Requests use the fixed
  official host with existing DNS, socket, redirect, timeout, cache, offline,
  response-size, and credential-isolation boundaries.
• Maven license evidence now follows a bounded parent-POM chain locally and
  remotely, verifies returned artifact identities, deduplicates shared parent
  requests, and fails closed on malformed XML, unsafe coordinates, cycles, or
  excessive depth.
• Fixed Maven multi-module parsing so dependency coordinates cannot be mistaken
  for a child project's inherited group or version, and exact reactor-internal
  dependencies are no longer reported as external packages.
• Added conservative SPDX aliases for unambiguous Maven POM license names while
  preserving unknown for ambiguous values such as unspecified LGPL 2.1 or
  generic public-domain labels.