Skip to main content
Each scan produces findings. A finding is one item someone needs to review, such as a file that matches an open-source component, a declared dependency, or a use of a cryptographic algorithm. Triage means looking at each finding and recording a decision about what it is. Your decisions change what your policies see. A file you mark as your own code stops counting against the merge gate, and confirming a match validates its attribution. Earnie records every decision, so you can show later why a component was accepted. You triage in the Review Workspace, which is Review in a project’s sidebar. Before you start:
  • The project needs at least one completed scan. See Your first scan.
  • To record decisions, you need a role that can triage, such as Operator or Admin. Viewers can move through findings but can’t decide them. See Team & roles.

The Review Workspace

Triaging Findings The Review Workspace has three panels:
  1. The list, on the left, shows what to review: a file tree, a queue of findings, or a list of components, depending on the mode.
  2. The code viewer, in the middle, shows the matched source code.
  3. The Triage panel, on the right, shows the evidence, the component’s details, and your decision. Before you pick a finding, it’s headed Component details or Finding details.
You can collapse the left and right panels to give the code more room.

Three Ways to Work

The toggle at the top switches how the backlog is organised: Review opens in Components, the mode for clearing volume. Switch to Files when you need to see a match in context. A project with no components opens in Files instead, and where your organisation has no open-source scanning, Components isn’t offered and Review opens in Findings. When every finding is resolved, the Findings queue still lists the resolved files. Select one to see its evidence and decision. A filter always applies to findings, so it carries across all three views. Files and Findings keep the files that hold a matching finding, and Components keeps the components that hold one.

Inventory: Findings That Need No Decision

Not every finding is work. An AI usage finding (code that imports an AI SDK, or uses a dataset or vector store) and a declared dependency record what your code uses. Nothing needs deciding about them until a policy flags one. Until then, they’re inventory:
  • They stay visible and searchable in Review.
  • They’re left out of the to-review counts, the Open section of the Findings queue, and review coverage. A project with a thousand imports of one SDK, or five hundred manifest entries, isn’t 0% reviewed.
  • In Findings mode, their files appear in their own Inventory section, below the files that need a decision. Each shows its inventory count instead of a progress fraction. When nothing else is left, the queue says “Nothing to review. The files below hold findings that need no decision.”
  • In Components mode, a component with no finding that needs a decision reads inventory. It’s listed only when you choose Status: Inventory. With no filter set, a list that holds only inventory says Nothing to review, and how many inventory rows there are.
  • Review never moves you to an inventory finding on its own. When only inventory is left, it shows the all-clear state.
An inventory finding becomes work as soon as a policy attached to the project flags it. For example, an AI usage that names a vendor you haven’t approved under Enforce approved AI vendors, or a dependency matched by a licence, vulnerability, or banned-package policy. It then moves into Open and counts towards coverage like any other finding. A violation covered by an active Policy Approval needs no decision either, so the finding returns to inventory until the approval is revoked or expires. Model files, open-source code matches, and cryptographic findings are never inventory. Each one needs a decision.

Searching, Filtering, and What the Counts Mean

Searching

The search box matches file name, file path, component PURL (the package’s standard identifier), and finding title. For a cryptographic finding it also matches the algorithm, so md5 finds an MD5 hash even when the rule that detected it never names MD5. It matches letters in order, not as a single block, so lgn finds login.go. In Components mode, it matches a component’s name, PURL, and licence instead.
  • The box shows your typing at once. The list updates only when you pause, and shows Searching… until it does. This way the list never shows results for a query you’re still typing.
  • Clearing the box takes effect at once.
In the Findings queue, each row marks the letters that matched. When a row matched on something it doesn’t display, such as a component PURL, a finding’s title, or an algorithm, it says matched component, title or algorithm instead of marking unrelated letters in the file name.

Filtering

+ Filter opens the filter menu on Views, a set of one-click presets built from your project’s data: Weak crypto, Quantum vulnerable, Reachable crypto, Copyleft, Has CVEs, Snippet matches, and Suggested: not a match. Earnie offers a view only when the project has matching data. Selecting a view replaces your current filter, and selecting the active view again clears it. Below Views are the filter dimensions, grouped by where the fact comes from: You can also filter cryptographic findings from newer scans by these dimensions:
  • Route evidence shows how strong the best call path to the finding is: Direct calls, Dispatch only, or Name match only. See How strong the path is.
  • No known callers is Yes when every path starts in code that nothing in your application calls.
  • Dependency applies to cryptography found in your dependencies. It’s Direct when your project declares the library, and Transitive when the library arrives through another dependency.
