process-vulnerability-report
$
npx mdskill add Significant-Gravitas/AutoGPT/process-vulnerability-reportA **GitHub security advisory** is a private record on the repo. Outside researchers open one through a web form; it sits in state `triage` until a maintainer works it. Publishing makes it public and pushes it into GitHub's vulnerability database, so downstream users get alerted.
SKILL.md
.github/skills/process-vulnerability-reportView on GitHub ↗
---
name: process-vulnerability-report
description: Take one reported vulnerability from the triage queue to a published GitHub security advisory — triage, verify, fix, author the advisory body, hand to a maintainer to publish. TRIGGER when the user asks to process a security report, work the advisory backlog, triage a GHSA, or write/publish a security advisory.
user-invocable: true
argument-hint: "[GHSA id] — if omitted, takes the highest-ranked item from the triage queue."
metadata:
author: autogpt-team
version: "1.0.0"
---
# Process a vulnerability report
A **GitHub security advisory** is a private record on the repo. Outside researchers
open one through a web form; it sits in state `triage` until a maintainer works it.
Publishing makes it public and pushes it into GitHub's vulnerability database, so
downstream users get alerted.
This skill takes **one advisory** from `triage` to `published`. It works the same on a
report filed five minutes ago and on one that has sat untouched for months — the
backlog is processed by running this skill per item, not by a separate tool.
`REPO=Significant-Gravitas/AutoGPT` throughout.
## Stages
| # | Stage | Input | Artefact | Decides |
|---|---|---|---|---|
| 1 | Triage | a GHSA id, or the queue | acknowledgment + dedup verdict + CVSS vector + metadata block | agent proposes, **human confirms severity and sends the acknowledgment** |
| 2 | Verify | the triaged report | reproduction note: proved-live vs read-in-source | agent, on the model *Which model does which work* picks |
| 3 | Fix | the reproduction note | fix PR with tests, its public text naming the change and no advisory id | agent |
| 4 | Author | fix PR + reproduction note | the advisory body, in the template below | agent drafts; a maintainer approves it before it replaces the description |
| 5 | Raise | body + fix PR + metadata | published advisory; the public sync's PR updates SECURITY.md | **human** reviews, merges, publishes |
**Three writes are irreversible and the agent never runs them: `state=closed`,
`state=published`, and the CVE request.** The skill prepares each payload and stops; a
human executes it. Also human, always: confirming the severity, approving the advisory
body before it replaces the description, merge approval, a duplicate spanning two
reporters, choosing the fix route, and anything sent to a reporter, a credit's invitation
included.
## Which model does which work
A **cleared model** is one cleared for security work, its safeguards adjusted for defensive
use. A standard model refuses part of this skill's work, so establish which of three cases
you are in before starting. In all three, a model built for finding vulnerabilities is only
for finding new ones, never for working a report, and a refused response is never retried
reworded: shorten it to the advisory id and the location, or hand it over.
**No cleared model.** A standard model refuses the advisory body (stage 4), a
security review that has to describe the exploit, and some reproductions (stage 2) and fix
sessions (stage 3). A human writes or does those; everything else runs as written.
**Billed access.** Metered calls go only where a standard model refuses, so declare a
budget before starting and split the work:
- **Cleared model:** the advisory body (stage 4), a short fix brief for a private
finding (the files, the rule to enforce as code behaviour, and which report sections to
read), a security review that has to describe the exploit, and a reproduction or fix
session a standard model still refuses.
- **Standard model:** everything else, from intake, coverage and duplicates to credits and
records, and the fix and its tests, built from that brief.
Hand work over by pointer (the advisory id, a ticket, the file and function), never by
pasting details. A standard-model session coordinating the work does not read the advisory
body, a reproducer or the write-up.
**Access included in a subscription.** The split and the pointer-only hand-over exist to
save metered calls and to keep refused content out of standard-model sessions, and neither
applies, so the whole report runs on the cleared model:
- the coordinating session reads the report itself;
- dedup (stage 1) compares the reports' content, not only their summaries;
- the CVSS vector and the CWE come from the exploit as proved in stage 2;
- stage 2's reproduction runs on it;
- the fix (stage 3) is written with the weakness in view, and the class is hunted at every
entry point;
- a security review tries to get around the fix before it lands;
- the disclosure read of every public text (the PR description, branch name, commit
messages, code comments and test fixtures) is done by a model that understands the
weakness;
- replies to the reporter are drafted on it, and a human still sends them.
---
## Stage 1 — Triage
**Input:** a GHSA id, or nothing (take the queue's top item).
**Artefact:** an acknowledgment drafted for a human to send, a dedup verdict naming
the ids compared, and a completed metadata block on the advisory — including an affected
version range derived from git history, never the reporter's.
**Meets:** SECURITY.md §4.1 *Target Timelines* — acknowledgment (5 business days) and
triage (14 business days), both measured **from `created_at`**: receipt, not from when we
picked it up. **Read the policy before quoting a number at a reporter.**
### Pick an item
A report waits in `triage` until a maintainer accepts it, which moves it to `draft`. An
accepted report is still open, and its clocks keep running from `created_at`.
`open_reports` lists both kinds, leaving out our own drafts, which carry no `submission`:
```bash
open_reports() {
for s in triage draft; do
gh api "/repos/$REPO/security-advisories?state=$s&per_page=100" --paginate \
--jq '.[] | select(.state == "triage" or .submission != null)'
done
}
open_reports | jq -rs 'map(. + {untouched: (.updated_at == .created_at)})
| sort_by((.severity as $s | ["critical","high","medium","low"] | index($s)) // 9,
(if .untouched then 0 else 1 end), .created_at)
| .[] | [.ghsa_id, .state, .severity, .created_at[:10], (if .untouched then "UNTOUCHED" else "-" end), .summary] | @tsv'
```
Rank untouched criticals first, then by age. A named GHSA id skips this. Print only the
record's metadata; the full record, description included, goes to a file under the next
heading:
```bash
gh api "/repos/$REPO/security-advisories/$GHSA" \
--jq '[.ghsa_id, .state, .severity, .created_at[:10], .summary] | @tsv'
```
### Working files never live in a checkout
An advisory's `description` is an unpublished vulnerability report, and its comment
thread can carry the reporter's proof of concept. Keep every scratch file out of the repo
tree, in one private directory named once and used throughout:
```bash
WORK=~/.local/state/autogpt-advisories/$GHSA && (umask 077 && mkdir -p "$WORK")
```
Read a description or a thread into a file there, never into a terminal or a transcript:
advisory bodies carry working exploit code. Every write to an advisory carries `--silent`
or a `--jq` filter, because GitHub answers a write with the whole advisory, description
included. **What is in an advisory stays in it.**
Everyone with access to the advisory reads its thread, the reporter included, so a comment
there says only what belongs to that report, and its findings, proof of concept and the
reporter's words go into no PR, ticket, chat or other advisory.
### Read the code as it was when the report arrived
A verdict read off today's `dev` is a verdict about today's code, not about the report,
so verify each claim against `master` at the time of submission. Resolve the submission-time head first, and read there — `git show`/`git grep` take a
commit, so nothing is checked out and no worktree state moves:
```bash
git fetch origin master dev --tags
CREATED=$(gh api "/repos/$REPO/security-advisories/$GHSA" --jq .created_at)
HEAD_AT=$(git rev-list -1 --before="$CREATED" origin/master)
git show "$HEAD_AT:<path>"
```
When the path or the named code is not on `master` at that head, the report is against
development code, which SECURITY.md §8.1 puts in scope: resolve `HEAD_AT` on `origin/dev`.
A report's excerpt goes stale on its own, sometimes within a day of filing: the files
worth reporting on are the ones under active development, so an excerpt that was accurate
at `created_at` routinely disagrees with today's `dev`. That disagreement is evidence
about the elapsed time, never about the report. Such a report can still fail — but on a
premise that does not move, such as what an identifier actually means or what a check
actually admits. "The code does not say what you quoted" is the wrong reason, and the one
that reads as sloppy to a researcher who quoted it correctly.
Two cheap queries settle most rows, and it is the second that does the work:
| Query | What it settles |
|---|---|
| `git rev-parse "$HEAD_AT:<path>"` against the blob at the head you read | Identical blobs mean the verdict was read off the same bytes. Active files move, so it often fails to settle the row; run it first and plan for a fresh read anyway. |
| `git log --all -S'<the claimed sink>' -- <dir>` | Zero commits means the sink has never existed on any ref at any date, so no line-by-line reading is needed. |
**A zero from the sink search proves nothing until a control returns non-zero**, because a
mistyped pathspec returns zero identically: `-- autogpt_platform/backend/backend/scripts`
(one `backend` too many) finds no commits for `subprocess.run`, which the real
`autogpt_platform/backend/scripts` contains. Pair every search with a term
you know that directory contains, and confirm the path has history at all:
`git log --all --format= --name-only -- <path> | sort -u`.
The triage row records all of it: the submission-time head, the named file's blob there
and at the head you read, and the sink search with its control.
A report can also trail a fix by days. Look for a change to the named code on both lines
since it arrived — `git log --since="$CREATED" -G'<the named function>' origin/dev
origin/master -- <path>` — and take a fix that has already merged to stage 2's
`already fixed` verdict rather than writing a second one.
### Close it out instead, if any of these hold
- The code is in `classic/` — out of scope per SECURITY.md §8.2.
- It is spam or a test submission (a one-word title, a test of the reporting form, an
empty body; no list covers every shape, so judge it).
- It is a later resubmission of an earlier report by the same reporter — and the duplicate
test below passed.
**The closure reason is a comment on the advisory, never an append to its description.**
The description is the
reporter's submission; a maintainer's verdict written into it rewrites what they filed,
and it is public the moment the advisory is published.
The thread's routes: `GET /repos/$REPO/security-advisories/$GHSA/comments` lists it, a
`POST` there with `{"body": "…"}` adds a comment, and `PATCH …/comments/<comment_id>` edits
one (`RepositoryAdvisory` is absent from GraphQL). There is no delete, so a posted comment
can be corrected but not removed. A caller with read-only access sees only eligible
post-publication comments, and none on an unpublished advisory; the reporter, a
collaborator on their own report, sees the whole thread. Write the note to a file; a
maintainer posts it, because it reaches the reporter:
```bash
gh api -X POST --jq .id "/repos/$REPO/security-advisories/$GHSA/comments" -F body=@"$WORK/closure-note.md"
```
> **STOP — prepare this, do not run it.** `state` accepts only `published`, `closed` and
> `draft`; `triage` returns 422, so a closure can never be undone through the API. Build
> the payload, back the record up, and hand both to a human with your reason. The `PATCH`
> is theirs to run.
**Closing a duplicate never costs its reporter their credit.** Once a maintainer has
decided the close and confirmed the credits it carries, carry every credit of the closing
copy, its author's included, to the survivor first, and read the survivor's list back; a
credit it adds sends that researcher an invitation. Summarize the
overlapping evidence on the survivor too, in a comment on its thread, so stage 4 finds it
in one place. The state write itself carries nothing else:
```bash
gh api "/repos/$REPO/security-advisories/$GHSA" > "$WORK/before.json" # agent
# a duplicate, once a maintainer has decided the close and confirmed its credits:
# merge them, the closing copy's author included, into the survivor's
gh api "/repos/$REPO/security-advisories/GHSA-SURVIVOR" > "$WORK/survivor-before.json"
jq -n --slurpfile s "$WORK/survivor-before.json" --slurpfile c "$WORK/before.json" \
'{credits: ([($s[0].credits // [])[], ($c[0].credits // [])[]]
+ (if $c[0].submission != null then [{login: $c[0].author.login, type: "reporter"}] else [] end)
| map({login, type}) | unique_by(.login))}' \
> "$WORK/survivor-credits.json"
gh api -X PATCH --silent "/repos/$REPO/security-advisories/GHSA-SURVIVOR" --input "$WORK/survivor-credits.json"
gh api "/repos/$REPO/security-advisories/GHSA-SURVIVOR" --jq '[.credits[].login] | join(",")'
# human runs these two:
gh api -X PATCH --silent "/repos/$REPO/security-advisories/$GHSA" -f state=closed
gh api "/repos/$REPO/security-advisories/$GHSA" \
--jq '[.state, .closed_at, (.description|length)] | @tsv' # description unchanged
```
**On a cross-reporter pair or a draft twin, a maintainer decides whether to make the closing
copy's reporter a collaborator on the survivor**, so they can follow the fix. A carried
credit does not make them one, and a collaborator can open the unpublished survivor and its
thread, which hold the other reporter's report. Within one reporter there is nothing to
add: a submitter is already a collaborator on their own report. Treat a `PATCH` of
`collaborating_users` as replacing the list, and build the array from the current one, as
for credits. A GET returns each collaborator as a user object; the `PATCH` takes usernames:
```bash
jq -n --slurpfile s "$WORK/survivor-before.json" --slurpfile c "$WORK/before.json" \
'{collaborating_users: ([($s[0].collaborating_users // [])[].login]
+ [($c[0].credits // [])[] | select(.type == "reporter") | .login]
+ (if $c[0].submission != null then [$c[0].author.login] else [] end) | unique)}' \
> "$WORK/survivor-collaborators.json"
# a maintainer runs this, once they decide to:
gh api -X PATCH --silent "/repos/$REPO/security-advisories/GHSA-SURVIVOR" \
--input "$WORK/survivor-collaborators.json"
```
The note itself is one paragraph — verdict, the evidence a reader can re-run, what the
reporter should expect:
```markdown
🤖 Closed as a duplicate of GHSA-SURVIVOR — <one-line reason>. Triage, credit and any
resulting fix stay on GHSA-SURVIVOR, which remains open. No action is needed from you.
```
The 🤖 marker is the first visible thing, so a note an agent drafted is not read as the
maintainer's own words.
### Dedup — two steps, in this order
**Step 1 establishes that two reports are the same bug. Step 2 decides which copy
survives. Never run step 2 on the output of the reporter listing alone.**
Compare the summary and the affected file against every state, not just published:
```bash
for s in triage draft published closed; do
gh api "/repos/$REPO/security-advisories?state=$s&per_page=100" --paginate \
| jq -r --arg s "$s" '.[] | [$s, .ghsa_id, .created_at[:10], .author.login, .summary] | @tsv'
done
```
#### Step 1 — is this a duplicate set at all?
A same-reporter listing is **not** a duplicate set. Researchers file batches — a
multi-report reporter is usually filing several different bugs at once, not
resubmitting one. The shape to expect — one reporter, filed minutes apart, every row a
different bug:
```
GHSA-xxxx-xxxx-xxx1 09:14:02 high PATH_TRAVERSAL in <module A>
GHSA-xxxx-xxxx-xxx2 09:14:11 high SSRF in <module B>
GHSA-xxxx-xxxx-xxx3 09:15:20 critical RCE in <module C>
GHSA-xxxx-xxxx-xxx4 09:17:46 critical RCE in <module D>
GHSA-xxxx-xxxx-xxx5 09:20:33 medium XSS in <module E>
GHSA-xxxx-xxxx-xxx6 09:21:19 high SSRF in <module F>
```
**Two reports are one bug only when they share the affected code path, the missing
control and the attacker's prerequisites.** "Would one fix fix both?" is a precondition,
not the test: a pair that needs two fixes is two bugs, and the three criteria decide the
rest. Same file is not enough, and neither is the reporter calling it "the same pattern" — a
systematic auditor's batch is the same class of bug in the same file at different call
sites. Two shapes that pass a same-file test and fail this one: one race reported against
two call sites in a single module, each needing its own guard; and two weak defaults in a
single config file, one per constant. A shared fixing commit does not make two reports one
bug either, since one commit can carry several fixes, and separate weaknesses stay separate
even when an attack chains them.
Summaries are not enough evidence for that call — they name behaviours, not lines. The
descriptions are read on the model *Which model does which work* gives them to: a
standard-model coordinating session hands that read over by pointer and decides on what
comes back. Fetch the batch:
```bash
REPORTER=$(gh api "/repos/$REPO/security-advisories/$GHSA" --jq .author.login)
for s in triage draft published closed; do
gh api "/repos/$REPO/security-advisories?state=$s&per_page=100" --paginate \
| jq -r --arg who "$REPORTER" '.[] | select(.author.login == $who) | .ghsa_id'
done | while read -r g; do gh api "/repos/$REPO/security-advisories/$g" > "$WORK/$g.json"; done
jq -r '[.ghsa_id, .created_at, .severity, .summary] | @tsv' "$WORK"/GHSA-*.json | sort -k2
```
**If the batch is a mix, it is not a duplicate set: close nothing and work each report on
its own.** The two criticals above are RCEs in different modules; a rule that keeps the
earliest would close them both. That stop is about the batch as a whole — a genuine
duplicate *pair* inside a mixed batch is still a duplicate, and the three criteria govern
it.
#### Step 2 — within a confirmed duplicate set, the earliest survives
`created_at` decides, and nothing else: keep the earliest, close the later
resubmissions.
Text similarity can only point step 1 at a candidate pair, and must never decide *which
copy* survives. Two traps:
- **Identical titles and byte-identical descriptions do not identify the survivor.** They
show two reports are copies, not which came first, and read backwards they close the
canonical report.
- **Never infer the survivor from which copy is already closed.** A closed copy usually
means the duplicate was handled correctly and the OPEN one is the report still needing
work, even when nobody has touched it yet.
`submission.accepted` looks like a second signal and is not: it only flips at acceptance
or publication, so every copy still in the queue reads `false`. Do not read it here.
**Only close within one reporter.** A cross-reporter pair stays open: closing one costs an outside researcher their credit and their place in the
acknowledgments. That is a maintainer's decision, not a triage call — and the house
answer already exists, since `GHSA-349p-3c3r-8mjr` credits two reporters on one advisory.
### Acknowledge
The acknowledgment goes in the advisory's thread, posted by a maintainer through the
comments route above or the web UI (`.html_url`). Draft it — one paragraph: received, the
date received, that we are reproducing it, and the next date they will hear from us — and
hand it over. Do not let stage 2 start before this is drafted; the 5-business-day
promise is the cheapest one to keep and the easiest to miss.
### Score it — a CVSS vector and a CWE are required
Reporters supply a vector or a severity, which may occasionally be overstated, and often a
CWE. Derive both yourself, independently, and compare: the vector from the anchors below,
the CWE from the weakness the code path shows rather than the reporter's label. Draft both
here from the report, and finalise both after stage 2 against what was actually proved. The drafted vector waits in
the triage note until a maintainer confirms it.
Use CVSS v3.1 (`CVSS:3.1/…`) for `cvss_vector_string`, and give the CWE as `CWE-<n>` for
`cwe_ids`.
Anchors for this codebase:
| Metric | Rule |
|---|---|
| `PR` | Nearly every platform endpoint requires auth. If the PoC carries a token, it is `PR:L`. `PR:N` only for a route that genuinely serves anonymous callers. |
| `AV` | The access the exploit needs, not who hosts the install: a self-hosted default reachable over the network is `AV:N`. `AV:L` only for what is reachable from the host itself, such as a service bound to localhost, which is often not a vulnerability at all. |
| `S` | `S:C` only across a real trust boundary: tenant→tenant, container→host. Block code doing what its graph author asked is not scope change. |
| `C`/`I` | Scope to one tenant's data unless cross-tenant access is demonstrated. |
| `A` | `A:H` needs a demonstrated sustained outage, not one slow request. |
**When your vector disagrees with the reporter's:** ours is what ships. Record both,
name the single metric that differs and why, and put that sentence in the reply to the
reporter. If they dispute it once, a maintainer decides — do not negotiate twice. Never
publish a reporter's vector unexamined, and never raise severity to end an argument.
### Derive the affected versions from git history
**Never carry the reporter's range forward.** Reporters' ranges are rarely right. The
range is derived from git history every time, and the derivation is recorded in the triage note so the next reader
can re-run it.
Derive it here against the `file:line` the report names, and redo it after stage 2 —
verification is what establishes the *actually* vulnerable line. Release tags are
ancestors of both `origin/dev` and `origin/master`; `git fetch origin --tags` first.
Platform releases carry three tag families: `agpt-platform-beta-v<VERSION>` up to 0.2.0,
`autogpt-platform-beta-v<VERSION>` from 0.2.1, and the bare `v0.6.44`. Other bare `v*` tags
are Classic's, and `agpt-platform-beta-v1.0.0` is a tag with no release. `platform_tags`
lists the Platform ones in version order:
```bash
platform_tags() {
git tag --list 'autogpt-platform-beta-v*' 'agpt-platform-beta-v0.*' v0.6.44 \
| awk '{v = $0; sub(/.*v/, "", v); print v "\t" $0}' | sort -V | cut -f2
}
```
1. **Locate the vulnerable code on `origin/dev`** — `file:line` from the reproduction
note, not from the report's prose.
2. **Find the introducing commit**, two reads cross-checked:
```bash
git log origin/dev -S'<distinctive token from the vulnerable line>' --reverse \
--format='%H %ci %s' -- <path> | head -3
git blame -L <line>,<line> --porcelain origin/dev -- <path> | head -1
```
Record the sha and its author date. `-S` reports the commit that changed that token's
*count*, so a rename or a file move surfaces as the introduction; when the two reads
disagree, the older one is the lead — follow it with `git log --follow -M -C`.
3. **First affected release** — the first platform tag containing that sha, checked
against the tags' contents too, because a change picked onto `master` by hand reaches a
release under another sha:
```bash
platform_tags | while read -r t; do
git merge-base --is-ancestor <sha> "$t" && { echo "$t"; break; }
done
platform_tags | while read -r t; do
git grep -qF '<distinctive token>' "$t" -- <path> && { echo "$t"; break; }
done
```
Take the earlier answer, and run the grep at the file's old path too if it moved. When
neither finds a tag, no release is affected: record the introducing commit and its date,
give the advisory the dev-only range below, and carry on to stage 2, since SECURITY.md
§8.1 puts development code in scope. An answer of `agpt-platform-beta-v0.1.0`, the first Platform release, does
**not** mean the bug arrived in 0.1.0 — every earlier commit reports it too. The code is
in every release, so the range is one-sided.
4. **Fix release** — the same two reads on the fixing commit, and on its `master` pick if
it had one, taking the first tag that is a published release (`gh release view <tag>`),
since a tag can have none. Only a complete fix counts: a release that carries only a partial
mitigation, such as an older change that narrows the path, is never `patched_versions`,
and the advisory is not published on it. With no fix yet, `patched_versions` is left for publication and
the range is bounded `<=` the current release, `platform_tags | tail -1`, until the fix
ships and the bound becomes `< <patched>`; a dev-only range's second line waits for the
fixing commit.
5. **Write the result into the advisory's `vulnerabilities` field** in the notation below
— in the metadata `PATCH` under *Write the metadata block*, or in a `PATCH` carrying
only `vulnerabilities` (never an empty array, never a nameless package) — and into the
triage note with both shas and their dates. Where derivation was impossible, name the step that failed; never fall
back to the reporter's range.
6. **A report against CI workflows or repo tooling reaches no user, so it is closed with
credit, not published.** It goes through stages 2 and 3 like any report, records the
introducing and removing commits with their dates in the triage note, and gets no
version range. A maintainer closes it, and its closure note says that means no CVE and
no SECURITY.md listing.
**Four notations, one per case — do not invent a fifth:**
| Case | `package.ecosystem` / `.name` | `vulnerable_version_range` | `patched_versions` |
|---|---|---|---|
| Platform, first affected release derived | `other` / `autogpt-platform-beta` | `>= 0.6.62, < 0.8.3` | `0.8.3` |
| Platform, introduction predates the first tag or step 2 failed | `other` / `autogpt-platform-beta` | `< 0.6.70` | `0.6.70` |
| Platform, dev-only: no release affected (step 3) | `other` / `autogpt-platform-beta` | `">= <introducing sha:7> (unreleased)\n<= <fixing sha:7>"` | the first release whose tag carries the fix |
| Docker image, beside the Platform row when the image is affected and the range includes 0.7.1 or later | `other` / `significantgravitas/autogpt` | `>= 0.7.1, < 0.8.3` | `0.8.3` |
The package is named after the release tags, `autogpt-platform-beta-v<VERSION>`, so the
Platform cases differ only in the range's shape. The two released shapes end at the patched
release, `< <patched>`; GHSA-x9c2-wpmm-2mx4 (two-sided) and GHSA-349p-3c3r-8mjr (one-sided)
show them. Their version fields are bare semver; the Git tag that carries a release belongs
in the description, never in a version field
(`docs/engineering/security-advisory-release-notes.md`).
**Dev-only code, where the bug never reached a release, is still published.** Its one row's
range names the introducing commit, marked unreleased, then on a second line the fixing
commit, each as a 7-character sha: `">= <introducing sha:7> (unreleased)\n<= <fixing sha:7>"`.
Its `patched_versions` is the first release whose tag carries the fix (step 4), so the sync
lists the advisory under that release and an accepted credit reaches SECURITY.md. Read the
range back after writing it: if the write refuses it or drops the newline, use `, ` in
place of the newline.
**The Docker image row goes in when the image is actually affected and the range includes
0.7.1 or later.** 0.7.1 is the first release we published the single-container image for:
`platform-single-container-docker.yml` builds it on each published release, and Docker
Hub's earliest version tag is `v0.7.1`. The image is affected when the affected component
ships in it and its runtime configuration exposes the reported path, which a source install
does not settle: only nginx listens on the image's public interface, the Compose host
mappings do not apply, and generated secrets can change exposure. Record those
prerequisites in the description. The row's range is always two-sided,
`>= <the later of 0.7.1 and the first affected release>, < <its patched version>`, and its
patched version is the Platform row's, unless that release has no image, when it is the
first image tag that carries the fix. Rows that disagree on the patched version need one `security-release`
mapping comment per row, naming that row's release tag and its package as the row reads
back after the rename (*Ecosystem names*, below), and a link to each tag in the
description, or the public sync's whole run stops. Version
fields stay numeric, the description says the image's tags carry a `v` prefix, and
`latest` or a development tag is never a version (all per
`docs/engineering/security-advisory-release-notes.md`). Dev-only code gets no image row.
### Ecosystem names
**Agents write every row with ecosystem `other`**, the one value in the API's fixed list
that fits. As the last step before publishing, a maintainer names the ecosystems in the web
UI: Other, then "GitHub release" for the `autogpt-platform-beta` row and "Docker" for the
image row. No API call can set the name: a `PATCH` carrying `package.ecosystem_other` exits
0 and drops it, so a clean exit proves nothing. GitHub stores its own form of what was
typed, so the maintainer reads the rows back afterwards, and those strings are the ones to
use, in any `security-release` mapping comment included:
```bash
gh api "/repos/$REPO/security-advisories/$GHSA" --jq '.vulnerabilities[] | [.package.ecosystem, .package.name] | @tsv'
```
From then on nothing sends `vulnerabilities` through the API: a write that carries the rows
fails with 422, and resetting them to `other` would undo the names. A `PATCH` that leaves
`vulnerabilities` out still succeeds and keeps them. So every version write and the
pre-publication checks come before the rename, and a mapping comment is brought in line
after it by a `PATCH` carrying only `description`.
### Write the metadata block
**This `PATCH` waits for a maintainer.** GitHub derives the severity the reporter sees from
its vector, and each credit it adds sends that researcher an invitation, so run it once a
maintainer has confirmed the drafted vector and credits.
Use `--input` — nested arrays do not survive `-f`. GitHub derives `severity` from the
vector, so the vector is the field that matters; send `severity` only when you have no
vector.
**`credits` REPLACES the list — it does not append.** GitHub's reference for this
endpoint: *"To add a credit to an advisory, send the whole array of values."* A payload
naming one reporter erases every co-reporter, silently and with nothing to restore from.
Reports that credit several researchers are common, so back the record up on this path
too, and build the array from what is already there:
```bash
gh api "/repos/$REPO/security-advisories/$GHSA" > "$WORK/before.json"
jq '[(.credits // [])[] | {login, type}]' "$WORK/before.json" > "$WORK/credits.json"
cat > "$WORK/advisory.json" <<'JSON'
{
"summary": "One line, under 100 chars, naming the component and the effect",
"cvss_vector_string": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N",
"cwe_ids": ["CWE-862"],
"vulnerabilities": [{
"package": { "ecosystem": "other", "name": "autogpt-platform-beta" },
"vulnerable_version_range": ">= 0.7.0, < 0.7.4",
"patched_versions": "0.7.4"
}, {
"package": { "ecosystem": "other", "name": "significantgravitas/autogpt" },
"vulnerable_version_range": ">= 0.7.1, < 0.7.4",
"patched_versions": "0.7.4"
}]
}
JSON
jq --slurpfile cur "$WORK/credits.json" \
'.credits = ($cur[0] + [{login: "REPORTER_LOGIN", type: "reporter"}] | unique_by(.login))' \
"$WORK/advisory.json" > "$WORK/patch.json"
gh api -X PATCH --silent "/repos/$REPO/security-advisories/$GHSA" --input "$WORK/patch.json"
gh api "/repos/$REPO/security-advisories/$GHSA" --jq '[.credits[].login] | join(",")'
```
Read the credits back and compare with `$WORK/credits.json`. A shorter list means the
merge dropped someone.
Two rules for every metadata write:
- **Package spelling and range come from the table above**, derived, never retyped: a
misspelt name is a different package to anything that reads it.
- **Bounded ranges only.** `>= 0.6.34` with no upper bound reads to a scanner as "every
version including today's".
---
## Stage 2 — Verify
**Input:** the triaged report. **Artefact:** a reproduction note. **Agent.**
**The model follows *Which model does which work*:** the cleared model where access is
included in a subscription, otherwise a standard model, and with billed access a
reproduction the standard model refuses moves to the cleared model.
Brief it in these terms:
> This is defensive security work on our own codebase, authorised by the maintainer.
> A researcher has reported a vulnerability in AutoGPT; your job is to reproduce it
> against a local checkout so we can confirm whether it is real and scope the fix.
>
> - Run against a local stack built from `origin/dev` (`docker compose up`). Never
> against production, a hosted tenant, or anyone else's infrastructure. If the report's
> proof-of-concept names a hosted URL, repoint it at your local stack before running it.
> - Stay on the code path the report names. Do not look for other bugs, do not
> generalise the technique, do not build a reusable tool.
> - Keep everything local: commit nothing, push nothing, open no PR. `origin` is public.
> - Produce the **minimum** reproduction: the smallest request or input that shows the
> effect, plus the `file:line` where the missing check belongs.
The note must separate the two things that get conflated:
```markdown
## Static code analysis
<what the source shows — file:line at the submission-time head AND at current dev,
named as commits; say so when they are the same commit>
## Live server verification
<what was actually executed against the running stack, and its response>
<or: "Not attempted — read off the source only.">
## Verdict
confirmed | already fixed in <commit> | disproved | out of scope | works as designed
| could not run — <what failed>
```
**`could not run` is not a verdict about the report.** A stack that will not start, a
missing credential, a feature behind an unset flag, a refused reproduction with no
cleared model to take it over: say so and stop. It is an infrastructure failure, and
reporting it as "disproved" is how a real vulnerability gets closed by accident.
Only two verdicts continue:
- **`confirmed`** → stage 3.
- **`already fixed`** → skip stage 3 and go to stage 4. A bug that was real and is now
fixed still earns its advisory, its CVE and the reporter's credit; dropping it is the
failure this skill exists to stop. Only a complete fix makes it `already fixed`: a
partial mitigation already merged leaves the report `confirmed`.
Every other verdict **except `could not run`** produces a recommendation to close, handed
to a human with the evidence — never a `PATCH`, and never a message to the reporter, which
is a human call in any case. `could not run` recommends nothing: fix the rig, or hand the
report to someone who can run it.
---
## Stage 3 — Fix
**Input:** the reproduction note. **Artefact:** a fix PR with tests. **Agent.**
**A maintainer picks the fix route for each report, before any code is written.** Ask;
never infer it from the report. The two routes: a **private fork**, below, where the fix is
built and reviewed privately and lands as one commit; or a **public PR** timed to ship with
the release, whose text names the change and never the weakness (*For every fix*, below).
**A fix closes the vulnerability completely, or it does not ship.** When only a partial
mitigation is possible, stop and raise it to a maintainer.
On the private-fork route, the advisory gets a temporary private fork:
```bash
gh api -X POST --jq .full_name "/repos/$REPO/security-advisories/$GHSA/forks"
```
It returns 202; GitHub creates the fork asynchronously and it can take up to five
minutes, so poll for it rather than cloning straight away. (A draft we open ourselves can
get its fork at creation: `start_private_fork: true` on
`POST /repos/$REPO/security-advisories`.)
- **Open the fix PR inside that fork**, against the branch the fix was built on (`dev`),
never against the public repo. Push by the fork's SSH URL with an explicit refspec —
`git push [email protected]:<owner>/<fork>.git HEAD:<branch>` — never through a new
remote, so nothing can land on `origin`.
- **The fork runs no CI and refuses PR comments** ("This action is forbidden on
workspace repositories"). Run locally what CI would: the whole backend suite when
backend code changed, plus the tests of every function the fix changes, found by
grepping the tests for each name. Say what ran in the PR description; the evidence goes
on the advisory's thread, posted as in stage 1.
- **Answer a review on the fork PR with a COMMENT review**:
`gh api -X POST "/repos/<owner>/<fork>/pulls/<n>/reviews" -f event=COMMENT -f commit_id=<head sha> -F body=@"$WORK/review-reply.md"`.
For every fix:
- **Fix the class at every entry point**, not only the sinks the report names, and **test
the guard, not the exploit**: the tests assert the check the fix adds, because a working
exploit in a test file is published when the fix lands.
- **Public text names the change, never the weakness or the advisory.** Before
publication, nothing describing the mechanism goes into a public PR, branch name, commit
message or comment, and neither does an advisory or report id: a GHSA id in a commit
tells everyone reading `dev` that it fixes a vulnerability. The fork PR's title,
description and commit messages count as public, since GitHub can carry them into the
commit that lands, and so do its code comments and test fixtures: grep the diff for the
advisory and report ids before it merges.
- **A fork fix lands as one commit that shares no ancestry with an earlier fork's landed
commit**, so fork PRs landing in the same window must not edit the same lines: two that
each append to the end of one file conflict at landing, and merging one fork branch into
the other does not help. Give a fix's architecture rule its own
`autogpt_platform/backend/backend/util/architecture_<topic>_test.py` instead of
appending to a shared one; a real overlap takes a merge of `dev` into the second fork
once the first has landed. The landing commit gets a regular title naming the change,
like any PR.
---
## Stage 4 — Author the advisory body
**Input:** the reproduction note, plus the fix PR — or, for an `already fixed` verdict,
the commit and release that fixed it. **Artefact:** the published description.
**Agent drafts, human approves.**
The reporter's text is *evidence*. The published body is a different document for a
different audience — someone running AutoGPT who needs to know if they are affected and
what to upgrade to.
Write it fresh, in this template. **The description holds only what no structured field
holds.** Credit goes in `credits`, affected and patched versions in `vulnerabilities`,
severity as the CVSS vector, the CWE in `cwe_ids` — all set under *Write the metadata
block* — and none of them is restated in the body.
The reporter's submission is source material, not an appendix: reuse its good parts inside
Details and Proof of concept, and append nothing. Drop every horizontal rule (`---`, `***`,
`___`) from the text you reuse: the only one in the body is the `---` before `### Details`.
Back it up before the `PATCH`, which overwrites `description`, the only copy — the API
exposes no version history.
```bash
gh api "/repos/$REPO/security-advisories/$GHSA" --jq .description > "$WORK/original.md"
```
What a reader acts on comes first: a summary before any heading, then Impact, Fix and
Workarounds. A `---` line then sections off Details, Proof of concept, References and
Timeline, so a long proof of concept never buries the upgrade. Write the vulnerability in
past tense from the first draft (it *could*, a user *was able to*): the body is published
once the fix has shipped, so there is no tense to change later.
```markdown
<At most three sentences, before any heading: what was affected, who could exploit it,
and what to do about it.>
### Impact
<Who was affected and what an attacker could get. Two sentences. Name the privilege
required — "any authenticated user could", not "an attacker could".>
### Fix
**Fixed in [AutoGPT Platform vX.Y.Z](https://github.com/Significant-Gravitas/AutoGPT/releases/tag/autogpt-platform-beta-vX.Y.Z).**
<or, for dev-only code:> **No release was affected. The fix shipped in [AutoGPT Platform vX.Y.Z](https://github.com/Significant-Gravitas/AutoGPT/releases/tag/autogpt-platform-beta-vX.Y.Z).**
<What changed for the user, in a short plain-language paragraph. No file or function
names: those belong in Details.>
Fix: [#NNNNN](https://github.com/Significant-Gravitas/AutoGPT/pull/NNNNN). <only with a public PR>
Fix evidence: [0123456789ab](https://github.com/Significant-Gravitas/AutoGPT/commit/<full sha>).
Upgrade to vX.Y.Z or later. Version numbers in this advisory identify Platform releases,
whose Git tags are `autogpt-platform-beta-v<VERSION>`, rather than the backend Python
package version. The `significantgravitas/autogpt` Docker image is tagged `v<VERSION>`. <only with an image row>
<only when the image row's patched release differs from the Platform row's:>
The Docker image is fixed in [AutoGPT Platform vA.B.C](https://github.com/Significant-Gravitas/AutoGPT/releases/tag/autogpt-platform-beta-vA.B.C).
<!-- security-release: {"tag": "autogpt-platform-beta-vX.Y.Z", "package": {"ecosystem": "<as read back>", "name": "autogpt-platform-beta"}} -->
<!-- security-release: {"tag": "autogpt-platform-beta-vA.B.C", "package": {"ecosystem": "<as read back>", "name": "significantgravitas/autogpt"}} -->
### Workarounds
<A concrete mitigation for someone who cannot upgrade today, or "None.">
---
### Details
<Root cause, in our own words and in past tense: `file:line` and the check it lacked. Pre-empt the
scope question: say plainly that this is supported platform code. Reuse the reporter's text where it
is good.>
### Proof of concept
<The minimum reproduction from stage 2. Nothing weaponised.>
### References
<Fix PR, commit, related advisories. GitHub's repository-advisory API has no
`references` field, so these live here or nowhere.>
### Timeline
<Reported YYYY-MM-DD · Triaged YYYY-MM-DD · Fixed YYYY-MM-DD · Published YYYY-MM-DD.>
```
In Fix, vX.Y.Z is the first release that carries the fix, derived in stage 1 (*Derive the
affected versions from git history*, step 4), and `Fix evidence` is the commit the fix
landed as, its sha cut to 12 characters. Each release link uses that release's own tag,
from `platform_tags`. `Fix` names a public pull request and is dropped
where none exists, as for a fix that landed from a private fork. The tag link in Fix's first line is load-bearing:
the public sync lists an advisory under a release only when its description links that
release's tag and one of its package rows gives that release's version as
`patched_versions` (`docs/engineering/security-advisory-release-notes.md`).
> **STOP — the `PATCH` below replaces the reporter's description, which they see at once.**
> Write the body to `$WORK/advisory-body.md` and hand it to a maintainer; run the `PATCH`
> only once they have approved that draft. An unattended run stops at the draft.
```bash
jq -n --rawfile d "$WORK/advisory-body.md" '{description: $d}' > "$WORK/body-patch.json"
gh api -X PATCH --silent "/repos/$REPO/security-advisories/$GHSA" --input "$WORK/body-patch.json"
```
---
## Stage 5 — Raise to a maintainer
**Input:** everything above. **Artefact:** a published advisory. **Human decides.**
Hand over: the GHSA id, the fix PR — or, on the `already fixed` route, the commit and the
release that carried it — your CVSS vector next to the reporter's, and the drafted body. The maintainer reviews the body, merges the fix, and publishes.
**Publication is per advisory, triggered by the fix landing in a release.** As soon as the
patched version is a real release tag, this advisory is ready; holding it for a batch
leaves users on an affected release without the alert.
The 120-day clock in the policy's §4.1 *Target Timelines* runs from **receipt**. Escalate
to the maintainer at day 105 with either a publication date or a reason; it is a backstop
that fires with or without a release. Nothing computes that date inside a single run —
the daily sweep's deadline query is what surfaces it.
### Pre-publication checks
Run them all.
| Check | Command / rule |
|---|---|
| Fix is in a release | For the `autogpt-platform-beta` row, with its `patched_versions` as `$PATCHED` and its tag as `$TAG` (the lookup below the table): `gh release view "$TAG"`, and that tag contains the fix, `git merge-base --is-ancestor <fix> "$TAG"`. `<fix>` is the landed commit on `dev` or `master` (for a fork fix, the commit it landed as, never the fork PR's head), or its `master` pick; when no pick's sha is known, run stage 1, step 3's tag-contents check on every line the fix adds, since a hand pick can carry part of a fix. For the image row, with its own `patched_versions` as `$IMAGE_PATCHED`, since it can differ from the Platform row's, Docker Hub has that tag: `curl -sf -o /dev/null "https://hub.docker.com/v2/repositories/significantgravitas/autogpt/tags/v$IMAGE_PATCHED"`, exit 22 when it does not. Dev-only code takes the same gate, on the release its `patched_versions` names. |
| Range is derived and bounded | the two shas and dates are in the triage note (stage 1, *Derive the affected versions from git history*), and the upper bound is `< <patched>` — never absent, never the reporter's. Dev-only code takes the commit form instead (stage 1, *Derive the affected versions from git history*), read back after the write |
| Package spelling | `other` / `autogpt-platform-beta` with the stage 1 range shape that matches the case — no other spelling — plus `other` / `significantgravitas/autogpt` when the image is affected and the range includes 0.7.1 or later, with the image's prerequisites in the description. The ecosystem is `other` before the maintainer's rename and the read-back name after it (*Ecosystem names*, stage 1). Dev-only code has the one `autogpt-platform-beta` row and no image row |
| References present | `### References` non-empty, or explicitly "none" |
| Body is ours | not the reporter's submission republished |
| Past tense | the opener, Impact and Details describe the vulnerability in past tense |
| Credits invited | the credits query below the table lists each credit's state. A pending credit does not hold publication: it joins the acknowledgments when the researcher accepts it, since the sync re-reads credits on every run. |
| CVE requested | **STOP** — prepare `gh api -X POST --silent "/repos/$REPO/security-advisories/$GHSA/cve"`; a human runs it. **Every confirmed in-scope vulnerability gets one, whatever the severity**, bar a stage 1, step 6 report, which is closed rather than published. *Published, but no CVE was requested* below lists the published advisories without one. |
| Duplicate cluster resolved | this advisory is the survivor of *its own* duplicate set — every later resubmission of **this bug** closed as a duplicate, with the reason in a comment on that advisory, its description unchanged, its credits carried here and its overlapping evidence summarized here. The reporter's other open reports are other bugs and stay open; see step 1 |
The tag lookup and the credits query, kept out of the table so they copy intact:
```bash
TAG=$(platform_tags | grep -xE "(autogpt-platform-beta-|agpt-platform-beta-)?v${PATCHED//./\\.}")
gh api "/repos/$REPO/security-advisories/$GHSA" --jq '.credits_detailed[] | [.user.login, .state] | @tsv'
```
### Publish, then close the loop
The last step before it is the maintainer's rename of the ecosystems and the read-back
(*Ecosystem names*, stage 1), after every check above has passed.
> **STOP — a human runs both of these.** Publication is irreversible and public: it
> pushes the advisory into GitHub's vulnerability database. Hand over the checklist
> results and the drafted body; do not run the `PATCH`.
```bash
gh api -X PATCH --silent "/repos/$REPO/security-advisories/$GHSA" -f state=published
```
SECURITY.md's acknowledgments and the releases' security sections are generated by the
public advisory sync (`.github/workflows/security-advisory-sync.yml`), never edited by hand;
`docs/engineering/security-advisory-release-notes.md` describes it. It reads published
advisories only. It lists a researcher once their credit is accepted, so a pending credit
joins the acknowledgments when the researcher accepts it, and a credit carried to a
survivor may need accepting again there. It names every published advisory that no
published release lists: link the fixing release's tag in the description and match
`patched_versions` to that release, and the next run picks it up. Package rows that
disagree on the patched version without one mapping comment per row stop its whole run.
Then: tell the reporter it is published, and close any tracking ticket.
---
## Endings off the main path
Four cases the stages above do not reach. Each has an ending, because an advisory with no
ending is where an agent improvises.
### The twin is a `draft`, not a queued report
A draft with no `submission` is ours: a maintainer created it, so a twin there usually
means we found the bug ourselves and are already fixing it. Step 1's reporter batch matches
the reporter's login, which our drafts never carry, so search them explicitly:
```bash
gh api "/repos/$REPO/security-advisories?state=draft&per_page=100" --paginate \
--jq '.[] | select(.submission == null) | [.ghsa_id, .created_at[:10], (.summary // "")] | @tsv'
```
A draft with a `submission` is an accepted report, and step 1 treats it like a queued one:
the same reporter's copy is in their batch, and another reporter's makes a cross-reporter
pair.
Our draft's author is a maintainer, so the pair spans two reporters and a maintainer
decides it; the queued copy stays open until they do. If they make the draft the survivor,
**add the reporter to the draft's credits first**, using the merge above. Do not close a
researcher's report against our own draft while that draft has no credits entry for them:
it is the one path that removes an outside reporter from the record entirely.
### The reporter withdrew
`withdrawn_at` is read-only, so a withdrawal arrives
as a comment on the advisory rather than as a field. Check the field, and read the thread
into a file, before starting work:
```bash
gh api "/repos/$REPO/security-advisories/$GHSA" --jq '[.state, (.withdrawn_at // "-")] | @tsv'
gh api --paginate "/repos/$REPO/security-advisories/$GHSA/comments" > "$WORK/comments.json"
```
Hand the closure to a maintainer with the withdrawal as the reason. Never publish it,
never request a CVE for it, and never credit the reporter without asking them first. If the bug is real, it is a
finding of ours — open a draft; do not publish theirs.
### Published, but no CVE was requested
Publication is not the end of the queue. Every confirmed in-scope vulnerability is meant
to have a CVE, and this lists the published advisories without one:
```bash
gh api "/repos/$REPO/security-advisories?state=published&per_page=100" --paginate \
| jq -r '.[] | select(.cve_id == null) | [.ghsa_id, .published_at[:10], .severity] | @tsv'
```
**STOP** — prepare the `POST …/cve` and hand it over. If it returns 400 or 422 on an
already-published advisory, that is the answer: it goes to GitHub Support, not into a
retry loop.
### The fix turns out not to fix it
**Stop. None of this is an agent action.** Publication cannot be undone — `withdrawn_at`
is read-only and `withdrawn` is not a writable `state`, so only GitHub Support can retract
an advisory. Tell a maintainer and the advisory's publisher the same hour, treat the
vulnerability as live and unfixed, and take the new fix back through stage 3 on a private
fork. Update the **existing** advisory — corrected version range, new patched version, a
Timeline entry — rather than opening a second one. A renamed row's versions change in the
web UI, since the API refuses its ecosystem.
**Open question, for a maintainer and not for this file:** whether an incomplete fix
warrants a second CVE. Common practice issues one. Ask.
---
## What SECURITY.md promises, and where this skill keeps it
Section numbers are SECURITY.md's.
| Promise (*section*) | Where | Kept, or only surfaced |
|---|---|---|
| Acknowledgment in **5 business days** (§4.1 *Target Timelines*) | Stage 1 | **Surfaced.** The skill drafts; a human must post it, nothing records that it was sent, and business-day arithmetic is absent |
| Triage in **14 business days** (§4.1 *Target Timelines*) | Stage 1 | **Surfaced.** The artefacts are real; no deadline is computed |
| Remediation in **90 days** (§4.1 *Target Timelines*) | Stage 3 | **Surfaced only.** Stage 3 carries no clock |
| Disclosure in **120 days of report** (§4.1 *Target Timelines*) | Stage 5 + the sweep's deadline query | **Surfaced.** Depends entirely on the sweep running daily |
| Keep reporters informed (§4.2 *Communication*) | Stages 1, 2, 5 | **Surfaced.** All three are human-in-the-UI actions |
| Fix before publish (§5 *Coordinated Disclosure*) | Stage 5 checklist | **Kept.** `gh release view` is a real gate |
| Credit, subject to consent (§9 *Recognition*) | Stages 1 and 5 | **Kept.** The sync lists only accepted credits |
Both clocks start at `created_at`. When a deadline has already passed, record the real
dates in the Timeline section anyway. Nothing here becomes
*kept* rather than *surfaced* without the per-advisory ledger described below.
---
## Running as a daily sweep
A scheduled run enumerates the queue and works items in rank order:
```bash
# open_reports is under *Pick an item*
# never answered — the acknowledgment backlog
open_reports | jq -r 'select(.updated_at == .created_at) | [.ghsa_id, .severity, .summary] | @tsv'
# approaching a deadline — every open report, queued or accepted, touched or not
open_reports | jq -r --argjson now "$(date +%s)" '
(($now - (.created_at|fromdate))/86400|floor) as $age | select($age >= 105)
| [.ghsa_id, .state, .severity, $age, .summary] | @tsv' | sort -t$'\t' -k4,4 -rn
```
A third pass belongs in the same run: the published advisories with no CVE, under
*Endings off the main path*. The second query is what carries the day-105 escalation and
the 120-day backstop. It must not filter on `updated_at`: an advisory leaves the untouched set the moment stage 1 writes
its metadata.
**What the sweep needs that this skill cannot give it:**
- **A durable per-advisory ledger.** GitHub records no "acknowledged" or "triaged" state,
and `updated_at` moves on any edit — so a sweep cannot distinguish a report we replied
to from one nobody has read. It needs its own store keyed by GHSA id (ack sent, triage
verdict, owner, next action).
- **A maintainer to send the acknowledgment.** The comments route can post it, but
anything sent to a reporter is a maintainer's call, so the sweep can only queue the
draft.
- **A maintainer on duty.** Severity confirmation, the stage 3 fix route, disclosure, CVE,
merge and publication are human. An unattended 03:00 run writes no fix: on a `confirmed`
report it stops after stage 2, queues the route question and leaves stages 3 and 4 to a
session that has the answer, because stage 4 needs the fix. Only an `already fixed`
report reaches stage 4, and the run stops at its draft.
- **The other intake channels.** The sweep sees GitHub advisories only. Reports that
arrive by other channels need their own check.
- **Business-day arithmetic.** The 5- and 14-day promises are business days, holidays
included.
Alerting is the point: without a sweep, nothing counts how long a report has waited, and
a sweep that only counts is already worth running.