- 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

- 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.
- The code viewer, in the middle, shows the matched source code.
- 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.
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.
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, somd5 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.
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.
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.
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, so116 files · 323 findingsis not a discrepancy. When a filter narrows the list, it readsN 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.
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 asnpm), 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
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.
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 asApp → 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:- 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.
- Only the matched line is available. The panel shows that single line, syntax highlighted, with its real line number in the gutter.
- Nothing is available. The panel says Code not available, instead of showing what looks like an empty file.
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.
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.
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:
- The project’s Scan Configuration, for example a correction saved with Also apply to future matches.
- The repository’s
scanoss.jsonfile:bom.remove,bom.replace, andbom.include(Confirm as declared). Earnie also acceptsbom.identifyas another name forbom.include. Earnie reads this file but never writes to it. See Declaring components for the file format. - The organisation’s Scan Configuration.
/, 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:- By source, from most to least specific: the project, then
scanoss.json, then the organisation. - Within one source, remove, then replace, then include.
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
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, pressCmd+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.