Skip to content

Security: dimipaun/fugaro

SECURITY.md

Security policy

In short

  • Report a vulnerability through GitHub's private vulnerability reporting, never in a public issue (Reporting a vulnerability).
  • The design assumes you trust the repository and the source of the task: anyone who can push to it, launch a run, or is listed in followup.trusted can steer an agent that holds the credentials below, and this is not a sandbox for code you would not run on a developer's laptop (The assumption).
  • What limits the blast radius today: one container per run, per-repository identities, and narrow git credentials — a project-wide credential is not narrow (What limits the blast radius today).
  • What is not on by default: the budget gateway, so with no budget: block the real model key sits in the agent's environment, and Vertex has no dollar cap in any mode; nor the credentials service's switch, which is per repository — fugaro update deploys the service on every installation, and a repository's jobs keep their model credentials until its own root has been re-applied with the switch on (What is not on by default, The credentials service).
  • What no boundary stops: network egress is unrestricted, the agent shares the container with the runner and can read its /proc, and the caps are the gateway's — set a credit limit on every key you give Fugaro (Known limits, Money).
  • What a proxied Bitbucket run reaches, and what it does not: the proxy narrows the run to one repository and the run's own branch and pull requests, the agent can act as the run at it, the flip has taken the token's mount and the accessor away, and the build account keeps its own copy until S4 (The Bitbucket git proxy).
  • Out of scope: an agent doing harmful things inside its own container with the credentials that job's service account is allowed to hold (Scope).

Reporting a vulnerability

Please do not open a public issue for a vulnerability. Use GitHub's private vulnerability reporting: open the repository's Security tab, then Report a vulnerability. Include what you found, how to reproduce it, and the version (fugaro version) or commit.

We will acknowledge a report as soon as we can, work on a fix with you privately, and credit you in the advisory if you wish. This is a small project maintained by volunteers, so we cannot promise a fixed response time.

Supported versions

The current minor release and the one before it are supported. Fugaro is pre-1.0; fixes land on main and ship in the next release.

Trust model and known limits

Fugaro runs a coding agent with its permission prompts turned off, in a fresh cloud container per run, and ends every run with a pull request. This section says what that design protects, what it does not, and what you should do about the gaps. It describes the code as it is; the details, with file references, are in docs/design/v1.md §6.

Project scope is the default for a name that has one

fugaro secrets set NAME stores the value once for the whole installation — in the project's own Secret Manager, not a repository's — unless --repo is passed, which stores one repository's own copy instead. --project-wide is still accepted as a synonym of the default, so scripts written before the change keep working. This reverses the earlier rule, under which nothing was shared until the owner allow-listed a repository: storing at project scope now is the opt-in, and that is the point of the change — the default is the one an operator can see, rather than the one they have to remember. A name that has no project-wide meaning (a workflow's own secrets: entry that no workflow_secrets entry in the operator's local config covers) is disabled for now and ignored, as a repository's own image is (D2313) — the entry stays valid, a shared job mounts only the project's secrets, and fugaro secrets set NAME --repo answers a notice instead of storing one, so a workflow secret several repositories need goes to the project through a workflow_secrets entry. The default Claude account's claude-oauth-token keeps the repository scope it had. bitbucket-token is the other exception, and it is not a narrow case of the default but the absence of one: its default is a repository access token, issued for one repository and usable for no other (Bitbucket's own scoping), so fugaro secrets set bitbucket-token stores the repository's own copy — the project-wide store is refused for it unless the operator's local config allow-lists repositories in project_secrets.bitbucket-token, and an operator who holds one workspace or project access token may instead mount it in many repositories at once through the allow-list, which the owner ruled on 2026-10-27 they may opt in to (see "Narrow git credentials" below).

The reach is every enrolled repository. Until a routing policy is published, that means every repository the local config knows; once one is published, every repository that policy admits. Either way this is the whole installation, not the repository whose job holds the value.

An allow_data_to entry may name a workspace, not only one repository. project_secrets.<name>.allow_data_to accepts * inside a segment — myworkspace/*, myworkspace/api-* — never across /, and the owner segment must be literal, so a bare * and */* are refused and no entry can mean every workspace at once (owner ruling, 2026-10-27). A wildcard means every current AND future repository it matches. A repository onboarded into that workspace later mounts this value on its next fugaro setup, with no further edit to the list, and nobody is asked again — that is the point of writing one entry instead of fifty, and it is the risk. Store a credential that way only when its reach really is the whole workspace, keep it at the minimum scopes the runs need (a Bitbucket workspace token with repository read/write and pull request read/write, no more), and prefer naming repositories one by one when only some of them need it. claude_accounts.<name>.allow_data_to takes exact names only, and so does a provider's allow_data_to with one widening that predates this rule and is wider than anything here: a provider key whose list is absent, or written as the literal ["*"], is open to every repository of the installation — every one of them may mount that key and send its code to that provider (the owner's ruling of 2026-10-13, docs/design/project-secrets.md §3a) — which fugaro validate and fugaro doctor name so it is not reached by accident. One entry is the exception even to the wildcard: project_secrets.claude-oauth-token is also the default account's list in the published policy, and that list is exact, so fugaro project policy publish refuses a wildcard there rather than widening what a shared job's runs may use.

Inside a shared job there is no IAM boundary between repositories — the profile is the boundary. Today each repository still has its own job and its own service account, and a project secret is mounted on that job only for a name the repository may use (a reserved secret; a model provider's key per its own allow_data_to; a named Claude account's token per its own allow_data_to). Once shared project jobs exist, one job carries runs for several repositories: the boundary between them is then the profile the run is admitted under, not an IAM grant, and a project secret in that job's environment is readable by every one of those runs. On a repository switched on to the credentials service — its own root re-applied with the switch on — a per-repository job's model credentials are not in the job at all — its accessors and its mounts are dropped together, and the service attaches the credential to the call (see "The credentials service" below). That reaches a shared project job too, and it is the profile that bounds it there (B5.1, B5.2): the service serves such a caller for the repositories its profile admits, so a cascade workflow can be served on one — while no installation admits the class yet, so a shared job's run is refused at the service's door until the deployment that renders the class's table lands (see "The credentials service" below). Either way this narrows the model credentials alone: the git credential, the workflow's own secrets and everything else this section names are unchanged.

A repository's own copy of the same name always wins over the project copy, until the copy's last enabled version is disabled — so passing --repo is how a platform credential's value stays this repository's; a secret a workflow declares has no repository scope at all for now (D2313), and --repo for one answers a notice.

The data-policy gate is unchanged. A model provider's allow_data_to still decides, at runtime and before any call, which repositories' code the gateway may send to that provider; a project-scope key mounted in a job is not permission to route another repository's code anywhere. A named Claude account's allow_data_to is likewise the only gate on its token until phase 5 replaces that fixture with person-owned secrets. And workflows.<n>.secrets can be shared this way, through the operator's own workflow_secrets.<name> entry: a workflow's own secret that no such entry names stays a repository copy. A shared project job never mounts one at all — its secret_env carries the platform's reserved names and a configured provider's key, and a workflow's own name is neither — so the shared copy is mounted on the repositories' own jobs alone.

