Skip to content

Pull Request Commands

When a repository posts Code Scanning findings on pull requests as comments, you can act on each finding without leaving the pull request. Comment a Fencer CLI command with a slash in front:

/fencer vuln ignore VULN-1A2B --reason false_positive --notes "only used in tests"

This does on the pull request what fencer vuln ignore VULN-1A2B … does in a terminal, so people and coding agents learn one syntax. VULN-1A2B is the finding’s slug, shown in its title. Fencer makes the change as your Fencer user and reacts to your comment with 👍 (a like on Azure DevOps; on Bitbucket, which has no reactions, it replies with what changed), or for a fix replies with a link to it. When it can’t, it replies with why.

Command What it does
ignore Ignores the finding. Takes --reason and --notes.
defer Ignores the finding for 7, 14, 30 or 90 days. Takes --days, --reason and --notes.
unignore Undoes an ignore or a deferral.
undefer Ends a deferral.
fix Has Fencer fix the finding. Takes --push and --notes.
  • --reason takes an ignore reason, such as false_positive, acceptable_risk, will_not_fix, duplicate, third_party_code or no_fix_available. false-positive works too.
  • --days takes 7, 14, 30 or 90. A defer without it lasts 7 days.
  • --notes says why, or for fix what to keep in mind. It takes everything up to the next flag, so quotes are optional: --notes only used in tests works.
  • Flags can be written --days 30 or --days=30.

vuln can be left out (/fencer ignore VULN-1A2B), the slug can be in any case or wrapped in backticks, and only the first /fencer line of a comment counts. /fencer review is not a findings command: it starts an AI PR review.

A command posted as a regular pull request comment names the finding by its slug:

/fencer vuln defer VULN-1A2B --days 30 --notes "fixed in the auth rewrite"

Each finding on a changed line gets its own inline comment: a review comment on GitHub, a discussion on GitLab, an inline comment on Bitbucket, a thread on Azure DevOps, an inline comment thread on Cursor Origin. Azure DevOps takes a thread on any line of a file the pull request changed, so there every finding in a changed file gets one, on a changed line or not. Reply in that thread and you can leave the slug out:

/fencer vuln ignore --reason acceptable_risk --notes "internal admin tool, not exposed"

Each inline comment also has a collapsed Act on this finding section with the commands for that finding, slug filled in, ready to copy.

A finding keeps that one thread for the life of the pull request: a new push adds inline comments only for findings that don’t have one yet. Findings that can’t be placed on a changed line are listed in Fencer’s findings summary on the pull request instead; name those by their slug.

Fencer reacts with 👍 (a like on Azure DevOps) to an ignore or a defer it applied, and resolves the finding’s inline thread when the command was posted there. On Bitbucket it replies to your comment instead, saying what it ignored or deferred and how to undo it. The finding’s Act on this finding section has the commands that undo it.

unignore and undefer reopen that thread. The finding counts in the Fencer check again from the next push. If there was nothing to undo, Fencer changes nothing and still reacts with 👍, or on Bitbucket says so.

On Azure DevOps every comment is part of a thread, so Fencer answers a command in its own thread. A command you posted as a new comment starts a thread of its own, and Fencer closes that thread once it applied the command, so it doesn’t hold up a pull request that needs its comments resolved. A thread for a command Fencer couldn’t apply stays active with Fencer’s reply.

fix starts the same AI fix as the Fix button in Fencer, and Fencer links to the run. When the fix is ready:

  • By default, Fencer opens a pull request with the fix into your pull request’s branch. Merge it to bring the fix in.
  • With --push, Fencer commits the fix onto your pull request’s branch and lists what it fixed and what it left out, and why. On GitHub, changes to workflow files under .github/workflows/ are left out for you to apply by hand; on GitLab, Bitbucket and Azure DevOps, a fix may change CI configuration such as .gitlab-ci.yml, bitbucket-pipelines.yml or azure-pipelines.yml like any other file. If Fencer can’t push, because it has no access to the branch, the branch moved, the pull request was closed or the push failed, it posts the fix as a patch instead.

Fencer answers in the thread you asked in, or on the pull request when you asked in a comment of its own. On Azure DevOps, where every comment is in a thread, it answers in the command’s thread.

