fix(mosaic): harden credential mutation boundaries

docs/PRD.md

@@ -79,49 +79,6 @@ Jarvis (v0.2.0) is a self-hosted AI assistant with a Python FastAPI backend and
 
 ---
 
-## Per-estate durable agent working memory (#1051)
-
-### Problem and objective
-
-Agent and lane continuity currently accumulates as plain local files with no repository backing. The installer must make a private, per-estate `mosaic-brain` clone at `~/.mosaic` reproducible without authorizing cross-estate access or introducing an independent credential path.
-
-### Normative requirements
-
-1. `MB-REQ-01` (R1): Ensure the target estate's existing `mosaic-brain` can be cloned to `~/.mosaic`; repository creation and live access granting remain broker-mediated.
-2. `MB-REQ-02` (R2/Q1): Derive estate and brain target from the configured target git host through the credential broker's estate registry. A second `brain_repo` authority and host-machine inference are forbidden; an unknown host fails closed with a named diagnosis.
-3. `MB-REQ-03` (R3): Seat access is granted only through `mosaic cred`; callers must never resolve or read a token independently. Live grant verification is gated on MC-CRED-01 implementation.
-4. `MB-REQ-04` (R4): The eventual live postcondition requires `~/.mosaic` to be a `main`-branch git repo with the expected remote and a seat-owned read/write round-trip. This live validation is gated on MC-CRED-01 implementation and cannot be replaced by a clone exit code.
-5. `MB-REQ-05` (R5): The out-of-estate refusal control covers both Git and API resolver axes. Axis disagreement is `indeterminate` failure, never permission; contract tests bind to the broker's four terminal classes and stable reason codes.
-6. `MB-REQ-06` (R6): The brain skeleton excludes `*.token`, `*.key`, `*.pem`, `.env`, and `credentials.json`; credentials remain broker-owned and no error path may print secret material. Arbitrary legacy content is never auto-published from a heuristic denylist: an approved content scanner must bind approval to the exact source snapshot, otherwise the item is retained and reported.
-7. `MB-REQ-07` (R7): Detect existing local lane directories and seat state files, publish approved snapshots into the durable layout without overwrite or deletion, and explicitly report every detected item that cannot be migrated. Automatic source deletion is parked until command-scoped identity propagation and the required clean audit; retained sources are always reported. Lane findings are append-only; `board/` has a named single writer; writes push immediately rather than on a timer.
-8. `MB-REQ-08` (R8): `mosaic doctor` reports missing clone, wrong remote, incomplete write-access evidence, and uncommitted local state. `--fix` repairs the first three only through the approved installer/broker path; it never hand-rolls credential resolution.
-9. `MB-REQ-09`: Retention is ownership-first and archive-only. Every retained artifact requires a named durable owner; absent or non-durable ownership leaves the gate open and blocking. Age and size never authorize deletion.
-10. `MB-REQ-10`: Brain provisioning occupies canonical installer P7 only after the applicable P5 credential postcondition commits; canonical phase numbers are unchanged.
-
-### Current delivery slice
-
-In scope now: estate derivation, secret exclusion, non-destructive migration, doctor reporting/repair orchestration, and red-first tests over all four credential-contract terminal classes. Live grant and live read/write round-trip evidence remain explicitly gated on the working MC-CRED-01 broker and must not be mocked or replaced by independent token lookup.
-
-### Acceptance criteria
-
-1. `AC-MB-01`: Contract tests observe RED before implementation and then distinguish `ok/0`, `refused/10`, `error/20`, and `indeterminate/30`, preserving v1.5 diagnoses including refused `provider-identity-mismatch`/`credential-rejected` and indeterminate `identity-not-measured`/`provider-unavailable`. A scope-forbidden `/user` result with confirmed in-scope repository capability is never represented as a dead credential. `identity-not-found` remains reserved for a future visibility-authorized inventory operation and is not an expected `validate` result.
-2. `AC-MB-02`: Estate resolution uses the configured target git host and one registry; unknown, mismatched, and host-machine-derived inputs fail closed.
-3. `AC-MB-03`: A clean fixture contains the required layout and exact secret exclusions; filename-, content-, binary-, and size-based secret controls remain outside Git without their values appearing in output. Without an approved scanner, even benign legacy content is retained and reported rather than auto-published.
-4. `AC-MB-04`: Migration publishes approved lane-durable and seat-state snapshots into collision-safe archive/ledger paths, retains and reports every source, never overwrites an existing finding, and never deletes by age/size.
-5. `AC-MB-05`: Doctor detects all four R8 defect classes; `--fix` repairs eligible classes through the approved P7/broker seam and leaves unresolved credential-dependent states visible.
-6. `AC-MB-06`: Git-axis and API-axis refusal must both be authoritative `refused` outcomes with matching stable reason codes; any disagreement yields `indeterminate`.
-7. `AC-MB-07`: Independent code review and security review pass at the exact head, and HOMELAB Woodpecker instance `mosaic` is terminal green before integration.
-8. `AC-MB-08`: After reviewed merge to `main`, report only **believed-fixed, pending jarvis validation**; issue #1051 remains open until W-jarvis validates the installed result.
-
-### Constraints and risks
-
-- MC-CRED-01 contract v1.5 is the caller boundary; no independent credential/token lookup is permitted. Identity is established from governed mint-time binding and provider evidence when measurable, never a credential filename. Runtime validation does not widen a least-privilege token merely to make `/user` observable.
-- C1 owns installer phase sequencing. This slice consumes P5/P7 ordering without renumbering or duplicating the phase machine.
-- Lane content is findings, so last-writer-wins is data loss. Append-only names and explicit collision handling are mandatory.
-- A created-but-empty brain beside unbacked local doctrine fails the objective; migration is a primary acceptance gate.
-
----
-
 ## Compaction Refresh Trust Lifecycle (M1, #827–#830)
 
 ### Problem and objective
@@ -480,6 +437,59 @@ Canonical checkpoint/handoff payloads, exactly-once connector receipts, concrete
 
 ---
 
+## Governed fleet credential lifecycle (`mosaic cred`, #1045)
+
+### Problem and objective
+
+Fleet credentials are issued, wired, resolved, granted, validated, rotated, and revoked through unrelated scripts and manual provider actions. The split has produced silent fallback to a human/shared principal, missing runtime identity, cross-estate login resolution, incomplete permission checks, and non-auditable grants. The objective is one mechanical, durable, systemic `mosaic cred` path that decides both what a fleet seat may do and which provider identity it acts as.
+
+### Scope
+
+Phase 1 governs the existing per-identity Gitea token store and Tea login registration. VaultWarden is explicitly out for the agent tier and is not a backend option in this workstream. Certificate-backed identity and short-lived broker-issued credentials remain later phases behind the same caller contract.
+
+### Normative requirements
+
+1. `CRED-REQ-01`: The CLI SHALL expose `provision`, `wire`, `grant`, `get`, `validate`, `whoami`, `list`, `rotate`, `revoke`, and `audit`. Grant and validate SHALL conform to [`docs/credentials/GRANT-VALIDATE-CONTRACT.md`](./credentials/GRANT-VALIDATE-CONTRACT.md).
+2. `CRED-REQ-02`: Every provider operation SHALL carry an explicit identity, estate, and host. Estate-to-host mapping SHALL come from strict non-secret configuration. Missing, ambiguous, inferred, or mismatched values SHALL refuse before credential resolution. Machine location SHALL grant no estate authority.
+3. `CRED-REQ-03`: Token capability and Tea login identity are inseparable. Provisioning SHALL create/register both or neither. At mint time, delegated Basic authority SHALL read its provider principal back, the minted token object SHALL read back exact scopes, and both the token binding and exact host-bound Tea record SHALL contain that same minted credential. Runtime `/user` identity remeasurement is required only when the seat token already carries `read:user`; least-privilege tokens SHALL NOT be widened to service the instrument. A wrong-host or absent Tea login SHALL never fall back to a host default.
+4. `CRED-REQ-04`: Under fleet context, unset or unresolvable identity SHALL fail closed identically in the git credential helper and API resolver. Interactive shared credentials remain available only through an explicit non-fleet/shared selection; absence SHALL never select them.
+5. `CRED-REQ-05`: Token scope, repository permission, and organization/team role are independent layers. Provision, grant, and validate SHALL report each separately from provider evidence. No layer substitutes for another, and a permission widening at one layer SHALL not be described as least privilege because another layer is narrow.
+6. `CRED-REQ-06`: Gitea token creation SHALL use an explicit delegated provisioning step because this provider requires Basic Auth. Password-equivalent provisioning material SHALL enter only through a protected control-plane runtime credential channel, never caller bearer storage, argv, ordinary environment, logs, or output.
+7. `CRED-REQ-07`: Permission grants SHALL be accepted only after provider read-back of the named direct collaborator permission or, for team grants, organization membership, team membership, team-repository attachment, and subject effective permission.
+8. `CRED-REQ-08`: `validate --repo` SHALL compute a side-effect-free write differential by result. One immutable credential resolution SHALL bind the declared subject's provider identity read-back, repository permission, and authenticated Git receive-pack advertisement. A distinct provider-confirmed read-only principal and an unauthenticated caller SHALL both be refused receive-pack in the same evaluation. Principal/handle disagreement SHALL be indeterminate, never refusal or success. The check SHALL create no ref or artifact and SHALL state that it does not prove a particular update will pass branch protection, hooks, races, or content policy.
+9. `CRED-REQ-09`: All provider HTTP calls SHALL share one transport implementation for URL/host binding, TLS, User-Agent, content-type, JSON-shape validation, redaction, and bounded responses. A 2xx status alone SHALL never establish identity, scope, permission, grant, or revocation.
+10. `CRED-REQ-10`: Operations SHALL return stable machine outcomes `ok`, `refused`, `error`, or `indeterminate`. Policy refusal, local operational failure, and incomplete/inconsistent evidence SHALL remain distinguishable. `provider-unavailable`, `identity-not-measured`, `identity-not-visible`, `identity-not-found`, and `credential-rejected` SHALL remain distinct diagnoses. Validation SHALL report capability from an in-scope probe separately from identity measurement. `/user` 401 is `credential-rejected`/refused; `/user` 403/404 plus successful in-scope capability is `identity-not-measured`, never a dead credential. A returned login mismatch is a binding refusal. No implemented operation may emit `identity-not-found`; that diagnosis requires a separately approved visibility-authorized inventory capability. Security callers SHALL fail closed on every outcome except `ok` without relabelling indeterminate evidence as a denial.
+11. `CRED-REQ-11`: No command SHALL print a token, password, authorization header, fingerprint, partial secret, or secret-bearing provider body, including error paths. Secrets SHALL not appear in process argv. Phase-1 file storage SHALL remain private, symlink-safe, regular-file-only, test-overridable, and compatible with existing managed token consumers.
+12. `CRED-REQ-12`: Every issue, provision, grant, rotate, revoke, and credential access SHALL be journaled with actor, subject, estate, host, repo/scope, operation, time, and non-secret provider evidence. The durable journal SHALL be opened and fsynced before the first mutation, append each mutation/read-back, and seal only after acceptance. Journal/audit write failure SHALL be fatal; an unsealed journal means incomplete/indeterminate work.
+13. `CRED-REQ-13`: `wire` SHALL be idempotent and SHALL update the exact roster-derived `<identity>.env.generated` fleet projection so both identity axes survive restart. It SHALL authenticate the same explicit seat through a protected delegated credential channel and provider identity read-back before mutation, refuse actor/identity/path/roster disagreements, and never authorize from the shared Unix account. It SHALL not write linked-worktree git configuration or silently infer identity from pane/session names.
+14. `CRED-REQ-14`: Rotate SHALL verify the new credential/provider identity before retiring the old credential. Revoke SHALL read back provider revocation/denial and preserve an auditable recovery record. A local file deletion or successful HTTP status is not revocation evidence.
+15. `CRED-REQ-15`: Before the #1044 fail-closed resolver change is eligible to land, `mosaic cred validate` SHALL resolve every live HOMELAB mosaic-lane seat from `git.mosaicstack.dev` by provider read-back. Any unresolved seat HOLDS the fail-closed change; the implementation may not widen or restore shared fallback.
+16. `CRED-REQ-16`: Provider claims SHALL record the estate, instance, endpoint, asserted content type, and decision-relevant object fields. Append-only provider status history SHALL be reduced to latest-per-context where current state is required.
+
+### Acceptance criteria
+
+1. `AC-CRED-01`: Red-first tests prove unset identity, missing token, wrong estate, wrong host, wrong Tea login, and out-of-estate identity produce the same structured refusal class/reason on git and API resolution, with no shared credential read and no provider mutation.
+2. `AC-CRED-02`: Provisioning against a provider fixture proves Basic Auth is required, bearer-only token minting is refused, both identity axes register atomically, exact token scopes are read back from the provider token object, and rollback removes partial local registration.
+3. `AC-CRED-03`: Direct and team grant tests read all applicable permission layers back from provider objects. Deliberately divergent token scope and repo grant cases cannot return `ok`; organization/team membership and team-repository attachment are additionally acceptance-bearing for team grants. A direct collaborator grant reports organization membership but does not require it, because direct collaborator permission and organization membership are intentionally independent provider layers.
+4. `AC-CRED-04`: Validate proves provider identity and the write differential on the intended repository through one credential handle. The subject is accepted, a separately resolved provider-confirmed read-only principal is refused, and an unauthenticated caller is refused in the same invocation. A shared/wrong-principal fallback, independent subject lookups, invalid read-only control, evidence disagreement, unexpected content type/shape, or provider outage returns `indeterminate`, never success or policy refusal. Runtime exact scope is reported independently as `not-measured` when the current seat credential is not authorized to read its provider token object; NOT-MEASURED is neither pass nor failure and does not erase confirmed repository capability. Exact scope is acceptance-bearing at provision/rotate time, where delegated mint authority can read the token object.
+5. `AC-CRED-05`: Audit/journal fault injection before and after each mutation proves write failure is fatal, open journals remain visible/recoverable, and no operation can claim success without a sealed journal and provider read-back.
+6. `AC-CRED-06`: Adversarial output/argv tests seed distinct secret values through success, refusal, provider-error, parser-error, rollback, rotate, and revoke paths and find zero secret/partial/fingerprint occurrences in stdout, stderr, logs, audit, and child argv.
+7. `AC-CRED-07`: Storage tests reject symlinked roots/files, non-regular files, permissive modes, traversal, conflicting concurrent mutation, and production-store leakage into fixture tests. Existing canonical per-seat token consumers continue through the governed adapter.
+8. `AC-CRED-08`: `wire` repeated twice is byte-idempotent, produces both required identity-axis values in the exact roster-derived generated environment, survives a fresh fleet projection/restart path, and leaves shared linked-worktree git config untouched. An unauthenticated caller, a caller authenticated as another seat, a caller-selected filename, or a file whose roster identity differs is refused before mutation.
+9. `AC-CRED-09`: Rotate validates new identity/capabilities before retiring old material; injected failure leaves the previously valid credential usable and the journal open. Revoke is accepted only when provider read-back proves the credential no longer authenticates/authorizes.
+10. `AC-CRED-10`: Every live HOMELAB mosaic-lane seat resolves from `git.mosaicstack.dev` before the #1044 fallback closes. The evidence names the complete seat population, provider endpoint/content type, and unresolved count; non-zero unresolved count blocks landing.
+11. `AC-CRED-11`: Baseline typecheck/lint/format/tests, focused auth/permission abuse cases, independent code review, independent security review, and terminal-green HOMELAB Woodpecker CI pass on the exact reviewed head.
+12. `AC-CRED-12`: Interim delivery to `next` is reported only as **believed-fixed, pending validation AND pending promotion to `main`**. Issues stay open until #1037 promotes the work and constitutional completion is independently verified.
+
+### Constraints and dependencies
+
+- C1 install-state-machine work merges first. This lane then re-takes base/head-bound measurements without redesigning or reworking code.
+- MB-BRAIN-01 (#1051) consumes the grant/validate contract and may proceed against the published interface before implementation merge.
+- The branch-model compatibility question for `next` remains escalated. No `done` claim, issue closure, or self-initiated promotion is permitted at the `next` checkpoint.
+- `ASSUMPTION:` Phase-1 Gitea support is the only provider implementation in this slice; provider-neutral types preserve later adapters without pretending unimplemented providers are supported.
+
+---
+
 ## Architecture
 
 ### High-Level System Diagram

docs/credentials/GRANT-VALIDATE-CONTRACT.md

@@ -0,0 +1,204 @@
+# `mosaic cred grant` / `validate` caller contract v1.5
+
+**Status:** early binding contract for MC-CRED-01 and MB-BRAIN-01. v1.3's anonymous absence classifier was withdrawn as unsound for private users. v1.4 adopted subject-credential validation without admin visibility. v1.5 separates in-scope capability from identity measurement so correctly least-privileged tokens are not widened to service the instrument. This contract may evolve before implementation merge; incompatible changes require an explicit change notice.
+
+## Security model
+
+- Every call carries both `--estate` and `--host`. The configured estate-to-host mapping must match exactly. Host inference, host-adjacent fallback, and cross-estate resolution are forbidden.
+- `<identity>` is always explicit. The CLI never substitutes a pane, roster, login, Unix user, or other plausible ambient identity.
+- The identity token and the host-bound Tea login are one provisioning unit. Minting authority reads the principal back when the invariant is created and records that binding with the token registration. Runtime validation re-measures identity only when the token already holds `read:user`; it never widens scopes to make the instrument green.
+- Grant authority is broker/delegated-provisioner material. It is never supplied as a CLI value, environment value, or bearer token readable by the requesting agent. The broker obtains it from its protected runtime credential channel.
+- Commands never print token, password, authorization header, fingerprint, partial secret, or secret-bearing error text. Structured evidence contains provider object fields and endpoint metadata only.
+- Every operation opens and fsyncs a durable journal before the first mutation. Journal/audit write failure is fatal. A grant is successful only after provider read-back and a sealed journal.
+
+## Commands
+
+```text
+mosaic cred grant <identity> \
+  --estate <estate> \
+  --host <host> \
+  --repo <owner/repo> \
+  --permission <read|write|admin> \
+  [--via <collaborator|team>] \
+  [--team <team>] \
+  [--read-only-control <identity>] \
+  [--json]
+
+mosaic cred validate <identity> \
+  --estate <estate> \
+  --host <host> \
+  [--repo <owner/repo>] \
+  [--require <read|write|admin>] \
+  [--read-only-control <identity>] \
+  [--json]
+```
+
+Rules:
+
+- `--via collaborator` is the default. It grants a direct repository permission and still reports the organization-membership layer.
+- `--via team` requires `--team`; `--team` with collaborator mode is invalid.
+- `validate --repo` reports two independent axes: capability from an in-scope repository probe, and identity binding from `/user` only when authorized. Capability may be `confirmed` while identity is `not-measured`; NOT-MEASURED is neither pass nor failure.
+- Write validation requires a distinct known-read-only control identity, supplied explicitly or configured in the declared estate. The control identity and its read-only permission are read back from the provider on every invocation; the configured name alone is not evidence.
+- `grant` invokes the same validation after mutation. HTTP 2xx and process exit status are never acceptance evidence.
+
+## Machine result
+
+`--json` writes exactly one non-secret JSON object to stdout. Human diagnostics go to stderr. Callers must decide from `outcome`, never by parsing prose.
+
+```json
+{
+  "schemaVersion": 1,
+  "operation": "grant",
+  "outcome": "ok",
+  "exitCode": 0,
+  "retryable": false,
+  "subject": {
+    "identity": "seat-name",
+    "estate": "estate-name",
+    "host": "git.example.invalid",
+    "repo": "owner/repo"
+  },
+  "mutation": "applied",
+  "reason": {
+    "code": "grant-verified",
+    "message": "Grant matched all provider read-backs."
+  },
+  "evidence": {
+    "providerIdentity": {
+      "login": "seat-name",
+      "endpoint": "GET /api/v1/user",
+      "contentType": "application/json"
+    },
+    "tokenCapabilities": {
+      "state": "not-measured",
+      "scopes": [],
+      "source": "runtime-not-authorized"
+    },
+    "repositoryPermission": {
+      "requested": "write",
+      "effective": "write",
+      "endpoint": "GET /api/v1/repos/owner/repo",
+      "contentType": "application/json"
+    },
+    "organizationMembership": {
+      "state": "present"
+    },
+    "teamMembership": {
+      "state": "not-applicable"
+    },
+    "writeDifferential": {
+      "state": "can-write",
+      "credentialBinding": "same-resolution",
+      "transportPrincipal": "seat-name",
+      "authenticatedReceivePack": "advertised",
+      "readOnlyControl": {
+        "identity": "read-only-control",
+        "providerPermission": "read",
+        "receivePack": "refused"
+      },
+      "unauthenticatedReceivePack": "refused",
+      "artifactCreated": false,
+      "proves": "One immutable credential resolution authenticated both the subject identity read-back and write transport; a provider-confirmed read-only principal and an unauthenticated caller were both refused.",
+      "doesNotProve": "A particular ref update will pass branch protection, hooks, races, or content policy."
+    }
+  },
+  "audit": {
+    "journalId": "opaque-id",
+    "state": "sealed"
+  }
+}
+```
+
+Fields may be `null` only when their enclosing evidence state explains why. Missing decision-relevant fields make the result `indeterminate`, never `ok`.
+
+## Terminal classes
+
+| Outcome         | Exit | Meaning                                                                                                                                                                                                                                                                                                                                                          | Mutation guarantee                                                              | Caller action                                                                               |
+| --------------- | ---: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| `ok`            |  `0` | Requested property was established from provider objects and all required layers agree.                                                                                                                                                                                                                                                                          | `validate`: `none`; `grant`: `applied` and read back.                           | Continue.                                                                                   |
+| `refused`       | `10` | A complete, authoritative policy/access decision denied the request. Examples: estate-host mismatch, missing explicit identity, provider identity mismatch, explicit permission denial, or cross-estate subject.                                                                                                                                                 | `none`; refusal occurs before mutation.                                         | Treat as a stable denial. Do not retry without changing authority/configuration.            |
+| `error`         | `20` | The command contract or local control failed before an access verdict. Examples: invalid arguments, malformed estate registry, insecure credential path, journal cannot be opened/fsynced, or internal invariant failure.                                                                                                                                        | `none` unless `mutation` explicitly says `unknown`; `unknown` is never success. | Repair the tool/configuration. Do not reinterpret as access denial.                         |
+| `indeterminate` | `30` | The requested security property could not be evaluated completely or evidence disagreed. Examples: provider unavailable, wrong content type/shape, permission and receive-pack disagreement, missing post-grant read-back, or unknown mutation acknowledgement. Runtime scope `not-measured` remains a separately reported axis and is neither pass nor failure. | `none`, `applied`, or `unknown`, stated explicitly. Never infer.                | Fail closed at the calling gate. Investigate/re-evaluate; do not label the subject refused. |
+
+Parsing/usage errors emitted by Commander remain exit `2` and do not produce a broker verdict. Callers should treat them as integration defects, not access decisions.
+
+## Refusal object
+
+A refusal is intentionally recognizable without prose:
+
+```json
+{
+  "schemaVersion": 1,
+  "operation": "validate",
+  "outcome": "refused",
+  "exitCode": 10,
+  "retryable": false,
+  "subject": {
+    "identity": "external-seat",
+    "estate": "homelab",
+    "host": "git.example.invalid",
+    "repo": "owner/repo"
+  },
+  "mutation": "none",
+  "reason": {
+    "code": "no-token-for-identity",
+    "message": "The explicit identity has no credential in the declared estate."
+  },
+  "evidence": {
+    "providerIdentity": null,
+    "tokenCapabilities": {
+      "state": "not-measured",
+      "scopes": [],
+      "source": "runtime-not-authorized"
+    },
+    "repositoryPermission": null,
+    "organizationMembership": null,
+    "teamMembership": null,
+    "writeDifferential": null
+  },
+  "audit": {
+    "journalId": "opaque-id",
+    "state": "sealed"
+  }
+}
+```
+
+The git credential helper and API resolver must map the same subject/estate/host failure to the same `reason.code` and terminal class. MB-BRAIN-01 may assert this parity. A caller does not need to know which resolver path was used.
+
+## Required reason codes
+
+Stable v1 codes:
+
+- refusal: `identity-required`, `estate-required`, `estate-host-mismatch`, `cross-estate-resolution`, `no-token-for-identity`, `tea-login-missing`, `tea-login-host-mismatch`, `provider-identity-mismatch`, `credential-rejected`, `permission-denied`, `organization-membership-required`, `team-membership-required`
+- error: `invalid-input`, `estate-registry-invalid`, `insecure-credential-source`, `journal-unavailable`, `internal-invariant`
+- indeterminate: `provider-unavailable`, `identity-not-visible`, `identity-not-measured`, `identity-not-found`, `unexpected-content-type`, `unexpected-provider-shape`, `scope-not-evaluable`, `permission-evidence-disagrees`, `transport-principal-mismatch`, `read-only-control-invalid`, `readback-missing`, `mutation-state-unknown`, `concurrent-mutation`, `mutation-lock-unavailable`, `team-scope-changed-during-grant`, `wire-audit-incomplete`
+
+`provider-unavailable` means no usable provider answer was available. `identity-not-measured` means `/user` was scope-forbidden while an in-scope repository probe confirmed the credential capability; it is `indeterminate` only for the identity axis and must not be represented as a dead credential. `identity-not-visible` and `identity-not-found` are reserved for the unimplemented external inventory capability. `credential-rejected` means the provider rejected the credential itself (Gitea 401), which is a stable `refused` outcome. A 403 on `/user` is not credential rejection when an in-scope probe succeeds.
+
+No anonymous or visibility-unprivileged 404 is admissible evidence of absence. `identity-not-found` requires, in the same invocation: (1) the visibility credential's own `/user` object read back as the configured authority with provider-admin visibility; (2) target lookup performed with that same authority; (3) a known-present PRIVATE control returning JSON 200 with matching login and `visibility=private`; and (4) a generated absent negative control returning JSON 404 under that same authority. Missing authority or any non-discriminating control yields `identity-not-visible`, never absence. A public positive control cannot certify private subjects.
+
+No currently implemented operation may emit `identity-not-found`: the required governed inventory capability was deliberately declined and runtime validation must not acquire standing admin visibility. For `validate`, `/user` 401 means `credential-rejected`; `/user` 403/404 triggers the in-scope capability probe and, when that succeeds, identity is `identity-not-measured`; JSON 200 with a mismatched login is a binding refusal. A future inventory operation must meet every precondition above and receive an explicit privilege decision before making `identity-not-found` reachable.
+
+Unknown future reason codes must still carry one of the four stable `outcome` values.
+
+## Side-effect-free write differential
+
+For Gitea v1, `validate --repo` resolves the subject credential exactly once into an immutable in-memory credential handle. The provider `/user` read-back, authenticated repository object, and Git smart-HTTP `git-receive-pack` advertisement all consume that same handle; callers may not perform independent lookups for those steps. The command also probes a separately resolved, provider-confirmed read-only control principal and repeats the request unauthenticated.
+
+`can-write` requires all of the following:
+
+1. provider `/user` login obtained with the subject credential handle equals `<identity>`;
+2. authenticated repository object obtained with that same handle reports write-capable permission;
+3. receive-pack obtained with that same handle returns the exact advertisement content type and protocol preamble;
+4. the transport evidence records the same declared principal as the identity read-back; any handle/principal seam disagreement is `transport-principal-mismatch` and therefore `indeterminate`, never refused;
+5. a distinct known-read-only credential resolves to its declared control identity, its provider repository object reports no write permission, and receive-pack is refused;
+6. the unauthenticated control is refused and does not return a receive-pack advertisement;
+7. estate, host, and repository in every request equal the declared subject.
+
+The read-only control varies the mechanism under accusation: principal selection. The unauthenticated arm remains as a separate control proving authentication is required; it cannot establish which principal authenticated the subject probe. A missing, write-capable, identity-mismatched, or otherwise invalid read-only control makes the result `indeterminate`.
+
+No ref is updated and no repository artifact is created. This proves that the declared subject credential—not merely some authenticated credential—can enter the write transport for that repository, while a provider-confirmed read-only principal and an unauthenticated caller cannot. It does not prove any specific branch update would survive branch protection, hooks, concurrent changes, or content policy.
+
+## Grant read-back
+
+A collaborator grant is accepted only when the provider returns the named collaborator permission and the subject credential independently reads the repository with matching effective permission. A team grant serializes governed mutations per provider team and enumerates the team's complete repository attachment set both before and after mutation. It refuses before mutation when the team is already attached outside the one explicitly requested repository (`team-scope-exceeds-request`). If the post-mutation set is not exactly the requested repository, it returns `indeterminate` (`team-scope-changed-during-grant`) and compensates only state proven absent before the locked invocation: a newly introduced subject membership and/or requested repository attachment. Both compensations require provider absence read-back and are journaled; the operation never reports success from the stale pre-check. The grant then requires provider read-back of organization membership, team membership, team repository attachment, and effective subject permission. Token capability, repository permission, and organization/team role are reported as separate layers; no layer substitutes for another.

docs/scratchpads/1045-mosaic-cred.md

@@ -0,0 +1,82 @@
+# MC-CRED-01 / stack #1045 scratchpad
+
+Last updated: 2026-08-05
+
+## Objective
+
+Deliver the governed `mosaic cred` identity boundary for issue, scope, validation, rotation, and revocation across explicitly declared estates. The trunk-only ruling superseded the original `next` checkpoint: the branch is rebased onto `origin/main` and its PR target is `main`. Linked issues remain **believed-fixed, pending jarvis validation** after merge.
+
+## Requirements sources
+
+- Charter: `/home/hermes/agent-work/tl-mosaic/CHARTER-MC-CRED-01-be-coder-06.md`
+- Stack issues: #1045, #1043, #1044, #1047, #1049, #1013, #1007; promotion #1037; consumer #1051
+- Remote spec: `jason.woltje/jarvis-brain` origin/main `b7687d51f4efe52e43dbcd6dc95b5554b3332957`
+- Greenfield PRD v3 addenda: INV-B durable journal, INV-C visible failure diagnostics, INV-D supported fixture
+- Binding doctrine: `/src/jarvis-brain/infra/fleet/FLEET-DOCTRINE.md`
+
+## Plan
+
+1. Publish grant/validate v1 caller contract for MB-BRAIN-01.
+2. Add repo PRD requirements and preregister acceptance tests.
+3. Implement explicit estate registry, secure current file-store adapter, durable operation journal/audit, provider transport, and terminal result types.
+4. Implement `grant` and side-effect-free `validate`; then provision/wire/get/whoami/list/rotate/revoke/audit.
+5. Make git and API resolver refusals identical and fail closed under fleet context.
+6. Reconcile live HOMELAB seats through each subject credential's own `/user`; #1044 hold is lifted, and its fail-closed change carries the pre-registered mechanism evidence (resolver refusal marker, same-run marker positive control, confirmed-lane negative arm).
+7. Run baseline/situational tests, independent code review and mandatory independent security review, CI on the exact head, then open the PR directly against `main` without closing issues or claiming Jarvis validation.
+8. C1 merges first. After any base/head move, re-derive merge-base, commit set, diff, CI, reviews, and provider measurements from the replacement SHA.
+
+## Budget
+
+No explicit token cap supplied. Working cap: keep implementation in one package plus shipped framework resolver changes and required docs/tests; avoid unrelated wrapper defect fixes and VaultWarden redesign. Escalate only if a charter requirement is technically unsatisfiable.
+
+## Decisions
+
+- VaultWarden is out for the agent tier per the charter verdict; phase 1 governs the existing per-identity file store.
+- Estate is explicit input and must match a configured host mapping; target host is never inferred from machine location.
+- Grant authority and basic-auth provisioning material are delegated control-plane credentials, never caller bearer material and never CLI argument/output.
+- `ok`, `refused`, `error`, and `indeterminate` are distinct machine outcomes. Security callers fail closed on all but `ok`, while retaining the semantic distinction.
+- Gitea write-differential resolves the subject once and binds provider identity, repository permission, and receive-pack to the same in-memory credential handle. It adds a distinct provider-confirmed read-only-principal control plus the unauthenticated control, with no ref update. The live HOMELAB negative-control subject is `tl-mosaic`, verified read-only on `mosaicstack/stack`; code and contract remain principal-agnostic.
+
+## Progress
+
+- [x] Mode/intake/core guides/skills/doctrine loaded.
+- [x] Spec repository READ confirmed under be-coder-06 from provider object.
+- [x] Target-branch conflict resolved by the trunk-only ruling; the lane was rebased from `next` onto `origin/main`.
+- [x] Canonical remote PRD v3 addenda re-read at new head.
+- [x] Required issues read via Mosaic wrapper.
+- [x] Early grant/validate contract v1 published at `docs/credentials/GRANT-VALIDATE-CONTRACT.md`.
+- [x] Contract v1.1 binds transport to the same resolved principal and adds a provider-confirmed read-only-principal control.
+- [x] Contract v1.2 distinguishes provider outage, absent identity, and rejected credential.
+- [x] Contract v1.3 positive-controlled anonymous visibility; subsequently withdrawn as unsound for private identities.
+- [x] Contract v1.4 implements ruling (b): subject credential's own `/user`, no admin/inventory authority, no implemented `identity-not-found` path.
+- [x] PRD update.
+- [x] Red-first principal-bound validate, estate-registry, file-store, provider-transport, and journal tests.
+- [x] Implementation: validate, direct/team grant, protected delegated authority, provision/wire/get/whoami/list/rotate/revoke/audit, reverse registry, and fleet fail-closed resolver paths.
+- [x] Review hardening: rotation returns visible open journals; team evidence records absent objects accurately; team scope is checked before/after under a host-qualified OS advisory lock with verified compensation; `wire` authenticates the exact seat/path/roster binding and preserves post-rename mutation semantics.
+- [ ] Independent code/security approvals on the final exact head (Codex advisory iterations are not independent approval).
+- [ ] Final exact-head CI and provider evidence.
+
+## Tests and evidence
+
+Baseline after workspace build: package typecheck passed; Vitest 81/81 files and 1,514/1,514 tests passed. The package shell suite reached a pre-existing tracked #973 Bash 5.2 BASH_LINENO incompatibility and exited 97 before wake tests; this is baseline, not introduced by MC-CRED.
+
+Red-first evidence:
+- principal-bound validate module absent → focused suite red;
+- incremental v1.1 run: write-capable, identity-mismatched, and receive-pack-admitted read-only controls each returned `ok`, causing 3/13 tests to fail for the exact control defect; after the control checks, 13/13 passed;
+- read validation absent → 2 tests failed `evaluateGiteaReadValidation is not a function`; after implementation, 15/15 validate tests passed;
+- estate registry, secure file resolver, Gitea transport, and audit journal each failed first because the module did not exist, then passed focused behavior suites.
+
+Current focused evidence: 77/77 across 11 credential/command suites; package lint, typecheck, formatting, and build are green. Full package Vitest reached 1,578 passing tests and three unrelated CLI-smoke failures caused solely by the installed-version update banner writing to stderr. Provider bodies are stream-bounded and requests deadline-bounded; delegated fd input is ownership/mode/size/time bounded; token and Tea stores are private and atomic; grant mutation/read-back state is journaled.
+
+Fail-closed resolver evidence: synthetic missing-token API and git paths each emitted stable `MOSAIC_CREDENTIAL_REFUSAL` with `reason=no-token-for-identity` and `shared_path_entered=false`; all 13 live token-bearing identities bypassed the shared path without over-fire in the same run. Evidence: `/home/hermes/agent-work/be-coder-06/review-evidence/failclosed-postcondition.jsonl`; independent verification remains tl-mosaic's obligation.
+
+Live validation v1.4 (subject credential's own `/user`, no admin): population 13; CONFIRMED 8; CREDENTIAL-REJECTED 4 (`coder-mos1`, `coder-mos2`, `f10-coder`, `merge-gate`); MISMATCH 1 (`mos-admin` token authenticates as `Mos`); NOT-MEASURED 0. The four false v1.2 `identity-not-found` sealed journals remain immutable and are explicitly superseded by four sealed correction journals. Evidence: `/home/hermes/agent-work/be-coder-06/live-validation-v1.4/`.
+
+Write differential for be-coder-06 passed with the configured read-only control and unauthenticated arm. Unit evidence proves the control arm invalidates validation when write-capable, identity-mismatched, or receive-pack-admitted.
+
+## Risks/blockers
+
+- The full CLI surface is broad; protect scope by sharing one provider/registry/journal core rather than per-command scripts.
+- Gitea exact token-scope read-back may require delegated Basic Auth. If a bearer-only validation path cannot obtain an exact provider token object, return `indeterminate` rather than claim a scope.
+- #1044 hold is LIFTED. The four least-privilege credentials are capability-confirmed and identity-not-measured, not dead. Fleet fail-closed paths now refuse with stable reason markers and never enter shared fallback under `MOSAIC_AGENT_NAME`; interactive callers retain explicit shared behavior. Runtime mismatch coverage remains limited to tokens holding `read:user`; future mints close identity binding at creation without widening seat scopes.
+- C1 PR #1054 must first be rebuilt from only its four commits on `main`; the retargeted head `8b067839` carries 13 unrelated `next` commits and is not merge-eligible. MC-CRED remains sequenced after the clean C1 merge.

docs/scratchpads/1051-mosaic-brain-installer.md

@@ -1,105 +0,0 @@
-# #1051 — per-estate mosaic-brain installer
-
-Last updated: 2026-08-05
-
-## Objective
-
-Codify estate-derived, repository-backed `~/.mosaic` support with secret exclusions, non-destructive migration, doctor diagnostics/fixes, and credential-contract terminal-class handling. Live broker grants and live read/write round-trips remain gated on MC-CRED-01.
-
-## Sources and bindings
-
-- Provider issue: HOMELAB `git.mosaicstack.dev`, `GET /api/v1/repos/mosaicstack/stack/issues/1051`, `application/json;charset=utf-8`.
-- Issue requirements: R1–R8 read directly on 2026-08-05.
-- MC-CRED caller contract: v1.5, SHA-256 `4cecba3386b37431d4a075205c6dfe43555c7673922fed61b84f43cac1a6ae92` at the 2026-08-05 re-derivation. Earlier moving bindings were v1.5 `710d22d61a93a4b9c70fc55506a023a675a110417fa7a6e72dc051c0d9fe8237`, v1.4 `27f20158561ae8292f3bfc926b5e97f398de93db6a1cf65fcc215d08811d39af`/`d12ad4595b7aef078e392988a07ab5cb00244440775c9c733dc825746d7ac67b`, and v1.3 `8cfa4853d2b0b0e8cc9e792fa8411310e16d7704c06e0af9d9a57155131d8086`.
-- Fleet doctrine: SHA-256 `026b43322e0551ef15b646a9f30d3a6aef58c662a810b732be2a03b1ecf7d36e` at intake.
-- Intake base was HOMELAB provider `next` = `4df478cdd150fdf8d52ea109f02ade5d85017acd`; `main` = `5916aeefd6ed12bcac086c6834c7f6c4ae38e1bc`. On 2026-08-05 `mos-claude` ruled that L0 trunk-based gate 15 requires all three lanes to retarget to `main`; `next` remains a non-merging integration branch. Never weaken or patch `pr-merge.sh`.
-
-## Scope
-
-### In now
-
-- R2/Q1 target-host estate derivation using one registry.
-- R5 both-axis refusal parity and disagreement failure.
-- R6 exact secret exclusions and no secret-bearing diagnostics.
-- R7 detection plus non-destructive, collision-safe migration/reporting.
-- R8 doctor checks and approved-seam fix orchestration.
-- Red-first tests over all four contract terminal classes and stable reason codes.
-
-### Gated / excluded
-
-- R3 live grant: waits for working MC-CRED-01.
-- R4 live seat-owned read/write round-trip: waits for working MC-CRED-01.
-- No independent token lookup, grant helper, or shared-credential fallback.
-- No phase renumbering; C1 owns the phase machine and provides the P5→P7 seam.
-- No age/size reaping or deletion.
-
-## Owner authority ruling and resolver seam
-
-- Binding addendum: `/home/hermes/agent-work/tl-mosaic/CHARTER-MB-BRAIN-01-ADDENDUM.md`; re-read after compaction.
-- HOMELAB durable lane-archive owner and user-namespace brain owner are the human provider account selected by local estate policy (operator ruling: `jason.woltje`) with a required GLPI queue as the standing remediation process. The brain target is therefore `<policy-owner>/mosaic-brain` on the estate host, not `<installer-source-org>/mosaic-brain`. Framework source remains operator-agnostic: the actual login and queue are local policy, not hardcoded open-source context.
-- Provider lookup is anonymous because the ruled owner is public. It requires exact allowlisted login plus a same-invocation public known-good control, private 404 control, and generated absent 404 control. It sends no Authorization header and never widens token scope.
-- Provider `active` is deliberately ignored: non-admin reads return false for demonstrably active accounts. Resolvability + exact login + public visibility are the gate.
-- Private and absent principals both return anonymous 404. The fail-closed reason is `owner-not-resolvable`, never owner-not-found.
-- Caller `owner` strings and `validated=true` are ignored. Migration consumes only an injected source-of-truth resolver result. Owner grammar is NFKC-stable, ASCII allowlisted, exact-policy matched, and mission-seat class is excluded.
-
-## Plan
-
-1. Pre-register acceptance tests and observe each requirement RED for its own missing behavior.
-2. Commit the red tests before implementation.
-3. Implement a narrow brain provisioning/doctor helper that consumes broker JSON outcomes and the shared estate registry without credential resolution.
-4. Implement safe migration and exact brain skeleton/ignore policy.
-5. Integrate the helper into C1's P7 seam and `mosaic doctor` after C1 lands/rebase.
-6. Run focused, package, installer, lint, typecheck, format, and situational security tests.
-7. Run independent code and security reviews in parallel; remediate and re-review.
-8. Push after HOMELAB queue guard, open the reviewed PR to `main`, and preserve merge order C1 → MC-CRED → MB-BRAIN. Do not modify the merge guard; `next` is non-merging integration only.
-9. Re-take CI measurement at the rebased exact head; do not rework code solely because base evidence moved.
-
-## Acceptance interpretation registered before results
-
-- `ok/0`: complete authoritative evidence only.
-- `refused/10`: complete authoritative denial only.
-- `error/20`: local contract/control failure; never reinterpret as denial.
-- `indeterminate/30`: incomplete/disagreeing evidence; fail closed, never resolve permissively.
-- Both Git and API axes must return authoritative `refused` with the same stable reason code for R5. Any axis disagreement is `indeterminate`. A provider `/user` login mismatch is first-class `provider-identity-mismatch`; credential filenames never establish principal identity.
-- Migration publication requires the durable object to contain the approved snapshot and no overwrite. Automatic path-based source deletion is parked; every source is retained and reported.
-- Secret exclusion is tested through exact ignore rules, nested secret-shaped paths, bounded UTF-8 content controls, and an approved-scanner gate bound to the exact source snapshot. Without an approved scanner, even benign content is retained and reported rather than committed.
-
-## Budget
-
-No explicit token ceiling was supplied. Working cap: 55K tokens for implementation/review and 3 focused remediation attempts per failure class. Reduce optional refactoring and documentation breadth before touching required acceptance scope.
-
-## Risks
-
-- C1 and MC-CRED branches have not merged into `main`; integration edits must wait for their exact interfaces or be confined to stable contract seams.
-- A broker runtime test before MC-CRED lands would either fail for an irrelevant reason or pressure a hand-rolled workaround; contract fixtures are allowed, live capability claims are not.
-- Migration can lose data through overwrite, cross-device move failure, or partial copy. Implementation must stage, verify resulting bytes, and retain/report source on incomplete transfer.
-- `~/.mosaic` is a git repo, while current working state may live under multiple local roots; detection must be explicit and cannot treat age/size as ownership.
-
-## Progress / evidence
-
-- [x] Charter receipt accepted by `tl-mosaic`.
-- [x] Issue #1051 R1–R8 read directly from provider.
-- [x] Contract re-derived through v1.3, moving v1.4, and v1.5 before R5 integration. v1.5 separates in-scope repository capability from `/user` identity measurement: 401 is `credential-rejected`/refused, 403/404 may become `identity-not-measured` only after in-scope capability succeeds, and 200 login mismatch is refused. `identity-not-found` is not reachable from `validate`.
-- [x] C1 P5→P7 seam receipt read; no brain implementation is in C1.
-- [x] RED acceptance set committed at `cf11c6c86abae073d8b02b4014cd5447ba67f12a`; author and committer read back as `be-coder-07` and branch reachability was independently verified by `tl-mosaic`.
-- [x] Moving-contract REDs observed independently for v1.4 mismatch, R8 prerequisite ordering, owner resolver seam/allowlist, tracked skeleton/no-follow behavior, runtime observation/publication, and provider owner resolution.
-- [x] Focused implementation includes secure migration, v1.5 write-differential/subject binding, production Git+API refusal parity, provider-backed durable owner resolution that ignores non-admin `active`, required GLPI standing-process policy, P7 provision orchestration, an internal installer command, and installed `mosaic doctor` wiring. Latest focused result: 97/97 (secure config 4, store 45, runtime 19, owner resolver 16, provision 5, provision command 3, installed doctor 5).
-- [x] MC-CRED added the required canonical reverse registry seam `ParsedCredentialEstateRegistry.resolveByHost()` at dependency head `6ca8758f`; current local copies are temporary until dependency integration and the 32-line permissive shim has been removed.
-- [x] Identity gotcha measured: inline `MOSAIC_GIT_IDENTITY=be-coder-07` controls credential resolution but does not override `user.name`/`user.email` inherited from the linked worktree common-dir config (`coder-mos1`). The first local P7 RED commit was immediately amended before push with command-scoped `GIT_AUTHOR_*` + `GIT_COMMITTER_*`; resulting author and committer both read back as `be-coder-07`. Every subsequent authoring command must carry both identity sets and be verified.
-- [x] R6 migration reports filename- or content-secret-shaped files without copying them; arbitrary legacy content requires an approved scanner bound to the exact source snapshot, and production currently retains/reports when no approved scanner is configured. `.gitignore` is canonical allowlisted content only: an existing noncanonical regular file fails closed and is never merged into publication. Symlinked `.gitignore`, layout directories, and nested migration destinations fail closed; a dirty checkout blocks provisioning before skeleton publication. The brain root is principal-owned mode `0700` before clone and after clone, all memory-bearing layout directories are mode `0700` even under umask `0022`, and doctor reports owner-accessible roots as hard unsafe findings.
-- [x] Provider owner lookup uses manual redirect handling, a five-second abort signal, strict JSON content type/shape, and an incrementally enforced 256 KiB response ceiling.
-- [x] Security-critical owner policy/registry reads have direct controls for principal UID ownership, file/ancestor permissions, and descriptor-safe regular-file reads.
-- [x] Automatic source deletion is parked per the shared-Git-identity governance ruling; remotely reachable snapshots still leave and report every source.
-- [x] Multi-host push-on-write uses an isolated temporary Git index populated from approved in-memory blobs rather than pathname re-reads, verifies each committed blob ID, the exact changed-path allowlist, and both author/committer trailers before push, then reconciles only approved paths into the real checkout index. Real-repository controls prove a clean checkout remains clean, a concurrent non-fast-forward fetch/rebase/push remains clean and preserves both findings, destination-path substitution cannot change committed bytes, and unrelated pre-staged secret-shaped content remains staged but never enters the published commit.
-- [x] Doctor Git observations preserve three states: `clean`, `dirty`, and `unmeasurable`; failed remote, branch, or status measurements emit hard `brain-git-state-indeterminate` findings rather than mismatch or ready. The boolean-literal guard sweep covered all MB-BRAIN production files in the 20-file PR population: its only remaining `=== false` guard is the non-nullable `isAbsolute()` predicate; no nullable boolean measurement guards remain.
-- [x] Author-run Review 10 and focused 88/88 evidence were declared void when blocker fixes changed the head; neither is an independent gate pass.
-- [ ] Installer shell P7 invocation after C1 + MC-CRED integration; production command is registered but the C1 shell has not yet called it.
-- [ ] Implementation green on merged dependency base.
-- [ ] Independent code review.
-- [ ] Independent security review.
-- [ ] HOMELAB CI terminal green at exact head.
-- [ ] Reviewed PR retargeted to `main` after C1 and MC-CRED; `next` remains non-merging integration only.
-
-## Completion language
-
-After reviewed merge to `main`, only: **believed-fixed, pending jarvis validation**. Issue #1051 remains open until W-jarvis validates the installed result.

packages/mosaic/framework/tools/git/detect-platform.sh

@@ -499,8 +499,17 @@ get_gitea_url_for_host() {
 
 # Resolve a Gitea API token for the given host.
 # Priority: Mosaic credential loader → GITEA_TOKEN env → ~/.git-credentials
+_trace_credential_resolution() {
+    [[ "${MOSAIC_CREDENTIAL_TRACE:-}" == 1 ]] || return 0
+    local reason="$1" identity="$2" host="$3" source="$4"
+    local shared_path_entered=false
+    [[ "$_resolution_path" == shared ]] && shared_path_entered=true
+    printf 'MOSAIC_CREDENTIAL_RESOLUTION outcome=ok reason=%s identity=%s host=%s resolution_path=%s shared_path_entered=%s source=%s\n' \
+        "$reason" "$identity" "$host" "$_resolution_path" "$shared_path_entered" "$source" >&2
+}
+
 get_gitea_token() {
-    local host="$1"
+    local host="$1" _resolution_path=unresolved
     local script_dir
     script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
     local cred_loader="$script_dir/../_lib/credentials.sh"
@@ -516,6 +525,16 @@ get_gitea_token() {
         _ident="$(git config --get mosaic.gitIdentity 2>/dev/null || true)"
         _ident_src="git config mosaic.gitIdentity"
     fi
+    if [[ -n "$_ident" && ! "$_ident" =~ ^[A-Za-z0-9][A-Za-z0-9_.-]*$ ]]; then
+        printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=invalid-identity identity=<invalid> host=%s shared_path_entered=false source=%s\n' \
+            "$host" "$_ident_src" >&2
+        return 1
+    fi
+    if [[ -n "${MOSAIC_AGENT_NAME:-}" && -n "$_ident" && "$_ident" != "$MOSAIC_AGENT_NAME" ]]; then
+        printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=provider-identity-mismatch identity=%s fleet_identity=%s host=%s shared_path_entered=false source=%s\n' \
+            "$_ident" "$MOSAIC_AGENT_NAME" "$host" "$_ident_src" >&2
+        return 1
+    fi
     if [[ -n "$_ident" ]]; then
         local _idpfx=""
         case "$host" in
@@ -524,8 +543,23 @@ get_gitea_token() {
         esac
         if [[ -n "$_idpfx" ]]; then
             local _idtok="$HOME/.config/mosaic/secrets/gitea-tokens/${_idpfx}-${_ident}.token"
-            if [[ -r "$_idtok" ]]; then
-                cat "$_idtok"
+            local _idcred="$HOME/.config/mosaic/secrets/gitea-tokens/${_idpfx}-${_ident}.credential.json"
+            if [[ -e "$_idcred" || -L "$_idcred" ]]; then
+                local _resolved_token
+                _resolved_token=$(python3 "$script_dir/resolve-credential-envelope.py" \
+                    "$HOME/.config/mosaic/secrets/gitea-tokens" "$_idcred" "$_ident" "${MOSAIC_CREDENTIAL_ESTATE:-}" "$host") || return 1
+                _resolution_path=identity
+                _trace_credential_resolution credential-resolved "$_ident" "$host" "$_ident_src"
+                printf '%s\n' "$_resolved_token"
+                return 0
+            fi
+            if [[ -e "$_idtok" || -L "$_idtok" ]]; then
+                local _resolved_token
+                _resolved_token=$(python3 "$script_dir/resolve-legacy-token.py" \
+                    "$HOME/.config/mosaic/secrets/gitea-tokens" "$_idtok") || return 1
+                _resolution_path=identity
+                _trace_credential_resolution credential-resolved "$_ident" "$host" "$_ident_src"
+                printf '%s\n' "$_resolved_token"
                 return 0
             fi
             # FAIL LOUD: an explicit git identity was requested for a recognized Gitea host,
@@ -534,12 +568,21 @@ get_gitea_token() {
             # would post PRs/issues/reviews under the WRONG agent (e.g. rev2's review attributed
             # to coder3), corrupting Gate-16 author≠reviewer separation. Hard-stop instead so the
             # caller aborts loudly rather than acting as the wrong identity.
-            echo "Error: git identity '$_ident' requested (via $_ident_src) for host '$host', but no per-slot token at $_idtok." >&2
-            echo "       Refusing to borrow another slot's token. Provision the per-slot token, or unset the identity to use shared credentials." >&2
+            printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=no-token-for-identity identity=%s host=%s shared_path_entered=false source=%s path=%s\n' \
+                "$_ident" "$host" "$_ident_src" "$_idtok" >&2
             return 1
         fi
     fi
 
+    # Fleet automation never borrows a shared human/default credential. An
+    # explicit interactive caller may still reach the shared paths below, but
+    # a fleet process must name an identity and resolve that identity exactly.
+    if [[ -n "${MOSAIC_AGENT_NAME:-}" ]]; then
+        printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=identity-required identity=<unset> host=%s shared_path_entered=false source=MOSAIC_AGENT_NAME\n' \
+            "$host" >&2
+        return 1
+    fi
+
     # 1. Mosaic credential loader (host → service mapping, run in subshell to avoid polluting env)
     if [[ -f "$cred_loader" ]]; then
         local token
@@ -571,6 +614,8 @@ get_gitea_token() {
             echo "${GITEA_TOKEN:-}"
         )
         if [[ -n "$token" ]]; then
+            _resolution_path=shared
+            _trace_credential_resolution shared-credential-resolved '<interactive-shared>' "$host" credentials-loader
             echo "$token"
             return 0
         fi
@@ -579,6 +624,8 @@ get_gitea_token() {
     # 2. GITEA_TOKEN env var (only when GITEA_URL, if present, matches the remote host)
     if [[ -n "${GITEA_TOKEN:-}" ]]; then
         if [[ -z "${GITEA_URL:-}" ]] || gitea_url_matches_host "$GITEA_URL" "$host"; then
+            _resolution_path=shared
+            _trace_credential_resolution shared-credential-resolved '<interactive-shared>' "$host" environment
             echo "$GITEA_TOKEN"
             return 0
         fi
@@ -590,6 +637,8 @@ get_gitea_token() {
         local token
         token=$(grep -F "$host" "$creds" 2>/dev/null | sed -n 's#https\?://[^@]*:\([^@/]*\)@.*#\1#p' | head -n 1)
         if [[ -n "$token" ]]; then
+            _resolution_path=shared
+            _trace_credential_resolution shared-credential-resolved '<interactive-shared>' "$host" git-credentials
             echo "$token"
             return 0
         fi

packages/mosaic/framework/tools/git/git-credential-mosaic

@@ -24,29 +24,79 @@ while IFS= read -r line; do
     username=*) username_in=${line#username=};;
   esac
 done
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+trace_resolution() {
+  [ "${MOSAIC_CREDENTIAL_TRACE:-}" = 1 ] || return 0
+  reason="$1" trace_identity="$2" trace_host="$3" source="$4"
+  shared_path_entered=false
+  [ "$resolution_path" = shared ] && shared_path_entered=true
+  printf 'MOSAIC_CREDENTIAL_RESOLUTION outcome=ok reason=%s identity=%s host=%s resolution_path=%s shared_path_entered=%s source=%s\n' \
+    "$reason" "$trace_identity" "$trace_host" "$resolution_path" "$shared_path_entered" "$source" >&2
+}
+resolution_path=unresolved
 # Per-agent identity resolution (Gate-16 author≠reviewer separation).
 # Priority: MOSAIC_GIT_IDENTITY env  >  git config mosaic.gitIdentity (per-worktree,
 # survives across non-persistent shells)  >  git-supplied username (credential.username
 # / URL). When the resolved identity has a matching per-agent token, use it instead of
 # the shared account. Backward-compatible: nothing resolvable → shared token.
+case "$host" in
+  git.uscllc.com) idpfx=gitea-usc;;
+  git.mosaicstack.dev) idpfx=gitea-mosaicstack;;
+  *) idpfx="";;
+esac
 ident="$MOSAIC_GIT_IDENTITY"
 [ -z "$ident" ] && ident=$(git config --get mosaic.gitIdentity 2>/dev/null)
 [ -z "$ident" ] && ident="$username_in"
+if [[ -n "$ident" && ! "$ident" =~ ^[A-Za-z0-9][A-Za-z0-9_.-]*$ ]]; then
+  echo "quit=true"
+  printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=invalid-identity identity=<invalid> host=%s shared_path_entered=false source=git-credential-mosaic\n' "$host" >&2
+  exit 1
+fi
+if [ -n "$idpfx" ] && [ -n "${MOSAIC_AGENT_NAME:-}" ] && [ -n "$ident" ] && [ "$ident" != "$MOSAIC_AGENT_NAME" ]; then
+  echo "quit=true"
+  printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=provider-identity-mismatch identity=%s fleet_identity=%s host=%s shared_path_entered=false source=git-credential-mosaic\n' \
+    "$ident" "$MOSAIC_AGENT_NAME" "$host" >&2
+  exit 1
+fi
 if [ -n "$ident" ]; then
-  case "$host" in
-    git.uscllc.com)      idpfx=gitea-usc;;
-    git.mosaicstack.dev) idpfx=gitea-mosaicstack;;
-    *) idpfx="";;
-  esac
   if [ -n "$idpfx" ]; then
     idtok="$HOME/.config/mosaic/secrets/gitea-tokens/${idpfx}-${ident}.token"
-    if [ -r "$idtok" ]; then
+    idcred="$HOME/.config/mosaic/secrets/gitea-tokens/${idpfx}-${ident}.credential.json"
+    if [ -e "$idcred" ] || [ -L "$idcred" ]; then
+      token=$(python3 "$script_dir/resolve-credential-envelope.py" \
+        "$HOME/.config/mosaic/secrets/gitea-tokens" "$idcred" "$ident" "${MOSAIC_CREDENTIAL_ESTATE:-}" "$host") || exit 1
+      resolution_path=identity
+      trace_resolution credential-resolved "$ident" "$host" git-credential-mosaic
       echo "username=${ident}"
-      echo "password=$(cat "$idtok")"
+      echo "password=${token}"
       exit 0
     fi
+    if [ -e "$idtok" ] || [ -L "$idtok" ]; then
+      token=$(python3 "$script_dir/resolve-legacy-token.py" \
+        "$HOME/.config/mosaic/secrets/gitea-tokens" "$idtok") || exit 1
+      resolution_path=identity
+      trace_resolution credential-resolved "$ident" "$host" git-credential-mosaic
+      echo "username=${ident}"
+      echo "password=${token}"
+      exit 0
+    fi
+    if [ -n "${MOSAIC_AGENT_NAME:-}" ]; then
+      echo "quit=true"
+      printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=no-token-for-identity identity=%s host=%s shared_path_entered=false source=git-credential-mosaic path=%s\n' \
+        "$ident" "$host" "$idtok" >&2
+      exit 1
+    fi
   fi
 fi
+if [ -n "${MOSAIC_AGENT_NAME:-}" ] && [ -z "$ident" ]; then
+  case "$host" in
+    git.uscllc.com|git.mosaicstack.dev)
+      echo "quit=true"
+      printf 'MOSAIC_CREDENTIAL_REFUSAL outcome=refused reason=identity-required identity=<unset> host=%s shared_path_entered=false source=git-credential-mosaic\n' "$host" >&2
+      exit 1
+      ;;
+  esac
+fi
 case "$host" in
   git.uscllc.com)      svc=gitea-usc;;
   git.mosaicstack.dev) svc=gitea-mosaicstack;;
@@ -55,10 +105,11 @@ esac
 # Script-relative (not $HOME-absolute) so this resolves correctly regardless
 # of where the framework installer places tools/ under $HOME — mirrors
 # detect-platform.sh's own cred_loader resolution in this same directory.
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=../_lib/credentials.sh
 source "$script_dir/../_lib/credentials.sh"
 load_credentials "$svc" >/dev/null 2>&1 || exit 0
+resolution_path=shared
+trace_resolution shared-credential-resolved '<interactive-shared>' "$host" credentials-loader
 # GITEA_USER is not populated by load_credentials (it only exports
 # GITEA_URL/GITEA_TOKEN for gitea-*), so this fallback is normally taken. Gitea's
 # git-over-HTTP auth authenticates from the token itself (the password field),

packages/mosaic/framework/tools/git/resolve-credential-envelope.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Fail-closed reader for one governed Mosaic credential envelope."""
+
+import hashlib
+import json
+import os
+import stat
+import sys
+
+MAX_BYTES = 64 * 1024
+EXPECTED_KEYS = {
+    "schemaVersion",
+    "identity",
+    "estate",
+    "host",
+    "providerLogin",
+    "tokenName",
+    "scopes",
+    "createdAt",
+    "tokenDigest",
+    "token",
+}
+
+
+def refuse(message: str) -> None:
+    print(f"credential envelope refused: {message}", file=sys.stderr)
+    raise SystemExit(1)
+
+
+if len(sys.argv) != 6:
+    refuse("expected governed root, path, identity, estate, and host")
+root, path, identity, estate, host = sys.argv[1:]
+if os.path.abspath(os.path.dirname(path)) != os.path.abspath(root):
+    refuse("credential is not a direct child of the governed root")
+if not estate:
+    refuse("explicit estate is required")
+parent = os.path.dirname(path)
+try:
+    parent_stat = os.stat(parent, follow_symlinks=False)
+except OSError:
+    refuse("credential directory unavailable")
+if not stat.S_ISDIR(parent_stat.st_mode) or stat.S_ISLNK(parent_stat.st_mode):
+    refuse("credential directory is not a real directory")
+if parent_stat.st_uid != os.getuid() or parent_stat.st_mode & 0o022:
+    refuse("credential directory owner or mode is unsafe")
+try:
+    fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
+except OSError:
+    refuse("credential file unavailable or symbolic")
+try:
+    file_stat = os.fstat(fd)
+    if not stat.S_ISREG(file_stat.st_mode):
+        refuse("credential is not a regular file")
+    if file_stat.st_uid != os.getuid() or file_stat.st_mode & 0o077:
+        refuse("credential owner or mode is unsafe")
+    content = os.read(fd, MAX_BYTES + 1)
+    if len(content) > MAX_BYTES:
+        refuse("credential exceeds size limit")
+finally:
+    os.close(fd)
+try:
+    value = json.loads(content)
+except (UnicodeDecodeError, json.JSONDecodeError):
+    refuse("credential is not valid JSON")
+if not isinstance(value, dict) or set(value) != EXPECTED_KEYS:
+    refuse("credential schema is not exact")
+if (
+    value.get("schemaVersion") != 1
+    or value.get("identity") != identity
+    or value.get("estate") != estate
+    or value.get("host") != host
+    or value.get("providerLogin") != identity
+):
+    refuse("credential binding does not match requested identity, estate, host, and principal")
+token = value.get("token")
+if not isinstance(token, str) or not token or any(ch.isspace() for ch in token):
+    refuse("credential token is invalid")
+if value.get("tokenDigest") != hashlib.sha256(token.encode()).hexdigest():
+    refuse("credential digest does not match token")
+sys.stdout.write(token + "\n")

packages/mosaic/framework/tools/git/resolve-legacy-token.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Fail-closed reader for one legacy per-seat token file."""
+
+import os
+import stat
+import sys
+
+MAX_BYTES = 16 * 1024
+
+
+def refuse(message: str) -> None:
+    print(f"legacy credential refused: {message}", file=sys.stderr)
+    raise SystemExit(1)
+
+
+if len(sys.argv) != 3:
+    refuse("expected governed root and token path")
+root, path = sys.argv[1:]
+if os.path.abspath(os.path.dirname(path)) != os.path.abspath(root):
+    refuse("credential is not a direct child of the governed root")
+parent = os.path.dirname(path)
+try:
+    parent_stat = os.stat(parent, follow_symlinks=False)
+except OSError:
+    refuse("credential directory unavailable")
+if not stat.S_ISDIR(parent_stat.st_mode) or stat.S_ISLNK(parent_stat.st_mode):
+    refuse("credential directory is not a real directory")
+if parent_stat.st_uid != os.getuid() or parent_stat.st_mode & 0o022:
+    refuse("credential directory owner or mode is unsafe")
+try:
+    fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC)
+except OSError:
+    refuse("credential file unavailable or symbolic")
+try:
+    file_stat = os.fstat(fd)
+    if not stat.S_ISREG(file_stat.st_mode):
+        refuse("credential is not a regular file")
+    if file_stat.st_uid != os.getuid() or file_stat.st_mode & 0o077:
+        refuse("credential owner or mode is unsafe")
+    content = os.read(fd, MAX_BYTES + 1)
+    if len(content) > MAX_BYTES:
+        refuse("credential exceeds size limit")
+finally:
+    os.close(fd)
+try:
+    token = content.decode("utf-8").strip()
+except UnicodeDecodeError:
+    refuse("credential is not UTF-8")
+if not token or any(ch.isspace() for ch in token):
+    refuse("credential token is invalid")
+sys.stdout.write(token + "\n")

packages/mosaic/framework/tools/git/test-git-credential-mosaic.sh

@@ -16,6 +16,7 @@
 # NEVER reads real secrets or touches the real ~/.config/mosaic/secrets.
 
 set -euo pipefail
+umask 077
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/git-credential-mosaic}"
@@ -34,6 +35,8 @@ mkdir -p "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens" \
          "$REPO_DIR"
 
 cp "$SCRIPT_DIR/git-credential-mosaic" "$HELPER"
+cp "$SCRIPT_DIR/resolve-credential-envelope.py" "$FAKE_HOME/.config/mosaic/tools/git/resolve-credential-envelope.py"
+cp "$SCRIPT_DIR/resolve-legacy-token.py" "$FAKE_HOME/.config/mosaic/tools/git/resolve-legacy-token.py"
 chmod +x "$HELPER"
 
 git -C "$REPO_DIR" init -q
@@ -84,6 +87,22 @@ git -C "$REPO_DIR" config --unset mosaic.gitIdentity 2>/dev/null || true
 out=$(run_helper "git.mosaicstack.dev" "")
 assert_eq "shared fallback: username" "username=git" "$(echo "$out" | grep '^username=')"
 assert_eq "shared fallback: password" "password=shared-mosaicstack-token" "$(echo "$out" | grep '^password=')"
+out=$(run_helper "git.mosaicstack.dev" "" MOSAIC_CREDENTIAL_TRACE=1 2>"$WORK_DIR/shared-trace.stderr")
+err=$(cat "$WORK_DIR/shared-trace.stderr")
+if [[ "$err" != *"resolution_path=shared"* || "$err" != *"shared_path_entered=true"* ]]; then
+  echo "FAIL: shared credential materialization did not emit its computed path" >&2
+  fail=1
+fi
+
+set +e
+out=$(run_helper "git.mosaicstack.dev" "" MOSAIC_AGENT_NAME=synthetic-seat 2>"$WORK_DIR/fleet-unset.stderr")
+rc=$?
+set -e
+err=$(cat "$WORK_DIR/fleet-unset.stderr")
+if [[ "$rc" -eq 0 || "$out" != *"quit=true"* || "$err" != *"reason=identity-required"* || "$err" != *"shared_path_entered=false"* ]]; then
+  echo "FAIL: fleet unset identity did not stop at the resolver marker" >&2
+  fail=1
+fi
 
 # ---------------------------------------------------------------------------
 # 2. git-supplied username resolves to an identity WITH a per-slot token ->
@@ -93,6 +112,21 @@ echo -n "agentA-mosaicstack-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-to
 out=$(run_helper "git.mosaicstack.dev" "agentA")
 assert_eq "username-resolved identity: username" "username=agentA" "$(echo "$out" | grep '^username=')"
 assert_eq "username-resolved identity: password" "password=agentA-mosaicstack-token" "$(echo "$out" | grep '^password=')"
+out=$(run_helper "git.mosaicstack.dev" "agentA" MOSAIC_AGENT_NAME=agentA MOSAIC_CREDENTIAL_TRACE=1 2>"$WORK_DIR/identity-trace.stderr")
+err=$(cat "$WORK_DIR/identity-trace.stderr")
+if [[ "$err" != *"resolution_path=identity"* || "$err" != *"shared_path_entered=false"* ]]; then
+  echo "FAIL: identity credential did not emit its computed path" >&2
+  fail=1
+fi
+set +e
+out=$(run_helper "git.mosaicstack.dev" "agentA" MOSAIC_AGENT_NAME=agentB 2>"$WORK_DIR/fleet-mismatch.stderr")
+rc=$?
+set -e
+err=$(cat "$WORK_DIR/fleet-mismatch.stderr")
+if [[ "$rc" -eq 0 || "$out" != *"quit=true"* || "$err" != *"reason=provider-identity-mismatch"* || "$err" != *"shared_path_entered=false"* ]]; then
+  echo "FAIL: fleet identity override was not refused before token resolution" >&2
+  fail=1
+fi
 
 # ---------------------------------------------------------------------------
 # 3. git config mosaic.gitIdentity (per-worktree) beats git-supplied username.
@@ -120,6 +154,16 @@ out=$(run_helper "git.mosaicstack.dev" "no-such-agent")
 assert_eq "no per-slot token: username" "username=git" "$(echo "$out" | grep '^username=')"
 assert_eq "no per-slot token: password" "password=shared-mosaicstack-token" "$(echo "$out" | grep '^password=')"
 
+set +e
+out=$(run_helper "git.mosaicstack.dev" "no-such-agent" MOSAIC_AGENT_NAME=no-such-agent 2>"$WORK_DIR/fleet-missing.stderr")
+rc=$?
+set -e
+err=$(cat "$WORK_DIR/fleet-missing.stderr")
+if [[ "$rc" -eq 0 || "$out" != *"quit=true"* || "$err" != *"reason=no-token-for-identity"* || "$err" != *"shared_path_entered=false"* ]]; then
+  echo "FAIL: fleet missing token did not stop at the resolver marker" >&2
+  fail=1
+fi
+
 # ---------------------------------------------------------------------------
 # 6. Correct per-slot token PATH is chosen per host: same agent id, different
 #    host prefix (gitea-usc- vs gitea-mosaicstack-).
@@ -135,14 +179,45 @@ assert_eq "host-scoped token path (cross-host must not leak): username" "usernam
 assert_eq "host-scoped token path (cross-host must not leak): password" "password=shared-mosaicstack-token" "$(echo "$out" | grep '^password=')"
 
 # ---------------------------------------------------------------------------
-# 7. Unrelated/unknown host -> exit 0, no output (passthrough for non-Gitea
+# 7. Governed envelopes use the same binding, owner, mode, and digest checks.
+# ---------------------------------------------------------------------------
+envelope="$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentE.credential.json"
+python3 - "$envelope" <<'PY'
+import hashlib, json, sys
+secret = "agentE-envelope-token"
+json.dump({
+  "schemaVersion": 1, "identity": "agentE", "estate": "homelab",
+  "host": "git.mosaicstack.dev", "providerLogin": "agentE",
+  "tokenName": "mosaic-agentE-1", "scopes": ["write:repository"],
+  "createdAt": "2026-08-05T00:00:00.000Z",
+  "tokenDigest": hashlib.sha256(secret.encode()).hexdigest(), "token": secret,
+}, open(sys.argv[1], "w", encoding="utf-8"))
+PY
+chmod 600 "$envelope"
+out=$(run_helper "git.mosaicstack.dev" "agentE" MOSAIC_AGENT_NAME=agentE MOSAIC_CREDENTIAL_ESTATE=homelab)
+assert_eq "governed envelope: password" "password=agentE-envelope-token" "$(echo "$out" | grep '^password=')"
+echo -n "must-not-fallback-legacy" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentE.token"
+chmod 640 "$envelope"
+set +e
+out=$(run_helper "git.mosaicstack.dev" "agentE" MOSAIC_AGENT_NAME=agentE MOSAIC_CREDENTIAL_ESTATE=homelab 2>"$WORK_DIR/envelope-mode.stderr")
+rc=$?
+set -e
+if [[ "$rc" -eq 0 || "$out" == *"password="* ]]; then
+  echo "FAIL: permissive envelope was consumed" >&2
+  fail=1
+fi
+
+# ---------------------------------------------------------------------------
+# 8. Unrelated/unknown host -> exit 0, no output (passthrough for non-Gitea
 #    remotes, e.g. github.com via a different credential helper).
 # ---------------------------------------------------------------------------
 out=$(run_helper "github.com" "agentA")
 assert_eq "unknown host: no output" "" "$out"
+out=$(run_helper "github.com" "github-user" MOSAIC_AGENT_NAME=agentA)
+assert_eq "unknown host in fleet context: no output" "" "$out"
 
 # ---------------------------------------------------------------------------
-# 8. Non-"get" verb (store/erase) -> exit 0, no output (git-credential
+# 9. Non-"get" verb (store/erase) -> exit 0, no output (git-credential
 #    protocol: this helper only implements get).
 # ---------------------------------------------------------------------------
 store_out=$(cd "$REPO_DIR" && env -i HOME="$FAKE_HOME" PATH="$PATH" bash "$HELPER" store <<EOF

packages/mosaic/framework/tools/git/test-gitea-token-identity.sh

@@ -28,6 +28,7 @@
 # HOME. NEVER reads real secrets or touches the real ~/.config/mosaic/secrets.
 
 set -euo pipefail
+umask 077
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/gitea-token-identity}"
@@ -85,7 +86,23 @@ call_get_gitea_token() {
 # ---------------------------------------------------------------------------
 git -C "$REPO_DIR" config --unset mosaic.gitIdentity 2>/dev/null || true
 out=$(call_get_gitea_token "git.mosaicstack.dev")
-assert_eq "shared fallback (no identity)" "shared-mosaicstack-token" "$out"
+assert_eq "interactive shared fallback (no identity)" "shared-mosaicstack-token" "$out"
+
+# Fleet context with no explicit identity refuses before the shared path. This
+# is the marker-emission positive control for the fail-closed mechanism.
+set +e
+out=$(call_get_gitea_token "git.mosaicstack.dev" MOSAIC_AGENT_NAME=synthetic-seat 2>"$WORK_DIR/stderr-fleet-unset.tmp")
+rc=$?
+set -e
+err=$(cat "$WORK_DIR/stderr-fleet-unset.tmp")
+if [[ "$rc" -eq 0 || -n "$out" ]]; then
+  echo "FAIL: fleet unset identity must refuse with empty stdout" >&2
+  fail=1
+fi
+if [[ "$err" != *"MOSAIC_CREDENTIAL_REFUSAL"* || "$err" != *"reason=identity-required"* || "$err" != *"shared_path_entered=false"* ]]; then
+  echo "FAIL: fleet unset identity did not emit the stable resolver refusal marker: $err" >&2
+  fail=1
+fi
 
 # ---------------------------------------------------------------------------
 # 2. git config mosaic.gitIdentity resolves to an agent WITH a per-slot
@@ -93,8 +110,17 @@ assert_eq "shared fallback (no identity)" "shared-mosaicstack-token" "$out"
 # ---------------------------------------------------------------------------
 echo -n "agentA-mosaicstack-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentA.token"
 git -C "$REPO_DIR" config mosaic.gitIdentity agentA
-out=$(call_get_gitea_token "git.mosaicstack.dev")
-assert_eq "git-config identity token" "agentA-mosaicstack-token" "$out"
+out=$(call_get_gitea_token "git.mosaicstack.dev" MOSAIC_AGENT_NAME=agentA)
+assert_eq "confirmed fleet identity bypasses shared path" "agentA-mosaicstack-token" "$out"
+set +e
+out=$(call_get_gitea_token "git.mosaicstack.dev" MOSAIC_AGENT_NAME=agentA MOSAIC_GIT_IDENTITY=agentB 2>"$WORK_DIR/fleet-mismatch.stderr")
+rc=$?
+set -e
+err=$(cat "$WORK_DIR/fleet-mismatch.stderr")
+if [[ "$rc" -eq 0 || -n "$out" || "$err" != *"reason=provider-identity-mismatch"* || "$err" != *"shared_path_entered=false"* ]]; then
+  echo "FAIL: fleet identity override was not refused before token resolution" >&2
+  fail=1
+fi
 
 # ---------------------------------------------------------------------------
 # 3. MOSAIC_GIT_IDENTITY env beats git config mosaic.gitIdentity.
@@ -143,13 +169,17 @@ assert_failloud() {
     echo "$stderr" >&2
     fail=1
   fi
+  if [[ "$stderr" != *"MOSAIC_CREDENTIAL_REFUSAL"* || "$stderr" != *"reason=no-token-for-identity"* || "$stderr" != *"shared_path_entered=false"* ]]; then
+    echo "FAIL: $desc — stable resolver refusal marker missing: $stderr" >&2
+    fail=1
+  fi
   if [[ "$stderr" != *"$expected_tok_path"* ]]; then
     echo "FAIL: $desc — stderr does not name the expected per-slot token path '$expected_tok_path':" >&2
     echo "$stderr" >&2
     fail=1
   fi
-  if [[ "$stderr" == *"shared"*"token"* ]]; then
-    echo "FAIL: $desc — stderr unexpectedly mentions a shared token value:" >&2
+  if [[ "$stderr" == *"shared-mosaicstack-token"* || "$stderr" == *"shared-usc-token"* ]]; then
+    echo "FAIL: $desc — stderr unexpectedly contains a shared credential value:" >&2
     echo "$stderr" >&2
     fail=1
   fi

packages/mosaic/src/cli.ts

@@ -14,6 +14,7 @@ import { registerTelemetryCommand } from './commands/telemetry.js';
 import { registerAgentCommand } from './commands/agent.js';
 import { registerInteractionCommand } from './commands/interaction.js';
 import { registerConfigCommand } from './commands/config.js';
+import { registerCredentialCommand } from './commands/cred.js';
 import { registerFleetCommand } from './commands/fleet.js';
 import { registerMissionCommand } from './commands/mission.js';
 import { registerUninstallCommand } from './commands/uninstall.js';
@@ -23,7 +24,6 @@ import { registerSkillCommand } from './commands/skill.js';
 import { registerLaunchCommands } from './commands/launch.js';
 import { registerLeaseCapabilityProbe } from './commands/lease-activation-probe.js';
 import { registerInstallOrderingGuardCommand } from './commands/install-ordering-guard.js';
-import { registerBrainProvisionCommand } from './commands/brain-provision-command.js';
 import { registerAuthCommand } from './commands/auth.js';
 import { registerFederationCommand } from './commands/federation.js';
 import { registerGatewayCommand } from './commands/gateway.js';
@@ -86,10 +86,6 @@ registerLeaseCapabilityProbe(program);
 
 registerInstallOrderingGuardCommand(program);
 
-// ─── durable brain P7 provisioner (hidden; #1051) ───────────────────────
-
-registerBrainProvisionCommand(program);
-
 // ─── login ──────────────────────────────────────────────────────────────
 
 program
@@ -376,6 +372,10 @@ registerInteractionCommand(program);
 
 registerFleetCommand(program);
 
+// ─── credential governance ─────────────────────────────────────────────
+
+registerCredentialCommand(program);
+
 // ─── config ────────────────────────────────────────────────────────────
 
 registerConfigCommand(program);

packages/mosaic/src/commands/brain-doctor-check.spec.ts

@@ -1,272 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-interface CommandRequest {
-  readonly program: 'git' | 'mosaic';
-  readonly args: readonly string[];
-  readonly env: Readonly<Record<string, string>>;
-}
-
-interface CommandResult {
-  readonly status: number;
-  readonly stdout: string;
-  readonly stderr: string;
-}
-
-interface InstalledDoctorResult {
-  readonly status: 'ok' | 'warn' | 'error';
-  readonly findings: readonly {
-    readonly code: string;
-    readonly reasonCode: string | null;
-  }[];
-  readonly lines: readonly string[];
-}
-
-interface BrainDoctorModule {
-  runInstalledBrainDoctorCheck(
-    options: {
-      readonly mosaicHome: string;
-      readonly home: string;
-      readonly identity?: string;
-      readonly fix: boolean;
-    },
-    run: (request: CommandRequest) => CommandResult,
-  ): InstalledDoctorResult;
-}
-
-const MODULE_PATH = './brain-doctor-check.js';
-const roots: string[] = [];
-
-async function loadDoctor(requirement: string): Promise<BrainDoctorModule> {
-  try {
-    return (await import(MODULE_PATH)) as BrainDoctorModule;
-  } catch (error: unknown) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${requirement}: installed brain doctor check is absent (${detail})`);
-  }
-}
-
-function tempRoot(): string {
-  const root = mkdtempSync(join(tmpdir(), 'mosaic-brain-doctor-'));
-  roots.push(root);
-  return root;
-}
-
-function installConfig(root: string): { readonly home: string; readonly mosaicHome: string } {
-  const home = join(root, 'home');
-  const mosaicHome = join(home, '.config', 'mosaic');
-  mkdirSync(join(mosaicHome, 'cred'), { recursive: true });
-  mkdirSync(join(mosaicHome, 'brain'), { recursive: true });
-  writeFileSync(
-    join(mosaicHome, 'cred', 'estates.json'),
-    JSON.stringify({
-      version: 1,
-      estates: [
-        {
-          name: 'homelab',
-          readOnlyControlIdentity: 'read-control',
-          hosts: [
-            {
-              host: 'git.example.invalid',
-              provider: 'gitea',
-              apiBaseUrl: 'https://git.example.invalid',
-              tokenPrefix: 'gitea-example',
-            },
-          ],
-        },
-      ],
-    }),
-    { mode: 0o600 },
-  );
-  writeFileSync(
-    join(mosaicHome, 'brain', 'owners.json'),
-    JSON.stringify({
-      version: 1,
-      estates: [
-        {
-          estate: 'homelab',
-          laneArchiveOwners: [{ kind: 'provider-user', login: 'durable-owner' }],
-          standingProcess: { kind: 'glpi-queue', queue: 'mosaic-brain-remediation' },
-          controls: { publicIdentity: 'public-control', privateIdentity: 'private-control' },
-        },
-      ],
-    }),
-    { mode: 0o600 },
-  );
-  writeFileSync(
-    join(mosaicHome, '.install-manifest.json'),
-    JSON.stringify({
-      version: 2,
-      status: 'committed',
-      sourceRepo: 'https://git.example.invalid/example/stack.git',
-    }),
-    { mode: 0o600 },
-  );
-  return { home, mosaicHome };
-}
-
-function validateResult(outcome: 'ok' | 'refused' | 'indeterminate', reasonCode: string): string {
-  const exitCode = outcome === 'ok' ? 0 : outcome === 'refused' ? 10 : 30;
-  return JSON.stringify({
-    schemaVersion: 1,
-    operation: 'validate',
-    outcome,
-    exitCode,
-    retryable: false,
-    subject: {
-      identity: 'seat-a',
-      estate: 'homelab',
-      host: 'git.example.invalid',
-      repo: 'durable-owner/mosaic-brain',
-    },
-    mutation: 'none',
-    reason: { code: reasonCode, message: 'non-secret' },
-    evidence: {
-      providerIdentity:
-        outcome === 'ok'
-          ? {
-              login: 'seat-a',
-              endpoint: 'GET /api/v1/user',
-              contentType: 'application/json',
-            }
-          : null,
-      repositoryPermission:
-        outcome === 'ok'
-          ? {
-              requested: 'write',
-              effective: 'write',
-              endpoint: 'GET /api/v1/repos/durable-owner/mosaic-brain',
-              contentType: 'application/json',
-            }
-          : null,
-      writeDifferential:
-        outcome === 'ok'
-          ? {
-              state: 'can-write',
-              credentialBinding: 'same-resolution',
-              transportPrincipal: 'seat-a',
-              authenticatedReceivePack: 'advertised',
-              readOnlyControl: {
-                identity: 'read-control',
-                providerPermission: 'read',
-                receivePack: 'refused',
-              },
-              unauthenticatedReceivePack: 'refused',
-              artifactCreated: false,
-              proves: 'non-secret evidence',
-              doesNotProve: 'branch update acceptance',
-            }
-          : null,
-    },
-    audit: { journalId: 'opaque', state: 'sealed' },
-  });
-}
-
-afterEach((): void => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-describe('installed mosaic doctor brain checks', (): void => {
-  it('derives the target from the committed install manifest and surfaces a missing clone plus refusal', async (): Promise<void> => {
-    const doctor = await loadDoctor('MB-REQ-08 installed doctor missing clone');
-    const config = installConfig(tempRoot());
-    const requests: CommandRequest[] = [];
-
-    const result = doctor.runInstalledBrainDoctorCheck(
-      { ...config, identity: 'seat-a', fix: false },
-      (request): CommandResult => {
-        requests.push(request);
-        return {
-          status: 10,
-          stdout: validateResult('refused', 'no-token-for-identity'),
-          stderr: 'refused reason=no-token-for-identity',
-        };
-      },
-    );
-
-    expect(result.status).toBe('warn');
-    expect(result.findings.map((finding) => finding.code)).toEqual(
-      expect.arrayContaining(['brain-clone-missing', 'brain-write-access-refused']),
-    );
-    expect(result.lines.join('\n')).toMatch(/brain-clone-missing/);
-    expect(result.lines.join('\n')).toMatch(/no-token-for-identity/);
-    expect(requests[0]?.args).toContain('durable-owner/mosaic-brain');
-  });
-
-  it('fails closed without an explicit identity and performs no command', async (): Promise<void> => {
-    const doctor = await loadDoctor('MB-REQ-08 explicit identity');
-    const config = installConfig(tempRoot());
-    let calls = 0;
-
-    const result = doctor.runInstalledBrainDoctorCheck(
-      { ...config, fix: false },
-      (): CommandResult => {
-        calls += 1;
-        return { status: 0, stdout: '', stderr: '' };
-      },
-    );
-
-    expect(result).toMatchObject({
-      status: 'error',
-      findings: [{ code: 'brain-identity-required', reasonCode: 'identity-required' }],
-    });
-    expect(calls).toBe(0);
-  });
-
-  it('treats identity-not-measured as an error, not no-write refusal and not a repairable grant case', async (): Promise<void> => {
-    const doctor = await loadDoctor('MB-REQ-08 identity measurement axis');
-    const config = installConfig(tempRoot());
-    const requests: CommandRequest[] = [];
-
-    const result = doctor.runInstalledBrainDoctorCheck(
-      { ...config, identity: 'seat-a', fix: true },
-      (request): CommandResult => {
-        requests.push(request);
-        return {
-          status: 30,
-          stdout: validateResult('indeterminate', 'identity-not-measured'),
-          stderr: 'identity not measured',
-        };
-      },
-    );
-
-    expect(result.status).toBe('error');
-    expect(result.findings).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          code: 'brain-write-access-indeterminate',
-          reasonCode: 'identity-not-measured',
-        }),
-      ]),
-    );
-    expect(requests.some((request) => request.args.includes('grant'))).toBe(false);
-  });
-
-  it('is wired into the top-level mosaic doctor path before the shell audit runs', (): void => {
-    const launch = readFileSync(join(process.cwd(), 'src', 'commands', 'launch.ts'), 'utf8');
-
-    expect(launch).toContain('runInstalledBrainDoctorCheck');
-    expect(launch).toContain('defaultInstalledBrainDoctorOptions');
-    expect(launch).toContain('systemCommandRunner');
-    expect(launch).toMatch(/brainCheckFailed[\s\S]*runDoctorScriptAndExit/);
-  });
-
-  it('reports a missing or unsafe registry/manifest as configuration error rather than defaulting estate', async (): Promise<void> => {
-    const doctor = await loadDoctor('MB-REQ-02 missing mapping fail-closed');
-    const root = tempRoot();
-    const home = join(root, 'home');
-    const mosaicHome = join(home, '.config', 'mosaic');
-    mkdirSync(mosaicHome, { recursive: true });
-
-    const result = doctor.runInstalledBrainDoctorCheck(
-      { home, mosaicHome, identity: 'seat-a', fix: false },
-      (): CommandResult => ({ status: 0, stdout: '', stderr: '' }),
-    );
-
-    expect(result.status).toBe('error');
-    expect(result.findings[0]?.code).toMatch(/brain-(estate-registry|install-manifest)-/);
-    expect(result.lines.join('\n')).not.toMatch(/homelab|usc/);
-  });
-});

packages/mosaic/src/commands/brain-doctor-check.ts

@@ -1,152 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { z } from 'zod';
-import { readBrainConfigSecure } from './brain-secure-config.js';
-import { resolveBrainOwnerPolicy } from './brain-owner-resolver.js';
-import { deriveBrainTarget } from './brain-store.js';
-import {
-  collectBrainDoctorReport,
-  repairBrainDoctor,
-  type CommandRunner,
-  type DoctorRuntimeReport,
-} from './brain-store-runtime.js';
-
-const IDENTITY = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
-const manifestSchema = z
-  .object({
-    version: z.literal(2),
-    status: z.literal('committed'),
-    sourceRepo: z.string().min(1),
-  })
-  .passthrough();
-
-export interface InstalledDoctorFinding {
-  readonly code: string;
-  readonly reasonCode: string | null;
-}
-
-export interface InstalledDoctorResult {
-  readonly status: 'ok' | 'warn' | 'error';
-  readonly findings: readonly InstalledDoctorFinding[];
-  readonly lines: readonly string[];
-}
-
-function configurationError(code: string, reasonCode = code): InstalledDoctorResult {
-  return {
-    status: 'error',
-    findings: [{ code, reasonCode }],
-    lines: [`[mosaic-doctor] [ERROR] ${code}`],
-  };
-}
-
-function renderReport(report: DoctorRuntimeReport): InstalledDoctorResult {
-  const findings = report.findings.map(
-    (finding): InstalledDoctorFinding => ({
-      code: finding.code,
-      reasonCode: finding.reasonCode,
-    }),
-  );
-  const hard = findings.some(
-    (finding): boolean =>
-      finding.code.endsWith('-error') ||
-      finding.code.endsWith('-indeterminate') ||
-      finding.code === 'brain-not-git-repository' ||
-      finding.code === 'brain-root-permissions-unsafe',
-  );
-  const status: InstalledDoctorResult['status'] =
-    findings.length === 0 ? 'ok' : hard ? 'error' : 'warn';
-  const severity = status === 'error' ? 'ERROR' : status === 'warn' ? 'WARN' : 'OK';
-  const lines =
-    findings.length === 0
-      ? ['[mosaic-doctor] [OK] mosaic-brain ready']
-      : findings.map(
-          (finding): string =>
-            `[mosaic-doctor] [${severity}] ${finding.code}${
-              finding.reasonCode === null ? '' : ` reason=${finding.reasonCode}`
-            }`,
-        );
-  return { status, findings, lines };
-}
-
-export function runInstalledBrainDoctorCheck(
-  options: {
-    readonly mosaicHome: string;
-    readonly home: string;
-    readonly identity?: string;
-    readonly fix: boolean;
-  },
-  run: CommandRunner,
-): InstalledDoctorResult {
-  if (options.identity === undefined || !IDENTITY.test(options.identity)) {
-    return configurationError('brain-identity-required', 'identity-required');
-  }
-
-  const registryPath = join(options.mosaicHome, 'cred', 'estates.json');
-  const manifestPath = join(options.mosaicHome, '.install-manifest.json');
-  const ownerPolicyPath = join(options.mosaicHome, 'brain', 'owners.json');
-  let registrySource: string;
-  try {
-    registrySource = readBrainConfigSecure(registryPath, options.mosaicHome);
-  } catch {
-    return configurationError('brain-estate-registry-unavailable');
-  }
-  let manifestSource: string;
-  try {
-    manifestSource = readBrainConfigSecure(manifestPath, options.mosaicHome);
-  } catch {
-    return configurationError('brain-install-manifest-unavailable');
-  }
-  let manifestRaw: unknown;
-  try {
-    manifestRaw = JSON.parse(manifestSource);
-  } catch {
-    return configurationError('brain-install-manifest-invalid');
-  }
-  const manifest = manifestSchema.safeParse(manifestRaw);
-  if (!manifest.success) return configurationError('brain-install-manifest-invalid');
-  let ownerPolicySource: string;
-  try {
-    ownerPolicySource = readBrainConfigSecure(ownerPolicyPath, options.mosaicHome);
-  } catch {
-    return configurationError('brain-owner-policy-unavailable');
-  }
-  let preliminaryTarget: ReturnType<typeof deriveBrainTarget>;
-  try {
-    preliminaryTarget = deriveBrainTarget(registrySource, manifest.data.sourceRepo, 'policy-probe');
-  } catch {
-    return configurationError('brain-estate-registry-invalid');
-  }
-  const ownerPolicy = resolveBrainOwnerPolicy(ownerPolicySource, preliminaryTarget.estate);
-  if (ownerPolicy === undefined) return configurationError('brain-owner-policy-invalid');
-
-  const input = {
-    registrySource,
-    targetGitUrl: manifest.data.sourceRepo,
-    brainNamespace: ownerPolicy.brainNamespace,
-    identity: options.identity,
-    root: join(options.home, '.mosaic'),
-  };
-  try {
-    return renderReport(
-      options.fix ? repairBrainDoctor(input, run) : collectBrainDoctorReport(input, run),
-    );
-  } catch {
-    return configurationError('brain-estate-registry-invalid');
-  }
-}
-
-export function defaultInstalledBrainDoctorOptions(fix: boolean): {
-  readonly mosaicHome: string;
-  readonly home: string;
-  readonly identity?: string;
-  readonly fix: boolean;
-} {
-  const home = homedir();
-  const identity = process.env['MOSAIC_GIT_IDENTITY'];
-  return {
-    mosaicHome: process.env['MOSAIC_HOME'] ?? join(home, '.config', 'mosaic'),
-    home,
-    ...(identity === undefined ? {} : { identity }),
-    fix,
-  };
-}

packages/mosaic/src/commands/brain-installer-integration.spec.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-function installerSource(): string {
-  return readFileSync(join(process.cwd(), '..', '..', 'tools', 'install.sh'), 'utf8');
-}
-
-describe('root installer P7 durable-brain integration', (): void => {
-  it('records the configured source repository in the committed manifest for doctor derivation', (): void => {
-    const installer = installerSource();
-
-    expect(installer).toContain('sourceRepo:');
-    expect(installer).toMatch(/sourceRepo:\s*process\.argv\[/);
-    expect(installer).toMatch(/MANIFEST_SOURCE_REPO/);
-  });
-
-  it('invokes the broker-only provision command in P7 with explicit owner and refusal controls', (): void => {
-    const installer = installerSource();
-    const provision = installer.indexOf('__brain-provision');
-    const p7 = installer.indexOf('state_phase_begin P7');
-
-    expect(provision).toBeGreaterThan(-1);
-    expect(p7).toBeGreaterThan(-1);
-    expect(provision).toBeGreaterThan(p7);
-    for (const flag of [
-      '--identity',
-      '--target-url',
-      '--owner',
-      '--refusal-identity',
-      '--lane',
-      '--owner-policy',
-    ]) {
-      expect(installer).toContain(flag);
-    }
-    expect(installer).not.toMatch(/__brain-provision[^\n]*(?:token|password|authorization)/i);
-  });
-
-  it('journals ~/.mosaic and the owner policy as P7 mutations and checks the resulting object', (): void => {
-    const installer = installerSource();
-
-    expect(installer).toContain('state_record_mutation P7 "$HOME/.mosaic"');
-    expect(installer).toContain('state_record_mutation P7 "$MOSAIC_HOME/brain/owners.json"');
-    expect(installer).toMatch(/P7\)[\s\S]*\.mosaic[\s\S]*(?:remote|get-url)[\s\S]*main/);
-  });
-
-  it('discovers every legacy lane directory rather than silently migrating only one lane', (): void => {
-    const installer = installerSource();
-
-    expect(installer).toMatch(/memory\/lanes/);
-    expect(installer).toMatch(/for\s+[^\n]*lane/);
-    expect(installer).toMatch(/__brain-provision[\s\S]*--lane/);
-  });
-});

packages/mosaic/src/commands/brain-owner-resolver.spec.ts

@@ -1,373 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-/**
- * Red-first owner-authority resolver contract for #1051.
- *
- * Fixtures are operator-agnostic. The HOMELAB owner name belongs in the local
- * estate policy, never in framework source. Anonymous lookup is intentional:
- * the ruled owner class is PUBLIC and least-privilege seats may lack read:user.
- */
-
-interface MigrationOwnerResolution {
-  readonly verdict: 'resolved' | 'refused' | 'not-measured';
-  readonly reasonCode: string;
-  readonly principal: {
-    readonly name: string;
-    readonly kind: 'durable-human';
-  } | null;
-  readonly authority: {
-    readonly system: 'gitea';
-    readonly endpoint: string;
-    readonly contentType: 'application/json';
-  } | null;
-}
-
-type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-
-interface OwnerResolverModule {
-  resolveProviderDurableOwner(
-    input: {
-      readonly estateRegistrySource: string;
-      readonly ownerPolicySource: string;
-      readonly host: string;
-      readonly requestedOwner: string;
-    },
-    dependencies: {
-      readonly fetch: FetchLike;
-      readonly absentControlName: () => string;
-    },
-  ): Promise<MigrationOwnerResolution>;
-}
-
-const MODULE_PATH = './brain-owner-resolver.js';
-
-async function loadResolver(requirement: string): Promise<OwnerResolverModule> {
-  try {
-    return (await import(MODULE_PATH)) as OwnerResolverModule;
-  } catch (error: unknown) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${requirement}: brain owner resolver is absent (${detail})`);
-  }
-}
-
-function estateRegistry(): string {
-  return JSON.stringify({
-    version: 1,
-    estates: [
-      {
-        name: 'homelab',
-        readOnlyControlIdentity: 'read-control',
-        hosts: [
-          {
-            host: 'git.example.invalid',
-            provider: 'gitea',
-            apiBaseUrl: 'https://git.example.invalid',
-            tokenPrefix: 'gitea-example',
-          },
-        ],
-      },
-    ],
-  });
-}
-
-function ownerPolicy(): string {
-  return JSON.stringify({
-    version: 1,
-    estates: [
-      {
-        estate: 'homelab',
-        laneArchiveOwners: [{ kind: 'provider-user', login: 'durable-owner' }],
-        standingProcess: { kind: 'glpi-queue', queue: 'mosaic-brain-remediation' },
-        controls: {
-          publicIdentity: 'public-control',
-          privateIdentity: 'private-control',
-        },
-      },
-    ],
-  });
-}
-
-function jsonResponse(status: number, body: unknown): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'content-type': 'application/json; charset=utf-8' },
-  });
-}
-
-function publicUser(login: string, active = false): Response {
-  return jsonResponse(200, {
-    id: 42,
-    login,
-    visibility: 'public',
-    active,
-  });
-}
-
-function identityFromUrl(input: string | URL | Request): string {
-  const value = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
-  return decodeURIComponent(new URL(value).pathname.split('/').at(-1) ?? '');
-}
-
-function controlledFetch(
-  overrides: Readonly<Record<string, Response>> = {},
-  calls: Array<{ identity: string; authorization: string | null }> = [],
-): FetchLike {
-  return async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
-    const identity = identityFromUrl(input);
-    const headers = new Headers(init?.headers);
-    calls.push({ identity, authorization: headers.get('authorization') });
-    const override = overrides[identity];
-    if (override !== undefined) return override.clone();
-    if (identity === 'public-control') return publicUser('public-control');
-    if (identity === 'private-control' || identity === 'generated-absent-control') {
-      return jsonResponse(404, { message: 'not found' });
-    }
-    if (identity === 'durable-owner') return publicUser('durable-owner', false);
-    return jsonResponse(404, { message: 'not found' });
-  };
-}
-
-describe('provider-backed durable owner resolver', (): void => {
-  it('resolves an allowlisted PUBLIC owner by exact login with public/private/absent controls and ignores active=false', async (): Promise<void> => {
-    const resolver = await loadResolver('MB-REQ-09 provider owner resolution');
-    const calls: Array<{ identity: string; authorization: string | null }> = [];
-
-    const result = await resolver.resolveProviderDurableOwner(
-      {
-        estateRegistrySource: estateRegistry(),
-        ownerPolicySource: ownerPolicy(),
-        host: 'git.example.invalid',
-        requestedOwner: 'user:durable-owner',
-      },
-      {
-        fetch: controlledFetch({}, calls),
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toEqual({
-      verdict: 'resolved',
-      reasonCode: 'owner-verified',
-      principal: { name: 'user:durable-owner', kind: 'durable-human' },
-      authority: {
-        system: 'gitea',
-        endpoint: 'GET /api/v1/users/durable-owner',
-        contentType: 'application/json',
-      },
-    });
-    expect(calls.map((call) => call.identity)).toEqual([
-      'public-control',
-      'private-control',
-      'generated-absent-control',
-      'durable-owner',
-    ]);
-    expect(calls.every((call) => call.authorization === null)).toBe(true);
-  });
-
-  it('refuses provider redirects and configures a bounded no-redirect request', async (): Promise<void> => {
-    const resolver = await loadResolver('MB-REQ-09 owner lookup SSRF boundary');
-    const requests: RequestInit[] = [];
-
-    const result = await resolver.resolveProviderDurableOwner(
-      {
-        estateRegistrySource: estateRegistry(),
-        ownerPolicySource: ownerPolicy(),
-        host: 'git.example.invalid',
-        requestedOwner: 'user:durable-owner',
-      },
-      {
-        fetch: async (_input, init): Promise<Response> => {
-          requests.push(init ?? {});
-          return new Response(JSON.stringify({ message: 'redirect' }), {
-            status: 302,
-            headers: {
-              'content-type': 'application/json',
-              location: 'http://127.0.0.1/internal',
-            },
-          });
-        },
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toMatchObject({ verdict: 'not-measured', reasonCode: 'owner-control-invalid' });
-    expect(requests).toHaveLength(1);
-    expect(requests[0]?.redirect).toBe('manual');
-    expect(requests[0]?.signal).toBeInstanceOf(AbortSignal);
-  });
-
-  it('cancels a chunked provider body as soon as it exceeds the byte ceiling', async (): Promise<void> => {
-    const resolver = await loadResolver('MB-REQ-09 bounded owner response stream');
-    let cancelled = false;
-    const oversized = new ReadableStream<Uint8Array>({
-      start(controller): void {
-        controller.enqueue(new Uint8Array(200_000));
-        controller.enqueue(new Uint8Array(100_000));
-      },
-      cancel(): void {
-        cancelled = true;
-      },
-    });
-
-    const result = await resolver.resolveProviderDurableOwner(
-      {
-        estateRegistrySource: estateRegistry(),
-        ownerPolicySource: ownerPolicy(),
-        host: 'git.example.invalid',
-        requestedOwner: 'user:durable-owner',
-      },
-      {
-        fetch: async (): Promise<Response> =>
-          new Response(oversized, {
-            status: 200,
-            headers: { 'content-type': 'application/json' },
-          }),
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toMatchObject({
-      verdict: 'not-measured',
-      reasonCode: 'owner-unexpected-provider-shape',
-    });
-    expect(cancelled).toBe(true);
-  });
-
-  it('requires the GLPI standing remediation queue in the local estate policy', async (): Promise<void> => {
-    const resolver = await loadResolver('MB-REQ-09 standing process policy');
-    const raw = JSON.parse(ownerPolicy()) as { estates: Array<Record<string, unknown>> };
-    delete raw.estates[0]?.['standingProcess'];
-    let fetchCalls = 0;
-
-    const result = await resolver.resolveProviderDurableOwner(
-      {
-        estateRegistrySource: estateRegistry(),
-        ownerPolicySource: JSON.stringify(raw),
-        host: 'git.example.invalid',
-        requestedOwner: 'user:durable-owner',
-      },
-      {
-        fetch: async (): Promise<Response> => {
-          fetchCalls += 1;
-          return publicUser('durable-owner');
-        },
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toMatchObject({ verdict: 'refused', reasonCode: 'owner-policy-invalid' });
-    expect(fetchCalls).toBe(0);
-  });
-
-  it('rejects a provider-valid but unlisted principal before provider lookup', async (): Promise<void> => {
-    const resolver = await loadResolver('MB-REQ-09 provider-valid unlisted owner refusal');
-    const calls: Array<{ identity: string; authorization: string | null }> = [];
-
-    const result = await resolver.resolveProviderDurableOwner(
-      {
-        estateRegistrySource: estateRegistry(),
-        ownerPolicySource: ownerPolicy(),
-        host: 'git.example.invalid',
-        requestedOwner: 'user:other-public-user',
-      },
-      {
-        fetch: controlledFetch({ 'other-public-user': publicUser('other-public-user') }, calls),
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toMatchObject({ verdict: 'refused', reasonCode: 'owner-not-allowlisted' });
-    expect(calls).toHaveLength(0);
-  });
-
-  it.each([
-    ['user:durable–owner', 'owner-name-invalid'],
-    [' user:durable-owner ', 'owner-name-invalid'],
-    ['user:durable.owner', 'owner-not-allowlisted'],
-    ['user:durable owner', 'owner-name-invalid'],
-    ['user:ｄurable-owner', 'owner-name-invalid'],
-    ['user:be-coder-07@mission-seat', 'owner-name-invalid'],
-  ] as const)(
-    'rejects non-canonical, unlisted, or transient-seat presentation %s before lookup',
-    async (name, reasonCode): Promise<void> => {
-      const resolver = await loadResolver('MB-REQ-09 owner allowlist grammar');
-      let fetchCalls = 0;
-
-      const result = await resolver.resolveProviderDurableOwner(
-        {
-          estateRegistrySource: estateRegistry(),
-          ownerPolicySource: ownerPolicy(),
-          host: 'git.example.invalid',
-          requestedOwner: name,
-        },
-        {
-          fetch: async (): Promise<Response> => {
-            fetchCalls += 1;
-            return publicUser('durable-owner');
-          },
-          absentControlName: (): string => 'generated-absent-control',
-        },
-      );
-
-      expect(result).toMatchObject({ verdict: 'refused', reasonCode });
-      expect(fetchCalls).toBe(0);
-    },
-  );
-
-  it('fails closed as not-resolvable rather than claiming a private-or-absent owner does not exist', async (): Promise<void> => {
-    const resolver = await loadResolver('MB-REQ-09 private/absent ambiguity');
-
-    const result = await resolver.resolveProviderDurableOwner(
-      {
-        estateRegistrySource: estateRegistry(),
-        ownerPolicySource: ownerPolicy(),
-        host: 'git.example.invalid',
-        requestedOwner: 'user:durable-owner',
-      },
-      {
-        fetch: controlledFetch({ 'durable-owner': jsonResponse(404, { message: 'hidden' }) }),
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toMatchObject({
-      verdict: 'not-measured',
-      reasonCode: 'owner-not-resolvable',
-      principal: null,
-    });
-    expect(JSON.stringify(result)).not.toMatch(/owner-not-found|does-not-exist/);
-  });
-
-  it.each([
-    ['public control hidden', { 'public-control': jsonResponse(404, {}) }],
-    ['public control login mismatch', { 'public-control': publicUser('other') }],
-    ['private control unexpectedly public', { 'private-control': publicUser('private-control') }],
-    [
-      'generated absent control unexpectedly resolves',
-      { 'generated-absent-control': publicUser('generated-absent-control') },
-    ],
-  ] as const)(
-    'makes the whole result not-measured when %s',
-    async (_caseName, overrides): Promise<void> => {
-      const resolver = await loadResolver('MB-REQ-09 owner resolver controls');
-
-      const result = await resolver.resolveProviderDurableOwner(
-        {
-          estateRegistrySource: estateRegistry(),
-          ownerPolicySource: ownerPolicy(),
-          host: 'git.example.invalid',
-          requestedOwner: 'user:durable-owner',
-        },
-        {
-          fetch: controlledFetch(overrides),
-          absentControlName: (): string => 'generated-absent-control',
-        },
-      );
-
-      expect(result).toMatchObject({
-        verdict: 'not-measured',
-        reasonCode: 'owner-control-invalid',
-      });
-    },
-  );
-});

packages/mosaic/src/commands/brain-owner-resolver.ts

@@ -1,280 +0,0 @@
-import { z } from 'zod';
-import { parseCredentialEstateRegistry } from '../credentials/estate-registry.js';
-import type { MigrationOwnerResolution } from './brain-store.js';
-
-const MAX_BODY_BYTES = 256 * 1024;
-const LOGIN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*$/;
-const REQUESTED_OWNER = /^user:(.+)$/;
-
-const ownerPolicySchema = z
-  .object({
-    version: z.literal(1),
-    estates: z
-      .array(
-        z
-          .object({
-            estate: z.string().min(1),
-            laneArchiveOwners: z
-              .array(
-                z
-                  .object({
-                    kind: z.literal('provider-user'),
-                    login: z.string().min(1),
-                  })
-                  .strict(),
-              )
-              .min(1),
-            standingProcess: z
-              .object({
-                kind: z.literal('glpi-queue'),
-                queue: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-              })
-              .strict(),
-            controls: z
-              .object({
-                publicIdentity: z.string().min(1),
-                privateIdentity: z.string().min(1),
-              })
-              .strict(),
-          })
-          .strict(),
-      )
-      .min(1),
-  })
-  .strict();
-
-const providerUserSchema = z
-  .object({
-    id: z.number().int(),
-    login: z.string().min(1),
-    visibility: z.literal('public'),
-  })
-  .passthrough();
-
-export type OwnerFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-
-function unresolved(reasonCode: string): MigrationOwnerResolution {
-  return {
-    verdict: 'not-measured',
-    reasonCode,
-    principal: null,
-    authority: null,
-  };
-}
-
-function refused(reasonCode: string): MigrationOwnerResolution {
-  return {
-    verdict: 'refused',
-    reasonCode,
-    principal: null,
-    authority: null,
-  };
-}
-
-function exactCanonicalLogin(value: string): boolean {
-  return value.normalize('NFKC') === value && LOGIN.test(value);
-}
-
-async function boundedJson(response: Response): Promise<unknown> {
-  const contentType = response.headers.get('content-type') ?? '';
-  if (!contentType.toLowerCase().startsWith('application/json')) {
-    throw new Error('owner-unexpected-content-type');
-  }
-  const declared = response.headers.get('content-length');
-  let declaredSize: number | null = null;
-  if (declared !== null) {
-    if (!/^\d+$/.test(declared)) throw new Error('owner-unexpected-provider-shape');
-    declaredSize = Number.parseInt(declared, 10);
-    if (!Number.isSafeInteger(declaredSize) || declaredSize > MAX_BODY_BYTES) {
-      throw new Error('owner-unexpected-provider-shape');
-    }
-  }
-  if (response.body === null) throw new Error('owner-unexpected-provider-shape');
-  const reader = response.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  while (true) {
-    const next = await reader.read();
-    if (next.done) break;
-    total += next.value.byteLength;
-    if (total > MAX_BODY_BYTES) {
-      await reader.cancel('owner response exceeds byte ceiling');
-      throw new Error('owner-unexpected-provider-shape');
-    }
-    chunks.push(next.value);
-  }
-  if (declaredSize !== null && declaredSize !== total) {
-    throw new Error('owner-unexpected-provider-shape');
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  try {
-    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(body));
-  } catch {
-    throw new Error('owner-unexpected-provider-shape');
-  }
-}
-
-async function readPublicIdentity(
-  origin: string,
-  identity: string,
-  fetchImpl: OwnerFetch,
-): Promise<{ readonly status: number; readonly user: unknown }> {
-  let response: Response;
-  try {
-    response = await fetchImpl(`${origin}/api/v1/users/${encodeURIComponent(identity)}`, {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json',
-        'User-Agent': 'mosaic-brain-owner/1',
-      },
-      redirect: 'manual',
-      signal: AbortSignal.timeout(5_000),
-    });
-  } catch {
-    throw new Error('owner-provider-unavailable');
-  }
-  return { status: response.status, user: await boundedJson(response) };
-}
-
-function publicIdentityMatches(value: unknown, identity: string): boolean {
-  const parsed = providerUserSchema.safeParse(value);
-  return parsed.success && parsed.data.login === identity;
-}
-
-export interface BrainOwnerPolicyBinding {
-  readonly brainNamespace: string;
-  readonly publicControl: string;
-  readonly privateControl: string;
-  readonly standingQueue: string;
-}
-
-export function resolveBrainOwnerPolicy(
-  ownerPolicySource: string,
-  estate: string,
-): BrainOwnerPolicyBinding | undefined {
-  let rawPolicy: unknown;
-  try {
-    rawPolicy = JSON.parse(ownerPolicySource);
-  } catch {
-    return undefined;
-  }
-  const policy = ownerPolicySchema.safeParse(rawPolicy);
-  if (!policy.success) return undefined;
-  const estatePolicies = policy.data.estates.filter(
-    (candidate): boolean => candidate.estate === estate,
-  );
-  if (estatePolicies.length !== 1) return undefined;
-  const estatePolicy = estatePolicies[0];
-  if (estatePolicy === undefined || estatePolicy.laneArchiveOwners.length !== 1) return undefined;
-  const brainNamespace = estatePolicy.laneArchiveOwners[0]?.login;
-  if (brainNamespace === undefined || !exactCanonicalLogin(brainNamespace)) return undefined;
-  return {
-    brainNamespace,
-    publicControl: estatePolicy.controls.publicIdentity,
-    privateControl: estatePolicy.controls.privateIdentity,
-    standingQueue: estatePolicy.standingProcess.queue,
-  };
-}
-
-export function parseRequestedOwner(requestedOwner: string): string | null {
-  if (requestedOwner.normalize('NFKC') !== requestedOwner) return null;
-  const match = REQUESTED_OWNER.exec(requestedOwner);
-  const login = match?.[1];
-  if (login === undefined || !exactCanonicalLogin(login)) return null;
-  return login;
-}
-
-export async function resolveProviderDurableOwner(
-  input: {
-    readonly estateRegistrySource: string;
-    readonly ownerPolicySource: string;
-    readonly host: string;
-    readonly requestedOwner: string;
-  },
-  dependencies: {
-    readonly fetch: OwnerFetch;
-    readonly absentControlName: () => string;
-  },
-): Promise<MigrationOwnerResolution> {
-  const requestedLogin = parseRequestedOwner(input.requestedOwner);
-  if (requestedLogin === null) return refused('owner-name-invalid');
-
-  const target = parseCredentialEstateRegistry(input.estateRegistrySource).resolveByHost(
-    input.host,
-  );
-  if (target === undefined) return refused('estate-host-unmapped');
-
-  const policy = resolveBrainOwnerPolicy(input.ownerPolicySource, target.estate);
-  if (policy === undefined) return refused('owner-policy-invalid');
-  if (policy.brainNamespace !== requestedLogin) return refused('owner-not-allowlisted');
-
-  const publicControl = policy.publicControl;
-  const privateControl = policy.privateControl;
-  const absentControl = dependencies.absentControlName();
-  if (
-    !exactCanonicalLogin(publicControl) ||
-    !exactCanonicalLogin(privateControl) ||
-    !exactCanonicalLogin(absentControl) ||
-    new Set([publicControl, privateControl, absentControl, requestedLogin]).size !== 4
-  ) {
-    return refused('owner-policy-invalid');
-  }
-
-  try {
-    const publicResult = await readPublicIdentity(
-      target.host.apiBaseUrl,
-      publicControl,
-      dependencies.fetch,
-    );
-    if (publicResult.status !== 200 || !publicIdentityMatches(publicResult.user, publicControl)) {
-      return unresolved('owner-control-invalid');
-    }
-
-    const privateResult = await readPublicIdentity(
-      target.host.apiBaseUrl,
-      privateControl,
-      dependencies.fetch,
-    );
-    if (privateResult.status !== 404) return unresolved('owner-control-invalid');
-
-    const absentResult = await readPublicIdentity(
-      target.host.apiBaseUrl,
-      absentControl,
-      dependencies.fetch,
-    );
-    if (absentResult.status !== 404) return unresolved('owner-control-invalid');
-
-    const ownerResult = await readPublicIdentity(
-      target.host.apiBaseUrl,
-      requestedLogin,
-      dependencies.fetch,
-    );
-    if (ownerResult.status === 401 || ownerResult.status === 403 || ownerResult.status === 404) {
-      return unresolved('owner-not-resolvable');
-    }
-    if (ownerResult.status !== 200) return unresolved('owner-provider-unavailable');
-    if (!publicIdentityMatches(ownerResult.user, requestedLogin)) {
-      return unresolved('owner-provider-identity-mismatch');
-    }
-    return {
-      verdict: 'resolved',
-      reasonCode: 'owner-verified',
-      principal: { name: `user:${requestedLogin}`, kind: 'durable-human' },
-      authority: {
-        system: 'gitea',
-        endpoint: `GET /api/v1/users/${requestedLogin}`,
-        contentType: 'application/json',
-      },
-    };
-  } catch (error: unknown) {
-    const reason = error instanceof Error ? error.message : 'owner-provider-unavailable';
-    if (reason === 'owner-unexpected-content-type') return unresolved(reason);
-    if (reason === 'owner-unexpected-provider-shape') return unresolved(reason);
-    return unresolved('owner-provider-unavailable');
-  }
-}

packages/mosaic/src/commands/brain-provision-command.spec.ts

@@ -1,122 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { Command } from 'commander';
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-interface BrainProvisionCommandModule {
-  readonly BRAIN_PROVISION_COMMAND: string;
-  registerBrainProvisionCommand(program: Command): void;
-  executeBrainProvisionCommand(
-    options: {
-      readonly mosaicHome: string;
-      readonly home: string;
-      readonly identity: string;
-      readonly refusalIdentity: string;
-      readonly targetUrl: string;
-      readonly owner: string;
-      readonly lane: string;
-      readonly sourceRoot?: string;
-      readonly brainRoot?: string;
-      readonly ownerPolicy?: string;
-      readonly registry?: string;
-    },
-    dependencies: {
-      readonly run: () => never;
-      readonly fetch: typeof fetch;
-      readonly absentControlName: () => string;
-    },
-  ): Promise<{
-    readonly status: 'provisioned' | 'blocked' | 'failed';
-    readonly reasonCode: string;
-  }>;
-}
-
-const MODULE_PATH = './brain-provision-command.js';
-const roots: string[] = [];
-
-async function loadCommand(requirement: string): Promise<BrainProvisionCommandModule> {
-  try {
-    return (await import(MODULE_PATH)) as BrainProvisionCommandModule;
-  } catch (error: unknown) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${requirement}: brain provision command is absent (${detail})`);
-  }
-}
-
-function tempRoot(): string {
-  const root = mkdtempSync(join(tmpdir(), 'mosaic-brain-command-'));
-  roots.push(root);
-  return root;
-}
-
-afterEach((): void => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-describe('internal P7 brain provision command', (): void => {
-  it('registers only explicit non-secret contract inputs and no credential/token lookup switches', async (): Promise<void> => {
-    const module = await loadCommand('MB-REQ-03 broker-only provision command');
-    const program = new Command();
-    module.registerBrainProvisionCommand(program);
-    const command = program.commands.find(
-      (candidate) => candidate.name() === module.BRAIN_PROVISION_COMMAND,
-    );
-
-    expect(command).toBeDefined();
-    const flags = command?.options.map((option) => option.flags) ?? [];
-    expect(flags.join(' ')).toContain('--identity');
-    expect(flags.join(' ')).toContain('--target-url');
-    expect(flags.join(' ')).toContain('--refusal-identity');
-    expect(flags.join(' ')).toContain('--owner-policy');
-    expect(flags.join(' ')).toContain('--owner');
-    expect(flags.join(' ')).toContain('--lane');
-    expect(flags.join(' ')).not.toMatch(/token|password|authorization|grant-authority/i);
-  });
-
-  it('is registered by the shipped CLI', async (): Promise<void> => {
-    const module = await loadCommand('MB-REQ-10 shipped P7 command');
-    const cli = readFileSync(join(process.cwd(), 'src', 'cli.ts'), 'utf8');
-
-    expect(cli).toContain('registerBrainProvisionCommand');
-    expect(cli).toContain(`registerBrainProvisionCommand(program)`);
-    expect(module.BRAIN_PROVISION_COMMAND).toBe('__brain-provision');
-  });
-
-  it('fails closed before commands when the local owner policy is absent', async (): Promise<void> => {
-    const module = await loadCommand('MB-REQ-09 owner policy required');
-    const root = tempRoot();
-    const home = join(root, 'home');
-    const mosaicHome = join(home, '.config', 'mosaic');
-    mkdirSync(join(mosaicHome, 'cred'), { recursive: true });
-    writeFileSync(
-      join(mosaicHome, 'cred', 'estates.json'),
-      JSON.stringify({ version: 1, estates: [] }),
-      { mode: 0o600 },
-    );
-    let commands = 0;
-
-    const result = await module.executeBrainProvisionCommand(
-      {
-        mosaicHome,
-        home,
-        identity: 'seat-a',
-        refusalIdentity: 'outside-seat',
-        targetUrl: 'https://git.example.invalid/example/stack.git',
-        owner: 'user:durable-owner',
-        lane: 'lane-a',
-      },
-      {
-        run: (): never => {
-          commands += 1;
-          throw new Error('must not run');
-        },
-        fetch,
-        absentControlName: (): string => 'generated-absent-control',
-      },
-    );
-
-    expect(result).toMatchObject({ status: 'failed', reasonCode: 'owner-policy-unavailable' });
-    expect(commands).toBe(0);
-  });
-});

packages/mosaic/src/commands/brain-provision-command.ts

@@ -1,133 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import type { Command } from 'commander';
-import { readBrainConfigSecure } from './brain-secure-config.js';
-import { provisionBrain, type ProvisionResult } from './brain-provision.js';
-import { systemCommandRunner, type CommandRunner } from './brain-store-runtime.js';
-import type { OwnerFetch } from './brain-owner-resolver.js';
-
-export const BRAIN_PROVISION_COMMAND = '__brain-provision';
-
-interface BrainProvisionCommandOptions {
-  readonly mosaicHome: string;
-  readonly home: string;
-  readonly identity: string;
-  readonly refusalIdentity: string;
-  readonly targetUrl: string;
-  readonly owner: string;
-  readonly lane: string;
-  readonly sourceRoot?: string;
-  readonly brainRoot?: string;
-  readonly ownerPolicy?: string;
-  readonly registry?: string;
-}
-
-interface BrainProvisionCommandDependencies {
-  readonly run: CommandRunner;
-  readonly fetch: OwnerFetch;
-  readonly absentControlName: () => string;
-}
-
-function configFailure(reasonCode: string): ProvisionResult {
-  return {
-    status: 'failed',
-    reasonCode,
-    findings: [{ code: `brain-${reasonCode}`, reasonCode }],
-    owner: null,
-    migration: null,
-  };
-}
-
-export async function executeBrainProvisionCommand(
-  options: BrainProvisionCommandOptions,
-  dependencies: BrainProvisionCommandDependencies,
-): Promise<ProvisionResult> {
-  const registry = options.registry ?? join(options.mosaicHome, 'cred', 'estates.json');
-  const ownerPolicy = options.ownerPolicy ?? join(options.mosaicHome, 'brain', 'owners.json');
-  let estateRegistrySource: string;
-  try {
-    estateRegistrySource = readBrainConfigSecure(registry, options.mosaicHome);
-  } catch {
-    return configFailure('estate-registry-unavailable');
-  }
-  let ownerPolicySource: string;
-  try {
-    ownerPolicySource = readBrainConfigSecure(ownerPolicy, options.mosaicHome);
-  } catch {
-    return configFailure('owner-policy-unavailable');
-  }
-
-  try {
-    return await provisionBrain(
-      {
-        estateRegistrySource,
-        ownerPolicySource,
-        targetGitUrl: options.targetUrl,
-        requestedOwner: options.owner,
-        identity: options.identity,
-        refusalIdentity: options.refusalIdentity,
-        root: options.brainRoot ?? join(options.home, '.mosaic'),
-        sourceRoot: options.sourceRoot ?? join(options.mosaicHome, 'memory'),
-        seat: options.identity,
-        lane: options.lane,
-        laneActive: false,
-      },
-      dependencies,
-    );
-  } catch {
-    return configFailure('brain-provision-exception');
-  }
-}
-
-export function registerBrainProvisionCommand(program: Command): void {
-  program
-    .command(BRAIN_PROVISION_COMMAND, { hidden: true })
-    .description('Internal installer P7 durable-brain provisioner')
-    .requiredOption('--identity <name>', 'explicit fleet identity')
-    .requiredOption('--target-url <url>', 'configured target git URL')
-    .requiredOption('--refusal-identity <name>', 'explicit out-of-estate negative control')
-    .requiredOption('--owner <owner>', 'policy-bound durable owner candidate')
-    .requiredOption('--lane <name>', 'source lane to migrate')
-    .option('--mosaic-home <path>', 'installed Mosaic home')
-    .option('--home <path>', 'principal home')
-    .option('--source-root <path>', 'legacy memory root')
-    .option('--brain-root <path>', 'per-estate brain checkout root')
-    .option('--owner-policy <path>', 'durable-owner allowlist policy')
-    .option('--registry <path>', 'estate registry path')
-    .action(async (raw: Record<string, string | undefined>): Promise<void> => {
-      const home = raw['home'] ?? homedir();
-      const mosaicHome =
-        raw['mosaicHome'] ?? process.env['MOSAIC_HOME'] ?? join(home, '.config', 'mosaic');
-      const result = await executeBrainProvisionCommand(
-        {
-          mosaicHome,
-          home,
-          identity: raw['identity']!,
-          targetUrl: raw['targetUrl']!,
-          refusalIdentity: raw['refusalIdentity']!,
-          owner: raw['owner']!,
-          lane: raw['lane']!,
-          ...(raw['sourceRoot'] === undefined ? {} : { sourceRoot: raw['sourceRoot'] }),
-          ...(raw['brainRoot'] === undefined ? {} : { brainRoot: raw['brainRoot'] }),
-          ...(raw['ownerPolicy'] === undefined ? {} : { ownerPolicy: raw['ownerPolicy'] }),
-          ...(raw['registry'] === undefined ? {} : { registry: raw['registry'] }),
-        },
-        {
-          run: systemCommandRunner,
-          fetch,
-          absentControlName: (): string => `mosaic-absent-${randomUUID()}`,
-        },
-      );
-      process.stdout.write(
-        `${JSON.stringify({
-          status: result.status,
-          reasonCode: result.reasonCode,
-          findings: result.findings,
-          owner: result.owner,
-          migration: result.migration,
-        })}\n`,
-      );
-      if (result.status !== 'provisioned') process.exitCode = result.status === 'blocked' ? 30 : 20;
-    });
-}

packages/mosaic/src/commands/brain-provision.spec.ts

@@ -1,561 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-interface CommandRequest {
-  readonly program: 'git' | 'mosaic';
-  readonly args: readonly string[];
-  readonly env: Readonly<Record<string, string>>;
-}
-
-interface CommandResult {
-  readonly status: number;
-  readonly stdout: string;
-  readonly stderr: string;
-}
-
-type CommandRunner = (request: CommandRequest) => CommandResult;
-type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-
-interface ProvisionResult {
-  readonly status: 'provisioned' | 'blocked' | 'failed';
-  readonly reasonCode: string;
-  readonly findings: readonly { code: string; reasonCode: string | null }[];
-  readonly owner: {
-    readonly verdict: 'resolved' | 'refused' | 'not-measured';
-    readonly reasonCode: string;
-  } | null;
-  readonly migration: {
-    readonly status: 'migrated' | 'reported' | 'failed';
-    readonly reported: readonly { path: string; reason: string }[];
-  } | null;
-}
-
-interface ProvisionModule {
-  provisionBrain(
-    input: {
-      readonly estateRegistrySource: string;
-      readonly ownerPolicySource: string;
-      readonly targetGitUrl: string;
-      readonly requestedOwner: string;
-      readonly identity: string;
-      readonly refusalIdentity: string;
-      readonly root: string;
-      readonly sourceRoot: string;
-      readonly seat: string;
-      readonly lane: string;
-      readonly laneActive: boolean;
-    },
-    dependencies: {
-      readonly run: CommandRunner;
-      readonly fetch: FetchLike;
-      readonly absentControlName: () => string;
-      readonly approveMigrationContent?: (path: string, content: Uint8Array) => boolean;
-    },
-  ): Promise<ProvisionResult>;
-}
-
-const MODULE_PATH = './brain-provision.js';
-const roots: string[] = [];
-
-async function loadProvisioner(requirement: string): Promise<ProvisionModule> {
-  try {
-    return (await import(MODULE_PATH)) as ProvisionModule;
-  } catch (error: unknown) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${requirement}: brain provisioner is absent (${detail})`);
-  }
-}
-
-function tempRoot(): string {
-  const root = mkdtempSync(join(tmpdir(), 'mosaic-brain-provision-'));
-  roots.push(root);
-  return root;
-}
-
-function estateRegistry(): string {
-  return JSON.stringify({
-    version: 1,
-    estates: [
-      {
-        name: 'homelab',
-        readOnlyControlIdentity: 'read-control',
-        hosts: [
-          {
-            host: 'git.example.invalid',
-            provider: 'gitea',
-            apiBaseUrl: 'https://git.example.invalid',
-            tokenPrefix: 'gitea-example',
-          },
-        ],
-      },
-    ],
-  });
-}
-
-function ownerPolicy(): string {
-  return JSON.stringify({
-    version: 1,
-    estates: [
-      {
-        estate: 'homelab',
-        laneArchiveOwners: [{ kind: 'provider-user', login: 'durable-owner' }],
-        standingProcess: { kind: 'glpi-queue', queue: 'mosaic-brain-remediation' },
-        controls: { publicIdentity: 'public-control', privateIdentity: 'private-control' },
-      },
-    ],
-  });
-}
-
-function validateResult(
-  outcome: 'ok' | 'refused' | 'indeterminate',
-  reasonCode: string,
-  identity = 'seat-a',
-): string {
-  const exitCode = outcome === 'ok' ? 0 : outcome === 'refused' ? 10 : 30;
-  return JSON.stringify({
-    schemaVersion: 1,
-    operation: 'validate',
-    outcome,
-    exitCode,
-    retryable: false,
-    subject: {
-      identity,
-      estate: 'homelab',
-      host: 'git.example.invalid',
-      repo: 'durable-owner/mosaic-brain',
-    },
-    mutation: 'none',
-    reason: { code: reasonCode, message: 'non-secret' },
-    evidence: {
-      providerIdentity:
-        outcome === 'ok'
-          ? {
-              login: identity,
-              endpoint: 'GET /api/v1/user',
-              contentType: 'application/json',
-            }
-          : null,
-      repositoryPermission:
-        outcome === 'ok'
-          ? {
-              requested: 'write',
-              effective: 'write',
-              endpoint: 'GET /api/v1/repos/durable-owner/mosaic-brain',
-              contentType: 'application/json',
-            }
-          : null,
-      writeDifferential:
-        outcome === 'ok'
-          ? {
-              state: 'can-write',
-              credentialBinding: 'same-resolution',
-              transportPrincipal: identity,
-              authenticatedReceivePack: 'advertised',
-              readOnlyControl: {
-                identity: 'read-control',
-                providerPermission: 'read',
-                receivePack: 'refused',
-              },
-              unauthenticatedReceivePack: 'refused',
-              artifactCreated: false,
-              proves: 'non-secret evidence',
-              doesNotProve: 'branch update acceptance',
-            }
-          : null,
-    },
-    audit: { journalId: 'opaque', state: 'sealed' },
-  });
-}
-
-function publicUser(login: string): Response {
-  return new Response(JSON.stringify({ id: 1, login, visibility: 'public', active: false }), {
-    status: 200,
-    headers: { 'content-type': 'application/json' },
-  });
-}
-
-function ownerFetch(ownerStatus = 200): FetchLike {
-  return async (input): Promise<Response> => {
-    const raw = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
-    const identity = decodeURIComponent(new URL(raw).pathname.split('/').at(-1) ?? '');
-    if (identity === 'public-control') return publicUser(identity);
-    if (identity === 'private-control' || identity === 'generated-absent-control') {
-      return new Response(JSON.stringify({ message: 'hidden or absent' }), {
-        status: 404,
-        headers: { 'content-type': 'application/json' },
-      });
-    }
-    if (identity === 'durable-owner' && ownerStatus === 200) return publicUser(identity);
-    return new Response(JSON.stringify({ message: 'hidden or absent' }), {
-      status: ownerStatus,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-}
-
-function baseInput(root: string): {
-  readonly estateRegistrySource: string;
-  readonly ownerPolicySource: string;
-  readonly targetGitUrl: string;
-  readonly requestedOwner: string;
-  readonly identity: string;
-  readonly refusalIdentity: string;
-  readonly root: string;
-  readonly sourceRoot: string;
-  readonly seat: string;
-  readonly lane: string;
-  readonly laneActive: boolean;
-} {
-  return {
-    estateRegistrySource: estateRegistry(),
-    ownerPolicySource: ownerPolicy(),
-    targetGitUrl: 'https://git.example.invalid/example/stack.git',
-    requestedOwner: 'user:durable-owner',
-    identity: 'seat-a',
-    refusalIdentity: 'outside-seat',
-    root: join(root, 'brain'),
-    sourceRoot: join(root, 'local-memory'),
-    seat: 'seat-a',
-    lane: 'lane-a',
-    laneActive: false,
-  };
-}
-
-afterEach((): void => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-describe('P7 brain provisioning orchestration', (): void => {
-  it('requires the P5 write-capability postcondition and never grants or clones on refusal', async (): Promise<void> => {
-    const provisioner = await loadProvisioner('MB-REQ-10 P5 before P7');
-    const root = tempRoot();
-    const requests: CommandRequest[] = [];
-
-    const result = await provisioner.provisionBrain(baseInput(root), {
-      run: (request): CommandResult => {
-        requests.push(request);
-        return {
-          status: 10,
-          stdout: validateResult('refused', 'no-token-for-identity'),
-          stderr: 'refused reason=no-token-for-identity',
-        };
-      },
-      fetch: ownerFetch(),
-      absentControlName: (): string => 'generated-absent-control',
-    });
-
-    expect(result).toMatchObject({
-      status: 'blocked',
-      reasonCode: 'credential-postcondition-failed',
-    });
-    expect(requests).toHaveLength(1);
-    expect(requests[0]?.program).toBe('mosaic');
-    expect(requests[0]?.args.slice(0, 3)).toEqual(['cred', 'validate', 'seat-a']);
-    expect(requests.some((request) => request.args.includes('grant'))).toBe(false);
-    expect(requests.some((request) => request.args.includes('clone'))).toBe(false);
-  });
-
-  it('blocks before clone when the out-of-estate Git and API axes disagree', async (): Promise<void> => {
-    const provisioner = await loadProvisioner('MB-REQ-05 P7 refusal control gate');
-    const root = tempRoot();
-    const requests: CommandRequest[] = [];
-
-    const result = await provisioner.provisionBrain(baseInput(root), {
-      run: (request): CommandResult => {
-        requests.push(request);
-        if (request.program === 'mosaic' && request.args[2] === 'outside-seat') {
-          return {
-            status: 10,
-            stdout: validateResult('refused', 'no-token-for-identity', 'outside-seat'),
-            stderr: 'refused reason=no-token-for-identity',
-          };
-        }
-        if (request.program === 'mosaic') {
-          return { status: 0, stdout: validateResult('ok', 'validation-verified'), stderr: '' };
-        }
-        if (request.args.includes('ls-remote')) {
-          return { status: 0, stdout: 'refs are visible', stderr: '' };
-        }
-        return { status: 99, stdout: '', stderr: 'unexpected command' };
-      },
-      fetch: ownerFetch(),
-      absentControlName: (): string => 'generated-absent-control',
-    });
-
-    expect(result).toMatchObject({
-      status: 'blocked',
-      reasonCode: 'refusal-control-failed',
-    });
-    expect(requests.some((request) => request.args.includes('clone'))).toBe(false);
-    expect(requests.some((request) => request.args.includes('grant'))).toBe(false);
-  });
-
-  it('blocks before skeleton publication when the existing checkout is dirty', async (): Promise<void> => {
-    const provisioner = await loadProvisioner('MB-REQ-06 dirty checkout publication gate');
-    const root = tempRoot();
-    const input = baseInput(root);
-    mkdirSync(join(input.root, '.git'), { recursive: true });
-    const requests: CommandRequest[] = [];
-
-    const result = await provisioner.provisionBrain(input, {
-      run: (request): CommandResult => {
-        requests.push(request);
-        if (request.program === 'mosaic') {
-          return request.args[2] === 'outside-seat'
-            ? {
-                status: 10,
-                stdout: validateResult('refused', 'no-token-for-identity', 'outside-seat'),
-                stderr: 'refused reason=no-token-for-identity',
-              }
-            : { status: 0, stdout: validateResult('ok', 'validation-verified'), stderr: '' };
-        }
-        const command = request.args.join(' ');
-        if (command.includes('ls-remote')) {
-          return {
-            status: 128,
-            stdout: '',
-            stderr: 'credential helper refused reason=no-token-for-identity',
-          };
-        }
-        if (command.includes('rev-parse --is-inside-work-tree')) {
-          return { status: 0, stdout: 'true\n', stderr: '' };
-        }
-        if (command.includes('remote get-url origin')) {
-          return {
-            status: 0,
-            stdout: 'https://git.example.invalid/durable-owner/mosaic-brain.git\n',
-            stderr: '',
-          };
-        }
-        if (command.includes('branch --show-current')) {
-          return { status: 0, stdout: 'main\n', stderr: '' };
-        }
-        if (command.includes('status --porcelain')) {
-          return { status: 0, stdout: '?? .gitignore\n', stderr: '' };
-        }
-        return { status: 99, stdout: '', stderr: 'unexpected publication command' };
-      },
-      fetch: ownerFetch(),
-      absentControlName: (): string => 'generated-absent-control',
-    });
-
-    expect(result).toMatchObject({
-      status: 'blocked',
-      reasonCode: 'brain-postcondition-failed',
-    });
-    expect(requests.some((request) => request.args.includes('commit'))).toBe(false);
-    expect(requests.some((request) => request.args.includes('push'))).toBe(false);
-  });
-
-  it('clones, seeds, resolves owner, migrates, pushes on each write, and archives source only after reachability', async (): Promise<void> => {
-    const provisioner = await loadProvisioner('MB-REQ-07 complete migration transaction');
-    const root = tempRoot();
-    const input = baseInput(root);
-    mkdirSync(join(input.sourceRoot, 'lanes', 'lane-a'), { recursive: true });
-    const source = join(input.sourceRoot, 'lanes', 'lane-a', 'finding.md');
-    writeFileSync(source, 'durable finding\n');
-    const requests: CommandRequest[] = [];
-    let commitOrdinal = 0;
-    let approvedPaths: string[] = [];
-    let privateAtClone = false;
-    const runner: CommandRunner = (request): CommandResult => {
-      requests.push(request);
-      if (request.program === 'mosaic') {
-        if (request.args[2] === 'outside-seat') {
-          return {
-            status: 10,
-            stdout: validateResult('refused', 'no-token-for-identity', 'outside-seat'),
-            stderr: 'refused reason=no-token-for-identity',
-          };
-        }
-        return { status: 0, stdout: validateResult('ok', 'validation-verified'), stderr: '' };
-      }
-      const command = request.args.join(' ');
-      if (command.includes('ls-remote')) {
-        return {
-          status: 128,
-          stdout: '',
-          stderr: 'credential helper refused reason=no-token-for-identity',
-        };
-      }
-      if (request.args[0] === 'clone') {
-        privateAtClone = existsSync(input.root) && (lstatSync(input.root).mode & 0o077) === 0;
-        mkdirSync(join(input.root, '.git'), { recursive: true });
-        return { status: 0, stdout: '', stderr: '' };
-      }
-      if (command.includes('read-tree')) {
-        approvedPaths = [];
-        return { status: 0, stdout: '', stderr: '' };
-      }
-      if (command.includes('hash-object')) {
-        return { status: 0, stdout: `${'f'.repeat(40)}\n`, stderr: '' };
-      }
-      if (command.includes('update-index')) {
-        const path = request.args.at(-1);
-        if (path !== undefined) approvedPaths.push(path);
-        return { status: 0, stdout: '', stderr: '' };
-      }
-      if (command.includes('rev-parse') && request.args.at(-1)?.includes(':')) {
-        return { status: 0, stdout: `${'f'.repeat(40)}\n`, stderr: '' };
-      }
-      if (command.includes('diff --cached --quiet')) {
-        return { status: 1, stdout: '', stderr: '' };
-      }
-      if (command.includes('diff-tree')) {
-        return { status: 0, stdout: `${approvedPaths.join('\0')}\0`, stderr: '' };
-      }
-      if (command.includes('show -s')) {
-        return {
-          status: 0,
-          stdout: 'seat-a\[email protected]\0seat-a\[email protected]\n',
-          stderr: '',
-        };
-      }
-      if (command.includes('rev-parse --is-inside-work-tree')) {
-        return { status: 0, stdout: 'true\n', stderr: '' };
-      }
-      if (command.includes('remote get-url origin')) {
-        return {
-          status: 0,
-          stdout: 'https://git.example.invalid/durable-owner/mosaic-brain.git\n',
-          stderr: '',
-        };
-      }
-      if (command.includes('branch --show-current')) {
-        return { status: 0, stdout: 'main\n', stderr: '' };
-      }
-      if (command.includes('status --porcelain')) {
-        return { status: 0, stdout: '', stderr: '' };
-      }
-      if (command.includes('rev-parse HEAD')) {
-        commitOrdinal += 1;
-        return {
-          status: 0,
-          stdout: `${commitOrdinal === 1 ? 'a' : 'c'.repeat(1)}`.repeat(40) + '\n',
-          stderr: '',
-        };
-      }
-      if (command.includes('rev-parse origin/main')) {
-        const value = commitOrdinal === 1 ? 'b' : 'd';
-        return { status: 0, stdout: `${value.repeat(40)}\n`, stderr: '' };
-      }
-      return { status: 0, stdout: '', stderr: '' };
-    };
-
-    const result = await provisioner.provisionBrain(input, {
-      run: runner,
-      fetch: ownerFetch(),
-      absentControlName: (): string => 'generated-absent-control',
-      approveMigrationContent: (): boolean => true,
-    });
-
-    expect(result).toMatchObject({
-      status: 'provisioned',
-      reasonCode: 'brain-provisioned',
-      owner: { verdict: 'resolved', reasonCode: 'owner-verified' },
-      migration: { status: 'reported' },
-    });
-    expect(privateAtClone).toBe(true);
-    expect(existsSync(source)).toBe(true);
-    const imported = result.migration?.reported ?? [];
-    expect(imported).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ path: source, reason: expect.stringMatching(/retained/i) }),
-      ]),
-    );
-    const laneImports = join(input.root, 'lanes', 'lane-a', 'findings', 'imports');
-    const archiveImports = join(input.root, 'archives', 'imports', 'lane');
-    expect(existsSync(laneImports)).toBe(true);
-    expect(existsSync(archiveImports)).toBe(true);
-    expect(
-      requests.filter((request) => request.program === 'git' && request.args.includes('push')),
-    ).toHaveLength(2);
-    expect(requests.some((request) => request.args.includes('grant'))).toBe(false);
-  });
-
-  it('keeps every source and reports the owner ambiguity when the public owner cannot be resolved', async (): Promise<void> => {
-    const provisioner = await loadProvisioner('MB-REQ-07 owner-blocked detection/reporting');
-    const root = tempRoot();
-    const input = baseInput(root);
-    mkdirSync(input.root, { recursive: true });
-    mkdirSync(join(input.root, '.git'), { recursive: true });
-    mkdirSync(join(input.sourceRoot, 'lanes', 'lane-a'), { recursive: true });
-    const source = join(input.sourceRoot, 'lanes', 'lane-a', 'finding.md');
-    writeFileSync(source, 'retain me\n');
-    let commitOrdinal = 0;
-
-    const result = await provisioner.provisionBrain(input, {
-      run: (request): CommandResult => {
-        if (request.program === 'mosaic') {
-          if (request.args[2] === 'outside-seat') {
-            return {
-              status: 10,
-              stdout: validateResult('refused', 'no-token-for-identity', 'outside-seat'),
-              stderr: 'refused reason=no-token-for-identity',
-            };
-          }
-          return { status: 0, stdout: validateResult('ok', 'validation-verified'), stderr: '' };
-        }
-        const command = request.args.join(' ');
-        if (command.includes('ls-remote')) {
-          return {
-            status: 128,
-            stdout: '',
-            stderr: 'credential helper refused reason=no-token-for-identity',
-          };
-        }
-        if (command.includes('rev-parse --is-inside-work-tree')) {
-          return { status: 0, stdout: 'true\n', stderr: '' };
-        }
-        if (command.includes('remote get-url origin')) {
-          return {
-            status: 0,
-            stdout: 'https://git.example.invalid/durable-owner/mosaic-brain.git\n',
-            stderr: '',
-          };
-        }
-        if (command.includes('branch --show-current')) {
-          return { status: 0, stdout: 'main\n', stderr: '' };
-        }
-        if (command.includes('status --porcelain')) {
-          return { status: 0, stdout: '', stderr: '' };
-        }
-        if (command.includes('rev-parse HEAD')) {
-          commitOrdinal += 1;
-          return { status: 0, stdout: `${'a'.repeat(40)}\n`, stderr: '' };
-        }
-        if (command.includes('rev-parse origin/main')) {
-          return { status: 0, stdout: `${'b'.repeat(40)}\n`, stderr: '' };
-        }
-        return { status: 0, stdout: '', stderr: '' };
-      },
-      fetch: ownerFetch(404),
-      absentControlName: (): string => 'generated-absent-control',
-    });
-
-    expect(result).toMatchObject({
-      status: 'blocked',
-      reasonCode: 'owner-not-resolvable',
-      owner: { verdict: 'not-measured', reasonCode: 'owner-not-resolvable' },
-      migration: { status: 'reported' },
-    });
-    expect(readFileSync(source, 'utf8')).toBe('retain me\n');
-    expect(result.migration?.reported).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ path: source, reason: expect.stringMatching(/owner/i) }),
-      ]),
-    );
-    expect(JSON.stringify(result)).not.toMatch(/owner-not-found|does-not-exist/);
-    expect(commitOrdinal).toBe(0);
-  });
-});

packages/mosaic/src/commands/brain-provision.ts

@@ -1,271 +0,0 @@
-import { existsSync } from 'node:fs';
-import { parseRequestedOwner, resolveProviderDurableOwner } from './brain-owner-resolver.js';
-import {
-  createBrainSkeleton,
-  deriveBrainTarget,
-  discoverBrainMigration,
-  ensureBrainRootPrivate,
-  migrateBrainState,
-  type MigrationResult,
-  type MigrationOwnerResolution,
-  type MigrationPublishEntry,
-} from './brain-store.js';
-import {
-  collectBrainDoctorReport,
-  collectBrainRefusalControl,
-  publishBrainPaths,
-  type CommandRequest,
-  type CommandResult,
-  type CommandRunner,
-} from './brain-store-runtime.js';
-import type { OwnerFetch } from './brain-owner-resolver.js';
-
-export interface ProvisionResult {
-  readonly status: 'provisioned' | 'blocked' | 'failed';
-  readonly reasonCode: string;
-  readonly findings: readonly {
-    readonly code: string;
-    readonly reasonCode: string | null;
-  }[];
-  readonly owner: Pick<MigrationOwnerResolution, 'verdict' | 'reasonCode'> | null;
-  readonly migration: Pick<MigrationResult, 'status' | 'reported'> | null;
-}
-
-function commandEnv(identity: string): Readonly<Record<string, string>> {
-  return { MOSAIC_GIT_IDENTITY: identity, GIT_TERMINAL_PROMPT: '0' };
-}
-
-function findingView(
-  findings: readonly { readonly code: string; readonly reasonCode: string | null }[],
-): readonly { readonly code: string; readonly reasonCode: string | null }[] {
-  return findings.map((finding): { readonly code: string; readonly reasonCode: string | null } => ({
-    code: finding.code,
-    reasonCode: finding.reasonCode,
-  }));
-}
-
-function blocked(
-  reasonCode: string,
-  findings: readonly { readonly code: string; readonly reasonCode: string | null }[],
-  owner: MigrationOwnerResolution | null = null,
-  migration: MigrationResult | null = null,
-): ProvisionResult {
-  return {
-    status: 'blocked',
-    reasonCode,
-    findings: findingView(findings),
-    owner: owner === null ? null : { verdict: owner.verdict, reasonCode: owner.reasonCode },
-    migration:
-      migration === null ? null : { status: migration.status, reported: migration.reported },
-  };
-}
-
-function failed(
-  reasonCode: string,
-  findings: readonly { readonly code: string; readonly reasonCode: string | null }[],
-  owner: MigrationOwnerResolution | null = null,
-  migration: MigrationResult | null = null,
-): ProvisionResult {
-  return {
-    ...blocked(reasonCode, findings, owner, migration),
-    status: 'failed',
-  };
-}
-
-export async function provisionBrain(
-  input: {
-    readonly estateRegistrySource: string;
-    readonly ownerPolicySource: string;
-    readonly targetGitUrl: string;
-    readonly requestedOwner: string;
-    readonly identity: string;
-    readonly refusalIdentity: string;
-    readonly root: string;
-    readonly sourceRoot: string;
-    readonly seat: string;
-    readonly lane: string;
-    readonly laneActive: boolean;
-  },
-  dependencies: {
-    readonly run: CommandRunner;
-    readonly fetch: OwnerFetch;
-    readonly absentControlName: () => string;
-    readonly approveMigrationContent?: (path: string, content: Uint8Array) => boolean;
-  },
-): Promise<ProvisionResult> {
-  const brainNamespace = parseRequestedOwner(input.requestedOwner);
-  if (brainNamespace === null) return blocked('owner-name-invalid', []);
-  const target = deriveBrainTarget(input.estateRegistrySource, input.targetGitUrl, brainNamespace);
-  if (existsSync(input.root)) {
-    try {
-      ensureBrainRootPrivate(input.root);
-    } catch {
-      return blocked('brain-root-permissions-unsafe', []);
-    }
-  }
-  const doctorInput = {
-    registrySource: input.estateRegistrySource,
-    targetGitUrl: input.targetGitUrl,
-    brainNamespace,
-    identity: input.identity,
-    root: input.root,
-  };
-  let report = collectBrainDoctorReport(doctorInput, dependencies.run);
-  if (report.access.outcome !== 'ok') {
-    return blocked('credential-postcondition-failed', report.findings);
-  }
-
-  const refusalControl = collectBrainRefusalControl(
-    {
-      registrySource: input.estateRegistrySource,
-      targetGitUrl: input.targetGitUrl,
-      brainNamespace,
-      refusalIdentity: input.refusalIdentity,
-    },
-    dependencies.run,
-  );
-  if (!refusalControl.observed) {
-    return blocked('refusal-control-failed', [
-      ...report.findings,
-      {
-        code: 'brain-refusal-control-indeterminate',
-        reasonCode: refusalControl.reasonCode,
-      },
-    ]);
-  }
-
-  const owner = await resolveProviderDurableOwner(
-    {
-      estateRegistrySource: input.estateRegistrySource,
-      ownerPolicySource: input.ownerPolicySource,
-      host: target.host,
-      requestedOwner: input.requestedOwner,
-    },
-    {
-      fetch: dependencies.fetch,
-      absentControlName: dependencies.absentControlName,
-    },
-  );
-  if (owner.verdict !== 'resolved') {
-    const plan = discoverBrainMigration(
-      {
-        sourceRoot: input.sourceRoot,
-        brainRoot: input.root,
-        seat: input.seat,
-        lane: input.lane,
-        laneActive: input.laneActive,
-      },
-      (): MigrationOwnerResolution => owner,
-    );
-    const migration = migrateBrainState(
-      plan,
-      (): never => {
-        throw new Error('blocked owner cannot publish');
-      },
-      input.root,
-    );
-    return blocked(owner.reasonCode, report.findings, owner, migration);
-  }
-
-  if (report.findings.some((finding): boolean => finding.code === 'brain-clone-missing')) {
-    try {
-      ensureBrainRootPrivate(input.root);
-    } catch {
-      return failed('brain-root-permissions-unsafe', report.findings);
-    }
-    const clone: CommandRequest = {
-      program: 'git',
-      args: ['clone', '--branch', 'main', '--single-branch', target.cloneUrl, input.root],
-      env: commandEnv(input.identity),
-    };
-    const cloneResult: CommandResult = dependencies.run(clone);
-    if (cloneResult.status !== 0) return failed('brain-clone-failed', report.findings);
-    try {
-      ensureBrainRootPrivate(input.root);
-    } catch {
-      return failed('brain-root-permissions-unsafe', report.findings);
-    }
-    report = collectBrainDoctorReport(doctorInput, dependencies.run);
-  }
-
-  const blockingCloneFindings = report.findings.filter(
-    (finding): boolean =>
-      finding.code === 'brain-clone-missing' ||
-      finding.code === 'brain-not-git-repository' ||
-      finding.code === 'brain-remote-mismatch' ||
-      finding.code === 'brain-branch-mismatch' ||
-      finding.code === 'brain-uncommitted-state' ||
-      finding.code === 'brain-git-state-indeterminate' ||
-      finding.code === 'brain-root-permissions-unsafe' ||
-      finding.code.startsWith('brain-write-access-'),
-  );
-  if (blockingCloneFindings.length > 0) {
-    return blocked('brain-postcondition-failed', report.findings);
-  }
-
-  let skeletonEntries: readonly MigrationPublishEntry[];
-  try {
-    const skeleton = createBrainSkeleton(input.root);
-    skeletonEntries = skeleton.publicationEntries;
-  } catch {
-    return failed('brain-skeleton-failed', report.findings);
-  }
-  if (skeletonEntries.length > 0) {
-    try {
-      const evidence = publishBrainPaths(
-        {
-          root: input.root,
-          identity: input.identity,
-          entries: skeletonEntries,
-          message: 'chore: seed durable brain layout',
-        },
-        dependencies.run,
-      );
-      if (!evidence.reachable) return failed('brain-skeleton-not-reachable', report.findings);
-    } catch {
-      return failed('brain-skeleton-publish-failed', report.findings);
-    }
-  }
-
-  const plan = discoverBrainMigration(
-    {
-      sourceRoot: input.sourceRoot,
-      brainRoot: input.root,
-      seat: input.seat,
-      lane: input.lane,
-      laneActive: input.laneActive,
-    },
-    (): MigrationOwnerResolution => owner,
-    dependencies.approveMigrationContent,
-  );
-  const migration = migrateBrainState(
-    plan,
-    (brainRoot: string, entries: readonly MigrationPublishEntry[]) =>
-      publishBrainPaths(
-        {
-          root: brainRoot,
-          identity: input.identity,
-          entries,
-          message: `migrate: archive ${input.lane} working memory`,
-        },
-        dependencies.run,
-      ),
-    input.root,
-  );
-
-  if (migration.status === 'failed') {
-    return failed('brain-migration-publish-failed', report.findings, owner, migration);
-  }
-
-  report = collectBrainDoctorReport(doctorInput, dependencies.run);
-  if (report.findings.length > 0) {
-    return blocked('brain-final-postcondition-failed', report.findings, owner, migration);
-  }
-  return {
-    status: 'provisioned',
-    reasonCode: 'brain-provisioned',
-    findings: [],
-    owner: { verdict: owner.verdict, reasonCode: owner.reasonCode },
-    migration: { status: migration.status, reported: migration.reported },
-  };
-}

packages/mosaic/src/commands/brain-secure-config.spec.ts

@@ -1,77 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-interface SecureConfigModule {
-  readBrainConfigSecure(path: string, root: string): string;
-}
-
-const roots: string[] = [];
-
-async function loadSecureConfig(): Promise<SecureConfigModule> {
-  try {
-    return (await import('./brain-secure-config.js')) as SecureConfigModule;
-  } catch (error: unknown) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`MB-REQ-06 secure brain config reader is absent (${detail})`);
-  }
-}
-
-function fixture(): { readonly root: string; readonly directory: string; readonly file: string } {
-  const outer = mkdtempSync(join(tmpdir(), 'mosaic-brain-secure-config-'));
-  roots.push(outer);
-  const root = join(outer, 'mosaic');
-  const directory = join(root, 'brain');
-  const file = join(directory, 'owners.json');
-  mkdirSync(directory, { recursive: true, mode: 0o700 });
-  writeFileSync(file, '{"version":1}\n', { mode: 0o600 });
-  return { root, directory, file };
-}
-
-afterEach((): void => {
-  vi.restoreAllMocks();
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-describe('security-critical brain configuration reads', (): void => {
-  it('reads a principal-owned non-writable regular file through the secure descriptor path', async (): Promise<void> => {
-    const secure = await loadSecureConfig();
-    const config = fixture();
-
-    expect(secure.readBrainConfigSecure(config.file, config.root)).toBe('{"version":1}\n');
-  });
-
-  it('rejects a managed root owned by a UID other than the running principal', async (): Promise<void> => {
-    const secure = await loadSecureConfig();
-    const config = fixture();
-    if (typeof process.getuid !== 'function') throw new Error('test requires POSIX getuid');
-    const processWithUid = process as typeof process & { getuid: () => number };
-    const actualUid = processWithUid.getuid();
-    vi.spyOn(processWithUid, 'getuid').mockReturnValue(actualUid + 1);
-
-    expect(() => secure.readBrainConfigSecure(config.file, config.root)).toThrow(
-      /config-ancestor-owner-unsafe/,
-    );
-  });
-
-  it('rejects a group/world-writable policy file', async (): Promise<void> => {
-    const secure = await loadSecureConfig();
-    const config = fixture();
-    chmodSync(config.file, 0o666);
-
-    expect(() => secure.readBrainConfigSecure(config.file, config.root)).toThrow(
-      /config-file-permissions-unsafe/,
-    );
-  });
-
-  it('rejects a group/world-writable managed ancestor', async (): Promise<void> => {
-    const secure = await loadSecureConfig();
-    const config = fixture();
-    chmodSync(config.directory, 0o777);
-
-    expect(() => secure.readBrainConfigSecure(config.file, config.root)).toThrow(
-      /config-ancestor-permissions-unsafe/,
-    );
-  });
-});

packages/mosaic/src/commands/brain-secure-config.ts

@@ -1,52 +0,0 @@
-import { lstatSync } from 'node:fs';
-import { dirname, relative, resolve, sep } from 'node:path';
-import { assertCanonicalContainment, readRegularFileSecure } from '../fleet/secure-file.js';
-
-const MAX_CONFIG_BYTES = 256 * 1024;
-const GROUP_OR_OTHER_WRITE = 0o022;
-
-function currentUid(): number {
-  if (typeof process.getuid !== 'function') {
-    throw new Error('config-owner-check-unsupported');
-  }
-  return process.getuid();
-}
-
-function assertOwnedNonWritableDirectory(path: string, uid: number): void {
-  const status = lstatSync(path);
-  if (!status.isDirectory() || status.isSymbolicLink() || status.uid !== uid) {
-    throw new Error('config-ancestor-owner-unsafe');
-  }
-  if ((status.mode & GROUP_OR_OTHER_WRITE) !== 0) {
-    throw new Error('config-ancestor-permissions-unsafe');
-  }
-}
-
-export function readBrainConfigSecure(path: string, root: string): string {
-  const canonicalRoot = resolve(root);
-  const canonicalPath = resolve(path);
-  assertCanonicalContainment(canonicalRoot, canonicalPath);
-  const uid = currentUid();
-  assertOwnedNonWritableDirectory(canonicalRoot, uid);
-  let cursor = canonicalRoot;
-  for (const component of relative(canonicalRoot, dirname(canonicalPath))
-    .split(sep)
-    .filter(Boolean)) {
-    cursor = resolve(cursor, component);
-    assertOwnedNonWritableDirectory(cursor, uid);
-  }
-
-  const snapshot = readRegularFileSecure(canonicalPath, {
-    root: canonicalRoot,
-    maxBytes: MAX_CONFIG_BYTES,
-  });
-  if (snapshot.uid !== uid) throw new Error('config-file-owner-unsafe');
-  if ((snapshot.mode & GROUP_OR_OTHER_WRITE) !== 0) {
-    throw new Error('config-file-permissions-unsafe');
-  }
-  try {
-    return new TextDecoder('utf-8', { fatal: true }).decode(snapshot.content);
-  } catch {
-    throw new Error('config-file-not-utf8');
-  }
-}

packages/mosaic/src/commands/brain-store-runtime.ts

@@ -1,569 +0,0 @@
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import {
-  assessCredentialResult,
-  brainRootIsPrivate,
-  deriveBrainTarget,
-  ensureBrainRootPrivate,
-  evaluateBrainDoctor,
-  planBrainDoctorFix,
-  type BrainDoctorFinding,
-  type BrainDoctorObservation,
-  type CredentialAssessment,
-} from './brain-store.js';
-
-const COMMIT = /^[0-9a-f]{40}$/;
-const GIT_OBJECT = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-const MAX_PUBLISH_ENTRY_BYTES = 1024 * 1024;
-
-export interface CommandRequest {
-  readonly program: 'git' | 'mosaic';
-  readonly args: readonly string[];
-  readonly cwd?: string;
-  readonly env: Readonly<Record<string, string>>;
-  readonly stdin?: Uint8Array;
-}
-
-export interface CommandResult {
-  readonly status: number;
-  readonly stdout: string;
-  readonly stderr: string;
-}
-
-export type CommandRunner = (request: CommandRequest) => CommandResult;
-
-export const systemCommandRunner: CommandRunner = (request: CommandRequest): CommandResult => {
-  const result = spawnSync(request.program, request.args, {
-    cwd: request.cwd,
-    env: { ...process.env, ...request.env },
-    encoding: 'utf8',
-    maxBuffer: 1024 * 1024,
-    input: request.stdin,
-  });
-  return {
-    status: result.status ?? 127,
-    stdout: result.stdout ?? '',
-    stderr: result.stderr ?? result.error?.message ?? '',
-  };
-};
-
-export interface DoctorRuntimeReport {
-  readonly findings: readonly BrainDoctorFinding[];
-  readonly access: CredentialAssessment;
-  readonly refusalControl: {
-    readonly observed: boolean;
-    readonly reasonCode: string | null;
-  };
-}
-
-export interface BrainRefusalControlResult {
-  readonly observed: boolean;
-  readonly reasonCode: string | null;
-  readonly gitReasonCode: string;
-  readonly apiReasonCode: string;
-}
-
-export interface PublishEvidence {
-  readonly commit: string;
-  readonly remoteHead: string;
-  readonly reachable: boolean;
-}
-
-function commandEnv(identity: string): Readonly<Record<string, string>> {
-  return {
-    MOSAIC_GIT_IDENTITY: identity,
-    GIT_TERMINAL_PROMPT: '0',
-  };
-}
-
-function integrationFailure(): CredentialAssessment {
-  return {
-    outcome: 'indeterminate',
-    exitCode: 30,
-    reasonCode: 'unexpected-provider-shape',
-    diagnostic: 'indeterminate: unexpected-provider-shape',
-  };
-}
-
-function runGit(run: CommandRunner, identity: string, args: readonly string[]): CommandResult {
-  return run({ program: 'git', args, env: commandEnv(identity) });
-}
-
-function runGitWithEnv(
-  run: CommandRunner,
-  identity: string,
-  args: readonly string[],
-  env: Readonly<Record<string, string>>,
-  stdin?: Uint8Array,
-): CommandResult {
-  return run({ program: 'git', args, env: { ...commandEnv(identity), ...env }, stdin });
-}
-
-export function collectBrainDoctorReport(
-  input: {
-    readonly registrySource: string;
-    readonly targetGitUrl: string;
-    readonly brainNamespace: string;
-    readonly identity: string;
-    readonly root: string;
-  },
-  run: CommandRunner,
-): DoctorRuntimeReport {
-  const target = deriveBrainTarget(input.registrySource, input.targetGitUrl, input.brainNamespace);
-  const validation = run({
-    program: 'mosaic',
-    args: [
-      'cred',
-      'validate',
-      input.identity,
-      '--estate',
-      target.estate,
-      '--host',
-      target.host,
-      '--repo',
-      target.repo,
-      '--require',
-      'write',
-      '--json',
-    ],
-    env: commandEnv(input.identity),
-  });
-  let access = assessCredentialResult(validation.stdout, {
-    identity: input.identity,
-    estate: target.estate,
-    host: target.host,
-    repo: target.repo,
-  });
-  if (validation.status !== access.exitCode) access = integrationFailure();
-
-  const rootExists = existsSync(input.root);
-  let gitRepository = false;
-  let remote: string | null = null;
-  let branch: string | null = null;
-  let worktreeState: BrainDoctorObservation['worktreeState'] = 'unmeasurable';
-  if (rootExists) {
-    const repository = runGit(run, input.identity, [
-      '-C',
-      input.root,
-      'rev-parse',
-      '--is-inside-work-tree',
-    ]);
-    gitRepository = repository.status === 0 && repository.stdout.trim() === 'true';
-    if (gitRepository) {
-      const remoteResult = runGit(run, input.identity, [
-        '-C',
-        input.root,
-        'remote',
-        'get-url',
-        'origin',
-      ]);
-      const branchResult = runGit(run, input.identity, [
-        '-C',
-        input.root,
-        'branch',
-        '--show-current',
-      ]);
-      const statusResult = runGit(run, input.identity, ['-C', input.root, 'status', '--porcelain']);
-      if (remoteResult.status === 0) remote = remoteResult.stdout.trim();
-      if (branchResult.status === 0) branch = branchResult.stdout.trim();
-      if (statusResult.status === 0) {
-        worktreeState = statusResult.stdout.trim().length > 0 ? 'dirty' : 'clean';
-      }
-    }
-  }
-
-  const observation: BrainDoctorObservation = {
-    rootExists,
-    rootPrivate: rootExists && brainRootIsPrivate(input.root),
-    gitRepository,
-    remote,
-    branch,
-    worktreeState,
-    access,
-  };
-  const refusalMarker = `refused reason=${access.reasonCode}`;
-  const refusalObserved =
-    validation.status === 10 &&
-    access.outcome === 'refused' &&
-    access.reasonCode === 'no-token-for-identity' &&
-    validation.stderr.includes(refusalMarker);
-  return {
-    findings: evaluateBrainDoctor(observation, target.cloneUrl),
-    access,
-    refusalControl: {
-      observed: refusalObserved,
-      reasonCode: refusalObserved ? access.reasonCode : null,
-    },
-  };
-}
-
-export function collectBrainRefusalControl(
-  input: {
-    readonly registrySource: string;
-    readonly targetGitUrl: string;
-    readonly brainNamespace: string;
-    readonly refusalIdentity: string;
-  },
-  run: CommandRunner,
-): BrainRefusalControlResult {
-  const target = deriveBrainTarget(input.registrySource, input.targetGitUrl, input.brainNamespace);
-  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(input.refusalIdentity)) {
-    return {
-      observed: false,
-      reasonCode: 'permission-evidence-disagrees',
-      gitReasonCode: 'invalid-control-identity',
-      apiReasonCode: 'invalid-control-identity',
-    };
-  }
-  const apiResult = run({
-    program: 'mosaic',
-    args: [
-      'cred',
-      'validate',
-      input.refusalIdentity,
-      '--estate',
-      target.estate,
-      '--host',
-      target.host,
-      '--repo',
-      target.repo,
-      '--require',
-      'write',
-      '--json',
-    ],
-    env: commandEnv(input.refusalIdentity),
-  });
-  let api = assessCredentialResult(apiResult.stdout, {
-    identity: input.refusalIdentity,
-    estate: target.estate,
-    host: target.host,
-    repo: target.repo,
-  });
-  if (apiResult.status !== api.exitCode) api = integrationFailure();
-
-  const gitResult = runGit(run, input.refusalIdentity, ['ls-remote', target.cloneUrl, 'HEAD']);
-  const marker = /(?:^|\s)reason=([a-z0-9-]+)(?:\s|$)/.exec(gitResult.stderr)?.[1];
-  const stableRefusals = new Set([
-    'identity-required',
-    'estate-required',
-    'estate-host-mismatch',
-    'cross-estate-resolution',
-    'no-token-for-identity',
-    'tea-login-missing',
-    'tea-login-host-mismatch',
-    'provider-identity-mismatch',
-    'credential-rejected',
-    'permission-denied',
-    'organization-membership-required',
-    'team-membership-required',
-  ]);
-  const gitReasonCode =
-    gitResult.status === 0
-      ? 'transport-accepted'
-      : marker !== undefined && stableRefusals.has(marker) && gitResult.stdout.length === 0
-        ? marker
-        : 'transport-indeterminate';
-  const observed =
-    api.outcome === 'refused' &&
-    gitReasonCode !== 'transport-accepted' &&
-    gitReasonCode !== 'transport-indeterminate' &&
-    gitReasonCode === api.reasonCode;
-  return {
-    observed,
-    reasonCode: observed ? api.reasonCode : 'permission-evidence-disagrees',
-    gitReasonCode,
-    apiReasonCode: api.reasonCode,
-  };
-}
-
-export function repairBrainDoctor(
-  input: {
-    readonly registrySource: string;
-    readonly targetGitUrl: string;
-    readonly brainNamespace: string;
-    readonly identity: string;
-    readonly root: string;
-  },
-  run: CommandRunner,
-): DoctorRuntimeReport {
-  const target = deriveBrainTarget(input.registrySource, input.targetGitUrl, input.brainNamespace);
-  let report = collectBrainDoctorReport(input, run);
-  const actions = planBrainDoctorFix({
-    findings: report.findings,
-    target,
-    identity: input.identity,
-    root: input.root,
-  });
-  for (const action of actions) {
-    if (action.program === 'mosaic') {
-      run({ program: 'mosaic', args: action.args, env: commandEnv(input.identity) });
-      report = collectBrainDoctorReport(input, run);
-      if (report.access.outcome !== 'ok') return report;
-      continue;
-    }
-    if (action.findingCode === 'brain-clone-missing') {
-      try {
-        ensureBrainRootPrivate(input.root);
-      } catch {
-        return collectBrainDoctorReport(input, run);
-      }
-    }
-    const result = runGit(run, input.identity, action.args);
-    if (result.status !== 0) return collectBrainDoctorReport(input, run);
-  }
-  return collectBrainDoctorReport(input, run);
-}
-
-function requireSuccess(result: CommandResult, operation: string): void {
-  if (result.status !== 0) throw new Error(`${operation}-failed`);
-}
-
-function containedRelative(root: string, path: string): string {
-  if (isAbsolute(path) === false) throw new Error('brain-publish-path-must-be-absolute');
-  const absoluteRoot = resolve(root);
-  const absolutePath = resolve(path);
-  if (absolutePath === absoluteRoot || !absolutePath.startsWith(`${absoluteRoot}${sep}`)) {
-    throw new Error('brain-publish-path-escaped-root');
-  }
-  return relative(absoluteRoot, absolutePath).split(sep).join('/');
-}
-
-export function publishBrainPaths(
-  input: {
-    readonly root: string;
-    readonly identity: string;
-    readonly entries: readonly {
-      readonly path: string;
-      readonly content: Uint8Array;
-    }[];
-    readonly message: string;
-  },
-  run: CommandRunner,
-): PublishEvidence {
-  if (input.entries.length === 0) throw new Error('brain-publish-paths-empty');
-  if (input.message.trim().length === 0) throw new Error('brain-publish-message-empty');
-  const entries = input.entries.map((entry) => {
-    if (entry.content.byteLength > MAX_PUBLISH_ENTRY_BYTES) {
-      throw new Error('brain-publish-entry-too-large');
-    }
-    return {
-      path: containedRelative(input.root, entry.path),
-      content: Uint8Array.from(entry.content),
-    };
-  });
-  const paths = entries.map((entry): string => entry.path);
-  if (new Set(paths).size !== paths.length) throw new Error('brain-publish-path-duplicate');
-
-  const readHead = (): string => {
-    const result = runGit(run, input.identity, ['-C', input.root, 'rev-parse', 'HEAD']);
-    requireSuccess(result, 'brain-git-read-commit');
-    const value = result.stdout.trim();
-    if (!COMMIT.test(value)) throw new Error('brain-git-commit-shape-invalid');
-    return value;
-  };
-  const verifyCommitIdentity = (commit: string): void => {
-    const result = runGit(run, input.identity, [
-      '-C',
-      input.root,
-      'show',
-      '-s',
-      '--format=%an%x00%ae%x00%cn%x00%ce',
-      commit,
-    ]);
-    requireSuccess(result, 'brain-git-read-commit-identity');
-    const expectedEmail = `${input.identity}@fleet.mosaicstack.dev`;
-    const [author, authorEmail, committer, committerEmail] = result.stdout.trimEnd().split('\0');
-    if (
-      author !== input.identity ||
-      authorEmail !== expectedEmail ||
-      committer !== input.identity ||
-      committerEmail !== expectedEmail
-    ) {
-      throw new Error('brain-git-commit-identity-mismatch');
-    }
-  };
-  const expectedObjects = new Map<string, string>();
-  const verifyCommitObjects = (commit: string): void => {
-    for (const [path, expected] of expectedObjects) {
-      const result = runGit(run, input.identity, [
-        '-C',
-        input.root,
-        'rev-parse',
-        `${commit}:${path}`,
-      ]);
-      requireSuccess(result, 'brain-git-read-commit-object');
-      if (result.stdout.trim() !== expected) throw new Error('brain-git-commit-content-mismatch');
-    }
-  };
-  const reconcileRealIndex = (): void => {
-    for (const [path, objectId] of expectedObjects) {
-      requireSuccess(
-        runGit(run, input.identity, [
-          '-C',
-          input.root,
-          'update-index',
-          '--add',
-          '--cacheinfo',
-          '100644',
-          objectId,
-          path,
-        ]),
-        'brain-git-reconcile-checkout-index',
-      );
-    }
-  };
-  const verifyCommitPaths = (commit: string): void => {
-    const changed = runGit(run, input.identity, [
-      '-C',
-      input.root,
-      'diff-tree',
-      '--root',
-      '--no-commit-id',
-      '--name-only',
-      '-r',
-      '-z',
-      commit,
-    ]);
-    requireSuccess(changed, 'brain-git-read-commit-paths');
-    const names = changed.stdout.split('\0').filter(Boolean);
-    const approved = new Set(paths);
-    if (names.length === 0 || names.some((name: string): boolean => !approved.has(name))) {
-      throw new Error('brain-git-commit-paths-unapproved');
-    }
-  };
-
-  const base = readHead();
-  const indexRoot = mkdtempSync(join(tmpdir(), 'mosaic-brain-index-'));
-  const isolatedEnv = { GIT_INDEX_FILE: join(indexRoot, 'index') };
-  let commit = base;
-  let createdCommit = false;
-  try {
-    requireSuccess(
-      runGitWithEnv(run, input.identity, ['-C', input.root, 'read-tree', base], isolatedEnv),
-      'brain-git-isolated-index-init',
-    );
-    for (const entry of entries) {
-      const object = runGitWithEnv(
-        run,
-        input.identity,
-        ['-C', input.root, 'hash-object', '-w', '--stdin'],
-        isolatedEnv,
-        entry.content,
-      );
-      requireSuccess(object, 'brain-git-write-approved-object');
-      const objectId = object.stdout.trim();
-      if (!GIT_OBJECT.test(objectId)) throw new Error('brain-git-object-shape-invalid');
-      expectedObjects.set(entry.path, objectId);
-      requireSuccess(
-        runGitWithEnv(
-          run,
-          input.identity,
-          [
-            '-C',
-            input.root,
-            'update-index',
-            '--add',
-            '--cacheinfo',
-            '100644',
-            objectId,
-            entry.path,
-          ],
-          isolatedEnv,
-        ),
-        'brain-git-stage-approved-object',
-      );
-    }
-    const difference = runGitWithEnv(
-      run,
-      input.identity,
-      ['-C', input.root, 'diff', '--cached', '--quiet', '--exit-code', base, '--', ...paths],
-      isolatedEnv,
-    );
-    if (difference.status === 1) {
-      requireSuccess(
-        runGitWithEnv(
-          run,
-          input.identity,
-          [
-            '-C',
-            input.root,
-            '-c',
-            `user.name=${input.identity}`,
-            '-c',
-            `user.email=${input.identity}@fleet.mosaicstack.dev`,
-            'commit',
-            '-m',
-            input.message,
-          ],
-          isolatedEnv,
-        ),
-        'brain-git-commit',
-      );
-      commit = readHead();
-      verifyCommitPaths(commit);
-      verifyCommitObjects(commit);
-      verifyCommitIdentity(commit);
-      reconcileRealIndex();
-      createdCommit = true;
-    } else if (difference.status !== 0) {
-      throw new Error('brain-git-isolated-diff-failed');
-    }
-  } finally {
-    rmSync(indexRoot, { recursive: true, force: true });
-  }
-
-  let pushed = !createdCommit;
-  for (let attempt = 0; createdCommit && attempt < 3; attempt += 1) {
-    const push = runGit(run, input.identity, ['-C', input.root, 'push', 'origin', 'HEAD:main']);
-    if (push.status === 0) {
-      pushed = true;
-      break;
-    }
-    const concurrentUpdate = /non-fast-forward|fetch first|\[rejected\]/i.test(push.stderr);
-    if (!concurrentUpdate || attempt === 2) throw new Error('brain-git-push-failed');
-    requireSuccess(
-      runGit(run, input.identity, ['-C', input.root, 'fetch', 'origin', 'main']),
-      'brain-git-fetch-concurrent',
-    );
-    requireSuccess(
-      runGit(run, input.identity, [
-        '-C',
-        input.root,
-        '-c',
-        `user.name=${input.identity}`,
-        '-c',
-        `user.email=${input.identity}@fleet.mosaicstack.dev`,
-        'rebase',
-        'origin/main',
-      ]),
-      'brain-git-rebase-concurrent',
-    );
-    commit = readHead();
-    verifyCommitPaths(commit);
-    verifyCommitObjects(commit);
-    verifyCommitIdentity(commit);
-  }
-  if (!pushed) throw new Error('brain-git-push-failed');
-  requireSuccess(
-    runGit(run, input.identity, ['-C', input.root, 'fetch', 'origin', 'main']),
-    'brain-git-fetch-readback',
-  );
-  const reachableResult = runGit(run, input.identity, [
-    '-C',
-    input.root,
-    'merge-base',
-    '--is-ancestor',
-    commit,
-    'origin/main',
-  ]);
-  if (reachableResult.status !== 0 && reachableResult.status !== 1) {
-    throw new Error('brain-git-reachability-check-failed');
-  }
-  const remoteResult = runGit(run, input.identity, ['-C', input.root, 'rev-parse', 'origin/main']);
-  requireSuccess(remoteResult, 'brain-git-read-remote-head');
-  const remoteHead = remoteResult.stdout.trim();
-  if (!COMMIT.test(remoteHead)) throw new Error('brain-git-remote-head-shape-invalid');
-  return { commit, remoteHead, reachable: reachableResult.status === 0 };
-}

packages/mosaic/src/commands/cred.spec.ts

@@ -0,0 +1,419 @@
+import {
+  chmod,
+  mkdtemp,
+  mkdir,
+  open,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  CredentialAuditJournal,
+  CredentialJournalError,
+  listCredentialJournals,
+} from '../credentials/audit-journal.js';
+import { parseCredentialEstateRegistry } from '../credentials/estate-registry.js';
+import { FileCredentialStore } from '../credentials/file-credential-store.js';
+import { executeCredentialRotate, executeCredentialWire } from './cred.js';
+
+let cleanup: string | undefined;
+afterEach(async (): Promise<void> => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+async function fixture(): Promise<{
+  readonly mosaicHome: string;
+  readonly registryPath: string;
+  readonly tokenDirectory: string;
+  readonly stateRoot: string;
+}> {
+  cleanup = await mkdtemp(join(tmpdir(), 'mosaic-cred-command-'));
+  await chmod(cleanup, 0o700);
+  const mosaicHome = join(cleanup, 'mosaic');
+  const credentialDirectory = join(mosaicHome, 'cred');
+  await mkdir(credentialDirectory, { recursive: true, mode: 0o700 });
+  const registryPath = join(credentialDirectory, 'estates.json');
+  await writeFile(
+    registryPath,
+    JSON.stringify({
+      version: 1,
+      estates: [
+        {
+          name: 'homelab',
+          hosts: [
+            {
+              host: 'git.example.invalid',
+              provider: 'gitea',
+              apiBaseUrl: 'https://git.example.invalid',
+              tokenPrefix: 'gitea-example',
+            },
+          ],
+        },
+      ],
+    }),
+    { mode: 0o600 },
+  );
+  return {
+    mosaicHome,
+    registryPath,
+    tokenDirectory: join(mosaicHome, 'secrets', 'gitea-tokens'),
+    stateRoot: join(cleanup, 'state'),
+  };
+}
+
+describe('credential lifecycle command controls', (): void => {
+  it('returns the visible open rotation journal when protected authority resolution fails', async (): Promise<void> => {
+    const paths = await fixture();
+    const registry = parseCredentialEstateRegistry(await readFile(paths.registryPath, 'utf8'));
+    await mkdir(join(paths.mosaicHome, 'secrets'), { mode: 0o700 });
+    const store = new FileCredentialStore(paths.tokenDirectory, registry);
+    await store.put(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        providerLogin: 'seat-name',
+        tokenName: 'old-generation',
+        scopes: ['write:repository'],
+        createdAt: '2026-08-05T00:00:00.000Z',
+      },
+      new TextEncoder().encode('old-token-canary'),
+    );
+
+    const result = await executeCredentialRotate('seat-name', {
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      actor: 'seat-name',
+      authorityFd: '999',
+      tokenName: 'new-generation',
+      mosaicHome: paths.mosaicHome,
+      registry: paths.registryPath,
+      tokenDir: paths.tokenDirectory,
+      stateDir: paths.stateRoot,
+    });
+
+    expect(result.outcome).toBe('error');
+    expect(result.mutation).toBe('none');
+    expect(result.audit.state).toBe('open');
+    expect(result.audit.journalId).not.toBeNull();
+    await expect(listCredentialJournals(paths.stateRoot)).resolves.toContainEqual(
+      expect.objectContaining({ id: result.audit.journalId, state: 'open' }),
+    );
+  });
+
+  it('refuses an unauthenticated actor before rewriting another seat environment', async (): Promise<void> => {
+    const paths = await fixture();
+    const agents = join(paths.mosaicHome, 'fleet', 'agents');
+    await mkdir(agents, { recursive: true, mode: 0o700 });
+    const seatEnvironment = join(agents, 'seat-name.env.generated');
+    const before = 'MOSAIC_AGENT_NAME=seat-name\nMOSAIC_AGENT_CLASS=coder\n';
+    await writeFile(seatEnvironment, before, { mode: 0o600 });
+
+    const result = await executeCredentialWire('seat-name', {
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      actor: 'intruder-seat',
+      seatEnv: seatEnvironment,
+      mosaicHome: paths.mosaicHome,
+      registry: paths.registryPath,
+      tokenDir: paths.tokenDirectory,
+      stateDir: paths.stateRoot,
+    });
+
+    expect(result.outcome).toBe('refused');
+    expect(result.mutation).toBe('none');
+    await expect(readFile(seatEnvironment, 'utf8')).resolves.toBe(before);
+  });
+
+  it('authenticates the exact seat and rewrites its roster-derived projection idempotently', async (): Promise<void> => {
+    const paths = await fixture();
+    const agents = join(paths.mosaicHome, 'fleet', 'agents');
+    await mkdir(agents, { recursive: true, mode: 0o700 });
+    const seatEnvironment = join(agents, 'seat-name.env.generated');
+    await writeFile(seatEnvironment, 'MOSAIC_AGENT_NAME=seat-name\nMOSAIC_AGENT_CLASS=coder\n', {
+      mode: 0o600,
+    });
+    const authorityPath = join(cleanup!, 'authority.json');
+    await writeFile(
+      authorityPath,
+      JSON.stringify({
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        secret: 'authority-canary',
+      }),
+      { mode: 0o600 },
+    );
+    vi.stubGlobal(
+      'fetch',
+      async (): Promise<Response> =>
+        new Response(JSON.stringify({ id: 7, login: 'seat-name' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        }),
+    );
+
+    const invoke = async () => {
+      const authority = await open(authorityPath, 'r');
+      try {
+        return await executeCredentialWire('seat-name', {
+          estate: 'homelab',
+          host: 'git.example.invalid',
+          actor: 'seat-name',
+          authorityFd: authority.fd.toString(),
+          seatEnv: seatEnvironment,
+          mosaicHome: paths.mosaicHome,
+          registry: paths.registryPath,
+          tokenDir: paths.tokenDirectory,
+          stateDir: paths.stateRoot,
+        });
+      } finally {
+        await authority.close();
+      }
+    };
+
+    const first = await invoke();
+    const afterFirst = await readFile(seatEnvironment, 'utf8');
+    const second = await invoke();
+    const afterSecond = await readFile(seatEnvironment, 'utf8');
+
+    expect(first.outcome).toBe('ok');
+    expect(second.outcome).toBe('ok');
+    expect(afterSecond).toBe(afterFirst);
+    expect(afterSecond).toContain('MOSAIC_GIT_IDENTITY=seat-name\n');
+    expect(afterSecond).toContain('MOSAIC_CREDENTIAL_ESTATE=homelab\n');
+    expect(afterSecond).toContain('GITEA_LOGIN=seat-name--git.example.invalid\n');
+  });
+
+  it.each(['recordMutation', 'seal'] as const)(
+    'reports an applied wire as indeterminate when audit %s fails after rename',
+    async (method): Promise<void> => {
+      const paths = await fixture();
+      const agents = join(paths.mosaicHome, 'fleet', 'agents');
+      await mkdir(agents, { recursive: true, mode: 0o700 });
+      const seatEnvironment = join(agents, 'seat-name.env.generated');
+      await writeFile(seatEnvironment, 'MOSAIC_AGENT_NAME=seat-name\n', { mode: 0o600 });
+      const authorityPath = join(cleanup!, 'authority.json');
+      await writeFile(
+        authorityPath,
+        JSON.stringify({
+          identity: 'seat-name',
+          estate: 'homelab',
+          host: 'git.example.invalid',
+          secret: 'authority-canary',
+        }),
+        { mode: 0o600 },
+      );
+      vi.stubGlobal(
+        'fetch',
+        async (): Promise<Response> =>
+          new Response(JSON.stringify({ id: 7, login: 'seat-name' }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+          }),
+      );
+      vi.spyOn(CredentialAuditJournal.prototype, method).mockRejectedValueOnce(
+        new CredentialJournalError('journal-unavailable', 'injected audit failure'),
+      );
+      const authority = await open(authorityPath, 'r');
+      try {
+        const result = await executeCredentialWire('seat-name', {
+          estate: 'homelab',
+          host: 'git.example.invalid',
+          actor: 'seat-name',
+          authorityFd: authority.fd.toString(),
+          seatEnv: seatEnvironment,
+          mosaicHome: paths.mosaicHome,
+          registry: paths.registryPath,
+          tokenDir: paths.tokenDirectory,
+          stateDir: paths.stateRoot,
+        });
+        expect(result.outcome).toBe('indeterminate');
+        expect(result.mutation).toBe('applied');
+        expect(await readFile(seatEnvironment, 'utf8')).toContain('MOSAIC_GIT_IDENTITY=seat-name');
+      } finally {
+        await authority.close();
+      }
+    },
+  );
+
+  it('refuses to overwrite a roster projection replaced after validation', async (): Promise<void> => {
+    const paths = await fixture();
+    const agents = join(paths.mosaicHome, 'fleet', 'agents');
+    await mkdir(agents, { recursive: true, mode: 0o700 });
+    const seatEnvironment = join(agents, 'seat-name.env.generated');
+    await writeFile(seatEnvironment, 'MOSAIC_AGENT_NAME=seat-name\n', { mode: 0o600 });
+    const authorityPath = join(cleanup!, 'authority.json');
+    await writeFile(
+      authorityPath,
+      JSON.stringify({
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        secret: 'authority-canary',
+      }),
+      { mode: 0o600 },
+    );
+    vi.stubGlobal(
+      'fetch',
+      async (): Promise<Response> =>
+        new Response(JSON.stringify({ id: 7, login: 'seat-name' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        }),
+    );
+    const authority = await open(authorityPath, 'r');
+    try {
+      const result = await executeCredentialWire('seat-name', {
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        actor: 'seat-name',
+        authorityFd: authority.fd.toString(),
+        seatEnv: seatEnvironment,
+        mosaicHome: paths.mosaicHome,
+        registry: paths.registryPath,
+        tokenDir: paths.tokenDirectory,
+        stateDir: paths.stateRoot,
+        wireBeforeRename: async (): Promise<void> => {
+          const replacement = join(agents, 'replacement');
+          await writeFile(replacement, 'MOSAIC_AGENT_NAME=seat-name\nNEW=value\n', { mode: 0o600 });
+          await rename(replacement, seatEnvironment);
+        },
+      });
+      expect(result.outcome).toBe('error');
+      expect(result.mutation).toBe('none');
+      expect(await readFile(seatEnvironment, 'utf8')).toBe(
+        'MOSAIC_AGENT_NAME=seat-name\nNEW=value\n',
+      );
+    } finally {
+      await authority.close();
+    }
+  });
+
+  it('reports directory-sync failure after rename as applied and indeterminate', async (): Promise<void> => {
+    const paths = await fixture();
+    const agents = join(paths.mosaicHome, 'fleet', 'agents');
+    await mkdir(agents, { recursive: true, mode: 0o700 });
+    const seatEnvironment = join(agents, 'seat-name.env.generated');
+    await writeFile(seatEnvironment, 'MOSAIC_AGENT_NAME=seat-name\n', { mode: 0o600 });
+    const authorityPath = join(cleanup!, 'authority.json');
+    await writeFile(
+      authorityPath,
+      JSON.stringify({
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        secret: 'authority-canary',
+      }),
+      { mode: 0o600 },
+    );
+    vi.stubGlobal(
+      'fetch',
+      async (): Promise<Response> =>
+        new Response(JSON.stringify({ id: 7, login: 'seat-name' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        }),
+    );
+    const authority = await open(authorityPath, 'r');
+    try {
+      const result = await executeCredentialWire('seat-name', {
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        actor: 'seat-name',
+        authorityFd: authority.fd.toString(),
+        seatEnv: seatEnvironment,
+        mosaicHome: paths.mosaicHome,
+        registry: paths.registryPath,
+        tokenDir: paths.tokenDirectory,
+        stateDir: paths.stateRoot,
+        wireDirectorySync: async (): Promise<void> => {
+          throw new Error('injected directory sync failure');
+        },
+      });
+      expect(result.outcome).toBe('indeterminate');
+      expect(result.mutation).toBe('applied');
+      expect(await readFile(seatEnvironment, 'utf8')).toContain('MOSAIC_GIT_IDENTITY=seat-name');
+    } finally {
+      await authority.close();
+    }
+  });
+
+  it('removes a temporary projection when directory revalidation fails before rename', async (): Promise<void> => {
+    const paths = await fixture();
+    const agents = join(paths.mosaicHome, 'fleet', 'agents');
+    await mkdir(agents, { recursive: true, mode: 0o700 });
+    const seatEnvironment = join(agents, 'seat-name.env.generated');
+    await writeFile(seatEnvironment, 'MOSAIC_AGENT_NAME=seat-name\n', { mode: 0o600 });
+    const authorityPath = join(cleanup!, 'authority.json');
+    await writeFile(
+      authorityPath,
+      JSON.stringify({
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        secret: 'authority-canary',
+      }),
+      { mode: 0o600 },
+    );
+    vi.stubGlobal('fetch', async (): Promise<Response> => {
+      await chmod(agents, 0o777);
+      return new Response(JSON.stringify({ id: 7, login: 'seat-name' }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    });
+    const authority = await open(authorityPath, 'r');
+    try {
+      const result = await executeCredentialWire('seat-name', {
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        actor: 'seat-name',
+        authorityFd: authority.fd.toString(),
+        seatEnv: seatEnvironment,
+        mosaicHome: paths.mosaicHome,
+        registry: paths.registryPath,
+        tokenDir: paths.tokenDirectory,
+        stateDir: paths.stateRoot,
+      });
+      expect(result.outcome).toBe('error');
+      expect(await readdir(agents)).toEqual(['seat-name.env.generated']);
+    } finally {
+      await authority.close();
+      await chmod(agents, 0o700);
+    }
+  });
+
+  it('refuses a caller-selected seat filename that is not bound to the requested identity', async (): Promise<void> => {
+    const paths = await fixture();
+    const agents = join(paths.mosaicHome, 'fleet', 'agents');
+    await mkdir(agents, { recursive: true, mode: 0o700 });
+    const seatEnvironment = join(agents, 'other-seat.env.generated');
+    const before = 'MOSAIC_AGENT_NAME=other-seat\nMOSAIC_AGENT_CLASS=coder\n';
+    await writeFile(seatEnvironment, before, { mode: 0o600 });
+
+    const result = await executeCredentialWire('seat-name', {
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      actor: 'seat-name',
+      authorityFd: '999',
+      seatEnv: seatEnvironment,
+      mosaicHome: paths.mosaicHome,
+      registry: paths.registryPath,
+      tokenDir: paths.tokenDirectory,
+      stateDir: paths.stateRoot,
+    });
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('credential-binding-mismatch');
+    await expect(readFile(seatEnvironment, 'utf8')).resolves.toBe(before);
+  });
+});

packages/mosaic/src/commands/launch.ts

@@ -29,11 +29,6 @@ import { readPersonaContractBlock } from '../fleet/persona-contract.js';
 import { canonicalizeRoleClass } from './fleet-personas.js';
 import { launchClaudex, type ClaudexHarnessAdapter } from './claudex.js';
 import { runLeaseEnforcementDoctorCheck } from './lease-doctor-check.js';
-import {
-  defaultInstalledBrainDoctorOptions,
-  runInstalledBrainDoctorCheck,
-} from './brain-doctor-check.js';
-import { systemCommandRunner } from './brain-store-runtime.js';
 
 const MOSAIC_HOME = process.env['MOSAIC_HOME'] ?? join(homedir(), '.config', 'mosaic');
 const MAX_INSTALLED_TOOLS_BYTES = 256 * 1024;
@@ -1262,11 +1257,8 @@ export function registerLaunchCommands(program: Command): void {
       });
   }
 
-  // `doctor` — the framework drift audit (bash script), the #869
-  // Point-1 C5 lease-enforcement activation check, and the #1051 per-estate
-  // durable brain check. Both TS checks run before the bash audit and can
-  // force a non-zero result for hard/indeterminate failures.
-  // The lease check reuses C1's
+  // `doctor` — the framework drift audit (bash script) PLUS the #869
+  // Point-1 C5 lease-enforcement activation check (TS, reusing C1's
   // `leaseEnforcementActivatable()` and C3's `checkBrokerSupervisorHealth()`).
   // Kept out of the generic `directCommands` loop above because this check
   // must run and report BEFORE the bash script's own exit, and must be able
@@ -1275,29 +1267,14 @@ export function registerLaunchCommands(program: Command): void {
   // undiagnosed (see lease-doctor-check.ts docstring).
   program
     .command('doctor')
-    .description('Health audit — detect drift, lease gaps, and per-estate brain defects')
+    .description('Health audit — detect drift, missing files, and #869 lease-activation gaps')
     .allowUnknownOption(true)
     .allowExcessArguments(true)
     .action(async (_opts: unknown, cmd: Command) => {
       checkMosaicHome();
       const leaseCheck = await runLeaseEnforcementDoctorCheck();
       const leaseCheckFailed = printLeaseDoctorCheck(leaseCheck);
-      const fix = cmd.args.includes('--fix');
-      const brainCheck = runInstalledBrainDoctorCheck(
-        defaultInstalledBrainDoctorOptions(fix),
-        systemCommandRunner,
-      );
-      for (const line of brainCheck.lines) {
-        (brainCheck.status === 'ok' ? console.log : console.error)(line);
-      }
-      const brainCheckFailed =
-        brainCheck.status === 'error' ||
-        (brainCheck.status === 'warn' && cmd.args.includes('--fail-on-warn'));
-      runDoctorScriptAndExit(
-        fwScript('mosaic-doctor'),
-        cmd.args,
-        leaseCheckFailed || brainCheckFailed,
-      );
+      runDoctorScriptAndExit(fwScript('mosaic-doctor'), cmd.args, leaseCheckFailed);
     });
 }
 

packages/mosaic/src/credentials/audit-journal.dto.ts

@@ -0,0 +1,57 @@
+export type CredentialJournalOperation =
+  | 'provision'
+  | 'wire'
+  | 'grant'
+  | 'get'
+  | 'validate'
+  | 'rotate'
+  | 'revoke'
+  | 'whoami'
+  | 'list'
+  | 'audit';
+
+export interface CredentialJournalContextDto {
+  readonly operation: CredentialJournalOperation;
+  readonly actor: string;
+  readonly identity: string;
+  readonly estate: string;
+  readonly host: string;
+  readonly repo: string | null;
+}
+
+export interface CredentialProviderJournalEvidenceDto {
+  readonly endpoint: string;
+  readonly contentType: string;
+  readonly decision: string;
+}
+
+export interface CredentialJournalCorrectionDto {
+  readonly supersedesJournalId: string;
+  readonly correctedByJournalId: string;
+  readonly previousReason: string;
+  readonly correctedReason: string;
+  readonly previousOutcome?: 'ok' | 'refused' | 'error' | 'indeterminate';
+  readonly correctedOutcome?: 'ok' | 'refused' | 'error' | 'indeterminate';
+}
+
+export interface CredentialPopulationCorrectionDto {
+  readonly entries: readonly {
+    readonly identity: string;
+    readonly supersedesJournalIds: readonly string[];
+    readonly settledByJournalId: string;
+    readonly capability: 'confirmed';
+    readonly identityBinding: 'not-measured';
+    readonly mechanism: 'identity-scope-forbidden-in-scope-capability-confirmed';
+  }[];
+}
+
+export interface CredentialJournalRuntimeOptionsDto {
+  readonly id?: string;
+  readonly now?: () => string;
+}
+
+export interface CredentialJournalSummaryDto {
+  readonly id: string;
+  readonly state: 'open' | 'sealed';
+  readonly path: string;
+}

packages/mosaic/src/credentials/audit-journal.spec.ts

@@ -0,0 +1,184 @@
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { CredentialAuditJournal, listCredentialJournals } from './audit-journal.js';
+
+let cleanup: string | undefined;
+
+async function stateRoot(): Promise<string> {
+  cleanup = await mkdtemp(join(tmpdir(), 'mosaic-cred-journal-'));
+  return join(cleanup, 'state');
+}
+
+afterEach(async (): Promise<void> => {
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+describe('credential durable audit journal', (): void => {
+  it('opens before mutation, appends provider evidence, and seals durably', async (): Promise<void> => {
+    const root = await stateRoot();
+    const journal = await CredentialAuditJournal.open(
+      root,
+      {
+        operation: 'grant',
+        actor: 'provisioner',
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+      },
+      { id: 'journal-id', now: (): string => '2026-08-05T00:00:00.000Z' },
+    );
+
+    await journal.recordIntent('provider-grant');
+    await journal.recordProviderEvidence({
+      endpoint: 'GET /api/v1/repos/owner/repo',
+      contentType: 'application/json',
+      decision: 'permission-write',
+    });
+    const sealedPath = await journal.seal('ok', 'grant-verified');
+
+    expect(sealedPath).toMatch(/journal-id\.sealed\.jsonl$/);
+    const records = (await readFile(sealedPath, 'utf8')).trim().split('\n');
+    expect(records).toHaveLength(4);
+    expect(records[0]).toContain('"phase":"opened"');
+    expect(records[1]).toContain('"phase":"intent"');
+    expect(records[2]).toContain('"phase":"provider-evidence"');
+    expect(records[3]).toContain('"phase":"sealed"');
+  });
+
+  it('leaves an unsealed journal visible for recovery', async (): Promise<void> => {
+    const root = await stateRoot();
+    const journal = await CredentialAuditJournal.open(root, {
+      operation: 'rotate',
+      actor: 'provisioner',
+      identity: 'seat-name',
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      repo: null,
+    });
+
+    const journals = await listCredentialJournals(root);
+
+    expect(journals).toHaveLength(1);
+    expect(journals[0]?.state).toBe('open');
+    await journal.closeIncomplete();
+  });
+
+  it('fails fatally when the durable journal root cannot be created', async (): Promise<void> => {
+    const root = await stateRoot();
+    await writeFile(root, 'not-a-directory', { mode: 0o600 });
+
+    await expect(
+      CredentialAuditJournal.open(root, {
+        operation: 'grant',
+        actor: 'provisioner',
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+      }),
+    ).rejects.toThrow(/journal-unavailable/);
+  });
+
+  it('rejects secret-shaped evidence instead of writing it', async (): Promise<void> => {
+    const root = await stateRoot();
+    const journal = await CredentialAuditJournal.open(root, {
+      operation: 'validate',
+      actor: 'seat-name',
+      identity: 'seat-name',
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      repo: 'owner/repo',
+    });
+
+    await expect(
+      journal.recordProviderEvidence({
+        endpoint: 'GET /api/v1/user',
+        contentType: 'application/json',
+        decision: 'seeded-secret-canary',
+      }),
+    ).rejects.toThrow(/unsafe-audit-value/);
+    const journals = await listCredentialJournals(root);
+    const source = await readFile(journals[0]?.path ?? '', 'utf8');
+    expect(source).not.toContain('seeded-secret-canary');
+    await journal.closeIncomplete();
+  });
+
+  it('refuses a group-writable journal root before opening evidence', async (): Promise<void> => {
+    const root = await stateRoot();
+    await mkdir(root, { mode: 0o700 });
+    await chmod(root, 0o770);
+    await expect(
+      CredentialAuditJournal.open(root, {
+        operation: 'grant',
+        actor: 'provisioner',
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+      }),
+    ).rejects.toThrow(/journal-unavailable/);
+  });
+
+  it('supersedes a false sealed classification without editing the original journal', async (): Promise<void> => {
+    const root = await stateRoot();
+    const journal = await CredentialAuditJournal.open(
+      root,
+      {
+        operation: 'validate',
+        actor: 'be-coder-06',
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+      },
+      { id: 'correction-1' },
+    );
+    await journal.recordIntent('classification-correction');
+    await journal.recordCorrection({
+      supersedesJournalId: 'old-sealed-id',
+      correctedByJournalId: 'new-validation-id',
+      previousReason: 'identity-not-found',
+      correctedReason: 'credential-rejected',
+      previousOutcome: 'indeterminate',
+      correctedOutcome: 'refused',
+    });
+    const path = await journal.seal('indeterminate', 'credential-rejected');
+    const source = await readFile(path, 'utf8');
+    expect(source).toContain('"phase":"classification-correction"');
+    expect(source).toContain('"supersedesJournalId":"old-sealed-id"');
+  });
+
+  it('records one settled population correction across a classification chain', async (): Promise<void> => {
+    const root = await stateRoot();
+    const journal = await CredentialAuditJournal.open(root, {
+      operation: 'validate',
+      actor: 'be-coder-06',
+      identity: 'fleet-reconciliation',
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      repo: 'owner/repo',
+    });
+    await journal.recordIntent('classification-correction');
+    await journal.recordPopulationCorrection({
+      entries: [
+        {
+          identity: 'seat-name',
+          supersedesJournalIds: ['v1-2-id', 'v1-4-id', 'v1-4-1-id'],
+          settledByJournalId: 'v1-5-id',
+          capability: 'confirmed',
+          identityBinding: 'not-measured',
+          mechanism: 'identity-scope-forbidden-in-scope-capability-confirmed',
+        },
+      ],
+    });
+    const path = await journal.seal('ok', 'classification-corrected');
+    const source = await readFile(path, 'utf8');
+    expect(source).toContain('"phase":"population-classification-correction"');
+    expect(source).toContain('"capability":"confirmed"');
+    expect(source).toContain('"identityBinding":"not-measured"');
+  });
+});

packages/mosaic/src/credentials/audit-journal.ts

@@ -0,0 +1,314 @@
+import { randomUUID } from 'node:crypto';
+import { lstatSync } from 'node:fs';
+import { open, readdir, rename } from 'node:fs/promises';
+import type { FileHandle } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ensureManagedDirectory } from '../fleet/secure-file.js';
+import type {
+  CredentialJournalContextDto,
+  CredentialJournalCorrectionDto,
+  CredentialJournalRuntimeOptionsDto,
+  CredentialPopulationCorrectionDto,
+  CredentialJournalSummaryDto,
+  CredentialProviderJournalEvidenceDto,
+} from './audit-journal.dto.js';
+
+const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+const SAFE_ESTATE = /^[a-z0-9][a-z0-9-]*$/;
+const SAFE_HOST = /^[a-z0-9][a-z0-9.-]*$/;
+const SAFE_REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const SAFE_ENDPOINT = /^(?:GET|PUT|POST|DELETE) \/[A-Za-z0-9_./{}:-]+$/;
+const SAFE_CONTENT_TYPE = /^[A-Za-z0-9!#$&^_.+/-]+(?:;[A-Za-z0-9=._+-]+)*$/;
+const SAFE_DECISIONS = new Set<string>([
+  'provider-grant',
+  'permission-none',
+  'permission-read',
+  'permission-write',
+  'permission-admin',
+  'identity-verified',
+  'inventory-authority-verified',
+  'scope-verified',
+  'grant-verified',
+  'revoke-verified',
+  'rotate-verified',
+  'validation-requested',
+  'whoami-requested',
+  'provision-requested',
+  'rotate-requested',
+  'revoke-requested',
+  'wire-requested',
+  'get-requested',
+  'validation-verified',
+  'team-member-present',
+  'team-member-absent',
+  'team-repository-present',
+  'team-repository-absent',
+  'team-repository-set-verified',
+  'organization-member-present',
+  'organization-member-absent',
+  'collaborator-grant-applied',
+  'team-member-applied',
+  'team-member-rollback-applied',
+  'team-repository-applied',
+  'team-repository-rollback-applied',
+  'transport-write-verified',
+  'token-mint-applied',
+  'token-binding-stored',
+  'tea-login-stored',
+  'tea-login-removed',
+  'provision-rollback-verified',
+  'rotate-rollback-verified',
+  'token-revoke-applied',
+  'wire-applied',
+  'credential-issuance-authorized',
+  'credential-issued',
+  'classification-correction',
+]);
+
+export class CredentialJournalError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(`Credential audit journal failed: code=${code} ${message}`);
+    this.name = 'CredentialJournalError';
+  }
+}
+
+function assertPrivateDirectory(path: string): void {
+  const stat = lstatSync(path);
+  if (
+    !stat.isDirectory() ||
+    stat.isSymbolicLink() ||
+    stat.uid !== process.getuid?.() ||
+    (stat.mode & 0o022) !== 0
+  ) {
+    throw new CredentialJournalError(
+      'journal-unavailable',
+      'journal directory owner or write permissions are unsafe',
+    );
+  }
+}
+
+function assertContext(context: CredentialJournalContextDto): void {
+  if (
+    !SAFE_NAME.test(context.actor) ||
+    !SAFE_NAME.test(context.identity) ||
+    !SAFE_ESTATE.test(context.estate) ||
+    !SAFE_HOST.test(context.host) ||
+    (context.repo !== null && !SAFE_REPO.test(context.repo))
+  ) {
+    throw new CredentialJournalError(
+      'unsafe-audit-value',
+      'journal context is outside the non-secret allowlist grammar',
+    );
+  }
+}
+
+function assertEvidence(evidence: CredentialProviderJournalEvidenceDto): void {
+  if (
+    !SAFE_ENDPOINT.test(evidence.endpoint) ||
+    !SAFE_CONTENT_TYPE.test(evidence.contentType) ||
+    !SAFE_DECISIONS.has(evidence.decision)
+  ) {
+    throw new CredentialJournalError(
+      'unsafe-audit-value',
+      'provider evidence is outside the non-secret allowlist',
+    );
+  }
+}
+
+async function syncDirectory(path: string): Promise<void> {
+  const directory = await open(path, 'r');
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
+
+export class CredentialAuditJournal {
+  private closed = false;
+
+  private constructor(
+    private readonly handle: FileHandle,
+    private readonly openPath: string,
+    private readonly journalsDirectory: string,
+    private readonly id: string,
+    private readonly now: () => string,
+  ) {}
+
+  static async open(
+    stateRoot: string,
+    context: CredentialJournalContextDto,
+    runtime: CredentialJournalRuntimeOptionsDto = {},
+  ): Promise<CredentialAuditJournal> {
+    assertContext(context);
+    const id = runtime.id ?? randomUUID();
+    if (!SAFE_NAME.test(id)) {
+      throw new CredentialJournalError('unsafe-audit-value', 'journal id is outside the grammar');
+    }
+    const now = runtime.now ?? ((): string => new Date().toISOString());
+    const journalsDirectory = join(stateRoot, 'journals');
+    let handle: FileHandle | undefined;
+    try {
+      ensureManagedDirectory(stateRoot, journalsDirectory);
+      assertPrivateDirectory(stateRoot);
+      assertPrivateDirectory(journalsDirectory);
+      const openPath = join(journalsDirectory, `${id}.open.jsonl`);
+      handle = await open(openPath, 'wx', 0o600);
+      const journal = new CredentialAuditJournal(handle, openPath, journalsDirectory, id, now);
+      await journal.append({ phase: 'opened', at: now(), context });
+      await syncDirectory(journalsDirectory);
+      return journal;
+    } catch (error: unknown) {
+      if (handle !== undefined) await handle.close().catch((): void => undefined);
+      if (error instanceof CredentialJournalError) throw error;
+      throw new CredentialJournalError(
+        'journal-unavailable',
+        'durable journal could not be opened and fsynced',
+      );
+    }
+  }
+
+  private async append(record: object): Promise<void> {
+    if (this.closed) {
+      throw new CredentialJournalError('journal-unavailable', 'journal is already closed');
+    }
+    try {
+      await this.handle.write(`${JSON.stringify(record)}\n`);
+      await this.handle.sync();
+    } catch {
+      throw new CredentialJournalError(
+        'journal-unavailable',
+        'durable journal append or fsync failed',
+      );
+    }
+  }
+
+  journalId(): string {
+    return this.id;
+  }
+
+  async recordIntent(decision: string): Promise<void> {
+    if (!SAFE_DECISIONS.has(decision)) {
+      throw new CredentialJournalError(
+        'unsafe-audit-value',
+        'intent decision is outside the non-secret allowlist',
+      );
+    }
+    await this.append({ phase: 'intent', at: this.now(), decision });
+  }
+
+  async recordProviderEvidence(evidence: CredentialProviderJournalEvidenceDto): Promise<void> {
+    assertEvidence(evidence);
+    await this.append({ phase: 'provider-evidence', at: this.now(), evidence });
+  }
+
+  async recordMutation(decision: string): Promise<void> {
+    if (!SAFE_DECISIONS.has(decision)) {
+      throw new CredentialJournalError(
+        'unsafe-audit-value',
+        'mutation decision is outside the non-secret allowlist',
+      );
+    }
+    await this.append({ phase: 'mutation', at: this.now(), decision });
+  }
+
+  async recordCorrection(correction: CredentialJournalCorrectionDto): Promise<void> {
+    if (
+      !SAFE_NAME.test(correction.supersedesJournalId) ||
+      !SAFE_NAME.test(correction.correctedByJournalId) ||
+      !SAFE_NAME.test(correction.previousReason) ||
+      !SAFE_NAME.test(correction.correctedReason) ||
+      (correction.previousOutcome === undefined) !== (correction.correctedOutcome === undefined)
+    ) {
+      throw new CredentialJournalError(
+        'unsafe-audit-value',
+        'classification correction is outside the non-secret grammar',
+      );
+    }
+    await this.append({ phase: 'classification-correction', at: this.now(), correction });
+  }
+
+  async recordPopulationCorrection(correction: CredentialPopulationCorrectionDto): Promise<void> {
+    if (
+      correction.entries.length === 0 ||
+      correction.entries.some(
+        (entry): boolean =>
+          !SAFE_NAME.test(entry.identity) ||
+          !SAFE_NAME.test(entry.settledByJournalId) ||
+          entry.supersedesJournalIds.length === 0 ||
+          entry.supersedesJournalIds.some((id): boolean => !SAFE_NAME.test(id)),
+      )
+    ) {
+      throw new CredentialJournalError(
+        'unsafe-audit-value',
+        'population correction is outside the non-secret grammar',
+      );
+    }
+    await this.append({
+      phase: 'population-classification-correction',
+      at: this.now(),
+      correction,
+    });
+  }
+
+  async seal(
+    outcome: 'ok' | 'refused' | 'error' | 'indeterminate',
+    reasonCode: string,
+  ): Promise<string> {
+    if (!SAFE_NAME.test(reasonCode)) {
+      throw new CredentialJournalError(
+        'unsafe-audit-value',
+        'reason code is outside the non-secret grammar',
+      );
+    }
+    await this.append({ phase: 'sealed', at: this.now(), outcome, reasonCode });
+    await this.handle.close();
+    this.closed = true;
+    const sealedPath = join(this.journalsDirectory, `${this.id}.sealed.jsonl`);
+    try {
+      await rename(this.openPath, sealedPath);
+      await syncDirectory(this.journalsDirectory);
+      return sealedPath;
+    } catch {
+      throw new CredentialJournalError(
+        'journal-unavailable',
+        'sealed journal could not be committed durably',
+      );
+    }
+  }
+
+  async closeIncomplete(): Promise<void> {
+    if (this.closed) return;
+    await this.handle.close();
+    this.closed = true;
+  }
+}
+
+export async function listCredentialJournals(
+  stateRoot: string,
+): Promise<readonly CredentialJournalSummaryDto[]> {
+  const journalsDirectory = join(stateRoot, 'journals');
+  let names: string[];
+  try {
+    assertPrivateDirectory(stateRoot);
+    assertPrivateDirectory(journalsDirectory);
+    names = await readdir(journalsDirectory);
+  } catch (error: unknown) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return [];
+    throw new CredentialJournalError('journal-unavailable', 'journal directory could not be read');
+  }
+  return names
+    .filter((name: string): boolean => /\.(?:open|sealed)\.jsonl$/.test(name))
+    .sort()
+    .map((name: string): CredentialJournalSummaryDto => {
+      const state = name.endsWith('.open.jsonl') ? 'open' : 'sealed';
+      return {
+        id: name.replace(/\.(?:open|sealed)\.jsonl$/, ''),
+        state,
+        path: join(journalsDirectory, name),
+      };
+    });
+}

packages/mosaic/src/credentials/credential-binding.dto.ts

@@ -0,0 +1,11 @@
+export interface CredentialBindingMetadataDto {
+  readonly schemaVersion?: 1;
+  readonly identity: string;
+  readonly estate: string;
+  readonly host: string;
+  readonly providerLogin: string;
+  readonly tokenName: string;
+  readonly scopes: readonly string[];
+  readonly createdAt: string;
+  readonly tokenDigest?: string;
+}

packages/mosaic/src/credentials/credential-provider.dto.ts

@@ -0,0 +1,52 @@
+import type {
+  ProviderIdentityEvidenceDto,
+  ReceivePackEvidenceDto,
+  RepositoryPermission,
+  RepositoryPermissionEvidenceDto,
+} from './credential-result.dto.js';
+
+export interface ResolvedCredential {
+  readonly identity: string;
+  readonly estate: string;
+  readonly host: string;
+  readonly resolutionId: string;
+  readonly secret: Uint8Array;
+}
+
+export interface CredentialResolver {
+  resolve(identity: string, estate: string, host: string): Promise<ResolvedCredential | undefined>;
+}
+
+export interface GiteaCredentialProvider {
+  readIdentity(resolved: ResolvedCredential): Promise<ProviderIdentityEvidenceDto>;
+  readRepositoryPermission(
+    resolved: ResolvedCredential,
+    repo: string,
+  ): Promise<RepositoryPermissionEvidenceDto>;
+  probeReceivePack(
+    resolved: ResolvedCredential | undefined,
+    repo: string,
+  ): Promise<ReceivePackEvidenceDto>;
+}
+
+export interface CredentialEstateRegistry {
+  matches(estate: string, host: string): boolean;
+}
+
+export interface CredentialValidationDependencies {
+  readonly resolver: CredentialResolver;
+  readonly provider: GiteaCredentialProvider;
+  readonly estateRegistry: CredentialEstateRegistry;
+}
+
+export interface GiteaReadValidationRequestDto {
+  readonly identity: string;
+  readonly estate: string;
+  readonly host: string;
+  readonly repo: string;
+  readonly requiredPermission?: RepositoryPermission;
+}
+
+export interface GiteaWriteValidationRequestDto extends GiteaReadValidationRequestDto {
+  readonly readOnlyControlIdentity: string;
+}

packages/mosaic/src/credentials/credential-result.dto.ts

@@ -0,0 +1,84 @@
+export type CredentialOutcome = 'ok' | 'refused' | 'error' | 'indeterminate';
+export type CredentialMutationState = 'none' | 'not-started' | 'applied' | 'unknown';
+export type RepositoryPermission = 'none' | 'read' | 'write' | 'admin';
+export type ReceivePackState = 'advertised' | 'refused';
+
+export interface CredentialReasonDto {
+  readonly code: string;
+  readonly message: string;
+}
+
+export interface CredentialSubjectDto {
+  readonly identity: string;
+  readonly estate: string;
+  readonly host: string;
+  readonly repo: string;
+}
+
+export interface ProviderIdentityEvidenceDto {
+  readonly login: string;
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+
+export interface RepositoryPermissionEvidenceDto {
+  readonly effective: RepositoryPermission;
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+
+export interface ReceivePackEvidenceDto {
+  readonly state: ReceivePackState;
+  readonly principal: string | null;
+  readonly resolutionId: string | null;
+  readonly contentType: string;
+}
+
+export interface ReadOnlyControlEvidenceDto {
+  readonly identity: string;
+  readonly providerPermission: RepositoryPermission;
+  readonly receivePack: ReceivePackState;
+}
+
+export interface WriteDifferentialEvidenceDto {
+  readonly state: 'can-write';
+  readonly credentialBinding: 'same-resolution';
+  readonly transportPrincipal: string;
+  readonly authenticatedReceivePack: 'advertised';
+  readonly readOnlyControl: ReadOnlyControlEvidenceDto;
+  readonly unauthenticatedReceivePack: 'refused';
+  readonly artifactCreated: false;
+  readonly proves: string;
+  readonly doesNotProve: string;
+}
+
+export interface TokenCapabilitiesEvidenceDto {
+  readonly state: 'measured' | 'not-measured';
+  readonly scopes: readonly string[];
+  readonly source: 'provider-token-object' | 'runtime-not-authorized';
+}
+
+export interface CredentialValidationEvidenceDto {
+  readonly providerIdentity: ProviderIdentityEvidenceDto | null;
+  readonly tokenCapabilities: TokenCapabilitiesEvidenceDto;
+  readonly repositoryPermission: RepositoryPermissionEvidenceDto | null;
+  readonly writeDifferential: WriteDifferentialEvidenceDto | null;
+}
+
+export interface CredentialAuditResultDto {
+  readonly journalId: string | null;
+  readonly state: 'not-started' | 'open' | 'sealed';
+}
+
+export interface CredentialValidationResultDto {
+  readonly schemaVersion: 1;
+  readonly operation: 'validate' | 'whoami';
+  readonly outcome: CredentialOutcome;
+  readonly exitCode: 0 | 10 | 20 | 30;
+  readonly retryable: boolean;
+  readonly subject: CredentialSubjectDto;
+  readonly mutation: CredentialMutationState;
+  readonly reason: CredentialReasonDto;
+  readonly evidence: CredentialValidationEvidenceDto;
+  readonly audit: CredentialAuditResultDto;
+}

packages/mosaic/src/credentials/credential-validate-service.ts

@@ -0,0 +1,141 @@
+import { CredentialAuditJournal, CredentialJournalError } from './audit-journal.js';
+import type {
+  CredentialValidationDependencies,
+  GiteaReadValidationRequestDto,
+  GiteaWriteValidationRequestDto,
+} from './credential-provider.dto.js';
+import type {
+  CredentialValidationResultDto,
+  RepositoryPermission,
+} from './credential-result.dto.js';
+import { evaluateGiteaReadValidation, evaluateGiteaWriteValidation } from './validate.js';
+
+export interface CredentialValidationServiceOptions {
+  readonly stateRoot: string;
+  readonly actor: string;
+  readonly operation?: 'validate' | 'whoami';
+}
+
+function permissionDecision(permission: RepositoryPermission): string {
+  if (permission === 'none') return 'permission-none';
+  if (permission === 'admin') return 'permission-admin';
+  if (permission === 'write') return 'permission-write';
+  return 'permission-read';
+}
+
+async function openValidationJournal(
+  request: GiteaReadValidationRequestDto,
+  options: CredentialValidationServiceOptions,
+): Promise<CredentialAuditJournal> {
+  const journal = await CredentialAuditJournal.open(options.stateRoot, {
+    operation: options.operation ?? 'validate',
+    actor: options.actor,
+    identity: request.identity,
+    estate: request.estate,
+    host: request.host,
+    repo: request.repo,
+  });
+  await journal.recordIntent(
+    options.operation === 'whoami' ? 'whoami-requested' : 'validation-requested',
+  );
+  return journal;
+}
+
+async function recordAndSealValidation(
+  journal: CredentialAuditJournal,
+  validation: CredentialValidationResultDto,
+): Promise<CredentialValidationResultDto> {
+  if (validation.evidence.providerIdentity !== null) {
+    await journal.recordProviderEvidence({
+      endpoint: validation.evidence.providerIdentity.endpoint,
+      contentType: validation.evidence.providerIdentity.contentType,
+      decision: 'identity-verified',
+    });
+  }
+  if (validation.evidence.repositoryPermission !== null) {
+    await journal.recordProviderEvidence({
+      endpoint: validation.evidence.repositoryPermission.endpoint,
+      contentType: validation.evidence.repositoryPermission.contentType,
+      decision: permissionDecision(validation.evidence.repositoryPermission.effective),
+    });
+  }
+  await journal.seal(validation.outcome, validation.reason.code);
+  return {
+    ...validation,
+    audit: { journalId: journal.journalId(), state: 'sealed' },
+  };
+}
+
+function journalFailureResult(
+  request: GiteaReadValidationRequestDto,
+  journal: CredentialAuditJournal,
+  error: CredentialJournalError,
+  operation: 'validate' | 'whoami',
+): CredentialValidationResultDto {
+  return {
+    schemaVersion: 1,
+    operation,
+    outcome: 'error',
+    exitCode: 20,
+    retryable: false,
+    subject: {
+      identity: request.identity,
+      estate: request.estate,
+      host: request.host,
+      repo: request.repo,
+    },
+    mutation: 'none',
+    reason: {
+      code: error.code,
+      message: 'Validation audit persistence failed; inspect the durable open journal.',
+    },
+    evidence: {
+      providerIdentity: null,
+      tokenCapabilities: {
+        state: 'not-measured',
+        scopes: [],
+        source: 'runtime-not-authorized',
+      },
+      repositoryPermission: null,
+      writeDifferential: null,
+    },
+    audit: { journalId: journal.journalId(), state: 'open' },
+  };
+}
+
+export async function runCredentialReadValidation(
+  request: GiteaReadValidationRequestDto,
+  dependencies: CredentialValidationDependencies,
+  options: CredentialValidationServiceOptions,
+): Promise<CredentialValidationResultDto> {
+  const journal = await openValidationJournal(request, options);
+  try {
+    const validation = await evaluateGiteaReadValidation(request, dependencies);
+    return await recordAndSealValidation(journal, {
+      ...validation,
+      operation: options.operation ?? 'validate',
+    });
+  } catch (error: unknown) {
+    if (error instanceof CredentialJournalError) {
+      return journalFailureResult(request, journal, error, options.operation ?? 'validate');
+    }
+    throw error;
+  }
+}
+
+export async function runCredentialValidation(
+  request: GiteaWriteValidationRequestDto,
+  dependencies: CredentialValidationDependencies,
+  options: CredentialValidationServiceOptions,
+): Promise<CredentialValidationResultDto> {
+  const journal = await openValidationJournal(request, options);
+  try {
+    const validation = await evaluateGiteaWriteValidation(request, dependencies);
+    return await recordAndSealValidation(journal, validation);
+  } catch (error: unknown) {
+    if (error instanceof CredentialJournalError) {
+      return journalFailureResult(request, journal, error, 'validate');
+    }
+    throw error;
+  }
+}

packages/mosaic/src/credentials/delegated-credential.spec.ts

@@ -0,0 +1,97 @@
+import { mkdtemp, open, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { readDelegatedCredentialFromFd } from './delegated-credential.js';
+
+let cleanup: string | undefined;
+afterEach(async (): Promise<void> => {
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+describe('protected delegated credential channel', (): void => {
+  it('reads authority from an inherited fd number without putting the secret in argv or env', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-authority-fd-'));
+    const path = join(cleanup, 'authority');
+    await writeFile(
+      path,
+      JSON.stringify({
+        identity: 'provisioner',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        secret: 'seeded-authority-canary',
+      }),
+      { mode: 0o600 },
+    );
+    const handle = await open(path, 'r');
+    try {
+      const resolved = await readDelegatedCredentialFromFd(
+        handle.fd,
+        'provisioner',
+        'homelab',
+        'git.example.invalid',
+      );
+      expect(resolved.identity).toBe('provisioner');
+      expect(Buffer.from(resolved.secret).toString('utf8')).toBe('seeded-authority-canary');
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it('rejects a regular-file authority fd with group or other access', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-authority-fd-'));
+    const path = join(cleanup, 'authority');
+    await writeFile(
+      path,
+      JSON.stringify({
+        identity: 'provisioner',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        secret: 'seeded-authority-canary',
+      }),
+      { mode: 0o644 },
+    );
+    const handle = await open(path, 'r');
+    try {
+      await expect(
+        readDelegatedCredentialFromFd(handle.fd, 'provisioner', 'homelab', 'git.example.invalid'),
+      ).rejects.toMatchObject({ code: 'delegated-authority-unavailable' });
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it('rejects an authority identity or estate mismatch without echoing the secret', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-authority-fd-'));
+    const path = join(cleanup, 'authority');
+    await writeFile(
+      path,
+      JSON.stringify({
+        identity: 'other',
+        estate: 'usc',
+        host: 'git.example.invalid',
+        secret: 'seeded-authority-canary',
+      }),
+      { mode: 0o600 },
+    );
+    const handle = await open(path, 'r');
+    try {
+      let message = '';
+      try {
+        await readDelegatedCredentialFromFd(
+          handle.fd,
+          'provisioner',
+          'homelab',
+          'git.example.invalid',
+        );
+      } catch (error: unknown) {
+        message = error instanceof Error ? error.message : String(error);
+      }
+      expect(message).toContain('delegated-authority-mismatch');
+      expect(message).not.toContain('seeded-authority-canary');
+    } finally {
+      await handle.close();
+    }
+  });
+});

packages/mosaic/src/credentials/delegated-credential.ts

@@ -0,0 +1,122 @@
+import { randomUUID } from 'node:crypto';
+import { createReadStream, fstatSync } from 'node:fs';
+import { z } from 'zod';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+
+const authoritySchema = z
+  .object({
+    identity: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*$/),
+    estate: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    host: z.string().regex(/^[a-z0-9][a-z0-9.-]*$/),
+    secret: z
+      .string()
+      .min(1)
+      .max(16 * 1024)
+      .regex(/^\S+$/),
+  })
+  .strict();
+
+export class DelegatedCredentialError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(`Delegated credential rejected: code=${code} ${message}`);
+    this.name = 'DelegatedCredentialError';
+  }
+}
+
+async function readProtectedFd(fd: number): Promise<Buffer> {
+  const controller = new AbortController();
+  const timeout = setTimeout((): void => controller.abort(), 5_000);
+  const chunks: Buffer[] = [];
+  let total = 0;
+  try {
+    const stream = createReadStream(`/proc/self/fd/${fd}`, {
+      highWaterMark: 4 * 1024,
+      signal: controller.signal,
+    });
+    for await (const chunk of stream) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += bytes.byteLength;
+      if (total > 32 * 1024) {
+        stream.destroy();
+        throw new Error('protected credential payload exceeded the bound');
+      }
+      chunks.push(bytes);
+    }
+    return Buffer.concat(chunks, total);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function readDelegatedCredentialFromFd(
+  fd: number,
+  expectedIdentity: string,
+  expectedEstate: string,
+  expectedHost: string,
+): Promise<ResolvedCredential> {
+  if (!Number.isSafeInteger(fd) || fd < 3 || fd > 1024) {
+    throw new DelegatedCredentialError('delegated-authority-unavailable', 'invalid inherited fd');
+  }
+  let bytes: Buffer;
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() && !stat.isFIFO()) {
+      throw new Error('fd is not a regular file or pipe');
+    }
+    const currentUid = process.getuid?.();
+    if (currentUid === undefined || stat.uid !== currentUid || (stat.mode & 0o077) !== 0) {
+      throw new Error('fd owner or permissions are unsafe');
+    }
+    bytes = await readProtectedFd(fd);
+  } catch {
+    throw new DelegatedCredentialError(
+      'delegated-authority-unavailable',
+      'protected inherited credential fd could not be read',
+    );
+  }
+  if (bytes.byteLength > 32 * 1024) {
+    bytes.fill(0);
+    throw new DelegatedCredentialError(
+      'delegated-authority-unavailable',
+      'protected credential payload exceeded the bound',
+    );
+  }
+  let raw: unknown;
+  try {
+    raw = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  } catch {
+    bytes.fill(0);
+    throw new DelegatedCredentialError(
+      'delegated-authority-unavailable',
+      'protected credential payload was invalid',
+    );
+  }
+  bytes.fill(0);
+  const parsed = authoritySchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new DelegatedCredentialError(
+      'delegated-authority-unavailable',
+      'protected credential payload did not match the schema',
+    );
+  }
+  if (
+    parsed.data.identity !== expectedIdentity ||
+    parsed.data.estate !== expectedEstate ||
+    parsed.data.host !== expectedHost
+  ) {
+    throw new DelegatedCredentialError(
+      'delegated-authority-mismatch',
+      'protected credential does not match the explicit actor, estate, and host',
+    );
+  }
+  return Object.freeze({
+    identity: parsed.data.identity,
+    estate: parsed.data.estate,
+    host: parsed.data.host,
+    resolutionId: randomUUID(),
+    secret: new TextEncoder().encode(parsed.data.secret),
+  });
+}

packages/mosaic/src/credentials/estate-registry.dto.ts

@@ -0,0 +1,15 @@
+export type CredentialProviderKind = 'gitea';
+
+export interface CredentialHostConfigDto {
+  readonly host: string;
+  readonly provider: CredentialProviderKind;
+  readonly apiBaseUrl: string;
+  readonly tokenPrefix: string;
+}
+
+export interface CredentialEstateConfigDto {
+  readonly name: string;
+  readonly readOnlyControlIdentity?: string;
+  readonly inventoryAuthorityIdentity?: string;
+  readonly hosts: readonly CredentialHostConfigDto[];
+}

packages/mosaic/src/credentials/estate-registry.spec.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+import { parseCredentialEstateRegistry } from './estate-registry.js';
+
+const validRegistry = JSON.stringify({
+  version: 1,
+  estates: [
+    {
+      name: 'homelab',
+      readOnlyControlIdentity: 'read-control',
+      hosts: [
+        {
+          host: 'git.example.invalid',
+          provider: 'gitea',
+          apiBaseUrl: 'https://git.example.invalid',
+          tokenPrefix: 'gitea-example',
+        },
+      ],
+    },
+  ],
+});
+
+describe('credential estate registry', (): void => {
+  it('requires an exact declared estate-host pair', (): void => {
+    const registry = parseCredentialEstateRegistry(validRegistry);
+
+    expect(registry.matches('homelab', 'git.example.invalid')).toBe(true);
+    expect(registry.matches('usc', 'git.example.invalid')).toBe(false);
+    expect(registry.matches('homelab', 'other.example.invalid')).toBe(false);
+    expect(registry.resolveByHost('git.example.invalid')).toMatchObject({
+      estate: 'homelab',
+      host: { host: 'git.example.invalid', provider: 'gitea' },
+    });
+    expect(registry.resolveByHost('other.example.invalid')).toBeUndefined();
+  });
+
+  it('rejects a provider URL whose host differs from the declared host', (): void => {
+    const source = validRegistry.replace(
+      'https://git.example.invalid',
+      'https://other.example.invalid',
+    );
+
+    expect(() => parseCredentialEstateRegistry(source)).toThrow(/api-host-mismatch/);
+  });
+
+  it('rejects one host assigned to multiple estates', (): void => {
+    const source = JSON.stringify({
+      version: 1,
+      estates: [
+        {
+          name: 'homelab',
+          hosts: [
+            {
+              host: 'git.example.invalid',
+              provider: 'gitea',
+              apiBaseUrl: 'https://git.example.invalid',
+              tokenPrefix: 'gitea-example',
+            },
+          ],
+        },
+        {
+          name: 'other',
+          hosts: [
+            {
+              host: 'git.example.invalid',
+              provider: 'gitea',
+              apiBaseUrl: 'https://git.example.invalid',
+              tokenPrefix: 'gitea-other',
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(() => parseCredentialEstateRegistry(source)).toThrow(/duplicate-host/);
+  });
+
+  it('rejects URLs with userinfo, path, query, fragment, or non-HTTPS scheme', (): void => {
+    for (const apiBaseUrl of [
+      'http://git.example.invalid',
+      'https://[email protected]',
+      'https://git.example.invalid/api',
+      'https://git.example.invalid?x=1',
+      'https://git.example.invalid#x',
+    ]) {
+      const source = validRegistry.replace('https://git.example.invalid', apiBaseUrl);
+      expect(() => parseCredentialEstateRegistry(source), apiBaseUrl).toThrow(/invalid-api-url/);
+    }
+  });
+
+  it('requires a configured read-only control for write validation', (): void => {
+    const registry = parseCredentialEstateRegistry(validRegistry);
+    const withoutControl = parseCredentialEstateRegistry(
+      validRegistry.replace('"readOnlyControlIdentity":"read-control",', ''),
+    );
+
+    expect(registry.readOnlyControl('homelab')).toBe('read-control');
+    expect(() => withoutControl.readOnlyControl('homelab')).toThrow(/read-only-control-missing/);
+  });
+});

packages/mosaic/src/credentials/estate-registry.ts

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import type { CredentialEstateRegistry } from './credential-provider.dto.js';
+import type { CredentialEstateConfigDto, CredentialHostConfigDto } from './estate-registry.dto.js';
+
+const NAME = /^[a-z0-9][a-z0-9-]*$/;
+const IDENTITY = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+const HOST = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+
+const hostSchema = z
+  .object({
+    host: z.string().regex(HOST),
+    provider: z.literal('gitea'),
+    apiBaseUrl: z.string(),
+    tokenPrefix: z.string().regex(NAME),
+  })
+  .strict();
+
+const estateSchema = z
+  .object({
+    name: z.string().regex(NAME),
+    readOnlyControlIdentity: z.string().regex(IDENTITY).optional(),
+    inventoryAuthorityIdentity: z.string().regex(IDENTITY).optional(),
+    hosts: z.array(hostSchema).min(1),
+  })
+  .strict();
+
+const registrySchema = z
+  .object({
+    version: z.literal(1),
+    estates: z.array(estateSchema).min(1),
+  })
+  .strict();
+
+export class CredentialEstateRegistryError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(`Credential estate registry rejected: code=${code} ${message}`);
+    this.name = 'CredentialEstateRegistryError';
+  }
+}
+
+function validateApiUrl(host: CredentialHostConfigDto): void {
+  let url: URL;
+  try {
+    url = new URL(host.apiBaseUrl);
+  } catch (error: unknown) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CredentialEstateRegistryError('invalid-api-url', detail);
+  }
+  if (
+    url.protocol !== 'https:' ||
+    url.username !== '' ||
+    url.password !== '' ||
+    url.pathname !== '/' ||
+    url.search !== '' ||
+    url.hash !== ''
+  ) {
+    throw new CredentialEstateRegistryError(
+      'invalid-api-url',
+      'provider API URL must be an HTTPS origin without userinfo, path, query, or fragment',
+    );
+  }
+  if (url.hostname !== host.host) {
+    throw new CredentialEstateRegistryError(
+      'api-host-mismatch',
+      'provider API URL hostname does not equal the declared host',
+    );
+  }
+}
+
+export class ParsedCredentialEstateRegistry implements CredentialEstateRegistry {
+  private readonly estates: ReadonlyMap<string, CredentialEstateConfigDto>;
+
+  constructor(estates: readonly CredentialEstateConfigDto[]) {
+    this.estates = new Map(
+      estates.map(
+        (estate: CredentialEstateConfigDto): readonly [string, CredentialEstateConfigDto] => [
+          estate.name,
+          estate,
+        ],
+      ),
+    );
+  }
+
+  matches(estate: string, host: string): boolean {
+    return this.resolve(estate, host) !== undefined;
+  }
+
+  resolve(estate: string, host: string): CredentialHostConfigDto | undefined {
+    return this.estates
+      .get(estate)
+      ?.hosts.find((candidate: CredentialHostConfigDto): boolean => candidate.host === host);
+  }
+
+  resolveByHost(
+    host: string,
+  ): { readonly estate: string; readonly host: CredentialHostConfigDto } | undefined {
+    for (const [estate, config] of this.estates) {
+      const match = config.hosts.find(
+        (candidate: CredentialHostConfigDto): boolean => candidate.host === host,
+      );
+      if (match !== undefined) return { estate, host: match };
+    }
+    return undefined;
+  }
+
+  inventoryAuthority(estate: string): string {
+    const identity = this.estates.get(estate)?.inventoryAuthorityIdentity;
+    if (identity === undefined) {
+      throw new CredentialEstateRegistryError(
+        'inventory-authority-missing',
+        `estate ${estate} has no delegated inventory authority identity`,
+      );
+    }
+    return identity;
+  }
+
+  readOnlyControl(estate: string): string {
+    const identity = this.estates.get(estate)?.readOnlyControlIdentity;
+    if (identity === undefined) {
+      throw new CredentialEstateRegistryError(
+        'read-only-control-missing',
+        `estate ${estate} has no provider-confirmed read-only control identity`,
+      );
+    }
+    return identity;
+  }
+}
+
+export function parseCredentialEstateRegistry(source: string): ParsedCredentialEstateRegistry {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(source);
+  } catch (error: unknown) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CredentialEstateRegistryError('invalid-json', detail);
+  }
+
+  const parsed = registrySchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CredentialEstateRegistryError(
+      'invalid-schema',
+      parsed.error.issues[0]?.message ?? 'invalid',
+    );
+  }
+
+  const estateNames = new Set<string>();
+  const hostNames = new Set<string>();
+  for (const estate of parsed.data.estates) {
+    if (estateNames.has(estate.name)) {
+      throw new CredentialEstateRegistryError('duplicate-estate', estate.name);
+    }
+    estateNames.add(estate.name);
+    for (const host of estate.hosts) {
+      validateApiUrl(host);
+      if (hostNames.has(host.host)) {
+        throw new CredentialEstateRegistryError('duplicate-host', host.host);
+      }
+      hostNames.add(host.host);
+    }
+  }
+
+  return new ParsedCredentialEstateRegistry(parsed.data.estates);
+}

packages/mosaic/src/credentials/file-credential-store.spec.ts

@@ -0,0 +1,160 @@
+import { chmod, copyFile, mkdir, symlink, unlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdtemp } from 'node:fs/promises';
+import { afterEach, describe, expect, it } from 'vitest';
+import { rm } from 'node:fs/promises';
+import { parseCredentialEstateRegistry } from './estate-registry.js';
+import { FileCredentialResolver, FileCredentialStore } from './file-credential-store.js';
+
+let cleanup: string | undefined;
+
+async function fixtureRoot(): Promise<string> {
+  cleanup = await mkdtemp(join(tmpdir(), 'mosaic-cred-store-'));
+  const root = join(cleanup, 'tokens');
+  await mkdir(root, { mode: 0o700 });
+  return root;
+}
+
+function registry(): ReturnType<typeof parseCredentialEstateRegistry> {
+  return parseCredentialEstateRegistry(
+    JSON.stringify({
+      version: 1,
+      estates: [
+        {
+          name: 'homelab',
+          hosts: [
+            {
+              host: 'git.example.invalid',
+              provider: 'gitea',
+              apiBaseUrl: 'https://git.example.invalid',
+              tokenPrefix: 'gitea-example',
+            },
+          ],
+        },
+      ],
+    }),
+  );
+}
+
+afterEach(async (): Promise<void> => {
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+describe('phase-1 governed file credential resolver', (): void => {
+  it('resolves only the exact estate/host/identity token at a test-overridable root', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    await writeFile(join(root, 'gitea-example-seat.token'), 'canary-token', { mode: 0o600 });
+    const resolver = new FileCredentialResolver(root, registry());
+
+    const resolved = await resolver.resolve('seat', 'homelab', 'git.example.invalid');
+    const wrongEstate = await resolver.resolve('seat', 'usc', 'git.example.invalid');
+
+    expect(resolved?.identity).toBe('seat');
+    expect(Buffer.from(resolved?.secret ?? []).toString('utf8')).toBe('canary-token');
+    expect(wrongEstate).toBeUndefined();
+  });
+
+  it('rejects a group-writable token directory even when the token file is private', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    await writeFile(join(root, 'gitea-example-seat-name.token'), 'private-token', {
+      mode: 0o600,
+    });
+    await chmod(root, 0o770);
+    const resolver = new FileCredentialResolver(root, registry());
+
+    await expect(resolver.resolve('seat-name', 'homelab', 'git.example.invalid')).rejects.toThrow(
+      /insecure-token-owner/,
+    );
+  });
+
+  it('rejects a token file with group or other permissions', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    const path = join(root, 'gitea-example-seat.token');
+    await writeFile(path, 'canary-token', { mode: 0o600 });
+    await chmod(path, 0o640);
+    const resolver = new FileCredentialResolver(root, registry());
+
+    await expect(resolver.resolve('seat', 'homelab', 'git.example.invalid')).rejects.toThrow(
+      /insecure-token-mode/,
+    );
+  });
+
+  it('rejects a symlinked token instead of following it', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    const target = join(cleanup ?? root, 'outside-token');
+    await writeFile(target, 'canary-token', { mode: 0o600 });
+    await symlink(target, join(root, 'gitea-example-seat.token'));
+    const resolver = new FileCredentialResolver(root, registry());
+
+    await expect(resolver.resolve('seat', 'homelab', 'git.example.invalid')).rejects.toThrow(
+      /symbolic link|unavailable/,
+    );
+  });
+
+  it('rejects traversal-shaped identities before touching storage', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    const resolver = new FileCredentialResolver(root, registry());
+
+    await expect(resolver.resolve('../other', 'homelab', 'git.example.invalid')).rejects.toThrow(
+      /invalid-identity/,
+    );
+  });
+
+  it('atomically stores, lists, reads binding metadata, and removes a governed credential', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    const store = new FileCredentialStore(root, registry());
+    await store.put(
+      {
+        identity: 'seat',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        providerLogin: 'seat',
+        tokenName: 'mosaic-seat-1',
+        scopes: ['write:repository'],
+        createdAt: '2026-08-05T00:00:00.000Z',
+      },
+      new TextEncoder().encode('new-private-token'),
+    );
+
+    await expect(store.list('homelab', 'git.example.invalid')).resolves.toEqual(['seat']);
+    await expect(
+      store.readBinding('seat', 'homelab', 'git.example.invalid'),
+    ).resolves.toMatchObject({
+      providerLogin: 'seat',
+      tokenName: 'mosaic-seat-1',
+    });
+    await expect(
+      new FileCredentialResolver(root, registry()).resolve(
+        'seat',
+        'homelab',
+        'git.example.invalid',
+      ),
+    ).resolves.toMatchObject({ identity: 'seat' });
+    await copyFile(
+      join(root, 'gitea-example-seat.credential.json'),
+      join(root, 'gitea-example-other.credential.json'),
+    );
+    await expect(
+      new FileCredentialResolver(root, registry()).resolve(
+        'other',
+        'homelab',
+        'git.example.invalid',
+      ),
+    ).rejects.toThrow(/credential-binding-mismatch/);
+    await unlink(join(root, 'gitea-example-other.credential.json'));
+    await store.remove('seat', 'homelab', 'git.example.invalid');
+    await expect(store.list('homelab', 'git.example.invalid')).resolves.toEqual([]);
+  });
+
+  it('returns undefined for an absent token without borrowing another identity', async (): Promise<void> => {
+    const root = await fixtureRoot();
+    await writeFile(join(root, 'gitea-example-shared.token'), 'shared-canary', { mode: 0o600 });
+    const resolver = new FileCredentialResolver(root, registry());
+
+    const resolved = await resolver.resolve('missing-seat', 'homelab', 'git.example.invalid');
+
+    expect(resolved).toBeUndefined();
+  });
+});

packages/mosaic/src/credentials/file-credential-store.ts

@@ -0,0 +1,504 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstatSync } from 'node:fs';
+import { open, readdir, rename, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import {
+  ensureManagedDirectory,
+  readRegularFileSecure,
+  type SecureFileSnapshot,
+} from '../fleet/secure-file.js';
+import type { CredentialBindingMetadataDto } from './credential-binding.dto.js';
+import type { CredentialResolver, ResolvedCredential } from './credential-provider.dto.js';
+import type { ParsedCredentialEstateRegistry } from './estate-registry.js';
+
+const IDENTITY = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+const MAX_TOKEN_BYTES = 16 * 1024;
+const bindingSchema = z
+  .object({
+    schemaVersion: z.literal(1),
+    identity: z.string().regex(IDENTITY),
+    estate: z.string().min(1),
+    host: z.string().min(1),
+    providerLogin: z.string().regex(IDENTITY),
+    tokenName: z.string().regex(IDENTITY),
+    scopes: z.array(z.string().regex(/^[a-z]+(?::[a-z]+)?$/)).max(32),
+    createdAt: z.string().datetime(),
+    tokenDigest: z
+      .string()
+      .regex(/^[a-f0-9]{64}$/)
+      .optional(),
+  })
+  .strict();
+const credentialEnvelopeSchema = bindingSchema.extend({
+  token: z.string().min(1).max(MAX_TOKEN_BYTES).regex(/^\S+$/),
+});
+
+export class CredentialStoreError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(`Credential store rejected: code=${code} ${message}`);
+    this.name = 'CredentialStoreError';
+  }
+}
+
+function isMissingFile(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    typeof error.code === 'string' &&
+    error.code === 'ENOENT'
+  );
+}
+
+function validateSecret(content: Buffer): Uint8Array {
+  if (content.byteLength === 0 || content.byteLength > MAX_TOKEN_BYTES) {
+    throw new CredentialStoreError('invalid-token-size', 'token file size is outside bounds');
+  }
+  for (const byte of content) {
+    if (byte <= 0x20 || byte === 0x7f) {
+      throw new CredentialStoreError(
+        'invalid-token-bytes',
+        'token file contains whitespace or control bytes',
+      );
+    }
+  }
+  return new Uint8Array(content);
+}
+
+export class FileCredentialResolver implements CredentialResolver {
+  constructor(
+    private readonly tokenDirectory: string,
+    private readonly estateRegistry: ParsedCredentialEstateRegistry,
+  ) {}
+
+  async resolve(
+    identity: string,
+    estate: string,
+    host: string,
+  ): Promise<ResolvedCredential | undefined> {
+    if (!IDENTITY.test(identity)) {
+      throw new CredentialStoreError(
+        'invalid-identity',
+        'identity is outside the allowlist grammar',
+      );
+    }
+    const hostConfig = this.estateRegistry.resolve(estate, host);
+    if (hostConfig === undefined) return undefined;
+
+    const currentUid = process.getuid?.();
+    if (currentUid === undefined) {
+      throw new CredentialStoreError('insecure-token-owner', 'runtime uid is unavailable');
+    }
+    const directory = lstatSync(this.tokenDirectory);
+    if (
+      !directory.isDirectory() ||
+      directory.isSymbolicLink() ||
+      directory.uid !== currentUid ||
+      (directory.mode & 0o022) !== 0
+    ) {
+      throw new CredentialStoreError(
+        'insecure-token-owner',
+        'token directory ownership or write permissions are unsafe',
+      );
+    }
+
+    const envelopePath = join(
+      this.tokenDirectory,
+      `${hostConfig.tokenPrefix}-${identity}.credential.json`,
+    );
+    try {
+      const envelopeSnapshot = readRegularFileSecure(envelopePath, {
+        root: this.tokenDirectory,
+        maxBytes: 64 * 1024,
+      });
+      const envelope = credentialEnvelopeSchema.safeParse(
+        JSON.parse(envelopeSnapshot.content.toString('utf8')),
+      );
+      if (
+        !envelope.success ||
+        envelopeSnapshot.uid !== process.getuid?.() ||
+        (envelopeSnapshot.mode & 0o077) !== 0
+      ) {
+        throw new CredentialStoreError(
+          'invalid-binding',
+          'credential envelope failed schema, owner, or mode validation',
+        );
+      }
+      if (
+        envelope.data.identity !== identity ||
+        envelope.data.estate !== estate ||
+        envelope.data.host !== host ||
+        envelope.data.providerLogin !== identity
+      ) {
+        throw new CredentialStoreError(
+          'credential-binding-mismatch',
+          'credential envelope does not match the requested identity, estate, host, and principal',
+        );
+      }
+      const secret = validateSecret(Buffer.from(envelope.data.token, 'utf8'));
+      const digest = createHash('sha256').update(secret).digest('hex');
+      if (envelope.data.tokenDigest !== digest) {
+        throw new CredentialStoreError(
+          'credential-generation-mismatch',
+          'credential envelope digest does not match its token',
+        );
+      }
+      return Object.freeze({
+        identity,
+        estate,
+        host,
+        resolutionId: randomUUID(),
+        secret,
+      });
+    } catch (error: unknown) {
+      if (!isMissingFile(error)) throw error;
+    }
+
+    const path = join(this.tokenDirectory, `${hostConfig.tokenPrefix}-${identity}.token`);
+    let snapshot: SecureFileSnapshot;
+    try {
+      snapshot = readRegularFileSecure(path, {
+        root: this.tokenDirectory,
+        maxBytes: MAX_TOKEN_BYTES,
+      });
+    } catch (error: unknown) {
+      if (isMissingFile(error)) return undefined;
+      throw error;
+    }
+
+    const bindingPath = join(
+      this.tokenDirectory,
+      `${hostConfig.tokenPrefix}-${identity}.binding.json`,
+    );
+    try {
+      const bindingSnapshot = readRegularFileSecure(bindingPath, {
+        root: this.tokenDirectory,
+        maxBytes: 64 * 1024,
+      });
+      const binding = bindingSchema.safeParse(JSON.parse(bindingSnapshot.content.toString('utf8')));
+      const digest = createHash('sha256').update(snapshot.content).digest('hex');
+      if (
+        !binding.success ||
+        binding.data.tokenDigest !== digest ||
+        binding.data.identity !== identity ||
+        binding.data.estate !== estate ||
+        binding.data.host !== host ||
+        binding.data.providerLogin !== identity
+      ) {
+        throw new CredentialStoreError(
+          'credential-generation-mismatch',
+          'token and binding metadata are not one committed identity-bound generation',
+        );
+      }
+    } catch (error: unknown) {
+      if (!isMissingFile(error)) throw error;
+      // Legacy token files predate binding metadata and remain readable until rotated.
+    }
+
+    const permissions = snapshot.mode & 0o777;
+    if (snapshot.uid !== currentUid) {
+      throw new CredentialStoreError(
+        'insecure-token-owner',
+        'token file is not owned by the runtime uid',
+      );
+    }
+    if ((permissions & 0o077) !== 0) {
+      throw new CredentialStoreError(
+        'insecure-token-mode',
+        'token file grants group or other access',
+      );
+    }
+
+    return Object.freeze({
+      identity,
+      estate,
+      host,
+      resolutionId: randomUUID(),
+      secret: validateSecret(snapshot.content),
+    });
+  }
+}
+
+function assertPrivateTokenDirectory(path: string): {
+  readonly dev: number | bigint;
+  readonly ino: number | bigint;
+} {
+  const stat = lstatSync(path);
+  if (
+    !stat.isDirectory() ||
+    stat.isSymbolicLink() ||
+    stat.uid !== process.getuid?.() ||
+    (stat.mode & 0o022) !== 0
+  ) {
+    throw new CredentialStoreError(
+      'insecure-token-owner',
+      'token directory ownership or write permissions are unsafe',
+    );
+  }
+  return { dev: stat.dev, ino: stat.ino };
+}
+
+async function syncDirectory(path: string): Promise<void> {
+  const handle = await open(path, 'r');
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+
+export class FileCredentialStore {
+  constructor(
+    private readonly tokenDirectory: string,
+    private readonly estateRegistry: ParsedCredentialEstateRegistry,
+  ) {}
+
+  private paths(
+    identity: string,
+    estate: string,
+    host: string,
+  ): {
+    readonly token: string;
+    readonly binding: string;
+    readonly envelope: string;
+    readonly prefix: string;
+  } {
+    if (!IDENTITY.test(identity)) {
+      throw new CredentialStoreError(
+        'invalid-identity',
+        'identity is outside the allowlist grammar',
+      );
+    }
+    const config = this.estateRegistry.resolve(estate, host);
+    if (config === undefined) {
+      throw new CredentialStoreError('estate-host-mismatch', 'estate and host do not match');
+    }
+    const prefix = `${config.tokenPrefix}-${identity}`;
+    return {
+      token: join(this.tokenDirectory, `${prefix}.token`),
+      binding: join(this.tokenDirectory, `${prefix}.binding.json`),
+      envelope: join(this.tokenDirectory, `${prefix}.credential.json`),
+      prefix,
+    };
+  }
+
+  async put(metadata: CredentialBindingMetadataDto, secret: Uint8Array): Promise<void> {
+    const paths = this.paths(metadata.identity, metadata.estate, metadata.host);
+    ensureManagedDirectory(this.tokenDirectory, this.tokenDirectory);
+    const directoryIdentity = assertPrivateTokenDirectory(this.tokenDirectory);
+    const token = validateSecret(Buffer.from(secret));
+    const envelope = credentialEnvelopeSchema.parse({
+      ...metadata,
+      schemaVersion: 1,
+      tokenDigest: createHash('sha256').update(token).digest('hex'),
+      token: Buffer.from(token).toString('utf8'),
+    });
+    const suffix = randomUUID();
+    const envelopeTemp = `${paths.envelope}.${suffix}.tmp`;
+    const lockPath = join(this.tokenDirectory, `${paths.prefix}.lock`);
+    let lock;
+    try {
+      lock = await open(lockPath, 'wx', 0o600);
+    } catch {
+      throw new CredentialStoreError(
+        'conflicting-credential-mutation',
+        'another mutation owns the identity lock',
+      );
+    }
+    try {
+      const handle = await open(envelopeTemp, 'wx', 0o600);
+      try {
+        await handle.writeFile(`${JSON.stringify(envelope)}\n`, 'utf8');
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      const beforeCommit = assertPrivateTokenDirectory(this.tokenDirectory);
+      if (
+        beforeCommit.dev !== directoryIdentity.dev ||
+        beforeCommit.ino !== directoryIdentity.ino
+      ) {
+        throw new CredentialStoreError(
+          'insecure-token-owner',
+          'token directory changed during credential commit',
+        );
+      }
+      await rename(envelopeTemp, paths.envelope);
+      await syncDirectory(this.tokenDirectory);
+    } finally {
+      await lock.close();
+      await unlink(envelopeTemp).catch((): void => undefined);
+      await unlink(lockPath).catch((): void => undefined);
+      await syncDirectory(this.tokenDirectory);
+    }
+  }
+
+  async snapshot(
+    identity: string,
+    estate: string,
+    host: string,
+  ): Promise<
+    | {
+        readonly binding: CredentialBindingMetadataDto;
+        readonly secret: Uint8Array;
+      }
+    | undefined
+  > {
+    const binding = await this.readBinding(identity, estate, host);
+    if (binding === undefined) return undefined;
+    const resolved = await new FileCredentialResolver(
+      this.tokenDirectory,
+      this.estateRegistry,
+    ).resolve(identity, estate, host);
+    if (resolved === undefined) {
+      throw new CredentialStoreError(
+        'invalid-binding',
+        'binding metadata exists without its token generation',
+      );
+    }
+    return { binding, secret: new Uint8Array(resolved.secret) };
+  }
+
+  async readBinding(
+    identity: string,
+    estate: string,
+    host: string,
+  ): Promise<CredentialBindingMetadataDto | undefined> {
+    const paths = this.paths(identity, estate, host);
+    let snapshot: SecureFileSnapshot;
+    try {
+      const envelope = readRegularFileSecure(paths.envelope, {
+        root: this.tokenDirectory,
+        maxBytes: 64 * 1024,
+      });
+      const parsed = credentialEnvelopeSchema.safeParse(
+        JSON.parse(envelope.content.toString('utf8')),
+      );
+      if (!parsed.success) {
+        throw new CredentialStoreError('invalid-binding', 'credential envelope is malformed');
+      }
+      const verified = await new FileCredentialResolver(
+        this.tokenDirectory,
+        this.estateRegistry,
+      ).resolve(identity, estate, host);
+      if (verified === undefined) {
+        throw new CredentialStoreError('invalid-binding', 'credential envelope was not resolvable');
+      }
+      verified.secret.fill(0);
+      return {
+        schemaVersion: 1,
+        identity: parsed.data.identity,
+        estate: parsed.data.estate,
+        host: parsed.data.host,
+        providerLogin: parsed.data.providerLogin,
+        tokenName: parsed.data.tokenName,
+        scopes: parsed.data.scopes,
+        createdAt: parsed.data.createdAt,
+        tokenDigest: parsed.data.tokenDigest,
+      };
+    } catch (error: unknown) {
+      if (!isMissingFile(error)) throw error;
+    }
+    try {
+      snapshot = readRegularFileSecure(paths.binding, {
+        root: this.tokenDirectory,
+        maxBytes: 64 * 1024,
+      });
+    } catch (error: unknown) {
+      if (isMissingFile(error)) return undefined;
+      throw error;
+    }
+    if ((snapshot.mode & 0o077) !== 0 || snapshot.uid !== process.getuid?.()) {
+      throw new CredentialStoreError('insecure-token-owner', 'binding metadata is not private');
+    }
+    const parsed = bindingSchema.safeParse(JSON.parse(snapshot.content.toString('utf8')));
+    if (!parsed.success) {
+      throw new CredentialStoreError(
+        'invalid-binding',
+        'binding metadata failed schema validation',
+      );
+    }
+    return parsed.data;
+  }
+
+  async list(estate: string, host: string): Promise<readonly string[]> {
+    const config = this.estateRegistry.resolve(estate, host);
+    if (config === undefined) return [];
+    const names = await readdir(this.tokenDirectory);
+    const prefix = `${config.tokenPrefix}-`;
+    return [
+      ...new Set(
+        names.flatMap((name): string[] => {
+          if (!name.startsWith(prefix)) return [];
+          if (name.endsWith('.token')) {
+            return [name.slice(prefix.length, -'.token'.length)];
+          }
+          if (name.endsWith('.credential.json')) {
+            return [name.slice(prefix.length, -'.credential.json'.length)];
+          }
+          return [];
+        }),
+      ),
+    ]
+      .filter((identity): boolean => IDENTITY.test(identity))
+      .sort();
+  }
+
+  async remove(
+    identity: string,
+    estate: string,
+    host: string,
+    expectedTokenDigest?: string,
+  ): Promise<void> {
+    const paths = this.paths(identity, estate, host);
+    const directoryIdentity = assertPrivateTokenDirectory(this.tokenDirectory);
+    const lockPath = join(this.tokenDirectory, `${paths.prefix}.lock`);
+    let lock;
+    try {
+      lock = await open(lockPath, 'wx', 0o600);
+    } catch {
+      throw new CredentialStoreError(
+        'conflicting-credential-mutation',
+        'another mutation owns the identity lock',
+      );
+    }
+    try {
+      if (expectedTokenDigest !== undefined) {
+        const current = await this.readBinding(identity, estate, host);
+        if (current === undefined || current.tokenDigest !== expectedTokenDigest) {
+          throw new CredentialStoreError(
+            'credential-generation-mismatch',
+            'credential generation changed before removal',
+          );
+        }
+      }
+      const beforeRemoval = assertPrivateTokenDirectory(this.tokenDirectory);
+      if (
+        beforeRemoval.dev !== directoryIdentity.dev ||
+        beforeRemoval.ino !== directoryIdentity.ino
+      ) {
+        throw new CredentialStoreError(
+          'insecure-token-owner',
+          'token directory changed during credential removal',
+        );
+      }
+      await unlink(paths.token).catch((error: unknown): void => {
+        if (!isMissingFile(error)) throw error;
+      });
+      await unlink(paths.binding).catch((error: unknown): void => {
+        if (!isMissingFile(error)) throw error;
+      });
+      await unlink(paths.envelope).catch((error: unknown): void => {
+        if (!isMissingFile(error)) throw error;
+      });
+      await syncDirectory(this.tokenDirectory);
+    } finally {
+      await lock.close();
+      await unlink(lockPath).catch((): void => undefined);
+      await syncDirectory(this.tokenDirectory);
+    }
+  }
+}

packages/mosaic/src/credentials/gitea-provider.spec.ts

@@ -0,0 +1,276 @@
+import { describe, expect, it } from 'vitest';
+import { GiteaCredentialProviderAdapter, GiteaTeamGrantProviderAdapter } from './gitea-provider.js';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+
+const credential: ResolvedCredential = Object.freeze({
+  identity: 'seat-name',
+  estate: 'homelab',
+  host: 'git.example.invalid',
+  resolutionId: 'resolution-1',
+  secret: new TextEncoder().encode('seeded-secret-canary'),
+});
+
+function jsonResponse(body: object, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json;charset=utf-8' },
+  });
+}
+
+describe('Gitea credential provider transport', (): void => {
+  it('reads the provider identity with the fixed transport and no secret in the URL', async (): Promise<void> => {
+    const calls: Array<{ readonly input: string; readonly init?: RequestInit }> = [];
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+        calls.push({ input: String(input), ...(init === undefined ? {} : { init }) });
+        return jsonResponse({ id: 21, login: 'seat-name' });
+      },
+    );
+
+    const evidence = await adapter.readIdentity(credential);
+
+    expect(evidence).toEqual({
+      login: 'seat-name',
+      endpoint: 'GET /api/v1/user',
+      contentType: 'application/json;charset=utf-8',
+    });
+    expect(calls[0]?.input).toBe('https://git.example.invalid/api/v1/user');
+    expect(calls[0]?.input).not.toContain('seeded-secret-canary');
+    expect(new Headers(calls[0]?.init?.headers).get('user-agent')).toBe('mosaic-cred/1');
+  });
+
+  it('maps the authenticated provider repository object to effective permission', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> =>
+        jsonResponse({
+          id: 99,
+          full_name: 'owner/repo',
+          permissions: { admin: false, push: true, pull: true },
+        }),
+    );
+
+    const evidence = await adapter.readRepositoryPermission(credential, 'owner/repo');
+
+    expect(evidence.effective).toBe('write');
+    expect(evidence.endpoint).toBe('GET /api/v1/repos/owner/repo');
+  });
+
+  it('binds an authenticated receive-pack advertisement to the supplied credential handle', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> =>
+        new Response('001f# service=git-receive-pack\n0000', {
+          status: 200,
+          headers: {
+            'content-type': 'application/x-git-receive-pack-advertisement',
+          },
+        }),
+    );
+
+    const evidence = await adapter.probeReceivePack(credential, 'owner/repo');
+
+    expect(evidence).toEqual({
+      state: 'advertised',
+      principal: 'seat-name',
+      resolutionId: 'resolution-1',
+      contentType: 'application/x-git-receive-pack-advertisement',
+    });
+  });
+
+  it('reports authenticated and unauthenticated receive-pack refusals without inventing success', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> =>
+        new Response('denied', { status: 403, headers: { 'content-type': 'text/plain' } }),
+    );
+
+    await expect(adapter.probeReceivePack(credential, 'owner/repo')).resolves.toMatchObject({
+      state: 'refused',
+      principal: 'seat-name',
+      resolutionId: 'resolution-1',
+    });
+    await expect(adapter.probeReceivePack(undefined, 'owner/repo')).resolves.toMatchObject({
+      state: 'refused',
+      principal: null,
+      resolutionId: null,
+    });
+  });
+
+  it('does not call a scope-forbidden identity read a dead credential', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> => jsonResponse({ message: 'forbidden' }, 403),
+    );
+
+    await expect(adapter.readIdentity(credential)).rejects.toMatchObject({
+      code: 'identity-read-forbidden',
+    });
+  });
+
+  it('classifies only the supplied credential as rejected without inferring identity absence', async (): Promise<void> => {
+    let calls = 0;
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> => {
+        calls += 1;
+        return jsonResponse({ message: 'unauthorized' }, 401);
+      },
+    );
+
+    await expect(adapter.readIdentity(credential)).rejects.toMatchObject({
+      code: 'credential-rejected',
+    });
+    expect(calls).toBe(1);
+  });
+
+  it('classifies a rejected credential separately when the declared identity exists', async (): Promise<void> => {
+    let call = 0;
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> => {
+        call += 1;
+        if (call === 1) return jsonResponse({ message: 'unauthorized' }, 401);
+        return jsonResponse({ id: 21, login: 'seat-name' });
+      },
+    );
+
+    await expect(adapter.readIdentity(credential)).rejects.toMatchObject({
+      code: 'credential-rejected',
+    });
+  });
+
+  it('cancels an undeclared oversized streaming provider response before buffering it all', async (): Promise<void> => {
+    let pulls = 0;
+    let cancelled = false;
+    const stream = new ReadableStream<Uint8Array>({
+      pull(controller): void {
+        pulls += 1;
+        controller.enqueue(new Uint8Array(64 * 1024));
+        if (pulls === 100) controller.close();
+      },
+      cancel(): void {
+        cancelled = true;
+      },
+    });
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> =>
+        new Response(stream, { status: 200, headers: { 'content-type': 'application/json' } }),
+    );
+
+    await expect(adapter.readIdentity(credential)).rejects.toMatchObject({
+      code: 'unexpected-provider-shape',
+    });
+    expect(pulls).toBeLessThan(100);
+    expect(cancelled).toBe(true);
+  });
+
+  it('rejects a 200 HTML identity response as unexpected content type', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> =>
+        new Response('<html>not an API object</html>', {
+          status: 200,
+          headers: { 'content-type': 'text/html' },
+        }),
+    );
+
+    await expect(adapter.readIdentity(credential)).rejects.toMatchObject({
+      code: 'unexpected-content-type',
+    });
+  });
+
+  it('reads team permission, member attachment, and repository attachment separately', async (): Promise<void> => {
+    let memberRemoved = false;
+    let repositoryDetached = false;
+    const adapter = new GiteaTeamGrantProviderAdapter(
+      'https://git.example.invalid',
+      async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+        const url = String(input);
+        if (url.endsWith('/api/v1/orgs/owner/teams')) {
+          return jsonResponse([{ id: 7, name: 'writers', permission: 'write' }]);
+        }
+        if (init?.method === 'PUT') return new Response(null, { status: 204 });
+        if (init?.method === 'DELETE') {
+          if (url.includes('/members/')) memberRemoved = true;
+          if (url.includes('/repos/')) repositoryDetached = true;
+          return new Response(null, { status: 204 });
+        }
+        if (url.includes('/members/seat-name')) {
+          return jsonResponse({ id: 21, login: 'seat-name' });
+        }
+        if (url.includes('/repos/owner/repo')) {
+          return jsonResponse({
+            id: 4,
+            full_name: 'owner/repo',
+            permissions: { admin: false, push: true, pull: true },
+          });
+        }
+        return jsonResponse({ message: 'unexpected' }, 500);
+      },
+    );
+
+    const team = await adapter.resolveTeam(credential, 'owner', 'writers');
+    await adapter.addTeamMember(credential, team.id, 'seat-name');
+    await adapter.attachTeamRepository(credential, team.id, 'owner/repo');
+    await expect(adapter.readTeamMember(credential, team.id, 'seat-name')).resolves.toMatchObject({
+      state: 'present',
+    });
+    await expect(
+      adapter.readTeamRepository(credential, team.id, 'owner/repo'),
+    ).resolves.toMatchObject({ state: 'present' });
+    await adapter.removeTeamMember(credential, team.id, 'seat-name');
+    await adapter.detachTeamRepository(credential, team.id, 'owner/repo');
+    expect(memberRemoved).toBe(true);
+    expect(repositoryDetached).toBe(true);
+    expect(team).toMatchObject({ id: 7, name: 'writers', permission: 'write' });
+  });
+
+  it('rejects a successful team read-back that names the wrong object', async (): Promise<void> => {
+    const adapter = new GiteaTeamGrantProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> => jsonResponse({ id: 99, login: 'other-seat' }),
+    );
+
+    await expect(adapter.readTeamMember(credential, 7, 'seat-name')).rejects.toMatchObject({
+      code: 'unexpected-provider-shape',
+    });
+  });
+
+  it('bounds a provider that never returns response headers', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (_input: string | URL | Request, init?: RequestInit): Promise<Response> =>
+        new Promise<Response>((_resolve, reject): void => {
+          init?.signal?.addEventListener('abort', (): void => {
+            reject(new Error('aborted'));
+          });
+        }),
+      10,
+    );
+
+    await expect(adapter.readIdentity(credential)).rejects.toMatchObject({
+      code: 'provider-unavailable',
+    });
+  });
+
+  it('never includes seeded secret material in provider error messages', async (): Promise<void> => {
+    const adapter = new GiteaCredentialProviderAdapter(
+      'https://git.example.invalid',
+      async (): Promise<Response> => {
+        throw new Error('connection reset');
+      },
+    );
+
+    let message = '';
+    try {
+      await adapter.readIdentity(credential);
+    } catch (error: unknown) {
+      message = error instanceof Error ? error.message : String(error);
+    }
+    expect(message).not.toContain('seeded-secret-canary');
+    expect(message).toContain('provider-unavailable');
+  });
+});

packages/mosaic/src/credentials/gitea-provider.ts

@@ -0,0 +1,943 @@
+import { z } from 'zod';
+import type { GiteaCredentialProvider, ResolvedCredential } from './credential-provider.dto.js';
+import type { GiteaGrantProvider } from './grant.js';
+import type { GiteaLifecycleProvider, MintedToken } from './lifecycle.js';
+import type { TokenObjectEvidenceDto } from './lifecycle.dto.js';
+import type {
+  GiteaTeamGrantProvider,
+  PresenceEvidence,
+  TeamRepositorySetEvidence,
+  TeamResolutionEvidence,
+} from './team-grant.js';
+import type {
+  CollaboratorPermissionEvidenceDto,
+  OrganizationMembershipEvidenceDto,
+} from './grant.dto.js';
+import type {
+  ProviderIdentityEvidenceDto,
+  ReceivePackEvidenceDto,
+  RepositoryPermission,
+  RepositoryPermissionEvidenceDto,
+} from './credential-result.dto.js';
+
+const MAX_PROVIDER_BYTES = 1024 * 1024;
+const USER_AGENT = 'mosaic-cred/1';
+const JSON_CONTENT_TYPE = 'application/json';
+const RECEIVE_PACK_CONTENT_TYPE = 'application/x-git-receive-pack-advertisement';
+const REPO_COMPONENT = /^[A-Za-z0-9_.-]+$/;
+
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+const userSchema = z
+  .object({
+    id: z.number().int(),
+    login: z.string().min(1),
+    is_admin: z.boolean().optional(),
+    visibility: z.enum(['public', 'limited', 'private']).optional(),
+  })
+  .passthrough();
+
+const collaboratorPermissionSchema = z
+  .object({
+    permission: z.enum(['read', 'write', 'admin']),
+    user: z.object({ login: z.string().min(1) }).passthrough(),
+  })
+  .passthrough();
+
+const organizationSchema = z.object({ username: z.string().min(1) }).passthrough();
+const tokenObjectSchema = z
+  .object({
+    name: z.string().min(1),
+    sha1: z.string().min(1).optional(),
+    token: z.string().min(1).optional(),
+    scopes: z.array(z.string()).default([]),
+  })
+  .passthrough();
+const teamSchema = z
+  .object({
+    id: z.number().int().positive(),
+    name: z.string().min(1),
+    permission: z.enum(['read', 'write', 'admin']),
+  })
+  .passthrough();
+
+const repoSchema = z
+  .object({
+    id: z.number().int(),
+    full_name: z.string().min(3),
+    permissions: z
+      .object({
+        admin: z.boolean(),
+        push: z.boolean(),
+        pull: z.boolean(),
+      })
+      .strict(),
+  })
+  .passthrough();
+
+export class CredentialProviderEvidenceError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(`Gitea credential evidence unavailable: code=${code} ${message}`);
+    this.name = 'CredentialProviderEvidenceError';
+  }
+}
+
+function contentType(response: Response): string {
+  return response.headers.get('content-type') ?? '';
+}
+
+function isJson(response: Response): boolean {
+  return contentType(response).toLowerCase().startsWith(JSON_CONTENT_TYPE);
+}
+
+async function boundedBody(response: Response): Promise<Uint8Array> {
+  const declared = response.headers.get('content-length');
+  if (declared !== null) {
+    if (!/^\d+$/.test(declared)) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'provider response declared an invalid content length',
+      );
+    }
+    const bytes = Number(declared);
+    if (!Number.isSafeInteger(bytes) || bytes > MAX_PROVIDER_BYTES) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'provider response exceeded the bounded size',
+      );
+    }
+  }
+  if (response.body === null) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    for (;;) {
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > MAX_PROVIDER_BYTES) {
+        await reader.cancel();
+        throw new CredentialProviderEvidenceError(
+          'unexpected-provider-shape',
+          'provider response exceeded the bounded size',
+        );
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (declared !== null && total !== Number(declared)) {
+    throw new CredentialProviderEvidenceError(
+      'unexpected-provider-shape',
+      'provider response length contradicted its declaration',
+    );
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+
+async function jsonObject(response: Response): Promise<unknown> {
+  if (!isJson(response)) {
+    throw new CredentialProviderEvidenceError(
+      'unexpected-content-type',
+      'provider response was not JSON',
+    );
+  }
+  const bytes = await boundedBody(response);
+  try {
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  } catch {
+    throw new CredentialProviderEvidenceError(
+      'unexpected-provider-shape',
+      'provider JSON could not be parsed',
+    );
+  }
+}
+
+function tokenText(resolved: ResolvedCredential): string {
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(resolved.secret);
+  } catch {
+    throw new CredentialProviderEvidenceError(
+      'unexpected-provider-shape',
+      'credential bytes were not valid text',
+    );
+  }
+}
+
+function apiAuthorization(resolved: ResolvedCredential): string {
+  return `token ${tokenText(resolved)}`;
+}
+
+function gitAuthorization(resolved: ResolvedCredential): string {
+  const basic = Buffer.from(`${resolved.identity}:${tokenText(resolved)}`, 'utf8').toString(
+    'base64',
+  );
+  return `Basic ${basic}`;
+}
+
+function repoPath(repo: string): { readonly owner: string; readonly name: string } {
+  const pieces = repo.split('/');
+  const owner = pieces[0];
+  const name = pieces[1];
+  if (
+    pieces.length !== 2 ||
+    owner === undefined ||
+    name === undefined ||
+    !REPO_COMPONENT.test(owner) ||
+    !REPO_COMPONENT.test(name)
+  ) {
+    throw new CredentialProviderEvidenceError(
+      'unexpected-provider-shape',
+      'repository must be exactly owner/name in the allowlist grammar',
+    );
+  }
+  return { owner, name };
+}
+
+function effectivePermission(permissions: {
+  readonly admin: boolean;
+  readonly push: boolean;
+  readonly pull: boolean;
+}): RepositoryPermission {
+  if (permissions.admin) return 'admin';
+  if (permissions.push) return 'write';
+  if (permissions.pull) return 'read';
+  return 'none';
+}
+
+export class GiteaCredentialProviderAdapter implements GiteaCredentialProvider {
+  protected readonly origin: string;
+
+  constructor(
+    apiBaseUrl: string,
+    private readonly fetchImpl: FetchLike = fetch,
+    private readonly requestTimeoutMs = 10_000,
+  ) {
+    const parsed = new URL(apiBaseUrl);
+    this.origin = parsed.origin;
+    if (
+      !Number.isSafeInteger(requestTimeoutMs) ||
+      requestTimeoutMs < 1 ||
+      requestTimeoutMs > 30_000
+    ) {
+      throw new CredentialProviderEvidenceError(
+        'invalid-input',
+        'provider request timeout is outside the bounded range',
+      );
+    }
+  }
+
+  protected async request(url: string, init: RequestInit): Promise<Response> {
+    const deadline = AbortSignal.timeout(this.requestTimeoutMs);
+    const signal = init.signal == null ? deadline : AbortSignal.any([init.signal, deadline]);
+    try {
+      return await this.fetchImpl(url, { ...init, signal });
+    } catch {
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        'provider request failed before evidence was available',
+      );
+    }
+  }
+
+  private async classifyRejectedIdentity(rejected: Response): Promise<never> {
+    if (!isJson(rejected)) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-content-type',
+        'provider credential rejection was not JSON',
+      );
+    }
+    const status = rejected.status;
+    await boundedBody(rejected);
+    if (status === 403 || status === 404) {
+      throw new CredentialProviderEvidenceError(
+        'identity-read-forbidden',
+        'provider denied the identity endpoint; credential capability must be tested in scope',
+      );
+    }
+    throw new CredentialProviderEvidenceError(
+      'credential-rejected',
+      'provider rejected the supplied credential; account existence was not inferred',
+    );
+  }
+
+  async readIdentity(resolved: ResolvedCredential): Promise<ProviderIdentityEvidenceDto> {
+    const endpoint = 'GET /api/v1/user';
+    const response = await this.request(`${this.origin}/api/v1/user`, {
+      method: 'GET',
+      headers: {
+        Accept: JSON_CONTENT_TYPE,
+        Authorization: apiAuthorization(resolved),
+        'User-Agent': USER_AGENT,
+      },
+    });
+    if (response.status === 401 || response.status === 403 || response.status === 404) {
+      return this.classifyRejectedIdentity(response);
+    }
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        `provider identity request returned HTTP ${response.status.toString()}`,
+      );
+    }
+    const parsed = userSchema.safeParse(await jsonObject(response));
+    if (!parsed.success) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'provider identity object lacked required fields',
+      );
+    }
+    return {
+      login: parsed.data.login,
+      endpoint,
+      contentType: contentType(response),
+    };
+  }
+
+  async readRepositoryPermission(
+    resolved: ResolvedCredential,
+    repo: string,
+  ): Promise<RepositoryPermissionEvidenceDto> {
+    const { owner, name } = repoPath(repo);
+    const endpoint = `GET /api/v1/repos/${owner}/${name}`;
+    const response = await this.request(`${this.origin}/api/v1/repos/${owner}/${name}`, {
+      method: 'GET',
+      headers: {
+        Accept: JSON_CONTENT_TYPE,
+        Authorization: apiAuthorization(resolved),
+        'User-Agent': USER_AGENT,
+      },
+    });
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        `provider repository request returned HTTP ${response.status.toString()}`,
+      );
+    }
+    const parsed = repoSchema.safeParse(await jsonObject(response));
+    if (!parsed.success || parsed.data.full_name !== repo) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'provider repository object did not identify the requested repository',
+      );
+    }
+    return {
+      effective: effectivePermission(parsed.data.permissions),
+      endpoint,
+      contentType: contentType(response),
+    };
+  }
+
+  async probeReceivePack(
+    resolved: ResolvedCredential | undefined,
+    repo: string,
+  ): Promise<ReceivePackEvidenceDto> {
+    const { owner, name } = repoPath(repo);
+    const headers = new Headers({
+      Accept: RECEIVE_PACK_CONTENT_TYPE,
+      'User-Agent': USER_AGENT,
+    });
+    if (resolved !== undefined) headers.set('Authorization', gitAuthorization(resolved));
+    const response = await this.request(
+      `${this.origin}/${owner}/${name}.git/info/refs?service=git-receive-pack`,
+      { method: 'GET', headers },
+    );
+    const responseType = contentType(response);
+    if (response.status === 401 || response.status === 403) {
+      await boundedBody(response);
+      return {
+        state: 'refused',
+        principal: resolved?.identity ?? null,
+        resolutionId: resolved?.resolutionId ?? null,
+        contentType: responseType,
+      };
+    }
+    if (!response.ok || !responseType.toLowerCase().startsWith(RECEIVE_PACK_CONTENT_TYPE)) {
+      throw new CredentialProviderEvidenceError(
+        response.ok ? 'unexpected-content-type' : 'provider-unavailable',
+        `receive-pack response was not an advertisement (HTTP ${response.status.toString()})`,
+      );
+    }
+    const body = new TextDecoder('utf-8', { fatal: true }).decode(await boundedBody(response));
+    if (!body.includes('# service=git-receive-pack')) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'receive-pack advertisement lacked the protocol service preamble',
+      );
+    }
+    return {
+      state: 'advertised',
+      principal: resolved?.identity ?? null,
+      resolutionId: resolved?.resolutionId ?? null,
+      contentType: responseType,
+    };
+  }
+}
+
+export class GiteaGrantProviderAdapter
+  extends GiteaCredentialProviderAdapter
+  implements GiteaGrantProvider
+{
+  async readBasicIdentity(authority: ResolvedCredential): Promise<ProviderIdentityEvidenceDto> {
+    const endpoint = 'GET /api/v1/user';
+    const response = await this.request(`${this.origin}/api/v1/user`, {
+      method: 'GET',
+      headers: {
+        Accept: JSON_CONTENT_TYPE,
+        Authorization: basicAuthorization(authority),
+        'User-Agent': USER_AGENT,
+      },
+    });
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError(
+        'credential-rejected',
+        'delegated Basic authority was rejected',
+      );
+    }
+    const parsed = userSchema.safeParse(await jsonObject(response));
+    if (!parsed.success) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'delegated Basic identity response was malformed',
+      );
+    }
+    return { login: parsed.data.login, endpoint, contentType: contentType(response) };
+  }
+
+  async grantCollaborator(
+    authority: ResolvedCredential,
+    identity: string,
+    repo: string,
+    permission: RepositoryPermission,
+  ): Promise<void> {
+    const { owner, name } = repoPath(repo);
+    const response = await this.request(
+      `${this.origin}/api/v1/repos/${owner}/${name}/collaborators/${encodeURIComponent(identity)}`,
+      {
+        method: 'PUT',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'Content-Type': JSON_CONTENT_TYPE,
+          'User-Agent': USER_AGENT,
+        },
+        body: JSON.stringify({ permission }),
+      },
+    );
+    await boundedBody(response);
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError(
+        response.status === 401 || response.status === 403
+          ? 'credential-rejected'
+          : 'provider-unavailable',
+        `provider grant request returned HTTP ${response.status.toString()}`,
+      );
+    }
+  }
+
+  async readCollaboratorPermission(
+    authority: ResolvedCredential,
+    identity: string,
+    repo: string,
+  ): Promise<CollaboratorPermissionEvidenceDto> {
+    const { owner, name } = repoPath(repo);
+    const endpoint = `GET /api/v1/repos/${owner}/${name}/collaborators/${identity}/permission`;
+    const response = await this.request(
+      `${this.origin}/api/v1/repos/${owner}/${name}/collaborators/${encodeURIComponent(identity)}/permission`,
+      {
+        method: 'GET',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError(
+        'readback-missing',
+        `collaborator permission read-back returned HTTP ${response.status.toString()}`,
+      );
+    }
+    const parsed = collaboratorPermissionSchema.safeParse(await jsonObject(response));
+    if (!parsed.success || parsed.data.user.login !== identity) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'collaborator permission object did not identify the declared subject',
+      );
+    }
+    return {
+      identity: parsed.data.user.login,
+      permission: parsed.data.permission,
+      endpoint,
+      contentType: contentType(response),
+    };
+  }
+
+  async readOrganizationMembership(
+    subject: ResolvedCredential,
+    organization: string,
+  ): Promise<OrganizationMembershipEvidenceDto> {
+    const endpoint = `GET /api/v1/users/${subject.identity}/orgs`;
+    const response = await this.request(
+      `${this.origin}/api/v1/users/${encodeURIComponent(subject.identity)}/orgs`,
+      {
+        method: 'GET',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: apiAuthorization(subject),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError(
+        response.status === 401 || response.status === 403
+          ? 'scope-not-evaluable'
+          : 'provider-unavailable',
+        `organization membership read-back returned HTTP ${response.status.toString()}`,
+      );
+    }
+    const parsed = z.array(organizationSchema).safeParse(await jsonObject(response));
+    if (!parsed.success) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'organization membership response was not an organization array',
+      );
+    }
+    return {
+      state: parsed.data.some((entry): boolean => entry.username === organization)
+        ? 'present'
+        : 'absent',
+      endpoint,
+      contentType: contentType(response),
+    };
+  }
+}
+
+export class GiteaTeamGrantProviderAdapter
+  extends GiteaGrantProviderAdapter
+  implements GiteaTeamGrantProvider
+{
+  async resolveTeam(
+    authority: ResolvedCredential,
+    organization: string,
+    team: string,
+  ): Promise<TeamResolutionEvidence> {
+    const endpoint = `GET /api/v1/orgs/${organization}/teams`;
+    const response = await this.request(
+      `${this.origin}/api/v1/orgs/${encodeURIComponent(organization)}/teams`,
+      {
+        method: 'GET',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        'team list was unavailable',
+      );
+    }
+    const parsed = z.array(teamSchema).safeParse(await jsonObject(response));
+    const matches = parsed.success
+      ? parsed.data.filter((entry): boolean => entry.name === team)
+      : [];
+    if (matches.length !== 1 || matches[0] === undefined) {
+      throw new CredentialProviderEvidenceError(
+        'readback-missing',
+        'team did not resolve uniquely',
+      );
+    }
+    return { ...matches[0], endpoint, contentType: contentType(response) };
+  }
+
+  async listTeamRepositories(
+    authority: ResolvedCredential,
+    teamId: number,
+  ): Promise<TeamRepositorySetEvidence> {
+    const endpoint = `GET /api/v1/teams/${teamId.toString()}/repos`;
+    const repositories: string[] = [];
+    let observedType = '';
+    for (let page = 1; page <= 100; page += 1) {
+      const response = await this.request(
+        `${this.origin}/api/v1/teams/${teamId.toString()}/repos?limit=50&page=${page.toString()}`,
+        {
+          method: 'GET',
+          headers: {
+            Accept: JSON_CONTENT_TYPE,
+            Authorization: basicAuthorization(authority),
+            'User-Agent': USER_AGENT,
+          },
+        },
+      );
+      if (!response.ok) {
+        await boundedBody(response);
+        throw new CredentialProviderEvidenceError(
+          'readback-missing',
+          'team repository set was unavailable',
+        );
+      }
+      observedType = contentType(response);
+      const parsed = z.array(repoSchema).safeParse(await jsonObject(response));
+      if (!parsed.success) {
+        throw new CredentialProviderEvidenceError(
+          'unexpected-provider-shape',
+          'team repository set was not a repository array',
+        );
+      }
+      repositories.push(...parsed.data.map((repo): string => repo.full_name));
+      if (parsed.data.length < 50) {
+        return { repositories, endpoint, contentType: observedType };
+      }
+    }
+    throw new CredentialProviderEvidenceError(
+      'readback-missing',
+      'team repository set exceeded the pagination bound',
+    );
+  }
+
+  async addTeamMember(
+    authority: ResolvedCredential,
+    teamId: number,
+    identity: string,
+  ): Promise<void> {
+    await this.putTeamPath(
+      authority,
+      `/api/v1/teams/${teamId.toString()}/members/${encodeURIComponent(identity)}`,
+    );
+  }
+
+  async removeTeamMember(
+    authority: ResolvedCredential,
+    teamId: number,
+    identity: string,
+  ): Promise<void> {
+    const response = await this.request(
+      `${this.origin}/api/v1/teams/${teamId.toString()}/members/${encodeURIComponent(identity)}`,
+      {
+        method: 'DELETE',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    await boundedBody(response);
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        'team member rollback failed',
+      );
+    }
+  }
+
+  async attachTeamRepository(
+    authority: ResolvedCredential,
+    teamId: number,
+    repo: string,
+  ): Promise<void> {
+    const { owner, name } = repoPath(repo);
+    await this.putTeamPath(authority, `/api/v1/teams/${teamId.toString()}/repos/${owner}/${name}`);
+  }
+
+  async detachTeamRepository(
+    authority: ResolvedCredential,
+    teamId: number,
+    repo: string,
+  ): Promise<void> {
+    const { owner, name } = repoPath(repo);
+    const response = await this.request(
+      `${this.origin}/api/v1/teams/${teamId.toString()}/repos/${owner}/${name}`,
+      {
+        method: 'DELETE',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    await boundedBody(response);
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        'team repository rollback failed',
+      );
+    }
+  }
+
+  private async putTeamPath(authority: ResolvedCredential, path: string): Promise<void> {
+    const response = await this.request(`${this.origin}${path}`, {
+      method: 'PUT',
+      headers: {
+        Accept: JSON_CONTENT_TYPE,
+        Authorization: basicAuthorization(authority),
+        'User-Agent': USER_AGENT,
+      },
+    });
+    await boundedBody(response);
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError(
+        'provider-unavailable',
+        'team grant mutation failed',
+      );
+    }
+  }
+
+  async readTeamMember(
+    authority: ResolvedCredential,
+    teamId: number,
+    identity: string,
+  ): Promise<PresenceEvidence> {
+    return this.readPresence(
+      authority,
+      `GET /api/v1/teams/${teamId.toString()}/members/${encodeURIComponent(identity)}`,
+      (value: unknown): boolean => {
+        const parsed = userSchema.safeParse(value);
+        return parsed.success && parsed.data.login === identity;
+      },
+    );
+  }
+
+  async readTeamRepository(
+    authority: ResolvedCredential,
+    teamId: number,
+    repo: string,
+  ): Promise<PresenceEvidence> {
+    const { owner, name } = repoPath(repo);
+    return this.readPresence(
+      authority,
+      `GET /api/v1/teams/${teamId.toString()}/repos/${owner}/${name}`,
+      (value: unknown): boolean => {
+        const parsed = repoSchema.safeParse(value);
+        return parsed.success && parsed.data.full_name === repo;
+      },
+    );
+  }
+
+  private async readPresence(
+    authority: ResolvedCredential,
+    endpoint: string,
+    matchesExpectedObject: (value: unknown) => boolean,
+  ): Promise<PresenceEvidence> {
+    const response = await this.request(`${this.origin}${endpoint.slice(4)}`, {
+      method: 'GET',
+      headers: {
+        Accept: JSON_CONTENT_TYPE,
+        Authorization: basicAuthorization(authority),
+        'User-Agent': USER_AGENT,
+      },
+    });
+    if (response.status === 404) {
+      await boundedBody(response);
+      return { state: 'absent', endpoint, contentType: contentType(response) };
+    }
+    if (!response.ok || !isJson(response)) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError('readback-missing', 'team read-back failed');
+    }
+    if (!matchesExpectedObject(await jsonObject(response))) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'team read-back did not identify the requested object',
+      );
+    }
+    return { state: 'present', endpoint, contentType: contentType(response) };
+  }
+}
+
+function basicAuthorization(authority: ResolvedCredential): string {
+  const prefix = Buffer.from(`${authority.identity}:`, 'utf8');
+  const material = Buffer.concat([prefix, Buffer.from(authority.secret)]);
+  try {
+    return `Basic ${material.toString('base64')}`;
+  } finally {
+    prefix.fill(0);
+    material.fill(0);
+  }
+}
+
+export class GiteaLifecycleProviderAdapter
+  extends GiteaCredentialProviderAdapter
+  implements GiteaLifecycleProvider
+{
+  async readBasicIdentity(authority: ResolvedCredential): Promise<ProviderIdentityEvidenceDto> {
+    const endpoint = 'GET /api/v1/user';
+    const response = await this.request(`${this.origin}/api/v1/user`, {
+      method: 'GET',
+      headers: {
+        Accept: JSON_CONTENT_TYPE,
+        Authorization: basicAuthorization(authority),
+        'User-Agent': USER_AGENT,
+      },
+    });
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError(
+        'credential-rejected',
+        'delegated Basic authority was rejected',
+      );
+    }
+    const parsed = userSchema.safeParse(await jsonObject(response));
+    if (!parsed.success) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'delegated Basic identity response was malformed',
+      );
+    }
+    return { login: parsed.data.login, endpoint, contentType: contentType(response) };
+  }
+
+  async mintToken(
+    authority: ResolvedCredential,
+    identity: string,
+    name: string,
+    scopes: readonly string[],
+  ): Promise<MintedToken> {
+    const endpoint = `POST /api/v1/users/${identity}/tokens`;
+    const response = await this.request(
+      `${this.origin}/api/v1/users/${encodeURIComponent(identity)}/tokens`,
+      {
+        method: 'POST',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          'Content-Type': JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+        body: JSON.stringify({ name, scopes }),
+      },
+    );
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError('provider-unavailable', 'token mint failed');
+    }
+    const parsed = tokenObjectSchema.safeParse(await jsonObject(response));
+    const secret = parsed.success ? (parsed.data.sha1 ?? parsed.data.token) : undefined;
+    if (!parsed.success || secret === undefined || parsed.data.name !== name) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'minted token object lacked the requested name or secret',
+      );
+    }
+    return {
+      secret: new TextEncoder().encode(secret),
+      evidence: {
+        name: parsed.data.name,
+        scopes: parsed.data.scopes,
+        endpoint,
+        contentType: contentType(response),
+      },
+    };
+  }
+
+  async readToken(
+    authority: ResolvedCredential,
+    identity: string,
+    name: string,
+  ): Promise<TokenObjectEvidenceDto> {
+    const endpoint = `GET /api/v1/users/${identity}/tokens`;
+    const response = await this.request(
+      `${this.origin}/api/v1/users/${encodeURIComponent(identity)}/tokens`,
+      {
+        method: 'GET',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError('readback-missing', 'token list read-back failed');
+    }
+    const parsed = z.array(tokenObjectSchema).safeParse(await jsonObject(response));
+    const matches = parsed.success
+      ? parsed.data.filter((token): boolean => token.name === name)
+      : [];
+    if (matches.length !== 1 || matches[0] === undefined) {
+      throw new CredentialProviderEvidenceError(
+        'readback-missing',
+        'minted token did not resolve uniquely by name',
+      );
+    }
+    return {
+      name: matches[0].name,
+      scopes: matches[0].scopes,
+      endpoint,
+      contentType: contentType(response),
+    };
+  }
+
+  async tokenExists(
+    authority: ResolvedCredential,
+    identity: string,
+    name: string,
+  ): Promise<boolean> {
+    const response = await this.request(
+      `${this.origin}/api/v1/users/${encodeURIComponent(identity)}/tokens`,
+      {
+        method: 'GET',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    if (!response.ok) {
+      await boundedBody(response);
+      throw new CredentialProviderEvidenceError(
+        'readback-missing',
+        'token absence read-back failed',
+      );
+    }
+    const parsed = z.array(tokenObjectSchema).safeParse(await jsonObject(response));
+    if (!parsed.success) {
+      throw new CredentialProviderEvidenceError(
+        'unexpected-provider-shape',
+        'token absence read-back was malformed',
+      );
+    }
+    return parsed.data.some((token): boolean => token.name === name);
+  }
+
+  async revokeToken(authority: ResolvedCredential, identity: string, name: string): Promise<void> {
+    const response = await this.request(
+      `${this.origin}/api/v1/users/${encodeURIComponent(identity)}/tokens/${encodeURIComponent(name)}`,
+      {
+        method: 'DELETE',
+        headers: {
+          Accept: JSON_CONTENT_TYPE,
+          Authorization: basicAuthorization(authority),
+          'User-Agent': USER_AGENT,
+        },
+      },
+    );
+    await boundedBody(response);
+    if (!response.ok) {
+      throw new CredentialProviderEvidenceError('mutation-state-unknown', 'token revoke failed');
+    }
+  }
+}

packages/mosaic/src/credentials/grant.dto.ts

@@ -0,0 +1,45 @@
+import type {
+  CredentialAuditResultDto,
+  CredentialMutationState,
+  CredentialOutcome,
+  CredentialReasonDto,
+  CredentialSubjectDto,
+  CredentialValidationEvidenceDto,
+  RepositoryPermission,
+} from './credential-result.dto.js';
+
+export interface CollaboratorPermissionEvidenceDto {
+  readonly identity: string;
+  readonly permission: RepositoryPermission;
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+
+export interface OrganizationMembershipEvidenceDto {
+  readonly state: 'present' | 'absent';
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+
+export interface CredentialGrantEvidenceDto extends CredentialValidationEvidenceDto {
+  readonly collaboratorPermission: CollaboratorPermissionEvidenceDto | null;
+  readonly organizationMembership: OrganizationMembershipEvidenceDto | null;
+}
+
+export interface CredentialGrantResultDto {
+  readonly schemaVersion: 1;
+  readonly operation: 'grant';
+  readonly outcome: CredentialOutcome;
+  readonly exitCode: 0 | 10 | 20 | 30;
+  readonly retryable: boolean;
+  readonly subject: CredentialSubjectDto;
+  readonly mutation: CredentialMutationState;
+  readonly reason: CredentialReasonDto;
+  readonly evidence: CredentialGrantEvidenceDto;
+  readonly audit: CredentialAuditResultDto;
+}
+
+export interface DirectGrantRequestDto extends CredentialSubjectDto {
+  readonly permission: RepositoryPermission;
+  readonly readOnlyControlIdentity: string;
+}

packages/mosaic/src/credentials/grant.spec.ts

@@ -0,0 +1,230 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { listCredentialJournals } from './audit-journal.js';
+import { grantDirectRepositoryPermission } from './grant.js';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+import type { GiteaGrantProvider } from './grant.js';
+import type { CredentialValidationDependencies } from './validate.js';
+
+let cleanup: string | undefined;
+const authority: ResolvedCredential = Object.freeze({
+  identity: 'provisioner',
+  estate: 'homelab',
+  host: 'git.example.invalid',
+  resolutionId: 'authority',
+  secret: new TextEncoder().encode('authority-canary'),
+});
+
+async function stateRoot(): Promise<string> {
+  cleanup = await mkdtemp(join(tmpdir(), 'mosaic-grant-'));
+  return join(cleanup, 'state');
+}
+
+afterEach(async (): Promise<void> => {
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+function validationDependencies(permission: 'read' | 'write'): CredentialValidationDependencies {
+  const subject: ResolvedCredential = Object.freeze({
+    identity: 'seat-name',
+    estate: 'homelab',
+    host: 'git.example.invalid',
+    resolutionId: 'subject',
+    secret: new TextEncoder().encode('subject-canary'),
+  });
+  const control: ResolvedCredential = Object.freeze({
+    identity: 'read-control',
+    estate: 'homelab',
+    host: 'git.example.invalid',
+    resolutionId: 'control',
+    secret: new TextEncoder().encode('control-canary'),
+  });
+  return {
+    estateRegistry: { matches: (): boolean => true },
+    resolver: {
+      async resolve(identity: string): Promise<ResolvedCredential | undefined> {
+        if (identity === 'seat-name') return subject;
+        if (identity === 'read-control') return control;
+        return undefined;
+      },
+    },
+    provider: {
+      async readIdentity(resolved: ResolvedCredential) {
+        return {
+          login: resolved.identity,
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async readRepositoryPermission(resolved: ResolvedCredential) {
+        return {
+          effective: resolved.identity === 'seat-name' ? permission : 'read',
+          endpoint: 'GET /api/v1/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async probeReceivePack(resolved: ResolvedCredential | undefined) {
+        const subjectWrite = resolved?.identity === 'seat-name' && permission === 'write';
+        return {
+          state: subjectWrite ? 'advertised' : 'refused',
+          principal: resolved?.identity ?? null,
+          resolutionId: resolved?.resolutionId ?? null,
+          contentType: subjectWrite ? 'application/x-git-receive-pack-advertisement' : 'text/plain',
+        };
+      },
+    },
+  };
+}
+
+describe('direct repository grant', (): void => {
+  it('opens the journal before mutation and accepts only matching provider read-back', async (): Promise<void> => {
+    const root = await stateRoot();
+    const provider: GiteaGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async grantCollaborator(): Promise<void> {
+        expect((await listCredentialJournals(root))[0]?.state).toBe('open');
+      },
+      async readCollaboratorPermission() {
+        return {
+          identity: 'seat-name',
+          permission: 'write',
+          endpoint: 'GET /api/v1/repos/owner/repo/collaborators/seat-name/permission',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const result = await grantDirectRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validationDependencies('write'),
+      { stateRoot: root, actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('ok');
+    expect(result.mutation).toBe('applied');
+    expect(result.evidence.repositoryPermission?.effective).toBe('write');
+    expect(result.evidence.organizationMembership?.state).toBe('absent');
+    expect(result.audit.state).toBe('sealed');
+    const [sealed] = await listCredentialJournals(root);
+    const source = await readFile(sealed?.path ?? '', 'utf8');
+    expect(source).toContain('"phase":"mutation"');
+    expect(source).toContain('"decision":"collaborator-grant-applied"');
+    expect(source).toContain('"decision":"identity-verified"');
+    expect(source).toContain('"decision":"organization-member-absent"');
+    expect(source).toContain('"decision":"transport-write-verified"');
+  });
+
+  it('preserves applied mutation and journal context when post-grant read-back fails', async (): Promise<void> => {
+    const root = await stateRoot();
+    const provider: GiteaGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async grantCollaborator(): Promise<void> {},
+      async readCollaboratorPermission() {
+        throw new Error('read-back unavailable');
+      },
+      async readOrganizationMembership() {
+        throw new Error('must not be reached');
+      },
+    };
+
+    const result = await grantDirectRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validationDependencies('write'),
+      { stateRoot: root, actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.mutation).toBe('applied');
+    expect(result.reason.code).toBe('readback-missing');
+    expect(result.audit.journalId).not.toBeNull();
+    expect(result.audit.state).toBe('sealed');
+  });
+
+  it('is indeterminate when grant read-back disagrees with the requested permission', async (): Promise<void> => {
+    const root = await stateRoot();
+    const provider: GiteaGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async grantCollaborator(): Promise<void> {},
+      async readCollaboratorPermission() {
+        return {
+          identity: 'seat-name',
+          permission: 'read',
+          endpoint: 'GET /api/v1/repos/owner/repo/collaborators/seat-name/permission',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const result = await grantDirectRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validationDependencies('read'),
+      { stateRoot: root, actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('permission-evidence-disagrees');
+    expect(result.mutation).toBe('applied');
+  });
+});

packages/mosaic/src/credentials/grant.ts

@@ -0,0 +1,262 @@
+import { CredentialAuditJournal, CredentialJournalError } from './audit-journal.js';
+import type {
+  CredentialValidationDependencies,
+  ResolvedCredential,
+} from './credential-provider.dto.js';
+import type { RepositoryPermission } from './credential-result.dto.js';
+import type {
+  CollaboratorPermissionEvidenceDto,
+  CredentialGrantResultDto,
+  DirectGrantRequestDto,
+  OrganizationMembershipEvidenceDto,
+} from './grant.dto.js';
+import { evaluateGiteaReadValidation, evaluateGiteaWriteValidation } from './validate.js';
+
+export interface GiteaGrantProvider {
+  readBasicIdentity(authority: ResolvedCredential): Promise<{
+    readonly login: string;
+    readonly endpoint: string;
+    readonly contentType: string;
+  }>;
+  grantCollaborator(
+    authority: ResolvedCredential,
+    identity: string,
+    repo: string,
+    permission: RepositoryPermission,
+  ): Promise<void>;
+  readCollaboratorPermission(
+    authority: ResolvedCredential,
+    identity: string,
+    repo: string,
+  ): Promise<CollaboratorPermissionEvidenceDto>;
+  readOrganizationMembership(
+    subject: ResolvedCredential,
+    organization: string,
+  ): Promise<OrganizationMembershipEvidenceDto>;
+}
+
+export class CredentialGrantExecutionError extends Error {
+  constructor(
+    public readonly code: string,
+    public readonly mutation: 'none' | 'unknown' | 'applied',
+    public readonly journalId: string,
+  ) {
+    super(`Credential grant control failed: code=${code}`);
+    this.name = 'CredentialGrantExecutionError';
+  }
+}
+
+export interface CredentialGrantServiceOptions {
+  readonly stateRoot: string;
+  readonly actor: string;
+}
+
+function exitFor(outcome: CredentialGrantResultDto['outcome']): 0 | 10 | 20 | 30 {
+  if (outcome === 'ok') return 0;
+  if (outcome === 'refused') return 10;
+  if (outcome === 'error') return 20;
+  return 30;
+}
+
+export async function grantDirectRepositoryPermission(
+  request: DirectGrantRequestDto,
+  authority: ResolvedCredential,
+  grantProvider: GiteaGrantProvider,
+  validationDependencies: CredentialValidationDependencies,
+  options: CredentialGrantServiceOptions,
+): Promise<CredentialGrantResultDto> {
+  const journal = await CredentialAuditJournal.open(options.stateRoot, {
+    operation: 'grant',
+    actor: options.actor,
+    identity: request.identity,
+    estate: request.estate,
+    host: request.host,
+    repo: request.repo,
+  });
+  await journal.recordIntent('provider-grant');
+  let mutation: 'none' | 'unknown' | 'applied' = 'none';
+  try {
+    const authorityIdentity = await grantProvider.readBasicIdentity(authority);
+    if (authorityIdentity.login !== options.actor) {
+      await journal.seal('refused', 'provider-identity-mismatch');
+      return {
+        schemaVersion: 1,
+        operation: 'grant',
+        outcome: 'refused',
+        exitCode: 10,
+        retryable: false,
+        subject: {
+          identity: request.identity,
+          estate: request.estate,
+          host: request.host,
+          repo: request.repo,
+        },
+        mutation: 'none',
+        reason: {
+          code: 'provider-identity-mismatch',
+          message: 'Delegated grant authority did not authenticate as the explicit audit actor.',
+        },
+        evidence: {
+          providerIdentity: authorityIdentity,
+          tokenCapabilities: {
+            state: 'not-measured',
+            scopes: [],
+            source: 'runtime-not-authorized',
+          },
+          repositoryPermission: null,
+          writeDifferential: null,
+          collaboratorPermission: null,
+          organizationMembership: null,
+        },
+        audit: { journalId: journal.journalId(), state: 'sealed' },
+      };
+    }
+    await journal.recordProviderEvidence({
+      endpoint: authorityIdentity.endpoint,
+      contentType: authorityIdentity.contentType,
+      decision: 'identity-verified',
+    });
+    mutation = 'unknown';
+    await grantProvider.grantCollaborator(
+      authority,
+      request.identity,
+      request.repo,
+      request.permission,
+    );
+    mutation = 'applied';
+    await journal.recordMutation('collaborator-grant-applied');
+
+    const collaborator = await grantProvider.readCollaboratorPermission(
+      authority,
+      request.identity,
+      request.repo,
+    );
+    const subject = await validationDependencies.resolver.resolve(
+      request.identity,
+      request.estate,
+      request.host,
+    );
+    const organization = request.repo.split('/')[0] ?? '';
+    const organizationMembership =
+      subject === undefined
+        ? null
+        : await grantProvider.readOrganizationMembership(subject, organization);
+    const validation =
+      request.permission === 'read'
+        ? await evaluateGiteaReadValidation(request, validationDependencies)
+        : await evaluateGiteaWriteValidation(request, validationDependencies);
+
+    if (organizationMembership !== null) {
+      await journal.recordProviderEvidence({
+        endpoint: organizationMembership.endpoint,
+        contentType: organizationMembership.contentType,
+        decision:
+          organizationMembership.state === 'present'
+            ? 'organization-member-present'
+            : 'organization-member-absent',
+      });
+    }
+    if (validation.evidence.providerIdentity !== null) {
+      await journal.recordProviderEvidence({
+        endpoint: validation.evidence.providerIdentity.endpoint,
+        contentType: validation.evidence.providerIdentity.contentType,
+        decision: 'identity-verified',
+      });
+    }
+    if (validation.evidence.repositoryPermission !== null) {
+      await journal.recordProviderEvidence({
+        endpoint: validation.evidence.repositoryPermission.endpoint,
+        contentType: validation.evidence.repositoryPermission.contentType,
+        decision: `permission-${validation.evidence.repositoryPermission.effective}`,
+      });
+    }
+    if (validation.evidence.writeDifferential !== null) {
+      await journal.recordMutation('transport-write-verified');
+    }
+
+    const readBackMatches =
+      collaborator.identity === request.identity &&
+      collaborator.permission === request.permission &&
+      validation.outcome === 'ok' &&
+      validation.evidence.repositoryPermission?.effective === request.permission;
+    const outcome: CredentialGrantResultDto['outcome'] = readBackMatches ? 'ok' : 'indeterminate';
+    const reasonCode = readBackMatches ? 'grant-verified' : 'permission-evidence-disagrees';
+    await journal.recordProviderEvidence({
+      endpoint: collaborator.endpoint,
+      contentType: collaborator.contentType,
+      decision: `permission-${collaborator.permission}`,
+    });
+    await journal.seal(outcome, reasonCode);
+
+    return {
+      schemaVersion: 1,
+      operation: 'grant',
+      outcome,
+      exitCode: exitFor(outcome),
+      retryable: false,
+      subject: {
+        identity: request.identity,
+        estate: request.estate,
+        host: request.host,
+        repo: request.repo,
+      },
+      mutation: 'applied',
+      reason: {
+        code: reasonCode,
+        message: readBackMatches
+          ? 'Grant matched every required provider read-back.'
+          : 'Grant mutation completed but provider permission evidence disagreed.',
+      },
+      evidence: {
+        ...validation.evidence,
+        collaboratorPermission: collaborator,
+        organizationMembership,
+      },
+      audit: { journalId: journal.journalId(), state: 'sealed' },
+    };
+  } catch (error: unknown) {
+    if (error instanceof CredentialJournalError) {
+      throw new CredentialGrantExecutionError(error.code, mutation, journal.journalId());
+    }
+    const reasonCode = mutation === 'applied' ? 'readback-missing' : 'mutation-state-unknown';
+    try {
+      await journal.seal('indeterminate', reasonCode);
+    } catch (journalError: unknown) {
+      if (journalError instanceof CredentialJournalError) {
+        throw new CredentialGrantExecutionError(journalError.code, mutation, journal.journalId());
+      }
+      throw journalError;
+    }
+    return {
+      schemaVersion: 1,
+      operation: 'grant',
+      outcome: 'indeterminate',
+      exitCode: 30,
+      retryable: false,
+      subject: {
+        identity: request.identity,
+        estate: request.estate,
+        host: request.host,
+        repo: request.repo,
+      },
+      mutation,
+      reason: {
+        code: reasonCode,
+        message: 'Grant mutation state was preserved after provider evidence failed.',
+      },
+      evidence: {
+        providerIdentity: null,
+        tokenCapabilities: {
+          state: 'not-measured',
+          scopes: [],
+          source: 'runtime-not-authorized',
+        },
+        repositoryPermission: null,
+        writeDifferential: null,
+        collaboratorPermission: null,
+        organizationMembership: null,
+      },
+      audit: { journalId: journal.journalId(), state: 'sealed' },
+    };
+  }
+}

packages/mosaic/src/credentials/lifecycle.dto.ts

@@ -0,0 +1,49 @@
+import type { CredentialOutcome } from './credential-result.dto.js';
+
+export type CredentialLifecycleOperation =
+  | 'provision'
+  | 'wire'
+  | 'get'
+  | 'whoami'
+  | 'list'
+  | 'rotate'
+  | 'revoke'
+  | 'audit';
+
+export interface TokenObjectEvidenceDto {
+  readonly name: string;
+  readonly scopes: readonly string[];
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+
+export interface CredentialLifecycleResultDto {
+  readonly schemaVersion: 1;
+  readonly operation: CredentialLifecycleOperation;
+  readonly outcome: CredentialOutcome;
+  readonly exitCode: 0 | 10 | 20 | 30;
+  readonly retryable: boolean;
+  readonly subject: {
+    readonly identity: string;
+    readonly estate: string;
+    readonly host: string;
+    readonly repo: null;
+  };
+  readonly mutation: 'none' | 'unknown' | 'applied';
+  readonly reason: { readonly code: string; readonly message: string };
+  readonly evidence: {
+    readonly providerIdentity: string | null;
+    readonly token: TokenObjectEvidenceDto | null;
+    readonly teaLogin: {
+      readonly name: string;
+      readonly host: string;
+      readonly state: 'registered' | 'not-measured';
+    } | null;
+    readonly identities: readonly string[];
+    readonly journalIds: readonly string[];
+  };
+  readonly audit: {
+    readonly journalId: string | null;
+    readonly state: 'not-started' | 'open' | 'sealed';
+  };
+}

packages/mosaic/src/credentials/lifecycle.spec.ts

@@ -0,0 +1,214 @@
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+import { parseCredentialEstateRegistry } from './estate-registry.js';
+import { FileCredentialStore } from './file-credential-store.js';
+import { provisionCredential, revokeCredential, type GiteaLifecycleProvider } from './lifecycle.js';
+import { TeaLoginStore } from './tea-login-store.js';
+
+let cleanup: string | undefined;
+afterEach(async (): Promise<void> => {
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+async function fixture(): Promise<{
+  root: string;
+  store: FileCredentialStore;
+  teaStore: TeaLoginStore;
+}> {
+  cleanup = await mkdtemp(join(tmpdir(), 'mosaic-lifecycle-'));
+  const tokens = join(cleanup, 'tokens');
+  await mkdir(tokens, { mode: 0o700 });
+  const registry = parseCredentialEstateRegistry(
+    JSON.stringify({
+      version: 1,
+      estates: [
+        {
+          name: 'homelab',
+          readOnlyControlIdentity: 'control',
+          hosts: [
+            {
+              host: 'git.example.invalid',
+              provider: 'gitea',
+              apiBaseUrl: 'https://git.example.invalid',
+              tokenPrefix: 'gitea-example',
+            },
+          ],
+        },
+      ],
+    }),
+  );
+  return {
+    root: join(cleanup, 'state'),
+    store: new FileCredentialStore(tokens, registry),
+    teaStore: new TeaLoginStore(join(cleanup, 'tea', 'config.yml')),
+  };
+}
+
+const authority: ResolvedCredential = Object.freeze({
+  identity: 'seat',
+  estate: 'homelab',
+  host: 'git.example.invalid',
+  resolutionId: 'basic-authority',
+  secret: new TextEncoder().encode('password-canary'),
+});
+
+function provider(): GiteaLifecycleProvider {
+  return {
+    async readBasicIdentity() {
+      return { login: 'seat', endpoint: 'GET /api/v1/user', contentType: 'application/json' };
+    },
+    async mintToken(_authority, _identity, name, scopes) {
+      return {
+        secret: new TextEncoder().encode('minted-token-canary'),
+        evidence: {
+          name,
+          scopes,
+          endpoint: 'POST /api/v1/users/seat/tokens',
+          contentType: 'application/json',
+        },
+      };
+    },
+    async readToken(_authority, _identity, name) {
+      return {
+        name,
+        scopes: ['write:repository'],
+        endpoint: 'GET /api/v1/users/seat/tokens',
+        contentType: 'application/json',
+      };
+    },
+    async revokeToken(): Promise<void> {},
+    async tokenExists(): Promise<boolean> {
+      return false;
+    },
+  };
+}
+
+describe('credential lifecycle', (): void => {
+  it('accepts provision only after exact principal and scope read-back', async (): Promise<void> => {
+    const { root, store, teaStore } = await fixture();
+    const result = await provisionCredential(
+      {
+        identity: 'seat',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        tokenName: 'mosaic-seat-1',
+        scopes: ['write:repository'],
+      },
+      authority,
+      provider(),
+      store,
+      teaStore,
+      { stateRoot: root, actor: 'seat', now: (): string => '2026-08-05T00:00:00.000Z' },
+    );
+    expect(result.outcome).toBe('ok');
+    await expect(
+      store.readBinding('seat', 'homelab', 'git.example.invalid'),
+    ).resolves.toMatchObject({ providerLogin: 'seat', scopes: ['write:repository'] });
+    expect(JSON.stringify(result)).not.toContain('minted-token-canary');
+  });
+
+  it('rolls back a minted token when exact scope read-back disagrees', async (): Promise<void> => {
+    const { root, store, teaStore } = await fixture();
+    let revoked = false;
+    const lifecycleProvider = provider();
+    lifecycleProvider.readToken = async (_authority, _identity, name) => ({
+      name,
+      scopes: ['admin'],
+      endpoint: 'GET /api/v1/users/seat/tokens',
+      contentType: 'application/json',
+    });
+    lifecycleProvider.revokeToken = async (): Promise<void> => {
+      revoked = true;
+    };
+    lifecycleProvider.tokenExists = async (): Promise<boolean> => false;
+
+    const result = await provisionCredential(
+      {
+        identity: 'seat',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        tokenName: 'mosaic-seat-bad',
+        scopes: ['write:repository'],
+      },
+      authority,
+      lifecycleProvider,
+      store,
+      teaStore,
+      { stateRoot: root, actor: 'seat' },
+    );
+
+    expect(result.outcome).toBe('error');
+    expect(result.mutation).toBe('none');
+    expect(revoked).toBe(true);
+    await expect(store.list('homelab', 'git.example.invalid')).resolves.toEqual([]);
+  });
+
+  it('revokes at provider before removing the local binding', async (): Promise<void> => {
+    const { root, store, teaStore } = await fixture();
+    await provisionCredential(
+      {
+        identity: 'seat',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        tokenName: 'mosaic-seat-1',
+        scopes: ['write:repository'],
+      },
+      authority,
+      provider(),
+      store,
+      teaStore,
+      { stateRoot: root, actor: 'seat' },
+    );
+    let revoked = false;
+    const lifecycleProvider = provider();
+    lifecycleProvider.revokeToken = async (): Promise<void> => {
+      revoked = true;
+    };
+    const result = await revokeCredential(
+      { identity: 'seat', estate: 'homelab', host: 'git.example.invalid' },
+      authority,
+      lifecycleProvider,
+      store,
+      teaStore,
+      { stateRoot: root, actor: 'seat' },
+    );
+    expect(result.outcome).toBe('ok');
+    expect(revoked).toBe(true);
+    await expect(store.list('homelab', 'git.example.invalid')).resolves.toEqual([]);
+  });
+
+  it('preserves the local recovery binding when provider revocation read-back still finds the token', async (): Promise<void> => {
+    const { root, store, teaStore } = await fixture();
+    await provisionCredential(
+      {
+        identity: 'seat',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        tokenName: 'mosaic-seat-1',
+        scopes: ['write:repository'],
+      },
+      authority,
+      provider(),
+      store,
+      teaStore,
+      { stateRoot: root, actor: 'seat' },
+    );
+    const lifecycleProvider = provider();
+    lifecycleProvider.tokenExists = async (): Promise<boolean> => true;
+    const result = await revokeCredential(
+      { identity: 'seat', estate: 'homelab', host: 'git.example.invalid' },
+      authority,
+      lifecycleProvider,
+      store,
+      teaStore,
+      { stateRoot: root, actor: 'seat' },
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    await expect(store.list('homelab', 'git.example.invalid')).resolves.toEqual(['seat']);
+  });
+});

packages/mosaic/src/credentials/lifecycle.ts

@@ -0,0 +1,364 @@
+import { CredentialAuditJournal, CredentialJournalError } from './audit-journal.js';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+import type { FileCredentialStore } from './file-credential-store.js';
+import type { TeaLoginStore } from './tea-login-store.js';
+import type {
+  CredentialLifecycleOperation,
+  CredentialLifecycleResultDto,
+  TokenObjectEvidenceDto,
+} from './lifecycle.dto.js';
+
+export interface MintedToken {
+  readonly secret: Uint8Array;
+  readonly evidence: TokenObjectEvidenceDto;
+}
+
+export interface GiteaLifecycleProvider {
+  readBasicIdentity(authority: ResolvedCredential): Promise<{
+    readonly login: string;
+    readonly endpoint: string;
+    readonly contentType: string;
+  }>;
+  mintToken(
+    authority: ResolvedCredential,
+    identity: string,
+    name: string,
+    scopes: readonly string[],
+  ): Promise<MintedToken>;
+  readToken(
+    authority: ResolvedCredential,
+    identity: string,
+    name: string,
+  ): Promise<TokenObjectEvidenceDto>;
+  revokeToken(authority: ResolvedCredential, identity: string, name: string): Promise<void>;
+  tokenExists(authority: ResolvedCredential, identity: string, name: string): Promise<boolean>;
+}
+
+export interface LifecycleRequest {
+  readonly identity: string;
+  readonly estate: string;
+  readonly host: string;
+}
+
+export interface ProvisionRequest extends LifecycleRequest {
+  readonly tokenName: string;
+  readonly scopes: readonly string[];
+}
+
+export interface LifecycleOptions {
+  readonly stateRoot: string;
+  readonly actor: string;
+  readonly now?: () => string;
+  readonly allowReplace?: boolean;
+  readonly journal?: CredentialAuditJournal;
+  readonly deferSuccessSeal?: boolean;
+}
+
+function lifecycleResult(
+  operation: CredentialLifecycleOperation,
+  request: LifecycleRequest,
+  options: {
+    readonly outcome: CredentialLifecycleResultDto['outcome'];
+    readonly mutation: CredentialLifecycleResultDto['mutation'];
+    readonly code: string;
+    readonly message: string;
+    readonly journalId: string | null;
+    readonly auditState: 'not-started' | 'open' | 'sealed';
+    readonly providerIdentity?: string | null;
+    readonly token?: TokenObjectEvidenceDto | null;
+    readonly teaLogin?: CredentialLifecycleResultDto['evidence']['teaLogin'];
+  },
+): CredentialLifecycleResultDto {
+  const exits = { ok: 0, refused: 10, error: 20, indeterminate: 30 } as const;
+  return {
+    schemaVersion: 1,
+    operation,
+    outcome: options.outcome,
+    exitCode: exits[options.outcome],
+    retryable: false,
+    subject: { ...request, repo: null },
+    mutation: options.mutation,
+    reason: { code: options.code, message: options.message },
+    evidence: {
+      providerIdentity: options.providerIdentity ?? null,
+      token: options.token ?? null,
+      teaLogin: options.teaLogin ?? null,
+      identities: [],
+      journalIds: [],
+    },
+    audit: { journalId: options.journalId, state: options.auditState },
+  };
+}
+
+async function openLifecycleJournal(
+  operation: 'provision' | 'rotate' | 'revoke',
+  request: LifecycleRequest,
+  options: LifecycleOptions,
+): Promise<CredentialAuditJournal> {
+  const journal = await CredentialAuditJournal.open(options.stateRoot, {
+    operation,
+    actor: options.actor,
+    identity: request.identity,
+    estate: request.estate,
+    host: request.host,
+    repo: null,
+  });
+  await journal.recordIntent(`${operation}-requested`);
+  return journal;
+}
+
+export async function provisionCredential(
+  request: ProvisionRequest,
+  authority: ResolvedCredential,
+  provider: GiteaLifecycleProvider,
+  store: FileCredentialStore,
+  teaStore: TeaLoginStore,
+  options: LifecycleOptions,
+): Promise<CredentialLifecycleResultDto> {
+  const journal = options.journal ?? (await openLifecycleJournal('provision', request, options));
+  let mutation: 'none' | 'unknown' | 'applied' = 'none';
+  let minted: MintedToken | undefined;
+  let failureCode = 'mutation-state-unknown';
+  const prior = await store.snapshot(request.identity, request.estate, request.host);
+  if (prior !== undefined && options.allowReplace !== true) {
+    await journal.seal('refused', 'credential-already-exists');
+    return lifecycleResult('provision', request, {
+      outcome: 'refused',
+      mutation: 'none',
+      code: 'credential-already-exists',
+      message: 'A governed credential already exists; use rotate.',
+      journalId: journal.journalId(),
+      auditState: 'sealed',
+    });
+  }
+  try {
+    const identity = await provider.readBasicIdentity(authority);
+    if (identity.login !== request.identity || authority.identity !== request.identity) {
+      await journal.seal('refused', 'provider-identity-mismatch');
+      return lifecycleResult('provision', request, {
+        outcome: 'refused',
+        mutation: 'none',
+        code: 'provider-identity-mismatch',
+        message: 'Delegated Basic authority did not bind the requested principal.',
+        journalId: journal.journalId(),
+        auditState: 'sealed',
+        providerIdentity: identity.login,
+      });
+    }
+    await journal.recordProviderEvidence({
+      endpoint: identity.endpoint,
+      contentType: identity.contentType,
+      decision: 'identity-verified',
+    });
+    mutation = 'unknown';
+    minted = await provider.mintToken(
+      authority,
+      request.identity,
+      request.tokenName,
+      request.scopes,
+    );
+    mutation = 'applied';
+    await journal.recordMutation('token-mint-applied');
+    const readBack = await provider.readToken(authority, request.identity, request.tokenName);
+    const expected = [...request.scopes].sort();
+    const actual = [...readBack.scopes].sort();
+    if (JSON.stringify(expected) !== JSON.stringify(actual)) {
+      failureCode = 'scope-not-evaluable';
+      throw new Error('scope read-back disagreed');
+    }
+    await store.put(
+      {
+        identity: request.identity,
+        estate: request.estate,
+        host: request.host,
+        providerLogin: identity.login,
+        tokenName: request.tokenName,
+        scopes: readBack.scopes,
+        createdAt: options.now?.() ?? new Date().toISOString(),
+      },
+      minted.secret,
+    );
+    await journal.recordMutation('token-binding-stored');
+    await teaStore.put(request.identity, request.host, minted.secret);
+    const teaLogin = teaStore.readBack(request.identity, request.host);
+    if (
+      teaLogin === undefined ||
+      !teaStore.matchesSecret(request.identity, request.host, minted.secret)
+    ) {
+      failureCode = 'tea-login-missing';
+      throw new Error('Tea login did not resolve exactly');
+    }
+    await journal.recordMutation('tea-login-stored');
+    await journal.recordProviderEvidence({
+      endpoint: readBack.endpoint,
+      contentType: readBack.contentType,
+      decision: 'scope-verified',
+    });
+    if (options.deferSuccessSeal !== true) {
+      await journal.seal('ok', 'provision-verified');
+    }
+    return lifecycleResult('provision', request, {
+      outcome: 'ok',
+      mutation: 'applied',
+      code: options.deferSuccessSeal === true ? 'replacement-staged' : 'provision-verified',
+      message:
+        options.deferSuccessSeal === true
+          ? 'Replacement was read back and staged under the open rotation transaction.'
+          : 'Provider principal and exact token scopes were read back and stored.',
+      journalId: journal.journalId(),
+      auditState: options.deferSuccessSeal === true ? 'open' : 'sealed',
+      providerIdentity: identity.login,
+      token: readBack,
+      teaLogin: { ...teaLogin, state: 'registered' },
+    });
+  } catch (error: unknown) {
+    const journalFailure = error instanceof CredentialJournalError;
+    if (minted === undefined) {
+      if (journalFailure) throw error;
+      await journal.seal('indeterminate', 'provider-unavailable');
+      return lifecycleResult('provision', request, {
+        outcome: 'indeterminate',
+        mutation,
+        code: 'provider-unavailable',
+        message: 'Provider token mint did not complete.',
+        journalId: journal.journalId(),
+        auditState: 'sealed',
+      });
+    }
+    let rollbackComplete = false;
+    try {
+      await provider.revokeToken(authority, request.identity, request.tokenName);
+      if (await provider.tokenExists(authority, request.identity, request.tokenName)) {
+        throw new Error('minted token still exists after rollback');
+      }
+      if (prior === undefined) {
+        await store.remove(request.identity, request.estate, request.host);
+        await teaStore.remove(request.identity, request.host).catch((): void => undefined);
+      } else {
+        await store.put(prior.binding, prior.secret);
+        await teaStore.put(request.identity, request.host, prior.secret);
+      }
+      rollbackComplete = true;
+    } catch {
+      rollbackComplete = false;
+    } finally {
+      prior?.secret.fill(0);
+    }
+    if (journalFailure) {
+      if (rollbackComplete) {
+        await journal.recordMutation('provision-rollback-verified').catch((): void => undefined);
+      }
+      throw error;
+    }
+    const code = rollbackComplete ? failureCode : 'rollback-incomplete';
+    if (rollbackComplete) await journal.recordMutation('provision-rollback-verified');
+    await journal.seal(rollbackComplete ? 'error' : 'indeterminate', code);
+    return lifecycleResult('provision', request, {
+      outcome: rollbackComplete ? 'error' : 'indeterminate',
+      mutation: rollbackComplete ? 'none' : mutation,
+      code,
+      message: rollbackComplete
+        ? 'Provisioning failed and every completed mutation was rolled back.'
+        : 'Provisioning failed and rollback could not be proven complete.',
+      journalId: journal.journalId(),
+      auditState: 'sealed',
+    });
+  } finally {
+    minted?.secret.fill(0);
+    prior?.secret.fill(0);
+  }
+}
+
+export async function revokeCredential(
+  request: LifecycleRequest,
+  authority: ResolvedCredential,
+  provider: GiteaLifecycleProvider,
+  store: FileCredentialStore,
+  teaStore: TeaLoginStore,
+  options: LifecycleOptions,
+): Promise<CredentialLifecycleResultDto> {
+  const journal = await openLifecycleJournal('revoke', request, options);
+  let mutation: 'none' | 'unknown' | 'applied' = 'none';
+  try {
+    const binding = await store.readBinding(request.identity, request.estate, request.host);
+    if (binding === undefined) {
+      await journal.seal('refused', 'no-token-for-identity');
+      return lifecycleResult('revoke', request, {
+        outcome: 'refused',
+        mutation: 'none',
+        code: 'no-token-for-identity',
+        message: 'No governed token binding exists for the identity.',
+        journalId: journal.journalId(),
+        auditState: 'sealed',
+      });
+    }
+    const identity = await provider.readBasicIdentity(authority);
+    if (identity.login !== request.identity || authority.identity !== request.identity) {
+      await journal.seal('refused', 'provider-identity-mismatch');
+      return lifecycleResult('revoke', request, {
+        outcome: 'refused',
+        mutation: 'none',
+        code: 'provider-identity-mismatch',
+        message: 'Delegated Basic authority did not bind the requested principal.',
+        journalId: journal.journalId(),
+        auditState: 'sealed',
+        providerIdentity: identity.login,
+      });
+    }
+    await journal.recordProviderEvidence({
+      endpoint: identity.endpoint,
+      contentType: identity.contentType,
+      decision: 'identity-verified',
+    });
+    mutation = 'unknown';
+    await provider.revokeToken(authority, request.identity, binding.tokenName);
+    mutation = 'applied';
+    await journal.recordMutation('token-revoke-applied');
+    if (await provider.tokenExists(authority, request.identity, binding.tokenName)) {
+      await journal.seal('indeterminate', 'revoke-readback-missing');
+      return lifecycleResult('revoke', request, {
+        outcome: 'indeterminate',
+        mutation,
+        code: 'revoke-readback-missing',
+        message: 'Provider still returned the token after revocation acknowledgement.',
+        journalId: journal.journalId(),
+        auditState: 'sealed',
+      });
+    }
+    await teaStore.remove(request.identity, request.host);
+    if (teaStore.readBack(request.identity, request.host) !== undefined) {
+      throw new Error('Tea login still exists after revocation');
+    }
+    await journal.recordMutation('tea-login-removed');
+    await store.remove(request.identity, request.estate, request.host, binding.tokenDigest);
+    await journal.seal('ok', 'revoke-verified');
+    return lifecycleResult('revoke', request, {
+      outcome: 'ok',
+      mutation,
+      code: 'revoke-verified',
+      message: 'Provider token revocation completed before local binding removal.',
+      journalId: journal.journalId(),
+      auditState: 'sealed',
+    });
+  } catch (error: unknown) {
+    if (error instanceof CredentialJournalError) {
+      return lifecycleResult('revoke', request, {
+        outcome: 'indeterminate',
+        mutation,
+        code: error.code,
+        message: 'Audit persistence failed; inspect the durable open journal before recovery.',
+        journalId: journal.journalId(),
+        auditState: 'open',
+      });
+    }
+    await journal.seal('indeterminate', 'mutation-state-unknown');
+    return lifecycleResult('revoke', request, {
+      outcome: 'indeterminate',
+      mutation,
+      code: 'mutation-state-unknown',
+      message: 'Revocation mutation state could not be established completely.',
+      journalId: journal.journalId(),
+      auditState: 'sealed',
+    });
+  }
+}

packages/mosaic/src/credentials/tea-login-store.spec.ts

@@ -0,0 +1,54 @@
+import { chmod, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { TeaLoginStore } from './tea-login-store.js';
+
+let root: string | undefined;
+afterEach(async (): Promise<void> => {
+  if (root !== undefined) await rm(root, { recursive: true, force: true });
+  root = undefined;
+});
+
+describe('host-bound Tea login store', (): void => {
+  it('serializes concurrent updates and preserves the same identity on two hosts', async (): Promise<void> => {
+    root = await mkdtemp(join(tmpdir(), 'mosaic-tea-store-'));
+    const store = new TeaLoginStore(join(root, 'tea', 'config.yml'));
+    await Promise.all([
+      store.put('seat', 'git.one.invalid', new TextEncoder().encode('token-one')),
+      store.put('seat', 'git.two.invalid', new TextEncoder().encode('token-two')),
+    ]);
+
+    expect(
+      store.matchesSecret('seat', 'git.one.invalid', new TextEncoder().encode('token-one')),
+    ).toBe(true);
+    expect(
+      store.matchesSecret('seat', 'git.two.invalid', new TextEncoder().encode('token-two')),
+    ).toBe(true);
+    await store.remove('seat', 'git.one.invalid');
+    expect(store.readBack('seat', 'git.one.invalid')).toBeUndefined();
+    expect(store.readBack('seat', 'git.two.invalid')).toEqual({
+      name: 'seat--git.two.invalid',
+      host: 'git.two.invalid',
+    });
+  });
+
+  it('preserves unrelated Tea configuration and rejects permissive secret reads', async (): Promise<void> => {
+    root = await mkdtemp(join(tmpdir(), 'mosaic-tea-store-'));
+    const configPath = join(root, 'tea', 'config.yml');
+    const store = new TeaLoginStore(configPath);
+    await store.put('seat', 'git.one.invalid', new TextEncoder().encode('token-one'));
+    const original = await readFile(configPath, 'utf8');
+    await writeFile(configPath, `preferences:\n  color: true\n${original}`, { mode: 0o600 });
+
+    await store.put('seat', 'git.two.invalid', new TextEncoder().encode('token-two'));
+    await store.remove('seat', 'git.one.invalid');
+    expect(await readFile(configPath, 'utf8')).toContain('color: true');
+
+    await chmod(configPath, 0o644);
+    expect(() => store.resolve('seat', 'homelab', 'git.two.invalid')).toThrow(
+      /tea-config-insecure/,
+    );
+    expect(() => store.readBack('seat', 'git.two.invalid')).toThrow(/tea-config-insecure/);
+  });
+});

packages/mosaic/src/credentials/tea-login-store.ts

@@ -0,0 +1,246 @@
+import { randomUUID, timingSafeEqual } from 'node:crypto';
+import { open, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { parse, stringify } from 'yaml';
+import { z } from 'zod';
+import { ensureManagedDirectory, readRegularFileSecure } from '../fleet/secure-file.js';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+
+const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+
+export class TeaLoginStoreError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+  ) {
+    super(`Tea login store rejected: code=${code} ${message}`);
+    this.name = 'TeaLoginStoreError';
+  }
+}
+
+interface TeaLoginRecord {
+  readonly name: string;
+  readonly url: string;
+  readonly token: string;
+  readonly user: string;
+  readonly default: boolean;
+}
+
+interface TeaConfig {
+  readonly logins: TeaLoginRecord[];
+  readonly [key: string]: unknown;
+}
+
+const loginSchema = z
+  .object({
+    name: z.string().regex(SAFE_NAME),
+    url: z.string().url(),
+    token: z.string().min(1),
+    user: z.string().regex(SAFE_NAME),
+    default: z.boolean().default(false),
+  })
+  .passthrough();
+const configSchema = z.object({ logins: z.array(loginSchema).default([]) }).passthrough();
+
+async function syncDirectory(path: string): Promise<void> {
+  const handle = await open(path, 'r');
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+
+async function acquireLock(path: string): Promise<Awaited<ReturnType<typeof open>>> {
+  for (let attempt = 0; attempt < 500; attempt += 1) {
+    try {
+      return await open(path, 'wx', 0o600);
+    } catch (error: unknown) {
+      if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST')) throw error;
+      await new Promise<void>((resolve): void => {
+        setTimeout(resolve, 10);
+      });
+    }
+  }
+  throw new TeaLoginStoreError(
+    'conflicting-credential-mutation',
+    'Tea configuration lock did not become available',
+  );
+}
+
+function loginName(identity: string, host: string): string {
+  return `${identity}--${host}`;
+}
+
+function assertPrivate(snapshot: { readonly mode: number; readonly uid: number }): void {
+  if ((snapshot.mode & 0o077) !== 0 || snapshot.uid !== process.getuid?.()) {
+    throw new TeaLoginStoreError('tea-config-insecure', 'Tea config is not private');
+  }
+}
+
+function missing(error: unknown): boolean {
+  return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+
+export class TeaLoginStore {
+  constructor(private readonly configPath: string) {}
+
+  async put(identity: string, host: string, secret: Uint8Array): Promise<void> {
+    if (!SAFE_NAME.test(identity) || !/^[a-z0-9][a-z0-9.-]*$/.test(host)) {
+      throw new TeaLoginStoreError('invalid-input', 'identity or host is outside the grammar');
+    }
+    const directory = dirname(this.configPath);
+    ensureManagedDirectory(directory, directory);
+    const lockPath = `${this.configPath}.lock`;
+    const lock = await acquireLock(lockPath);
+    try {
+      let current: TeaConfig = { logins: [] };
+      try {
+        const snapshot = readRegularFileSecure(this.configPath, {
+          root: directory,
+          maxBytes: 1024 * 1024,
+        });
+        assertPrivate(snapshot);
+        const decoded = configSchema.safeParse(parse(snapshot.content.toString('utf8')));
+        if (!decoded.success) {
+          throw new TeaLoginStoreError('tea-config-invalid', 'Tea config failed schema validation');
+        }
+        current = decoded.data;
+      } catch (error: unknown) {
+        if (!missing(error)) throw error;
+      }
+      const token = Buffer.from(secret).toString('utf8');
+      const record: TeaLoginRecord = {
+        name: loginName(identity, host),
+        url: `https://${host}`,
+        token,
+        user: identity,
+        default: false,
+      };
+      const logins = current.logins.filter(
+        (login): boolean =>
+          !(login.name === loginName(identity, host) && login.url === `https://${host}`),
+      );
+      logins.push(record);
+      const temp = `${this.configPath}.${randomUUID()}.tmp`;
+      const handle = await open(temp, 'wx', 0o600);
+      try {
+        await handle.writeFile(stringify({ ...current, logins }), 'utf8');
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temp, this.configPath);
+      await syncDirectory(directory);
+    } finally {
+      await lock.close();
+      await unlink(lockPath).catch((): void => undefined);
+    }
+  }
+
+  resolve(identity: string, estate: string, host: string): ResolvedCredential | undefined {
+    const directory = dirname(this.configPath);
+    let snapshot;
+    try {
+      snapshot = readRegularFileSecure(this.configPath, {
+        root: directory,
+        maxBytes: 1024 * 1024,
+      });
+    } catch (error: unknown) {
+      if (missing(error)) return undefined;
+      throw error;
+    }
+    assertPrivate(snapshot);
+    const decoded = configSchema.safeParse(parse(snapshot.content.toString('utf8')));
+    if (!decoded.success) return undefined;
+    const matches = decoded.data.logins.filter(
+      (login): boolean =>
+        login.name === loginName(identity, host) &&
+        login.url === `https://${host}` &&
+        login.user === identity,
+    );
+    if (matches.length !== 1 || matches[0] === undefined) return undefined;
+    return Object.freeze({
+      identity,
+      estate,
+      host,
+      resolutionId: randomUUID(),
+      secret: new TextEncoder().encode(matches[0].token),
+    });
+  }
+
+  matchesSecret(identity: string, host: string, secret: Uint8Array): boolean {
+    const resolved = this.resolve(identity, 'binding-check', host);
+    if (resolved === undefined || resolved.secret.byteLength !== secret.byteLength) return false;
+    return timingSafeEqual(Buffer.from(resolved.secret), Buffer.from(secret));
+  }
+
+  async remove(identity: string, host: string): Promise<void> {
+    const directory = dirname(this.configPath);
+    const lockPath = `${this.configPath}.lock`;
+    const lock = await acquireLock(lockPath);
+    try {
+      const snapshot = readRegularFileSecure(this.configPath, {
+        root: directory,
+        maxBytes: 1024 * 1024,
+      });
+      assertPrivate(snapshot);
+      const decoded = configSchema.safeParse(parse(snapshot.content.toString('utf8')));
+      if (!decoded.success) {
+        throw new TeaLoginStoreError('tea-config-invalid', 'Tea config failed schema validation');
+      }
+      const logins = decoded.data.logins.filter(
+        (login): boolean =>
+          !(login.name === loginName(identity, host) && login.url === `https://${host}`),
+      );
+      const temp = `${this.configPath}.${randomUUID()}.tmp`;
+      const handle = await open(temp, 'wx', 0o600);
+      try {
+        await handle.writeFile(stringify({ ...decoded.data, logins }), 'utf8');
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temp, this.configPath);
+      await syncDirectory(directory);
+    } finally {
+      await lock.close();
+      await unlink(lockPath).catch((): void => undefined);
+    }
+  }
+
+  readBack(
+    identity: string,
+    host: string,
+  ): { readonly name: string; readonly host: string } | undefined {
+    const directory = dirname(this.configPath);
+    let snapshot;
+    try {
+      snapshot = readRegularFileSecure(this.configPath, { root: directory, maxBytes: 1024 * 1024 });
+    } catch (error: unknown) {
+      if (missing(error)) return undefined;
+      throw error;
+    }
+    assertPrivate(snapshot);
+    const decoded: unknown = parse(snapshot.content.toString('utf8'));
+    if (
+      typeof decoded !== 'object' ||
+      decoded === null ||
+      !('logins' in decoded) ||
+      !Array.isArray(decoded.logins)
+    )
+      return undefined;
+    const matches = decoded.logins.filter((value: unknown): value is TeaLoginRecord => {
+      if (typeof value !== 'object' || value === null) return false;
+      return (
+        'name' in value &&
+        value.name === loginName(identity, host) &&
+        'url' in value &&
+        value.url === `https://${host}` &&
+        'user' in value &&
+        value.user === identity
+      );
+    });
+    return matches.length === 1 ? { name: loginName(identity, host), host } : undefined;
+  }
+}

packages/mosaic/src/credentials/team-grant.spec.ts

@@ -0,0 +1,613 @@
+import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { grantTeamRepositoryPermission, type GiteaTeamGrantProvider } from './team-grant.js';
+import type { ResolvedCredential } from './credential-provider.dto.js';
+import type { CredentialValidationDependencies } from './validate.js';
+
+let cleanup: string | undefined;
+afterEach(async (): Promise<void> => {
+  if (cleanup !== undefined) await rm(cleanup, { recursive: true, force: true });
+  cleanup = undefined;
+});
+
+const authority: ResolvedCredential = Object.freeze({
+  identity: 'provisioner',
+  estate: 'homelab',
+  host: 'git.example.invalid',
+  resolutionId: 'authority',
+  secret: new TextEncoder().encode('authority-canary'),
+});
+const subject: ResolvedCredential = Object.freeze({
+  identity: 'seat-name',
+  estate: 'homelab',
+  host: 'git.example.invalid',
+  resolutionId: 'subject',
+  secret: new TextEncoder().encode('subject-canary'),
+});
+const control: ResolvedCredential = Object.freeze({
+  identity: 'read-control',
+  estate: 'homelab',
+  host: 'git.example.invalid',
+  resolutionId: 'control',
+  secret: new TextEncoder().encode('control-canary'),
+});
+
+function validation(): CredentialValidationDependencies {
+  return {
+    estateRegistry: { matches: (): boolean => true },
+    resolver: {
+      async resolve(identity: string) {
+        return identity === 'seat-name' ? subject : control;
+      },
+    },
+    provider: {
+      async readIdentity(resolved: ResolvedCredential) {
+        return {
+          login: resolved.identity,
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async readRepositoryPermission(resolved: ResolvedCredential) {
+        return {
+          effective: resolved.identity === 'seat-name' ? 'write' : 'read',
+          endpoint: 'GET /api/v1/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async probeReceivePack(resolved: ResolvedCredential | undefined) {
+        const write = resolved?.identity === 'seat-name';
+        return {
+          state: write ? 'advertised' : 'refused',
+          principal: resolved?.identity ?? null,
+          resolutionId: resolved?.resolutionId ?? null,
+          contentType: write ? 'application/x-git-receive-pack-advertisement' : 'text/plain',
+        };
+      },
+    },
+  };
+}
+
+describe('team repository grant', (): void => {
+  it('reads team permission, org membership, member attachment, repo attachment, and effective subject permission', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-team-grant-'));
+    let repositoryReads = 0;
+    const provider: GiteaTeamGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async resolveTeam() {
+        return {
+          id: 7,
+          name: 'writers',
+          permission: 'write',
+          endpoint: 'GET /api/v1/orgs/owner/teams',
+          contentType: 'application/json',
+        };
+      },
+      async listTeamRepositories() {
+        repositoryReads += 1;
+        return {
+          repositories: repositoryReads === 1 ? [] : ['owner/repo'],
+          endpoint: 'GET /api/v1/teams/7/repos',
+          contentType: 'application/json',
+        };
+      },
+      async addTeamMember(): Promise<void> {},
+      async removeTeamMember(): Promise<void> {},
+      async attachTeamRepository(): Promise<void> {},
+      async detachTeamRepository(): Promise<void> {},
+      async readTeamMember() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/teams/7/members/seat-name',
+          contentType: 'application/json',
+        };
+      },
+      async readTeamRepository() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/teams/7/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const result = await grantTeamRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        team: 'writers',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validation(),
+      { stateRoot: join(cleanup, 'state'), actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('ok');
+    expect(result.evidence.organizationMembership?.state).toBe('present');
+    expect(result.evidence.teamMembership?.state).toBe('present');
+    expect(result.evidence.teamRepository?.state).toBe('present');
+  });
+
+  it('refuses a shared team already attached to any repository outside the request', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-team-grant-'));
+    let mutated = false;
+    const provider: GiteaTeamGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async resolveTeam() {
+        return {
+          id: 7,
+          name: 'writers',
+          permission: 'write',
+          endpoint: 'GET /api/v1/orgs/owner/teams',
+          contentType: 'application/json',
+        };
+      },
+      async listTeamRepositories() {
+        return {
+          repositories: ['owner/unrelated'],
+          endpoint: 'GET /api/v1/teams/7/repos',
+          contentType: 'application/json',
+        };
+      },
+      async addTeamMember(): Promise<void> {
+        mutated = true;
+      },
+      async removeTeamMember(): Promise<void> {
+        mutated = true;
+      },
+      async attachTeamRepository(): Promise<void> {
+        mutated = true;
+      },
+      async detachTeamRepository(): Promise<void> {
+        mutated = true;
+      },
+      async readTeamMember() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/teams/7/members/seat-name',
+          contentType: 'application/json',
+        };
+      },
+      async readTeamRepository() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/teams/7/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const result = await grantTeamRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        team: 'writers',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validation(),
+      { stateRoot: join(cleanup, 'state'), actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('team-scope-exceeds-request');
+    expect(mutated).toBe(false);
+  });
+
+  it('journals absent team objects as absent rather than present', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-team-grant-'));
+    let repositoryReads = 0;
+    const provider: GiteaTeamGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async resolveTeam() {
+        return {
+          id: 7,
+          name: 'writers',
+          permission: 'write',
+          endpoint: 'GET /api/v1/orgs/owner/teams',
+          contentType: 'application/json',
+        };
+      },
+      async listTeamRepositories() {
+        repositoryReads += 1;
+        return {
+          repositories: repositoryReads === 1 ? [] : ['owner/repo'],
+          endpoint: 'GET /api/v1/teams/7/repos',
+          contentType: 'application/json',
+        };
+      },
+      async addTeamMember(): Promise<void> {},
+      async removeTeamMember(): Promise<void> {},
+      async attachTeamRepository(): Promise<void> {},
+      async detachTeamRepository(): Promise<void> {},
+      async readTeamMember() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/teams/7/members/seat-name',
+          contentType: 'application/json',
+        };
+      },
+      async readTeamRepository() {
+        return {
+          state: 'absent',
+          endpoint: 'GET /api/v1/teams/7/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const stateRoot = join(cleanup, 'state');
+    const result = await grantTeamRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        team: 'writers',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validation(),
+      { stateRoot, actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    const [journalName] = await readdir(join(stateRoot, 'journals'));
+    const journal = await readFile(join(stateRoot, 'journals', journalName!), 'utf8');
+    expect(journal).toContain('team-member-absent');
+    expect(journal).toContain('team-repository-absent');
+    expect(journal).not.toContain('"decision":"team-member-present"');
+    expect(journal).not.toContain('"decision":"team-repository-present"');
+  });
+
+  it('fails closed and removes newly added membership when team scope changes during mutation', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-team-grant-'));
+    let repositoryReads = 0;
+    let membershipReads = 0;
+    let removed = false;
+    let detached = false;
+    const provider: GiteaTeamGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async resolveTeam() {
+        return {
+          id: 7,
+          name: 'writers',
+          permission: 'write',
+          endpoint: 'GET /api/v1/orgs/owner/teams',
+          contentType: 'application/json',
+        };
+      },
+      async listTeamRepositories() {
+        repositoryReads += 1;
+        return {
+          repositories: repositoryReads === 1 ? [] : ['owner/repo', 'owner/concurrent-attachment'],
+          endpoint: 'GET /api/v1/teams/7/repos',
+          contentType: 'application/json',
+        };
+      },
+      async addTeamMember(): Promise<void> {},
+      async removeTeamMember(): Promise<void> {
+        removed = true;
+      },
+      async attachTeamRepository(): Promise<void> {},
+      async detachTeamRepository(): Promise<void> {
+        detached = true;
+      },
+      async readTeamMember() {
+        membershipReads += 1;
+        return {
+          state: membershipReads === 1 || removed ? 'absent' : 'present',
+          endpoint: 'GET /api/v1/teams/7/members/seat-name',
+          contentType: 'application/json',
+        };
+      },
+      async readTeamRepository() {
+        return {
+          state: detached ? 'absent' : 'present',
+          endpoint: 'GET /api/v1/teams/7/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const stateRoot = join(cleanup, 'state');
+    const result = await grantTeamRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        team: 'writers',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validation(),
+      { stateRoot, actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('team-scope-changed-during-grant');
+    expect(result.evidence.teamRepositorySet?.repositories).toEqual([
+      'owner/repo',
+      'owner/concurrent-attachment',
+    ]);
+    expect(removed).toBe(true);
+    expect(detached).toBe(true);
+    const [journalName] = await readdir(join(stateRoot, 'journals'));
+    const journal = await readFile(join(stateRoot, 'journals', journalName!), 'utf8');
+    expect(journal.indexOf('team-member-absent')).toBeLessThan(
+      journal.indexOf('team-member-applied'),
+    );
+    expect(journal).toContain('team-repository-rollback-applied');
+    expect(journal).toContain('team-repository-absent');
+  });
+
+  it('compensates provider changes when repository attachment fails after applying', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-team-grant-'));
+    let memberPresent = false;
+    let repositoryPresent = false;
+    let memberRemoved = false;
+    let repositoryDetached = false;
+    const provider: GiteaTeamGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async resolveTeam() {
+        return {
+          id: 7,
+          name: 'writers',
+          permission: 'write',
+          endpoint: 'GET /api/v1/orgs/owner/teams',
+          contentType: 'application/json',
+        };
+      },
+      async listTeamRepositories() {
+        return {
+          repositories: repositoryPresent ? ['owner/repo'] : [],
+          endpoint: 'GET /api/v1/teams/7/repos',
+          contentType: 'application/json',
+        };
+      },
+      async addTeamMember(): Promise<void> {
+        memberPresent = true;
+      },
+      async removeTeamMember(): Promise<void> {
+        memberPresent = false;
+        memberRemoved = true;
+      },
+      async attachTeamRepository(): Promise<void> {
+        repositoryPresent = true;
+        throw new Error('provider response lost after attachment');
+      },
+      async detachTeamRepository(): Promise<void> {
+        repositoryPresent = false;
+        repositoryDetached = true;
+      },
+      async readTeamMember() {
+        return {
+          state: memberPresent ? 'present' : 'absent',
+          endpoint: 'GET /api/v1/teams/7/members/seat-name',
+          contentType: 'application/json',
+        };
+      },
+      async readTeamRepository() {
+        return {
+          state: repositoryPresent ? 'present' : 'absent',
+          endpoint: 'GET /api/v1/teams/7/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+
+    const result = await grantTeamRepositoryPermission(
+      {
+        identity: 'seat-name',
+        estate: 'homelab',
+        host: 'git.example.invalid',
+        repo: 'owner/repo',
+        permission: 'write',
+        team: 'writers',
+        readOnlyControlIdentity: 'read-control',
+      },
+      authority,
+      provider,
+      validation(),
+      { stateRoot: join(cleanup, 'state'), actor: 'provisioner' },
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(memberPresent).toBe(false);
+    expect(repositoryPresent).toBe(false);
+    expect(memberRemoved).toBe(true);
+    expect(repositoryDetached).toBe(true);
+  });
+
+  it('refuses a second governed mutation while the same team lock is held', async (): Promise<void> => {
+    cleanup = await mkdtemp(join(tmpdir(), 'mosaic-team-grant-'));
+    let releaseFirst!: () => void;
+    const firstMayFinish = new Promise<void>((resolve): void => {
+      releaseFirst = resolve;
+    });
+    let markFirstEntered!: () => void;
+    const firstEntered = new Promise<void>((resolve): void => {
+      markFirstEntered = resolve;
+    });
+    let addCalls = 0;
+    let memberAdded = false;
+    let repositoryAttached = false;
+    const provider: GiteaTeamGrantProvider = {
+      async readBasicIdentity() {
+        return {
+          login: 'provisioner',
+          endpoint: 'GET /api/v1/user',
+          contentType: 'application/json',
+        };
+      },
+      async resolveTeam() {
+        return {
+          id: 7,
+          name: 'writers',
+          permission: 'write',
+          endpoint: 'GET /api/v1/orgs/owner/teams',
+          contentType: 'application/json',
+        };
+      },
+      async listTeamRepositories() {
+        return {
+          repositories: repositoryAttached ? ['owner/repo'] : [],
+          endpoint: 'GET /api/v1/teams/7/repos',
+          contentType: 'application/json',
+        };
+      },
+      async addTeamMember(): Promise<void> {
+        addCalls += 1;
+        markFirstEntered();
+        await firstMayFinish;
+        memberAdded = true;
+      },
+      async removeTeamMember(): Promise<void> {
+        memberAdded = false;
+      },
+      async attachTeamRepository(): Promise<void> {
+        repositoryAttached = true;
+      },
+      async detachTeamRepository(): Promise<void> {
+        repositoryAttached = false;
+      },
+      async readTeamMember() {
+        return {
+          state: memberAdded ? 'present' : 'absent',
+          endpoint: 'GET /api/v1/teams/7/members/seat-name',
+          contentType: 'application/json',
+        };
+      },
+      async readTeamRepository() {
+        return {
+          state: repositoryAttached ? 'present' : 'absent',
+          endpoint: 'GET /api/v1/teams/7/repos/owner/repo',
+          contentType: 'application/json',
+        };
+      },
+      async readOrganizationMembership() {
+        return {
+          state: 'present',
+          endpoint: 'GET /api/v1/users/seat-name/orgs',
+          contentType: 'application/json',
+        };
+      },
+    };
+    const request = {
+      identity: 'seat-name',
+      estate: 'homelab',
+      host: 'git.example.invalid',
+      repo: 'owner/repo',
+      permission: 'write' as const,
+      team: 'writers',
+      readOnlyControlIdentity: 'read-control',
+    };
+    const options = { stateRoot: join(cleanup, 'state-one'), actor: 'provisioner' };
+    const secondOptions = { stateRoot: join(cleanup, 'state-two'), actor: 'provisioner' };
+
+    const first = grantTeamRepositoryPermission(
+      request,
+      authority,
+      provider,
+      validation(),
+      options,
+    );
+    await firstEntered;
+    const second = await grantTeamRepositoryPermission(
+      request,
+      authority,
+      provider,
+      validation(),
+      secondOptions,
+    );
+    releaseFirst();
+    const completedFirst = await first;
+
+    expect(completedFirst.outcome).toBe('ok');
+    expect(second.outcome).toBe('indeterminate');
+    expect(second.reason.code).toBe('concurrent-mutation');
+    expect(second.mutation).toBe('none');
+    expect(addCalls).toBe(1);
+  });
+});

packages/mosaic/src/credentials/team-grant.ts

@@ -0,0 +1,524 @@
+import { spawnSync } from 'node:child_process';
+import { constants, lstatSync } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ensureManagedDirectory } from '../fleet/secure-file.js';
+import { CredentialAuditJournal, CredentialJournalError } from './audit-journal.js';
+import type {
+  CredentialValidationDependencies,
+  ResolvedCredential,
+} from './credential-provider.dto.js';
+import type {
+  CredentialGrantResultDto,
+  DirectGrantRequestDto,
+  OrganizationMembershipEvidenceDto,
+} from './grant.dto.js';
+import type { RepositoryPermission } from './credential-result.dto.js';
+import { CredentialGrantExecutionError } from './grant.js';
+import { evaluateGiteaReadValidation, evaluateGiteaWriteValidation } from './validate.js';
+
+export interface TeamResolutionEvidence {
+  readonly id: number;
+  readonly name: string;
+  readonly permission: RepositoryPermission;
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+export interface PresenceEvidence {
+  readonly state: 'present' | 'absent';
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+export interface TeamRepositorySetEvidence {
+  readonly repositories: readonly string[];
+  readonly endpoint: string;
+  readonly contentType: string;
+}
+export interface TeamGrantRequest extends DirectGrantRequestDto {
+  readonly team: string;
+}
+export interface TeamGrantResult extends CredentialGrantResultDto {
+  readonly evidence: CredentialGrantResultDto['evidence'] & {
+    readonly team: TeamResolutionEvidence | null;
+    readonly teamMembership: PresenceEvidence | null;
+    readonly teamRepository: PresenceEvidence | null;
+    readonly teamRepositorySet: TeamRepositorySetEvidence | null;
+  };
+}
+export interface GiteaTeamGrantProvider {
+  readBasicIdentity(
+    authority: ResolvedCredential,
+  ): Promise<{ readonly login: string; readonly endpoint: string; readonly contentType: string }>;
+  resolveTeam(
+    authority: ResolvedCredential,
+    organization: string,
+    team: string,
+  ): Promise<TeamResolutionEvidence>;
+  listTeamRepositories(
+    authority: ResolvedCredential,
+    teamId: number,
+  ): Promise<TeamRepositorySetEvidence>;
+  addTeamMember(authority: ResolvedCredential, teamId: number, identity: string): Promise<void>;
+  removeTeamMember(authority: ResolvedCredential, teamId: number, identity: string): Promise<void>;
+  attachTeamRepository(authority: ResolvedCredential, teamId: number, repo: string): Promise<void>;
+  detachTeamRepository(authority: ResolvedCredential, teamId: number, repo: string): Promise<void>;
+  readTeamMember(
+    authority: ResolvedCredential,
+    teamId: number,
+    identity: string,
+  ): Promise<PresenceEvidence>;
+  readTeamRepository(
+    authority: ResolvedCredential,
+    teamId: number,
+    repo: string,
+  ): Promise<PresenceEvidence>;
+  readOrganizationMembership(
+    subject: ResolvedCredential,
+    organization: string,
+  ): Promise<OrganizationMembershipEvidenceDto>;
+}
+export interface TeamGrantOptions {
+  readonly stateRoot: string;
+  readonly actor: string;
+}
+
+class TeamGrantLockError extends Error {
+  constructor(public readonly code: 'concurrent-mutation' | 'mutation-lock-unavailable') {
+    super(code);
+  }
+}
+
+async function acquireTeamGrantLock(
+  estate: string,
+  host: string,
+  teamId: number,
+): Promise<() => Promise<void>> {
+  const uid = process.getuid?.();
+  if (uid === undefined) throw new TeamGrantLockError('mutation-lock-unavailable');
+  const locksDirectory = `/tmp/mosaic-cred-team-locks-${uid.toString()}`;
+  ensureManagedDirectory(locksDirectory, locksDirectory);
+  const directory = lstatSync(locksDirectory);
+  if (
+    !directory.isDirectory() ||
+    directory.isSymbolicLink() ||
+    directory.uid !== uid ||
+    (directory.mode & 0o077) !== 0
+  ) {
+    throw new TeamGrantLockError('mutation-lock-unavailable');
+  }
+  const lockPath = join(locksDirectory, `${estate}--${host}--team-${teamId.toString()}.lock`);
+  let handle: Awaited<ReturnType<typeof open>>;
+  try {
+    handle = await open(
+      lockPath,
+      constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW,
+      0o600,
+    );
+  } catch {
+    throw new TeamGrantLockError('mutation-lock-unavailable');
+  }
+  try {
+    const file = await handle.stat();
+    if (!file.isFile() || file.uid !== uid || (file.mode & 0o077) !== 0) {
+      throw new Error('team mutation lock file is unsafe');
+    }
+  } catch {
+    await handle.close().catch((): void => undefined);
+    throw new TeamGrantLockError('mutation-lock-unavailable');
+  }
+  // The child's fd 3 is a dup of the parent's open file description. Linux
+  // flock(2) associates the lock with that description, so it remains held
+  // after the helper exits until this process closes `handle` below.
+  const acquired = spawnSync('/usr/bin/flock', ['-n', '3'], {
+    stdio: ['ignore', 'ignore', 'ignore', handle.fd],
+  });
+  if (acquired.error !== undefined || acquired.status !== 0) {
+    await handle.close().catch((): void => undefined);
+    throw new TeamGrantLockError(
+      acquired.status === 1 ? 'concurrent-mutation' : 'mutation-lock-unavailable',
+    );
+  }
+  return async (): Promise<void> => {
+    await handle.close();
+  };
+}
+
+export async function grantTeamRepositoryPermission(
+  request: TeamGrantRequest,
+  authority: ResolvedCredential,
+  provider: GiteaTeamGrantProvider,
+  dependencies: CredentialValidationDependencies,
+  options: TeamGrantOptions,
+): Promise<TeamGrantResult> {
+  const journal = await CredentialAuditJournal.open(options.stateRoot, {
+    operation: 'grant',
+    actor: options.actor,
+    identity: request.identity,
+    estate: request.estate,
+    host: request.host,
+    repo: request.repo,
+  });
+  await journal.recordIntent('provider-grant');
+  let mutation: 'none' | 'unknown' | 'applied' = 'none';
+  let releaseTeamLock: (() => Promise<void>) | undefined;
+  let rollbackTeam: TeamResolutionEvidence | undefined;
+  let membershipBeforeMutation: PresenceEvidence | undefined;
+  let repositoryAttachedBeforeMutation = false;
+  let memberMutationAttempted = false;
+  let repositoryMutationAttempted = false;
+  try {
+    const authorityIdentity = await provider.readBasicIdentity(authority);
+    const organization = request.repo.split('/')[0] ?? '';
+    const team = await provider.resolveTeam(authority, organization, request.team);
+    rollbackTeam = team;
+    if (authorityIdentity.login !== options.actor || team.permission !== request.permission) {
+      await journal.seal('refused', 'provider-identity-mismatch');
+      return result(
+        request,
+        journal,
+        'refused',
+        'none',
+        'provider-identity-mismatch',
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+      );
+    }
+    await journal.recordProviderEvidence({
+      endpoint: authorityIdentity.endpoint,
+      contentType: authorityIdentity.contentType,
+      decision: 'identity-verified',
+    });
+    await journal.recordProviderEvidence({
+      endpoint: team.endpoint,
+      contentType: team.contentType,
+      decision: `permission-${team.permission}`,
+    });
+    try {
+      releaseTeamLock = await acquireTeamGrantLock(request.estate, request.host, team.id);
+    } catch (error: unknown) {
+      if (!(error instanceof TeamGrantLockError)) throw error;
+      await journal.seal('indeterminate', error.code);
+      return result(
+        request,
+        journal,
+        'indeterminate',
+        'none',
+        error.code,
+        null,
+        team,
+        null,
+        null,
+        null,
+        null,
+      );
+    }
+    const teamRepositorySet = await provider.listTeamRepositories(authority, team.id);
+    await journal.recordProviderEvidence({
+      endpoint: teamRepositorySet.endpoint,
+      contentType: teamRepositorySet.contentType,
+      decision: 'team-repository-set-verified',
+    });
+    if (teamRepositorySet.repositories.some((repo): boolean => repo !== request.repo)) {
+      await journal.seal('refused', 'team-scope-exceeds-request');
+      return result(
+        request,
+        journal,
+        'refused',
+        'none',
+        'team-scope-exceeds-request',
+        null,
+        team,
+        null,
+        null,
+        null,
+        teamRepositorySet,
+      );
+    }
+    const repositoryAttachedBefore = teamRepositorySet.repositories.includes(request.repo);
+    repositoryAttachedBeforeMutation = repositoryAttachedBefore;
+    const membershipBefore = await provider.readTeamMember(authority, team.id, request.identity);
+    membershipBeforeMutation = membershipBefore;
+    await journal.recordProviderEvidence({
+      endpoint: membershipBefore.endpoint,
+      contentType: membershipBefore.contentType,
+      decision: membershipBefore.state === 'present' ? 'team-member-present' : 'team-member-absent',
+    });
+    mutation = 'unknown';
+    memberMutationAttempted = true;
+    await provider.addTeamMember(authority, team.id, request.identity);
+    mutation = 'applied';
+    await journal.recordMutation('team-member-applied');
+    repositoryMutationAttempted = true;
+    await provider.attachTeamRepository(authority, team.id, request.repo);
+    await journal.recordMutation('team-repository-applied');
+    let teamMembership = await provider.readTeamMember(authority, team.id, request.identity);
+    let teamRepository = await provider.readTeamRepository(authority, team.id, request.repo);
+    const finalTeamRepositorySet = await provider.listTeamRepositories(authority, team.id);
+    await journal.recordProviderEvidence({
+      endpoint: teamMembership.endpoint,
+      contentType: teamMembership.contentType,
+      decision: teamMembership.state === 'present' ? 'team-member-present' : 'team-member-absent',
+    });
+    await journal.recordProviderEvidence({
+      endpoint: teamRepository.endpoint,
+      contentType: teamRepository.contentType,
+      decision:
+        teamRepository.state === 'present' ? 'team-repository-present' : 'team-repository-absent',
+    });
+    await journal.recordProviderEvidence({
+      endpoint: finalTeamRepositorySet.endpoint,
+      contentType: finalTeamRepositorySet.contentType,
+      decision: 'team-repository-set-verified',
+    });
+    const scopeRemainedExact =
+      finalTeamRepositorySet.repositories.length === 1 &&
+      finalTeamRepositorySet.repositories[0] === request.repo;
+    if (!scopeRemainedExact) {
+      if (membershipBefore.state === 'absent') {
+        await provider.removeTeamMember(authority, team.id, request.identity);
+        await journal.recordMutation('team-member-rollback-applied');
+        teamMembership = await provider.readTeamMember(authority, team.id, request.identity);
+        await journal.recordProviderEvidence({
+          endpoint: teamMembership.endpoint,
+          contentType: teamMembership.contentType,
+          decision:
+            teamMembership.state === 'present' ? 'team-member-present' : 'team-member-absent',
+        });
+        if (teamMembership.state !== 'absent') throw new Error('team member rollback disagreed');
+      }
+      if (!repositoryAttachedBefore) {
+        await provider.detachTeamRepository(authority, team.id, request.repo);
+        await journal.recordMutation('team-repository-rollback-applied');
+        teamRepository = await provider.readTeamRepository(authority, team.id, request.repo);
+        await journal.recordProviderEvidence({
+          endpoint: teamRepository.endpoint,
+          contentType: teamRepository.contentType,
+          decision:
+            teamRepository.state === 'present'
+              ? 'team-repository-present'
+              : 'team-repository-absent',
+        });
+        if (teamRepository.state !== 'absent') {
+          throw new Error('team repository rollback disagreed');
+        }
+      }
+      await journal.seal('indeterminate', 'team-scope-changed-during-grant');
+      return result(
+        request,
+        journal,
+        'indeterminate',
+        'applied',
+        'team-scope-changed-during-grant',
+        null,
+        team,
+        teamMembership,
+        teamRepository,
+        null,
+        finalTeamRepositorySet,
+      );
+    }
+    const subject = await dependencies.resolver.resolve(
+      request.identity,
+      request.estate,
+      request.host,
+    );
+    const organizationMembership =
+      subject === undefined
+        ? null
+        : await provider.readOrganizationMembership(subject, organization);
+    const validation =
+      request.permission === 'read'
+        ? await evaluateGiteaReadValidation(request, dependencies)
+        : await evaluateGiteaWriteValidation(request, dependencies);
+    if (organizationMembership !== null) {
+      await journal.recordProviderEvidence({
+        endpoint: organizationMembership.endpoint,
+        contentType: organizationMembership.contentType,
+        decision:
+          organizationMembership.state === 'present'
+            ? 'organization-member-present'
+            : 'organization-member-absent',
+      });
+    }
+    if (validation.evidence.providerIdentity !== null) {
+      await journal.recordProviderEvidence({
+        endpoint: validation.evidence.providerIdentity.endpoint,
+        contentType: validation.evidence.providerIdentity.contentType,
+        decision: 'identity-verified',
+      });
+    }
+    if (validation.evidence.repositoryPermission !== null) {
+      await journal.recordProviderEvidence({
+        endpoint: validation.evidence.repositoryPermission.endpoint,
+        contentType: validation.evidence.repositoryPermission.contentType,
+        decision: `permission-${validation.evidence.repositoryPermission.effective}`,
+      });
+    }
+    if (validation.evidence.writeDifferential !== null) {
+      await journal.recordMutation('transport-write-verified');
+    }
+    const ok =
+      teamMembership.state === 'present' &&
+      teamRepository.state === 'present' &&
+      organizationMembership?.state === 'present' &&
+      validation.outcome === 'ok' &&
+      validation.evidence.repositoryPermission?.effective === request.permission;
+    await journal.seal(
+      ok ? 'ok' : 'indeterminate',
+      ok ? 'grant-verified' : 'permission-evidence-disagrees',
+    );
+    return result(
+      request,
+      journal,
+      ok ? 'ok' : 'indeterminate',
+      'applied',
+      ok ? 'grant-verified' : 'permission-evidence-disagrees',
+      validation,
+      team,
+      teamMembership,
+      teamRepository,
+      organizationMembership,
+      finalTeamRepositorySet,
+    );
+  } catch (error: unknown) {
+    let compensationError: unknown;
+    try {
+      if (
+        rollbackTeam !== undefined &&
+        membershipBeforeMutation?.state === 'absent' &&
+        memberMutationAttempted
+      ) {
+        let current = await provider.readTeamMember(authority, rollbackTeam.id, request.identity);
+        if (current.state === 'present') {
+          await provider.removeTeamMember(authority, rollbackTeam.id, request.identity);
+          await journal.recordMutation('team-member-rollback-applied');
+          current = await provider.readTeamMember(authority, rollbackTeam.id, request.identity);
+          await journal.recordProviderEvidence({
+            endpoint: current.endpoint,
+            contentType: current.contentType,
+            decision: current.state === 'present' ? 'team-member-present' : 'team-member-absent',
+          });
+          if (current.state !== 'absent') throw new Error('team member rollback disagreed');
+        }
+      }
+      if (
+        rollbackTeam !== undefined &&
+        !repositoryAttachedBeforeMutation &&
+        repositoryMutationAttempted
+      ) {
+        let current = await provider.readTeamRepository(authority, rollbackTeam.id, request.repo);
+        if (current.state === 'present') {
+          await provider.detachTeamRepository(authority, rollbackTeam.id, request.repo);
+          await journal.recordMutation('team-repository-rollback-applied');
+          current = await provider.readTeamRepository(authority, rollbackTeam.id, request.repo);
+          await journal.recordProviderEvidence({
+            endpoint: current.endpoint,
+            contentType: current.contentType,
+            decision:
+              current.state === 'present' ? 'team-repository-present' : 'team-repository-absent',
+          });
+          if (current.state !== 'absent') throw new Error('team repository rollback disagreed');
+        }
+      }
+    } catch (rollbackError: unknown) {
+      compensationError = rollbackError;
+    }
+    const auditError =
+      compensationError instanceof CredentialJournalError
+        ? compensationError
+        : error instanceof CredentialJournalError
+          ? error
+          : undefined;
+    if (auditError !== undefined) {
+      throw new CredentialGrantExecutionError(auditError.code, mutation, journal.journalId());
+    }
+    const reasonCode =
+      compensationError !== undefined
+        ? 'rollback-incomplete'
+        : mutation === 'applied'
+          ? 'readback-missing'
+          : 'mutation-state-unknown';
+    try {
+      await journal.seal('indeterminate', reasonCode);
+    } catch (journalError: unknown) {
+      if (journalError instanceof CredentialJournalError) {
+        throw new CredentialGrantExecutionError(journalError.code, mutation, journal.journalId());
+      }
+      throw journalError;
+    }
+    return result(
+      request,
+      journal,
+      'indeterminate',
+      mutation,
+      reasonCode,
+      null,
+      null,
+      null,
+      null,
+      null,
+      null,
+    );
+  } finally {
+    // The kernel also releases this advisory lock on process exit. A close
+    // cleanup fault must not contradict an already sealed provider verdict.
+    await releaseTeamLock?.().catch((): void => undefined);
+  }
+}
+
+function result(
+  request: TeamGrantRequest,
+  journal: CredentialAuditJournal,
+  outcome: 'ok' | 'refused' | 'indeterminate',
+  mutation: 'none' | 'unknown' | 'applied',
+  code: string,
+  validation: Awaited<ReturnType<typeof evaluateGiteaWriteValidation>> | null,
+  team: TeamResolutionEvidence | null,
+  teamMembership: PresenceEvidence | null,
+  teamRepository: PresenceEvidence | null,
+  organizationMembership: OrganizationMembershipEvidenceDto | null,
+  teamRepositorySet: TeamRepositorySetEvidence | null,
+): TeamGrantResult {
+  return {
+    schemaVersion: 1,
+    operation: 'grant',
+    outcome,
+    exitCode: outcome === 'ok' ? 0 : outcome === 'refused' ? 10 : 30,
+    retryable: false,
+    subject: {
+      identity: request.identity,
+      estate: request.estate,
+      host: request.host,
+      repo: request.repo,
+    },
+    mutation,
+    reason: {
+      code,
+      message:
+        outcome === 'ok'
+          ? 'Team grant matched every provider read-back.'
+          : 'Team grant was refused or could not be established.',
+    },
+    evidence: {
+      providerIdentity: validation?.evidence.providerIdentity ?? null,
+      tokenCapabilities: validation?.evidence.tokenCapabilities ?? {
+        state: 'not-measured',
+        scopes: [],
+        source: 'runtime-not-authorized',
+      },
+      repositoryPermission: validation?.evidence.repositoryPermission ?? null,
+      writeDifferential: validation?.evidence.writeDifferential ?? null,
+      collaboratorPermission: null,
+      organizationMembership,
+      team,
+      teamMembership,
+      teamRepository,
+      teamRepositorySet,
+    },
+    audit: { journalId: journal.journalId(), state: 'sealed' },
+  };
+}

packages/mosaic/src/credentials/validate.spec.ts

@@ -0,0 +1,413 @@
+import { describe, expect, it } from 'vitest';
+import { CredentialProviderEvidenceError } from './gitea-provider.js';
+import {
+  evaluateGiteaReadValidation,
+  evaluateGiteaWriteValidation,
+  type CredentialResolver,
+  type CredentialValidationDependencies,
+  type GiteaCredentialProvider,
+  type ProviderIdentityEvidence,
+  type ReceivePackEvidence,
+  type RepositoryPermissionEvidence,
+  type ResolvedCredential,
+} from './validate.js';
+
+interface FixtureOptions {
+  readonly subjectProviderIdentity?: string;
+  readonly subjectPermission?: 'none' | 'read' | 'write' | 'admin';
+  readonly subjectTransportState?: 'advertised' | 'refused';
+  readonly subjectTransportPrincipal?: string;
+  readonly subjectTransportResolutionId?: string;
+  readonly controlProviderIdentity?: string;
+  readonly controlPermission?: 'none' | 'read' | 'write' | 'admin';
+  readonly controlTransportState?: 'advertised' | 'refused';
+  readonly controlTransportPrincipal?: string;
+  readonly unauthenticatedTransportState?: 'advertised' | 'refused';
+  readonly omitControl?: boolean;
+  readonly requiredPermission?: 'read' | 'write' | 'admin';
+}
+
+interface Fixture {
+  readonly dependencies: CredentialValidationDependencies;
+  readonly resolverCalls: string[];
+  readonly identityHandles: ResolvedCredential[];
+  readonly permissionHandles: ResolvedCredential[];
+  readonly receivePackHandles: Array<ResolvedCredential | undefined>;
+}
+
+const SUBJECT = 'seat-name';
+const CONTROL = 'read-only-control';
+const ESTATE = 'homelab';
+const HOST = 'git.example.invalid';
+const REPO = 'owner/repo';
+
+function credential(identity: string, resolutionId: string): ResolvedCredential {
+  return Object.freeze({
+    identity,
+    estate: ESTATE,
+    host: HOST,
+    resolutionId,
+    secret: new Uint8Array([99, 97, 110, 97, 114, 121]),
+  });
+}
+
+function fixture(options: FixtureOptions = {}): Fixture {
+  const subjectCredential = credential(SUBJECT, 'subject-resolution');
+  const controlCredential = credential(CONTROL, 'control-resolution');
+  const resolverCalls: string[] = [];
+  const identityHandles: ResolvedCredential[] = [];
+  const permissionHandles: ResolvedCredential[] = [];
+  const receivePackHandles: Array<ResolvedCredential | undefined> = [];
+
+  const resolver: CredentialResolver = {
+    async resolve(identity: string): Promise<ResolvedCredential | undefined> {
+      resolverCalls.push(identity);
+      if (identity === SUBJECT) return subjectCredential;
+      if (identity === CONTROL && options.omitControl !== true) return controlCredential;
+      return undefined;
+    },
+  };
+
+  const provider: GiteaCredentialProvider = {
+    async readIdentity(resolved: ResolvedCredential): Promise<ProviderIdentityEvidence> {
+      identityHandles.push(resolved);
+      const login =
+        resolved.identity === SUBJECT
+          ? (options.subjectProviderIdentity ?? SUBJECT)
+          : (options.controlProviderIdentity ?? CONTROL);
+      return {
+        login,
+        endpoint: 'GET /api/v1/user',
+        contentType: 'application/json',
+      };
+    },
+    async readRepositoryPermission(
+      resolved: ResolvedCredential,
+    ): Promise<RepositoryPermissionEvidence> {
+      permissionHandles.push(resolved);
+      const effective =
+        resolved.identity === SUBJECT
+          ? (options.subjectPermission ?? 'write')
+          : (options.controlPermission ?? 'read');
+      return {
+        effective,
+        endpoint: `GET /api/v1/repos/${REPO}`,
+        contentType: 'application/json',
+      };
+    },
+    async probeReceivePack(resolved: ResolvedCredential | undefined): Promise<ReceivePackEvidence> {
+      receivePackHandles.push(resolved);
+      if (resolved === undefined) {
+        return {
+          state: options.unauthenticatedTransportState ?? 'refused',
+          principal: null,
+          resolutionId: null,
+          contentType: 'text/plain',
+        };
+      }
+      if (resolved.identity === SUBJECT) {
+        return {
+          state: options.subjectTransportState ?? 'advertised',
+          principal: options.subjectTransportPrincipal ?? SUBJECT,
+          resolutionId: options.subjectTransportResolutionId ?? resolved.resolutionId,
+          contentType: 'application/x-git-receive-pack-advertisement',
+        };
+      }
+      return {
+        state: options.controlTransportState ?? 'refused',
+        principal: options.controlTransportPrincipal ?? CONTROL,
+        resolutionId: resolved.resolutionId,
+        contentType: 'text/plain',
+      };
+    },
+  };
+
+  return {
+    dependencies: {
+      resolver,
+      provider,
+      estateRegistry: {
+        matches(estate: string, host: string): boolean {
+          return estate === ESTATE && host === HOST;
+        },
+      },
+    },
+    resolverCalls,
+    identityHandles,
+    permissionHandles,
+    receivePackHandles,
+  };
+}
+
+async function validate(options: FixtureOptions = {}): Promise<{
+  readonly result: Awaited<ReturnType<typeof evaluateGiteaWriteValidation>>;
+  readonly observed: Fixture;
+}> {
+  const observed = fixture(options);
+  const result = await evaluateGiteaWriteValidation(
+    {
+      identity: SUBJECT,
+      estate: ESTATE,
+      host: HOST,
+      repo: REPO,
+      readOnlyControlIdentity: CONTROL,
+      requiredPermission: options.requiredPermission,
+    },
+    observed.dependencies,
+  );
+  return { result, observed };
+}
+
+describe('Gitea read validation', (): void => {
+  it('reads the explicit provider identity and repository permission without a write control', async (): Promise<void> => {
+    const observed = fixture({ subjectPermission: 'read' });
+    const result = await evaluateGiteaReadValidation(
+      { identity: SUBJECT, estate: ESTATE, host: HOST, repo: REPO },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('ok');
+    expect(result.evidence.providerIdentity?.login).toBe(SUBJECT);
+    expect(result.evidence.repositoryPermission?.effective).toBe('read');
+    expect(result.evidence.writeDifferential).toBeNull();
+    expect(observed.resolverCalls).toEqual([SUBJECT]);
+  });
+
+  it('refuses a repository object whose permission flags establish no read access', async (): Promise<void> => {
+    const observed = fixture({ subjectPermission: 'none' });
+    const result = await evaluateGiteaReadValidation(
+      { identity: SUBJECT, estate: ESTATE, host: HOST, repo: REPO },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('permission-denied');
+  });
+
+  it('classifies the provider rejecting the subject credential as an authoritative refusal', async (): Promise<void> => {
+    const observed = fixture({ subjectPermission: 'read' });
+    observed.dependencies.provider.readIdentity = async (): Promise<ProviderIdentityEvidence> => {
+      throw new CredentialProviderEvidenceError(
+        'credential-rejected',
+        'provider rejected the supplied credential',
+      );
+    };
+    const result = await evaluateGiteaReadValidation(
+      { identity: SUBJECT, estate: ESTATE, host: HOST, repo: REPO },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('refused');
+    expect(result.exitCode).toBe(10);
+    expect(result.reason.code).toBe('credential-rejected');
+  });
+
+  it('confirms in-scope capability while reporting identity as not measured', async (): Promise<void> => {
+    const observed = fixture({ subjectPermission: 'write' });
+    observed.dependencies.provider.readIdentity = async (): Promise<ProviderIdentityEvidence> => {
+      throw new CredentialProviderEvidenceError(
+        'identity-read-forbidden',
+        'identity endpoint requires a scope this token does not hold',
+      );
+    };
+    const result = await evaluateGiteaReadValidation(
+      { identity: SUBJECT, estate: ESTATE, host: HOST, repo: REPO },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('identity-not-measured');
+    expect(result.evidence.providerIdentity).toBeNull();
+    expect(result.evidence.repositoryPermission?.effective).toBe('write');
+  });
+
+  it('refuses a shared fallback rather than reporting a different principal as the subject', async (): Promise<void> => {
+    const observed = fixture({
+      subjectProviderIdentity: 'shared-owner',
+      subjectPermission: 'read',
+    });
+    const result = await evaluateGiteaReadValidation(
+      { identity: SUBJECT, estate: ESTATE, host: HOST, repo: REPO },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('provider-identity-mismatch');
+  });
+});
+
+describe('principal-bound Gitea write validation contract v1.1', (): void => {
+  it('confirms write capability when identity is scope-forbidden without exposing the internal reason', async (): Promise<void> => {
+    const observed = fixture();
+    const readIdentity = observed.dependencies.provider.readIdentity.bind(
+      observed.dependencies.provider,
+    );
+    observed.dependencies.provider.readIdentity = async (
+      resolved,
+    ): Promise<ProviderIdentityEvidence> => {
+      if (resolved.identity === SUBJECT) {
+        throw new CredentialProviderEvidenceError(
+          'identity-read-forbidden',
+          'identity endpoint scope forbidden',
+        );
+      }
+      return readIdentity(resolved);
+    };
+    const result = await evaluateGiteaWriteValidation(
+      {
+        identity: SUBJECT,
+        estate: ESTATE,
+        host: HOST,
+        repo: REPO,
+        readOnlyControlIdentity: CONTROL,
+      },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('identity-not-measured');
+    expect(result.evidence.repositoryPermission?.effective).toBe('write');
+    expect(observed.receivePackHandles).toEqual([
+      expect.objectContaining({ identity: SUBJECT }),
+      expect.objectContaining({ identity: CONTROL }),
+      undefined,
+    ]);
+  });
+  it('uses one immutable subject credential handle for identity, permission, and receive-pack', async (): Promise<void> => {
+    const { result, observed } = await validate();
+
+    expect(result.outcome).toBe('ok');
+    expect(observed.resolverCalls).toEqual([SUBJECT, CONTROL]);
+    expect(observed.identityHandles[0]).toBe(observed.permissionHandles[0]);
+    expect(observed.identityHandles[0]).toBe(observed.receivePackHandles[0]);
+  });
+
+  it('refuses a subject credential whose provider identity is a shared fallback', async (): Promise<void> => {
+    const { result } = await validate({ subjectProviderIdentity: 'shared-owner' });
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('provider-identity-mismatch');
+    expect(result.mutation).toBe('none');
+  });
+
+  it('routes a transport principal mismatch to indeterminate, not refused', async (): Promise<void> => {
+    const { result } = await validate({ subjectTransportPrincipal: 'shared-owner' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('transport-principal-mismatch');
+  });
+
+  it('routes a transport credential-handle mismatch to indeterminate', async (): Promise<void> => {
+    const { result } = await validate({ subjectTransportResolutionId: 'fallback-resolution' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('transport-principal-mismatch');
+  });
+
+  it('refuses when the provider repository object authoritatively denies write', async (): Promise<void> => {
+    const { result } = await validate({ subjectPermission: 'read' });
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('permission-denied');
+  });
+
+  it('is indeterminate when repo permission says write but receive-pack refuses', async (): Promise<void> => {
+    const { result } = await validate({ subjectTransportState: 'refused' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('permission-evidence-disagrees');
+  });
+
+  it('refuses write permission when admin permission is explicitly required', async (): Promise<void> => {
+    const { result } = await validate({
+      requiredPermission: 'admin',
+      subjectPermission: 'write',
+    });
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('permission-denied');
+  });
+
+  it('accepts admin permission when admin is explicitly required', async (): Promise<void> => {
+    const { result } = await validate({
+      requiredPermission: 'admin',
+      subjectPermission: 'admin',
+    });
+
+    expect(result.outcome).toBe('ok');
+  });
+
+  it('makes a write-capable read-only control invalidate the entire result', async (): Promise<void> => {
+    const { result } = await validate({ controlPermission: 'write' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('read-only-control-invalid');
+  });
+
+  it('makes an identity-mismatched read-only control invalidate the entire result', async (): Promise<void> => {
+    const { result } = await validate({ controlProviderIdentity: 'other-control' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('read-only-control-invalid');
+  });
+
+  it('makes a read-only control that receives write transport invalidate the result', async (): Promise<void> => {
+    const { result } = await validate({ controlTransportState: 'advertised' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('read-only-control-invalid');
+  });
+
+  it('is indeterminate when the configured read-only control credential is absent', async (): Promise<void> => {
+    const { result } = await validate({ omitControl: true });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('read-only-control-invalid');
+  });
+
+  it('keeps the unauthenticated arm and rejects an advertisement there', async (): Promise<void> => {
+    const { result } = await validate({ unauthenticatedTransportState: 'advertised' });
+
+    expect(result.outcome).toBe('indeterminate');
+    expect(result.reason.code).toBe('permission-evidence-disagrees');
+  });
+
+  it('refuses an estate-host mismatch before resolving any credential', async (): Promise<void> => {
+    const observed = fixture();
+    const result = await evaluateGiteaWriteValidation(
+      {
+        identity: SUBJECT,
+        estate: 'usc',
+        host: HOST,
+        repo: REPO,
+        readOnlyControlIdentity: CONTROL,
+      },
+      observed.dependencies,
+    );
+
+    expect(result.outcome).toBe('refused');
+    expect(result.reason.code).toBe('estate-host-mismatch');
+    expect(observed.resolverCalls).toEqual([]);
+  });
+
+  it('returns structured proof bounds only after every principal-bound arm passes', async (): Promise<void> => {
+    const { result } = await validate();
+
+    expect(result.outcome).toBe('ok');
+    expect(result.evidence.writeDifferential).toMatchObject({
+      state: 'can-write',
+      credentialBinding: 'same-resolution',
+      transportPrincipal: SUBJECT,
+      authenticatedReceivePack: 'advertised',
+      readOnlyControl: {
+        identity: CONTROL,
+        providerPermission: 'read',
+        receivePack: 'refused',
+      },
+      unauthenticatedReceivePack: 'refused',
+      artifactCreated: false,
+    });
+    expect(result.evidence.writeDifferential?.proves).toContain('declared subject credential');
+    expect(result.evidence.writeDifferential?.doesNotProve).toContain('branch protection');
+  });
+});

packages/mosaic/src/credentials/validate.ts

@@ -0,0 +1,521 @@
+import { CredentialProviderEvidenceError } from './gitea-provider.js';
+import type {
+  CredentialValidationDependencies,
+  GiteaReadValidationRequestDto,
+  GiteaWriteValidationRequestDto,
+  ResolvedCredential,
+} from './credential-provider.dto.js';
+import type {
+  CredentialOutcome,
+  CredentialReasonDto,
+  CredentialValidationEvidenceDto,
+  CredentialValidationResultDto,
+  ProviderIdentityEvidenceDto,
+  ReceivePackEvidenceDto,
+  RepositoryPermissionEvidenceDto,
+  WriteDifferentialEvidenceDto,
+} from './credential-result.dto.js';
+
+export type {
+  CredentialResolver,
+  CredentialValidationDependencies,
+  GiteaCredentialProvider,
+  GiteaReadValidationRequestDto,
+  GiteaWriteValidationRequestDto,
+  ResolvedCredential,
+} from './credential-provider.dto.js';
+export type {
+  ProviderIdentityEvidenceDto as ProviderIdentityEvidence,
+  ReceivePackEvidenceDto as ReceivePackEvidence,
+  RepositoryPermissionEvidenceDto as RepositoryPermissionEvidence,
+} from './credential-result.dto.js';
+
+const JSON_CONTENT_TYPE = 'application/json';
+const RUNTIME_SCOPE_NOT_MEASURED = {
+  state: 'not-measured' as const,
+  scopes: [] as readonly string[],
+  source: 'runtime-not-authorized' as const,
+};
+const RECEIVE_PACK_CONTENT_TYPE = 'application/x-git-receive-pack-advertisement';
+
+interface ResultOptions {
+  readonly outcome: CredentialOutcome;
+  readonly code: string;
+  readonly message: string;
+  readonly retryable?: boolean;
+  readonly evidence?: CredentialValidationEvidenceDto;
+}
+
+function subject(request: GiteaReadValidationRequestDto): CredentialValidationResultDto['subject'] {
+  return {
+    identity: request.identity,
+    estate: request.estate,
+    host: request.host,
+    repo: request.repo,
+  };
+}
+
+function result(
+  request: GiteaReadValidationRequestDto,
+  options: ResultOptions,
+): CredentialValidationResultDto {
+  const exits: Readonly<Record<CredentialOutcome, 0 | 10 | 20 | 30>> = {
+    ok: 0,
+    refused: 10,
+    error: 20,
+    indeterminate: 30,
+  };
+  return {
+    schemaVersion: 1,
+    operation: 'validate',
+    outcome: options.outcome,
+    exitCode: exits[options.outcome],
+    retryable: options.retryable ?? false,
+    subject: subject(request),
+    mutation: 'none',
+    reason: { code: options.code, message: options.message },
+    evidence: options.evidence ?? {
+      providerIdentity: null,
+      tokenCapabilities: RUNTIME_SCOPE_NOT_MEASURED,
+      repositoryPermission: null,
+      writeDifferential: null,
+    },
+    audit: { journalId: null, state: 'not-started' },
+  };
+}
+
+function refused(
+  request: GiteaReadValidationRequestDto,
+  reason: CredentialReasonDto,
+  evidence?: CredentialValidationEvidenceDto,
+): CredentialValidationResultDto {
+  return result(request, {
+    outcome: 'refused',
+    code: reason.code,
+    message: reason.message,
+    ...(evidence === undefined ? {} : { evidence }),
+  });
+}
+
+function indeterminate(
+  request: GiteaReadValidationRequestDto,
+  reason: CredentialReasonDto,
+  evidence?: CredentialValidationEvidenceDto,
+): CredentialValidationResultDto {
+  return result(request, {
+    outcome: 'indeterminate',
+    code: reason.code,
+    message: reason.message,
+    ...(evidence === undefined ? {} : { evidence }),
+  });
+}
+
+function providerEvidenceFailure(
+  request: GiteaReadValidationRequestDto,
+  error: CredentialProviderEvidenceError,
+): CredentialValidationResultDto {
+  if (error.code === 'credential-rejected') {
+    return refused(request, {
+      code: error.code,
+      message: 'The provider authoritatively rejected the supplied subject credential.',
+    });
+  }
+  return indeterminate(request, {
+    code: error.code,
+    message: 'Provider evidence could not be evaluated completely.',
+  });
+}
+
+function identityContentTypeValid(evidence: ProviderIdentityEvidenceDto): boolean {
+  return evidence.contentType.toLowerCase().startsWith(JSON_CONTENT_TYPE);
+}
+
+function permissionContentTypeValid(evidence: RepositoryPermissionEvidenceDto): boolean {
+  return evidence.contentType.toLowerCase().startsWith(JSON_CONTENT_TYPE);
+}
+
+function advertised(evidence: ReceivePackEvidenceDto): boolean {
+  return (
+    evidence.state === 'advertised' &&
+    evidence.contentType.toLowerCase().startsWith(RECEIVE_PACK_CONTENT_TYPE)
+  );
+}
+
+async function resolveCredential(
+  request: GiteaWriteValidationRequestDto,
+  identity: string,
+  dependencies: CredentialValidationDependencies,
+): Promise<ResolvedCredential | undefined> {
+  return dependencies.resolver.resolve(identity, request.estate, request.host);
+}
+
+function successfulEvidence(
+  subjectLogin: string,
+  subjectIdentity: ProviderIdentityEvidenceDto | null,
+  subjectPermission: RepositoryPermissionEvidenceDto,
+  subjectReceivePack: ReceivePackEvidenceDto,
+  controlIdentity: ProviderIdentityEvidenceDto,
+  controlPermission: RepositoryPermissionEvidenceDto,
+  controlReceivePack: ReceivePackEvidenceDto,
+): CredentialValidationEvidenceDto {
+  const writeDifferential: WriteDifferentialEvidenceDto = {
+    state: 'can-write',
+    credentialBinding: 'same-resolution',
+    transportPrincipal: subjectLogin,
+    authenticatedReceivePack: 'advertised',
+    readOnlyControl: {
+      identity: controlIdentity.login,
+      providerPermission: controlPermission.effective,
+      receivePack: controlReceivePack.state,
+    },
+    unauthenticatedReceivePack: 'refused',
+    artifactCreated: false,
+    proves:
+      'The declared subject credential authenticated provider identity, repository permission, and write transport while a distinct provider-confirmed read-only principal and an unauthenticated caller were refused.',
+    doesNotProve:
+      'A particular ref update will pass branch protection, hooks, races, or content policy.',
+  };
+  return {
+    providerIdentity: subjectIdentity,
+    tokenCapabilities: RUNTIME_SCOPE_NOT_MEASURED,
+    repositoryPermission: subjectPermission,
+    writeDifferential,
+  };
+}
+
+async function evaluateGiteaReadValidationUnsafe(
+  request: GiteaReadValidationRequestDto,
+  dependencies: CredentialValidationDependencies,
+): Promise<CredentialValidationResultDto> {
+  if (!dependencies.estateRegistry.matches(request.estate, request.host)) {
+    return refused(request, {
+      code: 'estate-host-mismatch',
+      message: 'The declared estate does not contain the declared host.',
+    });
+  }
+  const resolved = await dependencies.resolver.resolve(
+    request.identity,
+    request.estate,
+    request.host,
+  );
+  if (resolved === undefined) {
+    return refused(request, {
+      code: 'no-token-for-identity',
+      message: 'The explicit identity has no credential in the declared estate.',
+    });
+  }
+  let providerIdentity: ProviderIdentityEvidenceDto | null;
+  try {
+    providerIdentity = await dependencies.provider.readIdentity(resolved);
+  } catch (error: unknown) {
+    if (
+      error instanceof CredentialProviderEvidenceError &&
+      error.code === 'identity-read-forbidden'
+    ) {
+      const repositoryPermission = await dependencies.provider.readRepositoryPermission(
+        resolved,
+        request.repo,
+      );
+      const evidence: CredentialValidationEvidenceDto = {
+        providerIdentity: null,
+        tokenCapabilities: RUNTIME_SCOPE_NOT_MEASURED,
+        repositoryPermission,
+        writeDifferential: null,
+      };
+      if (!permissionContentTypeValid(repositoryPermission)) {
+        return indeterminate(
+          request,
+          {
+            code: 'unexpected-content-type',
+            message: 'In-scope capability evidence was not JSON.',
+          },
+          evidence,
+        );
+      }
+      if (repositoryPermission.effective === 'none') {
+        return refused(
+          request,
+          {
+            code: 'permission-denied',
+            message: 'The in-scope provider object denies repository access.',
+          },
+          evidence,
+        );
+      }
+      return indeterminate(
+        request,
+        {
+          code: 'identity-not-measured',
+          message:
+            'Repository capability was confirmed, but identity was not measured because this least-privilege token cannot read /user.',
+        },
+        evidence,
+      );
+    }
+    throw error;
+  }
+  const repositoryPermission = await dependencies.provider.readRepositoryPermission(
+    resolved,
+    request.repo,
+  );
+  const evidence: CredentialValidationEvidenceDto = {
+    providerIdentity,
+    tokenCapabilities: RUNTIME_SCOPE_NOT_MEASURED,
+    repositoryPermission,
+    writeDifferential: null,
+  };
+  if (
+    !identityContentTypeValid(providerIdentity) ||
+    !permissionContentTypeValid(repositoryPermission)
+  ) {
+    return indeterminate(
+      request,
+      {
+        code: 'unexpected-content-type',
+        message: 'Provider read evidence was not JSON.',
+      },
+      evidence,
+    );
+  }
+  if (repositoryPermission.effective === 'none') {
+    return refused(
+      request,
+      {
+        code: 'permission-denied',
+        message: 'The provider repository object denies read permission.',
+      },
+      evidence,
+    );
+  }
+  if (providerIdentity.login !== request.identity) {
+    return refused(
+      request,
+      {
+        code: 'provider-identity-mismatch',
+        message: 'The provider credential identity does not equal the declared subject.',
+      },
+      evidence,
+    );
+  }
+  return result(request, {
+    outcome: 'ok',
+    code: 'validation-verified',
+    message: 'Provider identity and repository permission were read back.',
+    evidence,
+  });
+}
+
+export async function evaluateGiteaReadValidation(
+  request: GiteaReadValidationRequestDto,
+  dependencies: CredentialValidationDependencies,
+): Promise<CredentialValidationResultDto> {
+  try {
+    return await evaluateGiteaReadValidationUnsafe(request, dependencies);
+  } catch (error: unknown) {
+    if (error instanceof CredentialProviderEvidenceError) {
+      return providerEvidenceFailure(request, error);
+    }
+    throw error;
+  }
+}
+
+async function evaluateGiteaWriteValidationUnsafe(
+  request: GiteaWriteValidationRequestDto,
+  dependencies: CredentialValidationDependencies,
+): Promise<CredentialValidationResultDto> {
+  if (!dependencies.estateRegistry.matches(request.estate, request.host)) {
+    return refused(request, {
+      code: 'estate-host-mismatch',
+      message: 'The declared estate does not contain the declared host.',
+    });
+  }
+
+  const resolved = await resolveCredential(request, request.identity, dependencies);
+  if (resolved === undefined) {
+    return refused(request, {
+      code: 'no-token-for-identity',
+      message: 'The explicit identity has no credential in the declared estate.',
+    });
+  }
+
+  let subjectIdentity: ProviderIdentityEvidenceDto | null = null;
+  try {
+    subjectIdentity = await dependencies.provider.readIdentity(resolved);
+  } catch (error: unknown) {
+    if (
+      !(error instanceof CredentialProviderEvidenceError) ||
+      error.code !== 'identity-read-forbidden'
+    ) {
+      throw error;
+    }
+  }
+  const subjectPermission = await dependencies.provider.readRepositoryPermission(
+    resolved,
+    request.repo,
+  );
+  const subjectReceivePack = await dependencies.provider.probeReceivePack(resolved, request.repo);
+  const baseEvidence: CredentialValidationEvidenceDto = {
+    providerIdentity: subjectIdentity,
+    tokenCapabilities: RUNTIME_SCOPE_NOT_MEASURED,
+    repositoryPermission: subjectPermission,
+    writeDifferential: null,
+  };
+
+  if (subjectIdentity !== null && !identityContentTypeValid(subjectIdentity)) {
+    return indeterminate(
+      request,
+      {
+        code: 'unexpected-content-type',
+        message: 'The provider identity response was not JSON.',
+      },
+      baseEvidence,
+    );
+  }
+  if (subjectIdentity !== null && subjectIdentity.login !== request.identity) {
+    return refused(
+      request,
+      {
+        code: 'provider-identity-mismatch',
+        message: 'The provider credential identity does not equal the declared subject.',
+      },
+      baseEvidence,
+    );
+  }
+  if (!permissionContentTypeValid(subjectPermission)) {
+    return indeterminate(
+      request,
+      {
+        code: 'unexpected-content-type',
+        message: 'The provider repository response was not JSON.',
+      },
+      baseEvidence,
+    );
+  }
+  if (request.requiredPermission === 'admin' && subjectPermission.effective !== 'admin') {
+    return refused(
+      request,
+      {
+        code: 'permission-denied',
+        message: 'The provider repository object denies required admin permission.',
+      },
+      baseEvidence,
+    );
+  }
+  if (subjectPermission.effective === 'read' || subjectPermission.effective === 'none') {
+    return refused(
+      request,
+      {
+        code: 'permission-denied',
+        message: 'The provider repository object denies write permission.',
+      },
+      baseEvidence,
+    );
+  }
+  if (
+    subjectReceivePack.principal !== request.identity ||
+    subjectReceivePack.resolutionId !== resolved.resolutionId
+  ) {
+    return indeterminate(
+      request,
+      {
+        code: 'transport-principal-mismatch',
+        message: 'The write transport evidence is not bound to the declared subject credential.',
+      },
+      baseEvidence,
+    );
+  }
+  if (!advertised(subjectReceivePack)) {
+    return indeterminate(
+      request,
+      {
+        code: 'permission-evidence-disagrees',
+        message: 'Repository permission and write transport evidence disagree.',
+      },
+      baseEvidence,
+    );
+  }
+
+  const control = await resolveCredential(request, request.readOnlyControlIdentity, dependencies);
+  if (control === undefined) {
+    return indeterminate(request, {
+      code: 'read-only-control-invalid',
+      message: 'The configured read-only control credential could not be resolved.',
+    });
+  }
+  const controlIdentity = await dependencies.provider.readIdentity(control);
+  const controlPermission = await dependencies.provider.readRepositoryPermission(
+    control,
+    request.repo,
+  );
+  const controlReceivePack = await dependencies.provider.probeReceivePack(control, request.repo);
+
+  const controlIsDistinct =
+    request.readOnlyControlIdentity !== request.identity &&
+    control.resolutionId !== resolved.resolutionId;
+  const controlIdentityMatches =
+    identityContentTypeValid(controlIdentity) &&
+    controlIdentity.login === request.readOnlyControlIdentity;
+  const controlPermissionIsReadOnly =
+    permissionContentTypeValid(controlPermission) && controlPermission.effective === 'read';
+  const controlTransportIsBoundAndRefused =
+    controlReceivePack.state === 'refused' &&
+    controlReceivePack.principal === request.readOnlyControlIdentity &&
+    controlReceivePack.resolutionId === control.resolutionId &&
+    !controlReceivePack.contentType.toLowerCase().startsWith(RECEIVE_PACK_CONTENT_TYPE);
+  if (
+    !controlIsDistinct ||
+    !controlIdentityMatches ||
+    !controlPermissionIsReadOnly ||
+    !controlTransportIsBoundAndRefused
+  ) {
+    return indeterminate(request, {
+      code: 'read-only-control-invalid',
+      message:
+        'The read-only control was absent, identity-mismatched, write-capable, unbound, or admitted to write transport.',
+    });
+  }
+
+  const unauthenticated = await dependencies.provider.probeReceivePack(undefined, request.repo);
+  if (
+    unauthenticated.state !== 'refused' ||
+    unauthenticated.contentType.toLowerCase().startsWith(RECEIVE_PACK_CONTENT_TYPE)
+  ) {
+    return indeterminate(request, {
+      code: 'permission-evidence-disagrees',
+      message: 'The unauthenticated write-transport control was not refused.',
+    });
+  }
+
+  const evidence = successfulEvidence(
+    request.identity,
+    subjectIdentity,
+    subjectPermission,
+    subjectReceivePack,
+    controlIdentity,
+    controlPermission,
+    controlReceivePack,
+  );
+  return result(request, {
+    outcome: subjectIdentity === null ? 'indeterminate' : 'ok',
+    code: subjectIdentity === null ? 'identity-not-measured' : 'validation-verified',
+    message:
+      subjectIdentity === null
+        ? 'Write capability and both controls were confirmed, but identity was not measured because this least-privilege token cannot read /user.'
+        : 'Every required provider evidence layer agreed.',
+    evidence,
+  });
+}
+
+export async function evaluateGiteaWriteValidation(
+  request: GiteaWriteValidationRequestDto,
+  dependencies: CredentialValidationDependencies,
+): Promise<CredentialValidationResultDto> {
+  try {
+    return await evaluateGiteaWriteValidationUnsafe(request, dependencies);
+  } catch (error: unknown) {
+    if (error instanceof CredentialProviderEvidenceError) {
+      return providerEvidenceFailure(request, error);
+    }
+    throw error;
+  }
+}