A workflow secret's entry is where its reach is decided. workflow_secrets.<name>.allow_data_to names the repositories whose jobs may mount a project copy of a workflow secret, so the reach of a name like db-password is that entry and not the whole installation — and the entry is the operator's own local config, which the shared config never carries. With no entry, or with an entry that lists nothing, the name mounts nowhere and stays a repository copy. A wildcard inside a segment (myworkspace/*) means every repository it matches now and later: a repository onboarded afterwards mounts the value with nothing else to do, and nobody is asked again. The value is whatever the repository's build and tests read, not a credential of Fugaro's own, which is why this block is the one place an application secret is stored once for several repositories. A repository that stores its own copy keeps it, as every other name does.

Reserved secret names

A name the platform reads a credential from is reserved, and no other document may have a value stored under it. Four names are mounts Fugaro itself builds into a job's environment — bitbucket-token, github-app-key, claude-oauth-token and anthropic-api-key (internal/config's ReservedSecrets, name → variable) — and two more families are reserved for a credential one component of the platform reads:

  • a model provider's own key, named after its entry in the local config (openrouter → openrouter-api-key, the convention docs/multi-model.md §2 spells out). The conventional name belongs to that provider whether or not its secret: field is written that way today, because a rename to the convention is exactly what would make a value stored under it the provider's credential: fugaro secrets set refuses another provider's — or any workflow's — value under it. A conventional name that is already one of the platform's own (an entry named anthropic gives anthropic-api-key, the direct Anthropic key) stays the platform's, and no warning advises it;
  • the harness OAuth names, claude-oauth-token (the harness Fugaro drives, with its claude-oauth-token-<account> namespace for named accounts) and codex-oauth-token (Codex, which Fugaro does not drive yet: nothing mounts one, and the name is reserved now so it cannot be captured before the harness lands), plus the codex-oauth-token-<name> namespace behind it.

The capture this closes is the same in every case: a value stored by a workflow or another document under a name the platform reserves would become a real credential — mounted into jobs, sent to a provider, or read by a harness — the day a rename or a new feature made that name live. fugaro validate refuses a fugaro.yaml that declares a reserved secret or a harness OAuth name, and refuses a local config's providers entry that claims another entry's conventional name, while warning (never failing) about a provider key written off convention; fugaro secrets set refuses to store a value under any of them, in either scope, before the value is read; fugaro setup's secrets stage neither prompts for one nor mounts one. An existing key named off convention keeps working and is never renamed or migrated — the reservation is about the name, and it holds from the day it is enforced.

The assumption

The design assumes you trust the repository and the source of the task. Everyone who can push to the repository, everyone who can launch a run, and (for follow-up runs) the people listed in followup.trusted can steer an agent that holds the credentials below. Fugaro is built for a team running it on its own code. It is not a sandbox for code you would not run on a developer's laptop.

A run may also be given files, and may also be asked for one. An artifact run (docs/design/artifact-runs.md) has no git token and no pull request: it is handed files the launcher attached, and it leaves files in the runs bucket instead. Two consequences follow, and neither is a sandbox. In: an attached file is trusted exactly as much as the task text, since the agent reads it and can act on what is in it — a screenshot can contain a token, a customer's name or someone's face, and an operator who attaches a file they did not write has handed the agent that content as an instruction. Out: an artifact is output of the same unsandboxed agent, written to runs/<slug>/<run>/artifacts/ under this repository's job account — the account a run of this repository runs as; there is no per-run account — so every launcher and every operator of the installation can read it (a launcher holds objectViewer on the whole bucket, an operator objectAdmin), every run of the same repository can read and overwrite it (the account is scoped to the repository's prefix, not to one run), and it is deleted with the rest of the run's record after 90 days by default. Nothing about an artifact is trusted: fugaro artifacts get verifies the sha256 recorded by the run, refuses a mismatch, never opens, executes or unpacks what it writes, and downloads into a fresh directory it creates (never .) — so a crafted name in a tampered record cannot land a .git/hooks/ or .claude/ file in a checkout you are working in. And what produces it is repository text read once, which is not a boundary against the agent: commands.render and commands.probe are the repository's own commands, kept in the runner's in-memory workflow configuration rather than re-read from a file the run itself can write, so the command string that ran is the string a reviewer read at the task's ref — but the plan stage and the render step are the same container, the same user and the same environment, so a render command that names a file in the checkout runs that file's working-tree bytes, which the plan stage could have rewritten, no more and no less than every other file in a checkout the agent controls.

That hash is integrity in transit, not tamper evidence: it and the artifact live in the same repository-scoped prefix, so anything that can rewrite one can rewrite the other — including another run of the same repository. Tampering is not detectable today; what is guaranteed is that the bytes you receive are the bytes the run uploaded.

The render step runs with the run's own environment, secrets included. commands.render executes as the agent's user with the agent's environment, so a workflow's secrets are visible to it — that is deliberate and is why an artifact recipe must not be handed to an untrusted repository. The runner builds the workflow's secret names into that environment only when !r.review (the secretEnvs block in internal/runner/runner.go), hands the result to r.env via agent.BuildEnv, and runRender in internal/runner/artifact.go starts the command with Env: r.env. It also means a render command can write a secret into a deliverable, and the deliverable is readable by everyone the paragraph above names.

Today that "everyone" stops at this repository, and that boundary is a precondition, not a property of artifacts. An artifact run's account is the repository's job account, so only runs of this repository can read or overwrite its deliverables. Project-centric phase 3's shared project jobs and the VM backend's accounts are not per-repository: on either of them the same run's inputs, artifacts and record would be readable and overwritable by every run on the profile. Because that blast radius has not been reviewed, an artifact-producing run stays on the plain per-repository Cloud Run backend until a per-run prefix condition or a per-run account exists (docs/design/artifact-runs.md §8.5, D11). No code in this slice enforces that, and this document does not claim it does: it is a decision about when artifact runs may be enabled on those backends, and the plan that does so must bring the per-run boundary with it. Until then an artifact run is only ever launched on the per-repository Cloud Run backend this installation uses today.

What limits the blast radius today

  • One container per run, discarded at the end. Nothing in the container itself persists between runs. What does persist is in the runs bucket by design: a cache a later run restores (cache/<slug>/) and a session a follow-up may resume (see below). The agent runs as an unprivileged user with no sudo and no setuid escape (the image self-test checks this on every build).
  • Per-repository identities. Each repository's jobs and builds run as their own service accounts. A job can read only the secrets its own workflow declares (not every secret the repository has), and it can read and write only its own repository's prefixes in the runs bucket. On a repository whose root has been re-applied with the switch on, a per-repository job reads no model credential at all: it declares none, mounts none, and its service account holds no grant on one (see "The credentials service" below). That scoping is the job account's alone; it does not mean the bucket itself is isolated between repositories or between launchers — see "What is not on by default" below. A project job is not one of these per-repository identities. Its service account is the profile's, it mounts the profile's own secrets rather than one workflow's list, and on a profile that lists Claude accounts that includes the account's OAuth token — which every run of the job holds, from the start, whatever the run's own configuration says — see "A project job holds its Claude account's OAuth token" below.
  • Cloud keys stay in the cloud. No command copies a secret value back to your machine: fugaro secrets never prints one and nothing writes one to disk. A few commands do read one into memory on the machine, each only where its work cannot be done without it. Three are yours, run at your own terminal and announced in one line before the read: the GitHub App pre-check (--check-github-app, which fugaro setup and fugaro doctor can ask for, and --github-app-key, which fugaro project sync takes) reads the App's private key to sign one JWT, and fugaro image build <entry> reads the credential it copies a catalog entry's Dockerfile with — the repository's github-app-key secret on GitHub, the project's bitbucket-token secret on Bitbucket — and only when your environment already holds none of its own. fugaro followups RUN reads the same two secrets, under the same condition, to open the repository's provider for one read: the parent pull request a merged run's deferred findings belong to, found by the branch the run's launcher wrote. That read is read-only on both providers — the pull request's merged state and the branch it was found on — and it writes nothing. It is also the one of the three a coding agent's session can run, and it reads no secret there: on an installation that runs the credentials service the read is the service's own read mint — one read-only, repository-scoped installation token, minted for the person's own Google identity and used for that one pull request — which is the same read fugaro review verify makes of a pull request's head; on an installation that runs no service the session is refused, in the command's own name. The rest read the credentials service's bundle document, on an installation that runs the service: fugaro creds set, fugaro creds ls and fugaro doctor --check-bitbucket-token are the commands that maintain and report on it. No value any of them reads is printed, logged, put in an error or written to disk, and none of the reads happens in a coding agent's session: they are refused there, because the value must never reach an agent's process.
  • With the budget gateway on, model keys stay out of the agent's environment. With budget observe or enforce and auth: api-key, or vertex under observe (Vertex under enforce is refused outright, see "What is not on by default" below), the agent's calls go through a per-run gateway: with api-key it gets a gateway token instead of the real key, and on Vertex the gateway fetches the job's own token instead. Either way the gateway pins the models and charges every call against the caps. This is off by default. With the credentials service on, the keys are out of the job entirely, not only out of the agent's environment: a cascade workflow's gateway carries each call to the service, which attaches the credential there (see "The credentials service" below).
  • Narrow git credentials. On GitHub, a run gets an installation token for its one repository (contents and pull requests write, issues and metadata read) that expires within about an hour. The App has no workflows permission, so a run cannot change .github/workflows/. On Bitbucket, the default is a repository access token, scoped to that one repository by Bitbucket's own design. A project-wide git credential is not narrow. fugaro secrets set bitbucket-token --project-wide (or github-app-key) stores one workspace or project access token, or one App key, for the whole installation — and, since project scope became the default for the App key (see "Project scope is the default for a name that has one" above), github-app-key does so with no flag at all. bitbucket-token needs an explicit project_secrets.bitbucket-token allow-list to be stored that way — one entry may name a whole workspace, myworkspace/*, so a repository created there later mounts it with no new grant (see "Project scope is the default for a name that has one" above) — and its per-repository default is why: a repository access token serves the one repository it was issued for, while the workspace or project access token an operator opts in to serves every repository the allow-list admits. What that token reaches is wider than the allow-list. The allow-list decides which jobs mount it; the token itself reaches everything its scopes reach. Every allow-listed run's agent holds the token's value, and so does every launcher of an allow-listed repository, and launchers are trusted as before: a malicious launcher can use the agent to write across the token's reach. Through pushes to another repository's base or Fugaro branches, an agent also reaches every other credential that repository's runs and builds hold. A hostile agent or launcher can push, open and comment on pull requests, and trigger Pipelines in every repository the token reaches, including repositories not enrolled in Fugaro; the App key mints tokens for every repository the App is installed on — not only the repository whose job or build holds it. Use it only where that reach is what you mean. A repository whose installation publishes proxy: true is the exception — its run reaches one repository and the run's own branch, and the flip's list (config.ProxiedGitSecretNames) takes the job's mount of the token and the accessor behind it away (see The Bitbucket git proxy below).
  • Logs are isolated in their own log bucket, readable by the people you made launchers, and redacted of every mounted secret, including common encodings. Redaction is best effort. Project Owners and Editors can still read every log, isolated or not. Cloud Build's own logs are never moved there: they carry a repository's build output, which by design never includes a secret value. fugaro setup --no-log-isolation leaves Fugaro's own logs in _Default too.

The GitHub App's key, when the credentials service holds it

A credentials service (docs/credentials-service/) is a separately deployed Cloud Run service that holds credentials a job would otherwise mount, and answers a run for them; fugaro update deploys it on every installation (the owner's ruling of 2026-11-05), and a repository's runs reach it once its own root has been re-applied with the switch on. The GitHub App's private key is one of them (D145). This section states the GitHub half — the App key, the minted installation token and the job's copy of the key — and nothing about the model credentials, which are the service's other half.

  • Signing is the service's, not the job's, from the release that tells a job where the service is. The App's key is one entry of the service's bundle secret, written by the owner with fugaro creds set github-app-key, and the service is the only Fugaro runtime identity that reads that secret. The keyless half is in the runner, and it is the job's own environment that switches it on: internal/gitprov/providers/providers.go opens the github provider without a key only when FUGARO_CREDENTIALS_SERVICE_URL is set, which is the "this installation has a credentials service" fact (D146/D147) — so no code path in the job mints a token or reads the App key when the job's environment names the service. A launch of a repository whose root has been re-applied with the switch on now sets it, on that repository's own job and on the shared project job its profile sends the run to (B5.2): fugaro run reads the installation's own record of the service — the URL the credentials stage wrote into the project's config, which the published shared config carries to every machine of the installation (internal/cli/run.go's credentialsServiceLaunchEnv, internal/localcfg) — and puts it on the execution's plain environment. So on a switched-on repository a run's installation token is minted by the service and the run's runner opens its git provider with no key at all; the bundle's copy of the key is the one that signs, and a bundle that holds none is a named refusal rather than a fall back to the job's copy (D143). A shared project job is told too, on the same switch (B5.2): the launch hands a switched profile's shared job the address on the same switch a repository's own job is judged with, and with one exception the code makes where the document the run will use cannot be read — a repository's own job is told anyway, because its mounts are already gone and withholding the address would halt the run at the service's door, while a shared job's is withheld, because it still holds every mount it had and so starts exactly as it did before this release. So the same keyless path opens for its runs and the mint that follows is served for the repositories its profile admits (B5.1, G21) — see "The credentials service" below. The App key it still mounts is one no code path in the job reads, and the class's own table is the piece no installation has yet: what that leaves a shared job's GitHub run is stated with the other limits below. On a repository whose root has not been re-applied with the switch on, no variable is set and the job reads the App key and mints in-job exactly as it did before the service existed. A token that cannot be minted is a refusal — the run fails at bootstrap and never falls back to a credential of its own.
  • What reaches the agent is its own run-scoped token, and its reach is unchanged. The mint signs with the same permission set the in-job mint uses (github.RunTokenPermissions: contents and pull requests write, issues and metadata read, no workflows permission), and the agent still gets that token as its git credential. Nothing here narrows or widens what a run may do on GitHub; what changes is where the signing key lives.
  • What bounds the mint is the run's identity, not a field in the request. A mint call carries the App's ID and nothing else — there is no repository field to fill in. The repository is the one the calling job's account is bound to, the caller's Google ID token is checked against the installation's job service accounts, and the service honours a run identity only from the job whose repository that identity belongs to. So a run of one repository has nowhere to ask for another repository's token.
  • The job's copy of the key is still in the job, and the runner no longer reads it. The mount and the runner's fetch ship as one change on purpose: a container that declares a secret its account may not read is a job Cloud Run refuses to create, so taking the accessor without taking the mount would break every GitHub run of a switched-on repository. Both are gated on one list in the code (config.ServiceHeldSecretNames, mirrored into the workflow module's service_held_secret_names and held to it by a Terraform guard test), and on this tree that list is empty — the flip is held until the owner's live Check 96 has proven the deployed service mints — so a switched-on repository still grants its job's account its accessor on github-app-key and still mounts FUGARO_GITHUB_APP_PRIVATE_KEY in the container: the residual in "What one run's agent can reach" below. What this release does change is who signs. The launch names the service (the bullet above), so the provider is opened keyless and the installation token is minted at the service, while the key the container still declares is one no code path in the job reads. This document claims the job no longer reads the key, not that the key is out of the job: the accessor and the mount leave in the release that flips that list, after the live check.
  • Every act on the answer path is audited, and no value is written anywhere else. One line per act, written before the answer goes out, and the line carries names — a credential's name, never its value — because the code that holds the values is the code that scrubs them (internal/credsvc/probe.go's NewProbeAuditor, over the bundle loader). One act carries two lines, and it is the model call: the issuance is written before the answer goes out — that ordering is fail-closed and it is why a stream cut in half would otherwise read as served — so when the stream then fails the outcome is written after it (internal/credsvc/cascade.go's answer, state_unavailable, the credential that answered and its tier), and the operator reads a call that got no whole answer rather than one that was served. That second line refuses nothing by then — the credential is spent and the answer has left — so a line that cannot be written is the service's own log line (s.log.Error) and not a refusal. The acts: a model call served (internal/credsvc/cascade.go, one line per issuance — an issuance whose line cannot be written is withheld, answerUnaudited), a mint issued or refused (internal/credsvc/github.go's auditMint and refuseMint; a mint's line names the App key and carries no tier), and every refusal answered once the caller's identity is verified — the refusals answered before the mint is reached included: a call refused because the run identity is not a run of the calling job's repository, and a call refused by a kill switch, are both answered by refuseCall (internal/credsvc/cascade.go), which writes the line through auditCall and then the typed refusal, and the line's status is the refusal's own wire error type. What carries no line is the refusals answered before there is a verified identity to record: an unknown route or method, a request whose headers cannot be read, and the identity check itself (internal/credsvc/server.go's refuseIdentity), all of which write the answer and nothing else (refuse). The mint's answer carries the token and nothing else, and no error, log line or record carries it either. That is the same rule the rest of this document's credential handling follows.
  • A merge is minted by the service too, for the installation's daemon and for nothing else (E16, D2049). POST /v1/github/merge-token — internal/credsvc's MergeMintPath, served by Server.mergeMint — is the App key's third act, and it exists because a run's own mint issues a token a run may push with and nothing more, so whatever merges a pull request had no credential to merge with (F28). Its caller is a class of its own, the orchestrator daemon: a list of service accounts the installation names (AuthConfig.OrchestratorAccounts), matched against the caller's Google ID token as every other class is, and admitted on this service's own URL alone — never gcloud's client id — so the token a plain gcloud auth print-identity-token mints is refused before any list is read. A run's token, a job's, a person's and the coordinator's are each refused by name, and a caller presenting a run identity on this route is refused by name. The mint is bound to the gate, and the gate is a condition of the mint and not a property of the token it hands over: the call names one repository, one pull request and the head that pull request must still be at; the service reads the pull request's current head from GitHub and refuses when the two differ (G2); and it reads both places GitHub lets the App be a bypass actor — the rulesets that cover the base, each listed ruleset read again by id because GitHub's list answers a summary of each one and the bypass list is in the per-id answer alone, and the base's classic branch protection, whose own bypass list is a second one — and refuses when the App is on either, when GitHub's own current_user_can_bypass says the App may bypass the ruleset, or when either list cannot be read at all, because an unreadable list is not an absent one; a rulesets page that comes back full is refused for the same reason, since a page cannot be told from a truncated list (G14). What comes back is an ordinary GitHub installation token — scoped to that repository and that permission set and to nothing narrower, so it does not expire when the head moves and cannot be told which pull request it was minted for — and what keeps a merge at the head this service checked is the daemon's own merge call passing sha equal to it (E8): a caller that mints and then merges without that sha has left the gate behind, which is why the client the daemon holds says so (internal/creds's MergeMinter). No token is minted for a base whose protection the App may bypass, and the permission set it carries is the narrowest GitHub's merge endpoint accepts — contents and pull requests write, metadata read, no administration noun and no bypass flag. One repository may be minted for ten times an hour per instance of this service and no more: the count is the serving process's own memory, so a restart, a cold start, a second instance or a new revision begins a fresh window and the bound is best effort — it is a bound on a daemon looping against one instance, which is what the owner ruled (D2049), and not a ceiling on what the service as a whole will mint. Every mint and every refusal taken after the caller is verified writes exactly one audit line, carrying names and never a value. What this class is not is a barrier against the machine the daemon runs on: the daemon runs as the operator (D1241), so an operator who may impersonate the daemon's account may do so from any process of theirs, a coding-agent session on the same machine included, and what bounds that session is the gate, the rate and the record above rather than the credential's shape. Closing that last reach needs a credential the machine cannot obtain at all, which is the owner's ruling to make (D2049's alternatives) and is not built. The class and the daemon's own token are on this tree as of this release (F19, O2). The grant that lets a daemon's account invoke the service, and the environment variable that names the class, are rendered by deploy/terraform/gcp/modules/installation/credentials.tf and orchestrator.tf from the installation's own orchestrator block, both behind that installation's two switches, so an installation that runs no daemon plans exactly what it planned before; and the daemon mints the token it presents through one seam (internal/cli/orchestrator_identity.go) — an impersonated token, --impersonate-service-account for the account this class holds, --audiences for this service's own URL and --include-email for the claim the class looks the caller up by, which is the exchange that makes the token the daemon's and not the operator's. What fugaro update cannot write is the right to make that exchange: the installation grants nobody actAs on that account, so a machine whose own credential cannot already impersonate the daemon needs roles/iam.serviceAccountTokenCreator on it, and a daemon that cannot mint says so in one line naming that grant and the command that adds it, rather than refusing every call with no cause a reader can find — the installation's orchestrator-identity live check takes that grant by hand and removes it afterwards. The App's own merge permission is the owner's per-repository step (D2048, Check 542).
  • What the merge that mint serves is allowed to land, and every input that refuses it (D2030, D1245, D2041, E10b). The merge is the orchestrator daemon's alone, and it is decided before the token is asked for: the ladder's rung 3 lands a stalled pull request only when the run behind it is over, its commits are pushed with a changed-path set that is neither empty nor truncated, the host's own checks read is green, the whole changed-path set is Routine (one path outside the routine allowlist — a workflow file under .github/, internal/creds, a prompt, Terraform, a tree nobody classified — means no merge), and no finding blocks: no critical one, and none high in a security path. Every one of those reads is made at one head SHA, and the merge call passes that same sha, so a push after the gate refuses the merge rather than landing a commit nobody read; an input the gate cannot read at all — no checks answer, an unreadable findings file, a record that is not terminal — refuses for the same reason. The mode a project runs decides only who is told, never whether the gate applies: critical waits for a person at its ceiling in every case, and so does any pull request the gate refused, which raises the question for a person with the reason attached. A pull request that is still a draft is readied and then merged at the head it readied, and that readying happens unless the machine's own config has turned escalation.ready_drafts off — it ships on, so a daemon nobody switched off readies a draft whose gate passes and a machine that wrote false merges no draft and asks a person. None of it is reachable on this tree: the grant that would let a daemon's account invoke the merge mint, and the environment variable that names it, are Terraform and are not carried (the bullet above), and the daemon's own tick is built without the ladder's seams (internal/cli/orchestrator_run.go's Tick carries no Ladder), so no daemon walks a rung and no pull request is merged by Fugaro today — an installation converges by the code existing in the binary and nothing calling it, and the App's own merge permission is still the owner's per-repository step (D2048, Check 542).
  • A label is read and written by the service too, for the installation's daemon and for nothing else (D2439, F5, F18). POST /v1/github/labels — internal/credsvc's LabelPath, served by Server.labelRoute — is the App key's fourth act, and it exists because GitHub has no label-only permission: any credential that could write a label could also approve, retitle or close any pull request of the repository (F5), so the service performs the write itself and no token leaves it (D2439). Its caller class is the merge mint's, the orchestrator daemon — matched against the caller's Google ID token on this service's own URL alone, so the token a plain gcloud auth print-identity-token mints is refused before any list is read, and a run's token, a job's, a person's and the coordinator's are each refused by name. The token it mints for its own act is scoped to the one repository and to {pull_requests: write, metadata: read} — no contents noun — is cached until near expiry and is never returned (U2). The call carries a repository, one of five acts (list, get, ensure, add, remove), the App ID it acts as, a pull request number, a label name and the id of the run that opened the pull request, and nothing else: the App ID is the caller's and the key is the bundle's — a caller names the ID exactly as it names it to the merge mint, so an ID that is not that key's App cannot mint, and a wrong one buys a refusal rather than an act — the pull request number is the one the corroboration below reads, while the colour and the description a label is created with are the service's own constants (D2437), remove takes fugaro:running and fugaro:failed alone, and a spec: name is accepted only in R3's shape, checked as ASCII before it is lowered (F26, R3). Every write lands only on a pull request the service has corroborated: its head branch must be exactly fugaro/<run id>, its head repository must be the repository the label is written in, and its author must be Fugaro's own identity — so a run that writes another pull request's number into its record cannot get that pull request relabelled (F17, O3). A repository outside the installation is refused, and a provider whose host has no pull request labels is refused too rather than made the silent no-op the daemon's own provider is: the daemon asked this service to perform an act, and an empty answer would read as one performed (R7). One repository may have 60 writes and 240 reads an hour per instance of this service and no more, counted apart and held in the serving process's own memory, so a restart, a cold start, a second instance or a new revision begins a fresh window and the bound is best effort — the same bound, in the same words, the merge mint's rate above carries — and those reads draw on the same App installation's GitHub budget the runs use (F22). Every call that reaches a verified caller writes exactly one audit line, served or refused, carrying names and never a value (C1.13). Its get act serves a Bitbucket repository too, and it is the one act that does (D2736, G5). The host is decided by the service and never stated by the caller: the name the call carries is resolved against the GitHub inventory and then the Bitbucket inventory, and a name both of them hold is refused as ambiguous rather than resolved by a rule a caller cannot see. A Bitbucket get is answered with the state of one pull request — open, merged or closed, mapped by the host's own adapter, so the daemon and the service cannot disagree about what "merged" means — and with no labels, because Bitbucket Cloud pull requests carry none; list, ensure, add and remove on that host are refused as unsupported rather than made the silent no-op the daemon's own provider is. A Bitbucket call names no App ID — there is no GitHub App on that host — and one that does is refused. Its credential is the installation's Bitbucket read consumer (bitbucket-read-consumer, see "The Bitbucket read consumer" below), which the service mints from read-only, per workspace, cached until near expiry and never returns: the read mint's own guards hold it, so no consumer is a refusal and never a fallback, the consumer's workspace must be the repository's, and only the read scope allow-list is accepted. Its audit line names that read consumer and not the App key, because that is the credential the act was performed with — and it is the only one of the two an installation with Bitbucket alone holds. The orchestrator class is a new caller of that consumer, which has served the person class and the coordinator class alone, and what makes that acceptable is the shape of the act rather than the caller: the token never leaves the service, and what comes back is one pull request's state and nothing else — no label, no body, no diff, and no way to write.
  • What bounds a stolen daemon identity is the acts themselves, and a session on the daemon's machine can present it (F18, F26). The daemon runs as the operator (D1241), so a coding agent's session on the operator's machine can present the daemon's identity exactly as it can for the merge route above, and the caller class does not stop it. What that identity can then do is bounded by what this route accepts, and by nothing else: it can relabel Fugaro's own pull requests — the ones a run of this installation opened, corroborated against the run id it sends, in a repository of this installation — with fugaro:running, fugaro:failed and a spec: name of R3's shape. It cannot write label text or a colour, cannot remove a spec: label a person added, and cannot reach a pull request Fugaro did not open with either of the two acts that write on one, because the corroboration refuses them there. On a Bitbucket repository there is one act at all — the get above — so the same identity can read the state of any pull request of an installation repository by number, a person's own included, and write nothing there: the act touches no label, the read consumer's token it is performed with never leaves the service, and what the call hands back is a state and no text. The corroboration covers those two acts and no others, and the rest of the route reaches the whole repository: ensure creates any label of R3's spec: shape across the repository, naming no pull request and having nothing to corroborate, and the reads reach further than the writes — list answers the labels of every open pull request in the repository and get the state and the labels of any pull request it names by number, a person's own included. The daemon's half is wired in this release, and no installation has proven it live (T7, F19, O2): the client that asks the route is built from the installation's own records — the service URL fugaro update published and the account the module creates — the tick that computes the difference runs every cycle, and the token the client presents is the daemon's own, minted as that account for this service's URL, so what bounds a stolen identity here is the acts above and the machine's ability to mint that token, and not the half being unwired; the paragraph above states the one grant that has to exist for the mint to succeed. No pull request carries these labels yet: the live check that would show one is owner-run and not written yet, and no installation has exercised the path end to end.
  • The repository's issues are read and opened by the service too, for the installation's daemon and for nothing else (D2718). POST /v1/github/issues — internal/credsvc's IssuePath, served by Server.issueRoute — is the App key's fifth act, and it exists for the label route's reason (F5): GitHub has no issue-only permission either, so a credential that could read a repository's issues could also open, retitle, label or close any of them, and the service performs the act itself and no token leaves it (D2439's pattern, D2718). Its caller class is the merge mint's and the label route's, the orchestrator daemon — matched against the caller's Google ID token on this service's own URL alone, so the token a plain gcloud auth print-identity-token mints is refused before any list is read, and a run's token, a job's, a person's and the coordinator's are each refused by name, as is a caller presenting a run identity — and it performs three acts and no others: list reads every open issue of the repository with pull requests excluded, get reads one issue back by number, an open or a closed one, and open creates one from a title and a body. There is no act that closes an issue: closing is GitHub's own work on the Fixes #N a merged run's pull request carries (D2727), so a close act would be a second way to close one, and the one the design chose leaves the record in the pull request. The token it mints for its own acts is scoped to the one repository and to {issues: write, metadata: read} — its own set and not the label route's, which cannot touch an issue at all (F39) — is cached until near expiry and is never returned, and it carries no contents noun, which no act of this route needs. What a caller may put into an issue is bounded by the service and not by the call: an opened issue's title is required and may be at most 256 characters, and its body at most 8000, both counted in characters rather than bytes, so a title a person can read is not refused for its encoding and no caller can widen either bound by writing a bigger field — the refusal names the field and the number and never the text. The host is GitHub and only GitHub (D2718): the repository is resolved against the installation's GitHub inventory alone, so a repository the installation holds only on Bitbucket is refused rather than answered empty, and Jira would arrive as its own contract and its own credential rather than as a second branch here (O3). The App's installation must hold issues: write — the mint asks GitHub for it, and GitHub refuses a mint that asks for a permission the installation does not hold — and the installation's required permission list unions the set in (github.RequiredPermissions), so fugaro doctor and fugaro setup name a missing grant and its fix before a call reaches this route; granting it is the owner's own step on the App, which fugaro update cannot take (the owner's ruling of 2026-11-17, U3). One repository may have 60 issue creations and 240 issue reads an hour per instance of this service and no more — the label route's own numbers, counted apart and held in the serving process's own memory, so a restart, a cold start, a second instance or a new revision begins a fresh window and the bound is best effort — and every call that reaches a verified caller writes exactly one audit line, served or refused, under the route's own purpose and with the App key as its credential, carrying names and never a value (C1.13). What bounds a stolen daemon identity here is the acts themselves, exactly as for the routes above: it can read the repository's issues and open one, it can neither close nor relabel nor otherwise touch one, and it never sees the token the act was performed with. No daemon reaches this route on this tree: the client that would ask it and the sync that would drive it are not wired, so the daemon holds no client for the route and no item carries an external issue id yet — an installation converges by the route existing in the binary.

What is not on by default

Three gaps are easy to miss, because nothing warns you about them:

  • Budget mode defaults to off. With no budget: block in the installation's own config (the project ceiling fugaro setup writes), or an empty mode, there is no gateway and no per-call cap: the real model key sits in the agent's environment like any other secret, and the only limits are the provider account's own limit and the token cap, if you set one (0 is none). A repository's own fugaro.yaml can only tighten that ceiling, never loosen it.
  • Vertex has no dollar cap, in any mode. auth: vertex with budget enforce is refused at fugaro validate/update --repo, and again by the runner before the agent starts, so a Vertex repository can only run observe or off in practice. There is also no key to put a credit limit on: the job's Vertex calls are authenticated by the job's own service account through the metadata server, not a key you hold.
  • Every launcher can write runs/, for every repository, even after the 0.7.0 bucket IAM hardening. Before 0.7.0, or on an installation whose operator has not yet run fugaro update to apply 0.7.0's migration, every launcher — not only operators — holds roles/storage.objectAdmin on the entire runs bucket, unconditioned, including the installation-wide project layer, recipes and shared config: a launcher can rewrite the project layer's commands or add an image.setup that runs in the next rebuild, replace a recipe or the shared config, or poison another repository's cache — all without launching a run, reaching that repository's secrets through its next build or job. Project Owners, Editors and anyone with a project-level storage role bypass the bucket's own policy regardless, hardened or not (docs/design/bucket-iam.md §9). Once the hardening is applied, a launcher's grant narrows to roles/storage.objectViewer (the whole bucket, unchanged) plus roles/storage.objectUser on runs/, tokens/ and issues/ only (tokens/ since the budget token moved there, docs/design/budget-token-channel.md §7.2; the sealed token objects a launcher writes, replaces on a retry and removes after a launch that did not start; and issues/ since the shared issue store moved there, docs/troubleshoot-issue/reconciliation.md D1727, where the issue a person files is the launcher's own write) — but runs/ and tokens/ hold every repository's runs and queued tokens, not only the ones a launcher was onboarded to, so a launcher can still delete or replace another repository's queued token object (its run then refuses to start; a launcher can mint any repository's budget identity anyway, see below), and can still (docs/design/bucket-iam.md §10, item L3): overwrite another launcher's queued task.json, forge result.json or launch.json, set the cancel marker on anyone's run, or plant a session/ file or followup.md that a later follow-up of that repository restores (see "A follow-up's protections are hygiene, not boundaries" below). What a launcher can no longer do, once the hardening is applied: write the project layer, the shared config, recipes or the marker; rewrite a build record, check.json or a layer copy; poison cache/; forge or steal locks/. The fugaroLauncher custom role, which every launcher also holds (a separate grant from the bucket one above), additionally lets any launcher list every secret in the project (names, labels and version counts; reading a value still needs secretAccessor, which only the job and build accounts hold).

The credentials service

Deployed for every installation, and reached only where the switch is on (the owner's ruling of 2026-11-05; DON1 and DON8). The service is a Cloud Run service in the installation root, deployed separately from every job, with a service account of its own. fugaro update deploys it on every installation — there is no flag and no separate command, because fugaro update is the whole upgrade — and the run that deploys it records the service's URL in the project's config. Deploying it is not the same as reaching it, and the deploy alone changes no run: the service is idle until the installation's bundle holds a model credential and that repository's own root has been re-applied with the switch on, which is the apply that drops its jobs' model mounts and grants their accounts an invoker on the service. The switch admits an api-key or oauth repository too (B2.2, B2.3, D2071): those two are switched on under two further terms — a budget mode of observe or enforce, because the gateway that reaches the service exists only there, and the service's bundle holding the credential that auth's runs are served under, which is anthropic-api-key for api-key and every account's claude-oauth-token[-<account>] for oauth — while a vertex repository is the one agent.auth it never admits: its calls go to Vertex AI on the job's own service account, so no route of the service serves it. On a switched-on repository, a cascade workflow's calls go job → gateway → service → upstream — every launch of a per-repository job of such a repository hands it the service's address, so the gateway's upstream is the service, which attaches the credential there (D143). A shared project job is given the address too, on the same switch, and the class is served for its profile's repositories (B5.1, B5.2, D2078): the launch hands a switched profile's shared job the service's address on the same switch a repository's own job is judged with — withholding it only where the document the run will use cannot be read, which is the one place the two paths differ: a repository's own job is told anyway, because its mounts are already gone, while a shared job, which still holds every mount, is not — and the service admits such a caller for the repository the run identity names and only where that repository is one its profile admits, read from the published node (G21, F40) — so the profile, and not an IAM grant, is the boundary between the repositories one job serves. A shared coding run is served by the service for its profile's repositories, and no shared job loses a mount here (G17): the job keeps the GitHub App key, the profile's provider keys and its Claude account's token, each with its account's secretAccessor on it, because the drop is the flip that has not landed (B5.7). What the class does not have yet is a deployment: its table is FUGARO_SHARED_JOB_ACCOUNTS, read by the service's own binary and rendered by no module under deploy/terraform/ — internal/infra/tf's CredentialsServiceEnvAwaitingTheModule carries it as the one entry the module does not carry yet — so every deployed service starts with an empty shared set and refuses the class whole, the caller falling through to the per-repository table and being refused there. The consequence is stated rather than left to be found: on an installation with the switch on, a shared job's own GitHub run is refused at the service's door — the git mint and the model call alike — and the run ends there rather than being served (D143) — a refused mint fails it at bootstrap and a refused call halts it, and neither is answered from the App key its container still holds. Making the class live is a deployment step beside the one that renders the profile's job, and it is not in this release. And the mount drop landed in 0.26.0 (B2.7, D2072): a switched api-key or oauth repository's runs' calls are the service's exactly as a cascade's are, and its job now declares neither the Anthropic key nor the Claude OAuth token, its account holding no secretAccessor on either — the mount and the accessor go in one apply, because a mount the job's account has no accessor on is a job Cloud Run refuses to create — while every provider key the job mounts stays its own (R6, D1634). The first bullet under "the limits this release does not hide" below states what that drop does not reach.

It is the only Fugaro runtime identity with access to model credentials (D148). The others are named here so the sentence is not read wider than it is: the build service account holds secretAccessor on the git secret and on the workflow build secrets; operators hold the roles that add and list secret versions, which is metadata and not a value; and Project Owners bypass any secret-level policy and can read any secret in the project. An Editor is not one of them: roles/editor carries secretmanager.secrets.getIamPolicy and delete but not secretmanager.versions.access, so an Editor reads a secret directly, only through its own secretAccessor grant; indirectly, by carrying iam.serviceAccounts.actAs and run.services.update, which let it deploy code that runs as an account holding one — the same kind of grant the job and build accounts hold, which fugaro doctor reports per container. The service is the only Fugaro runtime identity with a model credential — it is not the only identity with access to Secret Manager, and this document does not claim otherwise.

One secret, one grant, one leak (Q6). Every credential the service can issue lives in one Secret Manager secret — a YAML document with a strict schema (an unknown key and an oversize document are both refused), read at latest with a short cache — and the service's service account holds exactly one unconditioned secretmanager.secretAccessor grant in the installation root: on that one secret alone, no grant per credential, and no name-prefix condition over the model secrets. Two accessors of that account are the exception, and both are named rather than folded into the count, because a reader who counts grants would otherwise find them and read this paragraph as false: for a switched repository's job the account holds one secretmanager.secretAccessor per container the job's own environment mounts, granted in the repository root beside the job's own so it can read a value the job no longer mounts (B3.3, D2074 — secret-readers.md E7 is where each one is audited, one container per mount and never the project's), and the dynamic-delivery class's user-supplied containers are read through a project-level accessor conditioned on that grammar's two name prefixes (D1931, E25). The cost is stated with the shape: a read of the bundle is every credential the service holds at once, which is the same set compromising the service is — the single point of compromise and of availability the owner accepted as D143 — and not one key of it. The bundle is written by fugaro creds set, listed by fugaro creds ls, and never printed by either.

Its database reach is two permissions, and no instance lifecycle (D6). The service's second — and only other — grant is a role of its own on the installation's realtime database, and it is written rather than borrowed because Realtime Database IAM has no path-level scope: a binding is per instance and reaches the whole database, so the only question a role can answer is which operations the account may make. The operations the service makes are reads of a run's write-once outcome (outcomes/$day/$slug/$run — the first database read of a call, made by the identity check before the stop flags are read), of the operator's stop switches (config/kill/global, config/kill/repos/$slug), of the published policy (config/policy/shared and config/policy/repos/$slug) and of the credential state another revision wrote under creds/, and writes of its own creds/ nodes — a credential's mark, a run's lease and a probe's lease — each by compare-and-set (PutIfMatch, which is why the write permission is needed at all and not only the read). That surface is exactly the database's two data permissions — firebasedatabase.instances.get (read) and firebasedatabase.instances.update (write) — so the role is a custom one, fugaroCredentialsDatabase, declared in the Firebase project the database lives in, bound to that one account and to no other, with no condition, and deliberately neither predefined role: roles/firebasedatabase.viewer is get+list and cannot write a mark or a lease at all, and roles/firebasedatabase.admin adds the instance lifecycle (create, delete, disable, reenable, undelete) — the ability to delete the installation's database, held by the one identity that holds every model credential. This is the account's only grant on the database, and the only project-level role it holds that is not a Secret Manager one — its Secret Manager bindings are the paragraph above's, and two of them are project-level in the installation project: the dynamic-delivery class's accessor, conditioned on that grammar's two name prefixes, and the lister role beside it, which carries secretmanager.secrets.list alone and reads no version's payload (D1931, E25 — secret-readers.md audits both). Which project the database role lands in depends on the layout: in the default installation the Firebase project is the installation project, so the account holds projects/<installation>/roles/fugaroCredentialsDatabase there beside those two; where the installation's firebase_project names a second project, the role and its binding live in that one, and the installation project holds the two Secret Manager bindings and nothing of the database's. No condition is written on the binding because there is nothing a condition could fence: with no path to scope, one would be a fence that looks like one and is not.

What the two permissions are, rather than what the service uses them for. Realtime Database IAM has no path-level scope, so the binding that lets the service read a run's outcome, the stop switches and the policy is a binding that lets anything running as that account write every one of them too — config/kill/*, including the switch that is supposed to stop it, config/policy/*, including the allow-list that holds a call to a model, and outcomes/. The service writes none of those (its writes are the creds/ nodes above, built by internal/creds' own path builders and by no caller's string), but that is a fact about the code and not about the role: through IAM this account can read and write the whole installation database, so a revision that ran different code could in principle turn off its own stop switch or widen the policy it is checked against — and the same identity already holds every model credential a call can be given (the paragraph above), which is the class of reach that matters here. The fence is the service's own behaviour, and D6 accepted that rather than give the marks and the leases a second identity that would have to hold the credentials. What this role does not change: it reads no secret (the paragraph above is the whole of the service's reach on credentials), and it does not widen what a caller may ask for — the published policy and the account's own allow_repos still decide which credential a call may be given. An installation whose deployment predates 0.10.1 has no such binding, and its service refuses every call — the first database read of a call is the run's write-once outcome (outcomes/$day/$slug/$run, read by the identity check that runs before the stop-switch read), so the refusal is "the run's outcome could not be read" under state_unavailable, and a call that the identity check refuses first is never taken to the database at all. Running fugaro update once against that installation is what adds the binding, and until then its service refuses every call as it did in 0.10.0.

With the service on, a per-repository cascade job holds no model credential at all, and as of 0.26.0 an api-key or oauth one gives up the two Claude mounts and keeps only its provider keys (B2.7). The cascade job's service account has no secretAccessor on a model secret and its container mounts none; the two go together, because a mount left behind is a job Cloud Run refuses to create. The service attaches the real credential to a call the gateway forwards, and the value never reaches the job: not the agent's environment, not the runner's /proc, and not a log line — the service's own audit lines carry names and never values. A switched api-key or oauth repository is now in the cascade's state, with one class of credential left on its job (B2.7, D2072): its runs' calls are the service's exactly as a cascade's are — the launch puts the address on the job's execution and the runner builds such a run's agent environment as the cascade's, so the agent's own environment carries no credential of the job's — and its job mounts neither the Anthropic key nor the Claude OAuth token, its account holding secretAccessor on neither, so from 0.26.0 there is no mounted copy of either for the runner's /proc to hand the agent. What stays is every provider key the job mounts, which the service forwards rather than attaches (R6, D1634): on such a repository /proc is where a provider key reaches the agent, and no longer where the Anthropic key or the account's token does. A launch of such a repository on a job image below 0.25.0 is refused before any execution exists, because that runner reads the mounted key the drop takes away. The drop is installation-wide and per repository, and a shared project job is the one job it does not reach: the phase-3 module drops no mount, so a shared project job keeps its model-secret accessors and keeps the Claude account token its profile mounts (see "A project job holds its Claude account's OAuth token" below) — while the module does carry the switch's other half, the shared job account's roles/run.invoker on the service (B5.2), which is what makes the class's calls answerable there at all; so the model call of a switched shared job's run is the service's while the mounted copy stays where it is, one read of the runner's /proc away — the state a switched per-repository api-key or oauth job itself was in before 0.26.0. The drop is also not per workflow: it is a function of the repository's switch, so a switched-on repository whose own agent.auth is cascade mounts no model credential in any of its jobs — the Claude OAuth token, the Anthropic key, or a provider's own key.

The service reads the workflow's own secrets: too, and from S3's flip a run's start fetches them from it (S3, D491, D1267, F4). A workflow's secrets: are the class the service brokers where the reach does not change: the code under test reads the value as a plain variable in the job's environment, so a value the runner fetched at bootstrap is the same value in the same variable a mount put there and the agent reaches it through the runner's /proc exactly as it did before — what S3 moves is where the runner reads the value, not what a run can reach. fugaro update records each repository's fetchable workflow secrets by name in the installation's database (creds/workflowsecrets/<slug>: each workflow's secrets' variable names and container IDs, never a value), the service's account holds one secretAccessor on each container the job mounts, granted in the repository root beside the job's own (D2074), which is what lets it read a value the job no longer mounts, and at bootstrap the runner fetches every declared variable the job's own environment does not carry through the service's own route, which binds the repository and the workflow to the verified job account — never to a header the run writes — so one workflow's job is never served another's secrets (G19). A mounted value always wins: a declared variable the job's environment already carries is never fetched, so a repository whose root has not been re-applied with the switch on behaves exactly as it did, and the read leaves the job only when the flip lands (B3.8, D500). Where the fetch is a run's only source, its start waits on the service: a service that is unreachable, refuses, or answers with something that is not this contract halts the run at bootstrap, before any agent call, rather than carrying on without the value (D143) — and the service scales to zero (D501), so the first call after an idle period pays a cold start on a run's own start. A run that holds a slip — the per-run claim the service serves a slip-bound credential under — keeps the instance serving it warm while it runs, the runner asking the service to read that claim back at the cadence Check 511 measured (D1934), and that is best effort: there is no redundancy beyond Cloud Run's own, and an outage of the service is an outage of every switched repository's run start (D501). A repository on backend: cloud-batch keeps its workflow secrets on the VM (D2075): a Batch VM is not a job account the service admits, so S3's fetch never reaches it and those secrets stay the VM's own secretVariables — a permanent listed exception, which the audit records with the exit slice never.

The invariant. The rule the code enforces, and a test holds it, is that an OAuth token is only ever sent to Anthropic's own endpoint: checked on the route and on the destination the request will actually go to, and a test fails if any route carrying a provider base URL can also carry an OAuth credential. A cascade run's tier A is one of those tokens, so this holds for the service's calls exactly as it does for a job's.

Unreachable halts, never falls back. Once a run has an upstream to call, a service that is down, unreadable or refuses halts the run named rather than letting it reach for a credential of its own (D143): the runner refuses the run where the reason is known rather than falling back to an in-job key, and there is no fallback path in the gateway either. What makes that safe is the mount, and the mount is the switch's, not the outage's: a per-repository job is the job the switch reaches, so a cascade workflow there has no model credential mounted to reach for whether the service answers or not. A shared github coding project job, which keeps its mounts (above), is handed the address now, on the same switch a repository's own job is judged with (B5.2) — so it is served for its profile's repositories and there is no path back to its own token either: a run of it that the service cannot serve — a repository outside its profile, or a class no deployment admits yet (above) — halts at the service's door rather than being answered from the App key its container still holds. The review-only variant the deployer derives from that job is the other half, and it is handed the address: the deployer builds one for every shared coding job, GitHub's included (internal/infra's ProjectReviewJobs), it mounts nothing at all — no App key, no review key, no Claude token — and reviewVariant is what writes the service's address on it, because a review run's read-only token and its model calls come from there. A shared Bitbucket job is the exception the other way: it holds no git credential at all (D2302), so the deployer is what puts the address on it ("The Bitbucket git proxy" below), and no run meets that case until a Bitbucket profile is deployed onto one (docs/shared-jobs-default's I1).

The operator's stop flag. The service honours the kill switch Fugaro already has: with the project's switch or a repository's on — fugaro budget kill --all, or fugaro budget kill --repo <owner/name> — it issues no credential at all and answers a typed refusal the run halts on. The switch is read before the bundle, so a stopped service reads no credential, and an unreadable switch is a refusal rather than an off switch. fugaro budget resume clears it. docs/credentials-service/runbook.md is the operator's side of all of this.

What ends a run's identity, and what is left when nothing has. A call is admitted only for a caller that is an installation job service account — the ID token's signature checked against Google's own certificates, its email claim against the installation's job service accounts — and for a run identity this project issued and that has not ended. Liveness is read from the write-once outcome, outcomes/$day/$slug/$run, which the database's rules let only the run's own end write, and never from the registry entry the run's own token may rewrite. Until that outcome exists, the identity's own fx claim (at most 30 days past the mint) is the only bound on a replayed identity: a captured call is replayable until the run ends or its fx passes, and nothing narrows that further today.

The service's own cap check is ADVISORY. The service may read a cap and refuse a call over it, but the binding cap stays the in-job gateway's ledger (D143): a per-run figure the service got wrong is not a security boundary, nothing relies on it, and a run's real spend is bounded where it always was — by the gateway's caps, by the token cap, and by the provider account's own limit (see "Money" below).

Accepted limits, recorded rather than closed (the owner's answers of 2026-10-19). The launcher's reach: a launcher writes the task text of every run it starts, and any launcher can mint a budget identity for any repository (see "Any launcher can mint a budget identity for any repository" below), so a launcher that may start a run the service admits can steer what that run does with the credential the service hands it. The replay bounds: the paragraph above — fx is the only bound until the write-once outcome is there. A shared job's reach is its profile's, and that is the residue this slice accepts (D475, G21): one account serves every repository its profile admits, so a launcher that may start a run of any repository of the profile can still mint a run identity naming another repository the profile admits, and the service serves that repository — the gate is the profile's own list and not an IAM grant, so nothing stands between the repository a run was launched for and the one its identity names. Closing it needs an identity per repository, which is what a shared project job is not. All are limits this release states and does not mitigate; the budget token's seal narrows the first for peer reads and closes none of them.

Egress is unchanged (D144). A run can still reach any host (see "Network egress is not restricted" below). What the service changes is the size of what egress can take from a job: one run's short-lived identity and the workflow's own secrets, rather than the installation's model credentials. A VPC with egress rules is a later hardening and is not built here.

And the limits this release does not hide. Three things a reader would otherwise take from this section, said plainly rather than left to be assumed:

  • the service is wired as of 0.10.1, and as of this release every agent.auth the switch admits — cascade, api-key and oauth — reaches it; vertex is the one it does not admit at all, and the mount drop reached the other two in 0.26.0 (B2.7). fugaro update deploys the service and this release gives a per-repository job its address — fugaro run sets FUGARO_CREDENTIALS_SERVICE_URL on the execution's environment, which is the one name the runner's cascade upstream and the keyless GitHub path both read — so a run's calls reach the service and are served by it, under the switch's own terms: a cascade run's where that repository's own root has been re-applied with the switch on and the installation's bundle holds a model credential, and an api-key or oauth one's where it has been and the budget mode is observe or enforce and the bundle holds the credential its runs are served under (D2071) — and a GitHub run's installation token is minted there. A vertex repository is the one agent.auth the switch never admits — the default auth, and the launcher puts no address on its job at all — so its calls go to Vertex AI on the job's own service account and no credential of its own leaves the job: nothing in that repository's runs is served by the service, and nothing about it changes in this release. What the drop reaches, and what it leaves alone (B2.7, D2072): a switched api-key or oauth repository's job declares neither the Anthropic key nor the Claude OAuth token, and its account holds secretAccessor on neither, so the credential is no longer the job's own copy while the runs' calls are the service's; every provider key the job mounts stays its own (R6, D1634), and a switched shared project job keeps every mount it had until B5.7's flip (G17). A shared project job is wired too, and it is the last job the switch reaches — the launch hands a switched profile's shared job the address on the same terms a repository's own job is judged by, and the module grants its account roles/run.invoker on the service (B5.2), so a shared coding run is served there for its profile's repositories (B5.1) — and the class's own table (FUGARO_SHARED_JOB_ACCOUNTS) is rendered by no module yet (internal/infra/tf's CredentialsServiceEnvAwaitingTheModule carries the name ahead of its module), so a deployed service refuses the class whole and a shared job's run on a switched installation is refused at the service's door and halts there (D143) rather than being served; making the class live is a deployment step of its own and is not in this release. The review-only variant of such a job is deployed with the address rather than handed it by a launch (the variant internal/infra's ProjectReviewJobs derives from every shared coding job: it mounts nothing, so the service is where its review runs' read-only token and model calls come from), while a shared Bitbucket job's address is the deployer's and not a launch's, because such a job holds no git credential at all (D2302, "The Bitbucket git proxy" below) — and a repository whose root has not been re-applied with the switch on is byte for byte what it was.
  • the GitHub App key does not move off the job in this release. The one switch that would take its grant and its mount away is config.ServiceHeldSecretNames, and it is empty until the release after the owner's live Check 96 proves the deployed service mints. So with the service on, a job still mounts github-app-key and still holds secretAccessor on it, exactly as before — while the runner, told the service's address, no longer reads the key and mints at the service instead. The grant that survives is a key no code path in the job reads; it is taken away by the flip, not by this release.
  • the launcher makes no account allow-list check of its own. A cascade launch is refused for an installation with no database, for a project policy that does not carry the switch, for a budget whose mode leaves the gateway off, for a project policy that publishes no budget.allowed_models (the service refuses every call of a project that publishes none, so the run's first call would be refused and halt it), and for a database whose rules predate the credentials family — and it is not refused for a repository no admitted account covers. Which credential a call may be given is the service's decision: the intersection of the published policy node, the repository's own published child and the account's own allow_repos, read at the moment a credential is chosen.

The pairing key's cloud copy, and who can read it

The phone's pairing key gets a third home where an installation opts into a resident orchestrator (the mobile plan's Task P5.1e, 2026-11-17; the design of record's §4.2 and its revocation step 2b). The tag over every message between a paired phone and the process that serves it is a symmetric HMAC, so the process that verifies a message holds the same key the phone signs with — and that process is not the operator's laptop in phase 2. The key therefore lives in three places: the phone's own platform secure storage, the operator's OS keychain (the item the mobile decisions fix as the laptop's copy, on the laptop machine, beside the consumer's settings which hold only the item's name), and — only where the installation has opted in — a Secret Manager container of that installation's own project, one container per installation and one version per pairing. fugaro pair writes the copy when the container is there; an installation that never opted in has no container, no cloud consumer, and pairs exactly as it did before. This widens the two-places sentences the mobile decisions carry, and the dated note is in those decisions and in the mobile plan's own global constraints, in the same words as here.

The readers are not one, and the ones past the grant are the ones that are easy to miss. The container's policy grants roles/secretmanager.secretAccessor on that one secret to the orchestrator's own service account — the per-secret grant, never the project-wide accessor, and to no other account. That grant is not the whole set, and this section names the rest rather than leaving the fence to be read wider than it is: a project Owner reads any secret's value past its own policy, because roles/owner carries secretmanager.versions.access on every secret of the project and no secret-level policy takes that away — and the operator is one of them by construction, because fugaro setup is what creates the installation's project and the account that creates a project is its Owner. Anyone who can setIamPolicy on the container or on the project can grant themselves the accessor and read it too, and so can any principal the operator later grants secretAccessor on that container. An Editor is not one of them, and this section does not repeat the wider sentence the older text carries: roles/editor carries secretmanager.secrets.getIamPolicy and delete but not secretmanager.versions.access, so an Editor reads a value directly only through a secretAccessor grant of its own — or indirectly, by deploying code that runs as an account holding one. That is the owner's ruling of 2026-10-29, and the credentials service's own section above, the brokering audit's F3 and fugaro doctor's reader check carry the same correction. (The design of record's §4.3 table still states the wider "Owner or Editor" set; the ruling is the later word, and re-grounding that table is owed to the design's own pass rather than done here.)

fugaro pair revoke destroys the version, which is what ends the cloud's half (the design's revocation step 2b). Deleting the device node takes the phone off the allowlist from its next request on, and deleting the operator's keychain item leaves nothing on that machine to sign with — but the cloud consumer verifies with the container, so a pairing whose version survived would keep verifying in the cloud after its device was revoked. The command therefore destroys the version carrying that pairing's device uid, rather than rotating it or disabling it: a disabled version is still readable by any principal holding versions.access on the parent, which is exactly the reach the readers above have. A destroy that does not land is refused and reported rather than passed over, because a version the operator believes is gone and is not keeps verifying a revoked pairing's messages.

What the deletion does, and what it does not. It ends the installation's own service's ability to verify a message and to forge one — the key is symmetric, so both follow from the one read. It un-reads nothing: every principal that held the value keeps what it copied, a project Owner among them, and a phone whose pairing was revoked keeps its own key until the app is unpaired. What the step ends is the cloud's ability to use the key, and a holder of a copy is a state this section states rather than one it reverts.

The Bitbucket git proxy

A per-repository Bitbucket job's own git traffic can reach Bitbucket through the credentials service instead of carrying a token (R1). The proxy is a route of the service and not a second service. A repository is proxied only when two facts hold: the installation has opted in — its own root re-applied with the switch on, so the job's environment names the service's address — and the published policy's bitbucket_token block admits that repository with proxy: true (G15, the block is the one source of the second fact, and a local entry that disagrees with it is refused at update). The first fact no longer needs a cascade repository as of this release (F29). The switch admits an api-key or oauth repository too, where its budget mode is observe or enforce and the service's bundle holds the credential its runs are served under (B2.2, B2.3, D2071) — before it, proxy: true was inert for every repository whose agent.auth was not cascade, because the launcher writes the address on a job's execution only where the switch holds — while a vertex repository is still not admitted by the switch at all and so cannot be proxied. On such a repository the runner opens its provider with no token, starts a loopback forwarder that carries the job's Google ID token, the run's identity and the job's name and no credential of its own, and rewrites https://bitbucket.org/ to that forwarder in the run's own git environment (G5; internal/runner's startProxiedGit). The service classifies each request against the rules, holds the Bitbucket tokens the bundle carries, and makes the upstream call itself: a git fetch or push for this one repository, or one of the Bitbucket API calls the adapter makes (G4).

The bundle may hold any mix of the three token types, and the narrowest covering one serves each request (D2350, D2355). A token is added with fugaro creds set bitbucket-token--<name> — a repository, project or workspace access token, of any type and several at once — and the command checks it against Bitbucket before it writes anything (D2352). Every request is then served by the narrowest token whose coverage admits the repository it names — a repository token before a project token before a workspace token — chosen per request, so one run can reach one repository through a repository token and another through a project token and carry several bot identities, because each token is a different author at Bitbucket (D472). A token's coverage is not permission: the operator's allow_data_to list (the node's allow_repos) is still what decides which jobs may reach Bitbucket through the service at all, and coverage is only the narrower question inside it, so coverage never widens what a run may reach (D2354). A repository no usable token covers is refused naming the repository (token_not_covered), never served by a wider token that does not admit it.

A token that fails is marked, not trusted, and the node's facts are readable by every run. A 401 that a read of a repository the token covers confirms marks that one token broken; a 429 marks it throttled until Retry-After; a 403 or a 404 marks nothing and evicts the cached project match; the legacy untyped bitbucket-token entry is never marked, because an installation holding only it keeps today's behaviour with no step (R3). The next request is served by the narrowest usable token, which can be a wider one — the stated price of the swap — and the mark lives under the token's own subtree of the credential state store (creds/tokens/<name>), so a Bitbucket token named ci is never read as the model account ci and the readers of the model marks never see it; the request that met the failure names the token (credential) and the reaction (status) on the service's own audit line, names only and one line per act, as above. No Fugaro command clears a Bitbucket token's mark in this release — fugaro accounts clear writes the model half's node and never this one — so a token bitbucket.org refused stays out of service under its own name until that node is cleared, while a replacement stored under a different name serves what the broken one covered. Each token's facts are readable by every run token of the job when they are published, and that is deliberate (F21, R5). The publisher is the plan's own task T12 (docs/bitbucket-token-types/implementation-plan.md), and it is the policy stage of fugaro update: projectpolicy.DeriveBitbucketTokens derives the key from the local config's typed records and from the identities the credential state store holds for them, and the stage writes it into the published node (buildProjectPolicy, internal/cli/init_policy_publish.go; fugaro project policy publish makes the same write). The node carries no bitbucket_tokens member until that stage runs, so a typed token stored before the next fugaro update serves nothing, and the key then carries each token's name, type, coverage patterns, the project UUID a project token is scoped to and the account UUID the check proved — never a value and never a secret version — so a hostile agent reading it learns which repositories each token reaches (a project UUID and a workspace slug are not secrets) and nothing it could use to take one; that is the same fact the bitbucket_token block's allow_repos already publishes. The identity set is trusted at the level of the node's writer (F21, R12): the set is derived from the publisher's own local config and from the state store that fugaro creds set alone writes — and it can be partial, because a repository token answers no GET /user at all, so a set that names fewer accounts than the bundle holds tokens is the honest state and not a missing entry (R14) — so whoever may edit the published node also states which accounts a comment by one of Fugaro's tokens is read as the run's own — a hand-edited config states no identity, because the identity is never read from config. And a node carrying the key is a skew (R5): bitbucket_tokens is a new top-level member, and a CLI of the previous release refuses an unknown top-level key, so such a CLI cannot launch against a project whose node carries it until it is upgraded, while a runner of the previous release tolerates the key and falls back to its single GET /user identity for a run already in flight (R5). The row naming that fallback, and what the publish does to a run in flight, is docs/design/update-in-flight.md:62 — the bitbucket_tokens half of that page's step table — and what it asks of an operator is one line: upgrade the CLI before the fugaro update that publishes a typed Bitbucket token's coverage. That step is written by the release that carries the publisher, under its For operators heading (docs/releases/v0.26.0.md); the rule is already v0.25.0's, recorded under that release's Known limits heading (docs/releases/v0.25.0.md), because v0.25.0's own fugaro update cannot publish the key.

An older service refuses the whole bundle, so the service moves first. The token family is a set of bundle keys (bitbucket-token--<name>), and the bundle loader refuses a document with a key it does not know whole — every credential in it, the model credentials included. A deployed service older than the release that knows the family therefore refuses the entire bundle while it is rolled back, which is the fail-closed direction and also the reason the order is fixed: fugaro update first, so the deployed service can read the family, then fugaro creds set bitbucket-token--<name>, which refuses to write the family at all where the deployed service could not read it (T1, T11; docs/credentials-service/runbook.md §11).

The agent can act as the run at the proxy (R3, O1). The agent shares the container and its user with the runner, so it holds the run's identity and can mint the job's Google ID token (F5); every rule below is written as if the request were hand-built, because it can be. What the proxy narrows is the run, not the agent: a proxied run reaches one repository (the repository a request names must equal the calling job account's own, G3), the run's own branch (a push may name only refs/heads/<fb>, and fb is minted for the run and matches the branch rule, G2 and G6), and the run's own pull requests (a comment on a number in the run's fpr, and any pull-request write only when its source repository is this run's and its source branch is fb, G12). A pull-request write in another repository, a merge, an approve, a decline, /workspaces, Pipelines and every path outside the allow-list are refused, and the service's audit carries names only (R2, G7) and one line per act, not per git command and not per upstream call: an allowed call is recorded once, after bitbucket.org has answered it (the read the service makes to decide a pull-request write is part of that act, not a line of its own), and a refusal once — and only once the caller's identity is verified. A request refused before that — an unreadable request, an identity that does not verify, a run whose write-once outcome already exists — is answered and not recorded, because every field of the line is the verified identity's own. There is no agent sandbox, and none is planned: what the proxy buys is a run narrowed to one repository, one branch and the run's life, with no real token in the run's own traffic — the boundary is the credential the service holds, not a separation between the agent and the run. The job's mounted copy was a different fact and it is gone with the flip (below): a proxied repository's job account holds no secretAccessor on the token and its container mounts none of it, so there is no mounted copy in that container for the agent to read out of the runner's /proc.

What ends D462's reach (D500, D506). D462 accepted, on the record, that the agent's reach is the token's reach. Two things end it for a repository whose installation publishes proxy: true, and this tree holds both. First, the run's own git and API traffic: there it is the service's credential that goes on the wire, and the run's requests reach one repository and one branch. Second, the whole job's reach: the flip that takes the mount and the accessor away is config.ProxiedGitSecretNames, and that list names bitbucket-token — so a proxied repository's job account holds no secretAccessor on the token and the container mounts none of it, and there is no mounted copy in that container to read out of the runner's /proc. What the code in the job does is unchanged: on a proxied repository the runner reads no token at all, the credential helper answers with an empty token, and every git and Bitbucket API call goes through the service. What a proxied repository still holds is the build account's copy, which the proxy does not serve and S4 ends (below): a Dockerfile can still reach the token at build time, and the flip does not reach the build's identity — it narrows the run's own container and nothing else. Every Bitbucket repository the node does not proxy keeps the mount and the grant, whichever installation it belongs to (G9), because the flip is per repository and per installation rather than a global drop, and the release's ### For operators entry names it. The flip ships in 0.26.0, the release after the proxy chain's — the chain's own is the one proxySince names, 0.22.0 — and the owner released its hold on 2026-11-16; fugaro update refuses to drop the mount until the bundle holds the token, and its refusal names the one command that stores it.

The build account still holds the token (until S4). A repository's builds and its daily image-check job clone with the build account's own copy, which the proxy does not serve, so a Dockerfile can still reach the token at build time and a rotation writes that copy as well as the bundle's. S4 is what ends it.

Cold starts, and no redundancy (D501). The service stays opt-in and scales to zero, with no minimum instance count and no probe, so the first request after an idle period pays a cold start — and for a proxied run that cold start is on the critical path of its clone, before any work. There is no redundancy beyond Cloud Run's own: a single revision serves every proxied run of the installation, so an outage of the service is an outage of every proxied repository's git access. A run that cannot reach it fails or halts named and never falls back to a token of its own (D143), the same rule the service's model half follows.

What stops the proxy, and what a cancel does not end (D504). The kill switch is what stops the service: fugaro budget kill --all or --repo <owner/name> makes it issue no credential at all, and it reads the switch before it reads the bundle, so a stopped service reads no credential and answers a typed refusal the run halts on. fugaro cancel is not that switch. It writes the run's cancel marker; the runner sees it, stops the stage it is in and finalizes a draft pull request, which it pushes and opens through the proxy. Only a run still in a stage after --grace — or one cancelled with --now, which takes no grace — has its execution stopped through Cloud Run, and a run stopped that way never reaches finalize and opens no pull request, so a cancelled run does not finish its task. What a cancel does not reach is the proxy itself, nor an identity taken before it: the forwarder is closed only after finalize, and the service keeps serving until the run's write-once outcome exists — written by the runner, or by the sweeper when the runner never got there — so a run identity and a job's ID token taken before the cancel keep working for at most the ID token's hour, which is the only bound on a replayed identity until that outcome is written.

A proxied run fetches only its own repository (O6). The proxy serves this run's repository and refuses every other, so a git submodule or a private git dependency in another Bitbucket repository — which a workspace or project access token fetches today — is refused for a proxied run. Fetch such a dependency another way, or keep that repository non-proxied.

A shared Bitbucket job holds no token at all (F12; D460, D2302). The profile is the boundary, and the job holds no Bitbucket credential at all. It serves several repositories of one profile and mounts no bitbucket-token: the deployer refuses a profile that mounts one, in the words fugaro project policy publish refuses it with, so there is no Bitbucket credential in the job for the flip to take away — the mount config.ProxiedGitSecretNames removes from a proxied per-repository job (above) is a copy that repository's runs can still read out of /proc until the list is filled, and a shared Bitbucket job has no copy for anyone to read at any point. Its git traffic reaches Bitbucket only through the credentials service's Bitbucket proxy, which pairs the verified run identity to the repositories the job's own profile admits and puts the project's workspace or project access token on the wire for the run's own repository, under the rules the paragraphs above give a proxied run: one repository, the run's own branch, the run's own pull requests, and names only in the audit. What the profile decides is everything else the job is — its service account is the profile's, so every run the profile serves shares it, while the condition on that account is the one whole-prefix condition every project job account carries, whatever its profile, because a profile separates secrets and not bucket objects (the installation-wide reach the owner accepted on 2026-10-17, stated in full under "Known limits" below) — and since one token serves the whole profile, every run of it reaches every repository the profile's allow-list names, which is the project-wide token's own reach rather than a per-repository token's. What a deployment still owes such a job is not in the provider list: the deployer's list admits bitbucket beside github (docs/shared-jobs-default's I1, and internal/infra's SharedJobProvider is the one place the deployer and the launcher both read it), so fugaro setup deploys the job for a Bitbucket profile and a Bitbucket repository's launch reaches it wherever the published policy defines a profile for its provider, admits the repository and the workflow is a clone one (a baked one keeps its own job for the image rather than for access, checkout.md) — while a repository the published policy serves no profile for keeps the per-repository job this section describes. What still keeps such a job's runs unserved is the service's own admission rather than the list: the class's table is FUGARO_SHARED_JOB_ACCOUNTS, rendered by no module yet (above), so a deployed service refuses the class whole and such a run ends at its door.

The Bitbucket read consumer

The service's second Bitbucket credential is read-only, and it is the installing person's (D361, D362, D367). Where the proxy holds the git token a run reaches Bitbucket with, this one is read by nobody but the service and is spent on one route of its own: POST /v1/bitbucket/read-token, the read mint, which mints a Bitbucket Cloud access token out of the bundle's bitbucket-read-consumer entry — the read-scoped OAuth consumer the installing person created under their own account (D367). The CLI never reads the bundle for it and never holds the consumer: a caller asks, the service mints, the token is handed back (B2). Nothing this mint returns can write anywhere, as far as that is measurable today: the consumer carries read scopes only, Q3's rule is that no Bitbucket credential Fugaro mints is write-capable, and the mint's own allow-list refuses a scope outside the read set — so the coordinator's reads and a person's are read-only at the credential, not by the callers' restraint. The allow-list refuses a scope the token answer names, and two things it cannot see are open (U11, U14): whether Bitbucket's token response lists the granted scopes at all is unmeasured, and if it does not, the allow-list refuses nothing and the consumer's own configured scopes are the whole of that guarantee; and whether the token then reaches admin endpoints beyond its scopes is unmeasured too. Both are Check 145's, owner-run and not run, so what holds the read token to reading is the scopes the consumer was created with until it has.

Two caller classes are admitted, and a run is neither of them (G4). The person class (BB4) is the installation's operators — the people list the installation's own roles derive, the same list that already mints run tokens and reads the database — matched as a bare email claim against the Google ID token the caller presents, and deliberately not its launchers, whose class is another route's and who need none of this reach. The coordinator class (BB5) is the coordinator job's own service account, and nothing else. Both are empty by default, and an empty list is a statement rather than a missing gate: the read mint then admits nobody of that class and answers every call of it with the class's own refusal. An address may not be in both — that would be one caller admitted twice, with its class decided by which list a lookup happened to read first — and a person may not be a job of this installation, a shared job, a review job, a verifier or the coordinator account, nor a *.gserviceaccount.com address, because a service account is not a human operator. Neither class takes a run identity, and neither needs one: a person holds none, the coordinator job holds none, and a caller presenting a run identity, a job name or a run's token on that route is refused by name — so no run, and no agent inside one, can reach this mint, in either class or by any of the proxy's own credentials.

One class per command, one repository per mint. coordinator show on a Bitbucket repository and a person's own local coordinator status mint through the person class; the sweep mints through the coordinator class, as the coordinator job. The request names a repository, and the mint refuses a repository in a workspace other than the consumer's by name (G11) rather than minting something narrower: what the caller gets is a workspace-read token, and it is spent against Bitbucket's own API root, never one a repository's configuration overrode — a service-minted token never goes to an overridden API root (G10). The consumer's key and secret are the only thing the service itself presents at Bitbucket's own OAuth root, in the exchange that mints the token, and they go to no other host.

What the read token reaches is the installing person's own, which is the point and the limit (D367). The consumer is theirs, so the token acts as that person, read-only, with everything that person can read in the workspace — and it stops working when that person leaves the workspace or loses their access. That dependency is the accepted cost of choosing a person's own consumer over a machine identity, and it is why the runbook makes the ownership transfer a step of its own rather than a rename. Four questions about the reach are not settled and this document claims none of them: whether the token reaches beyond the workspace's repositories (U3), whether the workspace's IP allowlisting applies to a token minted this way (U8), whether Bitbucket's token answer names the granted scopes at all, which is what the mint's allow-list refuses against (U11), and whether the token reaches admin endpoints beyond its scopes (U14). Check 145, owner-run, is what settles all four, and until it has run on a sandbox workspace the honest reading is that they are open.

Its custody is accepted and documented, not mitigated (O6, answered 2026-11-01 as B4). Whoever either class admits can obtain a token that acts as the installing person, read-only, for one named repository — a reach wider than the caller's own, and the same reach the person whose consumer it already is. What bounds it is the admission above and the record of it: the two classes, each checked against the installation's own list, and one audit line per mint, carrying names and never a value (R2, G5). What is not built is any narrowing of the token itself: there is no per-call scope reduction, no delegation to the caller's own identity, and no shorter lifetime than Bitbucket gives. That is the custody the owner accepted on 2026-11-01, and it is the reason this section exists next to the proxy's.

The coordinator job keeps its App key, and is its second holder (D365). The read mint gives the coordinator a Bitbucket read; it does not take the coordinator's own github-app-key grant and mount away, and config.ServiceHeldSecretNames stays empty, so the document above about a job's mounted copy applies to it too. The difference that makes it a second holder rather than a second instance of the same problem is the job it is: the sweep runs no agent, so the mounted key reaches no agent's process — where a per-repository job's copy is one read of the runner's /proc away.

The voice hop

A phone's audio and text can go through Fugaro's own service before they reach a provider, and that service is opt-in: an installation runs one only if it asks for it, and fugaro update then deploys and keeps it like the credentials service — one command, and no flag or second step of its own. The hop (internal/voicesvc, the installation module's voice.tf under var.voice_service) is a Cloud Run service of the installation's own, off unless the installation writes the block that asks for it: with no block the module creates no service, no service account and no invoker binding, and every project is served locally. It scales to zero (min instances 0): the first call after an idle period pays a cold start. No project reaches a provider until the installation publishes a voice policy that admits one: with no policy node — or one whose force_local is set — every project's status answer is "served locally" and there is nothing to forward. With a policy that admits a provider, one utterance's path is the phone → this service → that provider → the phone, and the property that follows is the one the design rests on: the provider sees Fugaro's own address and not the phone's, and the device holds no provider credential (the owner's ruling of 2026-10-19 refused the alternative — a provider key in the app is a third credential item on a phone). What the hop holds is the provider credential — one Secret Manager container of the installation's own, holding every admitted provider's key, read by this process and by nothing else in the tree — and the register of what each admitted provider's terms are, a table compiled into the binary rather than a value of the deployment; what it writes about a call is one line naming the act, the device uid, the project slug, the provider and the direction of a forwarded call, the provider's own status, how many bytes of its answer the caller was sent, and the outcome — and no byte of any body: not the audio, not the transcript, not the caller's ID token. The types are the fence here rather than a promise: internal/voicesvc's callLog has no field for a body, for a header or for a refusal's message, so logging one would first be a field added in a diff a reviewer reads.

The opt-in is one block in the installation root's own tfvars, and that block is the whole switch. The file is the machine's copy of the installation's root — $XDG_STATE_HOME/fugaro/terraform/<gcp-project>/installation/gcp/roots/installation/terraform.tfvars.json, by default under ~/.local/state (internal/infra/workdir.go's InstallationWorkdir) — and every fugaro update rewrites it from its own spec while carrying this key forward (internal/infra's CarriedVoiceService, and internal/cli/init.go's keepVoiceHop for a machine that has lost the file), so the block survives the command and nothing else has to be done to keep the hop. Its three members are:

"voice_service": {
  "account_id": "fugaro-voice",
  "service": "fugaro-voice",
  "image": "us-east5-docker.pkg.dev/<project>/fugaro-ghcr/<owner>/fugaro-credentials:<version>@sha256:<64 lower-case hex digits>"
}

account_id is the account the hop runs as, and it is not a choice: it is the one ID internal/infra creates that account under and the one the plan's cover classifies its single database grant by, so the module's variable accepts no other. service is the Cloud Run service's name, which the installation picks and keeps — a name is a force-new attribute of the service, so a later update composes the block from the name the installation's own outputs carry rather than from a default. image is the released binary, pinned by digest and never by a tag, the same reference the credentials service and the intake run: the hop is that binary's voice serve subcommand, and a tag is refused here for the credentials service's reason — every operator may push to that registry, and this account reads the whole database instance.

Turning the hop off is that same key written as null — "voice_service": null — and nothing else. Deleting the block does not turn it off: a missing key is a fact a run cannot tell apart from a machine that never held the file, so the run composes the block back out of the installation's own state. The null is a decision the document records, so the run leaves it alone and the plan that follows is the hop's removal — its service, its account, its public invoker binding, its database read, the accessor on the provider-key container and the one API the hop's google engine calls — and that container is the one object of the removal no flag can take: it carries prevent_destroy = true, because the keys in it are values a person typed by hand (gcloud secrets versions add, which secrets.tf documents) and nothing in this installation can put them back, the same protection the credentials bundle and the orchestrator's pairing key carry. So the null with the container in state is not a removal but a plan that fails whole — Terraform's own "Instance cannot be destroyed", rather than the guard refusing an address — and the way out is not a code edit: internal/infra's PrepareWorkdir re-extracts the terraform tree on every run (docs/design/config-transitions.md records that a hand edit to a workdir file is gone before the plan that would use it), and the plan an edit unblocked is the very one that destroys the container and every key in it. The hop comes out in the credentials bundle's two owner steps, in this order:

  1. Forget the container, in the installation root's Terraform workdir. The address is that root's state — this resource is inside module "installation", so the module prefix is not optional, and the single quotes are, because [0] is a glob to zsh:

    terraform state rm 'module.installation.google_secret_manager_secret.voice_provider_keys[0]'
    

    It deletes nothing in GCP and leaves every provider key in the container alone, and forgetting the container is what takes prevent_destroy out of the plan's way: Terraform plans no resource there any more.

  2. Then fugaro update with the null written, naming the addresses of the six things that plan still removes (fugaro update --allow-delete module.installation.google_cloud_run_v2_service.voice[0] --allow-delete module.installation.google_service_account.voice[0] --allow-delete module.installation.google_cloud_run_v2_service_iam_member.voice_public[0] --allow-delete module.installation.google_project_iam_member.voice_state_read[0] --allow-delete module.installation.google_secret_manager_secret_iam_member.voice_provider_keys[0] --allow-delete 'module.installation.google_project_service.this["texttospeech.googleapis.com"]'): the service, its account, its public invoker binding, its database read, the accessor, and the API the hop's google engine calls — apis.tf enables it on this same switch, so the null takes the enablement away too, and the address is single-quoted because its index carries double quotes a shell would otherwise read as its own. The container is not among them and neither step removes it — it is left behind with its keys, as the credentials bundle is by that service's own two steps — and a person adopts it back or deletes it by hand when they are sure nothing needs it.

On an installation with no hosted MCP front door — the default, and the one every installation that turned the hop on without it has — the removal is one resource more, and needs a seventh address. The one-permission role fugaroStateRead is the hop's reader and the front door's at once, created while either is on (state_read.tf's count = local.mcp_server_on || local.voice_on ? 1 : 0), so turning the hop off with the front door already off takes its count to 0 and the plan deletes it as well: name --allow-delete module.installation.google_project_iam_custom_role.state_read[0] beside the six above, or the refusal stops the apply and the hop stays up. There is no command and no config key that writes or clears this block today: it is a hand edit of that file, and fugaro update is the command that acts on it.

This spend is outside every cap Fugaro has. The caps and the ledger are a run's: fugaro budget counts what an agent's model calls cost, the gateway holds a run's credential and refuses a call over the run's cap. A phone's utterance is not a run — it reaches this service directly, with no run, no lease and no gateway — so nothing in the budget counts it and nothing in the budget refuses it. What bounds it is the provider account's own limit, the device node an operator can delete (fugaro pair revoke; the hop reads the node on every call and refuses the next one, which is what makes revocation take effect on the next call rather than when a token expires), and the installation's own switch, which takes the service and its grant away once its two owner steps above are both taken — the null written, and the container forgotten — and until then the plan refuses whole and nothing leaves.

The hop's account reads the whole Realtime Database instance, and that is the grant rather than the code. Realtime Database IAM has no path-level scope: firebasedatabase.instances.get is a read of any node of the instance — the same instance-wide read the credentials service's own account holds, said the same way in credentials.tf ("read any node of the instance. The only read permission there is") — so the account the hop runs as can read every device node, every policy node, creds/ — every credential's mark and every run's lease, which is credential state and never a credential: what a call is given lives in the Secret Manager bundle and not in this database — and every other node any part of Fugaro keeps in that database, the phone-facing state among them. It is given the one-permission reader fugaroStateRead, which the hosted MCP front door already holds, and never a role that could write — and that grant reaches no Secret Manager secret: the account holds no secretAccessor on the bundle and none on any job's, repository's or coordinator's secret, so this grant's reach is the database alone. The provider credential is a grant of its own rather than this one, and since P5.3.5 it is exactly one: roles/secretmanager.secretAccessor on the installation's provider-key container (secrets.tf's google_secret_manager_secret.voice_provider_keys, the literal ID fugaro-voice-provider-keys that the process carries as its own constant) and on no other container — never a project-wide accessor, which is the credentials service's role and not this account's. That container is the whole of what the hop reads outside the database, and it carries no value until a person adds one. The nodes this service's code touches — a device node under config/admin/devices/, the project's policy node, and the shared one — are a property of the code and not of the grant: a change to this service, or a bug in it, reads anything the installation keeps in the database. That is the blast radius this section exists to state, and it is what the change that added the hop was reviewed for.

And the check that admits a caller is inside the process rather than in front of it. Cloud Run's own invoker check cannot admit a phone: a device presents a Firebase ID token, which is not a Google IAM principal, so there is no principal to write an invoker binding for — the alternative, an installation-issued Google credential compiled into a phone, is the third credential item the ruling above refused. The service is therefore reachable without an IAM principal and admits a caller itself: an ID token signed by Google's published key set for this installation's Firebase project, unexpired, whose uid is a device's (m~ and 22 base64url characters; a run's identity, r~…, is refused here), whose device node still exists, and whose project's policy admits the call. A refusal on the wire carries a reason the app branches on, and never a copy of the policy or of what the caller sent.

What this state of the tree does not carry, said plainly rather than left to be assumed:

  • The hop forwards, and the app has no client for it yet. The provider call and the register of admitted providers are P5.3.5's half and they are in this binary: a paired device that the project's policy admits can have one utterance carried to the provider the register names, and the audio is forwarded as it arrives (nothing buffered, spooled, retried or written to disk, and never a second provider for a call that failed). What is still missing is the caller: the phone's own client for this service is P5.3.7, so the audio path drawn above is one this service can walk and no released app walks today. The live half of this work's verification — one device, one utterance, one provider — is not written either, so nothing here has measured a call end to end.
  • No provider key is in the container until a person puts one there, and the register's rows are unverified. fugaro update creates the provider-key container empty: secrets.tf documents the one command that fills it (gcloud secrets versions add fugaro-voice-provider-keys --data-file=<file>), which is an operator's act and no fugaro command's, and the hop refuses every forwarded call until it is done. The register (internal/voicesvc/register.json) carries a row for each provider the design read, with its directions, its terms and a per-term state — read, with the source it was read from, or unverified — and several of those terms (Deepgram's retention and training, ElevenLabs' price, every latency figure) are unverified because no page stated them: Check 85 is where they are settled.
  • A device node exists only where someone wrote one. fugaro pair writes it under config/admin/devices/ and fugaro pair revoke deletes it; a phone that was never paired is refused.

Fugaro workspaces

A workspace is a project of its own that groups member projects, and it adds an identity surface, a shared credential pool and a spend ceiling that no member had. It widens no member: a member's own lists, policy and caps are untouched, and a workspace is a grouping over projects that already exist rather than a second permission model inside one. The design is docs/workspaces/spec.md, and its §8 is the threat model whose residual risks this section states.

Four surfaces are reachable, and an earlier draft of the design named only the first — the kind of omission a threat model cannot afford:

  • the member's exchange, on each member: the member's own /oauth/authorize accepts the workspace's member-bound assertion as the sign-in proof (D1294). It opens no member's API to anyone who is not already in that member's own lists, and the assertion is bound to that one member and single-use.
  • the workspace's signer endpoint, in the workspace's own project, reached with a workspace Firebase token. It verifies that token and mints the assertion above, and it is the only place a workspace token is ever presented.
  • the workspace's credentials service, in the workspace's own project, reached by every member's job service account with a Google ID token — and, for the read mint and not for a credential, by a person of the workspace owner's own people. It is the surface that spends the workspace's money, and anything holding one of the member job service accounts can reach it.
  • the workspace's own Firebase, which is a public sign-in surface: anybody who can reach it may attempt to sign in, and Firebase decides whether they get a token. What that token is worth is still the member's own lists, so the surface grants nothing by itself — but it is a surface, and naming it is the difference between describing this system and describing a smaller one.

The workspace adds no endpoint to a member's own API — the member's /oauth/authorize and /oauth/token are the MCP design's endpoints, and the assertion is one more proof the authorize step accepts rather than a new route — and its own database is read by its own service and by the workspace owner's CLI: no member reads it.

What a stolen workspace token reaches. One thing: the workspace's own signer endpoint, which turns it into a member-bound assertion — and only for a member whose own lists name the person, and only while it is unexpired. It is never a bearer for a member's API and never a bearer for a member's exchange directly, which is the whole reason the assertion exists, so its blast radius is the set of members the person was already admitted to. The assertion is not a second theft: it is single-use (jti) and bound to one member (aud), so a stolen assertion is worth one sign-in at one member rather than a bearer to replay.

What a stolen workspace token reaches that the person did not have: nothing about a member, and nothing about the group. The member list is the one thing a signer endpoint could be built to disclose, by answering "which members may I reach?", and the design forbids it: there is no member enumeration in the token, in the assertion or in the answer, the client names the member it wants, and a member the person is not in is refused with a refusal identical in shape and timing to one for a member that does not exist. The timing half of that claim has no hermetic test: it is a property of a running server's answers rather than a value a test can read, so it is an owner-run check and this document does not claim it as pinned.

A stolen member token is unchanged. One member, its own scopes, its own caps, its own policy, until it expires: the workspace cannot mint a sibling from it, cannot extend it, and cannot revoke it.

There is no rotation here, and the design does not claim one. The MCP design's rotating refresh token, whose replay revokes the whole family, is a property of the tokens that design mints and not of Firebase's: a Firebase refresh token neither rotates nor detects a replay, and this design's workspace token is Firebase's. A theft of the workspace token is therefore not detectable by rotation; what bounds it is that the token is a bearer for the exchange and for nothing else, that the exchange refuses anyone a member's lists do not name, and that the token is short-lived.

Revocation at the workspace ends the person's ability to exchange, and nothing else, and it is bounded by two short lifetimes rather than instantaneous: the member checks the assertion against the workspace key, the project and the issuer it pins in its own config, and reads nothing of the workspace's state, because no member holds a grant on the workspace's project. A member token already minted keeps working until it expires, which is why member tokens stay short-lived, and a workspace revocation takes effect when the workspace token the person holds expires. The honest statement is that neither revocation is instantaneous across members, and the design buys both back with token lifetime rather than with a callback into every member.

A compromised member reaches the pool, and the intersection is what bounds it. A member's job service account can call the workspace's credentials service, and therefore spend the workspace's money and use the credentials its allow-list admits. It cannot read a credential's value (the service proxies a call and never discloses one), and it cannot reach a credential another member's allow-list admits and its own does not (D1298). That is the same trust a member's operator already has over that member's own credentials; grouping it means one member's compromise reaches the pool and not just that member, which is why the allow-list is mandatory and why a shared credential's allow-list should name the fewest members that need it.

The cap is a fence metered where the money is spent. The workspace's service reserves the room for a call before it makes it and settles on the response's usage, atomically in the workspace's own database, so the accounting does not rest on a member's own ledger, which a run writes under rules that forbid lowering it and do nothing to force it to rise. The figure is the workspace's and no member's: a member's own ledger stays authoritative for that member's own caps, and what compares the two is the reconciliation alarm below. The hard stop is the workspace kill, further down. What the design accepts rather than hides: the cap can be passed by at most the reservation in flight, and a failed settle refuses the call rather than serving it unmetered, so a call whose cost cannot be recorded is not served. The reconciliation alarm. A member the per-member table does not bind is reported as an alarm rather than counted as zero, so an absent binding fails closed instead of reading as no spend, and a member whose ledger and the service's own count disagree beyond a stated bound is reported rather than either figure being trusted. It is built, and it does not run yet: the limit below says which call would host it.

And the limit this release does not hide. The meter above is built, and it is not wired: nothing on this tree calls the reservation or the settle from the credentials service's paid-call path, and no answer a member gets carries the headroom header, so no code path takes them on this tree and a workspace's cap binds nothing today. The machinery — the ceiling read from the workspace's own record on every question, the reservation, the settle, the room a member is answered with — is built and tested, and the wiring that takes it on each call the service pays for is a task of its own rather than a piece this section leaves to be assumed. Until it lands, a cap a workspace's record states is a number and not a fence, and nothing is refused for passing it; what does not rest on it is the stop below, which is read before a credential is chosen. The reconciliation alarm is in the same state, and it is the alarm the paragraph above describes: budget.ReconcileWorkspace is reached from its own tests and from nothing that runs, so no member's ledger is compared with the service's own count today and a member the per-member table does not bind is not being reported to anybody. What runs today of the cap's half is the stop; the meter, the headroom and the alarm arrive together with the wiring.

What the workspace's service can read, and what it cannot. The service holds a read of each member's database, and it is worth stating at its real size: IAM on a Realtime Database is whole-database and bypasses the rules, so the one read permission the service holds on a member (firebasedatabase.instances.get, with no write permission at all) reads every node of that member's database. "Only the ledger, the policy and the outcomes" is a property of the service's code and not of its grant, and no IAM policy enforces it. A compromised workspace service therefore reads a member's whole database — its policy, its budget and caps, its run records, its outcomes — and learns each member's spend and a great deal more. It cannot write any of it: the write permission the design once contemplated was withdrawn by the owner on 2026-11-04 (O1), so a whole-database write is not a thing this service can do, and "a workspace never widens a member" is now a property of IAM rather than only of the code. What else it cannot do is what the code and the members' own projects keep out of reach: it cannot read a credential's value (the bundle is in Secret Manager, not the database, and the service proxies calls), it cannot read a member's secrets, it cannot reach a member's project IAM or its job, and it cannot delete or disable a member's database — that needs the instance lifecycle, which the narrow custom role does not carry. The runs bucket is not read at all: the storage read the old cross-check needed is not bound any more, so the service holds no read of a member's run artifacts or logs. A member's own database rules are not a mitigation against this account: IAM bypasses them. This is the design's largest accepted exposure, stated rather than argued away, and it is residual risk 5 below — which is withdrawn, because with O1's answer it is a read exposure and no longer a write one.

The stop, and what it does not reach. The hard stop is fugaro budget kill --workspace <name>, and it writes the workspace's own kill switch in the workspace's own database — one command that depends on no member's honesty. fugaro budget resume --workspace <name> clears it. The cap itself is the workspace owner's own, written by fugaro workspace cap set --workspace <name> --monthly <amount> and read back offline by fugaro workspace show <name>. What the stop does not reach is not a member's own credentials, not a member's own budget or caps, not a member's sign-in: a workspace stop stops the workspace, and every member's own switches stay the member's own.

Injection into the workspace service. The service parses untrusted text on every call — a member name, a run identifier, a bearer token — and the rules are the ones the MCP design already states: a token's content is never echoed, a member name is validated against the workspace's own record rather than concatenated into a path, and a run identifier is resolved through the member's own run list rather than used as a key.

An unattended agent as a caller. An agent's workspace token is admitted exactly as a person's, on the same lists, and the exchange cannot widen it. The limits that bound it are a member's rather than the workspace's — an agent that should only ever run in one repository is bounded by that member's own limits — and the design therefore has no workspace-level token limit to get wrong, which is deliberate: a second limit beside the MCP design's would be a second place a ceiling is decided.

What this design accepts, as residual risk. The design's independent security review returned seven findings, the owner answered all seven on 2026-11-04, and six of them remain accepted while one is withdrawn. They are numbered as docs/workspaces/spec.md §8 numbers them, so the two lists can be read beside each other.

  1. A member's operator can spend the workspace's pool within the intersection of the credential's allow-list and that member's own policy: the operator controls the member's job image and can make its jobs call the service with any request they like. Mitigation: the allow-list, the member's own policy, the stop — and, once the wiring lands, the meter the member cannot write and the reconciliation alarm, neither of which runs on this tree yet (the limit stated beside the cap's paragraph). Not elimination.
  2. A workspace revocation does not reach a member token already minted. Mitigation: the member token's short lifetime, and the short lifetime of the assertion beside it.
  3. The workspace's identity provider is a single point of sign-in: if it is down, no one signs in through the workspace. Mitigation: each member's own sign-in is untouched, so a member stays reachable the way it is today.
  4. The workspace service is on the critical path of every shared-credential call. Mitigation: the advisory headroom lets a run stop early, and the runbook's stop is one command.
  5. Withdrawn on 2026-11-04. The risk was that a compromised workspace service could write any node of any member's database, so that "a workspace never widens a member" rested on the service's code rather than on IAM. The owner removed the grant: the service holds a read on a member and no write permission at all, and nothing is written into a member's database. The read exposure that remains is the cross-project read above, and the number is kept rather than reused so a reader who meets "residual risk 5" in an earlier release's notes finds where it went.
  6. Anyone who can mint a custom token for the workspace's project can set email and email_verified to anything, and reach every member as anybody. It is not only a Firebase Auth administrator: two permissions do it — signBlob and TokenCreator on any service account in the workspace's project — and the anonymous provider is another path to a token nobody's address proves. That is what any identity provider is, and it is not a widening this design introduces, but it is the trust the workspace's Firebase now carries for every member at once, where a member's own Firebase carries it for no other member. Mitigation, and it is a real one: the workspace's signer endpoint and the member's exchange accept only the pinned firebase.sign_in_provider set — google.com and password — and refuse custom and anonymous before any list is consulted; the member's own lists still decide who is admitted; and a member that will not extend that trust to the workspace's project says which identity provider, key and issuer it trusts in the pin its own config carries, where the workspace's record names none of them.
  7. A shared credential is served where the member's own service would refuse it: the run's repository is not held to the calling job account. The workspace's service asks the repository from the slug the run identity verified and asks the member's own policy legs, so the pool serves only names the member admits, and a node stale against the policy it was derived from is refused exactly as the member's own service refuses it. What is not re-asked is the pairing of that repository with the account that called, because the per-member table names job accounts and no repository. Reaching a second repository this way still takes the member's own policy to scope the credential to it, so what it reaches is another repository of the same member, admitted by that member itself, and never another member's pool and never a repository the member's own lists do not name. The second way this risk is reachable is the account's class: the workspace builds each member's verifier from the owner's table of job accounts alone, so the shared-job gate and the review class that the member's own installation decides from its own policy are not asked, and an account the owner's table names is treated as a per-repository job on every repository the member's own lists name. Closing either is an owner decision and a column rather than a redesign, and this release ships both stated and not enforced.

What a workspace never does. The design's two rules, written as prohibitions: a workspace never widens a member — it cannot add a launcher or an operator, admit an address a member's lists do not name, raise a member's cap, run a mode a member's policy forbids, or serve a credential a member's policy excludes; it never hands out a credential — no shared credential's value is returned to a run, a CLI, a person, an error message or a log line, because the service proxies the call and the key stays with the service; it never owns a repository, a runs bucket, a job or an image, because a workspace is a grouping over projects that already exist and it holds no runs and launches nothing; it never writes a member's database, any node of it; it never becomes a second permission model, because there is no workspace role that means something in a member and the member's own lists are the only thing that admits anyone; and it carries no workspace-wide repository allow-list, because the per-repository allow-list is the policy's and it is per project.

Workspace authority over member projects

The addendum gives a workspace IAM authority over its member projects, and it supersedes three of the six rules docs/workspaces/spec.md §9 states as prohibitions. The design is docs/workspace-projects-users/spec.md, its decisions are reconciled in docs/workspace-projects-users/reconciliation.md, and the whole of what the authority reaches is stated in docs/workspace-projects-users/threat-model.md: the threat model, written at the size of what the authority actually reaches, whose independent security review the plan makes mandatory and run by the coordinator before any other task of that work is allowed to build.

What it reverses is the first, the fourth and the fifth of that §9's prohibitions — it never widens a member, never writes a member's database and never becomes a second permission model — and it reverses them for people and roles only, on one consent, and it is the member owner's own act. The consent is fugaro workspace project link, run on the member owner's own machine with the member's own config and its own credentials (D2819): the member joins the workspace's folder, or grants the workspace's service account roles/owner on its project, and nothing on the workspace's side can create that authority. Linking is what changes it, and an unlinked member — every existing one — keeps fugaro user … unchanged: linking is opt-in per member, fugaro update links nothing and changes no member's authority, and a member owner who never ran link is not reached by any command of the addendum. What the three rules are replaced by is this: the workspace's admins hold an owner's authority over every linked member, a workspace grant lands in a member's own roster and becomes that member's IAM at that member's own fugaro update, and "workspace admin" is a role that means something inside a member. What the consent's wording is not is a narrowing of its reach: the commands touch people and roles, and the authority they are given is a project owner's. In the folder model the consent has a second effect that is worth naming at link, because it is not about people or roles at all: moving the member's project into the workspace's folder changes the policies it inherits. A project takes the IAM and organization policies of the parent it sits under — a key-creation ban, a domain restriction, an allowed-locations constraint, whatever the old parent carried — and a project that moves loses the old parent's and takes the workspace folder's instead. link therefore reports the difference it can read rather than moving the project silently (WU18's acceptance).

The other three rules stand, and the first of them is the one a reader must not misread. A workspace still never hands out a credential: no shared credential's value is returned to a run, a CLI, a person, an error message or a log line, and the service proxies the call, exactly as this document's workspaces section states it. It still never owns a repository, a runs bucket, a job or an image — a workspace still holds no runs and launches nothing — and it still carries no workspace-wide repository allow-list: the scope grammar is per grant and a repository allow-list stays the policy's and per project. What the addendum adds has nothing to do with the workspace's own handling of a credential and everything to do with the people it admits: after a link a workspace admin holds an owner's authority on the member, and an owner reads credentials. That rule was never a claim that no one in the workspace can read a member's secrets, and the paragraphs that follow state what it does mean rather than leaving it to be assumed. It is not a claim about the workspace's own bundle either: every workspace admin holds roles/owner on the workspace's own project (R8, D2818), which is where the workspace's one credentials bundle lives, and a project owner reads any secret in its project — so the shared pool's keys are readable by every workspace admin, beside every member secret the paragraphs below state.

A stolen workspace-admin credential reaches every linked member, and that is the consent's real size. A workspace admin holds roles/owner on the workspace's folder, inherited by every project in it, or — on the service-account fallback — a token-creator binding on an account that is roles/owner on every member it linked (D2804, D2818). An owner is the widest authority a member's project has, and it is worth naming what that holds rather than calling it admin: it reads every secret of that member, the Secret Manager bundle's model keys and its forge credential among them and every personal Claude OAuth token the member's people stored under their own prefixes; it reads and rewrites the member's whole Realtime Database, rules bypassed, which is that member's policy, caps, kill switches, mode, limits, paired devices and run ledgers; it reads the member's runs bucket and its run logs; it writes the member's IAM, so it can grant itself or anyone else anything; and it can delete the member's project. Nothing here detects a stolen credential — it is a Google account, its protection is the owner's own, and no part of this design reads how it was used. What bounds the authority is D2823's rule that only an Admins entry which also holds the live binding is trusted, fugaro workspace user rm <email> --admin removing that binding at once (D2818), the member owner's own unlink (D2822), and Cloud Audit Logs, which record every SetIamPolicy on a member that status reads against Fugaro's own trail (D2811).

A compromised workspace IAM account is the same reach held as an account, and a key made on it outlives the binding that made it. The service-account fallback's identity exists only where a member's owner linked it that way, it is used by impersonation alone, and the root that creates it writes no key (D2803) — a fact about what Fugaro writes and not a claim that no key can exist. Key creation is held by every workspace admin, and that is R8's own grant: D2818 gives each of them roles/owner on the workspace's own project, where this account lives, and roles/owner resolves to iam.serviceAccountKeys.create and iam.serviceAccounts.actAs — so the account's key path is not outside the design's grant at all, and any workspace admin can mint a key on it with their own credentials. Beside them, on GCP, roles/editor on that project resolves to exactly those two permissions (the fugaro doctor token-signers check reports an editor by iam.serviceAccountKeys.create, internal/infra/tokensigners.go), roles/iam.serviceAccountKeyAdmin carries the key, and roles/iam.serviceAccountAdmin can grant either to itself. The account therefore has two credential paths Fugaro writes no key for and status does not read today, both of them held by every workspace admin through roles/owner: a user-managed key made out of band, a credential of the account's own that acts as it wherever it still holds authority; and iam.serviceAccounts.actAs, which roles/owner, roles/editor and roles/iam.serviceAccountUser carry (the credentials section above names the editor's pair, actAs and run.services.update), by which a holder deploys a workload that runs as the account with no key and no impersonation grant. Whoever holds a token-creator binding on the account — or holds resourcemanager.projects.setIamPolicy on the workspace project, which is what that project's owners hold and its editors do not, roles/editor being unable to write an IAM policy — reaches every member linked through the account as that member's owner, and D2823's intersection and status show that set; neither path above is in it. rm --admin removes the token-creator binding and revokes no key, so a key an admin made under their own credentials keeps acting as the account, and keeps reaching every member still linked, until it is deleted on the account or the account is disabled — gcloud iam service-accounts keys list and the account's own IAM policy are what show it, WU11's status takes both up, and the organization policy constraints/iam.disableServiceAccountKeyCreation is the one control that closes key creation outright, which no Fugaro root can set on a project it does not own. A member owner's unlink does bound it for that member: it takes the account's grant away (D2822), and the key can then only act as an account that holds nothing there.

The workspace credentials service's account can rewrite the roster, Admins included. The workspace's member list, its domains and its Admins live at workspaceRosters/<name> in the workspace's own database (R5). That project is an installation of its own, converged by the installation's roots exactly as a member's is, so five accounts hold a whole-database write on it, none of them path-scoped: the workspace's credentials service, whose custom role fugaroCredentialsDatabase is firebasedatabase.instances.get and .update (deploy/terraform/gcp/modules/installation/credentials.tf); the workspace's own service account, holding fugaroWorkspaceDatabase, that same pair, for the workspace's own service (deploy/terraform/gcp/roots/workspace/main.tf); the catalog-check job's account, holding fugaroCatalogLease — that same pair once more — where the installation carries a catalog_check, because that job's build leases are written into this database (D1554, deploy/terraform/gcp/modules/installation/catalogcheck.tf), and holding nothing on it where the installation carries none; the history account the installation's Firebase root creates and grants on every converged project, fugaro-history@<project> with roles/firebasedatabase.admin — all eight firebasedatabase.instances.* — where an empty history_account input is filled in from the project's own name (deploy/terraform/gcp/modules/firebase/iam.tf); and the coordinator's writer account, holding that same admin role on the project where the owner has opted the coordinator in (fugaro update --coordinator) and nothing where they have not. IAM on a Realtime Database reads and writes the whole instance, so any of the five reaches every node of the workspace's database, and a compromise of any rewrites the member list, the domains and Admins whole — beside the workspace's cap, its kill switch and its own meter figures. The two roles/firebasedatabase.admin holders are the wider pair: that role adds the instance lifecycle (create, delete, disable, reenable, undelete), so the history account and the coordinator's writer can also delete or disable the workspace's database, where the three custom-role accounts — the credentials service, the workspace's own service and the catalog-check job's — can rewrite it and not remove it. What it cannot do is become an admin by writing the list: writing Admins is not authority, whichever of the five makes the write — only an Admins entry that also holds the live folder-owner or token-creator binding is propagated or trusted (D2823), the workspace's commands and its drift check use that intersection, and status flags both directions of the difference between the list and the bindings. None of the five can mint that binding: none of their roles writes the workspace project's IAM policy, the credentials service holds no write on any member at all (D1299), the workspace root's plan is pinned to its own service account and its one database grant, and WU3 keeps the SA fallback's new workspace IAM account distinct from it (D2803, F20). What a compromise of any can do is make the workspace manage the wrong people — drop an entry, mark an address external, touch the workspace's own stop and cap — until a workspace admin reads status.

The workspace project's owners, editors and budget admins are workspace admins de facto. The workspace's own project is an installation like any other, so its project IAM reaches its database over IAM with the rules bypassed. Its owners and editors can write the roster whole, Admins included; only its owners can then grant themselves a token-creator binding on the workspace's own account, which takes resourcemanager.projects.setIamPolicy — roles/owner has it and roles/editor does not — and once held that binding is real, so D2823's intersection trusts them. An owner and an editor alike have the pair the paragraph above states, iam.serviceAccounts.actAs and iam.serviceAccountKeys.create: it mints no binding and leaves no Admins entry, so the intersection that makes a rewritten Admins visible sees nothing of it — for an editor it is the only route to the account, and for an owner it is the one that leaves no trace of the entry D2823 would distrust. Its budget admins hold roles/firebasedatabase.admin on that project, the whole-database write roles/owner already implies, which writes the same nodes and cannot write IAM: that is exactly the difference D2823 rests on, and it is the difference between a rewrite status shows as an untrusted entry and one that reaches a member. Stated plainly rather than argued away: the workspace project's own IAM is the workspace's root of trust, nobody who owns that project can be kept out of the workspace's roster, and what the roster and the intersection buy is that the difference is visible and that a member operation still needs a live binding, written with the caller's own credentials.

A hostile project admin rewrites the mirror and the member's audit node. A member's own admin, and any account holding the member's database write, holds roles/firebasedatabase.admin there — a whole-database write — so they can rewrite config/admin/workspace-members, the mirror the grant gate reads, landing a grant for an address the workspace's record does not list or hiding one it does; the fence is not the mirror but drift, run by a workspace admin against the workspace's record and never against the mirror (D2813). They can also rewrite config/admin/workspace-audit: its entries are create-only by construction, and they are written with the permission the roster write itself needs (D2811), so the audit trail is as tamperable as the roster — the cross-check is Cloud Audit Logs, where status names each SetIamPolicy whose binding is drift and which neither audit trail holds. What a project admin cannot do is write the workspace's own database: a member's people hold no grant on the workspace's project, so they cannot add themselves to the workspace, change its domains, or reach another member.

A hostile member owner reaches their own member and nothing else. A member's owner holds their own project by definition: they can rewrite its roster, its mirror and its audit node, remove any binding the workspace holds there, read their own secrets, and refuse to link at all. The one record of theirs the workspace's own commands read is config/admin/workspace-link, the original parent written by the member owner at link, and it is treated as untrusted input: Unlink refuses a recorded parent inside any workspace's folder rather than moving a project there, so the worst a rewritten record achieves is a refusal — a denial of the move back, never a redirection into another workspace's folder. A member's owner and its people read no node of the workspace's database; what they read of the group is the mirror, which the paragraph headed Every member's launchers and viewers read the mirror below states.

Every member's launchers and viewers read the mirror: the workspace's member addresses and external marks. Every launcher, operator and viewer of a member holds roles/firebasedatabase.viewer on the member's own project, which reads every node of its database over IAM with the config/admin deny to clients bypassed, so the mirror is readable by that member's own people — and with it the workspace's member addresses, each member's kind, and which of them are external. The design above says the member list is read by the workspace's own service and the workspace owner's CLI "and by nothing else"; the mirror is a second copy, in every member's database, readable by that member's people. It is bounded — addresses, kinds and external marks only, no roles, no grants and no per-project data, and each member's grants stay in that member's own roster — but it is not nothing, no rules change narrows it because IAM bypasses the rules, and a workspace whose membership is sensitive should know it. The same list is readable from the workspace's own side, where the workspace's launchers, operators and viewers read the roster whole and its budget admins can write it.

The revocation lag is the member's own update, and removing an admin does not take back what they made while they held the authority. Removing a workspace admin is two acts on two clocks (D2818): fugaro workspace user rm <email> --admin removes the folder's roles/owner or the account's token-creator binding at once, in the same command, so the authority Fugaro granted them is gone then — and the workspace's stored grants stay in the member's roster, with the resource-level bindings that member derives from its admin list, until that member's own fugaro update (D2801). Between the two the removed admin still holds a member's bucket, job, secret and log grants, bounded by that member's next update. What no command here takes back is the three things an owner could have made before the command ran (the owner's ruling of 2026-11-19, accepted as residual risk): a key minted on any of the member's service accounts — the member's own Terraform accounts included — which is a credential of that account's and is not revoked by anything fugaro runs; an IAM binding they added for themselves outside Terraform, which a member's own update never removes because its roots are additive (google_project_iam_member) and touch only what its own lists name; and the copied value of any secret they could read, which is every secret of the member and the shared pool's keys in the workspace's own project (R8). All three outlive rm --admin, unlink and the member's fugaro update, so removing a workspace admin is followed by rotating that member's secrets — its model keys, the personal Claude OAuth tokens its people stored, its forge credential and the run-scoped ones — and by reading the member's IAM policy for bindings its own roots did not make. status shows the second half through drift, which reports a member's policy against its roster (WU12), and carries no row of its own for a key or for a value someone copied. A member owner's unlink drops only the authority in the same way, and the stored grants stay until the workspace project's owner runs project rm (D2822, D2808) — so ending a member's part in a workspace, or a person's access to a member, takes both sides, and status says which half is still outstanding.

The hosted MCP front door, and what its audit does not record

Two events leave one structured line — a token this door refused, and a tools/call naming a tool of this installation, whatever the door answered — and the records live in a store of their own. The token records, the client registrations and the audit are objects in a bucket of the installation's own — fugaro-mcpauth-<project>, whose IAM names the front door's account mcp_server and, of what this installation grants, no other member — and never in the project's Realtime Database, where the mcpauth node stays in the rules as a second barrier with .read: false and .write: false (D935). So the store is reached by the service and not by a person, a launcher, an operator or a budget admin, and a reader of the record is one of the two doors below rather than a reader of the bucket. That store and its one member are an installation's own now, and both are Terraform: deploy/terraform/gcp/modules/installation/mcpauth_store.tf creates the bucket fugaro-mcpauth-<project> and the one binding the installation writes on it — roles/storage.objectAdmin for the front door's own account mcp_server and for nobody else — with uniform bucket-level access and public access prevention enforced, and the installation publishes the name as its mcpauth_store_bucket output. That one binding is the whole of the store's own IAM, and it is not the whole of who can read it: the project's Owners and Editors reach the bucket through their project-level roles regardless, as they reach every bucket of the installation (docs/design/bucket-iam.md §9), and GCS attaches its own convenience bindings to a new bucket — a basic project Viewer's legacyBucketReader and legacyObjectReader among them — so that Viewer gets the list and the read of the store until the bindings are stripped: whether GCS still attaches them to a bucket Terraform created is not something any test in this tree settles, and the reading that would is owner-run (docs/mcp-server/reconciliation.md §6, check 8). Taking those bindings off is a Storage IAM call of its own — internal/infra.RemoveProjectViewers, the call fugaro setup and fugaro update already make on the state and runs buckets — and its call site for this bucket is the release that turns the front door on. The bucket is created and never adopted: a bucket already held under that name in another project fails the apply rather than receiving this installation's records, and discovery imports nothing of the store's. It arrives with the front door's own opt-in (D934) and with nothing else: an installation that never asked for a front door acquires neither the bucket nor the grant, and no released fugaro update writes the flag that turns one on yet, so the front door stays off by default with no binary linking this package — what the tree carries is the code's own way of writing records into such a store and the store an installation creates for it, and what it does not carry is a binary that serves either. The line names the identity the token resolved to, the tool, the scopes the token carried, the outcome and, when the door refused, why — every field a value out of a closed set or a name, never a token, a code or a credential (ee/coordinator/mcpauth/audit.go) — and it is written before the answer goes out, with the sink asked whether it records at all before any tool is handed the call: the line names the outcome and so cannot be written before the tool runs, so a sink that records nothing is found out while a deletion is still only a request. A call this door cannot audit is not answered — the same fail-closed rule the credentials service follows (D143) — and a handler that fails while writing the line is the one fault no check can see coming: there the act has been made, and the caller is told the door could not record it. One person's calls also come to a bounded per-identity record in that store, at most 64 entries and newest first, which is what an operator reads through the get_audit_record tool; a launcher is refused that tool, and no caller of any kind reaches the objects (D933). Revocation is one delete of a token family, through POST /oauth/revoke or the revoke_family tool, and it is the same delete either way (D930).

What the audit does not record, said plainly rather than left to be assumed:

  • The per-identity record is a view, and a caller can flush it. It is bounded and it is per-identity, so 64 calls by one person erase that person's own oldest entries — the Cloud Logging line is the durable copy and the record is the readable view (the owner's answer of 2026-11-04). It is the line that has to be written for the call to be answered; a line lost after that — a sink that routes nowhere, a retention that expires — is evidence this door cannot know it lost. The record never holds another person's calls, so a caller can only flood its own.
  • A refusal is audited once a token, a tool or a call is what was refused. A refusal of the credential itself — no bearer token, one this installation never minted, one whose family was revoked, one that has expired or is of the wrong kind, an identity on neither of the installation's lists — is one line, and so is the refusal of a tools/call that named a tool of this installation: a scope the token does not hold, arguments the tool cannot read, a name the catalogue holds that nothing has registered yet (D936's spawn_task and cancel_task are exactly that), or the tool's own refusal. What carries no line is a request this door refuses before it has a tool of its own to name: a body that is not one JSON-RPC request, a method it does not serve, a tools/call naming no tool at all, and a tools/call naming a name the catalogue does not hold — a misspelling, or a name some other build of this front door serves. Each of those is answered and recorded nowhere: the door's logger line (finding M-e) is the line of a credential or a scope refusal, and none of them named one. The audit's unit is a call on a tool of this installation, and an event with no such tool is not one.
  • A request this door answers without naming a tool leaves no line, and neither does a notification. initialize, ping and tools/list are answered to a token this door admitted and are recorded nowhere, and a notification — a request with no id, which is what MCP's own notifications/initialized is — is answered with no body at all (JSON-RPC 2.0 §4.1) and leaves no line either. A client that connects, lists the tools and polls ping for a day is therefore absent from the audit: the only line such a request can leave is a refusal of the token it presented, and nothing is written about the ones this door admitted.
  • The identity in a line is what the token resolved to, and it is not proof of who was there. H1 is accepted and documented rather than closed: any launcher can mint a device token and sign in as an operator's device at the approve step (the amendment of 2026-11-04), so a line is evidence of which token was used and not of who used it. The change that would close it — a device-held signing key — is not built.
  • Revoking a family ends what that family minted, and not a person's whole access. A person holds one family per registration they approved, and each is ended on its own; the audit record names the family a call came from, which is what makes ending the right one possible, and it keeps naming it after the revocation, because the record is a record of what happened.

Shared images: what the key protects, and what it does not

internal/imagecheck computes the key a shared dependency-layer image is built and reused under (the design is docs/forge-authorship-images/shared-images.md: the key, the superset lookup and the lock are built, and the refresh, the job update and image ls are not). The key is a hash of the packages' names, versions and the integrity or checksum each key file states for that version's artifact, with the toolchain and the base, and the reduction refuses a package a file resolves from a source that is not the ecosystem's registry. What that answers is one repository's honest lockfile against another's: two repositories whose files resolve a version to different bytes get different keys and different images, and a package a file states no integrity for is keyed only when the file also says it came from the ecosystem's default registry — so a name and a version alone never stand in for an artifact.

It is not a boundary between the repositories that share an image. The files that decide what the install runs state no package versions, so they contribute no fact of the key: .npmrc and .yarnrc.yml name registries, .pnpmfile.cjs and a plugin under .yarn/plugins/ are code the package manager loads, a patch under .yarn/patches/ or one a pnpm patchedDependencies entry names rewrites a package's source before it is installed, a package.json scripts entry runs during the install, and a go.mod replace directive sends a module to another tree than the one its version names. A repository on a shared key can therefore change what the next build of that key installs for every repository already on it — the same class as the image.setup of the repository that built the key, which the others inherit (the design's §2.2) — and a hostile repository inside the installation the images are shared across is not something the key addresses. What bounds it is the assumption above: image sharing is a decision about repositories you already trust.

Two shapes key an empty integrity from configuration the file does not state. A pnpm packages entry written as a bare name@version key, with no resolution line, is keyed with an empty integrity: that format's convention is that such an entry came from the default registry, and pnpm writes no source for one. Which registry the install actually fetches it from is configured in .npmrc, which states no package version and contributes no fact of the key, so two repositories whose pnpm locks are that shape take one key even when one of them points its install at another registry. A requirements*.txt pin that carries no --hash is keyed the same way: pip's index is configuration too — pip.conf, PIP_INDEX_URL — and not a line of the file, so such a pin takes one key whichever index the install would read it from. The other empty integrities are read from a line in the file — the host of an npm resolved, a Cargo source, a uv or Poetry registry, a Pipfile entry's own index — and a source those lines name that is not the default registry is keyed only beside an integrity. A URL among those lines is read as a URL and not as text: the host is the one its authority names, so a source that carries the default registry's name in userinfo — https://registry.npmjs.org:x@evil.example/x.tgz — is evil.example's artifact and not the default registry's.

The source an image carries, and who can read it

An image built for a repository bakes that repository's checkout, and an image that bakes is source. A repository-level derived image puts the checkout at /work/repo, at the commit it was built from. A catalog entry built with the project's bake switch on (bake_repos, the policy's own boolean) is composed with one stage per repository the project's image_map puts on that entry (internal/imagebake): each stage clones that repository's checkout at /work/baked/<slug>, and it stays in the image. The stage for the build's own repository is reset to the commit the build was handed, so a push after the definition was copied cannot change what the image bakes; the stages for the entry's other repositories pin no commit — a build holds the commit of no repository but its own — and clone the head of its branch when the build ran.

Whoever holds pull on the registry the image sits in reads that source, and every job that runs the image can read it too. A catalog image is pushed to the installation's one shared registry (deploy/terraform/gcp/modules/installation/registry.tf), whose readers are each repository's build account and each repository's job accounts (deploy/terraform/gcp/modules/repo/registry.tf) — and any principal the project grants pull on it besides. The repository a run is for is not the only one in it: an image that bakes several repositories carries all of their checkouts, and the run removes none of the checkouts it does not work on — the removal docs/shared-jobs-default/reconciliation.md records as D2309 is not built — so a job of one repository reads the source of the others it was baked beside. What the layout does bound is what the run works on: a job opens the directory its own slug names and holds that checkout's origin to the repository its task names (internal/runner's openBakedCheckout and checkBakedCheckoutOrigin), so another repository's baked checkout is readable and is not what the run commits, pushes or opens the pull request from.

A context repository is never baked. A read-only context repository (docs/forge-authorship-images/implementation-plan.md, C5a–C5c) is read through a read-only clone for one run alone, outside the work tree and under a token naming exactly that run's repositories and permitting a read of nothing else (internal/runner's cloneContextRepos, internal/gitprov/github's context mint), and no definition composes one. What a bake carries is the repositories the entry serves, so a repository is baked only where the project's own map puts it on that entry, and a repository a run merely reads is never among them.

Image builds are Cloud Build cost, and they are outside the run budget (D621). A catalog build, a derived image's build and the catalog's scheduled rebuild (D1148) are Cloud Build jobs: they cost what Cloud Build charges, and budget.per_run_usd and its caps count only the model calls a run makes through the gateway. A build happens before the run that pulls it starts, and a rebuild fires from the definition's own inputs — a lockfile, the base image, the entry's setup, an age — so an entry nobody runs still costs its rebuild.

Known limits

These are real, current gaps. Each is a decision or a later hardening item, not an oversight.

  • What one run's agent can reach. On a first run the agent's environment holds:

    • the repository's git token (as a credential helper, FUGARO_GIT_TOKEN and GH_TOKEN);
    • the per-run gateway token;
    • every secret the workflow declares.

    It shares the container and its user with the runner, so it can also read the runner's environment through /proc. That includes:

    • the GitHub App's private key, which can mint tokens for every repository the App is installed on (use one App per repository if that matters to you) — unless the repository's own root has been re-applied with the switch on, where the key is the service's and the runner mints nothing in-job: that keyless path is switched on by the job's environment naming the service, and the launch of such a repository's job now does set it, so the runner reads no key and the installation token is minted at the service (see "The GitHub App's key, when the credentials service holds it" above). What is left is the key's own copy: it stays in the job — the account's accessor and the container's mount — until the release that flips the drop, and that release has not landed on this tree (the list the drop reads is empty), so a switched-on repository's job still mounts the key and the agent can still reach that mounted copy here, while no code path in the job reads it;
    • the real model and provider keys;
    • the job's service account, through the metadata server.

    On a repository whose root has been re-applied with the credentials service's switch on, the second item is empty for every workflow whose agent.auth is cascade, and empty of the two Claude mounts for one whose agent.auth is api-key or oauth (B2.7, D2072): the switch removes the model mounts, not the workflow's auth — the drop is the root's and not the workflow's, so an oauth or api-key workflow of a cascade repository mounts no model key at all for the agent to read, and one of an api-key or oauth repository mounts no Anthropic key and no Claude OAuth token while its provider keys stay, the service attaching the credential its runs are served under to each call it forwards (R6, D1634; see "The credentials service" above) — with one exception, the stage account's own variant job of an api-key repository that declares one (B2's mix, B0's ruling of 2026-11-04, design/mixed-credentials.md §11): its agent.auth is api-key, so the drop reaches it, but the CLAUDE_CODE_OAUTH_TOKEN it mounts is the credential of the stages that run on that job, which go straight to Anthropic and never through the run's gateway, so the service has no call of theirs to attach a credential to and the runner has no other value to hand the stage. That mount and the account's secretAccessor on it stay together — a job whose account keeps a grant its container no longer mounts is one Cloud Run refuses (C1.20) — while the job's Anthropic key goes with the run's, so the account's job holds its own token and no key of the run's, and the run's own job holds neither Claude credential. A switched api-key or oauth repository has that same state for the two Claude mounts and keeps the provider keys it mounts (B2.7, D2072): its runs' calls are the service's — the address is on the job's execution and the agent's own environment carries no credential of the job's — while the job's Anthropic key mount and its service account's secretAccessor on it are gone, and so are the Claude OAuth token's, so neither reaches the agent through the runner's /proc; a FUGARO_PROVIDER_KEY_* the job mounts still does (R6, D1634). The git token, the App key, the gateway token, the workflow's secrets and the metadata server are all unchanged, and a shared project job is unchanged in every one of them, this item included: the service serves such a job's runs for its profile's repositories (B5.1, B5.2) and drops nothing off the job, so every mount it had — the account's token included — is still there until B5.7's flip (G17). The one exception is a proxied Bitbucket repository's git token: on the run's own git traffic the runner reads none and the credential helper answers with none (see "The Bitbucket git proxy" above), and the flip has taken the job's mount and its accessor away, so the agent finds no mounted copy in the container and no git call of the run inherits one.

    Commands run through fugaro verify see the agent's full environment.

  • A mixed-credential run holds the review account's OAuth token in the runner's environment, the same class as the provider key it already holds. Ruled 2026-11-04, with the rung that names the account widened on 2026-11-05: an api-key run whose coder is provider-served may declare one stage-scoped Claude OAuth account and run its review, adversarial and triage stages on it, those three and no others — named by the stage's own key, or, where that stage's own model is an Anthropic one, by the project's default_claude_account (design/mixed-credentials.md §11: the rule, the threat model, and what a failed stage does). The rule is built end to end, and its tasks B1–B5 shipped in 0.19.0: the config rule and the launch (B1), the job's mount of the account's token (B2) — on that account's own variant job, which is the one job the credentials service's flip leaves a Claude mount on (above) — the stage's own environment and the managed settings that follow it (B3), the account stage's notional accounting (B4) and the run's own text for the account's usage limit (B5). The mount is the runner's, because the runner is what gives a stage its environment, and the coder's own environment is an allow-list: internal/agent/env.go's BuildEnv keeps the base variables, the auth variables and the workflow's declared secrets, while the provider key stays in the runner where the gateway reads it, so the coder's stages' environment carries neither credential. That is the whole of the narrowing, and it does not narrow the /proc read: the agent shares the container and its user with the runner, so a prompt-injected coder reads the account's token from /proc/<pid>/environ on that account's own job exactly as it already reads the provider key, the git token and every declared secret there (the flip strips the run's own credential off both jobs and leaves the account's own token where it was, above) — the same exposure class, not a new one, which is the ground the mix was accepted on. The token also becomes that job's own service account's to read (secretAccessor on that account's secret, and no other account's — the run's own job account holds none) with the metadata server still reachable, so two routes reach it. What the review stage costs is not bounded the way the rest of the run is: its calls go direct to Anthropic and never through the gateway, so there is no dollar cap of the gateway's on the stages that use it, and the credential is account-wide, shared in its rate limits with the owner's own use of the account, and revocable at the account (see "Money" below, where the same limit is stated for auth: oauth). The one mitigation that would narrow all of it is a separate job execution for the review stage, with its own container and service account; it is not built (design/mixed-credentials.md §6.4, §11).

  • A run's commit author is the launcher's claim, and its trailers are a record. With git.author: launcher in fugaro.yaml a run's commits are authored by the name and address the launching machine's local config carries (the address is commit_email, else the identity that machine launches as; the name is commit_name, else its git config user.name), and nothing verifies either: any launcher may write any name there, and only the domain of the address is checked (internal/cli/run.go): an address that is neither the launcher's own nor at a forge's noreply domain is refused, while a colleague's noreply id and login pass, and the name is checked only for the shape git's header can hold — so a launcher can write a colleague's noreply address and name and have the forge link the run's commits to that colleague's account. Nothing is signed either. The committer stays the run's own identity. Read an author on such a commit as what a launcher said about the run, not as who they are. The Fugaro-Run, Fugaro-Rigor and Fugaro-Model trailers are written into the commit's message by a hook the runner installs, reading values it puts in the commit's environment, and a run's agent shares the container and its user with the runner (see "What one run's agent can reach" above): an agent can commit with the hook bypassed (-c core.hooksPath=…), unset the environment those values travel in, or push the run's branch itself with its own token, so a commit without the trailers is no evidence that no run made it and one carrying them is no proof that the run's own code made it. Finalize counts the run's commits that lack a Fugaro-Run line and logs the count; it never rewrites them.

  • A launcher may approve a pull request their own name is on. Fugaro opens the pull request as the bot account, and with git.author: launcher the commits under it are authored by the launcher, so the forge's rule against approving your own pull request does not see them: it compares the approver with the pull request's author, which is Fugaro. Nothing in Fugaro reads who approves a pull request, so a repository that needs a second person uses its forge's own review rules (code owners, required reviewers) rather than counting on this.

  • The managed settings file only guards against committed configuration, and only with the gateway on. With the gateway on, the runner writes it before every stage, with the highest precedence, so a repository's own .claude/settings.json can't reroute the agent's model calls by itself, and the runner refuses to start a stage if anything still routes around it. With budget off there is no managed file and no routing check at all, so a committed .claude/settings.json can send the agent's calls, and the key, anywhere. Even with the gateway on, the file is writable by the agent's own user — the runner's — so a compromised agent can edit it mid-stage, or read the gateway token and the real key from the runner's /proc directly, same as above.

  • A follow-up's configuration can be stale, but its working tree isn't. A follow-up reads fugaro.yaml, agent.instructions and the review prompt from the base branch, but Claude Code still loads CLAUDE.md, .claude/ (skills, settings, subagents) and .mcp.json from the pull request's own branch, so a hook or MCP server planted there runs with the job's full environment and secrets. Review a PR's diff with that in mind before launching a follow-up on it.

  • Any launcher can mint a budget identity for any repository. The signing account that mints a run's Firebase custom token holds no roles itself, but every launcher — not only the ones who onboarded that repository — holds signJwt on it, so a launcher credential is budget write access up to the caps for every repository, not only their own.

  • A launcher can override a job's environment, and the project's policy is read from it. Anyone who may launch may pass environment overrides to jobs.run — Check 49 step 6 (added by Task 1.7, owner-run) sets FUGARO_RUN on a live job to show exactly what that reaches — so a launcher can also clear or redirect the two variables that decide whether a run reads the project's policy at all: FUGARO_RTDB_URL, the pointer to the database, and FUGARO_FIREBASE_API_KEY. Pointed at another database, or cleared, the run has no policy to read, and since project-centric mode is the published node, what it does next depends on the job it runs in: a budget-on job stops, because its launcher minted it a budget token — it mints whenever it can see a published policy or a shared budget, whatever the run's own mode — and a run launched with a token whose job carries no budget backend to read the policy with refuses rather than falling back (the same refusal a mode-on job meets when the token object has been removed from the bucket); a budget-off job of a project that has published nothing has no token and no marker to refuse on, and runs on the ceiling its job was deployed with, the same ceiling an installation that has never published a policy runs on. The budget token deliberately does not travel that way: it is a bearer credential — a Firebase custom token minted per run, whose theft is the whole attack — so it is left in the runs bucket, sealed, and never passed as an environment value, because the request that starts a job reaches audit logs. What does travel that way is the seal key, and it is a different object: the launcher seals the token object under a 32-byte key it draws for that one launch (a --retry draws a new one and replaces the object) and hands the key to the one execution it starts as the value of the FUGARO_BUDGET_TOKEN marker. The key is not a credential: it opens one object, for one run, and grants nothing by itself. Its audience is the override's, and it is named rather than assumed: the project's readers — launchers, anyone the owner has given log read (the jobs.run request reaches the audit log), and, unverified until Check 52 step 3 and Check 60 step 3 record it, anyone with execution read (run.executions.get) — and not a peer run of the job, which holds the object and no Cloud Run permission. A principal who holds both halves — the object and an override view, such as an operator who reads the audit log — recovers the token; the seal is a capability against the peer run, not a boundary against the project's readers (docs/design/budget-token-channel.md §7.1). A run parses the marker strictly, never prints its value, registers the key with its redactor before anything else, and reads the object only through the key: a plaintext object, or any object with no key, is refused, never read. The launch's own agent is outside the seal, and reaches the key the same way it reaches the others above: the marker lives in the runner's process environment — the agent's own environment is built from an allow-list and does not carry it, and every git call strips it — but the agent runs as the same user in the same container, so it can read /proc/<pid>/environ for it and unseal its own run's token. That is the run's own budget identity, the one it already spends under, and never a peer's: what the seal removes is the peer run's theft, and this residual is the agent's own token, not another run's. It is named here rather than left implicit because the seal is a capability against the peer and not a boundary against the run itself. On the Batch backend, which has no per-execution override and could only carry the key in the job definition's plain variables — a standing copy every launcher (roles/batch.jobsEditor) and the reaper (batch.jobs.get) can read back with gcloud batch jobs describe — a sealed launch is refused rather than carried. The marker is itself an environment value a launcher may set or clear: a different key unseals nothing (the object was sealed under the key of the launch that won the claim), so overriding it can only make the run refuse; and a launcher who can write tokens/ can remove the token object the marker points at (see "Every launcher can write runs/" above). A launcher is also closer to choosing which repository a run is for than the run's own refusals suggest: it can set FUGARO_RUN, the run's storage slug, and anyone who can write runs/ can write the task.json of any run (see above), so the slug-and-task pair an admission is computed from is not beyond a launcher. What stops that today, on a phase-1 job, is the per-repository job's bucket condition: the job's service account holds its own slug's prefixes, so a FUGARO_RUN override naming another slug fails at the task read, before the admission check runs, and for the bucket condition's reason rather than the binding's. Check 49 step 6 is what records which of the two refusals appeared; the binding's own live proof is the phase-3 check on a project job, Check 53 step 6 (added by Task 3.7), where the admission check is the only thing that can refuse. The run's own refusals are what a project job relies on: the slug must be the slug of the repository the task names, a remote on another provider's host is refused, and the project's allow-list is matched against the provider kind derived from that slug, never against FUGARO_GIT_PROVIDER, which may only refuse. FUGARO_REMOTE is not tied to the task's repository, though: it is where a job whose image has no checkout clones from, and everything the remote gives away is compared with the task before anything is cloned, in the admission check the run makes before any git credential is requested (internal/runner's admissionCheck, reading the remote through remoteHost, remoteEndpoint and repoNamedByRemote). Refused there are: a remote on another provider's host; one on a host no provider kind owns — github.com and bitbucket.org are the two, so a self-hosted forge is refused — because the run scopes this repository's git credential to the remote's endpoint — scheme, host and port — with no allow-list of its own; one written over http (that credential in cleartext), or one naming a port on an https remote (that credential sent to an endpoint the provider does not serve); and one whose path names a repository other than this run's, a group or project path included — task.CanonicalRepo allows a nested path such as acme/group/app, so the path is compared with the task's own repository segment by segment and refused when it differs, rather than read as "no repository" — as is any path a repository name cannot hold (dot segments, an empty segment, an encoded separator, acme/app.git;x), which is a refusal rather than a skip because git may resolve such a path to a repository this run is not for. On a project job FUGARO_REMOTE is not read at all: the clone URL is computed from the task's repository, the job's provider and the policy (Task 3.3). On a per-repository job, what is not compared with the task at all is the remote that gives the comparison nothing to read: one naming no host — an empty FUGARO_REMOTE, a local path (/srv/git/app.git, ./app, file:///tmp/app), a bare github.com with no scheme — and one naming a host but no repository path (https://github.com/). And with FUGARO_GIT_PROVIDER also unset and the remote naming no host, the provider the run opens is the one the cloned repository's own fugaro.yaml names, which is not compared with the provider derived from the slug either; where the remote does name a host, the provider is that host's kind, and a git.provider that disagrees with it is refused (the token is scoped to its own host). This is an accepted decision, not an oversight: the launcher holds the job's own credentials, and this list's first items already say what a launcher can reach. The launcher-side refusals fugaro run makes (a repository the policy does not admit, a policy newer than the binary) are advisory for the same reason — they are there to tell an operator before a job fails, and the run makes its own.

  • A follow-up's protections are hygiene, not boundaries. Pull request comments sit inside a nonce-delimited block, but a model can still follow instructions inside it; the delimiter only keeps a legitimate review comment from being mistaken for one. A resumed session is replayed as the agent's own earlier turns, outside that block, so anyone who could write to a previous run's session file can plant context there: any run of the same repository (they share the job's service account and bucket prefix), and, since 0.7.0, any launcher of the installation at all — a launcher's runs/ write reaches every repository's session files, not only the ones they were onboarded to (see "Every launcher can write runs/" above).

  • The shared issue store's own rules are hygiene between honest clients, not a boundary. A launcher's grant reaches issues/ (see "Every launcher can write runs/" above), so any launcher can rewrite or delete any issue record, its number counter, its claim or the fingerprint index the store keeps, and "a submitted record is final", "one fingerprint gets one number" and "two submitters file once" hold only among clients that follow the protocol (docs/troubleshoot-issue/reconciliation.md D1727, finding F24). What is not a boundary is not a hole either: a public post is rebuilt, previewed and re-redacted by the submitter's own binary from the record that machine wrote and read, so a rewritten record cannot make anyone file text they did not see and approve. fugaro issue mine reads further than a record's own fields, and that reach is the same write access. Who reported an issue or a regression, and how many people hit it, are read from names: the reporter index under issues/reporters/<digest>/ and the occurrence names under issues/occurrences/<NNNN>/<digest>/<time>, which any launcher can write for any digest. A launcher can therefore forge a report or a regression attributed to a person, delete an occurrence to lower a count or inflate it to raise one, or make the view point at issues that person never hit — what changes is which rows somebody's listing shows them, and the status and also hit by N other(s) count beside each; never a name, because other reporters are counted and never named and the user is never among the counted. A forged resolved record or resolved_in says "fixed in" a release that fixed nothing, and it can put the update nudge on a row that does not need one, since the nudge is this machine's own comparison of the release the record names with the version it runs. What the forgery does not do is spread: mine writes what this machine has of its own — the pending issues its sync uploads before it reads — and a record it read is never written back. The retry suggestion comes from a local file, so it is the reader's machine rather than the bucket. A covered row offers the command this machine's own issue file recorded for the failure — matched to the row by number and fingerprint, and printed only if it is a fugaro command this build's own tree answers to — so anything on that machine that can edit that file can put a command in front of its owner, the same exposure the update retry line already has; nothing is run for them. And the resolved list is that same write access read back out. Any launcher can mark any issue resolved with any resolved_in, and the next fugaro update or fugaro runs digest prints it as a fix this project got — a wrong "fixed in" line in front of an admin, and fugaro issue mine telling a reporter they are behind a release that fixed nothing — while the regression flag for that issue goes quiet, because a fresh report of the same failure is matched to a record that already reads resolved. The same record carries the command that failed: where the machine running the update has no issue file of its own for that issue, the shared record's text is what the update prints, labelled as coming from the shared record and with no suggestion to rerun, and accepted only if it is a fugaro command this build's own tree answers to — a command-and-flags check, which a shared fugaro update --forget passes. So a launcher can put a plausible command in front of an operator's eyes. Nothing is ever run: what the forgery buys is a displayed line and a wrong "fixed", never an action.

  • A proxied network's credentials reach the agent. HTTP_PROXY and HTTPS_PROXY pass through verbatim so the agent works on proxied networks; NO_PROXY does too, except that with the gateway on the runner adds the loopback addresses to it. A proxy URL with user:password@ embedded is as readable to the agent as any other variable. Authenticate your proxy by network or identity, not a URL credential.

  • Network egress is not restricted. A run can reach any host. Prompt injection through the repository, a dependency, an issue or a PR comment could send source code or the credentials above anywhere. A VPC with egress rules is a later hardening option, not built.

  • The base branch is protected only by your branch protection. The runner pushes only to fugaro/<run-id> branches, but the agent holds a token with contents write and can run git push itself. Require reviews and status checks on your default branch: Fugaro relies on it.

  • The agent can open or edit pull requests itself with gh. Its instructions tell it not to; nothing technical stops it.

  • Money. The gateway's caps bound a run that goes through the gateway. An agent that reads the real key from /proc can spend outside it. The backstop is the provider account's own limit: set a credit limit on every key you give Fugaro (Anthropic workspace limits, OpenRouter credit limits; Vertex has none to set, see "What is not on by default" above). With auth: oauth there is no gateway, only the token cap and the kill switches. A run's budget identity can reserve, up to the caps, until it expires (job timeout plus about an hour), even after the run ended. A cascade run of a per-repository job has no model key in its /proc to read (see "The credentials service" above), so its calls all go through the gateway and the caps bound them — but the service's own cap check is advisory, not a second boundary: the binding cap is still the gateway's ledger, and a subscription tier has no dollar cap to set at all.

  • An artifact run's compute is not capped. The budget's caps count model dollars (docs/design/m9-spec-v3-reconciliation.md §7.4's reconciliation), and a render is compute: it is bounded by the run's own clock (timeouts.total, and a Cloud Run task timeout of total + 2m) and by the workflow's resources, never by budget.per_run_usd. result.json's cost.compute_usd is an estimate, reported and never charged. If you give an artifact workflow 8 vCPU, a two-hour total, and a command that never finishes, you pay for two hours of 8 vCPU and the caps will not stop it.

  • Runs of one repository can see each other, and the 0.7.0 bucket IAM work does not change that. They share a service account and its bucket prefixes, so a hostile run can read or overwrite another run's records and caches in the same repository. docs/design/bucket-iam.md is explicit that a compromised agent inside a run is unchanged by that work; it narrows what launchers can write (see "What is not on by default" above), not what a run's own job account can reach. A shared project job widens that from one repository to every repository in the runs bucket, not to a profile, and that regression is stated here. Phase 3's module (deploy/terraform/gcp/modules/project/, design docs/design/project-centric.md §4.1) creates one Cloud Run job and one job service account per (profile, provider, Claude account), and fugaro setup creates one for every profile a local config names. Such an account serves every repository admitted to its profile, so its runs-bucket grant cannot name one slug: the condition covers the whole of runs/, cache/ and locks/, and, read-only, the whole of tokens/ (roles/storage.objectViewer, never objectUser, so a project job can read a queued run's sealed token and neither delete nor replace it) — every project job account gets those same conditions, whatever its profile, and it reaches every repository's objects in the bucket, including repositories on other profiles and repositories that still run their own per-repository jobs. That is a loss of a property this document credits 0.7.0 with gaining (above: 0.7.0 removed "poison cache/" and "forge or steal locks/" from what a launcher can do). A run is an untrusted agent, unlike a launcher: a hostile one on a shared job can poison another repository's cache — cross-repository code execution on that repository's next run, since a cache it restores is code and configuration the run executes — forge or steal a lock, and rewrite another repository's queued task.json, which is what a run's task, ref and workflow are read from. Two more things the same prefixes reach, neither of which the design's accepted decision D4 listed on its own: another run's launch.json and result.json, which is why the runner checks the execution it was launched as (CheckRunExecution; plan Task 3.4) — and another queued run's budget token (tokens/<slug>/<run>/budget-token), which is the one object this no longer covers, because its channel is sealed (docs/design/budget-token-channel.md, both halves built for 0.9.0): the token object lives under tokens/, where a job's grant is read-only (roles/storage.objectViewer, so a run can neither delete nor replace a queued run's token), and it is sealed under a key only the execution it was minted for receives, so a run that reads another run's object — today a run of the same repository, and on a shared job a run of the same profile — reads ciphertext it cannot use. That is a capability, not a boundary: the peer can still read the bytes, and a peer that hands them to someone who also holds the key's audience (above: the project's readers) has handed over the token. The read-only take leaves the object in the bucket until the lifecycle rule removes it (a day), and the token inside is exchangeable for an hour after the mint, so a copy taken together with the execution's key stays usable for that hour. It is an accepted decision of its own, D13, ruled by the owner on 2026-10-15, whose open decisions D14 to D19 were answered the same day. A profile separates secrets, not bucket objects. Different profiles are different job service accounts, so a profile decides which secrets a run can read; it does not keep one repository's run away from another repository's runs/, cache/ or locks/ objects, because the object layout is <prefix>/<slug>/… with no profile in it and so no per-profile condition can be written. Putting repositories that must stay apart on different profiles therefore does not isolate them in the bucket. D4's and D13's rulings named separate profiles as the mitigation on the premise that a profile is a bucket boundary; that premise does not hold, and the owner ruled the question on 2026-10-17: the installation-wide reach is ACCEPTED, and this paragraph is the statement of it. Every shared project job's service account holds roles/storage.objectUser on the whole of runs/, cache/ and locks/, and roles/storage.objectViewer (read-only) on the whole of tokens/ — the same conditions for every profile's account, because a condition can name no slug and no profile — so a run on a shared job reaches every repository's objects under those three prefixes: every repository of its own profile, every repository of every other profile, and every repository still running its own per-repository job. It is accepted with the exposure above stated in full rather than with a mitigation claimed for it. What it is accepted for: one job account serves one profile's repositories, so a condition that named one slug would refuse every run of the profile but one, and the alternative — a profile segment in the object layout — is a breaking change to the path every installed CLI and job reads, and is a later change rather than this phase's. What bounds it: the reach is a run's, and a run is already the untrusted party here (this is one repository's job account's own reach — poison its own cache, forge its own lock, rewrite its own queued task — widened to the installation's repositories); an installation that names no profile in its config gets no coding project job of a profile and keeps its per-repository grants, but it is not outside this reach: the credentials service — which every fugaro update deploys — deploys the service's own review-only job there too, one job and one account per provider (standard/github/default wherever the local config records exactly one GitHub App ID, and standard/bitbucket/default wherever it records a Bitbucket repository — internal/infra/projectjobs.go's implicit review variant, pinned on the plan by TestGoldenImplicitReviewJobIsDeployedWithoutProfiles), and that account carries the same whole-prefix grants a shared job's account does. What bounds that one is the launch and not the grants, and the launch reaches it: fugaro review --pr N resolves the review onto that job for a repository whose workflow resolves no shared project job (internal/cli/review.go's implicitReviewJobFor, which the runner places through matchJobName), so a review run of such a project holds the whole-prefix reach above — a review is not a lesser run, and its agent runs in a container that mounts nothing while its account carries these grants. This paragraph used to read the other way and said the job was deployed with nothing launching it, which held until the release that added the installation's implicit review job; docs/design/bucket-iam.md §3 carries the same correction. Which repositories such a launch admits is answered by the credentials service and the published policy's admissions, never by the bucket's conditions; and docs/design/bucket-iam.md §10 states the threat model, including the token exposure D13 accepted. Repositories that must be kept apart are not kept apart by profiles, in the bucket or in budget identity: the only bucket isolation today is not deploying a shared job. D4 and D13 are the owner's decisions in docs/plans/2026-10-14-project-centric.md, and the 2026-10-17 ruling is recorded in docs/design/bucket-iam.md §3 and §10.

  • A project job holds its Claude account's OAuth token, and every run of that job holds it too. Phase 3 deploys one Cloud Run job and one job service account per (profile, provider, Claude account) (gcp.ProjectJobName, internal/infra's ProjectJobs), and a profile's claude_accounts: list decides how many it has: every listed named account gets a job of its own whose container mounts that account's token (claude-oauth-token-<name>) as CLAUDE_CODE_OAUTH_TOKEN, and the profile's no-account job — the one job every profile keeps, whatever it serves (D9) — mounts the default account's unsuffixed claude-oauth-token exactly when the profile lists default (docs/design/project-named-oauth-tokens.md §4.3, D5). The mount is static and it is the platform's: the value is in the job's container, not in the run, so it is there from the start of every run of that job and no run can decline it. Each account job's service account holds secretAccessor on its own account's secret and on no other account's, and that is the whole of who can read a value: no launcher's own credentials read it, and the launcher's gate decides which job a run may be started on from the published policy and the run's own configuration, and never reads, seals or forwards a token (design D2; a read would need secretAccessor, which only the job and build accounts hold, see "Every launcher can write runs/" above). What a launcher can do instead is start a run on the job that holds the token, and a launcher is trusted: it writes the task text of every run it starts, so a launcher that may start a run on an account job can send a run that reads the token and hands it back — reaching the token that way is reaching everything the token can do (design D2; project-centric.md's D10, "launcher environment overrides: accepted and documented"). What bounds that is the account's list and not the launcher's credentials: only the repositories in accounts.<name>.allow_repos (published from claude_accounts.<name>.allow_data_to) are given that account's token, so the launchers of those repositories are the ones who reach it. What follows is this feature's own cost, stated by the design in §6.1:

    • A hostile run can use the token during its own run, and after it. The agent shares the container and its user with the runner (see "What one run's agent can reach" above), so a hostile run — or an agent talked into it by the repository, the task text or a comment — can read the token, copy it into an artifact, a pull request body, a commit or a log line (the redactor masks what Fugaro itself publishes, and is not a boundary), and use it until the owner revokes it. Nothing prices an OAuth run the way the gateway prices a provider-key run: there is no gateway in front of it and no per-call cap on it, only the token cap and the account's own usage limit ("Money" above).
    • The account is the blast radius, not the repository. claude_accounts.<name>.allow_data_to, published as the policy's accounts.<name>.allow_repos, decides which runs are given that token — the launcher's gate before any claim is taken, and the runner's own re-check before any stage, lease or budget spend, independently of the launcher — and neither of them scopes what the token can do. A repository the list admits gets a credential that speaks as that Claude account for every repository in the list; a repository the list does not admit is refused by both.
    • A profile that lists default gives that token to every run of its no-account job, whatever that run's agent.auth is. The token belongs to the job, so an api-key or Vertex run of that job holds the default account's token even though its own configuration selects no Claude account at all, and the account's list bounds it the same way (that the profile's list and the account's agree is the subset rule's business, projectpolicy.validProfileAccounts). That is documented rather than refused, deliberately: the same rule keeps an Anthropic API key off a profile that lists Claude accounts (design D4 — projectpolicy.validProfileAccounts, enforced when a policy is published, when fugaro setup builds the jobs and when a published node is read; fugaro validate is not one of the three — it reads the published node for the cascade's own switch and for nothing this rule covers), so such a profile's runs are OAuth or Vertex runs, or api-key runs under the gateway, where the Anthropic key is optional and a call that needs it is the gateway's to refuse rather than the launch's (agent.BuildEnv) — and the residual is a Vertex run, or one of those api-key runs, holding a token it does not use. fugaro doctor names the job, the account and the token for exactly this case, so an operator meets it without reading this file.
    • This carrier is a stopgap. It is the same static secret_env mount a per-repository OAuth run already uses, chosen because it needs no new mechanism (design D1), and it is replaced by the credentials/security service (docs/credentials-service/README.md, spec), after which no job mounts the token at all (design §4.6; the service as built is "The credentials service" above, and its operator side is the runbook). The swap changes the mount and nothing else: no job is renamed, and the policy block, the profile field and both gates stay as they are. It is not done in this release, and this bullet is the reason to say so here rather than only there: the switch takes a per-repository job's model mounts and accessors away (see "The credentials service" above), and it takes nothing off a shared project job — projectAccountMount still adds the entry, and what the phase-3 module carries for such a job is the switch's other half, its account's roles/run.invoker on the service rather than a drop (B5.2) — so a shared project job keeps mounting the account's token with the service on. What the service does with the class is serve it, for the repositories its profile admits (B5.1); what no installation has yet is the class's own table, so a shared job's run there is refused at the service's door until the deployment that renders it lands (above).
  • Follow-up runs act on pull request comments from the people in followup.trusted on the base branch (and, on GitHub, only owners, members and collaborators among them). A trusted person who quotes an untrusted comment passes it on. A follow-up's agent gets no git credential and no GH_TOKEN in its own environment — the runner fetches and pushes the branch itself, and the comments arrive in the prompt — but it still shares the container and user with the runner, so it can read the token from the runner's /proc, the same residual as the model and provider keys above.

  • The managed deployer exists in every installation, and its fence has not been measured. Every owner-run fugaro setup or fugaro update plans a fugaro-deployer service account (deploy/terraform/gcp/modules/installation/deployer.tf), belong included, and grants each principal in the installation's operators list roles/iam.serviceAccountTokenCreator on that account alone — so an operator, and nobody else, may impersonate it. It holds one unconditioned custom role on the project, fugaroDeployer, of create and read permissions (including iam.serviceAccounts.create, run.jobs.create, storage.buckets.create and serviceusage.services.enable), and no conditioned project role unless the installation uses managed projects, which is what sets the module's managed_deployer_scoped: the creating run writes it from the project's own creation fact for an installation that uses managed projects (internal/cli/init.go's installRoot), so such an installation gets the seven conditioned roles and their seven bindings, and an installation that never asks for managed gets the account and the unconditioned project role and no conditioned role at all. It also holds a ninth grant that is not one of those project roles and carries no condition: roles/storage.objectAdmin bound at the bucket level on the managed state bucket gs://fugaro-managed-tfstate-<project> (internal/managed/statebucket.go's EnsureManagedStateBucket, docs/design/managed-deployer-fence.md §3's F4a). That one is not gated on --managed or on managed_deployer_scoped: fugaro setup's D77 step writes it, on the operator's own credentials, for every project the creating run creates — belong included — and a fugaro setup that creates no project writes nothing. What confines it is the binding's scope, not a condition: it is bucket-level, on that one bucket, where a project-level roles/storage.objectAdmin would reach every bucket in the project. No condition can narrow it, because the state bucket deliberately does not carry the fmgd- prefix the seven conditioned roles admit — a condition that named the state bucket would put the state inside the fence around those seven. What the account is for is a feature that ships in 0.10.0, with its fence unmeasured: internal/cli's managedDeployerShipped is true as of 0.10.0, so the creating run with --create-project --managed, fugaro managed apply and fugaro restore are available, and a managed apply runs as this account (the operator impersonates it, on the project authority they already hold; it is the deployer that holds no project IAM authority beyond its own role and the seven conditioned ones). What is not settled is whether the fence works: no Check 68 run has shown that IAM accepts the seven conditioned bindings or honours resource.name per type, and that measurement is owner-run after the release. The fence, now that it ships, is seven conditioned roles — one per service, each bound once — whose conditions admit only names carrying the reserved fmgd- prefix, using resource.name.startsWith where the front of the name is fixed and resource.name.extract("<template>").startsWith where a middle segment is not knowable before apply — the extract templates are the form the design records — literal text around one placeholder, anchored at the collection segment the resource's own name follows ("/secrets/{secret}", "/jobs/{job}"), never the whole resource path — and the design holds that grammar UNVERIFIED: it is this repository's reading of the reference, and no source in the tree quotes the reference's text (design docs/design/managed-deployer-fence.md, §3's C6/C7 rows and option 1). One thing about it is unverified, and this document does not claim otherwise: whether IAM honours resource.name at all for an IAM service account, a Cloud Run job, a Cloud Scheduler job, an Artifact Registry repository or an API key — this is what Check 68 of docs/gcp-live-checklist.md, written, owner-run and not run, measures per service and in both directions. If it is not honoured for those five services, then the fence is Cloud Storage and Secret Manager and nothing else: a condition whose resource attribute cannot be evaluated is never satisfied, so those five roles grant nothing at all — fail-closed, and not a fence. And the Secret Manager half is measured, not expected: the name-prefix conditions this repository has measured live are Cloud Storage's (Check 32, RUN 2026-10-14) and Secret Manager's (Check 52's U3, RUN 2026-10-16: the condition is honoured — a read inside the prefix was allowed and one outside it denied). The other half — whether a name that does not carry its extract template's literal text fails closed rather than open — is UNVERIFIED, and this document does not claim otherwise: under the reading the design records, the call extracts the empty string, the empty string does not start with the prefix, and the condition denies. The tree models exactly that (internal/infra/tf's extractSegment) and pins it with the fail-closed rows of TestDeployerConditionFencesOnlyTheManagedPrefix — but extractSegment is this repository's reading written down rather than evidence for it, and no live step can construct the mismatch, so Check 68 cannot settle it either (design §3's C6/C7 rows, §9). Until Check 68 has run and passed, do not read the prefix condition as a boundary. A permission whose condition Google does not honour is dropped from the role rather than granted unconditioned, so an unsupported service costs the feature that type, not a hole. And what the fence does not do: it constrains the program's apply path, not an agent that goes around it — the agent's session holds the operator's credentials, which can impersonate the deployer (design §6 item 4).

  • The managed gate records what it used to refuse, and the record is what a reader has afterwards. The gate belongs to fugaro update on a managed project — fugaro setup applies its Terraform with no gate at all, and a project that is not managed keeps the confirmations and the coding agent's refusals it had, and leaves no record — and since the owner's ruling of 2026-11-07 (D1545, docs/no-prompt-policy/reconciliation.md) that gate is audit-only for what a plan contains: a resource type outside the managed allow-list, a role granted to a principal the grant table does not carry, a delete or replace of a type the classification does not call data-bearing, a blocked cost attribute, and a creation fact that records no budget amount are applied — the step prints the rules that fired, and they are written into that step's audit record in the installation's bucket. What still refuses is the integrity class (a saved plan that changed after the gate, a creation fact that does not say managed, environment injection, the managed configuration rule, the pre-init refusal of backend, cloud, provider_meta, ephemeral and action blocks, an address named on the command line, the symlink and nesting bounds, the impersonation checks, and the marker checks, which fail closed) and D1551's rule: a delete or replace of a data-bearing or unclassified type refuses. Two consequences are stated rather than left to be assumed: the gate is not a boundary against an agent that goes around it, so an out-of-table IAM grant applies, and the identity that applied the plan is the identity that could delete the record. The bucket is versioned, so a deletion leaves a noncurrent version of the record rather than erasing it — the object role is what erasure costs — fugaro doctor prints the newest record that carries warnings, over the two days it reads (today and yesterday), and the independent review of the IAM and cover code is the pre-apply control this decision rests on.

The VM backend, and the Docker daemon it gives a run

Fugaro can run a workflow on Cloud Batch instead: one VM per run, for workflows that ask for docker: true. It is opt-in per installation: the project config's backend: cloud-batch is a name this build accepts, and fugaro doctor is what judges an installation that selects it — the backend's own checks, from the Compute and Batch APIs down to the reaper that sweeps its VMs, must pass or doctor fails, and fugaro setup --provision-batch is what provisions them. Doctor is a report and not a fence around the launch: fugaro run reads none of those checks, so a run launched on an installation that named the backend before it was provisioned goes out anyway, carrying the two hazards this section is about — the run's output stays in the project's _Default log bucket, which every project viewer reads, instead of going to the installation's own log view, and its VM is left to the job's own duration instead of being swept. Read fugaro doctor on the installation before the first Batch launch: it is what tells an operator which of those checks is missing. The details are in docs/design/compute-backend.md §3.

  • A run that asks for Docker is root on its VM. The recipe mounts the VM's Docker socket into the container and adds the container's process to the socket's group (§2.2). Access to that socket is root-equivalence on the VM: docker run --privileged -v /:/host is the VM's filesystem, its service-account token and its network. It is not a new secret exposure inside the run — the agent already shares the container and its user with the runner and can read the runner's /proc (see "What one run's agent can reach" above) — but it is root on the host the run stands on, which the Cloud Run path does not have: there a job is a container with no daemon and no root.
  • That root is not the agent's alone — it is every command the repository gets to run. The socket is mounted for the whole run, so a docker call in the repository's own scripts, a test that starts a container, a Dockerfile's build steps, a Makefile target, a package's post-install step — anything the workflow or the repository causes to execute — reaches the same daemon with the same power as the agent's own commands. Fugaro makes no distinction between them: a run that asked for docker: true asked for the repository's code to have root on the VM, not only for the model to have it. Treat docker: true as a statement about the repository: enabling it for a repository whose code you do not review is enabling root-on-a-VM for that code, and the container boundary the "Out of scope" note below draws is the container, not the VM.
  • The VM is the isolation unit, and it is never reused. One run, one VM, deleted on every exit path. Nothing at the OS level crosses from one run's VM to another's: separate VM, separate kernel, separate Docker store. That is stronger than Cloud Run's shared job against other runs, and weaker than it against the host, which on Cloud Run does not exist.
  • The IAM boundary is unchanged. A VM runs as the job's own service account, at the same granularity project-centric D4 already accepted: by default the account of the (profile, account) pair, so every repository on that profile runs under one account, can read every object and secret that account reaches, and can poison another repository's cache and locks. A per-repository service account is expressible on this backend and would restore the per-repository boundary for the repositories that opt in; until an installation does that, the cross-repository loss is exactly what it is on Cloud Run's shared job.
  • The metadata server is reachable, by the agent and by every container it starts, so the VM's service account is one request away.
  • Root can outlive its own runner. Through the socket the agent can stop or kill the runner's process on the VM, and the VM keeps billing until the job's maxRunDuration or the sweeper's teardown ends it. It can also leave containers running that no Fugaro code knows about. That is why the VM, not the runner process, is the unit that gets reaped, and why a leaked VM is found by the sweeper and deleted.
  • The reaper is a scheduled sweep, and the account it runs as is a janitor's by construction. A leaked VM is ended by the sweep and not by the run, and the sweep is a process: fugaro reaper runs internal/backend/batch's reaper once, in a Cloud Run job the compute module creates for it, started by a Cloud Scheduler job every fifteen minutes — ReapMargin, so a job that should have ended is swept at most one margin after it should have. The Cloud Run job runs as the reaper account (a dedicated, project-wide account that shares nothing with the launcher's or the job's), and that account's project role holds exactly five permissions — batch.jobs.list, batch.jobs.get, batch.jobs.delete, compute.instances.list, compute.instances.delete — with nothing that can create a resource: no batch.jobs.create, no compute.instances.create, no setMetadata. It holds one grant besides that role, and on a single resource: roles/run.invoker on the reaper's own job and no other — run.jobs.run, which is what starting a job execution takes — because the Scheduler job mints its OAuth token from this same account. So the account can start the sweep it runs as and nothing else: it can still create no Batch job, no VM, and no execution of any image or command but this one. The role is a custom one because the predefined roles that name these verbs are far wider: roles/batch.jobsEditor carries batch.jobs.create — the power to run any container in the project, which is a launcher's power — and roles/compute.instanceAdmin.v1 carries compute.instances.create and the rest of the instance lifecycle, including the setMetadata that is how SSH keys reach a VM. So a mistake in this component ends resources; it never starts them. Its reach is wider than its name suggests, and the reason is IAM's: no condition can say "only jobs and VMs labelled fugaro", so the five permissions are project-wide and the account can delete any Batch job and any VM in the project. What makes that acceptable is on the code's side, below.
  • What the reaper refuses is what makes its reach acceptable, and the refusals are the review's subject. It deletes an instance only when it carries both this installation's fugaro=managed marker and a fugaro_run label, and only when no job the pass did not clear carries that run — that is, the run's job reached a finished state, or no job in the listing mentions the run at all — and the instance is in the reaper's own region and past the age floor. "Not cleared" is wider than "not running", deliberately: a job the pass refused to act on (an unknown state, an unreadable creation time, two label fields that disagree about the run) may still be running, so its VMs are not this pass's either, and a refusal never hands the VM it just declined to explain to the instance pass; a job this pass or the queue deadline deleted is not cleared for that pass either, because Batch tears a deleted job's VMs down itself and deleting them in the same pass would race that. Only a finished job, and a run no job in the listing mentions, frees a run's VM. It deletes a job only when the job has sat in QUEUED past the queue deadline (and the reaper reads such a job back before deleting it, so a run that started in between is never the one erased), when it is stuck past every deadline it could legitimately have had, or when it is stuck in DELETION_IN_PROGRESS. Everything else is refused and named in the report: a job or VM whose time it cannot read, a job whose state this build does not know, a job whose two label fields disagree, an instance young enough that Batch may simply be mid-teardown, a VM whose run label it cannot match, and anything outside the project and region the job was pointed at. A reviewer answering "what does it delete that it should not?" from this paragraph alone should compute the queue-deadline slack: the deadline is the installation's longest task timeout or a run's own ceiling, whichever is longer, plus the launcher's slack, and that margin is the whole of the defence against deleting the VM of a run that was still starting. The report — one line per action and per refusal, naming the target and the reason — is what the Cloud Run job prints, so it reaches Cloud Logging under the job's own fugaro_role=reaper labels; a pass that errored prints the part it finished and exits non-zero, so a partial sweep is never read as a clean project.
  • The budget caps stay model-only, and bypassable. The gateway's caps count model dollars and are enforced in-process by fugaro exec. An agent that holds the provider key — on this backend, every container it starts can read it from the host — can call the provider directly, off the gateway, and nothing halts it. The VM's compute also keeps billing after the runner is gone. The backstop is the provider account's own credit limit, the same one "Money" above names.
  • Who can launch, and what that reaches. On Batch a launcher needs roles/batch.jobsEditor on the project, plus roles/iam.serviceAccountUser on the account a job names. A project-level batch.jobsEditor is not confined to Fugaro's repositories, images or commands: a launcher can create a job with any image, any command and any secret it can name, running as any account it holds serviceAccountUser on, and can cancel or delete any job in the project, including another launcher's. The Cloud Run path is narrower — a launcher runs one named job per (repository, workflow), so the image, the command and the environment are the job's. Enabling this backend trusts launchers further.
  • Egress is unchanged. A run's VM has no external IP, but egress is still unrestricted: the agent can send whatever it can read anywhere the network allows, exactly as the Cloud Run path does ("Network egress is not restricted" above).

Running Fugaro on repositories with external contributors

  • Do not launch runs whose task text you copied from an untrusted issue or comment without reading it: the task is an instruction the agent follows.
  • Keep followup.trusted to people with write access.
  • A first run or follow-up gives a fork's pull request no special handling at all. If such a run checks out and executes a fork's code — a build script, a test command — that code runs with the workflow's secrets, the same as any other code a run touches. Treat a fork's pull request with the same caution as an untrusted task.
  • mode: review (review-only, pick) is trusted-author-only (owner ruling 2026-10-13): it reviews a pull request only when the author's LIVE GitHub author_association is OWNER, MEMBER or COLLABORATOR, right now, or the author is Fugaro's own identity on a pull request it opened itself — fork or not. followup.trusted, the account-ID allow-list a follow-up's own comment trust also consults, plays NO part in this decision: unlike the live association, a list entry does not expire or re-check itself, so a person removed as a collaborator but left on the list would otherwise stay trusted here indefinitely. An outside contributor's pull request is refused outright, whether or not its head is in a fork; there is no flag to let one through. A trusted author's own fork is reviewed only when the fork repository's owner is that same trusted author, so a shared or organizational fork can't carry someone else's commits under a name the trust check never sees. Bitbucket has no author_association at all: review mode accepts only a same-repository branch there — on the premise that pushing one already needs write access — and refuses every fork. A workspace or project token breaks that premise (see "Narrow git credentials" above): an agent of an allow-listed repository can push a branch and open a pull request in another allow-listed repository. A hostile agent in one repository can open its own malicious pull request in another, and a later review-only run there trusts it. That is accepted rather than mitigated (D476), and the docs tell operators never to put the token's own account ID in followup.trusted. None of this is a sandbox, though: the reviewing agent is still the same unsandboxed process, as the same user, in the same container, as every other run. A trusted author's own prompt injection — the diff itself, a commit message, and, in a first run or follow-up, the checkout's own CLAUDE.md and .claude/rules, which those runs load as instructions (review mode removes both from the checkout and gives the reviewer the base branch's own instead, so there they reach it as the diff content they are, not as loaded instructions) — is still code execution under --dangerously-skip-permissions, and that code can still read the runner's own /proc environment (see "What one run's agent can reach" above) for every workflow secret, the GitHub App's private key, the real provider keys and the job's service account token, and send any of it out over the open network egress nothing here restricts — redaction of the posted comment and the logs only ever masks what Fugaro itself publishes, never a secret a running process exfiltrates on its own. Trusting a person this way also trusts what THEY trust: a collaborator who lets other people push to their own fork, or who enables "allow edits by maintainers" on their pull request, or who merges someone else's commits into their own branch, extends review mode's trust to all of it — the check is "whose fork, and whose association", not "whose commit". "Member" and "collaborator" are GitHub's own categories and can be broader than you expect: a MEMBER is any member of the organization, even one with no access to this particular repository, and a COLLABORATOR can be a read-only one. A stricter check (the collaborator's actual permission level) is possible future hardening whose required GitHub App permission is unverified; see docs/recipes.md §3 for the full account.
  • Give Fugaro its own provider keys with credit limits, and its own repository access — a GitHub App on GitHub, a repository access token on Bitbucket, or one workspace or project access token allow-listed for many — installed only on the repositories it serves, and only where the token's reach is what you mean (see "Narrow git credentials" above).
  • Public repositories are refused for follow-ups unless followup.allow_public is set, for the same reason.

Scope

In scope:

  • The budget gateway, the Realtime Database rules and token handling that enforce the shared budget
  • Credential handling: secrets in Secret Manager, fugaro secrets, redaction of logs and PRs, the runner's use of provider and model tokens
  • The IAM and Terraform that fugaro setup creates (per-repository isolation, custom roles, bucket conditions)
  • The CLI and the runner (for example path or command injection from a task, a repository's fugaro.yaml or a PR comment)
  • The release pipeline (checksums, signatures, the Homebrew cask)

Out of scope:

  • An agent doing harmful things inside its own container with the credentials that job's service account is allowed to hold: the trust boundary is the container, and the design says so openly
  • Problems that need an attacker who already holds your cloud project's owner credentials
  • Vulnerabilities in Google Cloud, GitHub, Bitbucket or a model provider themselves; report those to the vendor
  • Denial of service by spending your own budget

The trust boundary and what each credential can reach are described in docs/design/v1.md (section 6, Security model).

There aren't any published security advisories