Nullgap.dev Docs

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:

StoredWhat it is
The decisionfalse_positive or accepted_risk, the reason, who decided and when, and the review date of an accepted risk
The weakness classFor example SQL injection or access control
The placeThe file and the enclosing function
The flagged statement and the dangerous operationIn a normalised form: whitespace, comments and the names of local variables are set aside
The surroundingsA 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.

kindMeaning
same_findingThe very finding that was dismissed, found again in the same place by a later run.
patternOther 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.

  1. The two findings share a weakness class.
  2. 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.
  3. The dangerous operation is the same statement.
  4. It is the same one of several identical statements in the function.
  5. The data comes in at the same kind of place, and the entry point has the same guards and method.
  6. The code within six lines of the flagged statement is identical.
  7. The rest of the enclosing function is at least 90% alike.
  8. 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

DecisionHolds backNever holds back
False positiveMatching code anywhere in the repositoryA finding that was reproduced in the sandbox in that run
Accepted riskMatching code in the same file and the same function only, until its review dateThe 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} and GET /pentests/{id} return them in suppressed, with suppressedCount on the run. GET /suppressions lists 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.

QueryMeaning
stateactive (the default: still held back), restored, or all
repoIdOne repository
sourceIdOne run: a review or pentest id. Add source=review or source=pentest to be exact.
limit, offsetPaging, 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 wasAnd nowWhat happens
False positiveThe run reproduced it in the sandboxThe finding is reopened. A probe that worked outranks the opinion that it cannot happen.
False positiveThe code around the statement has changedThe finding is reopened. The decision was about the code as it was.
Accepted riskThe review date has passedThe finding is reopened for review.
EitherThe statement on those lines is a different statement nowIt is a new finding. The dismissed one is left as it is.
Accepted riskThe same code now sits in a different functionIt is a new finding. A risk accepted for one function is not stretched to another.
EitherNone of the aboveIt 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 wasAndWhat happens
False positiveThe new finding was reproduced in the sandbox in this runRaised
Accepted riskThe new finding is in a different file or functionRaised
Accepted riskThe review date has passedRaised

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:

kindWhat bringing it back does
patternIt 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_findingThe 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 earlierDecision with a note saying why it was held and why it is raised, and sends a finding.created webhook 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.

Nullgap documentation