Route evidence and No known callers don’t appear for a finding with no traced path. Findings in your own code, and findings from scans that don’t report it, have no Dependency value. AI vendor filters AI usage findings by the company behind the SDK, package, or provider the code names, such as OpenAI or Azure OpenAI. A usage that names no vendor, such as an agent, a tool, or a dataset, has no value, and neither does a model file. Choosing a vendor therefore lists only the usages that name it. Each vendor on the project’s AI vendors card opens Review filtered this way. A dimension appears only when your findings carry at least two different values for it. A project with no cryptographic findings shows no Cryptography dimensions, and the list you see depends on what your project’s findings contain. Selecting a dimension opens a searchable list of its values, each with the number of findings you’d see if you added it. Ticking more than one value in a dimension widens the result. Adding a second dimension narrows the result to findings that match both. Each active dimension shows as a chip beside + Filter. Remove one chip on its own, or select Clear all to remove all of them. The number on + Filter counts the dimensions you’re filtering by, not the values you’ve ticked.
Filters are stored in the page’s address. A link you share opens with the same filters applied, and reloading the page keeps them. The one exception is Components’ own Status (Open, Resolved, Inventory), which belongs to that view and never appears in the link.
In Files and Findings mode, the counts in + Filter can include cryptography found inside a dependency. Those two views don’t otherwise show it, because it has no file of its own in your repository. When this happens, the menu adds a line: Counts include cryptography found inside dependencies, which this list does not show.

Reading the Counts

Every count names its unit, because the numbers count different things and you can’t add or subtract one from another:
  • The Findings queue’s header reads, for example, 12 to review · 116 files · 323 findings · 40 inventory. Files are the rows of the queue, and findings are what those rows contain, so 116 files · 323 findings is not a discrepancy. When a filter narrows the list, it reads N matching files.
  • In Components mode, each section counts its rows, for example Open · 14 rows. A row is a component, or a review group: findings that belong to no package, grouped by the library or the AI SDK they name. The count on the Components button counts these rows, not the project’s full inventory.

Reviewing an Earlier Run

You can open the Review Workspace for a past run. In Scan history, open the run, then select Open review workspace. You stay on that run:
  • The bar at the top names the run and marks it Selected run.
  • The run stays in the address bar, so Back, Forward, and a shared link all open the same run.
  • Current review, beside it, returns you to the project’s current review.
The bar also says that the findings and decisions shown are current. The run shows the source as it was at the time, but not what was decided on that day.

Switching Projects

When you switch project from the project switcher in the top bar, you stay on the same kind of page if it exists in the other project. Review stays Review, and Scan history stays Scan history. If the page showed one specific item, such as a run, a policy, or a Self-check, you land on the new project’s list of those items. Earnie never carries an identifier from one project into another. A run opened under the wrong project reports itself as not found, instead of showing another project’s numbers under this project’s name.

Reviewing a Component

In Components mode, the left-hand list shows one row per component. Each row has its name, the vendor or package ecosystem (such as npm), and how many of its findings are decided, for example 0/113. A row with nothing to decide reads inventory instead. Selecting a component opens its findings in the middle panel and its details on the right. AI usage findings have no package, so Earnie groups them by the SDK or vendor they name instead. There’s one row per SDK, however many files use it. The row shows the SDK (for example torch), the kinds of usage present (such as AI SDK or AI dependency), and its file count. A usage that names nothing is grouped by its kind. Cryptography in your own code that calls a known library, with no package of its own, is grouped under that library, marked Platform library. Anything else that belongs to no package is under No associated component. Select the row to list its files and locations. A row moves from Inventory to Open while a policy flags one of its usages. See Inventory.

The Middle Panel