Fencer refuses a fix, and changes nothing, when:

  • your plan has no automatic fixes, or your organization is out of credits;
  • the pull request comes from a fork;
  • the finding is already resolved, ignored or deferred, or another fix is already working on it;
  • Fencer has no fix for the finding that can run from a pull request;
  • with --push, you don’t have write access to the repository (on GitLab, the Developer role or above; on Azure DevOps, the Contribute permission, given to you or to a group you are in), the branch is the repository’s default branch, the branch is protected on GitLab, has a push restriction on Bitbucket, or on Azure DevOps is locked, has a required branch policy or has permissions of its own that deny Contribute, or another --push fix is still running on the pull request. Without --push, a fix into a protected branch opens as a pull request as usual.
  • with --push on Cursor Origin, Fencer’s Origin app lacks the Read repository collaborators permission it checks write access with. The reply says so; a workspace admin approves it as the Cursor Origin integration page describes. A ruleset that blocks the push on Origin shows only when Fencer pushes, so Fencer posts the fix as a patch then.

An ignore or deferral anywhere in Fencer (the app, the CLI, MCP, Slack, a pull request command or Fencer triage) reaches each pull request whose latest scan reported the finding:

  • The Fencer check is counted again without a new push. When nothing else fails it, the check turns green. This works on every git provider: GitHub, GitLab, Bitbucket, Azure DevOps and Cursor Origin.
  • The finding’s inline thread is resolved, and Fencer’s findings summary counts only the findings still open. Once none is open, the summary is cut to one line.

Fencer, not the conversation, decides whether a thread is open: a thread stays open while its finding is open, is resolved once the finding is handled in Fencer or no longer found, and opens again when the finding comes back, even if someone resolved it by hand. A finding reopened in Fencer keeps its thread as it is until the next scan counts it.

So where a pull request can’t merge with open threads (GitLab’s All threads must be resolved, a GitHub branch that requires conversation resolution, or Azure DevOps’s Check for comment resolution policy), it can’t merge while a finding is open. Handle the finding in Fencer, or with a command, and its thread is resolved.

On Azure DevOps, an open finding’s thread is Active and a handled one’s is Resolved. Fencer’s findings summary is a thread too: it is active while findings are open, and closed once it is cut to one line.

A pull request that was closed or pushed to since its latest scan is left alone: its next scan picks the change up.

A command runs only for someone with a Fencer account in your organization, and only once Fencer can tie the GitHub, GitLab, Bitbucket, Azure DevOps or Cursor account that posted it to that Fencer user. Fencer then checks the user’s role:

  • Every command needs permission to edit vulnerabilities.
  • fix also needs permission to run scans.

If the role doesn’t allow the command, Fencer replies and changes nothing. Fencer’s own comments are never treated as commands.

Linking your GitHub account to your Fencer user

Section titled “Linking your GitHub account to your Fencer user”

Fencer ties the two through the people on Posture > Identities (Vendor Identities):

  • The GitHub integration syncs your GitHub organization’s members as vendor identities, and Fencer links each one to a person.
  • Fencer syncs every member of your Fencer organization the same way, as a Fencer vendor identity. The person your Fencer account is linked to, by email or by an admin, holds your Fencer user.

Your GitHub account counts when it is linked to that person by an email match, by an admin with Link to User, or by a name match an admin has confirmed with Mark as reviewed on the person. A name match nobody has reviewed doesn’t count: whoever owns a GitHub account picks the name it matched on.

When no linked person holds a Fencer user, Fencer matches by email instead: the email of your synced GitHub identity, or the primary email of the person it is linked to when that link counts. For a GitHub account Fencer hasn’t synced, it uses the public email on your GitHub profile, which GitHub shows only once you’ve verified it. The email has to belong to a member of your Fencer organization, and when the emails point to different members, Fencer matches nobody rather than act as the wrong person. A Fencer user found through a linked person comes before any email.

GitHub members are synced as identities only when your plan includes identity management. Without it, Fencer can match a commenter only by the public email on their GitHub profile.

Linking your GitLab account to your Fencer user

Section titled “Linking your GitLab account to your Fencer user”

