Draft CodeGhoul isn't live yet, so this page describes the service as it is being built. Text in [brackets] waits for a decision. Don't publish the page before those are made.
Where your code goes.
To review a pull request, Maeve has to read it. This page says what she reads, what leaves your repository and where it goes, what stays on our servers, and who can reach it. For personal data, the data processing agreement sets our obligations.
The short version
- She works as a GitHub App, on the repositories you choose, with the permissions listed below.
- Every job gets its own GitHub token, which reaches only the repository under review.
- Your reviews run in a worker of your own, with its own storage. No other customer's worker can read it.
- To review a change, she sends a model provider the diff and the code around it. The provider's own terms govern what it keeps.
- Secrets she detects are never posted or stored in full.
What happens to a pull request
- GitHub tells us. It sends a signed event when a pull request opens or gets a push. Our event router checks the signature and passes the event to your worker. The router writes down only which installation belongs to which worker: event content and tokens pass through its memory without being written or logged.
- Your worker gets a token. For each job the router issues a GitHub token that reaches only the repository under review, and keeps no copy. Your worker sends it to GitHub in a request header, never in a config file or on a command line.
- She fetches two commits. The base and the head of the pull request, each with its files and no history.
- She reads your rules from the base. Settings and house rules in
.codeghoul/come from the pull request's base, so a pull request can't change the rules it's reviewed under. - Scanners check the changed files. Secret, dependency and pattern scanners run in a sandbox with no network, reading only the changed files. Dependency advisories come from a copy of the vulnerability database kept on our servers, so no code goes to a scanning service.
- She asks the model. The prompt holds the diff and the code the review reads around it, your house rules and the dismissals that apply to those paths, the scanners' findings, and the text of issues the pull request links. A second review also sees the first one's findings, a security pass your CI's scan results, and a walkthrough the pull request's title and description.
- The model answers. A pass that runs an agent works in a sandbox: it reads only a snapshot of the head commit and the system's own libraries, writes only its own scratch folder, reaches nothing but the model's endpoint and never runs as root. Its snapshot and scratch folder are removed when it ends. Every other pass is a prompt and an answer, with no tools: no files, no shell, no web.
- She posts the review. The review, its inline comments and the check run go to GitHub from her bot account. Everyone who can see the pull request can read them; on a public repository, that's everyone.
What she can do on GitHub
She asks for these repository permissions, and GitHub holds her to them. Her reviews, comments and check runs come from her bot account, never from a person's.
| Permission | Access | What for |
|---|---|---|
| Pull requests | write | read the pull request and its diff; post the review and its inline comments; if you turn on auto-approve, approve small, low-risk changes and withdraw her own approvals, never a person's |
| Checks | write | complete her check runs and record overrides |
| Contents | read | fetch the base and head commits; read .codeghoul/ at the base |
| Actions | read | read a head's CI scan results for the security pass |
| Issues | read | receive the comments that carry commands |
| Metadata | read | look up repositories and collaborators' roles |
GitHub sends her events for pull requests, the comments on them, and pushes. She acts on pushes only to your default branch, to keep her code index current.
Model providers
Review prompts go to third-party model providers, over HTTPS. CodeGhoul makes no promise about what a provider keeps of a prompt or trains on: the provider's own terms govern that. The subprocessor list names each provider and where it processes prompts.
Some passes run through a model provider's command-line tool on our servers. Such a tool's own session store is turned off, so it keeps no copy of the prompt or the answer. [Make this true in the service before publishing.]
Your own model. [When it's available:] with your own model key or subscription, prompts go out under your account, so your agreement with that provider governs them. If your code mustn't leave your network at all, a self-hosted worker is something we're exploring.
What we keep
Text from your repository means code and diffs, file paths, commit messages, the titles, descriptions and comments of pull requests, and what a model or a scanner wrote about them. Repository names, numbers, commit hashes, logins and IDs don't count.
Everything below sits on your worker's own storage unless its row says otherwise. The servers are in the European Union. The hosting provider is on the subprocessor list.
| What | Text from your repository | How long |
|---|---|---|
| A Git copy of each repository she reviews, holding the commits its reviews fetched | Yes | Between reviews, until 30 days after you remove the App |
| A Git copy of your default branch, updated on pushes, to look up callers | Yes | While the App is installed, then 30 days |
| Code indexes: symbols, paths and callers | Yes | The 8 most recently used commits of each repository |
| Review reports: the findings, the review as posted, scanner evidence with secrets masked | Yes | 12 months |
| Feedback: dismissals, reactions to her comments and resolved threads, with the file, the finding and the reason given | Yes | While the App is installed, then 30 days |
| Job records: which pull request, commit and pass, its state and times | Only in error notes, which can quote a file path or a finding's title | 90 days |
| Cost records: credits charged per run and which model answered | Only in notes on why another model answered, which can quote a file path | As Czech accounting and tax law requires, up to 10 years |
| Logs | Can quote file paths and finding titles | 30 days |
| Agent pass records, on the server that ran the pass: models, tokens, cost and hashes of the prompts | No | 90 days |
| Working folders: snapshots and scanner folders | Yes | Removed when each step ends. A worker stopped mid-step can leave one behind. |
| Plan and billing records, kept apart from your worker: your plan and seats, which account holds each installation, who opened each pull request | No | Plan and billing: as Czech accounting and tax law requires, up to 10 years. Who opened each pull request: 12 months |
| The event router's list of which installation goes to which worker | No | Until you remove the App |
Who can reach it
- Each customer's worker keeps its files on a storage volume of its own, readable only by that worker. Workers on one server share the program they run, the App and the event router, and nothing they could read of each other.
- No worker holds the App's private key or webhook secret; a worker refuses to start with one. The event router issues each job's token, and only for an installation that belongs to the worker asking.
- The router signs every event it forwards with the receiving worker's own secret, and every other worker refuses it.
- Calls to GitHub and to model providers use HTTPS. Storage is encrypted at rest where the hosting provider offers it.
- Manufactoria staff open a worker's storage only when you ask, for example on a support request, and each access is logged. [Make this true in the service before publishing, and say who may open it during a security incident.]
Improving the reviews
A weekly quality check replays feedback through the review models: for each finding a team kept or dismissed, it reviews that pull request's base and head commits again and scores the answer. It runs only on repositories that opt in. Ask at support@codeghoul.ai to opt a repository in or out.
Removing access
Remove the App from a repository, or from your whole organization, in GitHub's settings at any time. GitHub stops sending her events, and the event router forgets the installation. Within 30 days we delete the Git copies, code indexes and feedback that worker holds for your repositories; the other records follow the periods in the table. To have them deleted sooner, write to support@codeghoul.ai.
Report a vulnerability
Write to security@codeghoul.ai with what you found and how to reproduce it. The same contact is in security.txt. We reply within 3 working days. Give us 90 days to fix a problem before you publish it, don't access or change other people's data, and don't disrupt the service. We won't take legal action against research done in good faith under these rules. [Lawyer to confirm this promise.]