The toolbar above the list has Expand loaded and Collapse all, which open or close the file cards, and Bulk decide, which decides every open file at once. See Deciding a whole component at once. Most components show a single list of matched files, which are your own source files that match the package’s published code. Each file is a card showing:
  • the file path, for example flash/PooledSocket.as
  • the match percentage (100% for a whole-file match, lower for a snippet)
  • the match type (File or Snippet) and the matched version
  • the file’s state, such as open
Expand a card to see the matched source, with the decision buttons below it: Confirm match (1), Mark original (2), Replace component (3), and Not a match (4). Compare to OSS shows your file beside the published open-source version, where that version is available. You decide each matched file on its own. Once it’s decided, the buttons give way to the decision, such as Confirmed match, with Reopen to undo it.

Extra Sections for Some Components

Some components also have declared dependencies or cryptography. Only then does the middle panel add a labelled section for each, with a heading and a count: The matched files list has no heading. If a component has no declared dependency or cryptography, as is common for a package matched only by file, you see the list of files and nothing else. Earnie never shows an empty section. A crypto-only package, for instance, shows no Declared section and no matched files. INVENTORY shows whatever data is available: names, types, primitives, PQC (post-quantum cryptography) status, reachability counts, and expandable lists of source files. Earnie doesn’t infer missing metadata. Even when collapsed, the Inventory header says how many of the dependency’s findings are reachable from your application, and lists the first three reachable ones under it. Expanding it shows Findings in this dependency, one verdict at a time (Reachable, Unknown, or Unreachable), each with its count. Each row names the algorithm, the file and line inside the dependency, and how many call paths the scanner found. On newer scans it also shows how strong the best path is. When a verdict’s findings differ in strength, a second row of buttons filters them by strength. Selecting a row opens that finding in the triage panel for reading, where the proof shows how your application reaches it. You decide a dependency’s cryptography once, for the whole package, from the component. If you dismiss the declared dependency, or mark it original, Earnie removes its embedded cryptography from your CBOM (cryptography bill of materials) and posture the next time they’re read. This never changes the underlying findings. They stay open, in case you accept the dependency again later.

The Right-Hand Panel

The Triage panel on the right shows the component’s state (for example Open), then its name, vendor, and package identifier (PURL), followed by groups of details. A group appears only when there’s data for it: The audit trail’s first entry, Detected, shows when the finding was detected and by which scanner, for example scanoss-go. The panel opens on this component summary. Earnie expands the first open card in the middle panel, but the right-hand panel stays on the summary until you pick a card. Clicking a card, or moving to one with j or k, switches the panel to that finding. Press Esc, or close the card, to return to the component summary. A link that already names a finding opens on that finding.
The two counts measure different things. The count on the component’s row, such as 0/113, answers “is this specific package fully decided?”. It never includes a dependency’s embedded Inventory, because there’s nothing there to decide. The Review counter answers “how much of this scan’s reviewable work is done?”, so the two numbers don’t have to match.

Reading the Evidence

The Source Panel

The middle panel shows the matched source, with the match percentage: 100% for a whole-file match, lower for a snippet.
  • The selected match is highlighted in its family colour, green for open source and red for cryptography, so you work on one match at a time.
  • Other matches in the same file keep a coloured rail in the gutter, and the rest of the file isn’t highlighted.
  • Hovering over another match previews it, but only when that match doesn’t already cover your selection.
  • When a file holds several matches, opening it selects the first one by line. The toolbar list names each finding, with a small family icon after the name.
  • When a file matches several components, they’re listed by match percentage, then by the scanner’s own ranking, so at the same percentage the component the file comes from is listed and opened first. A component you’ve confirmed moves to the top, and one marked as original moves to the bottom. Findings from older scans pick up this order at their next scan.

Cryptographic Findings

A cryptographic finding highlights the exact lines where an algorithm is used, in the same source panel as an open-source match. What the finding names depends on where the cryptography is:
  • Inside a dependency, it names that package.
  • In your own code that calls a known cryptography library, it names that library.
  • In plain standard-library usage, it names no package.
When a file holds several cryptographic findings, the toolbar list names each one by its algorithm, not by the library package, since many algorithms can share one package.

Starting from the Cryptography Page