The same rules apply to GitLab accounts, with two differences:

  • The GitLab integration syncs members as vendor identities only when its connection has a Gitlab group path, and only with a plan that includes identity management. A synced GitLab identity carries the member’s public email.
  • For a GitLab account Fencer hasn’t synced, it uses the public email on the GitLab profile only on gitlab.com, which shows an email only once it is confirmed. A self-managed GitLab instance may not confirm emails, so there Fencer matches commenters through synced identities alone.

Linking your Bitbucket account to your Fencer user

Section titled “Linking your Bitbucket account to your Fencer user”

The same rules apply to Bitbucket accounts, with two differences, both because Bitbucket doesn’t show its members’ emails:

  • The Bitbucket integration syncs workspace members as vendor identities with a plan that includes identity management, but without their emails. A synced Bitbucket account counts only once an admin links it to you with Link to User, or marks a name match reviewed.
  • For a Bitbucket account Fencer hasn’t synced, Fencer asks Bitbucket which of your Fencer organization’s members’ emails belongs to it. Bitbucket answers only when the account that connected Bitbucket to Fencer is a workspace admin.

Linking your Azure DevOps account to your Fencer user

Section titled “Linking your Azure DevOps account to your Fencer user”

The same rules apply to Azure DevOps accounts, with two differences:

  • The Azure DevOps integration syncs your Azure DevOps organization’s users as vendor identities, with a plan that includes identity management. A synced Azure DevOps identity carries no email, so it counts only through its link to a person.
  • For an Azure DevOps account Fencer hasn’t synced, it uses the account’s sign-in name, which Azure DevOps shows as the account’s email.

Matching your Cursor account to your Fencer user

Section titled “Matching your Cursor account to your Fencer user”

Cursor Origin has no member listing, so Fencer doesn’t sync Cursor accounts as identities. Instead, Origin sends the email of the Cursor account that posted each comment, and Fencer acts as the member of your Fencer organization with that email. Use the same email for your Cursor account and your Fencer account. Cursor’s own accounts, such as Bugbot, Automations and hosted agents, aren’t Fencer users, so their commands change nothing; a Cursor agent that comments as you counts as you.

Fencer changes nothing and replies with what’s wrong, linking to the page in Fencer where an admin fixes it. It says so once per account on each pull request, so anyone able to comment on the repository can’t make Fencer post again and again. The reply says one of three things:

  • Your account’s link to Fencer isn’t verified yet: your GitHub account is linked to you only by a name match nobody has reviewed. Anyone in the GitHub organization can change their name, so Fencer doesn’t act on that link until an admin marks the name match reviewed, on the person’s page the reply links to.
  • Your account isn’t linked to a Fencer user: ask an admin to link your GitHub account to you on the account’s page the reply links to, with Link to User.
  • Fencer doesn’t know your account: Fencer hasn’t synced your GitHub account and can’t match you by email. Without a Fencer account, ask an admin to invite you. A GitHub account that joined the organization recently shows up on the Vendor Identities tab after the next identity sync.

Making your GitHub profile’s email public, with the same address as your Fencer account, also lets Fencer match you by email. On Cursor Origin, the reply is always that Fencer doesn’t know your account: check that your Cursor account’s email is the one your Fencer account uses.

When Fencer can’t act on a command, it replies with why: an unknown command gets the list of commands, a wrong flag or value gets the command’s usage, and a missing slug gets asked for again, each with a link to this page. A slug that isn’t a finding in this repository gets a link to the repository’s findings in Fencer.

The collapsed Act on this finding section under each inline comment tells a coding agent working on the pull request (Claude Code, Cursor, Copilot and similar) what it can do with the finding. The agent can act on it in two ways:

  • Post a command, when it comments with your GitHub, GitLab, Bitbucket, Azure DevOps or Cursor account (for example a CLI agent signed in with your gh, glab or az login, or a Cursor agent acting as you on Origin). Fencer checks your identity and role as for any command. An agent that comments as its own GitHub App, such as claude[bot], isn’t linked to a Fencer user, so Fencer changes nothing and says so once per pull request.
  • Run the command without the slash in the Fencer CLI (fencer vuln ignore VULN-1A2B …), or use the local MCP server built into it (fencer mcp), which has the same actions as tools such as vulnerabilities.ignore, vulnerabilities.defer and vulnerabilities.fix. The remote MCP server can list and read vulnerabilities, but not change them.