What each part of Aegis does, what it needs from you, and what it will not tell you.
Generated from the same registry the application reads, which is checked against the repository by a test. A capability that lost its implementation would fail that test rather than quietly keep its page here.
Who can see and change what, across single sign-on, roles and tenancy.
Change one finding's severity for this organisation with a written reason. The scanner's own value is kept, a rescan does not undo the decision, and the change, the person and the reason appear in the finding's history and the audit log. Setting it back to the scanner's value clears it.
One finding at a time; a whole group cannot be adjusted at once.
Implemented in: src/lib/finding-history.functions.ts, src/components/finding-history.tsx
Tested by: tests/rls/severity-adjustment.test.ts
Scoped tokens that can never exceed the permissions of the person who created them, with rotation and revocation. API access can be restricted to an organisation's allowlist of source addresses, enforced server-side on every request.
Implemented in: src/lib/credentials.ts, src/lib/access.ts, src/lib/ip-allowlist.ts, src/lib/ip-allowlist.functions.ts
Tested by: tests/unit/credentials.test.ts, tests/rls/public-api.test.ts, tests/unit/ip-allowlist.test.ts, tests/rls/org-ip-allowlist.test.ts
Append-only record of security-relevant actions, exportable as CSV.
Implemented in: src/lib/identity.functions.ts
Tested by: tests/rls/identity.test.ts
Select findings on the feed and set a status, assign or clear a team, or snooze or ignore them together, with a reason that lands on every finding's history and as one audit row per finding. A change and its record are one transaction, so a refused finding fails the whole batch, and assignment is limited to the organisation's own teams and members.
Assignment to a person is in the API; the feed's bar assigns teams.
Implemented in: src/components/bulk-actions.tsx, src/lib/workflow.functions.ts
Tested by: tests/rls/bulk-actions.test.ts, tests/integration/bulk-triage-postgrest.test.ts
Free-form labels such as payments or pii on a repository or container image, edited on the repository page and the Containers page, and a label filter on the findings feed that keeps the findings on labelled resources: those on the asset itself and every dependency finding whose repository carries the label. Filtered in the database, so the feed's 500-row cut never hides a labelled finding, and a rescan keeps the labels a person set.
Labels are typed by hand. GitHub topics and Kubernetes workload labels are not imported.
Implemented in: src/lib/asset-labels.ts, src/lib/asset-labels.functions.ts, src/components/asset-labels.tsx
Tested by: tests/unit/asset-labels.test.ts, tests/rls/asset-labels.test.ts, tests/integration/asset-labels-postgrest.test.ts
Six built-in roles plus organisation-defined custom roles, with every permission checked in the database.
Implemented in: src/lib/access.ts, src/lib/identity.functions.ts
Tested by: tests/unit/access.test.ts, tests/rls/rbac.test.ts
A named set of the findings feed's filters, saved per person and optionally shared with the organisation. Only the person who saved a view can change or delete it, and a view saved by an older version of the page still applies, naming any filter it had to reset.
Views cover the findings feed only.
Implemented in: src/lib/saved-views.ts, src/lib/saved-views.functions.ts, src/components/saved-views.tsx
Tested by: tests/unit/saved-views.test.ts, tests/rls/saved-views.test.ts
SAML/OIDC configuration and SCIM 2.0 user provisioning and deprovisioning, including session revocation on deprovisioning.
Configure an identity provider under Settings. SCIM is off until an admin enables it and issues a scoped token.
Implemented in: src/lib/identity.functions.ts
Tested by: tests/rls/scim.test.ts
Team objects with membership, used to route ownership of assets and findings. Ownership rules assign findings nobody owns by module, severity, repository and the path of the file they are in, so one monorepo can belong to several teams; a finding no rule claims goes to the team a GitHub repository's CODEOWNERS names for its file (`@org/payments` is the Aegis team `payments`), read on every scan pass by GitHub's own rules -- last match wins, a line with no known team leaves the file unowned.
Teams are never created from CODEOWNERS: a contributor can edit that file, and a pull request must not be able to add an organisation's teams. CODEOWNERS is read for GitHub repositories only; GitLab's file uses another lookup order and section syntax, and GitLab, Bitbucket and Azure DevOps repositories use path rules instead. An assignment somebody made is never overwritten.
Implemented in: src/lib/identity.functions.ts, src/lib/codeowners.ts, src/lib/persist.server.ts
Tested by: tests/rls/identity.test.ts, tests/unit/codeowners.test.ts, tests/unit/assignment-rules-are-applied.test.ts, tests/integration/codeowners-github-e2e.test.ts
Every tenant-scoped table is protected by Postgres row-level security, so isolation is enforced by the database rather than by application code remembering to filter.
Implemented in: src/lib/access.ts
Tested by: tests/rls/tenant-isolation.test.ts, tests/rls/rbac.test.ts
Reading repositories, and writing back to them as pull requests and checks.
Sends a repository's open findings to GitHub code scanning as SARIF, on the head of its default branch, through the organisation's GitHub connection, and reports what GitHub processed. Severity comes through as GitHub shows it, a re-upload updates alerts rather than duplicating them, and a finding Aegis no longer reports open is closed on GitHub as fixed.
Public repositories, or private ones with GitHub Advanced Security. Sent on request from the repository page, not after every scan.
Implemented in: src/lib/github-code-scanning.ts, src/lib/github-code-scanning.functions.ts
Tested by: tests/integration/code-scanning-github-e2e.test.ts
Device-code sign-in, GitHub App installation or personal access token, with repository inventory and file-content scanning. Each repository has its own page listing every open finding -- dependencies, code, secrets, infrastructure, supply chain -- grouped into the upgrades and rules they are, each with the fix Aegis can write or the reason it cannot, and the pull request can be created from there. The Findings and Fix sections start from a repository: a picker above their tabs, remembered per organisation, and every tab and its badge then shows only that repository's findings, fixes, scans, plans and pull requests. The page also shows what the repository is made of, read from its file paths: languages with the SAST coverage each gets, package managers, CI, containers, infrastructure, entry points, and how many files are application code rather than tests, fixtures or docs. An architecture and data-flow view is drawn from the files the scan reads: the routes each module declares, the data stores, queues, services and authentication its files import, and the configuration it reads from the environment, each node naming the file that proves it; a data flow is shown only where one module both declares the route and holds the store's client, and open findings are laid over the module and route that contain them. It states the branch and commit it was read from.
Implemented in: src/lib/github.server.ts, src/lib/github-app.server.ts, src/lib/github.functions.ts, src/lib/github-device-flow.ts, src/lib/autofix-eligibility.ts, src/lib/scan-lifecycle.ts, src/lib/nav-counts.ts, src/components/repo-scope.ts, src/components/repo-scope-gate.tsx, src/lib/diff-view.ts, src/lib/scan-budget.ts, src/lib/durable-dispatch.server.ts, src/lib/subrequest-tally.ts, src/lib/repo-archive.server.ts, src/lib/tar-stream.ts, src/lib/repo-issues.ts, src/lib/repository.functions.ts, src/lib/repository-profile.ts, src/lib/repository-architecture.ts
Tested by: tests/unit/repo-issues.test.ts, tests/unit/repository-profile.test.ts, tests/unit/repository-architecture.test.ts, tests/unit/github-app.test.ts, tests/unit/github-auth-paths.test.ts, tests/unit/github-device-flow.test.ts, tests/unit/autofix-eligibility.test.ts, tests/unit/findings-reach-the-ui.test.ts, tests/unit/scan-lifecycle.test.ts, tests/unit/scans-finish.test.ts, tests/unit/nav-counts.test.ts, tests/unit/repo-scope.test.ts, tests/unit/diff-view.test.ts, tests/unit/scan-budget.test.ts, tests/unit/subrequest-tally.test.ts, tests/unit/tar-stream.test.ts, tests/unit/repo-archive.test.ts, tests/unit/the-product-says-what-it-knows.test.ts, tests/unit/scan-button-runs-in-an-object.test.ts
Repository inventory and pull/merge request review across GitLab, Bitbucket Cloud and Server, and Azure DevOps. A self-managed instance behind Cloudflare Access is reached with an Access service token stored beside the provider token and sent on every call to that instance (connect, repository list, commit status); a refusal by Access is reported as Access, not as a bad provider token, and an Access login redirect is not followed -- measured against the owner's gitlab.aegis.sarl: no token and a made-up token refused at the edge, the real token admitted. Repositories on GitLab, Bitbucket Cloud and Azure DevOps are scanned through each provider's own API, and Scan on the Repositories panel is the only trigger (DEC-037): there are no incoming push webhooks for these providers (removed, DEC-037). One scan (`runScmScan`, `src/lib/scm-scan.server.ts`) resolves the default branch to its head commit, lists the tree at that commit once, reads the dependency manifests and then up to 300 files, and runs the secrets, IaC, SAST, SCA and code-quality engines over what it read. It writes one scan row and keeps no walk state: what was not read is counted in the scan's stats and its coverage says so, so a large repository is never reported as fully clean. Findings are closed only for files the scan read and only when the listing was whole; dependency findings only when every manifest was read. A provider's rate limit stops the scan and is recorded on it, rather than pushed through. GitLab is measured end to end against the owner's instance through Access: a planted command injection and token were reported against their file and closed once it was deleted (`tests/integration/scm-scan-gitlab-live.test.ts`). Bitbucket and Azure DevOps reading is measured against public repositories on their real APIs. Merge request review (the code is kept; nothing starts it on its own, DEC-037): a GitLab merge request was reviewed as a merge request: its changed files are scanned under its own target (so a scan of the default branch never closes them), the merge gate weighs each finding at the rule's severity, an `aegis/security` commit status is written that a protected branch can require, findings on changed lines are posted as positioned discussions, and a summary note says what was and was not read. A review run again on the same head posts nothing new -- measured against the owner's GitLab: a planted command injection produced a failed status and a discussion on its line.
Add a token for the provider under Integrations. Bitbucket Server cannot enforce a merge gate, and says so rather than appearing to. A reviewer's reply accepting a finding on a GitLab merge request is not yet recorded as an exception, Bitbucket pull requests are scanned at their source branch rather than reviewed, and the secret-history walk, the dependency inventory, AI code review and scan profiles read through GitHub only (each refuses another provider's repository by name rather than failing on it). Maven, Gradle and NuGet manifests are not pinned, so on these providers they are read only when they fall on the page. Bitbucket and Azure DevOps scanning has not yet been run against a connected account with findings. Bitbucket Server webhooks are refused at registration, since the receiver reads Cloud payloads only.
Implemented in: src/lib/scm.ts, src/lib/scm-connection.server.ts, src/lib/scm-request.server.ts, src/lib/scm-reader.server.ts, src/lib/scm-scan.server.ts
Tested by: tests/unit/scm.test.ts, tests/unit/scm-reader.test.ts, tests/integration/scm-scan-gitlab-live.test.ts, tests/integration/scm-reader-public-live.test.ts, tests/unit/scm-request.test.ts, tests/integration/scm-cloudflare-access.test.ts
Per-PR delta scanning with line-level review comments and an `aegis/security` commit status. Nothing starts on a push: reviews and scans start only when the owner asks (DEC-037). A reviewer who replies `intentional`, `accepted`, `false positive`, `wontfix` or `aegis: ignore` under an Aegis comment suppresses that finding on the next pass: it is recorded as a 90-day exception quoting the reviewer and reply, is not re-commented, and does not fail the status. The acceptance follows the code, not the line: if the line the comment was about changes, the finding is reported again with a note that the earlier acceptance no longer applies. Replies from bots or from the account that posted the comment do not count, and an acceptance an admin revoked in the product is not re-applied. When a PR changes a lockfile, the review lists what it does to the dependency tree: packages added (and how many are transitive), changed and removed, with every incoming package published in the last seven days or running an install script tabulated. Packages the registry would not answer for are named as not assessed, never counted as clean.
Implemented in: src/lib/review-fix.ts, src/lib/review-fix.functions.ts, src/lib/deep-review.ts, src/lib/deep-review.functions.ts, src/lib/pr-comments.ts, src/lib/pr-accept-replies.ts, src/lib/github.server.ts, src/lib/supply-chain/dependency-diff.ts, src/lib/supply-chain/pull-dependencies.ts
Tested by: tests/unit/review-fix.test.ts, tests/integration/review-fix-github-e2e.test.ts, tests/unit/deep-review.test.ts, tests/unit/pr-comments.test.ts, tests/unit/pr-accept-replies.test.ts, tests/unit/commit-status.test.ts, tests/unit/branch-protection.test.ts, tests/unit/dependency-diff.test.ts, tests/unit/pull-dependencies.test.ts, tests/integration/pr-dependency-diff-github-e2e.test.ts
What is wrong in the code and its dependencies, and how far it is actually reachable.
Dependency version bumps, deterministic configuration fixes and AI-generated source fixes, raised as a branch and pull request after the repository's own install, typecheck, lint and test scripts have been run against the change in an isolated copy. A dependency bump installs the lowest release OSV reports no advisory against, not merely the advisory's own fix, and a rescan of the default branch closes the findings it resolved -- proven by scanning, fixing, merging and rescanning a real repository, for a dependency and for a Terraform finding, and by delivering the merge's push through the signed webhook. Autonomous autofix is removed (DEC-037): nothing opens these pull requests unattended. It used to open them itself -- one upgrade per package and repository, highest risk first, a daily cap, never the same upgrade twice, with the organisation's branch prefix, commit prefix and notes -- and a scanner node advertising autofix-validate runs the repository's own checks on the branch before the pull request opens. The node ships as a container (scanner-node/Dockerfile, docs/SCANNER_NODE_HOSTING.md) with git, Node, npm, pnpm and yarn pinned, runs as a non-root user with the workspace on tmpfs, and makes only outbound calls, so it runs on a NAS, a VPS or any Docker host. Nodes now start only with an operator-issued one-time connect ticket and receive work over a direct WebSocket session (no claim-poll or run-once mode); the copied GitHub Actions template is manual-only and starts a ticket-bound session. Historical production validation of the earlier claim-poll node: with no node on the developer's machine, the container claimed the job and its report opened a verified pull request; on 27 September the compose service (restart policy unless-stopped: a crashing container on the same image was restarted seven times in ten seconds; a host reboot has not been observed) validated a sandbox lodash fix whose single commit carried package.json and package-lock.json, and `npm ci` and the test passed on the branch; and, with that service stopped, the same template's steps and environment run in a clean node:22 container (not on GitHub's runners) drained a fix queued from the fix window, exited 0, and the pull request opened verified; and the same image, loaded into the Docker of a UGREEN DXP4800 Plus NAS itself (not a VM on it) and started with the compose file, claimed a production fix and opened it verified with npm ci and the test passing. The repository's install and tests run on the node without access to its credentials: the node re-executes itself with neither token in its environment and is non-dumpable, scripts run with credential-shaped variables removed, git authenticates per command rather than through a URL written to .git/config, and a job whose branch git could read as an option is refused -- proven by a hostile npm on a real node finding nothing in its environment or any ancestor's /proc entry, and on production through the hardened DXP node. The node needs no GitHub credential at all: each repository job is handed a codeload archive address the control plane mints with the organisation's own credential -- measured to serve one repository at one ref, with no credential, and to expire within five minutes -- and the node refuses an archive from any other host. Proven by a real node with no GITHUB_TOKEN and git replaced by a trap validating the private sandbox repository. The fix window offers node validation only while a ticket-bound session is connected; without an active session it says validation is unavailable instead of waiting on an offline poller. The unattended run is gone (DEC-037), so its rule that it used only a node polling at that moment no longer applies. Historical validation evidence from before direct sessions: the branch was pushed, a connected node ran the install, typecheck, lint, test and build, regenerated a lockfile the editor left to npm, and the pull request opened with its checks -- measured on production with a node registered from the Scanner Nodes page: cookie-parser via its parent and diff via an override, each opened as verified with `npm ci` and the repository's test passing, the override's package-lock.json regenerated by npm on the node. Following a fix pull request back is removed (DEC-037): the `fix.pulls` job that did it every half hour has no starter, so a pull request closed without merging does not return its findings to open and a merged one is not verified by a scan of the files it changed, and a finding stays in progress until the next owner scan decides it. What the follower did when it ran, kept for the evidence below: one closed without merging returned its findings to open, and a merged one was verified by scanning the files it changed at the default branch, closing what is gone and reopening what is still there -- proven end to end from the repository page against a real repository. An npm fix is one commit carrying package.json and package-lock.json together, the lockfile edited without running npm: each moved package's registry entry, integrity and flags, the dependencies the new release needs moved to their lowest accepted release, and every dependant in the tree checked to still be satisfied. Where that cannot be done exactly -- a package installed more than once, one with nested dependencies of its own, one from outside the public registry, one the manifest overrides, or a lockfile older than version 2 -- the lockfile is left alone and the pull request says why. A transitive package whose single direct parent has released a version depending only on fixed releases of it is fixed by upgrading that parent, within its major, before an override is considered: the fix its maintainers made, and the only fix where the override would be a breaking upgrade (cookie-parser 1.4.6 -> 1.4.7 for cookie 0.4.1, whose fix 0.7.0 is a new minor at 0.x) -- measured end to end on production: the scan found cookie 0.4.1 in the sandbox, the fix window opened one commit with package.json and a package-lock.json byte-identical to npm's own, npm ci installed the branch, and after the merge the rescan closed the finding. The parent route is offered from the fix window and the Autofix page, not by autonomous autofix, because whether it exists is only known from the lockfile and a refusal spends the daily cap. The parent is read from whichever lockfile the project has -- package-lock.json, pnpm-lock.yaml (lockfile 6.0 and 9.0), yarn.lock (1 and Berry) or bun.lock (lockfile-parents.ts, tested on lockfiles written by each tool) -- and for those other than npm's the scanner node regenerates the lockfile with the repository's own package manager: measured on production with a pnpm project and a yarn 1 project, where cookie-parser was raised via pnpm-lock.yaml and yarn.lock and each pull request opened verified with the frozen install and the test passing. Yarn Berry and bun are tested on lockfiles those tools wrote, not yet on production. A transitive package whose every dependant already declares a range admitting the fix is fixed in package-lock.json alone -- no manifest change, no override, byte-identical to `npm update <pkg>` -- measured on production: js-yaml 4.1.0 under cosmiconfig's ^4.1.0 moved to 4.3.2, the pull request opened verified, and the merge closed five findings. It applies only where package-lock.json is what installs the project -- not beside a pnpm, yarn or bun lockfile, nor under another `packageManager`. How often each route applies, measured two ways on production's 1,684 open transitive npm findings: a read-only pass over all of them with each finding's own fixed version gives 105 parent upgrades (61 npm, 39 pnpm, 5 yarn), 158 lockfile-only and 1,421 overrides or refusals (1,102 in pnpm projects, where most packages arrive through a longer chain); the real plan, run read-only on a random 60 -- it first raises the version to the lowest release OSV clears -- gave 2 parent, 5 lockfile-only, 42 overrides and 11 refusals, each refusal naming why. The parent and lockfile routes are the minority case; the override remains the common fix. An override whose jump would be breaking is refused, and the refusal names why the parent could not be upgraded instead (no lockfile, a longer chain, several direct parents, no release yet, or only in a new major). Measured on 7 real projects: 21 lockfiles npm ci installed, 1 byte-identical to npm's own, 15 refused with a reason, none npm ci rejected. Every fix pull request is written in the format Aikido uses on the owner's own repositories (iconicLive #6, #7, #23, #24 and #26): an '[Aegis] Fix … via … version upgrade from X to Y' or '[Aegis] AI Fix for …' title, a fix/aegis-security-… branch, a fix(security): commit, and for a dependency the same three collapsible blocks -- breaking changes, the CVEs it resolves with their severity, and remediation details with a version-changes table. Where Aikido says the code is not affected by breaking changes, Aegis says so only when the repository's own tests passed on a bump that is not a major; a deterministic configuration fix is not described as AI. On GitLab, the dependency fix is opened as a merge request through the same plan, version choice, lockfile rewrite and description, written through the organisation's GitLab connection (and its Cloudflare Access service token) -- measured against the owner's GitLab: a vulnerable lodash bumped in one commit on a fix branch, the merge request opened against the default branch, the branch's package.json read back from GitLab, and a second attempt finding the open merge request rather than opening another. Every open finding a repository has on one package can be fixed in one pull request from the Autofix page's Fix bundles strip: each installed version is planned exactly as its own fix would be and sized on its own, two plans that would write the same file are never merged over each other (the second is named as left out), and every finding the bundle closes is marked in progress and linked to the pull request, which nothing follows back now (DEC-037) -- proven against the sandbox repository: two findings, one upgrade, one pull request read back from GitHub, both findings linked to it, and a second request returning the open pull request. A package several repositories carry can be fixed in all of them with one approval from the same page: the approver sees each repository with its installed versions and finding counts and may untick any, the server checks the list again against what carries the package now (a repository the approver was never shown is refused by name), and the fix.campaign job opens one bundle per repository, a few per run, recording each result as it lands -- proven against two real sandbox repositories: one approval, two pull requests, each moving its own package.json, the campaign completed with both results, and a second run opening nothing. An organisation's context for AI fixes -- conventions, preferred APIs, what not to touch -- is saved with the autofix settings and given to the model with every AI fix, bounded at 4,000 characters (refused above that when saved, and cut again in the prompt), fenced so it cannot close its own block, and placed after rules that say they take precedence; proven against a real database by saving it and reading the prompt the AI fix builds. An organisation's pull request template wraps every fix it opens -- dependency, bundle, campaign, configuration and AI -- with placeholders for the title, repository, kind, package, versions and finding count, and {{body}} for Aegis's own description, which is appended if the template leaves it out; an unknown placeholder is refused by name when the template is saved. Proven by a real pull request on the sandbox whose body, read back from GitHub, is the rendered template. Auto-merge is a setting, off by default, and it does nothing today: its only reader is the `fix.pulls` handler, which has no starter (DEC-037), so no follower runs and nothing merges Aegis's own dependency fix pull requests. The rules the follower applied are kept for when a starter returns -- only patch or minor upgrades, only when at least one check ran and every status and check run passed, never a draft or a conflicted pull request, and never onto a protected branch or one whose protection cannot be read -- squashing at the exact head commit whose checks were read, so a later push is refused by GitHub rather than merged unchecked. Proven against real GitHub: without the setting nothing is read; on the private sandbox, whose plan cannot report protection, nothing merges; on the public sandbox no check refuses, a failing status refuses, and the same pull request with a passing status is merged, as GitHub then reports. Every fix window shows how the organisation's earlier fixes of that kind (dependency, configuration, code) fared -- merged as written, changed before merging, or closed -- from one outcome recorded per pull request when a person follows it up, read from GitHub: a commit dated after the pull request opened is somebody's edit. Because the follow-up job has no starter (DEC-037), no new outcome is recorded, so this history stops growing. Below three decided pull requests it gives counts, not a rate.
A fix whose checks fail opens as a draft rather than being hidden, and a repository with no test script yields a fix marked unvalidated rather than verified. Validation runs the repository's own scripts, which means executing its code, so it belongs on a scanner node the customer controls. Autofix never pushes to a protected branch, and merges only when an organisation has switched on auto-merge, and then never onto a protected branch. On GitLab a fix is not validated on a scanner node (the node checks out through GitHub's archive) and opens saying nothing was run; AI and configuration fixes are GitHub-only and say so; Bitbucket and Azure DevOps fixes are described, not opened. A GitLab fix merge request is not yet followed back the way a GitHub pull request is: its finding stays in progress until a scan of the default branch decides. Configuration fixes cover 10 of the 22 IaC scanner rules -- including a floating base image, pinned to the digest its tag resolves to now in the registry (with the organisation's stored credential for that host, or anonymously for public images), and a third-party GitHub Action pinned to the commit its tag resolves to now; the other 12 need a decision the code does not contain (which CIDR to allow, which IAM actions a role needs, where a secret should live) and say so instead of guessing. Dependency bumps edit npm manifests and Python requirements files: an exact == pin, with a pip-compile entry's --hash lines replaced by the target release's digests from PyPI (proven by pip accepting the pull request's file and refusing the stale hashes). Rust dependencies are moved in Cargo.lock -- version, checksum from the crates.io index, and references to that version -- only when the fix is inside the manifest's range and the fixed release depends on exactly what the installed one did; the result is byte-identical to `cargo update --precise` and accepted by `cargo fetch --locked` (measured on iconicbeen/weft), and anything the resolver would have to settle is refused with the cargo command to run. pyproject.toml, Poetry and uv lockfiles, and Go modules are reported with the reason and not patched.
Implemented in: src/lib/ai-fix.ts, src/lib/autofix.functions.ts, src/lib/fix-validation.ts, src/lib/fix-validation.server.ts, src/lib/config-fixes.ts, src/lib/clean-upgrade.ts, src/lib/npm-manifest.ts, src/lib/pypi-requirements.ts, src/lib/autofix-pypi.ts, src/lib/autofix-cargo.ts, src/lib/gitlab-fix-client.server.ts, src/lib/cargo-lock.ts, src/lib/npm-lockfile.ts, src/lib/npm-parent-upgrade.ts, src/lib/lockfile-parents.ts, src/lib/registry-credentials.server.ts, src/lib/fix-checks.ts, src/components/fix-dialog.tsx, src/lib/autofix-node.ts, src/lib/node-checkout.server.ts, src/lib/fix-pulls.ts, src/lib/ai-triage.server.ts, src/lib/pull-request-format.ts, src/lib/fix-bundles.ts, src/lib/fix-bundles.functions.ts, src/components/fix-bundles-panel.tsx, src/lib/fix-campaigns.ts, src/lib/fix-campaigns.functions.ts, src/components/fix-campaigns-panel.tsx, src/lib/fix-outcomes.ts, src/lib/fix-outcomes.server.ts
Tested by: tests/unit/fix-bundles.test.ts, tests/integration/fix-bundle-github-e2e.test.ts, tests/unit/fix-campaigns.test.ts, tests/rls/fix-campaigns.test.ts, tests/integration/fix-campaign-github-e2e.test.ts, tests/unit/ai-fix-context.test.ts, tests/unit/pr-template.test.ts, tests/unit/pr-template-openers.test.ts, tests/unit/fix-outcomes.test.ts, tests/unit/gitlab-fix-client.test.ts, tests/integration/autofix-gitlab-e2e.test.ts, tests/unit/pull-request-format.test.ts, tests/unit/autofix-pypi.test.ts, tests/unit/autofix-cargo.test.ts, tests/unit/fix-checks.test.ts, tests/integration/autofix-browser-github-e2e.test.ts, tests/integration/autofix-pypi-github-e2e.test.ts, tests/unit/fix-pulls.test.ts, tests/rls/code-context.test.ts, tests/unit/deferred-findings-stay-open.test.ts, tests/integration/fix-pull-idempotent-github-e2e.test.ts, tests/unit/autofix-node-job.test.ts, tests/rls/autofix-settings.test.ts, tests/unit/clean-upgrade.test.ts, tests/unit/npm-manifest.test.ts, tests/unit/npm-lockfile.test.ts, tests/unit/npm-parent-upgrade.test.ts, tests/unit/lockfile-parents.test.ts, tests/unit/autofix-node-online.test.ts, tests/unit/scanner-node-scheduled.test.ts, tests/integration/scanner-node-run-once.test.ts, tests/integration/scanner-node-credentials.test.ts, tests/unit/scanner-node-credentials.test.ts, tests/unit/node-checkout.test.ts, tests/integration/scanner-node-archive.test.ts, tests/unit/autofix-npm-lockfile-plan.test.ts, tests/integration/fix-loop-github-e2e.test.ts, tests/integration/autofix-browser-github-e2e.test.ts, tests/unit/ai-fix.test.ts, tests/unit/fix-validation.test.ts, tests/unit/config-fixes.test.ts, tests/integration/fix-validation-e2e.test.ts, tests/integration/config-fixes-e2e.test.ts
A catalogue of code quality checks by category, severity and language, each switched on or off per organisation, run on every repository scan and kept out of security counts, grades and the pull request gate. Thirteen deterministic checks -- debugging leftovers, obfuscated code, dangerous SKILL.md instructions, weak hashes on credentials, sensitive data in logs, empty catch blocks, catastrophic regexes, SELECT *, TODOs, long functions, large files, deep nesting, long lines -- each tested on the look-alikes measured in real code. Every finding opens the same fix window as a security finding. Twelve more checks need judgement -- simpler equivalent code, commenting the why, single responsibility, recursion without a depth limit, division without a zero check -- and are read by the organisation's own model, three application files per press of Review now (no scheduler runs it, DEC-037), largest first, each file again only when its content changes. A reply is kept only where the code it quotes is on the line it names, so an answer about code that is not in the file is dropped and counted. Deep Review (Pull Requests page): a model reads the diff -- lockfiles and binaries skipped, the rest bounded and the cut files named -- with the pull request's own text fenced as untrusted data, and its claims are checked before anything is posted: each must name a changed file and a line present in the new file within a hunk, quote code that is on that line or two either side, and use the fixed severity and category sets; anything else is discarded and listed in the review summary rather than moved to another line. Sent only after the organisation's AI policy allows the destination, and audited. Each comment says it is a model's reading, by which model, and not executed. Fix from comments (same page): any review comment on a current line -- Deep Review's, the rule-based review's or a person's -- can become a fix pull request. A model proposes edits against the file on the pull request's branch with the comment fenced as untrusted data; the edits must apply exactly once and pass the same checks as an AI fix, a person reads the diff, and opening re-checks the content and refuses if the file moved. The fix opens into the reviewed pull request's branch (never the default branch) on an aegis-review-fix/ branch that finding follow-up and auto-merge ignore, and is linked from the comment's thread. Replies, outdated comments, closed pull requests and forks are refused by name.
Model-judged checks need a model route (the Anthropic sign-in or a key under Model providers) and cannot be switched on without one. Source leaves the product for them, under the organisation's AI policy and audited per call; a file the secrets scanner flags is never sent. Their findings are a reader's judgement, stored at medium confidence, and only a later model review of the same file closes them. The deterministic checks are line and brace based, not AST based, so function length and nesting depth are measured on the source as written.
Implemented in: src/lib/scanners/quality.ts, src/lib/code-quality.functions.ts, src/routes/_authenticated/code-quality.tsx, src/lib/quality-model.ts, src/lib/quality-model.server.ts
Tested by: tests/unit/code-quality.test.ts, tests/unit/quality-model.test.ts, tests/integration/quality-model-review.test.ts
Chains the checks an analyst would otherwise do by hand across five screens — known exploitation, reachability, internet exposure, data classification, fix availability, blast radius — and returns a trail of steps, a verdict where each claim cites the step that produced it, and the gaps it could not close. Runs when a person asks for it. The unattended run over findings nobody has opened was removed (DEC-037): its scheduler and the `triage.auto` job's starter were deleted, so nothing runs it and AEGIS_AUTO_TRIAGE=1 now switches on nothing.
Read-only by construction: acting tools are declared so they can be proposed, and are refused execution by the loop, because an agent that can act unattended is an agent that can be prompt-injected into acting. Tool selection is deterministic rather than model-driven, so the same finding investigated twice takes the same path. The step budget is bounded, and exhausting it is reported as a partial investigation rather than summarised into a confident answer. No model is called: the reasoning is code, which is why it can be tested. Unattended runs are removed (DEC-037), so the loop still never acts on its own; the code for them is kept but has no starter, and running an agent over a customer's findings stays a decision they make by asking; conclusions are recorded as finding events and never applied to a finding's severity or status.
Implemented in: src/lib/agent.ts, src/lib/agent.functions.ts, src/lib/finding-context.server.ts
Tested by: tests/unit/agent.test.ts, tests/unit/finding-context.test.ts, tests/integration/agent-e2e.test.ts, tests/integration/handler-schema-e2e.test.ts
Compares a scan against one taken on the base branch and reports only the findings this change added, so a pull request against a repository with four hundred existing findings shows the one its author can still fix cheaply. Findings are matched on the CLI's own key (scanner, file, CVE, package and title, with no line number), so a finding that moved because a line was inserted above it is not reported as new. That key is not the queue's identity: the server's `findings.dedupe_key` includes the line for SAST, secrets and data-flow findings, and a same-code line move keeps its row only through move pairing on default-branch scans. A file rename, a rule rename or a moved secret opens a new finding in the queue.
Run `aegis scan --format json` on the base branch, keep the output, and pass it as `aegis scan --baseline <file>`. Findings present on the base are filtered out before the report, the chosen output format and the `--fail-on` gate, so all three agree. A baseline that cannot be read reports the full list and says so rather than treating a missing file as a clean diff. A renamed file produces one fixed and one introduced finding rather than a guessed match.
Implemented in: src/lib/finding-baseline.ts, cli/aegis.ts
Tested by: tests/unit/finding-baseline.test.ts, tests/unit/cli-baseline-flag.test.ts
Checks whether a detected credential still authenticates, using the most harmless read-only call each provider offers: GitHub, GitLab, Slack, Stripe, OpenAI, Anthropic, Hugging Face, npm, SendGrid and Discord webhooks. With it on, a credential is checked only when a person presses the check on a single finding: the scheduled sweep that checked a few secret findings per run and re-checked each verdict weekly was removed (DEC-037) and its job (`secrets.validate`) has no starter. A live credential becomes critical, a revoked one low, and the verdict survives rescans until the credential on that line changes.
Off until an admin turns it on on the Secrets page, because it transmits the credential to its own provider. The credential is never stored: it is re-read from the repository for one call, and only if it is still the value that was reported. Only the server can record a verdict; a member writing one directly is refused by the database. JWTs, database URLs, private keys, AWS keys and generic high-entropy strings have no read-only check and are never sent.
Implemented in: src/lib/secret-liveness.ts, src/lib/secret-liveness.functions.ts, src/lib/secret-validation.server.ts, src/components/secret-liveness.tsx
Tested by: tests/unit/secret-liveness.test.ts, tests/unit/secret-validation.test.ts, tests/rls/secret-liveness.test.ts
Provider-specific rules and entropy analysis over the current file tree, plus full commit-history scanning with Gitleaks on a scanner node. Each hit carries a keyed fingerprint of the value -- never the value -- so the same credential in several files is one issue to rotate; a hit in test, fixture, example or documentation code is rated low with the reason stated, unless its counterpart sits beside it. The commit history is also read on the control plane through the organisation's own GitHub connection, with no node and no clone: every commit's added and removed lines are scanned, stored as masked events, and folded into one lifecycle per credential -- first committed, still present or the commit that removed the last copy -- across a walk that resumes over many passes, started by the owner (nothing follows a push now, DEC-037). A credential removed from the code but still in history is one finding keyed on its fingerprint; one the tree scan still reports is left to that finding. Every hit also reads the value and its line for the signs that it was typed rather than issued -- a run of consecutive characters, a repeated block, a handful of distinct symbols, a provider's documentation example, a name like fake_token -- and a hit with such a sign is rated low with each reason stated, unless a production name or a paired counterpart says otherwise; the reasons are shown on the finding as 'Why it is rated this way'. Measured against 20,000 random tokens per provider shape, fewer than 1 in 5,000 real-shaped values is called typed. History findings store the sign ids with each event and are rated by the same function. Each history finding also shows where the credential went: the branches that still contain the commit that added it, the pull requests that carried it (a fork's called out), and whether the repository is public, was made public within GitHub's 90-day event window, or has forks holding their own copy; not rechecked on a timer (DEC-037). An organisation can register its own credential shapes on the Policies page -- an internal service token, a partner key -- each a regular expression with one capture group around the secret, tried on a pasted sample before saving; every repository scan, pull-request gate, merge verification and history walk runs them with the built-in detectors' placeholder skipping, test-file downgrade, entropy floor, masking and fingerprinting.
Gitleaks history scanning needs a scanner node. The API-based history walk needs only the GitHub connection and reads up to 1000 commits per repository, twenty per pass; a longer history is recorded as depth-limited rather than complete. Whether a detected credential still works is the separate secret-liveness capability, off until an admin turns it on. Organisation patterns get the custom-rule guards against slow regular expressions (no nested repeats, no backreferences, at most three unbounded repeats), at most 25 per organisation; liveness checks do not know how to test an organisation's own token, so those findings are never marked live or revoked.
Implemented in: src/lib/scanners/gitleaks.ts, src/lib/scanners/secrets-scan.ts, src/lib/scanners/secret-plausibility.ts, src/lib/secret-history.ts, src/lib/secret-history.server.ts, src/lib/scanners/secret-patterns.ts, src/components/secret-patterns-panel.tsx
Tested by: tests/unit/gitleaks.test.ts, tests/integration/gitleaks-history-e2e.test.ts, tests/unit/database-url-secrets.test.ts, tests/unit/private-key-body.test.ts, tests/unit/secret-correlation.test.ts, tests/unit/secret-history.test.ts, tests/integration/secret-history-persist.test.ts, tests/unit/secret-plausibility.test.ts, tests/unit/secret-patterns.test.ts, tests/rls/secret-patterns.test.ts
Aegis's native implementation of Cloudflare's security-audit methodology: a 112-class attack registry built from every companion file of the vendored security-audit-skill, a hunt plan that selects which of eleven domains apply to a repository from its real surface (a route, a datastore behind auth, a model service, a Rust file), trust boundaries read from the architecture, a coverage ledger with a full state table and an inspected-percentage claim so a clean result can never be reported without its coverage, a coverage critic that finds gaps rather than findings, a verdict contract with three states (confirmed, needs_validation with no severity, rejected kept as false-positive memory), an adversarial seam where a hunter can never confirm its own candidate and overall severity can never exceed demonstrated impact, root-cause fingerprints stable across candidate to fixed to regression, and a per-attack-class reputation feed into the learning engine. The whole pipeline runs end to end over a controlled fixture repository with four planted defects and two safe counterparts.
The pipeline is pure and in-memory: it turns a repository profile and architecture into a plan, routes candidates from the existing scanners and code audit through an independent verifier, and emits structured records and a coverage-first report. Candidates come from Aegis's code audit and, with `--model`, from model hunters over the reasoning-only classes: a model candidate must quote a line of the file verbatim or it is discarded, and a separate model verifier with a different agent id decides its verdict, with severity capped at the verifier's stated impact. `--profile quick|standard|deep` sets the wave's breadth and `--budget N` caps model calls, reserving verification first; what is not hunted is deferred with the reason, and a budget too small to fund one hunter and verifier marks the run incomplete. Proven against a live local model; a small local model is slow and finds less than a frontier one, which the run's coverage states. Persisting a run is built: `aegis security-audit --submit` posts it to /api/public/v1/security-audit-runs, which re-validates the ledger and every record and recomputes counts and report before storing it in security_audit_runs, and the Security audit page lists runs with their coverage. The engine runs where the source is (CLI or CI); there is no hosted run. The native and desktop-IPC domains apply only to repositories with that surface.
Implemented in: src/lib/security-audit/attack-classes.ts, src/lib/security-audit/hunt-plan.ts, src/lib/security-audit/coverage-ledger.ts, src/lib/security-audit/coverage-critic.ts, src/lib/security-audit/verdict.ts, src/lib/security-audit/pipeline.ts, src/lib/security-audit/reputation.ts, src/lib/security-audit/coverage-matrix.ts, src/lib/security-audit/benchmark-ids.ts, src/lib/security-audit/report.ts, src/lib/security-audit/audit-run.ts, src/lib/security-audit/run-store.ts, src/lib/security-audit/model-hunter.ts, src/lib/security-audit/model-transport.ts, src/lib/security-audit/run-profile.ts, src/routes/api/public/v1/security-audit-runs.ts, src/lib/security-audit.functions.ts, src/routes/_authenticated/security-audit.tsx, cli/aegis.ts
Tested by: tests/unit/security-audit-attack-classes.test.ts, tests/unit/security-audit-verdict.test.ts, tests/unit/security-audit-coverage.test.ts, tests/unit/security-audit-reputation-report.test.ts, tests/unit/security-audit-pipeline-e2e.test.ts, tests/unit/cloudflare-attack-class-coverage.test.ts, tests/unit/security-audit-run-store.test.ts, tests/unit/security-audit-model.test.ts, tests/rls/security-audit-runs.test.ts, tests/integration/security-audit-runs-e2e.test.ts, tests/integration/cli-e2e.test.ts
A built-in pattern engine covering JavaScript, TypeScript, Python, Go and others, plus source-to-sink dataflow for JavaScript, TypeScript, Python, Go, Java and PHP that traces an untrusted value from where it enters to where it is dangerous and reports the path step by step, across function and module boundaries in all six. The owner-started whole-repository scan also runs the deterministic TypeScript/JavaScript and Python cross-file business-logic audit, persisting its likely findings as normal SAST evidence; page-bounded PR scans deliberately exclude that audit. Semgrep, including taint-mode rules, runs on a scanner node.
Dataflow follows values by reading assignments line by line, and a second pass crosses function boundaries and imports: in JavaScript and TypeScript by relative or package import; in Python by `from x import y` (with `as`), `import x` called as `x.y`, and relative imports, following f-strings, % and .format(); in Go by same-package resolution (any .go file in the same directory), following := and =, fmt.Sprintf and concatenation; in Java into the same class, a class in the same package, an imported class or an `import static` member, with a Spring @RequestParam/@PathVariable/@RequestBody parameter as a source; in PHP into a function in the same file or a literally required file, a method on $this or self::, or a class named by `use` (PSR-4), with superglobals and Laravel's $request->input() as sources and double-quoted interpolation followed. Java and PHP instance methods reached through an injected field are not followed. In Python, Go, Java and PHP a value the callee returns is tainted in the caller, so a sink after the call is found, and a flow whose every hop resolved to exactly one definition is reported at high confidence; a hop through a decorated Python function, a `*args` parameter list or a Go method (whose receiver type is not resolved) keeps the file-local confidence. Not modelled in either: dynamic dispatch, class methods and `self.` calls, calls into another Go package, interface method resolution, goroutines, channels and closures; the language matrix on the repository page states this per language. A source used directly in a sink, with no variable in between, is reported at high confidence because nothing about the propagation is inferred. Not tracked: values passed as call arguments from a handler parameter, and values crossing a callback boundary other than the element of a collection the request sent (`items.map(item => ...)`). A price the buyer's request sets -- a Stripe `unit_amount` inside `price_data`, or a PaymentIntent or Charge `amount` -- is followed with the reverse rules: converting or rounding does not clean it, while using it as a key (an index into a price table, the argument to a lookup) or comparing it with a server amount does. A buyer's quantity times a server price, a catalogue price an operator defines, and a donation, tip, top-up or deposit named near the charge are not reported. Measured on 70 real Stripe handlers from public repositories and 17810 files of the owner's own projects: 35 checkouts at a price the request chose, and no false positives after the exclusions above; the exclusions are name and shape based, so a donation page that never says so is still reported. A Stripe webhook that takes the request body as the event with no signature check anywhere in the file is reported as critical; measured on 750 public webhook files it reported 22, each read and confirmed, and nothing on the owner's projects. A file that verifies anywhere is not reported, even when that verification only runs if a secret is configured, because a file cannot show what production sets. An AI SDK constructed with `dangerouslyAllowBrowser: true` and a key from a client-bundled variable is reported when the variable's name does not already give it away (`VITE_API_KEY`); where it does, the key is reported once on its own line. On 286 public files using the flag that is 9 constructors, each read and confirmed. Every finding states its own limit. A finding whose code only moved (lines inserted above it) keeps its row, first detection, triage and tickets, when the scanner, file, rule and recorded code match; a move to another file, a rename, or an engine that records no code (secrets) is not followed and still reads as one fixed and one new. Semgrep needs a registered scanner node. An organisation can write its own line rules on the Policies page -- a regular expression, the file types it applies to, a severity -- tried against a pasted snippet before saving; every repository scan, pull-request gate and merge verification runs them with the built-in rules' comment skipping, test-code downgrade and inline suppression, and closes their findings when the line is gone. Patterns that can backtrack catastrophically (a repeated group that itself repeats, backreferences, more than three unbounded repeats) are refused at save time, and a custom rule reads at most 500 characters of a line; a slow but bounded pattern is still possible. Custom rules are single-line patterns, not dataflow, and cannot follow a value between lines. Each rule shows its standing since it was last saved: firing (with the lines matched), dead (it read files of its types and matched none), or not run yet (no scan has read a file of its types) -- counted from what every completed repository pass records per rule, so a rule saved an hour ago is never called dead. CodeQL queries cannot be run: there is no CodeQL engine on the node or in the Worker. Measured against labelled benchmarks nobody here wrote (docs/execution/DETECTION_BENCHMARKS.md): on the half of the OWASP Benchmark for Python never inspected while changing the engine, the score (TPR minus FPR) is 0.932, up from 0.158, finding all 229 real vulnerabilities with 13 of 386 safe cases flagged; DVNA 6 of 6 and NodeGoat 6 of 6 documented defects. A Python shell call or deserialisation whose input is provably fixed text (literals, constant f-strings and concatenation on every path reaching it, including arms a constant condition decides) is not reported; anything the proof cannot establish still is. A guard the engine recognises -- a host allowlist with an https check before a redirect, a '..' or apostrophe refusal, a string-literal check before eval -- is recognised only in the forms written in docs/execution/DETECTION_BENCHMARKS.md; a guard written differently still reports. The deterministic code audit (B03) runs on every repository, pull-request and merge-verification scan alongside the pattern engine: a handler that passes a request-supplied organisation id into a service-role read with no membership check is written as a `sast` finding at high severity (scanner `aegis-code-audit`, rule `audit:unguarded-privileged-read`) and blocks the merge gate under the default policy like any other high finding. The audit's `possible` findings -- a verifier that only tests presence, a limit checked outside a transaction -- are a count on the engine summary, never a row, and its whole-tree rule (a control written and never read) runs only from `aegis audit`, because a scan holds a page and a setting read on the next page is not dead. A cross-file business-logic pass (category `business-logic`, severity medium and CWE-285; likely findings persist as SAST rows only in the owner-started whole-tree repository scan, while possible findings remain a count and page-bounded scans never run this category) follows a request handler through the files it calls (route, service, data access) and reports three shapes no single-file check can see: `inconsistent-guard-same-resource` (a handler writes a table with a privileged client and nothing on its call path checks the caller, while sibling handlers writing the same table do), `request-tenant-id-to-write-unchecked` (an organisation or tenant id from the request reaches a write in another module with no membership check on the path), and `state-transition-skips-precondition` (one writer sets a status value without the status filter every other writer of that transition applies). It is deterministic and quiet where unsure: writes bound to the caller's own identity and test files are skipped, and a status filter on a read in the same function counts as a precondition. Planted multi-file fixtures each fire and their clean twins do not (22 tests, each rule mutation-checked). Run on this repository (756 files) it reports 0; its first run reported 8, all false, and each was fixed by tightening the rule. On NodeGoat and DVNA it reports 0, which shows it stays quiet on apps without a tenant or status-machine shape, not that it catches anything there; detection on a real application with such a flaw is proven only by the planted fixtures. It follows calls to depth 3 by name and import, so dynamic dispatch and calls through injected objects are not followed. The same three rules read Python (Django, DRF, Flask, FastAPI): entry points are route-decorated functions and `def view(request, ...)` functions nothing else calls (a function a view calls is that view's helper), class methods only when named for an HTTP verb or viewset action; writes are Django managers, saved or deleted instances (the model read from the assignment, annotation or a helper's return annotation), SQLAlchemy 1.x and 2.x, session add/delete and supabase-py; keyword arguments bind by name and `self` is dropped. Authorisation is a permission check, PermissionDenied, a 401/403 abort or HTTPException, or a capability link (a signed token, a compared token, a lookup filtered on a key or secret column); `login_required` alone is authentication, not a guard. Python reaches only these rules, never the JavaScript per-file ones. Run on 1722 files of four real Python apps (full-stack-fastapi-template, microblog, healthchecks, netbox) it reports 3, down from 21 before tightening, and all 3 are true to the shape but not exploitable: a user-creation route mounted only in development, a Twilio delivery callback authenticated by an unguessable notification UUID, and a 'clear events' action that moves a check to 'new' without the paused test resume makes, which healthchecks intends. On pygoat and dvpwa it reports 0. Python is pinned by 23 further planted-fixture tests, 20 mutations of the dialect each killed. Run it with `bun scripts/audit-business-logic.ts <root> <subdir>...`.
Implemented in: src/lib/scanners/semgrep.ts, src/lib/scanners/dataflow.ts, src/lib/scanners/interprocedural.ts, src/lib/scanners/language-coverage.ts, src/lib/scanners/sast-scan.ts, src/lib/scanners/custom-sast.ts, src/components/custom-sast-rules-panel.tsx, src/lib/finding-location.ts, src/lib/finding-moves.ts, src/lib/scan-engines.ts, src/lib/code-audit.ts, src/lib/code-audit-business-logic.ts, src/lib/scanners/code-audit-findings.ts, src/lib/pr-gate.ts
Tested by: tests/unit/custom-sast.test.ts, tests/unit/code-audit.test.ts, tests/unit/code-audit-in-gate.test.ts, tests/unit/code-audit-business-logic.test.ts, tests/unit/whole-scan.test.ts, tests/unit/python-detection.test.ts, tests/unit/js-detection.test.ts, tests/unit/custom-sast-in-scan.test.ts, tests/unit/dead-custom-rules.test.ts, tests/integration/dead-custom-rules.test.ts, tests/rls/custom-sast-rules.test.ts, tests/unit/finding-moves.test.ts, tests/integration/finding-moves.test.ts, tests/unit/semgrep.test.ts, tests/unit/dataflow.test.ts, tests/unit/detection-benchmark.test.ts, tests/unit/weak-hash-helper.test.ts, tests/unit/finding-location.test.ts, tests/unit/interprocedural-local-source.test.ts, tests/unit/interprocedural-go-python.test.ts, tests/unit/sast-client-env-secret.test.ts, tests/unit/dataflow-client-price.test.ts, tests/unit/sast-stripe-webhook.test.ts, tests/unit/sast-browser-ai-key.test.ts
Line, function and branch coverage per repository and file, from the LCOV report CI already writes (Jest, Vitest, c8, pytest-cov, cargo-llvm-cov, Go via gcov2lcov), uploaded with a token carrying only coverage:write. Each code finding says whether a test executes its line, from the latest report for its repository, and records it: a finding on a line no test executes carries a small named risk factor (No test executes this line, +4) and can be filtered on the findings page; a covered line never lowers a finding, because tests rarely send hostile input. Recomputed whenever a new report arrives or a rescan drops the record. A file the report does not mention is shown as no data rather than untested, a file with nothing to cover as unknown rather than 0% or 100%, a report naming no file inside the repository is refused rather than stored as zero coverage, and one over 10,000 files is refused whole rather than truncated.
Implemented in: src/lib/coverage.ts, src/lib/coverage.functions.ts, src/routes/api/public/v1/coverage.ts, src/routes/_authenticated/coverage.tsx, src/components/finding-coverage.tsx, src/lib/test-coverage-display.ts, supabase/migrations/20261002020000_test_aware_severity.sql
Tested by: tests/unit/coverage-lcov.test.ts, tests/integration/coverage-upload-e2e.test.ts, tests/unit/test-aware-severity.test.ts, tests/rls/test-aware-severity.test.ts
Findings in the Problems panel while the file is still open, and package vetting before an install. Shells out to the same CLI the pipeline runs, so the editor cannot disagree with CI, and reports a scanner that did not run rather than showing an empty panel a developer would read as clean. Editor-side severity filtering never suppresses anything in CI. A JetBrains plugin is the same thin client in Java: its CLI-client core compiles and is tested with javac, and the IntelliJ UI wrapper assembles with the IDE SDK. Neovim and Zed (item 32): a Neovim plugin publishes vim.diagnostic entries on save and on :AegisScan and clears them when a rescan is clean, and a stdio language server (ide/zed/aegis-lsp) publishes the same diagnostics to Zed through a Zed extension or to any LSP client; both are held to one shared mapping fixture. Building it found that `aegis scan <file>` reported a file full of secrets as clean (gitleaks could not write its report inside a file path and the missing report read as no findings); a file target now works and a scanner that wrote no report is reported as not run. Full-workspace scan (item 37): VS Code 'Aegis: Scan workspace' streams each folder's findings into the Problems panel for files that are not open, cancellable with the scan process killed and stale files cleared; the language server answers workspace/executeCommand aegis.scanWorkspace; Neovim has :AegisScanWorkspace, filling diagnostics and the quickfix list. Eclipse (item 31): a plugin over LSP4E that launches the same aegis stdio language server, so Eclipse gets the identical diagnostics with no second mapping, plus a Scan workspace command sending aegis.scanWorkspace; its plugin.xml and MANIFEST are checked against LSP4E's own languageServer extension-point schema, and its Java is compiled against the real LSP4E 0.19.15, LSP4J and Eclipse jars (SHA-256 pinned) and driven over stdio, where a planted secret comes back as an Error diagnostic on the right line.
Install the Aegis CLI and put it on PATH, or set aegis.cliPath (VS Code) / AEGIS_CLI (JetBrains). Scanners are separate installs; whichever are present run, and whichever are not are reported as not run. VS Code and JetBrains are implemented. VS Code (item 34): the real `vsce package` produces a .vsix whose contents are checked to include out/extension.js and the README and exclude src/ and test stubs; publishing to the Marketplace and Open VSX needs the owner's tokens (ide/vscode/RELEASE.md) and has not been done. JetBrains (item 33): the installable zip is built here with the Gradle wrapper (8.10.2, distribution SHA-256 pinned) against the downloaded IntelliJ IDEA Community 2024.2 SDK, and verifyPluginStructure passes; that first real build found that AegisScanAction did not compile (a bare notify() inside an anonymous Task resolved to Object.notify) and that instrumentationTools() was missing. The zip has not been loaded into a running IDE, is not signed, and is not on the Marketplace. The Eclipse plugin has not been loaded into a running Eclipse; it is proven by schema and by driving its server connection class directly. The Zed extension compiles to wasm32-wasip2 against zed_extension_api 0.7.0 but has not been loaded into a running Zed; the Neovim tests ran against a downloaded Neovim 0.12.5 and skip by name where nvim is absent.
Implemented in: ide/vscode/src/extension.ts, cli/aegis.ts, ide/jetbrains/src/main/java/sarl/aegis/AegisCli.java, ide/jetbrains/src/main/java/sarl/aegis/AegisScanAction.java, ide/neovim/lua/aegis/init.lua, ide/zed/aegis-lsp/src/server.ts, ide/zed/aegis-lsp/src/diagnostics.ts, ide/eclipse/plugin.xml, ide/eclipse/src/sarl/aegis/eclipse/AegisServerConnection.java, ide/eclipse/src/sarl/aegis/eclipse/ScanWorkspaceHandler.java
Tested by: tests/integration/vscode-extension-e2e.test.ts, tests/integration/jetbrains-plugin-e2e.test.ts, tests/unit/ide-diagnostics-mapping.test.ts, tests/integration/aegis-lsp-e2e.test.ts, tests/integration/neovim-plugin-e2e.test.ts, tests/integration/aegis-cli-file-target.test.ts, tests/unit/eclipse-plugin-structure.test.ts, tests/integration/eclipse-plugin-e2e.test.ts, tests/integration/vscode-vsix-package.test.ts, tests/unit/jetbrains-build-config.test.ts
What you are installing and where it came from, before an advisory exists to warn you.
Runs an Android build on a throwaway emulator on a scanner node and watches what it does on the network. The node boots the emulator, installs the APK, routes its traffic through mitmproxy with the proxy CA in the system trust store, drives the app, and sends back what the proxy recorded; the control plane turns those records into findings and assigns severity, as for apk-static. It reports cleartext HTTP requests with the observed request line and the hosts contacted, and HTTPS requests that completed through an intercepting proxy, which shows the app did not pin its certificate. Every finding carries evidence copied from a record the proxy wrote; a record without that evidence yields no finding, so nothing is inferred. A run where the emulator cannot boot (no /dev/kvm, a boot timeout, an emulator exit) or where the CA could not be installed is failed with the reason, never read as clean.
Runs on a scanner node with KVM, adb, the Android emulator with an x86_64 system image and an AVD, and mitmdump (AEGIS_ANDROID_SDK, AEGIS_ANDROID_AVD, AEGIS_MITMDUMP, AEGIS_MITM_CONFDIR). Proven on this machine by a hand-driven capture of InsecureBankv2 (a cleartext POST /login was recorded byte for byte); the runner was not executed end to end here because the emulator was unstable under host load, so runner.ts has no integration test and the jobs ingest branch has no direct test. Frida runtime hooks (SharedPreferences, WebView, TrustManager) are NOT implemented: Frida attached but its hooks did not fire on this emulator, so no runtime-hook finding exists. There is no UI automation, so only the traffic an app produces on launch and under simple driving is seen, and traffic is attributed to the device, not to one app (stated on each finding).
Implemented in: src/lib/scanners/apk-dynamic.ts, scanner-node/apk-dynamic/runner.ts, scanner-node/apk-dynamic/addon.py, src/lib/scanners/catalog.ts, scanner-node/index.ts, src/routes/api/public/nodes/jobs.ts
Tested by: tests/unit/apk-dynamic.test.ts
For a vulnerability whose fix landed in a version you cannot take, this finds the upstream fix commit, separates the source change from the upstream's own regression test, and checks whether it applies to the version you are pinned to -- read from the published artefact itself: the npm tarball, a PyPI source distribution, or a Maven sources jar. The test is the point: it is evidence written by the people who understood the bug, so a patch that carries one gives you something that fails before and passes after. Proven for each: a jinja2 3.1.2 sdist patched with its fix for GHSA-h5c8-rqwp-cp95 installs and the upstream test passes; org.json 20230618's sources patched with its fix for GHSA-4jq9-2xhw-jpx7 compile and the release's tests pass with the fix's new test; and the jinja fix against 2.11.3 is reported as not applying, which git confirms.
Aegis produces the patch and never the package. Publishing a patched dependency means owning its security, its correctness and its next CVE for as long as anyone runs it, and an abandoned backport library is worse than none because the customer is pinned to a fork nobody maintains. You apply it yourself, through patch-package or a vendored fork, knowingly. Where the fix was written against later code and does not apply to your version, that is reported as the headline with the missing lines named, rather than offered anyway. Installable form (item 16, npm only): when the patch applies, an owner or admin can open a pull request into the repository holding the finding that adds patches/<name>+<version>.patch in patch-package's format and runs patch-package on postinstall (an existing postinstall is kept), so npm install applies the fix; the pull request states that the patch is the customer's to maintain (DEC-023). Proven with a real npm install: Aegis's patch for cross-spawn 7.0.3 (GHSA-3xgq-45jj-v275) was applied by patch-package 8.0.1 and the fixed line is in node_modules. PyPI and Maven have no install-time equivalent, so no pull request is offered for them; none has been opened against a customer repository.
Implemented in: src/lib/backport-patch.ts, src/lib/backport-apply.ts, src/lib/artifact-files.ts, src/lib/backport-package-patch.ts, src/lib/backport.functions.ts, src/components/backport-patch.tsx
Tested by: tests/unit/backport-patch.test.ts, tests/unit/backport-package-patch.test.ts, tests/integration/backport-package-patch-e2e.test.ts, tests/unit/backport-apply.test.ts, tests/unit/artifact-files.test.ts, tests/integration/backport-pypi-maven-e2e.test.ts
Says how likely a version bump is to break something before a reviewer approves it: a patch bump is the maintainer promising nothing observable changed, a major bump is a statement that something did, and an automated fix that presents both identically is how the mechanism gets switched off after an outage. Major-version migration (item 11): for an npm major bump it reads both versions' published type declarations from the registry tarballs, builds the repository's import graph, and edits the call sites, not only the manifest: deterministic codemods for a removed default export (default to named import) and for member and option renames the maintainer documented in their own @deprecated notes, plus, only when a model route is configured, model-proposed edits that are kept only if the repository's own typecheck passes. Every call site it could not fix is listed in the pull request body, and such a pull request is opened as a draft, blocked, and never auto-merged. Proven on the real lru-cache 7.18.3 to 10.0.0 upgrade: the fixture repository typechecks on 7, fails on 10 (no default export), and typechecks again after the codemod.
npm only. The codemods cover renames and export-shape changes that the declarations or @deprecated notes state; a behaviour change with an unchanged signature is invisible to them and is left to the repository's tests. Model edits need a configured model route and are discarded when typecheck fails. The pull request path through the existing fix-pull flow was not exercised against a live repository in this change.
Implemented in: src/lib/upgrade-breakage.ts, src/lib/major-migration.ts, src/lib/major-migration.functions.ts, src/lib/major-migration-pr.ts, src/lib/major-migration-pr.server.ts, src/lib/major-migration-registry.server.ts
Tested by: tests/unit/upgrade-breakage.test.ts, tests/unit/major-migration.test.ts, tests/integration/major-migration-tsc.test.ts
OCI manifests and config blobs are read live over the registry API. Layer CVEs run through Trivy and Grype on a scanner node, with hardened base image recommendations. Images built on a shared base are grouped by their layer diff_ids, so a base is fixed once at the root rather than in each image. A language-package vulnerability in an image inherits the reachability verdict the image's source repository already reached for the same package, so an unused dependency in an image is marked not reachable while operating-system packages and unlinked images stay unknown.
Layer scanning needs a scanner node. Private registries are supported: store a credential per host and it is used at pull time. Base-image hardening advice compares your own scans of the current and suggested images and reports the difference; where either has not been scanned it says the saving is unmeasured rather than showing a count. Base-image ancestry groups images that share leading layers, which needs those images to have been scanned since diff_ids were recorded. Maintaining pre-patched base images, as a vendor-supplied catalogue, is not something Aegis does: that is a continuous commitment to rebuild other people's software, not a feature. Instead (item 17) `aegis base-image <Dockerfile>` and the IaC page recommend a maintained minimal image (slim, Alpine, distroless or Chainguard, from a table citing each maintainer's documentation) for the final build stage only, offered only when Trivy measures strictly fewer critical plus high CVEs on the same architecture, with a warning where RUN steps follow a FROM that has no shell. Measured on 5 October through the real `aegis base-image`: node:16-bullseye 250 critical and 2755 high against gcr.io/distroless/nodejs16-debian11 2 and 26 (recommended), node:16-alpine 1 and 42, node:16-slim 3 and 73, cgr.dev/chainguard/node 0 and 0 (a different Node major, so ranked after same-version candidates). A test asks the registries for every candidate the table can name; it found that nodejs16-debian12, which the table first produced, does not exist. Whether the customer's application still builds on the new base is not proven.
Implemented in: src/lib/registry.server.ts, src/lib/scanners/trivy.ts, src/lib/scanners/grype.ts, src/lib/base-images.ts, src/lib/base-image-compare.functions.ts, src/lib/base-ancestry.ts, src/lib/containers.functions.ts, src/lib/container-reachability.ts, src/lib/container-reachability.functions.ts, src/lib/base-image-advisor.ts, src/lib/base-image-proof.server.ts
Tested by: tests/unit/registry.test.ts, tests/unit/trivy.test.ts, tests/unit/grype.test.ts, tests/unit/base-images.test.ts, tests/rls/base-image-compare.test.ts, tests/integration/trivy-image-e2e.test.ts, tests/integration/node-session-e2e.test.ts, tests/unit/base-image-advisor.test.ts, tests/integration/base-image-proof.test.ts, tests/unit/base-ancestry.test.ts, tests/unit/container-reachability.test.ts, tests/rls/container-reachability.test.ts
A CI job routes npm through Aegis with the lines `aegis npm-gate --write` appends to .npmrc (registry=<aegis>/api/npm/ and an auth line reading ${AEGIS_TOKEN} from the environment, keyed to the gate's path so npm never sends it elsewhere). Every tarball npm downloads -- including those a committed lockfile resolves to registry.npmjs.org, which npm's default replace-registry-host rewrites to the configured registry -- is judged before download: a version that an OSV MAL- (malicious-packages) advisory covers is refused with 403 and the reason. Today OSV is the only source that refuses anything: the gate also reads Aegis's own `registry_detections` table, but the registry watchers that wrote it were removed (DEC-037) and nothing writes it, so Aegis's own malware detection contributes nothing. A refused version fails `npm ci` with E403 before any install script runs, and the refusal is written to the audit log. Anything else is a redirect to registry.npmjs.org, so package bytes never pass through Aegis and npm still checks them against the lockfile's integrity hash. Fails closed: when either source cannot be read the tarball is refused with 503, except that a known detection still refuses (the Aegis source is empty today, so in practice an OSV outage refuses). Proven with real npm against the dev server: a clean package installs, vl-ui-body@10.1.1 (a live dependency-confusion package) is refused naming MAL-2026-990, and a version planted as an Aegis detection is refused and audited (the planted row is how the test exercises a source nothing fills in production); disabling either source in the route fails its own test. In production on 3 October, real `npm ci` through app.aegis.sarl installed is-number and failed E403 on vl-ui-body@10.1.1 naming MAL-2026-990, with npm_gate.blocked in the audit log. pnpm, yarn berry and bun (`aegis npm-gate --client pnpm|yarn|bun`): unlike npm they download from the tarball URL the package document names, so the gate serves package documents with every registry.npmjs.org tarball URL rewritten to itself, streamed (25 MB for `next`, 2.3s through the dev server). Proven with pnpm 10, yarn 4 and bun 1.3, each resolving fresh and from a lockfile made without the gate: is-number installs, vl-ui-body@10.1.1 fails with the gate's 403, and each refusal is audited (tests/integration/npm-gate-clients-e2e.test.ts, 14/14). Before the rewrite all three installed vl-ui-body@10.1.1 through the gate; removing it fails the three fresh-resolve tests.
npm, pnpm, yarn berry and bun; yarn classic (v1) has not been run. pnpm 10 will not expand ${AEGIS_TOKEN} in a credential from a project .npmrc, so its credential is a separate user-level file the CI job points NPM_CONFIG_USERCONFIG at. Package documents now pass through Aegis (rewritten, not stored), so a resolve depends on Aegis being up as well as the registry. Only malicious versions are blocked here; vulnerable ones are the scan's and merge gate's concern. A vulnerability-only GHSA does not block. Every tarball costs one OSV query, so a cold install of a large tree adds latency, and an OSV outage stops installs by design. Needs an API token with policies:read.
Implemented in: src/lib/supply-chain/npm-gate.ts, src/routes/api/npm/$.ts, cli/aegis.ts
Tested by: tests/unit/npm-gate.test.ts, tests/integration/npm-gate-e2e.test.ts, tests/integration/npm-gate-clients-e2e.test.ts
The npm install gate's refusal, for three more package managers, each pointed at Aegis the way it is pointed at a private mirror (`aegis gate <pip|cargo|maven>` prints the configuration) and answered in its own protocol. pip and uv read a PEP 503 simple index at /api/gate/pypi/simple/: Aegis serves PyPI's page for the project with every file of a refused version removed, so an unpinned install takes the newest allowed release and a pin to a refused one fails resolution ("No matching distribution") before anything downloads. Cargo reads a sparse registry at /api/gate/cargo/index/: crates.io's index file with refused versions' lines removed, and a config.json naming Aegis's download route, which answers a refused crate 403 and redirects everything else to static.crates.io. Maven and Gradle use /api/gate/maven/ as a mirror of Central: any file of a refused version (jar, pom, classifier, checksum) is answered 403, which fails dependency resolution, and every other path is a redirect to repo1.maven.org. Refused means what it means for npm: an OSV MAL- advisory covering that version. The other source, an unwithdrawn Aegis malware detection, is empty because the registry watchers that wrote it were removed (DEC-037), so these gates are OSV-only today. Allowed bytes come from the registry's own CDN and each client checks its own hash. Fails closed with 503 when either source cannot be read; every refusal is audited (`<tool>_gate.blocked` for a refused download, `.filtered` for versions removed from an index). The token is the API token, sent as a Basic password by pip, uv and Maven and bare by Cargo; it is never written to a file. Proven with the real clients against the dev server: pip, uv, Cargo and Maven 3.9.11 each install a clean package, fail on MyMalDependency 2.1.1 (MAL-2026-3694), proton-pfff 99.99.5 (MAL-2026-6959) and the scribejava-core 8.3.5 typosquat (MAL-2025-2552) respectively, and fail on a clean version planted as an Aegis detection; switching off each route's filter or the OSV source fails its test. Poetry 2.4 (`aegis gate poetry` prints a primary [[tool.poetry.source]] at the same simple index, credential from POETRY_HTTP_BASIC_AEGIS_*) locks a clean pin with the gate recorded as its source, and cannot lock MyMalDependency 2.1.1 or a version planted as an Aegis detection, while the same pin locks without the gate; a lockfile made without the gate is refused until relocked, because the added source changes its content hash. Making the source supplemental instead of primary fails all three Poetry tests. PDM 2.29 (`aegis gate pdm` prints a [[tool.pdm.source]] named pypi, so it replaces PyPI, with ${AEGIS_TOKEN} in the URL userinfo, the only place PDM expands a variable) locks MyMalDependency 1.1.1 with neither token nor gate URL written to pdm.lock and cannot lock 2.1.1, which locks without the gate; naming the source anything but pypi fails that test.
pip, uv, Poetry, PDM, Cargo and Maven only: Gradle is expected to work as a Maven repository but has not been run, and NuGet and RubyGems have no gate. The PyPI gate filters PyPI's HTML page, so a client that insists on the JSON simple API is served HTML. A version OSV lists with a bounded range is compared with semver ordering, close for PyPI and Maven and exact for crates.io; a range that cannot be compared is treated as covering the version. Each index page or download costs one OSV query, so a cold resolve of a large tree adds latency, and an OSV outage stops installs by design. Cargo over plain HTTP needs CARGO_HTTP_MULTIPLEXING=false because the dev server does not speak HTTP/2 without TLS; production is HTTPS. Needs an API token with policies:read.
Implemented in: src/lib/supply-chain/install-gate.ts, src/lib/supply-chain/install-gate.server.ts, src/routes/api/gate/pypi/simple/$.ts, src/routes/api/gate/cargo/index/$.ts, src/routes/api/gate/cargo/download/$.ts, src/routes/api/gate/maven/$.ts, src/lib/platform.ts, cli/aegis.ts
Tested by: tests/unit/install-gate.test.ts, tests/integration/install-gate-e2e.test.ts
Reads a mobile build artifact on a scanner node without installing or running it. Android APKs: the binary XML manifest (permissions, cleartext traffic, debuggable, exported components). iOS IPAs (item 4): Info.plist and embedded.mobileprovision in both XML and binary plist form -- App Transport Security arbitrary loads and per-domain insecure HTTP exceptions, custom URL schemes as deep-link surface, empty usage descriptions, get-task-allow (a debug build shipped), enterprise all-devices provisioning, the minimum iOS version, and hardcoded secrets in plist and strings files using the repository's secret rules, masked. Every finding cites the file and key it came from; a file that cannot be parsed is reported as unreadable rather than read as clean. The node sends facts and the control plane assigns severity, so a modified node cannot inflate or erase a finding's weight.
Runs on a scanner node (it needs unzip and the customer's artifact, which is often unreleased). Static only: no emulator, Frida or traffic capture (item 3), and the iOS Mach-O binary is not read, so the minimum iOS version comes from Info.plist alone. The ingest branch for ipa-static in the jobs route has no direct test; the analyser and the node's extraction path are tested against real zips with XML and binary plists.
Implemented in: src/lib/scanners/apk.ts, src/lib/scanners/ipa.ts, src/lib/scanners/catalog.ts, scanner-node/index.ts, src/routes/api/public/nodes/jobs.ts
Tested by: tests/unit/apk-analysis.test.ts, tests/unit/ipa-analysis.test.ts
Assesses a repository's dependencies for typosquatting, dependency confusion against the organisation's private scopes, install scripts that read credentials or download code, maintainer takeover and dormant revival, scored into a reputation with the evidence attached.
Reads the lockfile so packages are assessed at the version actually installed: bun.lock and package-lock.json give the full tree with each finding naming the direct dependency that pulls it in, poetry.lock gives versions and edges but cannot say which packages the project asked for directly, and go.sum gives exact versions with no edges at all because Go resolves those from each module's own go.mod. Where a path cannot be known it is not invented. Bounded at 500 packages per scan with the number omitted reported. Maven, NuGet, RubyGems and crates read metadata but have no lockfile walk. The name-based checks -- typosquatting and dependency confusion -- also run inside every repository scan with no registry traffic, deriving the organisation's own scopes from its root manifest rather than waiting for a policy nobody fills in; the registry-backed signals (maintainer changes, publication history, install scripts) still require the full scan.
Implemented in: src/lib/supply-chain/reputation.ts, src/lib/supply-chain/dependency-tree.ts, src/lib/supply-chain/scan.ts, src/lib/supply-chain/offline-signals.ts, src/lib/supply-chain.functions.ts
Tested by: tests/unit/dependency-tree.test.ts, tests/unit/dependency-tree-ecosystems.test.ts, tests/unit/supply-chain-reputation.test.ts, tests/unit/supply-chain-scan.test.ts, tests/unit/offline-supply-chain.test.ts
Authenticates to private registries by reading the registry's own challenge and exchanging a stored credential for a token scoped to pull on one repository. Recognises Docker Hub, GHCR, ECR, GAR, ACR, Harbor and generic v2 registries.
Credentials are stored and rotated per organisation from the containers page, encrypted in integration_secrets and never in the connector config, and a credential is verified against a repository the operator names before it is stored: a scoped token that authenticates but cannot pull is refused rather than saved. A host that answers without credentials is recorded as reachable-only, because a public repository proves nothing about the credential. Rotation leaves the working credential in place when the new one fails.
Implemented in: src/lib/registry-auth.ts, src/lib/registry-connections.functions.ts, src/lib/registry.server.ts
Tested by: tests/unit/registry-connections.test.ts, tests/unit/registry-auth.test.ts, tests/integration/registry-auth-e2e.test.ts
CycloneDX 1.5 and SPDX 2.3 export, with licence policy evaluation from deps.dev, and Syft inventory on a scanner node. VEX statements persisted per organisation with an audit trail: recorded from the finding drawer or imported as an OpenVEX document (validated statement by statement, refused ones named, source document hashed), listed and revoked on the Supply Chain page. A not_affected statement closes the findings it covers, keeps them closed on later scans, takes them out of the merge gate with the reason in the pull-request comment, and is shown on the Dependencies page; fixed leaves the gate pending the next scan; under_investigation annotates and blocks. Revoking reopens what the statement closed. OpenVEX export carries the recorded decisions. Licence obligations per release (Supply Chain page and `aegis notices`): each dependency's licence (deps.dev) is resolved to what it requires -- keep the notice, ship the NOTICE file, mark changes, file-level or whole-work source, relinking, network use, restricted use, or review for an unrecognised licence -- with the lighter branch of an OR chosen and named, and a THIRD_PARTY_NOTICES.md is written with copyright holders and NOTICE files from ClearlyDefined and licence texts from the pinned SPDX list (v3.29.0). Everything that could not be included (no licence, unharvested by ClearlyDefined, an unread NOTICE or manifest, a non-SPDX licence) is listed at the top, and the CLI exits 1 while anything is missing. The product drives the work in chunks, each its own Worker invocation (a manifest read, then 400 packages per call, then 30 texts per call), because one call for iconicbeen/ui's 3,212 packages on production reached copyright data for only 500. Licence lookups go a hundred to a request through deps.dev's version batch, so 200 packages cost two subrequests rather than two hundred; results are matched by position because deps.dev's echoed key can name another request (measured). Proven against live providers: requests 2.32.3's NOTICE text, lodash's holders, serde's dual licence choice; on a real 1,873-package pnpm lockfile 104 versions ClearlyDefined has not harvested were listed as gaps rather than printed without holders. An AI bill of materials (Supply Chain page and `aegis ai-bom`, CycloneDX 1.6 with machine-learning-model and data components, schema-validated): AI SDKs from the manifests and imports, models and datasets named in the code with file and line, weights files (pickle formats flagged as running code on load) and prompt files. An owner/name id counts as a Hugging Face model only once the Hub answers for it -- LiteLLM's `anthropic/claude-3-5-sonnet-20240620` is a Hub 401 and is reported as hosted -- and each confirmed model or dataset carries its Hub licence, gating, commit and whether its weights exist only in pickle form. Doctest examples, comments, test fixtures and example data are not inventoried; a model chosen from the environment at run time is reported as unseeable. Measured on smolagents, the OpenAI cookbook and rag-from-scratch, where the first version's three false positives (Bedrock ids in docstrings, provider strings taken for Hub models, cached transcripts taken for weights) were each fixed and are now tests.
Implemented in: src/lib/sbom.ts, src/lib/scanners/license.ts, src/lib/scanners/syft.ts, src/lib/supply-chain/licence-obligations.ts, src/lib/supply-chain/licence-notices.ts, src/lib/licence-notices.functions.ts, src/lib/supply-chain/ai-bom.ts, src/lib/supply-chain/ai-bom.server.ts, src/lib/ai-bom.functions.ts, src/lib/vex.ts, src/lib/vex.functions.ts, supabase/migrations/20260929210000_vex_import_and_revocation.sql
Tested by: tests/unit/license.test.ts, tests/unit/syft.test.ts, tests/unit/licence-obligations.test.ts, tests/integration/licence-notices-live.test.ts, tests/unit/ai-bom.test.ts, tests/integration/ai-bom-live.test.ts, tests/unit/vex-output.test.ts, tests/unit/vex-persisted.test.ts, tests/integration/syft-sbom-e2e.test.ts, tests/rls/vex-statements.test.ts, tests/rls/vex-persistence.test.ts, tests/integration/vex-statement-browser.test.ts
Dependency vulnerabilities from OSV including transitive paths, enriched with CISA KEV and EPSS, with reachability analysis and end-of-life detection. The installed version is read from the lockfile, not from the floor of a package.json range. Every repository's whole dependency set -- every manifest, in one request -- is scanned when the owner starts a scan of the repository, so a merged upgrade closes its findings at the next owner scan even in a monorepo. Nothing rescans a repository on a timer, and nothing re-checks it while a fix pull request is open (DEC-037), so a newly published advisory reaches existing code at the next owner scan. Advisory detail is stored once for every tenant and filled in for findings a scan had no request left to enrich.
Every vulnerability here comes from a published advisory. Pre-CVE and zero-day intelligence is deliberately not offered: producing it means analysts, paid-for sources and a disclosure pipeline, which is a threat-intelligence operation rather than a feature, and a product that implied it had one would be claiming knowledge it does not have. A vulnerability nobody has published is therefore absent rather than predicted, and the gap is stated instead of filled with a guess. Measured on 27 September for the case that prompted it: Aikido opened a fix for postal-mime 2.7.5 under its own identifier AIKIDO-2026-297362; four public sources -- OSV, the GitHub advisory database (queried for reviewed, unreviewed and malware entries), npm's audit endpoint and deps.dev -- return nothing for that version, and the upstream 2.7.6 release notes call the change a bug fix (unbounded message/rfc822 recursion). Aegis does not report it. Were an advisory published naming 2.7.6 as the fix, the parent route would choose resend ^6.28.1 from the live registry (checked with the same function; the pull request itself was not exercised for this package).
Implemented in: src/lib/sca.functions.ts, src/lib/reachability.ts, src/lib/eol.ts, src/lib/dependency-inventory.server.ts, src/lib/advisory-detail.server.ts, src/lib/function-reachability.ts, src/lib/function-reachability-display.ts, supabase/migrations/20261002000000_advisory_fix_symbols.sql, supabase/migrations/20261002010000_second_order_reachability.sql
Tested by: tests/unit/advisory-detail.test.ts, tests/unit/function-reachability.test.ts, tests/unit/function-reachability-display.test.ts, tests/rls/advisory-fix-symbols.test.ts, tests/rls/second-order-reachability.test.ts, tests/integration/dependency-inventory-github-e2e.test.ts, tests/rls/reopen-redetected.test.ts, tests/unit/reachability.test.ts, tests/unit/eol.test.ts, tests/integration/reachability-e2e.test.ts, tests/unit/recorded-refusals.test.ts
Configuration, identity and data exposure across cloud accounts.
Snapshot-based scanning of EC2 instances and EBS snapshots, extracting installed packages and matching them against known vulnerabilities without running anything inside the VM. Azure and GCP (item 28): an Azure managed-disk snapshot is read through a one-hour read SAS from beginGetAccess, downloaded to the node as a VHD and scanned with trivy vm, with endGetAccess called on success, failure and timeout; a GCP snapshot is scanned from the customer's own `gcloud compute images export` tarball, from which only disk.raw is unpacked. A raw Azure or GCP snapshot id never reaches Trivy: the target must have been materialised to a local disk first. On AWS, a snapshot Aegis creates to scan a live volume is deleted when that scan ends, pass or fail, through a guard that re-reads its tags and refuses anything not this organisation's.
Runs on a scanner node with snapshot read permission on the connected cloud account. Aegis creates and deletes snapshots on AWS only; on Azure and GCP it reads them. Since DEC-037 there is no sweep of idle snapshots and no later pass for a snapshot a scan failed to delete: the deletion at the end of the scan is the only cleanup, and a failure is written to the audit log. Azure needs Microsoft.Compute/snapshots/beginGetAccess/action and downloads the whole disk (tens of GB for a typical OS disk, minutes to tens of minutes); GCP needs the customer to run the image export into a bucket the node can read, because Aegis does not create images. The scanning half is proven with a real trivy vm over a real Debian 12 ext4 disk served both as a fixed VHD and as a GCP export tarball (235 CVEs); the provider calls are tested against their documented responses only, as no Azure or GCP account is connected.
Implemented in: src/lib/scanners/vm.ts, src/lib/snapshot-lifecycle.ts, src/lib/cloud-snapshots.server.ts, scanner-node/vm-materialise.ts
Tested by: tests/unit/vm-scanner.test.ts, tests/unit/vm-export.test.ts, tests/integration/vm-disk-image-e2e.test.ts, tests/integration/vm-scan-e2e.test.ts, tests/unit/snapshot-lifecycle.test.ts, tests/unit/snapshot-creation-lifecycle.test.ts
Read-only posture scanning of S3, EC2, RDS and IAM using signed SigV4 calls, against CIS rule packs. The sweep also reads what the shadow-asset engine judges on: every load balancer with its healthy-target count (DescribeTargetGroups and DescribeTargetHealth per balancer), every instance with its state and, for a stopped one, when it stopped, and every elastic IP with whether anything is attached. All within the SecurityAudit policy; a reader that fails is a named read error, never an empty fleet.
Connect an AWS account with read-only credentials under Integrations.
Implemented in: src/lib/aws.server.ts, src/lib/cloud-posture.ts, src/lib/cloud-scaling.ts
Tested by: tests/unit/aws-cspm.test.ts, tests/unit/cloud-posture.test.ts, tests/unit/cloud-scaling.test.ts, tests/unit/describe-scaling-groups.test.ts, tests/unit/shadow-assets-live.test.ts
Azure and Google Cloud posture scanning against CIS rule packs, alongside AWS.
Connect an Azure or GCP account under Integrations. Posture is read per connected account. Discovery on the Cloud page lists every subscription the Azure credential can see and every project the GCP credential can search (with its parent folder), across all pages, and names those with no credentials in Aegis; it does not connect or scan them, and a credential that cannot list says so instead of reporting an empty tenant.
Implemented in: src/lib/azure.server.ts, src/lib/gcp.server.ts, src/lib/multi-cloud.functions.ts, src/lib/scanners/scaling-findings.ts
Tested by: tests/unit/multi-cloud.test.ts, tests/unit/cloud-scaling-readers.test.ts, tests/unit/scaling-findings.test.ts, tests/unit/cloud-discovery.test.ts
A cloud misconfiguration finding becomes a Terraform patch and the equivalent CLI command, opened as a pull request into the repository that owns the estate (Fix as code, in the finding drawer). Because Aegis reads the live resource rather than the customer's Terraform, it never edits an HCL block it has not seen: it adds a standalone, idempotent resource addressed by the real resource id -- aws_s3_bucket_public_access_block and server-side-encryption and versioning for a named bucket, a cloudflare_zone_setting for min TLS and always-use-HTTPS on a real zone id -- so applying it corrects the setting without touching anything else. Where the correct fix is removing a statement from a policy document Aegis cannot see (a public bucket policy), setting an argument on an existing block (RDS deletion protection, GCP uniform access, shown as the one line to add plus the CLI), or a human decision (enabling MFA, choosing a CIDR for an open admin port), it says why there is no generated patch rather than guessing a resource. The fix is re-derived on the server from the finding at open time, never taken from the browser, and lands on its own fix/aegis-security-iac branch behind the repository's review. Proven against real GitHub: an S3 public-access-block patch committed as a new .tf on its own branch, the pull request against the default branch, the file read back byte-for-byte, and a second attempt finding the open pull request. The evidence read is proven against a real schema in the RLS suite (a column list is a string typecheck cannot see), and the PR body carries the CLI and a reminder to run terraform plan; nothing is applied for the customer. On GitLab the same file lands on the same branch name in a merge request to the default branch, resolved from the stored connection by the repository's gitlab:group/name identifier -- proven against the owner's GitLab through Access (`tests/integration/cloud-fix-gitlab-e2e.test.ts`): the file read back is exactly the generated Terraform, and a second attempt finds the open merge request instead of opening another.
GitHub (pull request) and GitLab (merge request, through the organisation's connected GitLab and its Cloudflare Access token when it is behind one); a Bitbucket or Azure DevOps repository is refused by name because neither has a fix client. The patch is generated for the rules whose fix is a deterministic Terraform argument on a resource addressed by its real id; a rule whose fix depends on a policy document or IAM shape Aegis cannot see from the live API reports the reason instead of a guess. Opening requires the owner, admin or security admin role.
Implemented in: src/lib/cloud-fix-code.ts, src/lib/cloud-fix-code.functions.ts
Tested by: tests/unit/cloud-fix-code.test.ts, tests/integration/cloud-fix-gitlab-e2e.test.ts, tests/rls/cloud-fix-code.test.ts, tests/integration/cloud-fix-github-e2e.test.ts
Enumerates the accounts in an AWS organisation and reports which are active but unconnected, so an account nobody remembered to connect stops being invisible. Also flags recorded resources that look unowned: idle, untagged, unattached or referenced by no connected repository.
Needs organisation-level credentials to enumerate accounts. Shadow assets are read from stored metadata, which the AWS sweep now fills with what the judgement needs: healthy targets behind each balancer, whether each elastic IP is attached, and when a stopped instance stopped. A resource the live readers do not cover (buckets, databases) still carries only last_seen, and one whose provider was never recorded is reported as unknown rather than assumed: a guessed provider reaches the finding, the dedupe key and every cross-cloud rule, where it is both wrongly matched and wrongly missed. Azure and GCP sweeps do not yet read attachment or activity, so their resources are judged on tags alone. No AWS account is connected to this deployment, so the live readers are proven against documented response shapes only (O4).
Implemented in: src/lib/cloud-discovery.ts, src/lib/cloud-discovery.functions.ts
Tested by: tests/unit/cross-cloud-rules.test.ts, tests/unit/cloud-discovery.test.ts
Cloudflare account posture with a read-only API token: zone SSL mode against real origins, minimum TLS, HTTPS redirect, DNSSEC, DNS records exposing an origin, Access applications open to everyone, Workers also served on workers.dev beside a custom domain, and two-factor sign-in for the account and each member.
Connect a Cloudflare account on the Cloud page with a custom token holding read permissions only. Every request is a GET. A permission the token lacks is reported per resource as a read error, never as a pass. WAF rulesets are not judged: they need the Zone WAF read scope, and the legacy WAF switch reads off on every Free zone while the managed ruleset runs, so a rule on it would report a missing control that is there. Zone-level HSTS is not judged either, because the origin may send the header itself (app.aegis.sarl does). R2 is not read.
Implemented in: src/lib/cloudflare.server.ts, src/lib/cloud-posture.ts, src/lib/multi-cloud.functions.ts, src/components/multi-cloud-panels.tsx
Tested by: tests/unit/cloudflare-posture.test.ts, tests/integration/cloudflare-posture-live.test.ts
Classifies what a datastore holds from its column, table and object names, then weights its exposures by that: a public bucket of payroll data is critical and a public bucket of build logs is not. Covers PII, financial, health and credential data. Code-first as well (`aegis data`): reads migrations, models and handlers for sensitive field names and the lines that log, return or export them, and follows a field across files through the import graph, so a row read in one module and sent by another is reported with both ends and every hop between. A route returning only a derived scalar or a masked copy is not reported, and a partial chain is not reported. The cross-file pass also runs in every hosted repository scan with SAST selected, writing each exposure as a `sast` finding in category `data-exposure` (CWE-359, medium) keyed on its sink line, over the same page of files the dataflow pass reads -- so a carrier and its caller on different pages are not joined.
Metadata only by default. Contents are never read by Aegis, because copying customer data into it to classify it would make this database a second copy of everything sensitive they own. Where a store's names say nothing, an admin can consent -- per store, per column, with the authority it rests on, expiring within a year, withdrawable -- to a scanner node reading a bounded sample (at most 1000 rows) where the data lives. The node reads the database configured on it (AEGIS_DSPM_DSN, sealed from the code it runs); Aegis never holds or sends a connection string. The consent is read again when the node claims the job, so one withdrawn while the job waited stops it, and only counts per category come back: a submission carrying anything else is refused. Proven with the shipped node against a real Postgres whose role could read only the consented column, and on production on 29 September: the deployed claim route handed a temporary node the consented column and a 20-row bound, the submission produced one finding (20 of 20 values matched) with no value from the table in any production row, and after the consent was withdrawn the next claim failed the queued job with the reason. The consent form on the Cloud page has not been clicked on production: it is shown only for a datastore metadata could not classify, and production has none. The code-first analysis runs from the CLI only; it is not yet part of the hosted repository scan.
Implemented in: src/lib/dspm.ts, src/lib/dspm.functions.ts, src/lib/dspm-sampling.ts, src/lib/dspm-sampling.functions.ts, src/lib/dspm-code.ts, src/lib/dspm-cross-file.ts, src/components/sampling-consents.tsx
Tested by: tests/unit/dspm.test.ts, tests/unit/dspm-sampling.test.ts, tests/unit/dspm-code.test.ts, tests/unit/dspm-cross-file.test.ts, tests/rls/dspm-sampling-consents.test.ts, tests/integration/dspm-claim.test.ts, tests/integration/dspm-node-sample.test.ts, tests/integration/dspm-consent-functions.test.ts, tests/integration/cli-e2e.test.ts
Item 23. DigitalOcean with a read-scope token: cloud firewalls exposing an administrative port to the internet (ports "0", DigitalOcean's all-ports value, is read as every port), Droplets no cloud firewall applies to by id or tag, managed databases with no trusted sources or one of 0.0.0.0/0, load balancers serving HTTP with the HTTPS redirect off, and Kubernetes clusters with auto-upgrade off. Supabase's hosted account through the Management API: tables in exposed schemas with RLS disabled and a vulnerable Postgres version (both from Supabase's own security advisor), network restrictions allowing 0.0.0.0/0, and SSL not enforced. The repository-side Supabase RLS check is separate (supabase-rls).
Connect either on the Cloud page with a personal access token; Aegis only sends GET requests. Supabase personal tokens cannot be scope-limited, so use an account with read-only membership. A 401 or 403 is a read error for that service and the rules that needed it stay silent, never a pass, and a scan with no token stored is refused as not connected before anything is recorded. Each field read was taken from the provider's published OpenAPI document; three of the Supabase endpoints are marked experimental by Supabase. No account with resources was connected, so the rules are proven against the documented response shapes, and the unmodified collectors are run against the live APIs with an invalid token, where every service comes back as a refused credential and the result says it is not a clean one; not against a real misconfigured account. Oracle Cloud, Alibaba Cloud and Render are not covered (docs/INTEGRATIONS.md says why).
Implemented in: src/lib/digitalocean.server.ts, src/lib/supabase-mgmt.server.ts, src/lib/cloud-posture.ts, src/lib/multi-cloud.functions.ts, src/components/multi-cloud-panels.tsx
Tested by: tests/unit/cloud-posture-more.test.ts, tests/integration/cloud-posture-more-live.test.ts
A built-in rule set runs in-runtime across Terraform, CloudFormation, Kubernetes manifests, Helm, ARM, Bicep and Dockerfiles, with Checkov and Trivy config mode on a scanner node. GitHub Actions workflows and composite actions are read for script injection from attacker-controlled event fields, privileged workflows that check out a fork's code, third-party actions on a movable tag, write-all tokens and re-enabled insecure commands -- measured against zizmor's own labelled corpus, where it reports every high-severity line zizmor does for those checks and nothing more. Supabase migrations are replayed as one history to find public tables no migration protects with row-level security, tables whose RLS a later migration switched off, and write policies whose condition is `true`; a history the scan could not read in full is reported as not judged rather than clean.
Checkov and Trivy config scanning need a scanner node.
Implemented in: src/lib/scanners/checkov.ts, src/lib/scanners/iac-scan.ts, src/lib/scanners/sarif.ts, src/lib/scanners/workflow-scan.ts, src/lib/scanners/supabase-rls.ts
Tested by: tests/unit/checkov.test.ts, tests/unit/supabase-rls.test.ts, tests/integration/public-tables-behind-rls.test.ts, tests/unit/workflow-scan.test.ts, tests/unit/workflow-scan-benchmark.test.ts, tests/unit/trivy-config.test.ts, tests/unit/sarif.test.ts, tests/integration/checkov-iac-e2e.test.ts
A validating admission webhook the cluster calls before each pod is created. It refuses an image with a known unresolved critical finding in enforce mode, and admits it with a warning in audit mode. Audit is the default, because a webhook that refuses pods the day it is installed takes the cluster down rather than securing it. An image Aegis has never scanned is admitted with a warning, never refused, and every error fails open so the webhook cannot become a single point of failure for pod creation. It only judges findings Aegis already holds: DEC-037 removed the former scan-on-admission follow-up because an admission request is not the owner's Scan action.
An operator enables the webhook, chooses audit or enforce, and mints a token shown once. The cluster's ValidatingWebhookConfiguration points at the per-organisation callback URL carrying that token, which is stored hashed. The verdict uses the organisation's own container findings; an image with no scan is never refused. Proven against a real k3s cluster: a pod with a flagged image is refused in enforce mode and admitted in audit mode.
Implemented in: src/lib/admission.ts, src/lib/admission.functions.ts, src/routes/api/public/admission.$token.ts, src/lib/admission-webhook.server.ts
Tested by: tests/unit/admission.test.ts, tests/rls/admission-policies.test.ts, tests/integration/admission-webhook-e2e.test.ts
Workload and RBAC posture evaluated from manifests, covering privileged containers, host mounts, missing security contexts and over-broad roles.
Analyses manifests supplied by a connected repository. Running workloads are read from a cluster by the separate live cluster connector (kubernetes-live), over the Kubernetes API with a read-only service-account token; it has been exercised against k3s, not against EKS, AKS or GKE specifically, and there is no managed-provider sign-in that discovers clusters for you.
Implemented in: src/lib/kubernetes.ts
Tested by: tests/unit/kubernetes.test.ts
Reads pods, RBAC, services, network policies and Secret metadata from a running cluster over its API, and runs the existing posture rules against what is actually deployed rather than what a manifest says. Also collects running image references, which is the link from a workload back to the repository that built it.
Apply the generated read-only RBAC manifest and supply a service-account token. The connector can only get and list: it cannot create, modify or delete anything, and it reads Secret metadata without ever fetching Secret contents.
Implemented in: src/lib/kubernetes-cluster.ts, src/lib/kubernetes-cluster.functions.ts, src/lib/kubernetes.ts
Tested by: tests/unit/kubernetes-cluster.test.ts, tests/integration/kubernetes-cluster-e2e.test.ts
Broad CIS and compliance coverage across AWS, Azure, GCP, Kubernetes and infrastructure-as-code, parsed from Prowler's OCSF output by the server.
Runs on a scanner node with Docker. Prowler's own severities are never trusted directly: the server recalculates severity from its own rules.
Implemented in: src/lib/scanners/prowler.ts
Tested by: tests/unit/prowler.test.ts, tests/integration/prowler-e2e.test.ts
Lambda, Cloud Run functions (Cloud Functions v2) and Azure function apps as one asset type (serverless_function), judged by one rule set (Serverless functions, Cloud page). Runtimes are checked against each vendor's own published deprecation date -- the AWS, Google and Microsoft runtime tables copied into the code with their URLs (checked 3 October 2026) -- so a deprecated runtime is high, one within 90 days of deprecation is low, an Azure language version older than any Microsoft lists for runtime 4.x is high, and a runtime in no table is unknown rather than deprecated. Public invocation is read per function: a Lambda resource policy allowing Principal * with no condition or a function URL with AuthType NONE, or a Cloud Run function whose invoker role includes allUsers or allAuthenticatedUsers; a 404 for the policy or URL is read as none, and any other failure leaves it unread rather than private. Azure apps accepting plain HTTP are flagged. Environment variables go through the same secrets engine a repository scan uses, so a key in a Lambda's configuration is found the way a key in a .env file is, named by variable and never stored. Each function is an inventory asset whether or not it has a finding. Findings close per cloud and only for a cloud read without error.
Function code is not downloaded or scanned; this reads configuration only. Azure app settings need the list action, which the Reader role does not grant, so Azure environment variables are not read, and Azure invocation (function keys) is not judged. Lambda is read in the regions the caller names (up to six), at most 50 functions per region. The runtime tables are a snapshot of the vendors' pages on 3 October 2026 and need updating when the vendors publish new dates. Tested against each provider's documented response shapes with a stand-in fetch; no AWS, GCP or Azure account is connected in production, so it has not run against a real one.
Implemented in: src/lib/serverless-posture.ts, src/lib/serverless.functions.ts, src/lib/aws.server.ts, src/lib/gcp.server.ts, src/lib/azure.server.ts
Tested by: tests/unit/serverless-posture.test.ts, tests/unit/serverless-readers.test.ts
What is happening in production, as opposed to what is in the repository.
Judges automated traffic by behaviour rather than by user agent: request rate, whether assets a browser would load are requested, cookie and Referer handling, network type, and whether one address presents several identities. Responses are graded from observe through throttle and challenge to block, and a verified crawler is exempt.
Challenges are proof of work, not CAPTCHA: no third party sees the visitor and nothing is tracked. Supply a challengeSecret to the SDK to enable them; without one a client over the rate limit is refused outright, because a challenge nobody can verify is worse than none. Default difficulty is 12 bits, about 30ms here, chosen by measurement after 16 bits came back at 289ms median and 1.7s worst case. It raises the cost of volume; it does not detect humanity and does not stop a determined attacker solving one per session. Reputation feeds are not integrated.
Implemented in: src/lib/runtime-rules.ts, src/lib/bot-defence.ts, sdk/node/bot-challenge.ts
Tested by: tests/unit/runtime-extended.test.ts, tests/unit/bot-defence.test.ts, tests/unit/bot-challenge.test.ts, tests/integration/bot-challenge-sdk.test.ts
An optional Coraza-based reverse proxy enforcing Aegis rules in front of an application, with monitor and blocking modes and per-route exceptions. Virtual patches turn a confirmed finding into a temporary, expiring rule scoped to the affected route and parameter, generated as a Coraza rule so the proxy and the in-app SDK enforce the same definition.
Deploy the WAF binary in front of the application: `go build` in waf/, then run it with --upstream. Verified as a deployment rather than in-process — the compiled binary proxies to a real application, blocks SQL injection and path traversal with 403 in block mode, passes both through in the default detect mode, and refuses to start when a --rules directory is missing or empty. A virtual patch is never a fix: the vulnerable code is unchanged, the finding stays open, and every patch expires so it cannot become permanent by accident.
Implemented in: waf/main.go, src/lib/virtual-patch.ts, src/lib/virtual-patch-feed.ts
Tested by: waf/main_test.go, tests/integration/waf-deploy-e2e.test.ts, tests/unit/virtual-patch.test.ts, tests/integration/virtual-patch-waf-e2e.test.ts, tests/unit/virtual-patch-feed.test.ts
Falco alerts from a Kubernetes cluster may be explicitly imported by an authenticated operator as bounded JSON, or received through the existing per-organisation callback URL (/api/public/runtime/falco/<token>, token stored hashed, 600 requests a minute, bodies capped at 64 KB, a malformed or unauthenticated post stores nothing). Events are normalized with RLS and shown on the Kubernetes page. An event is linked to a container image asset only on an exact digest or repository:tag match, never by name similarity. Error priority and above raise one runtime finding per rule and container, deduplicated on replay. Neither import path initiates a scanner run.
Aegis does not run Falco. Install Falco or falcosidekick in the cluster. The manual operator import is DEC-037-compatible and on demand. The existing inbound callback is still an automatic event receiver and is not claimed as DEC-037-compliant; whether it remains enabled requires an explicit policy decision or a separately approved disablement. A live Falco run was not possible on the build machine (modern_ebpf fails in scap_init under Docker on kernel 7.0.0-34 with BTF present, root cause not found), so ingestion is proven against Falco's documented example alert copied from falco-website commit b6ed9de, not against a running cluster. An empty list is not evidence that nothing happened. Cilium Tetragon events have no ingest endpoint; only Falco's JSON alert format is accepted.
Implemented in: src/lib/falco.ts, src/lib/falco-ingest.server.ts, src/lib/falco.functions.ts, src/components/runtime-events-panel.tsx, src/routes/api/public/runtime/falco.$token.ts
Tested by: tests/unit/falco.test.ts, tests/integration/falco-ingest-e2e.test.ts, tests/integration/falco-ingress-d1.test.ts, tests/integration/better-auth-worker-e2e.test.ts, tests/rls/falco-runtime-events.test.ts
In-app SDKs for Node, Python, Java, PHP, .NET, Go and Ruby (Rack) reporting attacks and enforcing monitor or block mode, with per-endpoint policy. Each carries the manifest its ecosystem installs from, and the Node SDK is verified by packing it, installing the tarball into an empty directory, and driving the installed code.
Install an SDK in the protected application and issue an agent token. Until an agent reports, the page shows no data rather than an empty success. Source for all seven is public at github.com/iconicbeen/aegis-sdks. The Go SDK installs with `go get` from there today; the other six are not yet on their registries (npm @aegis-sarl/node, PyPI aegis-sarl, RubyGems aegis-sarl, NuGet AegisSarl.Security, Maven sarl.aegis:aegis-sarl, Packagist aegis-sarl/sdk), so until they are, installation means building from that repository. Protection is decided locally and reporting is best-effort, so an unreachable control plane changes neither what is blocked nor what is allowed.
Implemented in: sdk/node/runtime-protection.ts, src/lib/runtime-rules.ts, src/lib/runtime.functions.ts, sdk/node/package.json, sdk/java/pom.xml, sdk/php/composer.json, sdk/ruby/aegis-sarl.gemspec
Tested by: tests/unit/runtime-protection.test.ts, tests/unit/runtime-extended.test.ts, tests/integration/sdk-parity-e2e.test.ts, tests/integration/sdk-package-e2e.test.ts, tests/integration/sdk-ruby-e2e.test.ts
Fresh traffic to an endpoint raises the priority of findings on that endpoint, with the observation named in the explanation. Silence never lowers one: a collector that has stopped reporting, an endpoint nobody visited this week, and an asset the collector cannot speak for all leave the score exactly where it was. For npm dependencies, the Node SDK's dependency collector (`aegisDependencies` in @aegis-sarl/node) reports which package versions a running service loaded, through a `node:module` load hook, and which were executing while each route was served, through V8's sampling profiler in short windows, crediting a sample to a route only when exactly one request was in flight. A finding on a reported version is raised and its explanation names the route and service ("semver 7.6.3 was on the call stack serving GET /versions/:v in checkout-service"), or says it is loaded and not yet seen running. Proven with a real Express app under Node 22: semver and ms were each credited to the one route that called them, lodash (imported, never called) to none, the report reached the ingest route, and a persisted finding on semver scored above an identical one on a package never reported, which kept exactly the score it has with no collector. The runtime page lists what was seen, with the open findings on each version. Python and Go services report the same two facts (`sdk/python/aegis_dependencies.py`, `sdk/go/dependencies.go`), keyed as the inventory keys them (`PyPI:name@version`, `Go:module@version`): Python's loaded set is every imported module resolved to its distribution through RECORD, Go's is the modules linked into the binary (`debug.ReadBuildInfo`), and both sample the stacks of the threads or goroutines serving a request, crediting a sample only when exactly one request was in flight for the whole span of the stack read. Proven under real CPython (a WSGI app: packaging credited to GET /parse only, idna to GET /idna only, six loaded and called nowhere) and a real `go build` net/http server (uuid to GET /uuid only, x/mod to GET /semver only, pkg/errors linked and called nowhere), each reaching the ingest route and raising a persisted finding above an identical unseen one. The span rule was found by the Go test: timestamping a sample after the stack read credited uuid to GET /semver; removing it, or reading every goroutine instead of the serving ones, fails a test.
Runtime events record HTTP requests, so they are evidence about a web application and nothing else; a container image or cloud account gets no runtime verdict, and a dependency gets one only from the dependency collector, never from traffic. Collectors exist for Node (22.15 or later), Python (WSGI) and Go (net/http); Java and .NET services report nothing, and a Maven sighting would match nothing because no lockfile parser writes Maven inventory rows. Go's loaded set means linked into the binary, which is every module the build includes, called or not. Python's attribution needs the application to name the matched route; with no route function it reports loaded distributions only. Each collector sees what it samples: a library call shorter than the sampling interval, a request that overlaps another, or code that ran outside a profiling window (10 seconds in 300 by default) is not credited to a route, and a module loaded before the collector started is seen only through the CommonJS cache. Evidence is per organisation, not per deployment: a package seen in one service raises its findings wherever the same version appears. The verdict is never negative: `computeRisk` has a branch for telemetry that looked and saw nothing, and this never reaches it, because absence over a window is weak evidence and a wrong negative is the one answer that makes a finding look safer than it is.
Implemented in: src/lib/runtime-evidence.ts, src/lib/persist.server.ts, src/lib/runtime-dependencies.ts, src/routes/api/public/runtime/dependencies.ts, sdk/node/dependencies.ts, sdk/python/aegis_dependencies.py, sdk/go/dependencies.go, src/lib/runtime.functions.ts, src/routes/_authenticated/runtime.tsx, supabase/migrations/20261006210000_runtime_dependency_sightings.sql, supabase/migrations/20261007040000_runtime_dependency_ecosystems.sql
Tested by: tests/unit/runtime-evidence.test.ts, tests/unit/runtime-dependencies.test.ts, tests/integration/dependency-runtime-e2e.test.ts, tests/integration/dependency-runtime-python-e2e.test.ts, tests/integration/dependency-runtime-go-e2e.test.ts, tests/rls/runtime-dependency-sightings.test.ts, sdk/python/test_aegis_dependencies.py, sdk/go/dependencies_test.go
What is reachable from the internet, including what nobody meant to publish.
Builds an API inventory from observed traffic and compares it against the specification, naming shadow endpoints that serve traffic and appear in no spec, and zombie endpoints that are specified and serve nothing. A shadow endpoint can be recorded as a finding, and it closes automatically once the endpoint is documented.
Report observations from the runtime SDK or a proxy; nothing is discovered without traffic. Endpoint shapes only are stored -- method, normalised path, status codes, and parameter names with inferred types -- because recording real requests would make Aegis a copy of every request its customers serve, which is a worse liability than the undocumented endpoint it found. Only a shadow endpoint becomes a finding; a zombie is a documentation-hygiene matter and stays in the drift report.
Implemented in: src/lib/api-discovery.ts, src/lib/api-discovery.functions.ts, src/lib/api-drift.server.ts
Tested by: tests/unit/api-discovery.test.ts, tests/unit/api-drift-findings.test.ts, tests/integration/api-drift-e2e.test.ts
OpenAPI inventory and static analysis, GraphQL schema analysis covering introspection exposure and destructive mutations, and Schemathesis contract testing on a scanner node.
Schemathesis needs a scanner node and a verified host. OpenAPI documents are read as JSON.
Implemented in: src/lib/api-schema.ts, src/lib/graphql-scan.ts, src/lib/scanners/schemathesis.ts
Tested by: tests/unit/graphql-scan.test.ts, tests/unit/schemathesis.test.ts, tests/integration/schemathesis-api-e2e.test.ts
Derives relationships between assets from evidence the scanners already collected — an image label naming its source repository, a pod naming its image, a domain resolving to an address a resource holds — and walks them to answer which repository produced the container running behind a given domain. Attack paths are deterministic and every step cites its evidence. Cloud map (item 24, Asset Graph page): cloud assets nested provider, account/subscription/project, region and network, drawn only at levels the data records (Cloudflare has no region or network, Azure no network), with edges from real asset_edges rows; exposure comes only from internet_exposed set by a scan, an import or an exposure proof, with its source shown, and null is drawn as unknown rather than closed; open findings per resource by severity link to Issues filtered to that asset (?asset=). With no cloud assets the view lists each connector's state instead of an empty canvas. The AWS, Azure, GCP and Cloudflare writers now record provider, account and region (and VPC for AWS) so resources can be placed.
Implemented in: src/lib/attack-path.ts, src/lib/asset-graph.ts, src/lib/asset-edges.ts, src/lib/asset-types.ts, src/lib/risk-optimizer.ts, src/lib/digital-twin.ts, src/lib/cloud-topology.ts, src/lib/cloud-topology-layout.ts, src/lib/cloud-topology.server.ts, src/lib/cloud-topology.functions.ts, src/components/cloud-topology-view.tsx
Tested by: tests/unit/attack-path.test.ts, tests/unit/asset-graph.test.ts, tests/unit/asset-edges.test.ts, tests/unit/asset-types.test.ts, tests/unit/graph-relation-vocabulary.test.ts, tests/unit/cloud-topology.test.ts, tests/integration/cloud-topology-postgrest.test.ts
Certificate transparency enumeration, DNS resolution, HTTP fingerprinting and dangling CNAME detection, against DNS-verified domains only. A separate posture check reads the apex's SPF, DMARC, CAA and DNSSEC from public DNS, notes DKIM keys at the common selectors, and fetches its security.txt; a lookup that does not answer produces no finding, and a DNSSEC failure is read from inside the zone, where dnssec-failed.org shows it, rather than from the parent's DS record, which still validates. A web-surface pass reads up to twelve same-origin pages, robots.txt and the sitemap, the site's own scripts and their source maps, and the conventional OpenAPI paths; it records the technologies the site states, the third parties whose scripts run on it, CDN-loaded libraries, and the API, GraphQL and WebSocket endpoints its client code names, links them in the asset graph, and grades CSP, HSTS, framing, Permissions-Policy, CORS, redirects, forms, Subresource Integrity, public source maps and public API descriptions. It runs on demand only, from a button, inside a Durable Object: nothing crawls a domain on a timer (DEC-037), so a change on the surface is found the next time somebody runs it. It never fetches outside the verified apex. After each pass the application's endpoints are matched against the routes every repository declares: when one repository explains at least two distinct endpoints, one of them more than a single segment deep, and no other explains as many, the application is linked built_from that repository with the matched routes as evidence, and every open code finding in a file that declares a matched route is marked internet-exposed with the URLs that reach it and its risk rescored. Domain intelligence reads each verified domain's registration from RDAP (registrar, expiry, name servers, transfer lock), the network each address sits in (reverse DNS and the Team Cymru ASN service), every certificate certificate transparency holds, and whether look-alike domains resolve; it reports an expiring registration, a missing transfer lock, an expiring newest certificate, a valid certificate from a CA the domain's CAA does not allow, and resolving look-alikes. Each observer keeps its latest snapshot and writes one row per change against the previous one -- a new address, name server, certificate or network, a lost header, a new third party or endpoint -- and the Attack Surface page shows them as Latest changes. A source that does not answer produces no finding, closes nothing and records no change. A TLS check on a scanner node pins one OpenSSL handshake to each of TLS 1.0, 1.1, 1.2 and 1.3 and reads the certificate and chain OpenSSL verifies against the system trust store; it reports accepted TLS 1.0 or 1.1, no modern version, an expired or expiring certificate, a self-signed one, a name mismatch, a missing intermediate and an RSA key under 2048 bits. It needs a verified domain but no active-test approval, because a handshake carries no payload, and a host whose certificate could not be read is a failed scan rather than a clean one. Exposure proof (item 30, Assets page): for a web application, domain or API asset on a verified domain, an HTTPS request from the Cloudflare edge -- a vantage outside the customer's network -- confirms reachability. Any response proves it and is the only thing that sets internet_exposed to true; a probe that gets no response is recorded as unconfirmed and changes nothing, because one vantage failing is not proof the asset is unreachable. Each run writes a timestamped evidence record and never follows a redirect, so configuration stays the prior and the proof is a measurement a customer can check.
Verify domain ownership before a host can be scanned. Port discovery is a TCP connect scan that additionally needs a recorded approval covering active_safe testing, and it runs on a scanner node: Workers has no outbound TCP API, and a scan from the control plane would report what Cloudflare can reach rather than what your network exposes.
Implemented in: src/lib/exposure-proof.ts, src/lib/exposure-proof.functions.ts, src/lib/domains.functions.ts, src/lib/dns.server.ts, src/lib/domain-posture.ts, src/lib/web-surface.ts, src/lib/web-surface.server.ts, src/lib/endpoint-correlation.ts, src/lib/endpoint-correlation.server.ts, src/lib/domain-intel.ts, src/lib/domain-intel.server.ts, src/lib/surface-changes.ts, src/lib/scanners/port-scan.ts, src/lib/scanners/tls-scan.ts, src/lib/scanners/tls-session.ts, src/lib/scanners/zone-transfer.ts
Tested by: tests/unit/exposure-proof.test.ts, tests/rls/active-scan-auth.test.ts, tests/unit/domain-posture.test.ts, tests/unit/web-surface.test.ts, tests/integration/web-surface-persist.test.ts, tests/unit/endpoint-correlation.test.ts, tests/integration/endpoint-correlation-persist.test.ts, tests/unit/domain-intel.test.ts, tests/integration/domain-intel-persist.test.ts, tests/unit/port-scan.test.ts, tests/integration/port-scan-sockets.test.ts, tests/unit/tls-scan.test.ts, tests/unit/tls-session.test.ts, tests/integration/tls-scan-node.test.ts, tests/unit/zone-transfer.test.ts, tests/integration/zone-transfer-node.test.ts
Re-testing of open findings under a written authorisation that an admin approves, scoped to verified domains and bounded by an expiry. Discovery pentests probe a fixed read-only set, cross-role and role-reach comparisons, and in whitebox mode every parameter-free GET route the connected repository declares. A scanner-node validation stage confirms reflected XSS, boolean SQLi, traversal and controlled open redirects with bounded evidence and high-confidence findings, confirms blind SSRF out-of-band through a single-use Aegis-controlled callback token that is confirmed only when the callback is actually reached inside the challenge window, and confirms cross-role access (IDOR) from two recorded sessions when the other user receives the owner's identical resource. A validated finding can be retested on demand, re-running its exact checks: a finding whose flaw no longer reproduces is closed and the retest is recorded, and one still confirmed is left open with a fresh sighting. Removed under DEC-037: a push to a repository with a verified deploy target no longer validates anything, because the push receivers and the deploy-validation trigger (`deploy-validate.server.ts`) were deleted and nothing starts that path now. What it did, kept here so the evidence below still reads: it validated just the routes the diff changed against the running deployment, scoped to the changed files, with the changed files read at the pushed commit and a bounded budget of 20 routes spent on the highest-value trust boundaries first (authentication, then administration, payment, account, redirects and webhooks, uploads, API, then the rest), read from each route's path; routes the budget left out are recorded on the scan as deferred with their boundary, never dropped silently. The boundary is a hint from the path, recorded beside each route so the ordering can be checked. Proven against real GitHub (the sandbox read at its pushed commit, the payload recording commit, boundaries and deferred). Every confirmed validation has a proof-of-exploit replay pack, downloadable from the finding drawer: a self-extracting sh archive holding a README with the single curl request and a replay.sh that resends exactly the stored proof markers and decides with the validator's own rule, printing CONFIRMED (exit 0), NOT REPRODUCED (exit 1) or REQUEST FAILED (exit 2, never read as a fix). Its manifest names each file's SHA-256 and is signed with the deployment's evidence key; built only from stored evidence, so one finding always gives the same bytes. IDOR packs ask for the two sessions rather than containing them; blind SSRF says it cannot be replayed from a client. Proven by running each pack with sh against a real server that has the flaw (CONFIRMED) and then the same server fixed (NOT REPRODUCED), and by unpacking the archive, checking every hash and verifying the signature with openssl, which refuses a one-character change. Production holds no validated finding yet (3 October), so the drawer button has not been exercised there; it appears only on a pentest-validate finding. A retest of a reflected-XSS check re-sends the nonce its first run used, read from that run's stored evidence and matched by path and parameter: the nonce is part of the request URL and so of the finding's identity, and with a fresh one a fixed endpoint's retest matched nothing and closed nothing (measured 3 October against a real server; proven through the real scanner node). Removed under DEC-037, with the push receivers: a push to the default branch of a repository with a deploy target no longer plans a retest. A retest now runs only when somebody asks for it. What it did was plan again, from each finding's stored evidence, the attacks that confirmed that target's open findings -- same kind, path, parameter and nonce, so the same URL -- and queued as a retest under the same verified-host and approval guards; blind SSRF and IDOR are skipped with the reason, since they need a fresh token or sessions that are never stored. A finding closes only if its attack now fails, and the closing retest records on the finding the request it sent and the response it got, as proof the fix works. Proven against the local database through the real submit path: planned from the open finding, the fixed target's retest closes it and records the escaped response. Per-run escalation (item 5, Aikido #46): an owner may grant a single-use widening for one run -- named hosts, named classes, who authorised it and why, a hard expiry of at most 24 hours -- recorded in test_escalations. The run path tries the standing approval first and leaves it untouched; only when that refuses does it claim a matching escalation, stamping consumed_at on the exact scan so the grant permits one run and no more, proven against a real database (owner-only insert, single-use consumption, a second run refused). An escalation never widens by subdomain. Threat-model-driven plan (item 7, Validation page): the product's own STRIDE threat model, joined to this organisation's real scans, is ordered into what to attack first -- unexamined threats before tested ones, the stalest tested ones next, ties toward the more severe boundary -- each item naming the live technique this product can run for it (a target-boundary threat maps to the reflected-XSS, boolean-SQLi, traversal, open-redirect or cross-role probe) or stating why it has none (denial of service has no safe live probe; tenant isolation is proven by the RLS suite, not a live run). It orders work and runs nothing; the mapping is honest about what a live probe can and cannot cover. AI endpoint pentest (item 2, Validation page): sends prompt-injection, role-play, base64-encoded, delimiter-confusion and system-prompt-leak probes to a customer's own OpenAI-compatible chat/completions endpoint, under the same gate as any active test -- a verified domain and a recorded active_injection approval on the endpoint host, resolved to a public address first. Each probe carries a run-unique marker and instructs the endpoint to emit it; a finding is confirmed only when the marker appears as an emitted token (a refusal that quotes it does not count), which proves the endpoint followed an instruction embedded in the input -- the same reflected-marker discipline as the XSS validator, not a classifier judging tone. An injection is high and a system-prompt leak medium, keyed per technique on the llm_endpoint asset; a probe with no marker is not-confirmed, never read as a defence, and a failed call is errored, never a clean pass. The optional API key is used for the run and never stored. Proven against three real loopback endpoints -- compliant, refusing and 500 -- for confirmed, not-confirmed and errored. Continuous pentest per release (item 1) is removed: the chain (a confirmed finding queuing one bounded follow-up validation scan, and a per-release new/fixed/still-present diff) could only start from a release row that the deleted deploy trigger opened, so under DEC-037 and OD-10 its code, its job-submit hook and its tests were deleted. The pentest_releases table is kept and its fate is part of D49. Proof of fix (item 14): when a retest closes a finding, the closing event carries one signed statement (format aegis-fix-proof/1, src/lib/fix-proof.ts) placing the confirming observation beside the retest's -- the same request (kind, method and URL with its nonce) confirmed before and not-confirmed after, each side's scan, engine version, time, response status and the SHA-256 of the response excerpt (identified, not republished), and the deploy that triggered it -- signed with the deployment's Ed25519 evidence key. A degraded retest, a different request or a different kind of check produces no statement, recorded as refused. The same event records the outcome fixed for the learning engine. A fixed validated finding's drawer downloads it as a self-extracting archive that openssl verifies. Proven through the real submit path at D1 phase 4 (openssl verifies the stored statement and refuses a one-character change) and through the built Worker in Chrome (download, unpack, verify).
The implemented validation classes run only on a registered scanner node after active_injection approval and persist bounded evidence. Blind SSRF confirms out-of-band: the server mints a hashed, bounded-lifetime callback token, the node injects it into the authorised target, and the finding is confirmed only when the public callback route records a hit inside the window -- never from the node's response. Cross-role (IDOR) validation takes two recorded sessions and confirms only when the other user's response body equals the owner's, which distinguishes a real leak from a public page; the session cookies are redacted out of stored evidence. A retest re-reads the prior scan's checks rather than taking them from the caller, runs the same approval and host guards, and closes only findings whose check came back not-confirmed -- a degraded or dropped check closes nothing. Explicit 429/backoff degradation is absent, and expired authorisation stops the run. Whitebox reads Express-style, Flask, FastAPI and Spring declarations, Django urlconfs with DRF routers, Laravel and Rails route files, and Next.js file routes; declarations it cannot follow are counted, so the probed surface is a lower bound.
Implemented in: src/lib/ai-pentest.ts, src/lib/ai-pentest.functions.ts, src/lib/test-approval.functions.ts, src/lib/test-escalation.functions.ts, src/lib/pentest-plan.ts, src/lib/validation.functions.ts, src/lib/pentest.functions.ts, src/lib/pentest-probe.ts, src/lib/source-routes.ts, src/lib/pentest-validation.ts, src/lib/oob.ts, src/lib/pentest-retest.ts, src/lib/replay-pack.ts, src/lib/replay-pack.functions.ts, src/lib/fix-proof.ts, src/lib/fix-proof.functions.ts, src/lib/scanners/catalog.ts, src/lib/nodes.ts, src/routes/api/public/nodes/jobs.ts, src/routes/api/public/oob.$token.ts, scanner-node/index.ts
Tested by: tests/unit/fix-proof.test.ts, tests/unit/ai-pentest.test.ts, tests/integration/ai-pentest-endpoint-e2e.test.ts, tests/unit/test-approval.test.ts, tests/rls/test-approvals.test.ts, tests/unit/test-escalation.test.ts, tests/rls/test-escalation.test.ts, tests/unit/pentest-plan.test.ts, tests/unit/source-routes.test.ts, tests/unit/django-routes.test.ts, tests/unit/django-drf-routes.test.ts, tests/unit/laravel-routes.test.ts, tests/unit/rails-routes.test.ts, tests/unit/rails-minimal-routes.test.ts, tests/integration/pentest-pipeline.test.ts, tests/integration/replay-pack-e2e.test.ts, tests/unit/pentest-retest-nonce.test.ts, tests/rls/replay-pack.test.ts, tests/unit/pentest-cross-role.test.ts, tests/integration/scan-target-live-e2e.test.ts, tests/integration/pentest-node-e2e.test.ts, tests/integration/pentest-validate.test.ts, tests/integration/whitebox-pentest-github-e2e.test.ts, tests/unit/oob.test.ts, tests/rls/oob-challenges.test.ts, tests/integration/oob-callback-e2e.test.ts, tests/unit/pentest-cross-role-validation.test.ts, tests/integration/idor-validation-e2e.test.ts, tests/unit/pentest-retest.test.ts
Aegis's bounded HTTP header, cookie, banner and reviewed exposed-path checks run on the authenticated direct-node session; PASSIVE is the default, while sensitive-path requests require explicit per-scan ACTIVE_SAFE consent and a recorded approval. HackerTool also exposes a pinned reviewed Nuclei header profile and a bounded ZAP passive baseline through the existing scanner-node adapters.
Runs only against DNS-verified domains on demand through an authenticated scanner-node session (DEC-037). The Aegis web-scan PASSIVE mode makes at most a root GET and an HTTP-to-HTTPS HEAD; ACTIVE_SAFE adds seven reviewed sensitive-path GETs only after per-scan user confirmation and an unexpired active_safe approval. Redirects are not followed, each request rechecks resolved target scope, and raw response bodies are never returned as findings or persisted as scan evidence. HackerTool's Nuclei profile is limited to the pinned http-missing-security-headers GET template, requires per-scan authorization and the existing active_injection approval, and routes requests and redirects through the scope proxy. Its ZAP entry exposes only the bounded passive baseline, disables form submission and active attack rules, and requires explicit per-scan confirmation plus active_safe approval. Neither adapter runs automatically.
Implemented in: src/lib/scanners/web-scan.ts, src/lib/scanners/catalog.ts, src/lib/nodes.functions.ts, scanner-node/index.ts, src/routes/api/public/nodes/jobs.ts, src/lib/scanners/nuclei.ts, src/lib/scanners/zap.ts, scanner-node/nuclei-hackertool.ts, src/lib/scanners/nuclei-profile.ts, src/lib/auth-crawl.server.ts, src/routes/_authenticated/dast.tsx, src/routes/_authenticated/hackertool.tsx
Tested by: tests/unit/web-scan-error-page.test.ts, tests/unit/scanner-registry.test.ts, tests/integration/node-session-e2e.test.ts, tests/unit/nuclei.test.ts, tests/unit/nuclei-fuzzing.test.ts, tests/unit/zap.test.ts, tests/unit/auth-crawl-dispatch.test.ts, tests/integration/nuclei-hackertool-profile.test.ts, tests/integration/zap-dast-e2e.test.ts, tests/integration/better-auth-worker-e2e.test.ts
A native six-entry catalog: reviewed Aegis web-surface, TLS configuration, DNS zone-transfer and bounded TCP port-inventory adapters, plus the existing pinned Nuclei HTTP-header profile and bounded ZAP passive baseline. They share the authorized direct-node scan lifecycle and canonical finding pipeline; no unreviewed upstream code is installed or executed.
All six entries require an explicit owner action, a connected compatible scanner node and a host or zone covered by an organization-verified domain. Web checks default to PASSIVE; sensitive-path ACTIVE_SAFE checks require per-scan confirmation and an unexpired active_safe approval. TCP port inventory requires active_safe approval; DNS AXFR asks only the verified zone's own name servers and stores bounded name/type evidence. The Nuclei adapter runs only its pinned http-missing-security-headers GET template through the scope proxy and requires the existing active_injection approval. The ZAP adapter exposes only its bounded passive baseline, disables form submission and active attack rules, and requires per-scan confirmation and active_safe approval. Unreviewed upstream catalog items are not presented as runnable.
Implemented in: src/lib/hackertool.ts, src/components/scanner-node-test-panel.tsx, src/routes/_authenticated/hackertool.tsx, src/lib/scanners/web-scan.ts, src/lib/scanners/catalog.ts, src/lib/nodes.functions.ts, src/routes/api/public/nodes/jobs.ts, scanner-node/index.ts, src/lib/scanners/tls-scan.ts, src/lib/scanners/zone-transfer.ts, src/lib/scanners/port-scan.ts, scanner-node/tcp-probe.ts, src/lib/scanners/nuclei.ts, src/lib/scanners/nuclei-profile.ts, scanner-node/nuclei-hackertool.ts, src/lib/scanners/zap.ts
Tested by: tests/unit/hackertool-catalog.test.ts, tests/unit/web-scan-error-page.test.ts, tests/unit/scanner-registry.test.ts, tests/integration/node-session-e2e.test.ts, tests/unit/port-scan.test.ts, tests/unit/tcp-probe.test.ts, tests/integration/port-scan-sockets.test.ts, tests/integration/node-session-e2e.test.ts, tests/integration/tls-scan-node.test.ts, tests/integration/zone-transfer-node.test.ts, tests/integration/nuclei-hackertool-profile.test.ts, tests/integration/zap-dast-e2e.test.ts, tests/integration/better-auth-worker-e2e.test.ts
Devices and virtual machines, and what is installed on them.
A Claude Code PreToolUse hook (`aegis agent-guard`) that judges each shell command an AI coding agent proposes before it runs, and denies it in Claude Code's documented hook format with the rule named: a download piped into an interpreter (including inside $() or backticks), a read of a well-known credential file (~/.aws/credentials, SSH private keys, .npmrc, .netrc, docker and gh config, kubeconfig, .git-credentials), the environment sent over the network, a force-push of main/master/production/release, a recursive delete of / or home, and an install of a package that OSV lists as malicious (MAL- advisories) or, with AEGIS_URL and AEGIS_TOKEN set, that the deployment's npm install gate refuses. Ordinary work -- tests, clean installs, deleting build output, reading a .pub key, a force-push of a feature branch -- gets no decision, so the normal permission flow stays in charge. Proven by spawning the hook exactly as Claude Code does from a real .claude/settings.json, including a live malicious package (vl-ui-body, MAL-2026-990). It also enforces the repository's development-control policy (docs/DEVELOPMENT_CONTROL.md): a command that acts beyond the machine (git push, a Worker deploy or rollback, a hosted Supabase migration or management-API SQL, a package or image publish, a release or release tag, a production secret change) is refused unless the session's AEGIS_ALLOW_REMOTE names that action; dry runs, local migrations, fetch and local commits pass, and a force push to main stays refused even with a push grant.
Reads the command text, split on the shell's separators with command substitutions pulled out; a command assembled at runtime (decoded and eval'd) is judged on its visible text only. Claude Code's own documentation says a hard allow or deny belongs in its permission system; this is a layer in front of it, and a developer can remove the hook. Claude Code only: other agents' hook formats are not wired. A run through the claude CLI itself could not be completed on the development machine because its configured model proxy was not running, so the end-to-end proof is the hook contract rather than a model choosing to run the command.
Implemented in: src/lib/agent-guard.ts, cli/aegis.ts
Tested by: tests/unit/agent-guard.test.ts, tests/integration/agent-guard-hook-e2e.test.ts
An opt-in agent reporting global packages, IDE extensions, AI tooling and MCP servers, analysed against OSV, with per-category consent. MCP servers are judged on one narrow combination -- broad filesystem reach together with a network path -- and a server whose reach cannot be read is surfaced for review rather than scored, because the agent reads the invocation and never connects to the server. VS Code extension allow and block lists (item 41): the approved editor policy is written by the agent into VS Code's own extensions.allowed setting on a device whose owner enabled enforcement, so VS Code refuses to install a blocked extension (by id or publisher) while unlisted ones stay allowed; extensions already installed are reported, never removed, a missing settings file is never created, and one with comments is left unchanged. Proven with the real code CLI in a scratch profile: the blocked extension installs with enforcement off and is refused with it on.
Enrol a device and run the agent from a clone with `bun run device-agent/index.ts`, or deploy it as a package or through an MDM (capabilities device-agent-packages and mdm-profiles), granting consent per category. It refuses to start without AEGIS_URL and AEGIS_DEVICE_TOKEN, and reports a failed upload rather than exiting as though it had succeeded. Posture checks such as disk encryption need a privileged system agent and are not implemented.
Implemented in: src/lib/extension-allowlist.ts, src/lib/devices.server.ts, src/lib/devices.functions.ts, src/lib/scanners/mcp-posture.ts, device-agent/index.ts
Tested by: tests/unit/device-agent.test.ts, tests/unit/extension-allowlist.test.ts, tests/integration/extension-policy-e2e.test.ts, tests/unit/mcp-posture.test.ts, tests/integration/self-hosted-agents-e2e.test.ts
Item 39. The device agent as a native package that runs on a schedule instead of from a clone, in each user's session (it reads the developer's home directory, so as root it would report /root): a Debian package with systemd user units enabled for every user, an RPM spec with the same, and a WiX source for an MSI whose scheduled task's principal is BUILTIN\Users. Each ships the agent bundled into one file and a configuration file holding only a placeholder token.
The .deb and .rpm are proven end to end. The .deb: built by dpkg-deb, installed with apt in a Debian container, the timer enabled for all users, and the installed command run as an ordinary user posts a real inventory with the configured token; the first version ran the agent as a root system service, and that test is what showed it. The .rpm (7 October): built by rpmbuild and installed with dnf in Fedora 41 containers, timer enabled for every user, the installed command run as an ordinary user posts a real inventory with the configured token, and removal disables the timer and removes the bundled Bun; dropping either step from the spec fails its test. The .msi is a real source checked statically (the .wxs parsed as XML) and has not been built: it uses full WiX (SetProperty, NeverOverwrite), which msitools' wixl does not implement (tried in fedora:41 on 7 October: unhandled child Product node SetProperty), so it needs WiX on Windows. Debian ships no Bun, so postinst downloads it from bun.sh (not exercised in the test, where Bun is preinstalled); the MSI expects Bun installed by the fleet. Not code-signed; not installed on a managed fleet.
Implemented in: deploy/agent-packages/build-deb.sh, deploy/agent-packages/aegis-agent.spec, deploy/agent-packages/aegis-agent.wxs
Tested by: tests/integration/agent-package-deb-install.test.ts, tests/integration/agent-package-rpm-install.test.ts, tests/integration/agent-package-deb.test.ts, tests/unit/agent-package-spec.test.ts
Quarantines MCP servers an approved policy blocks, so the client no longer launches them. This is the only developer tooling this product can genuinely prevent rather than report: an MCP server is an entry in a configuration file read at startup, whereas a browser extension cannot be refused from outside the browser and a deleted editor extension is reinstalled in seconds. Nothing is removed -- the definition is kept verbatim in the same file with the reason and the policy version, and the developer can restore it by hand.
Needs all three: an `editor_policies` row at status `active`, which requires a second person's approval; `enforcement_enabled` set on the device by whoever owns it; and the agent started with `--enforce`. Any one absent and the agent reports what would have happened and changes nothing. A developer with local admin can undo the quarantine, which is the honest limit: this is friction and an audit trail, not a seal.
Implemented in: src/lib/mcp-enforcement.ts, src/lib/mcp-quarantine.ts, device-agent/index.ts
Tested by: tests/unit/mcp-enforcement.test.ts, tests/unit/mcp-quarantine.test.ts, tests/unit/device-report-carries-policy.test.ts
Item 40. `aegis mdm <jamf|kandji|intune> --out <dir>` writes what each MDM deploys, with the agent embedded (bundled when the CLI is built, so the npm package carries it). macOS: a root install script for a Jamf policy or Kandji Custom Script that installs Bun, writes the agent and its settings, and installs a LaunchAgent so the agent runs in each developer's session; and a configuration profile with Apple's Managed Login Items payload (com.apple.servicemanagement, Label rule) so macOS 13+ treats it as managed. Windows: an Intune Win32 app script (install, uninstall, detect) whose scheduled task runs as BUILTIN\Users, not SYSTEM.
The macOS install script is run as root in a Debian container with launchctl, stat -f and the staff and wheel groups shimmed; the LaunchAgent's command, run as an ordinary user, posts a real inventory with the configured token. It has not run on a Mac. The Intune script is parsed by real PowerShell and its embedded agent decodes byte-identical; it has not run on Windows, so Register-ScheduledTask and icacls are unexercised. The installed npm CLI is shown to write a script carrying the whole agent. Nothing has been uploaded to a real Jamf, Kandji or Intune tenant, and no device has been enrolled. A first version emitted a profile with a payload type Apple does not define and never placed the agent on the machine; both were found by running the artefacts, not by the unit tests that parsed them.
Implemented in: src/lib/mdm/profiles.ts, src/lib/mdm/agent-bundle.ts, cli/aegis.ts
Tested by: tests/unit/mdm-profiles.test.ts, tests/integration/mdm-install-script.test.ts, tests/integration/cli-package-e2e.test.ts
A CLI wrapper that checks package provenance and known advisories before a dependency is installed.
Implemented in: safe-install/index.ts
Tested by: tests/unit/safe-install.test.ts, tests/integration/safe-install-live.test.ts
Turning findings into the evidence an auditor asks for, and recording the controls no scanner can see.
Technical controls evaluated from real scan, finding and audit evidence across multiple frameworks, with hash-verifiable evidence packs, Ed25519-signed where the deployment holds a signing key so an auditor can verify authorship with openssl and the published public key, and a trust centre. Ten organisational controls that no scanner can see are recorded separately as dated attestations by named people, with review intervals, an undeletable history of superseded claims, and wording that never presents a claim as a check. Device evidence (item 42): AEG-11 (endpoint inventory, SOC 2 CC6.8, ISO 27001 A.8.1) is judged from what enrolled devices reported -- current, stale and never-reported counted separately against a 7-day window -- instead of from endpoint scans that nothing wrote, which had left it at no evidence on every fleet; AEG-16 (install-time malware prevention, CC6.8, A.8.7) reports the share of current devices with npm ignore-scripts on, with the setting's bypass stated. Counts only; no device names in the pack. Proven by running the real device agent against the dev server for two devices with ignore-scripts on and off, then reading the evidence over PostgREST as a member.
Aegis evidences technical controls and records organisational ones; it does not verify the latter and says so wherever they appear. The auditor request workflow is implemented -- request, submit, review, with separation of duties enforced in the database so a member cannot insert a submission directly -- and GRC platform sync is its own capability, grc-connectors.
Implemented in: src/lib/compliance.ts, src/lib/compliance.functions.ts, src/lib/evidence.ts, src/lib/attestations.ts, src/lib/attestations.functions.ts, src/lib/evidence-signing.ts, src/lib/compliance-ops.functions.ts, src/lib/trust-center.functions.ts, src/routes/trust.$slug.tsx, src/lib/device-evidence.ts
Tested by: tests/unit/evidence.test.ts, tests/rls/compliance-ops.test.ts, tests/rls/evidence-requests.test.ts, tests/unit/attestations.test.ts, tests/unit/device-evidence.test.ts, tests/integration/device-evidence-e2e.test.ts, tests/rls/attestations.test.ts, tests/unit/evidence-signing.test.ts, tests/rls/evidence-pack-signatures.test.ts, tests/integration/evidence-signature-browser.test.ts
Pushes Aegis observations into Drata, Vanta or Secureframe so an audit reads from the tool the auditor already uses. Every mapping between an Aegis control and an external one is declared with the rationale that defends it and what it does not cover, and both travel with the evidence. Controls Aegis has no evidence for are pushed as such rather than omitted, since an omitted control reads as one nobody checked.
Store the platform's API token, which only an owner or admin can do. Previewing and sending are separate actions, and the send button appears only after a preview, so the button offering to show what would be written cannot write it. Aegis never marks a control passed or compliant — it reports what it observed and the platform and auditor draw the conclusion; a push that would assert a verdict is refused before it reaches the network. Six mappings ship, deliberately few: each is a claim that two differently-worded controls are about the same thing, and a wrong one is invisible until an audit depends on it. Both handlers run against a real Postgres with RLS in force, delivery is verified against a local HTTP server that records what arrives, and the built server refuses a cross-site request to every endpoint. Not verified against a real Drata, Vanta or Secureframe account.
Implemented in: src/lib/grc.ts, src/lib/grc.server.ts, src/lib/grc.functions.ts, src/components/grc-panel.tsx
Tested by: tests/unit/grc.test.ts, tests/integration/grc-push-e2e.test.ts, tests/rls/grc-push.test.ts, tests/integration/production-build-e2e.test.ts
Routing of findings to Slack, Microsoft Teams, Discord, Google Chat, email, PagerDuty, Opsgenie, Jira, Linear, GitHub Issues, GitLab Issues, Azure Boards, Shortcut and ServiceNow, plus signed webhooks and ECS-format SIEM export, delivered natively to Splunk (HTTP Event Collector), Microsoft Sentinel (Logs Ingestion API through a data collection rule, with an Entra client-credentials token) and Datadog Logs (any of its six sites) as well as to any HTTP collector (docs/SIEM_DELIVERY.md). Each SIEM is judged by its own success answer -- Splunk code 0, Sentinel 204, Datadog 202 -- so a proxy or portal answering 200 is not counted as delivered. Splunk is proven against a real Splunk in Docker, the event searched back by id with its fields; Datadog and Sentinel are proven against local servers shaped like each API and against the real public endpoints refusing a bad credential in their own words, since no Datadog or Azure account was available. Delivery is judged by each provider's own answer, not by a 2xx: PagerDuty only on 202 with status success, Opsgenie only on 202, Discord only when ?wait=true returns a message id, Google Chat only when a message name comes back, and a ticket only when the tracker returns its id. GitLab Issues and Azure Boards file through the organisation's existing SCM connection rather than a second pasted token; GitLab, Azure Boards and Shortcut ticket status is read back on demand from the provider's own fields (GitLab state, Azure System.State built-in names, Shortcut's completed and started flags). Not sent without anyone pressing a button today: the unattended sender (`notify.unattended`: new critical or high findings in application code, SLA deadlines that pass, and what GitHub did with an Aegis fix pull request) has no starter since DEC-037, so a notification goes out only when a person sends one from a finding. Jira Cloud, Linear and GitHub Issues call back when a ticket changes: a signed delivery to the channel's callback URL closes the finding the moment the ticket is done, through the same status rule the on-demand sync applies. Every callback, including a refused one, is on the page with its reason. The other direction is not running: closing a finding's GitHub issue when the finding is fixed, ignored, marked a false positive or accepted (with a comment saying why, as completed for a fix and not planned otherwise) was done by the same unattended sender (`closeResolvedTickets`), so it does not happen now (DEC-037). Microsoft Teams receives an Adaptive Card 1.5, checked against Microsoft's published schema, with Open, Assign and Snooze buttons; Teams webhooks cannot submit an action from the card, so Assign and Snooze open the finding in Aegis with that form already open.
Add a channel with its credential under Notifications. Nothing is delivered until a route exists, and nothing detected before the first active rule is announced. For a tracker callback, point the provider's webhook at the URL and secret issued when the channel is created; ServiceNow and the other trackers have no callback and are read on demand only.
Implemented in: src/lib/notifications.ts, src/lib/workflow.functions.ts, src/lib/channel-config.ts, src/lib/ticket-webhooks.ts, src/lib/ticket-webhook-receiver.server.ts, src/lib/ticket-status-apply.ts, src/lib/scm-tickets.server.ts, src/lib/deliver-paging.ts, src/lib/deliver-siem.ts, src/lib/notifications-email.ts
Tested by: tests/unit/notifications.test.ts, tests/rls/workflow.test.ts, tests/unit/channel-config.test.ts, tests/unit/siem-channels.test.ts, tests/integration/siem-splunk-e2e.test.ts, tests/integration/siem-datadog-sentinel.test.ts, tests/unit/ticket-webhooks.test.ts, tests/rls/ticket-webhooks.test.ts, tests/unit/scm-tickets.test.ts, tests/integration/gitlab-issues-nas-e2e.test.ts, tests/unit/paging-channels.test.ts, tests/unit/notifications-email.test.ts, tests/integration/email-channel-smtp.test.ts
SLA targets, merge-gate policy, time-bounded exceptions requiring a second admin to approve the riskiest kinds, an optional approval inbox for ignoring findings (a member who is not an admin requests with a reason and the finding stays open until an admin approves; enforced by the database, including for false positives and VEX statements that an advisory does not apply, while an admin's rule-tuning suppression still applies to a developer's scan), a licence policy the repository scan enforces (and the merge gate can block on), and a minimum package age: a dependency version published more recently than the organisation allows becomes a supply-chain finding.
The licence policy has defaults; the package-age policy is off until an owner or admin sets a number of days on the Policies page. Approval to ignore is off until an owner or admin turns it on under Notifications > Exceptions. Snoozing a finding never needs approval: it hides the finding for a while and brings it back.
Implemented in: src/lib/policy.ts, src/lib/workflow.ts, src/lib/policies.functions.ts, src/lib/supply-chain/reputation.ts
Tested by: tests/unit/policy.test.ts, tests/unit/workflow.test.ts, tests/rls/ignore-approval.test.ts, tests/unit/ignore-approval-sql.test.ts, tests/rls/sla-anchor.test.ts, tests/rls/license-policy.test.ts, tests/rls/package-age-policy.test.ts, tests/unit/supply-chain-reputation.test.ts
MTTR, SLA, backlog and coverage metrics, with Markdown, CSV and PDF exports generated from stored scanner evidence. Reports carry the organisation's company name, footer and a handling marking stamped on every PDF page, and PDFs its uploaded logo and heading colour.
Reports are generated on demand; report schedules were removed (DEC-037) because Aegis runs no background work. PDF reports carry a detached Ed25519 signature over their exact bytes when EVIDENCE_SIGNING_KEY is set; production has one since 24 September (a PDF downloaded there verifies with `openssl pkeyutl -verify -rawin` against /api/public/evidence-signing-key, and one appended byte is refused); a deployment without one downloads unsigned and says so. PDF reports carry the organisation's uploaded logo on the first page and its colour on headings -- checked by rendering with poppler, not by reading the file -- for PNG (8-bit greyscale or RGB, not interlaced) and JPEG (greyscale or RGB); a transparent, palette, 16-bit, interlaced or CMYK image is refused at upload with what to export instead. A logo is uploaded, never fetched from an address. The markdown and CSV exports carry neither, and the CSV export is unmarked.
Implemented in: src/lib/metrics.ts, src/lib/pdf.ts, src/lib/report-pdf.functions.ts, src/lib/report-branding.ts, src/lib/report-branding.functions.ts, src/lib/pdf-image.ts, src/lib/read-all.ts, src/lib/in-chunks.ts, src/lib/page-window.ts, src/lib/evidence-signing.ts, src/lib/overview-metrics.ts, src/lib/custom-reports.ts, src/lib/custom-reports.functions.ts, src/lib/artifact-contract.ts, src/lib/artifacts.server.ts, src/lib/artifacts.functions.ts, src/components/artifact-panel.tsx, src/lib/artifact-scope.ts
Tested by: tests/unit/overview-metrics.test.ts, tests/unit/read-all.test.ts, tests/unit/in-chunks.test.ts, tests/unit/reads-respect-the-row-cap.test.ts, tests/integration/postgrest-row-cap.test.ts, tests/unit/metrics.test.ts, tests/unit/pdf.test.ts, tests/rls/reports.test.ts, tests/unit/report-branding.test.ts, tests/rls/report-branding.test.ts, tests/unit/report-logo-pdf.test.ts, tests/unit/evidence-signing.test.ts, tests/unit/page-window.test.ts, tests/integration/pagination-keyboard.test.ts, tests/unit/custom-reports.test.ts, tests/rls/custom-reports.test.ts, tests/unit/artifact-scope.test.ts
Saved searches for Splunk and KQL analytics and hunting queries for Microsoft Sentinel, over the finding events the SIEM channels deliver (item 43). Every query is generated from the exact field list `siemEvent` emits, so a dashboard can never reference a field the events do not carry -- the drift that makes a vendor content pack render empty panels. `aegis siem-apps splunk` prints a savedsearches.conf and `aegis siem-apps sentinel [--table]` prints the KQL; the committed packs live in `siem-apps/`. Two tests guard it: one runs the real `siemEvent` and `sentinelRow` and asserts every field each query names is one those events actually produce, and a sync test fails if the committed files drift from the generator. The content is a convenience, not a second source of truth -- the event is the truth, and the queries are derived from it.
The queries assume findings are being delivered to Splunk (HEC, sourcetype aegis:finding) or Sentinel (a custom table through a DCR); set that up in a SIEM channel first (docs/SIEM_DELIVERY.md). The Splunk app is a copy-in directory and the Sentinel queries are a JSON list to import; neither is published to Splunkbase or the Sentinel content hub, which is an owner step.
Implemented in: src/lib/siem-apps.ts, cli/aegis.ts, siem-apps/README.md
Tested by: tests/unit/siem-apps.test.ts, tests/unit/siem-apps-generated.test.ts
The parts that make the rest usable: limits, jobs, delivery and setup.
Dependency scanning on a machine with no network (docs/AIRGAP.md). deploy/airgap/build-bundle.sh runs where there is internet and writes a bundle: the scanner node image (docker save), the OSV database for each ecosystem asked for (downloaded by OSV-Scanner itself, so the layout is the one it reads back), the appliance Compose file and scan script, and a manifest with the build date and every file's SHA-256. On the far side the Compose service runs with network_mode none, a read-only root, no capabilities and as uid 10001, scans a mounted repository with --offline-vulnerabilities against the carried database, and writes the JSON report to disk. Proven end to end: a real bundle built from the local node image, its own Compose service run with no network against a Cargo.lock pinning regex 1.5.4 reports RUSTSEC-2022-0013, and the same service against an empty database exits 127 from the scan script -- the failure mode whose output is valid JSON with no results, which reads as clean if the exit code is ignored. The builder makes the databases world-readable because OSV-Scanner writes them owner-only and the node cannot otherwise read them (measured; removing the chmod fails the test). A connected scanner node can also use a local database: AEGIS_OSV_OFFLINE_DB switches its OSV-Scanner job to offline mode.
Covers dependency scanning only. The hosted application and its database are not part of the appliance, so results are JSON files, not findings in the web UI; the node image's other scanners (SAST, secrets, IaC) are not wired into the appliance's scan script. The database is a snapshot as old as the bundle, and refreshing it means carrying a new one across. There is no Helm chart.
Implemented in: deploy/airgap/build-bundle.sh, deploy/airgap/docker-compose.yml, deploy/airgap/scan.sh, src/lib/scanners/osv-scanner.ts, scanner-node/index.ts
Tested by: tests/integration/airgap-appliance-e2e.test.ts, tests/unit/osv-scanner.test.ts
A reproducible precision, recall and false-positive rate per scanner, produced by running Aegis's own sast, secrets and IaC engines over a committed, labelled corpus of small files -- each either vulnerable or deliberately clean -- and counting what each engine reported (`aegis benchmark`, docs/SCANNER_BENCHMARK.md). Aikido claims a 95% false-positive reduction with no method shown; the answer here is a number anybody can reproduce rather than a larger unaudited one. The scanners are executed, not described: the test runs them over the corpus and asserts the measured scores, and relabelling a clean case as vulnerable fails that test, which is the proof the engine really ran. Two guards against self-flattery: the corpus must carry clean cases that resemble sinks (a parameterised query beside the concatenated one, textContent beside innerHTML, placeholder tokens beside real ones), so the false-positive rate is actually measured, and a scanner with no clean cases or one that fires on nothing is reported as untested rather than perfect, exiting non-zero. Every number is stated to bound the 16-case corpus and say nothing about a real repository.
The corpus is small and hand-written on purpose; the figures are reproducible, not representative of a real estate. Extending the corpus and re-running the command changes the table, which is the point. The benchmark covers the three engines that run without a scanner node (sast, secrets, IaC); node-only tools are not in it.
Implemented in: src/lib/scanner-benchmark.ts, src/lib/scanner-benchmark-runners.ts, cli/aegis.ts
Tested by: tests/unit/scanner-benchmark.test.ts
A conversation over the organisation's own findings, assets and scans (Overview → Chat with Aegis). Each question is mapped to one of a fixed set of retrievals -- counts, critical findings, KEV exposure, SLA breaches, findings with no fix, findings on internet-exposed assets ("which of my criticals are internet exposed?"), exposed assets and recent scans -- run through the asker's own Supabase client so RLS applies, and the answer is composed from the rows that came back. A follow-up such as "and in production?" keeps the previous question's intent and narrows its filters. Every listed record is numbered and cited with a link to the record itself (a finding opens in Issues, an asset opens the inventory filtered to its identifier). Totals are exact counts, not the length of a page: the previous version counted the rows of a 500-row page, so on production's 7093 open findings it would have answered 500.
No language model writes or plans the answer, so it cannot invent a finding and the same question gets the same answer; a question no retrieval covers is refused with the list of supported ones. That also bounds it: it understands the fixed question shapes, not free-form analysis. A scan citation opens Scan history rather than the scan, which has no page of its own.
Implemented in: src/lib/assistant.ts, src/lib/assistant.functions.ts, src/routes/_authenticated/assistant.tsx
Tested by: tests/unit/assistant.test.ts, tests/integration/assistant-chat-postgrest.test.ts
A CLI producing SARIF, line-delimited diagnostics for editors, and CI-appropriate exit codes, with ready-made templates for GitHub Actions, GitLab, Azure Pipelines and Jenkins, plus a pre-commit hook that blocks a commit only when a staged secret works: `aegis precommit` runs gitleaks on the index and asks each provider whether the credential is accepted, using the same identity call secret liveness uses -- a live credential or one that could not be checked blocks, one the provider refused lets the commit through with a note, and the value is never printed (without the CLI, the template falls back to blocking on every gitleaks finding). Proven through the shipped template in a throwaway repository: a random GitHub token passes as revoked, the developer's own working token is blocked as live, and an AWS key id, which has no single-value validator, is blocked as unverified. Packaged as @aegis-sarl/cli: a single bundled file with a linked `aegis` binary, verified by installing the tarball into an empty directory and running it.
The package builds, packs and installs, but is not published to npm, so `bun x @aegis-sarl/cli` in the CI templates will not resolve until it is. Scanners are separate installs; whichever are present run, and whichever are not are reported as not run.
Implemented in: cli/aegis.ts, cli-package/package.json, src/lib/precommit-secrets.ts, ci-templates/pre-commit-hook.sh
Tested by: tests/integration/cli-e2e.test.ts, tests/integration/cli-package-e2e.test.ts, tests/unit/precommit-secrets.test.ts, tests/integration/precommit-live-e2e.test.ts
Fires a deliberately safe canary at a control and records what it did, so evidence is an observation rather than a claim. A WAF whose rule no longer matches still looks configured; a drill is what notices. Response times are computed from recorded instants rather than stored, so any number in a report traces back to two timestamps that each name an observer, and a phase that never happened is null rather than zero because zero would present the worst outcome as the best. A drill cannot pass without a canary, without detection, with detection preceding the canary, or with the canary left behind. Every kind carries a stated scope, safety rationale and cleanup plan, and a planned-but-never-run drill leaves its control reported as unvalidated. Signed drill statement (item 49): a trust centre that shows drills also publishes /api/public/trust-drills/<slug>, a deterministic JSON statement of the latest drill per control -- each phase's instant and observer, cleanup time, measured time to detect, and whether it passes, recomputed from the phases rather than copied from the row -- signed with the deployment's Ed25519 evidence key, with the curl and openssl commands to verify it on the trust page. The canary detail, scope and cleanup plan are never published. Proven against the dev server: openssl verifies a statement and signature fetched in separate requests and refuses one changed character; a trust centre not showing drills and a missing one give the same 404.
Implemented in: src/lib/control-drills.ts, src/lib/control-drills.functions.ts, src/routes/_authenticated/drills.tsx, src/lib/drill-attestation.ts, src/routes/api/public/trust-drills.$slug.ts, src/routes/trust.$slug.tsx
Tested by: tests/unit/control-drills.test.ts, tests/rls/control-drills.test.ts, tests/unit/drill-attestation.test.ts, tests/integration/trust-drills-e2e.test.ts
A conversation with the Aegis Security Brain over any one of three providers -- the self-hosted OmniRoute gateway, OpenAI or Anthropic -- chosen per organisation and switchable mid-thread. One adapter contract (src/lib/ai/types.ts) carries streaming, model discovery, reported capabilities, usage, cancellation and named provider errors, so the agent layer never learns which provider answered and changing the model never touches the knowledge. Saved knowledge lives in ai_knowledge_entries: organisation-shared, cited by number in every answer, deduplicated on a normalised SHA-256 of title and body, corrected by superseding rather than overwriting, and removable without breaking the citations of answers already given. A model's suggestion becomes knowledge only through ai_knowledge_proposals and a person approving it. Every turn is persisted with the provider and model that produced it, and the first question names the thread.
On demand only: nothing here is scheduled, polled, retried in the background or started without a person pressing Send (DEC-037), and closing the tab aborts the provider call. Research text, advisories and pasted documents are fenced as untrusted and stripped of the fence markers before wrapping, so a document cannot become an instruction. Tools are Aegis's, not the model's: a closed catalogue with hand-written schema checks, read tools scoped to the caller's own Supabase client (so RLS applies), an audit row for every decision with hashed arguments, and no shell, arbitrary SQL, scan start or deployment tool at all. Tools are offered only to a model that reported support for them. The provider a person picks is still inside the deployment's own egress ceiling: the resolved host is checked against AI_ALLOWED_DESTINATIONS before any credential is read, so a provider this deployment does not permit reports not configured with the list it does permit rather than being called anyway. Two things are not claimed: retrieval is a keyword match over saved facts rather than a measured vector search, and a provider whose OAuth cannot complete in this deployment reports oauth_unavailable with its supported alternative rather than a connection it does not have.
Implemented in: src/lib/ai/types.ts, src/lib/ai/registry.ts, src/lib/ai/adapters/openai-compatible.ts, src/lib/ai/adapters/anthropic.ts, src/lib/brain/knowledge.ts, src/lib/brain/tools.ts, src/lib/brain/agent.server.ts, src/lib/brain.functions.ts, src/components/brain-panel.tsx, src/routes/_authenticated/brain.tsx
Tested by: tests/unit/brain-knowledge.test.ts, tests/unit/brain-tools.test.ts, tests/unit/ai-provider-adapters.test.ts, tests/rls/ai-brain.test.ts, tests/integration/brain-postgrest.test.ts
Shares indicators between organisations under recorded consent, redacting on the way out and trusting nothing on the way in: a received signal carries its provenance and is weighed rather than believed. A partner pushes Ed25519-signed envelopes to a per-consent callback URL; the signature, not the payload, establishes who sent it, replays are refused by envelope id inside the age window, and deliveries are rate limited per partner. Consents created before transport existed still verify with their shared secret and are told that path is deprecated.
Both organisations must record a consent covering the specific signal class, with the partner's Ed25519 public key. Nothing is shared by default, nothing is shared unredacted, and nothing received is trusted on the strength of having arrived. Sending to a partner is still by hand: the outbound client needs an agreement that does not exist.
Implemented in: src/lib/federation.ts, src/lib/federation.functions.ts, src/lib/federation-receiver.server.ts, src/lib/federation-keys.server.ts
Tested by: tests/unit/federation.test.ts, tests/unit/federation-transport.test.ts, tests/rls/federation.test.ts
Item 45. Each organisation is pinned to one region (eu or us) when it is created, in a column a trigger makes immutable. A deployment serves only organisations pinned to its own region (AEGIS_DATA_REGION): the session guard every organisation check passes through refuses another region's organisation, the scanner node job route refuses a node whose organisation is pinned elsewhere, and AI destinations whose declared region is not the organisation's are dropped from its policy. Settings shows the region read-only.
There is one deployment, in the US, and no EU region; standing one up is new infrastructure and an owner decision (docs/DATA_RESIDENCY.md). The hosted database is in AWS us-east-1 (its host's address, checked against AWS's published ranges), so the column defaults to us and the deployment sets AEGIS_DATA_REGION=us; a test fails if the code's default and the migration's differ. The migration was applied to the hosted database on 5 October 2026 on the owner's instruction, and every existing organisation reads us; organisation creation and the settings page still tolerate a database without the column. The one AI destination is declared us, matching the pin. Cloudflare Workers run at the nearest edge, so request processing is not region-pinned, and provider logs and email delivery are outside the pin. Proven against a real Postgres (default, CHECK and the update-refusing trigger) and through the real session guard.
Implemented in: src/lib/data-region.ts, src/lib/session-guard.ts, src/lib/ai-governance.ts, src/routes/api/public/nodes/jobs.ts
Tested by: tests/unit/data-region.test.ts, tests/rls/data-region.test.ts, tests/rls/ai-policy.test.ts
A sample organisation with deterministic example findings and assets, so the product can be explored without connecting a repository. Every record is flagged in the database and labelled in its title, so it stays identifiable in exports and API responses.
Only available in an organisation created as a demo. Seeding a real organisation is refused, because fabricated findings alongside genuine ones would be indistinguishable until somebody chased one down.
Implemented in: src/lib/demo.ts, src/lib/demo.functions.ts
Tested by: tests/unit/demo.test.ts
A declared environment schema with startup validation, a migration runner that applies each file once under an advisory lock, and liveness, readiness and version endpoints. The packaged build is verified by building it, serving it, and driving it in a real browser rather than only compiling it.
The deployment preset is cloudflare-module. The production-build test runs the same application under the node-server preset instead, because workerd accepts connections but never responds in some sandboxes — confirmed with a three-line hello-world Worker — and an untestable build is one nobody checks.
Implemented in: src/lib/environment.ts, src/lib/health.ts, src/lib/build-info.ts, src/routes/api/public/health.ts, src/routes/api/public/version.ts
Tested by: tests/unit/environment.test.ts, tests/unit/health.test.ts, tests/integration/migrate-e2e.test.ts, tests/integration/production-build-e2e.test.ts
Combines rules, dataflow, runtime and model signals without letting any of them rule. Weights come from measured precision and recall on a labelled corpus built from repository fixtures rather than customer data, keyed per detector and version, because a rule set change is exactly what invalidates a measurement. A detector that never fired has undefined precision rather than perfect precision, and a corpus too small to calibrate is reported as uncalibrated instead of as a score. Where reproducible detectors disagree the disagreement is the output and goes to a human. A model agreeing raises confidence within a cap, a model disagreeing is recorded and subtracts nothing, and a model alone can raise something for review but never auto-triage it.
Implemented in: src/lib/ensemble.ts, src/lib/ensemble.functions.ts, src/routes/_authenticated/ensemble.tsx, src/lib/finding-correlation.ts, src/lib/finding-noise.ts, src/lib/scanners/precision.ts, src/lib/finding-trend.ts, src/lib/issue-summary.ts, src/lib/queue-view.ts, src/lib/queue-cards.ts, src/lib/queue-cards.functions.ts
Tested by: tests/unit/ensemble.test.ts, tests/rls/ensemble.test.ts, tests/unit/finding-correlation.test.ts, tests/unit/finding-noise.test.ts, tests/unit/scanner-precision.test.ts, tests/unit/finding-trend.test.ts, tests/unit/issue-summary.test.ts, tests/unit/queue-view.test.ts, tests/unit/queue-cards.test.ts
Every claim the product makes is linked to the observations behind it, with the source, its version, the commit or digest examined, and when it was seen. Freshness is the worst of the supporting observations rather than the best, so a claim resting on one current reading and one stale one reports as stale. Disagreement between sources is surfaced rather than resolved into a single verdict. Investigation bundles carry provenance and never raw scanner output, because that output routinely contains the secret that caused the finding. A wrong observation is corrected rather than deleted: any member proposes a retraction with a reason, an administrator other than the proposer decides it, and the claims that rested on it are marked as standing on withdrawn support instead of silently changing.
Only one kind of claim has a creator. The owner-started whole scan (`recordScanClaims` in `src/lib/whole-scan/scan.server.ts`) writes one `finding` claim per new or changed finding, linked by `supports` to one observation of the scan; a rescan that changes nothing writes no evidence row (tests/unit/evidence-claims-from-scan.test.ts). No other claim kind (control, metric, parity, asset_state, policy_decision) has a writer, no production path writes a `contradicts` link, and the `supersede_evidence_claim` SQL function has no caller (the scan supersedes in a batch itself). The tenant restore (`importTenant`) still copies rows an earlier export held. So disagreement between sources is shown only by rows the tests insert, not by rows Aegis produced. Known gaps: F1, a claim chunk that failed after an earlier one succeeded left claims with no link (FIXED: any claim or link chunk failure now removes every claim the scan inserted, and a test refuses the second chunk); F2, a finding that closes keeps a current claim, so the ledger still asserts it; F3, claims use the pre-tuning severity (`baseSeverity`), so a finding the organisation lowered or suppressed is still claimed at its original severity. Verified on the D1 stack only, not against a real PostgREST (docs/AEGIS_INTEGRATION_STATUS.md).
Implemented in: src/lib/evidence-graph.ts, src/lib/evidence-graph.functions.ts, src/lib/correction-notice.ts, src/components/evidence-corrections-panel.tsx, src/routes/_authenticated/evidence.tsx, src/lib/whole-scan/scan.server.ts
Tested by: tests/unit/evidence-graph.test.ts, tests/unit/evidence-claims-from-scan.test.ts, tests/unit/correction-notice.test.ts, tests/rls/evidence-graph.test.ts, tests/rls/evidence-retractions.test.ts
A dashboard checklist showing the shortest path from an empty account to a useful one, with each step explaining what it gets you rather than only what to click. State is derived from what exists rather than from a stored flag, so disconnecting an integration makes its step incomplete again, and steps that do not apply say why. Disappears once setup is done. Free tier and measured first run (item 50): /get-started takes a public GitHub repository as owner/name or a github.com URL, confirms it is public with an anonymous read (anything private or missing is refused, never read with another credential), starts the first scan at once, and records each step on the organisation from server timestamps, so time to first finding is a stored measurement rather than a claim. The result is one of a closed set (findings, clean, nothing scannable, scan failed, not run), and a scan that did not finish reading is never reported clean. The free plan's limits are the existing plan and quota numbers (PLANS.free and org_quotas), shown on the page and enforced on this path. Measured in a real browser against the local stack on appsecco/dvna, three fresh sign-ups: connect to first finding 3.8s, 2.9s and 2.7s, 46 findings each, against a two-minute target asserted by the test. The Setup Hub (/setup) shows the same evidence as one page in five areas, each item stating what is configured, what has been verified, what failed verification and what to do next, with every state derived on the server from what exists rather than from a stored flag.
The free-plan limits are enforced on the first-run path; repositories connected through the GitHub App or token flows are counted but those paths do not yet refuse past the limit. Public repositories are read anonymously, so GitHub's unauthenticated rate limit (60 requests an hour per server address) applies and a refusal says so. The timing was measured against a development build on a shared machine, and has not been measured against production.
Implemented in: src/lib/onboarding.ts, src/lib/onboarding.functions.ts, src/lib/setup-hub.ts, src/lib/setup-hub.functions.ts, src/routes/_authenticated/setup.tsx, src/lib/first-run-scan.server.ts, src/lib/scan-requested.server.ts
Tested by: tests/unit/onboarding.test.ts, tests/integration/onboarding-e2e.test.ts, tests/unit/onboarding-first-run.test.ts, tests/unit/scan-requested-runs-whole-scan.test.ts, tests/integration/onboarding-first-run-e2e.test.ts, tests/unit/setup-hub.test.ts
Triage outcomes record what a decision says about the detector, and the scan-history page derives precision per scanner and rule when at least ten findings are labelled. `aegis benchmark --record` calibrates the in-process SAST engine from its committed corpus, rule-tuning proposals only populate a form, AI agreement compares an AI verdict with a later human outcome, and custom SAST rules remain in a human-controlled draft, shadow, active or retired lifecycle. A signed-in organisation operator can manually record that another detector missed a finding, with a reason, through the finding action. The D1 path attributes that one claim to the person, refuses duplicate claims for the same detector and finding, and refuses a claim against the detector that raised the finding. Under DEC-037 that manual claim is the only known-miss input: scans do not record per-file reads, derive misses, or produce daily learning reports in the background.
Partial by design: outcomes, metrics, SAST calibration, tuning proposals, AI agreement, the rule lifecycle and manual missed-finding claims are built. Automated known-miss derivation and daily learning reports were removed under DEC-037 because they needed per-file database writes and scheduled background work. A manual claim is evidence a person supplied, not a recall figure. Precision is meaningful only where people classify triage decisions, and AI agreement needs ten later human outcomes.
Implemented in: src/lib/outcomes.ts, src/lib/metrics.ts, src/lib/workflow.functions.ts, src/lib/scan-profiles.functions.ts, src/lib/scanners/sast-scan.ts, src/lib/benchmark-corpus.ts, src/lib/benchmark-record.ts, src/lib/coverage-matrix.ts, src/lib/coverage-doc.ts, src/lib/vuln-classes.ts, src/routes/api/public/v1/benchmark-runs.ts, src/lib/tuning-suggestions.ts, src/lib/ai-agreement.ts, src/lib/learning.functions.ts, src/lib/scanners/custom-sast.ts, src/components/custom-sast-rules-panel.tsx
Tested by: tests/unit/outcomes.test.ts, tests/unit/detector-precision.test.ts, tests/unit/event-kind-spelling.test.ts, tests/unit/sast-ruleset-version.test.ts, tests/rls/learning-outcomes.test.ts, tests/integration/detector-precision-postgrest.test.ts, tests/unit/coverage-matrix.test.ts, tests/unit/benchmark-corpus.test.ts, tests/unit/benchmark-record.test.ts, tests/integration/benchmark-calibration-e2e.test.ts, tests/unit/tuning-suggestions.test.ts, tests/unit/ai-agreement.test.ts, tests/rls/learning-misses.test.ts, tests/integration/learning-phase3-postgrest.test.ts, tests/unit/rule-lifecycle.test.ts, tests/rls/rule-lifecycle.test.ts
Connect Anthropic or OpenAI by OAuth sign-in or a pasted API key, and choose which model powers triage and fixes. The router prefers a per-org API key, then the Anthropic sign-in, then a deployment-wide AI_API_KEY. The Claude sign-in is used only for actions a signed-in person starts in the app (DEC-038); background work never routes onto it and uses an API key or reports that no model is available.
The API key is verified against the provider before it is stored, so a saved connection is one that works. The chosen model is validated against a catalog on the way in, so a stored preference can only be a model the provider serves. OAuth borrows the provider CLI's public client id by default -- the consent screen names that CLI -- and a deployment that registers its own OAuth app sets AEGIS_<PROVIDER>_CLIENT_ID so the screen names it instead.
Implemented in: src/lib/model-call.server.ts, src/lib/model-api-key.server.ts, src/lib/model-choice.server.ts, src/lib/provider-oauth.ts, src/lib/provider-oauth.server.ts, src/lib/provider-oauth.functions.ts
Tested by: tests/unit/model-api-key-routing.test.ts, tests/unit/model-choice.test.ts, tests/unit/provider-oauth.test.ts, tests/unit/provider-oauth-refresh.test.ts, tests/unit/provider-oauth-pending-store.test.ts
Detects sub-projects from their manifests and routes a finding to the team that owns the directory it is in, so a repository holding forty services does not send every finding to whoever is listed first.
Add a sub-project prefix to a notification rule; rules without one are unaffected and keep matching exactly as before. A finding with no file path never matches a sub-project rule, because a cloud misconfiguration belongs to no directory and routing it to the first-named service would be a guess.
Implemented in: src/lib/monorepo.ts, src/lib/workflow.ts
Tested by: tests/unit/monorepo.test.ts, tests/unit/workflow.test.ts
Install Aegis as an application on GitHub, Bitbucket, Slack and Jira, or authorise it where a provider has no installable app (GitLab, Google Workspace). Full operational access: it reads code and configuration and writes back -- branches, pull requests, workflow files, code scanning alerts, tickets and their transitions, and messages. Nothing is pasted, tokens are exchanged server-side with PKCE, and they refresh before they expire.
Register an application with each provider and set its client id, secret and (where it installs) its public app slug. A connector without credentials is shown as unavailable with the variables named, and prints the exact redirect URI to register.
Implemented in: src/lib/connectors.ts, src/lib/integration-auth.ts, src/lib/connectors.server.ts, src/lib/connectors.functions.ts
Tested by: tests/unit/connectors.test.ts, tests/unit/connector-flows.test.ts, tests/unit/integration-auth.test.ts, tests/unit/connector-grants.test.ts, tests/unit/connectors-server.test.ts, tests/unit/connector-callback.test.ts, tests/unit/channel-connector-credentials.test.ts
Extensions declare a kind, an API version, capabilities and resource limits, and the host grants no more than it was asked for. A plugin cannot choose its tenant, set severity or risk score, or close and suppress findings: those fields are refused by name rather than stripped, because a silently sanitised field looks to the author like it worked and to an attacker like a control worth probing. Capabilities are checked at the point of use, not only at install, since an install-time check stops applying the moment policy changes underneath a loaded plugin. Output is bounded by count and bytes, a flood is refused entirely rather than truncated, and a hanging plugin is stopped at its budget. An admitted plugin runs as a plugin-run scan on the customer's scanner node inside a bubblewrap sandbox: own user, PID, network, IPC and UTS namespaces, read-only runtime, only its directory writable, empty environment, killed at its deadline. Measured from inside: the host filesystem is absent, sockets are refused, a /tmp write never reaches the host. The node submits the plugin's raw output and the sandbox's refusals; the control plane judges the output against the SDK contract again and refuses any run that reports no sandbox.
Plugin execution needs a registered scanner node with bubblewrap installed (the node image ships it). Not enforced: a per-host network allow-list, since the sandbox has no network at all, so network:outbound stays refused at admission; memory limits; anything a kernel escape would reach.
Implemented in: src/lib/plugin-sdk.ts, src/lib/plugin-registry.functions.ts, src/lib/plugin-run.ts, src/routes/_authenticated/plugins.tsx
Tested by: tests/unit/plugin-sdk.test.ts, tests/unit/plugin-run.test.ts, tests/integration/plugin-sandbox.test.ts
Four plans with derived feature entitlements and usage limits, a grace period before a failed payment changes anything, and a downgrade preview that states what would stop working before the change is made. A codified list of capabilities no plan may withhold — seeing your own findings, exporting your data, receiving a critical alert, revoking a credential — is enforced by a test rather than by convention.
Stripe (item 47): an owner or admin starts a Checkout Session for Team or Business (seats as quantity, the organisation as client_reference_id) or opens the Billing Portal; the webhook verifies the signature over the raw body before parsing, ignores a replayed event id, maps the Stripe price to a plan and refuses an unknown price rather than granting anything, and a cancelled subscription returns the organisation to free. No Stripe account is connected and no keys exist here, so nothing has been sold: without STRIPE_SECRET_KEY every entry point says it is not configured and the upgrade buttons say so, and every organisation stays on the free plan. Proven against a real Postgres (upgrade, replay, bad signature, unknown price, downgrade, and developer, viewer and security admin refused before Stripe is contacted) and against Stripe's real 401; not against a Stripe test-mode account. Setup is docs/BILLING.md.
Implemented in: src/lib/entitlements.ts, src/lib/entitlements.functions.ts, src/lib/stripe.server.ts, src/lib/billing-stripe.server.ts, src/lib/billing.functions.ts, src/components/billing-panel.tsx
Tested by: tests/unit/entitlements.test.ts, tests/rls/subscriptions.test.ts, tests/unit/stripe-checkout.test.ts, tests/integration/stripe-checkout.test.ts, tests/rls/billing-stripe-webhook.test.ts
A complete export of an organisation's findings, assets, scans, exceptions, policies, audit log and evidence graph, as JSON with a SHA-256 manifest per section so the file can be checked for damage. Available on every plan including a lapsed one, because holding an audit history against a billing status is what the never-gated list forbids. Credentials are withheld and the manifest says so, since an export is routinely written to a laptop or a ticket attachment. The same file restores into an organisation the caller administers, behind a typed confirmation of the destination: the manifest is verified first, every row gets a new identity, references outside the export are left empty and counted, and all nine sections are written back including exceptions and policies.
Implemented in: src/lib/tenant-export.ts, src/lib/tenant-export.functions.ts, src/components/export-panel.tsx, src/components/import-panel.tsx
Tested by: tests/unit/tenant-export.test.ts, tests/unit/export-readers.test.ts, tests/rls/tenant-export.test.ts, tests/rls/tenant-import-roundtrip.test.ts
One page ranking every organisation a person can act for by what needs attention first, so a provider looking after ten customers does not have to open ten dashboards to find the one that needs them.
Reads each organisation separately and authorises each one through assertOrgMemberOrDelegate, the same guard fleetHealth uses: is_org_member is untouched, because every RLS policy calls it and widening it would change every table at once. The organisation list comes from the caller's own memberships and live delegations and never from input, so it cannot be used to probe which organisation ids exist. A customer whose findings could not be read is ranked above every known problem and shows why, rather than showing zeroes; there is deliberately no portfolio-wide severity total, because ten criticals at one customer and ten across nine others are different situations that one number cannot distinguish.
Implemented in: src/lib/portfolio.ts, src/lib/portfolio.functions.ts
Tested by: tests/unit/portfolio.test.ts
An unauthenticated page describing every capability, generated from the same registry the application reads rather than written by hand. Lists what is not built before what is, carries each capability's stated limit verbatim, and publishes the modules and tests behind every claim so a reader can check rather than believe.
Implemented in: src/lib/docs.ts, src/routes/docs.tsx
Tested by: tests/unit/docs.test.ts, tests/integration/browser-hydration-e2e.test.ts
A documented, scope-authenticated REST API with an OpenAPI 3.1 description, per-token rate limiting and RFC 9457 problem responses. The same API is exposed as MCP tools (`@aegis-sarl/mcp`) for Claude Code, Cursor and Copilot, read-only unless an operator enables scan requests, with the token taken from the environment and never from a tool argument.
Implemented in: src/routes/api/public/v1/findings.ts, src/routes/api/public/v1/openapi.ts, src/lib/asset-import.ts, mcp-server/server.ts, mcp-server/index.ts, mcp-package/package.json
Tested by: tests/unit/openapi.test.ts, tests/rls/public-api.test.ts, tests/unit/asset-import.test.ts, tests/integration/mcp-server-e2e.test.ts, tests/integration/mcp-against-aegis-e2e.test.ts, tests/integration/mcp-package-e2e.test.ts
Scans applications that never face the internet, through a node running inside the customer network that dials out and is never dialled into, with an explicit per-node allowlist of what it may reach.
Run a scanner node and set AEGIS_ALLOWED_TARGETS to the internal hosts it may reach. A scan of a private address is admitted only while a compatible node has an operator-started direct session and free capacity; Aegis refuses before creating a scan row otherwise. The node fetches only the one scan admitted to its session. With no connected node the hosted runtime's refusal applies unchanged: a service that fetches http://10.0.0.5/ on request is an SSRF proxy with a login page. Reachability is not authorisation: an internal host must still be covered by a verified domain and an unexpired in-scope approval. A target outside the node's own allowlist is refused by the node rather than silently skipped.
Implemented in: src/lib/broker.ts, src/lib/nodes.functions.ts
Tested by: tests/unit/broker.test.ts
Records a fix as a chain of separate claims rather than a status, so a change that got as far as a built artefact reports that instead of being rounded up to fixed. A contract cannot be verified until runtime verification passed, enforced by a database function so the word means the same thing whichever caller writes it. The rollback plan and the previous known-good reference are captured when the contract is created, because a plan written during an incident is written by somebody who may no longer have the digest. Diffs that close a finding by adding a suppression or editing a scanner ignore file are reported as symptom fixes, and a suppression alongside real code changes is reported as suspected rather than condemned. Unmeasured quantities are null rather than zero, and a repository with no tests reports unknown regression risk rather than low.
Implemented in: src/lib/fix-contract.ts, src/lib/fix-contract.functions.ts, src/routes/_authenticated/fixes.tsx
Tested by: tests/unit/fix-contract.test.ts, tests/rls/fix-contract.test.ts
Ranks units of work rather than findings: one dependency upgrade that closes twelve findings is one item, ordered by weighted risk removed per engineering hour. Business weightings are inputs a team can disagree with rather than constants, and every recommendation carries the assumptions behind its estimate, so a guess is never presented as a measurement. Accepted risk and findings with no available fix are excluded from the plan and reported separately, so what the plan leaves out stays visible. A simulation shows which attack paths a remediation would close before it is done, including the case where it removes real risk and closes nothing.
Implemented in: src/lib/risk-optimizer.ts, src/lib/risk-optimizer.functions.ts, src/routes/_authenticated/plan.tsx
Tested by: tests/unit/risk-optimizer.test.ts, tests/rls/risk-optimizer.test.ts
A profile (repository, web surface, or both) queues the scans that apply to a chosen repository and verified host as ordinary jobs, and records a reason for every step it did not queue: no verified domain, no online node advertising the scanner, or a node gate that refused. Node steps go through the same function and checks as the per-scanner button; hosted steps use the idempotency keys the daily triggers used (those triggers were removed, DEC-037), so a profile pressed while the same job is pending joins it instead of doubling it. Each web-surface and intelligence job re-reads domain verification when it runs. The Engines table lists every hosted engine and every node scanner with where it runs, whether it is installed, the version that last ran, its last success and last failure with the error, and what it needs, aggregated in the database from the scans table.
Implemented in: src/lib/scan-profiles.ts, src/lib/scan-profiles.server.ts, src/lib/scan-profiles.functions.ts
Tested by: tests/unit/scan-profiles.test.ts, tests/integration/scan-profiles-persist.test.ts
A node run on customer infrastructure that executes heavyweight tools and uploads raw output. The server parses it and decides severity, so a node cannot inject findings or dictate their severity.
Register a node and run it from a clone with `bun run scanner-node/index.ts`, where the tools are installed. Capabilities are fixed at registration, so a node cannot claim work it was not approved for. It refuses to start without AEGIS_URL and AEGIS_NODE_TOKEN, announces which scanners it actually found, and reports an unreachable control plane rather than polling silently.
Implemented in: src/lib/nodes.server.ts, src/routes/api/public/nodes/jobs.ts, scanner-node/index.ts, src/lib/node-fleet.ts, src/lib/node-fleet.functions.ts
Tested by: tests/rls/scanner-nodes.test.ts, tests/integration/scanner-node-e2e.test.ts, tests/integration/self-hosted-agents-e2e.test.ts, tests/unit/node-fleet.test.ts, tests/rls/node-tool-versions.test.ts
One page answering what is connected and what is broken, across source control, cloud, registries, notifications, compliance, runtime and model providers. Every connection reports in the same vocabulary: connected, needs attention with a reason, not connected, or unavailable with the missing variables named.
Implemented in: src/lib/connections.ts, src/lib/connections.functions.ts
Tested by: tests/unit/connections.test.ts, tests/unit/connections-status.test.ts
Lists every organisation a person can act for, by membership or by live delegation, and switches between them: what a managed service provider needs to reach the second of their ten customers.
The chosen organisation is a display preference stored client-side, and the server checks membership on every request regardless of what is stored: a request for an organisation the caller does not belong to returns no row and falls back to their own, which refuses without confirming whether that organisation exists. Delegated organisations are shown as delegated and drop off the list when the grant expires.
Implemented in: src/lib/org.functions.ts, src/lib/delegations.functions.ts
Tested by: tests/rls/org-switching.test.ts, tests/unit/org-guard-delegation.test.ts