Where Cryptography is enabled, a project’s sidebar also has a Cryptography page, with Overview, Libraries, and Assets tabs. It lists every cryptographic asset detected in the project, shows how much of it your code reaches, and names what your policies block, send for approval, or warn about. See Cryptography. Select an asset on the Assets tab, or an asset in Needs attention on the Overview tab, to open the Review Workspace filtered to it, with the first file that implements it already open. An asset found only inside dependencies opens in Components mode instead, because there’s no file of yours to show. Use the page to answer “where do we use RSA?” or “what here isn’t quantum-safe?” before you work through individual findings.

The Evidence Card

The right-hand Evidence group is headed by the asset’s name, and lists only the facts its kind of asset has: an algorithm, key material, a certificate, or a protocol. An algorithm shows its primitive, mode, padding, and key size, for instance, and key material shows its type, size, and format. A fact the asset doesn’t have gets no row, instead of an empty one.
  • A protocol asset’s title comes from the protocol’s own name, so an SSLv3 finding reads SSL 3.0, not “TLS 3.0”.
  • What provides the cryptography (the library, API, and provider) sits in its own Implementation group.
  • When the scanner didn’t name an algorithm, the card names the matched API or the asset type, never an internal rule ID.
  • When the finding also names a package, the card adds the licence, known vulnerabilities, and how far behind the current release it is, the same groups as for open source.

Reachability

A crypto finding shows its reachability as a verdict, with one line explaining it, under the source in the middle panel. Reachability tells you whether your application can run the code in question:

When Earnie Says Unknown

Unknown isn’t a soft Not reached. It says the analysis didn’t run to a conclusion, so nothing has been established about whether the code runs. The sentence beside the verdict names the reason: None of these is evidence of safety. Reachability only changes how urgent a finding is, never whether to decide it. A project with no lockfile or build file isn’t Unknown for that reason alone. Earnie then traces reachability through the project’s own source code.
Not reached is not the same as not used. The trace is static analysis, which reads the code without running it. It can’t follow code reached through reflection, dynamic dispatch, or configuration, and some languages have no call-graph support at all. In those cases Earnie says Unknown instead of guessing. Treat a reachable finding as more urgent, but never treat an unreachable one as harmless.

How Strong the Path Is

Some calls on a path are less certain than others. When your code calls a method through an interface, the scanner can’t always tell which class receives the call, so it follows every class that could. Newer scans say how strong the best path to a finding is, under the verdict in the middle panel: A finding can also say Reached only from code with no known callers. This means every path starts at a function that nothing in your application calls, such as a command-line tool, a test helper, or code that only reflection reaches. The finding stays Reachable, because that function may run, but nothing shows that it does. Older scans show neither wording.

How Your Application Depends on the Library

On newer scans, the triage panel of a dependency finding says under the verdict whether the library is a Direct dependency (your project declares it) or a Transitive dependency (it arrives through another one). It also shows the shortest chain of declarations that brings the library in, such as App → tika-parsers 1.28.5 → bcprov-jdk15on 1.70. A library the scanner read without its source is marked (no source). This chain isn’t the same as the libraries a route passes through. The route follows calls, which can go through libraries that declare nothing about this one. To stop shipping the library, change the declaration the panel names. To stop reaching its code, change the calls the route shows. An assessed, reachable finding whose severity sits one level above its curated base severity shows a severity escalation row under the reachability pill, explaining why. The row appears only for that exact combination: assessed, reachable, and exactly one level up. An unassessed or unreached finding, or one already at its base severity, shows no such row.

Reading the Proof of a Crypto Finding

