Findings
Memory of dismissals
What Nullgap remembers when you dismiss a finding, when a later finding is held back because of it, the rules that raise it anyway, and how to undo a dismissal.
When a person dismisses a finding as a false positive or an accepted risk, Nullgap remembers the decision for that repository. A later finding that is the same finding, or whose code is the same, is not raised again. It is held back, listed on the run that produced it with the decision it rests on, and anyone on the team can bring it back.
Nothing is held back silently, and the comparison is fixed code: no AI is asked, so the same code always gets the same answer.
#What is remembered
A dismissal is remembered when both of these hold:
- A person made it. In the console, through the API, by a reply on the pull request, from Slack, or a Nullgap researcher's rejection. A finding Nullgap closed by itself, for example because a later review refuted it, stays closed as that one finding but is not remembered as a pattern.
- The finding carries a record of its code's shape. Findings about a line of code from recent runs do. A dependency finding, or one stored before shapes were kept, does not: it is still not raised again as the same finding, but it cannot hold back other code.
What is stored with the decision:
| Stored | What it is |
|---|---|
| The decision | false_positive or accepted_risk, the reason, who decided and when, and the review date of an accepted risk |
| The weakness class | For example SQL injection or access control |
| The place | The file and the enclosing function |
| The flagged statement and the dangerous operation | In a normalised form: whitespace, comments and the names of local variables are set aside |
| The surroundings | A hash of the code within six lines of the statement, a summary of the rest of the function for comparison, where the data comes in, the guards on the entry point, and the callers of the function |
Memory is per repository. A decision in one repository never holds back a finding in another.
#Same finding or pattern match
A held-back finding has a kind.
kind | Meaning |
|---|---|
same_finding | The very finding that was dismissed, found again in the same place by a later run. |
pattern | Other code that matches the dismissed code: a copy of it in another file, or the same statement in a function that is otherwise the same. |
#What counts as the same code
For a pattern match, every one of these must hold. The first that fails means no match, and the finding is raised.
- The two findings share a weakness class.
- The flagged statement is identical once whitespace, comments and local variable names are set aside. The text of string literals counts: a different query is a different statement.
- The dangerous operation is the same statement.
- It is the same one of several identical statements in the function.
- The data comes in at the same kind of place, and the entry point has the same guards and method.
- The code within six lines of the flagged statement is identical.
- The rest of the enclosing function is at least 90% alike.
- The callers of the code are known for both, and nothing new calls it.
The comparison is strict on purpose. A dismissal is a statement about one piece of code in one context, such as "the value is validated two lines above". When the surrounding code, the way data enters or the set of callers differs, that statement may no longer hold. Hiding a real flaw is worse than asking a person twice.
Anything that could not be established counts against a match. A finding with no record of its code's shape is never held back as a pattern.
#What each decision covers
| Decision | Holds back | Never holds back |
|---|---|---|
| False positive | Matching code anywhere in the repository | A finding that was reproduced in the sandbox in that run |
| Accepted risk | Matching code in the same file and the same function only, until its review date | The same code in any other function; anything found after the review date |
An accepted risk does hold back a proven finding in its own function: your team already said the flaw is real and chose to live with it. Accepting a risk in one place says nothing about another.
#How held-back findings are listed
A held-back finding is not in the findings list, is not counted in the run's number of findings, does not affect the pull request check, and sends no finding.created event. It is recorded, and shown in four places.
- On the run. The Findings tab of the pull request review or pentest has a section Not raised because of earlier decisions, with the count. Each entry shows the finding, whose decision it rests on, the reason given, and under Why it counts as the same the statements that matched.
- In the run's log. One line says how many findings were produced and not raised.
- On the dismissed finding. Under Findings like this, a notice says how many later findings its decision is holding back.
- By API.
GET /reviews/{id}andGET /pentests/{id}return them insuppressed, withsuppressedCounton the run.GET /suppressionslists them across the organisation.
curl -s -H "Authorization: Bearer $NULLGAP_API_KEY" \
"$NULLGAP_URL/api/orgs/$NULLGAP_ORG/suppressions?state=active&sourceId=pen_4c1d9e7a2b60"
{
"items": [
{
"id": "sup_6a0d3c9e1f72",
"repoId": "repo_5b2e8a1c9d3f",
"repoFullName": "acme/shop",
"kind": "pattern",
"decision": "false_positive",
"decidedBy": "dana@acme.example",
"decidedAt": "2026-10-02T10:14:00.000Z",
"reason": "The id is cast to an integer in parseOrderId before it reaches the query.",
"dismissedFindingId": "fnd_8f3a2c9d1b4e",
"why": [
"Same weakness class (sql-injection).",
"The flagged statement and the dangerous operation are identical once whitespace, comments and local variable names are set aside.",
"The code within 6 lines of it is identical, and the rest of the function is 97% alike.",
"It is called from the same places, and the code around each call is unchanged."
],
"similarity": 0.97,
"firstAt": "2026-11-16T14:01:58.000Z",
"lastAt": "2026-11-16T14:01:58.000Z",
"restoredAt": null
}
],
"total": 1
}
The sample is abridged: each item also carries the finding itself, its priority and its sightings.
| Query | Meaning |
|---|---|
state | active (the default: still held back), restored, or all |
repoId | One repository |
sourceId | One run: a review or pentest id. Add source=review or source=pentest to be exact. |
limit, offset | Paging, as for any list |
#When a dismissed finding is raised again
A dismissal does not last for ever regardless of what happens. These rules raise a finding in spite of an earlier decision.
#The dismissed finding itself, found again
| The decision was | And now | What happens |
|---|---|---|
| False positive | The run reproduced it in the sandbox | The finding is reopened. A probe that worked outranks the opinion that it cannot happen. |
| False positive | The code around the statement has changed | The finding is reopened. The decision was about the code as it was. |
| Accepted risk | The review date has passed | The finding is reopened for review. |
| Either | The statement on those lines is a different statement now | It is a new finding. The dismissed one is left as it is. |
| Accepted risk | The same code now sits in a different function | It is a new finding. A risk accepted for one function is not stretched to another. |
| Either | None of the above | It is held back as same_finding. |
A reopened finding has stateBy set to nullgap, the reason beginning "Raised again:", and earlierDecision holding the earlier decision and its reason.
#Other code that matches
| The decision was | And | What happens |
|---|---|---|
| False positive | The new finding was reproduced in the sandbox in this run | Raised |
| Accepted risk | The new finding is in a different file or function | Raised |
| Accepted risk | The review date has passed | Raised |
A finding raised this way is an ordinary open finding. It carries earlierDecision, with a note naming the rule that required it, and the console shows the note with Open the earlier decision.
#Undoing a dismissal
There are three ways, and each releases what the decision was holding.
#Bring back one held-back finding
On the run, press Bring back next to the finding and confirm. By API:
curl -s -X POST -H "Authorization: Bearer $NULLGAP_API_KEY" \
-H "Content-Type: application/json" -d '{}' \
"$NULLGAP_URL/api/orgs/$NULLGAP_ORG/suppressions/sup_6a0d3c9e1f72/restore"
The answer is { "finding": ..., "alsoRestored": n }. Any member can do this, and so can a key with the write scope.
What it does depends on the kind:
kind | What bringing it back does |
|---|---|
pattern | It becomes an open finding, first seen on the day it was first held back. The remembered pattern is removed, so every other finding that pattern was holding comes back as well; alsoRestored counts them. The original dismissed finding keeps its state: you said this other code is not covered, not that the first decision was wrong. |
same_finding | The dismissed finding itself goes back to open and its decision is withdrawn. Anything else that decision was holding comes back as well. |
A second attempt on the same entry is refused with 409 already_restored.
#Reopen the dismissed finding
Set the dismissed finding back to Open, in any of the ways on Triage. Its pattern is removed and everything it was holding back is raised as open findings.
#Narrow a false positive to an accepted risk
Changing a finding from False positive to Accepted risk keeps it dismissed but narrows what it covers to its own function. Findings its pattern was holding are raised.
In all three cases:
- each finding that comes back is attached to the run that last saw it, carries
earlierDecisionwith a note saying why it was held and why it is raised, and sends afinding.createdwebhook event; - the release is written to the audit log as
finding.unsuppressed.
#Seeing decisions before you make one
A finding's Findings like this section shows, for findings in the same repository with the same weakness on the same statement:
- Previous decisions on findings like this: who decided what, when and why;
- Similar findings: the others, with their states.
GET /findings/{id}/similar returns the same as similar, decisions and suppressedByThis. When determined is false, the finding has no record of its code's shape and cannot be compared.
To apply one decision to all of them, see Bulk actions.
#Related
Nullgap documentation