The proof of a crypto finding reads top to bottom in the middle panel, under the source: the verdict and one sentence of why, the route as lanes, and where the call’s value comes from. Nothing opens over it. The verdict. The first line says where the route starts and how far it goes: for example From CheckoutHandler.handle, in your code when it never leaves your code, From CheckoutHandler.handle through 2 libraries when it crosses into dependencies, No route from an entry point when the code isn’t reached, or, for Unknown, the reason the analysis couldn’t decide. A line under it gives the route’s number and how many the scanner kept, and says when the route may be incomplete, when middle calls were dropped, or when it starts at code with no known callers. A route that starts at code with no known callers (a command-line tool, a test helper, or code only reflection reaches) stays Reachable, because that code may run, but nothing shows that it does. Several routes, shortest kept. When a finding has more than one way in, numbered buttons switch between the routes Earnie kept, shortest first. Earnie keeps the shortest distinct routes, not everything the scanner walked, and says how many the scanner found and how many are shown when it kept fewer. This is about the listing, never the verdict: the finding is reachable either way, and the routes you aren’t shown are longer ones, not hidden ones. Lanes. A route is drawn as lanes, one per owner of the code, in call order: Your code, then each library the calls pass through, named. The line that marks each crossing gives the library’s version and whether your project declares it (direct) or it arrives through another library (transitive), such as enters httpclient 4.5.14 · direct, or says returns to your code. Hops. Each row is one function on the route, with its file and the line of the call it makes. The first is marked entry point, with the rule that made it one where the scanner named it, and the last is the cryptographic call. A call resolved to exactly one method carries no marker. A weaker one is marked: dispatch when it goes through an interface or base type and the scanner followed every class that could receive it, and by name when it was matched by the method’s name only. A route with a dispatch or by-name hop stays Reachable, on weaker evidence: check that the class it continues into really receives that call in your application. Source on each hop. Select a hop to expand it on a few lines of its real source, with the line of the call highlighted. The cryptographic call is expanded for you. For your own code, Earnie reads the scanned files. For a library, newer scans carry the excerpt the scanner read from the library’s source, so a hop inside a library shows that library’s code. Where the scanner had no source for a library, its hops stay one line each, and the route says why once, under the lanes: Library code not shown: no source for it, its source could not be read, the call site is outside its source, or Library code is not in the scan. Open <file> at line <n> under an excerpt of your code opens that file and line in the source panel without changing the finding under review. Why this value. Under the route, each argument of the cryptographic call that the scanner resolved is listed with the value and where it came from, for example a field, a variable, a parameter of the function, or what another call returned. When the scanner read the key size from the code, a last row names the call it came from, or says Key size unresolved. A value the scanner didn’t resolve has no row: the section shows what is proven, not a guess.

Policy Matches

Under a finding, Policy matches lists each policy that fired on it with its verdict and, where Earnie can say it in words, what the rule checks, for example “Crypto asset type is algorithm and crypto reachability is reachable and severity is one of blocked severities”. When a rule is too complex to put in words, the row keeps the policy’s name and verdict, and View policy opens the rule.

Findings Inside a Dependency

When a finding sits inside a dependency, its code lives in that package’s own source, which isn’t among your scanned files. What you see depends on what Earnie could resolve during the scan:
  1. The package’s source was resolved. Earnie shows the real file, opened at the line where the algorithm is used, in the same source panel as your own code. Today this works for Java projects built with Maven or Gradle.
  2. Only the matched line is available. The panel shows that single line, syntax highlighted, with its real line number in the gutter.
  3. Nothing is available. The panel says Code not available, instead of showing what looks like an empty file.
The decision controls stay available in every case.

Where the Severity Comes From

Earnie rates the severity of cryptographic findings from curated datasets that ship with Earnie. The datasets are tables of algorithms, protocols, and key material with their risk levels. Earnie publishes the datasets at Settings → Crypto Assessment. The page shows what each dataset contains, not the assessment of any one finding. It has one table, with one row per family:
  • Scope switches between Algorithms, Key material, and Protocols.
  • Search finds a family, an alternative name, or a protocol.
  • Show narrows the table to High severity, Quantum-vulnerable, or Export-controlled rows, or shows All.
  • Each row gives its Base severity, its Post-quantum verdict (for algorithm families), and its Export threshold.
Select a row to open its details drawer. It shows the base severity, any key-size and mode variants that override it, the post-quantum verdict, the export-control line the family falls under, and the sources each value cites. Below the table, two short explainers describe how reachability escalates a base severity and what the post-quantum verdicts mean. Two buttons open the full export-control regime and the numbered list of every document the page cites. A strip at the top shows the version of each dataset and when it was last reviewed. Export ruleset downloads the whole published ruleset as JSON, exactly as it appears on screen. The page is read-only, because these datasets ship with Earnie and nobody can edit them. Every role can open it wherever Cryptography is enabled.
Where a published document sets a migration deadline for an algorithm family, such as the 2030 retirement of the classical public-key families, the Triage panel adds a Migration horizon 2030 marker, and the Crypto Assessment page marks the family Migrate by 2030. The Triage panel explains: “Migrate before 2030, a published deadline, not a risk level; this finding’s severity is unchanged by it.” A deadline is not a severity. RSA-2048 is Low today and also has a date to migrate by. Earnie reports both, and the deadline doesn’t change the severity. Use the deadline to plan migration work, not to decide findings.

Making a Decision

Select Decide and pick the answer that’s true. Earnie records it straight away and moves you to the next open finding. Hover over an option to see what it does, including whether it keeps the finding in the gate. In Files and Findings mode, and after a bulk decision, a message offers Undo. In Components mode, a decided file shows Reopen instead.

Open-Source Matches

Not a match is a statement about the match, not about who wrote the code. It takes the finding out of the gate and removes the detected component from the SBOM. Mark original says something different: the code is yours, and it matched because its published copy is yours too. Use Mark original for your own code, and Not a match when the match is wrong. Declared dependencies are never offered it; they keep Accept into SBOM and Dismiss. The audit trail entry reads Marked not a match. Matches Earnie proposes as not a match. After each scan, Earnie scores every open-source snippet match by checking whether the lines reported in your file and the lines reported in the open-source file correspond. When they don’t appear to, the match’s Evidence shows a proposal above its decision: Likely not a match, how likely that is, and The reported lines do not appear to correspond. Check them, then decide. In Decide, Not a match carries a Suggested badge. Nothing is decided for you. Read the lines, use Compare to OSS if you want them side by side, then choose. Once the finding is decided, the badge stays as history, without the sentence. The Suggested: not a match view lists every open snippet match with a proposal. A proposal needs the scanned files, so a project that imports an SBOM never shows one, and neither does a scan that turned off Snippet classification. See Choosing Scanners.

Declared Dependencies

For a declared dependency, the choice is Accept into SBOM (1) or Dismiss (2). When the component has nothing else left open, Earnie moves you to the next open component.
  • Accept into SBOM keeps the dependency in the SBOM and records its licence as concluded.
  • Dismiss removes the dependency, and the cryptography found inside it, from the SBOM and from the gate.
A dependency that no policy flags is inventory. It’s in your SBOM whether or not anyone decides it, so both decisions are optional. They stay available because they still have an effect.

Cryptography

All three decisions close the finding and keep its row, so an accepted risk stays visible in the list. Whether the algorithm is reachable may change what you decide, but never which decisions you’re offered.
There is no “Fixed” for cryptography. You record a fix by removing the weak algorithm and re-scanning. The next run reports it as gone and keeps your decision history. Earnie can verify that from the scan, instead of relying on your word.

AI Model Findings

Where AI provenance is enabled, a model file gets its own decisions, separate from a usage finding: An AI usage finding is code that calls an AI service or SDK, not a model file. You decide it separately: Confirm AI usage, Not AI usage, or Approve AI usage. You can’t apply a model-finding decision to a usage finding, or the reverse. Earnie refuses the mismatch instead of recording a decision that doesn’t fit the evidence.

Deciding a Pull Request’s Own Findings

A pull request can introduce a finding that has no counterpart yet on the project’s default branch. You can still resolve or reopen that finding from the pull request’s own Review Workspace. Until the change merges there’s no standing finding to attach the decision to, so Earnie records it as Applies on merge. The finding shows as decided in that pull request’s view right away, including for its gate. Once the same code reaches the default branch, Earnie applies the original decision, and any Policy Approval requested against it, to the project’s real findings. Also apply to future matches isn’t offered for these findings until they exist as standing findings after merge. Bulk decide isn’t either: a group or component that holds one reads Decide one at a time.

Deciding a Whole Component at Once

In Components mode, Bulk decide applies a decision to every open file for that component. With the keyboard, Shift+1 confirms all and Shift+2 marks all as original. On a large first triage, this saves the most time.
  • Each group of actions in the menu shows how many findings it will decide. A group with nothing left to decide is greyed out.
  • Findings you reopened count as open, so Bulk decide includes them. You decide assigned findings one at a time.
  • If an action finds nothing left to decide, Earnie says that no findings changed and how many were already decided. It doesn’t confirm a decision.
  • For an AI usage group, it offers Confirm AI usage, Not AI usage, and Approve AI usage, each applied to every open usage in the group.
  • For a review group, Earnie sends a decision on more than 1,000 findings in batches of 1,000 and reports it once. If a batch fails, the message says how many were recorded, and Undo reopens exactly those.

Saving a Correction for Future Scans

When you replace a component in Files or Findings mode, you can also tick Also apply to future matches of that package, any version, in this project. Earnie saves the correction to the project’s Scan Configuration as a component override, and future scans apply it without asking you again. The option is off by default, and needs permission to change Scan Configuration.

Component Overrides

A component override settles a package’s findings automatically on every scan, so you don’t have to decide them again. Each override names a package, optionally limited to a path, and one decision: Earnie reads overrides from three places:
  1. The project’s Scan Configuration, for example a correction saved with Also apply to future matches.
  2. The repository’s scanoss.json file: bom.remove, bom.replace, and bom.include (Confirm as declared). Earnie also accepts bom.identify as another name for bom.include. Earnie reads this file but never writes to it. See Declaring components for the file format.
  3. The organisation’s Scan Configuration.
When an override settles a finding, Earnie records it in the finding’s audit trail, the same way it records a decision a person made. An override’s path matches everything under it, with or without a trailing /, so src and src/ are the same.

When Overrides Overlap

When more than one override names the same package, Earnie applies them in this order, and the first one to claim a path wins:
  1. By source, from most to least specific: the project, then scanoss.json, then the organisation.
  2. Within one source, remove, then replace, then include.
Paths overlap when they’re identical, when one is inside the other, or when either has no path (the whole project). Earnie drops a later override whose path overlaps an earlier one. It drops the whole override, not only the overlapping part. Overrides for the same package at paths that don’t overlap all apply.

How a Decision Moves the Dashboard

False positive and Accepted risk take the finding out of these Cryptography Dashboard numbers:
  • the reachable-and-weak headline
  • the post-quantum migration counts
  • the algorithm ranking
Those numbers count the work that’s left, and a finding you’ve decided isn’t left to do. The finding is still counted elsewhere. The same cards report the decided findings beside the headline, split by the decision that closed them, so a decision moves a finding from one number to another instead of removing it.
Confirm usage works differently. It does not reduce those counts. Confirming that an algorithm is in use confirms that the risk is real, so Earnie keeps the finding in those counts. The merge gate counts it either way. The card shows how many findings you’ve confirmed, so your work is visible and the risk stays counted.
Deciding a finding doesn’t shrink your inventory. The counts that describe how much cryptography is in the product ignore your decisions: total findings, distinct assets, the reachability split, first-party versus dependency, and the asset-type breakdown. Confirming or accepting an algorithm doesn’t remove it from the build, so it doesn’t remove it from the inventory. Only the counts of work left to do respond to triage.Export evidence is a third case. It measures the evidence you hold for what you ship, and deciding a finding never completes it by itself. A false positive drops out, because it wasn’t cryptography. An accepted risk and a confirmed usage are both still in your CBOM, and you still need to gather export evidence for them.

The Audit Trail

Earnie writes every action to the finding’s Audit trail: what was decided, by whom, when, and what the state was before. Use this record to show later why a decision was made.

Keyboard Shortcuts

To jump to another page or project from anywhere in Earnie, press Cmd+K on a Mac or Ctrl+K elsewhere. See Getting around. Press ? anywhere in the Review Workspace, or select the keyboard button in its toolbar, to open the Keyboard shortcuts panel. It lists the shortcuts for the mode you’re in. Shortcuts do nothing while you’re typing in a field. Decision keys appear only for roles that can record decisions.

Components Mode

Findings and Files Modes

The Dashboard has keys of its own, but only while Edit is on. Focus a panel’s move handle, then use ← / → to move it one place, Home / End to move it to the start or end, and, on a wide window, Shift+← / Shift+→ to resize it. See Making the canvas your own.

Finding States

Each finding shows its state: In the Files tree, a folder with work left has an orange dot, and hovering over it says how many of its files are reviewed. A file whose findings are all decided is dimmed.

What’s Next

Once your findings are triaged, turn the decisions you keep repeating into a policy that Earnie applies on every scan.