feat(869-c5): mosaic doctor surfaces wired-but-unactivatable lease enforcement

Part of #869 (Point-1 C5). Adds runLeaseEnforcementDoctorCheck(), which
detects whether the Claude Code enforcement hooks (mutator-gate.py /
receipt-observer-client.py) are wired in ~/.claude/settings.json and, if so,
reuses C1's leaseEnforcementActivatable() and C3's
checkBrokerSupervisorHealth() to determine whether activation could actually
satisfy enforcement right now. Wired-but-not-activatable/unhealthy reports a
LOUD [mosaic-doctor] [ERROR] (forces mosaic doctor to exit non-zero even if
the underlying bash audit script is green); not-wired or wired-and-healthy
both pass silently, matching this file's existing checkMosaicHome/checkFile
conventions.

Red-first unit tests inject every dependency (settings read, activation
probe, broker-health check) — no real ~/.claude/settings.json or broker is
ever touched.

packages/mosaic/framework/install.sh

@@ -639,6 +639,10 @@ reconcile_framework_files
 # Ensure tool scripts are executable
 find "$TARGET_DIR/tools" -name "*.sh" -exec chmod +x {} + 2>/dev/null || true
 find "$TARGET_DIR/tools/_scripts" -type f -exec chmod +x {} + 2>/dev/null || true
+# git-credential-mosaic (per-agent Gitea identity helper) ships without a .sh
+# suffix — git resolves credential helpers by exact name/path, not extension —
+# so the *.sh glob above does not cover it; chmod it explicitly.
+[[ -f "$TARGET_DIR/tools/git/git-credential-mosaic" ]] && chmod +x "$TARGET_DIR/tools/git/git-credential-mosaic" 2>/dev/null || true
 
 ok "Framework synced to $TARGET_DIR"
 

packages/mosaic/framework/tools/git/README.md

@@ -33,3 +33,64 @@ The Gitea API token is **never passed on a curl command line.** An `Authorizatio
 Both `pr-review.sh` and `issue-comment.sh` accept an optional `--login <name>` flag that overrides the automatically detected Gitea login for that single invocation. The override selects **which credential the REST write, the `/user` identity lookup, and the read-back all use** — its token is resolved from the tea config for that login name (`get_gitea_token_for_login`), falling back to the repo host's credential when no login is named. The resolved login is **host- and port-bound**: the login's configured URL host **and effective port** (the scheme's default port — 80 for `http`, 443 for `https` — applies when a port is omitted, symmetrically on both sides) must match the repo remote's, so a login name shared across hosts (or an override configured for a different Gitea, including one on a different port of the same host) can never send one host's credential to another — a host or port mismatch fails closed rather than leaking a cross-host token. Resolving the acting identity and the read-back from the _same_ login that performs the write is essential: a write performed under an overridden login must be verified against that login's identity, not the host default's. Callers who need a different login than the host default should pass `--login <reviewer-login>`.
 
 As a durable successor to this mechanism, consider giving each reviewer/approver slot its own dedicated Gitea login credential, so that author≠reviewer holds at the credential level rather than relying on wrapper-level `--login` bookkeeping. This is a recommendation for future hardening, not something implemented by this flag.
+
+## Per-agent Gitea identity (Gate-16 author≠reviewer)
+
+By default, git push/fetch (via `git-credential-mosaic`) and the API wrappers above (via
+`detect-platform.sh`'s `get_gitea_token`) all authenticate as the single shared Gitea
+account/token configured through `tools/_lib/credentials.sh`. That means every agent in a
+fleet commits, pushes, and opens PRs under one identity — with no cryptographic
+separation between an author and a reviewer.
+
+Both `git-credential-mosaic` and `get_gitea_token()` resolve an optional **per-agent
+identity** before falling back to the shared account:
+
+1. `MOSAIC_GIT_IDENTITY` environment variable, or
+2. `git config --get mosaic.gitIdentity` (set per-worktree; persists on disk across
+   non-persistent shells — `git config mosaic.gitIdentity <agent-id>`), or
+3. (git-credential-mosaic only) the username git itself supplies for the credential
+   request.
+
+If the resolved identity has a token file at
+`~/.config/mosaic/secrets/gitea-tokens/gitea-{usc,mosaicstack}-<agent-id>.token`, that
+identity + token is used. **Nothing configured → nothing changes**: with no per-slot
+token file present, both tools fall through to the existing shared-account path
+unchanged, so this feature is a no-op on any host that hasn't provisioned per-slot
+tokens.
+
+### Enabling it for a clone
+
+The framework installer syncs `git-credential-mosaic` to
+`~/.config/mosaic/tools/git/git-credential-mosaic` (executable) on every install/update,
+but does **not** register it as git's credential helper automatically. Registration is a
+one-time, explicit step:
+
+```bash
+# Per-repo (recommended — scopes the helper to this clone only):
+git config credential.helper "$HOME/.config/mosaic/tools/git/git-credential-mosaic"
+
+# Per-worktree identity pin (Gate-16 separation):
+git config mosaic.gitIdentity <agent-id>
+```
+
+This is deliberately **not** auto-registered on install/update: `credential.helper` is
+global, order-sensitive git config (`~/.gitconfig`) that can already hold an
+operator-chosen credential manager (keychain, `store`, `manager-core`, …) for
+repositories unrelated to Mosaic. Silently inserting an entry on every framework
+install/upgrade risks reordering or shadowing that operator-owned surface across the
+whole host — the same operator-owned config the installer's manifest system is
+otherwise careful never to touch. Because identity is already resolved per-worktree
+(`mosaic.gitIdentity`), the correct granularity for registering the helper is per-clone
+too, so a documented manual step is the right shape here, not a global auto-write.
+
+### PowerShell parity
+
+`detect-platform.ps1`'s Gitea wrappers authenticate through `tea` CLI logins
+(`Get-GiteaLoginForHost`), not a raw-token `get_gitea_token`-equivalent function — there
+is nothing to prepend the identity-resolution block to on the PowerShell side. A native
+PowerShell git-credential helper is also unnecessary: `git-credential-mosaic` is invoked
+by git's credential-helper protocol (stdin/stdout), which works identically under Git for
+Windows' bundled `bash`/`sh` when configured via `credential.helper`, without a `.ps1`
+counterpart. A `tea`-login-based per-agent identity for the PowerShell wrappers is a
+separate, larger design (mapping identities to `tea login` profiles) and is out of scope
+here.

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

@@ -505,6 +505,28 @@ get_gitea_token() {
     script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
     local cred_loader="$script_dir/../_lib/credentials.sh"
 
+    # 0. Per-agent identity (Gate-16 author≠reviewer). If MOSAIC_GIT_IDENTITY, or the
+    #    per-worktree `git config mosaic.gitIdentity`, resolves to an agent that has a
+    #    stored per-slot token for this host, act AS that agent so API tooling
+    #    (pr-create, issue-create, …) authors under the right identity — matching the
+    #    git credential helper. Backward-compatible: nothing resolvable → shared logic below.
+    local _ident="${MOSAIC_GIT_IDENTITY:-}"
+    [[ -z "$_ident" ]] && _ident="$(git config --get mosaic.gitIdentity 2>/dev/null || true)"
+    if [[ -n "$_ident" ]]; then
+        local _idpfx=""
+        case "$host" in
+            git.uscllc.com)      _idpfx=gitea-usc ;;
+            git.mosaicstack.dev) _idpfx=gitea-mosaicstack ;;
+        esac
+        if [[ -n "$_idpfx" ]]; then
+            local _idtok="$HOME/.config/mosaic/secrets/gitea-tokens/${_idpfx}-${_ident}.token"
+            if [[ -r "$_idtok" ]]; then
+                cat "$_idtok"
+                return 0
+            fi
+        fi
+    fi
+
     # 1. Mosaic credential loader (host → service mapping, run in subshell to avoid polluting env)
     if [[ -f "$cred_loader" ]]; then
         local token

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

@@ -0,0 +1,69 @@
+#!/bin/bash
+# git-credential-mosaic — git credential helper — resolves Gitea tokens from
+# the Mosaic credential store at runtime so remote URLs never embed secrets.
+#
+# Install (one-time, per clone or globally):
+#   git config credential.helper "$HOME/.config/mosaic/tools/git/git-credential-mosaic"
+#   # or, fleet-wide: git config --global credential.helper "$HOME/.config/mosaic/tools/git/git-credential-mosaic"
+#
+# Per-agent Gate-16 identity (author != reviewer separation):
+#   git config mosaic.gitIdentity <agent-id>   # per-worktree, persists on disk
+#   # or: export MOSAIC_GIT_IDENTITY=<agent-id>
+#
+# Resolution 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 file, use it instead of the shared account. Backward
+# compatible: nothing resolvable -> shared token (unchanged behavior).
+[ "$1" = "get" ] || exit 0
+host=""; username_in=""
+while IFS= read -r line; do
+  [ -z "$line" ] && break
+  case "$line" in
+    host=*)     host=${line#host=};;
+    username=*) username_in=${line#username=};;
+  esac
+done
+# 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.
+ident="$MOSAIC_GIT_IDENTITY"
+[ -z "$ident" ] && ident=$(git config --get mosaic.gitIdentity 2>/dev/null)
+[ -z "$ident" ] && ident="$username_in"
+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
+      echo "username=${ident}"
+      echo "password=$(cat "$idtok")"
+      exit 0
+    fi
+  fi
+fi
+case "$host" in
+  git.uscllc.com)      svc=gitea-usc;;
+  git.mosaicstack.dev) svc=gitea-mosaicstack;;
+  *) exit 0;;
+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
+# 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),
+# not from the username string, so any non-empty placeholder works here — this
+# is deliberately NOT a real account name (framework files must stay
+# operator-agnostic; see tools/quality/scripts/verify-sanitized.sh).
+echo "username=${GITEA_USER:-git}"
+echo "password=$GITEA_TOKEN"

packages/mosaic/framework/tools/git/pr-review.sh

@@ -203,7 +203,15 @@ try:
         if not url:
             return False
         origin, path = _origin_and_path(url)
-        return origin == base_origin and path == expected_path
+        # Repo owner/repo slugs are case-insensitive (Gitea canonicalizes the
+        # pull_request_url slug to lowercase on return), while EXPECTED_REPO_SLUG
+        # is taken verbatim from GITEA_API_BASE and may be mixed-case. The
+        # remainder of the path (".../pulls/<number>") is numeric, so lowercasing
+        # the whole path for this comparison only relaxes case, not identity: the
+        # origin tuple (scheme+host+port) above still pins the provider host, and
+        # the path is still compared in FULL (no endswith/suffix match), so the
+        # look-alike-host and same-host decoy-prefix protections are unchanged.
+        return origin == base_origin and path.lower() == expected_path.lower()
 
     if comment.get("id") != expected_id:
         raise ValueError("read-back id does not match the created id")

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

@@ -0,0 +1,161 @@
+#!/usr/bin/env bash
+# Regression harness for `git-credential-mosaic` — per-agent Gitea identity
+# resolution (Gate-16 author≠reviewer separation).
+#
+# Covers:
+#   1. Identity resolution priority: MOSAIC_GIT_IDENTITY env > git config
+#      mosaic.gitIdentity (per-worktree) > git-supplied username.
+#   2. Correct per-slot token file path chosen per host
+#      (gitea-usc-<id>.token vs gitea-mosaicstack-<id>.token).
+#   3. Per-slot token present -> emits that identity + token.
+#   4. Per-slot token absent -> falls back to the shared account
+#      (backward-compat / no-op for hosts without per-slot tokens).
+#   5. Unknown/unrelated host -> exits 0 with no output (passthrough).
+#
+# Uses stubbed token files under a fake HOME + a real (throwaway) git repo.
+# NEVER reads real secrets or touches the real ~/.config/mosaic/secrets.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/git-credential-mosaic}"
+FAKE_HOME="$WORK_DIR/home"
+REPO_DIR="$WORK_DIR/repo"
+# Mirror the real deployed layout (~/.config/mosaic/tools/{git,_lib}/) under the
+# fake HOME: git-credential-mosaic resolves its credentials.sh sibling via a
+# script-relative path (BASH_SOURCE), so the copy must live next to a stubbed
+# _lib/credentials.sh, not the real one, to keep this test hermetic.
+HELPER="$FAKE_HOME/.config/mosaic/tools/git/git-credential-mosaic"
+
+rm -rf "$WORK_DIR"
+mkdir -p "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens" \
+         "$FAKE_HOME/.config/mosaic/tools/git" \
+         "$FAKE_HOME/.config/mosaic/tools/_lib" \
+         "$REPO_DIR"
+
+cp "$SCRIPT_DIR/git-credential-mosaic" "$HELPER"
+chmod +x "$HELPER"
+
+git -C "$REPO_DIR" init -q
+git -C "$REPO_DIR" config user.email "test@example.invalid"
+git -C "$REPO_DIR" config user.name "Test"
+
+# Fake shared-account credential loader — stands in for
+# tools/_lib/credentials.sh's load_credentials(), scoped to this test only.
+cat > "$FAKE_HOME/.config/mosaic/tools/_lib/credentials.sh" <<'SH'
+load_credentials() {
+  case "$1" in
+    gitea-mosaicstack) GITEA_URL="https://git.mosaicstack.dev"; GITEA_TOKEN="shared-mosaicstack-token"; export GITEA_URL GITEA_TOKEN; return 0 ;;
+    gitea-usc)         GITEA_URL="https://git.uscllc.com"; GITEA_TOKEN="shared-usc-token"; export GITEA_URL GITEA_TOKEN; return 0 ;;
+    *) return 1 ;;
+  esac
+}
+SH
+
+fail=0
+assert_eq() {
+  local desc="$1" expected="$2" actual="$3"
+  if [[ "$expected" != "$actual" ]]; then
+    echo "FAIL: $desc — expected '$expected', got '$actual'" >&2
+    fail=1
+  fi
+}
+
+# Feed "host=<h>\nusername=<u>\n\n" on stdin (mirrors git's credential protocol)
+# and run the helper with the fake HOME, inside REPO_DIR (so `git config
+# mosaic.gitIdentity` resolves per-worktree), plus any extra env passed in $@.
+run_helper() {
+  local host="$1" username_in="$2"; shift 2
+  (
+    cd "$REPO_DIR"
+    env -i HOME="$FAKE_HOME" PATH="$PATH" "$@" bash "$HELPER" get <<EOF
+host=$host
+username=$username_in
+
+EOF
+  )
+}
+
+# ---------------------------------------------------------------------------
+# 1. No identity resolvable anywhere, no per-slot token -> shared fallback
+#    (backward-compat: unchanged behavior when nothing is configured).
+# ---------------------------------------------------------------------------
+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=')"
+
+# ---------------------------------------------------------------------------
+# 2. git-supplied username resolves to an identity WITH a per-slot token ->
+#    that identity + token wins over the shared account.
+# ---------------------------------------------------------------------------
+echo -n "agentA-mosaicstack-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentA.token"
+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=')"
+
+# ---------------------------------------------------------------------------
+# 3. git config mosaic.gitIdentity (per-worktree) beats git-supplied username.
+# ---------------------------------------------------------------------------
+echo -n "agentB-mosaicstack-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentB.token"
+git -C "$REPO_DIR" config mosaic.gitIdentity agentB
+out=$(run_helper "git.mosaicstack.dev" "agentA")
+assert_eq "git-config beats username: username" "username=agentB" "$(echo "$out" | grep '^username=')"
+assert_eq "git-config beats username: password" "password=agentB-mosaicstack-token" "$(echo "$out" | grep '^password=')"
+
+# ---------------------------------------------------------------------------
+# 4. MOSAIC_GIT_IDENTITY env beats git config mosaic.gitIdentity.
+# ---------------------------------------------------------------------------
+echo -n "agentC-mosaicstack-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentC.token"
+out=$(run_helper "git.mosaicstack.dev" "agentA" MOSAIC_GIT_IDENTITY=agentC)
+assert_eq "env beats git-config: username" "username=agentC" "$(echo "$out" | grep '^username=')"
+assert_eq "env beats git-config: password" "password=agentC-mosaicstack-token" "$(echo "$out" | grep '^password=')"
+git -C "$REPO_DIR" config --unset mosaic.gitIdentity
+
+# ---------------------------------------------------------------------------
+# 5. Identity resolves, but no matching per-slot token file -> falls back to
+#    the shared account (per-agent identity is opt-in, not a hard requirement).
+# ---------------------------------------------------------------------------
+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=')"
+
+# ---------------------------------------------------------------------------
+# 6. Correct per-slot token PATH is chosen per host: same agent id, different
+#    host prefix (gitea-usc- vs gitea-mosaicstack-).
+# ---------------------------------------------------------------------------
+echo -n "agentD-usc-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-usc-agentD.token"
+out=$(run_helper "git.uscllc.com" "agentD")
+assert_eq "host-scoped token path (usc): username" "username=agentD" "$(echo "$out" | grep '^username=')"
+assert_eq "host-scoped token path (usc): password" "password=agentD-usc-token" "$(echo "$out" | grep '^password=')"
+# agentD has NO mosaicstack token -> must fall back to shared mosaicstack, not
+# leak the usc token across hosts.
+out=$(run_helper "git.mosaicstack.dev" "agentD")
+assert_eq "host-scoped token path (cross-host must not leak): username" "username=git" "$(echo "$out" | grep '^username=')"
+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
+#    remotes, e.g. github.com via a different credential helper).
+# ---------------------------------------------------------------------------
+out=$(run_helper "github.com" "agentA")
+assert_eq "unknown host: no output" "" "$out"
+
+# ---------------------------------------------------------------------------
+# 8. 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
+host=git.mosaicstack.dev
+username=agentA
+password=whatever
+
+EOF
+)
+assert_eq "store verb: no output" "" "$store_out"
+
+if [[ "$fail" -eq 0 ]]; then
+  echo "git-credential-mosaic identity resolution regression passed"
+fi
+
+exit "$fail"

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

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# Regression harness for detect-platform.sh's get_gitea_token() per-agent
+# identity resolution (Gate-16 author≠reviewer separation) — the API-tooling
+# counterpart to git-credential-mosaic, so pr-create.sh/issue-create.sh/etc.
+# open records under the resolved agent identity, not the shared account.
+#
+# Covers:
+#   1. Identity resolution priority: MOSAIC_GIT_IDENTITY env > git config
+#      mosaic.gitIdentity (per-worktree).
+#   2. Correct per-slot token file path chosen per host
+#      (gitea-usc-<id>.token vs gitea-mosaicstack-<id>.token).
+#   3. Per-slot token present -> that token is returned (agent-authored calls).
+#   4. Per-slot token absent -> falls back to the shared credential-loader
+#      token (backward-compat / no-op for hosts without per-slot tokens).
+#   5. Unrelated host with no shared credentials configured -> failure
+#      (unchanged, existing behavior).
+#
+# Uses a stubbed credentials.json + stubbed per-slot token files under a fake
+# HOME. NEVER reads real secrets or touches the real ~/.config/mosaic/secrets.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/gitea-token-identity}"
+FAKE_HOME="$WORK_DIR/home"
+REPO_DIR="$WORK_DIR/repo"
+CREDENTIALS_FILE="$FAKE_HOME/.config/mosaic/credentials.json"
+
+rm -rf "$WORK_DIR"
+mkdir -p "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens" "$REPO_DIR"
+
+git -C "$REPO_DIR" init -q
+git -C "$REPO_DIR" remote add origin https://git.mosaicstack.dev/mosaicstack/stack.git
+
+cat > "$CREDENTIALS_FILE" <<'JSON'
+{
+  "gitea": {
+    "mosaicstack": {
+      "url": "https://git.mosaicstack.dev",
+      "token": "shared-mosaicstack-token"
+    },
+    "usc": {
+      "url": "https://git.uscllc.com",
+      "token": "shared-usc-token"
+    }
+  }
+}
+JSON
+
+fail=0
+assert_eq() {
+  local desc="$1" expected="$2" actual="$3"
+  if [[ "$expected" != "$actual" ]]; then
+    echo "FAIL: $desc — expected '$expected', got '$actual'" >&2
+    fail=1
+  fi
+}
+
+# Runs get_gitea_token for $1=host inside REPO_DIR (per-worktree git config
+# resolves there) with a fake HOME + the stub credentials.json, plus any
+# extra env passed in $@.
+call_get_gitea_token() {
+  local host="$1"; shift
+  (
+    cd "$REPO_DIR"
+    # shellcheck disable=SC2016 # deliberately deferred: $DETECT_PLATFORM_SH is
+    # expanded by the INNER bash -c (via the exported env var below), not here.
+    env -i HOME="$FAKE_HOME" PATH="$PATH" MOSAIC_CREDENTIALS_FILE="$CREDENTIALS_FILE" \
+      DETECT_PLATFORM_SH="$SCRIPT_DIR/detect-platform.sh" "$@" \
+      bash -c 'source "$DETECT_PLATFORM_SH"; get_gitea_token "$1"' _ "$host"
+  )
+}
+
+# ---------------------------------------------------------------------------
+# 1. No identity resolvable -> shared credential-loader token (unchanged).
+# ---------------------------------------------------------------------------
+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"
+
+# ---------------------------------------------------------------------------
+# 2. git config mosaic.gitIdentity resolves to an agent WITH a per-slot
+#    token -> that token wins over the shared account.
+# ---------------------------------------------------------------------------
+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"
+
+# ---------------------------------------------------------------------------
+# 3. MOSAIC_GIT_IDENTITY env beats git config mosaic.gitIdentity.
+# ---------------------------------------------------------------------------
+echo -n "agentB-mosaicstack-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-mosaicstack-agentB.token"
+out=$(call_get_gitea_token "git.mosaicstack.dev" MOSAIC_GIT_IDENTITY=agentB)
+assert_eq "env beats git-config identity token" "agentB-mosaicstack-token" "$out"
+
+# ---------------------------------------------------------------------------
+# 4. Identity resolves but has no per-slot token for THIS host -> falls back
+#    to the shared token (per-agent identity is opt-in per host).
+# ---------------------------------------------------------------------------
+git -C "$REPO_DIR" config mosaic.gitIdentity no-such-agent
+out=$(call_get_gitea_token "git.mosaicstack.dev")
+assert_eq "no per-slot token falls back to shared" "shared-mosaicstack-token" "$out"
+
+# ---------------------------------------------------------------------------
+# 5. Correct per-slot token PATH per host: same agent id, only a usc token
+#    exists -> usc host returns it, mosaicstack host must NOT leak it and
+#    instead falls back to the shared mosaicstack token.
+# ---------------------------------------------------------------------------
+echo -n "agentD-usc-token" > "$FAKE_HOME/.config/mosaic/secrets/gitea-tokens/gitea-usc-agentD.token"
+git -C "$REPO_DIR" config mosaic.gitIdentity agentD
+out=$(call_get_gitea_token "git.uscllc.com")
+assert_eq "host-scoped token path (usc)" "agentD-usc-token" "$out"
+out=$(call_get_gitea_token "git.mosaicstack.dev")
+assert_eq "host-scoped token path (no cross-host leak)" "shared-mosaicstack-token" "$out"
+git -C "$REPO_DIR" config --unset mosaic.gitIdentity
+
+if [[ "$fail" -eq 0 ]]; then
+  echo "get_gitea_token identity resolution regression passed"
+fi
+
+exit "$fail"

packages/mosaic/framework/tools/git/test-pr-review-gitea-comment.sh

@@ -406,6 +406,13 @@ elif mode == "comment-url-wrong-repo":
 elif mode == "comment-url-suffix-injection":
     # Prefix-injected: a bare endswith("/<slug>/pulls/123") test would ACCEPT it.
     pr_url = f"{_origin}/deceptive{_slug}/pulls/123"
+elif mode == "comment-mixed-case-slug":
+    # #875: EXPECTED_REPO_SLUG is taken verbatim from GITEA_API_BASE and can be
+    # mixed-case (e.g. "USC/uconnect"), but Gitea canonicalizes the returned
+    # pull_request_url's owner/repo segment to LOWERCASE. Model that here by
+    # lowercasing only the slug path, independent of the (possibly mixed-case)
+    # web_base the wrapper was configured with.
+    pr_url = f"{_origin}{_slug.lower()}/pulls/123"
 record = {
     "id": 456,
     "body": body,
@@ -868,6 +875,19 @@ for bad_mode in comment-url-wrong-host comment-url-wrong-owner comment-url-wrong
     assert_no_temp_leak "$bad_mode"
 done
 
+# Case 15b (#875): a MIXED-CASE repo slug (as embedded verbatim in
+# GITEA_API_BASE, e.g. "USC/uconnect") must still verify when Gitea returns the
+# comment's pull_request_url with its owner/repo segment canonicalized to
+# LOWERCASE ("usc/uconnect"). This is a legitimate, unforged provider response —
+# not a spoof — so `_belongs` must accept it (case-insensitive slug compare)
+# while still requiring the origin (scheme+host+port) and the rest of the path
+# to match in full. Pre-#875-fix this fails closed on a real success
+# (false-negative); post-fix it verifies.
+run_review comment-mixed-case-slug comment durable-body https://git.mosaicstack.dev \
+    https://git.mosaicstack.dev/USC/uconnect.git USC/uconnect
+grep -q 'Added and verified comment on Gitea PR #123' "$OUTPUT_FILE"
+assert_no_temp_leak "comment-mixed-case-slug"
+
 # Case 16 (#865 ITEM 1, current-head TOCTOU): the PR head advances between the
 # pre-submit head read (which pins the review) and the post-verify re-read. The
 # review is genuinely created and verified as pinned to the OLD head, but the

packages/mosaic/package.json

@@ -25,7 +25,7 @@
     "lint": "eslint src",
     "typecheck": "tsc --noEmit",
     "test": "vitest run --passWithNoTests && pnpm run test:framework-shell",
-    "test:framework-shell": "python3 src/lease-broker/daemon_deadline_unittest.py && python3 src/lease-broker/normative_fragments_unittest.py && python3 src/lease-broker/receipt_challenge_unittest.py && python3 src/lease-broker/context_recovery_unittest.py && python3 src/lease-broker/recovery_runtime_unittest.py && python3 src/lease-broker/recovery_b1_adversarial_unittest.py && python3 src/lease-broker/framework_skill_portability_unittest.py && python3 src/mutator-gate/runtime_tools_unittest.py && python3 src/mutator-gate/runtime_launch_guard_unittest.py && python3 framework/tools/lease-broker/check-runtime-launches.py --root ../.. && bash framework/tools/codex/test-pr-diff-context.sh && bash framework/tools/qa/test-deps-preflight.sh && bash framework/tools/git/test-pr-review-gitea-comment.sh && bash framework/tools/git/test-ci-queue-wait-branch-absent.sh"
+    "test:framework-shell": "python3 src/lease-broker/daemon_deadline_unittest.py && python3 src/lease-broker/normative_fragments_unittest.py && python3 src/lease-broker/receipt_challenge_unittest.py && python3 src/lease-broker/context_recovery_unittest.py && python3 src/lease-broker/recovery_runtime_unittest.py && python3 src/lease-broker/recovery_b1_adversarial_unittest.py && python3 src/lease-broker/framework_skill_portability_unittest.py && python3 src/mutator-gate/runtime_tools_unittest.py && python3 src/mutator-gate/runtime_launch_guard_unittest.py && python3 framework/tools/lease-broker/check-runtime-launches.py --root ../.. && bash framework/tools/codex/test-pr-diff-context.sh && bash framework/tools/qa/test-deps-preflight.sh && bash framework/tools/git/test-pr-review-gitea-comment.sh && bash framework/tools/git/test-ci-queue-wait-branch-absent.sh && bash framework/tools/git/test-git-credential-mosaic.sh && bash framework/tools/git/test-gitea-token-identity.sh"
   },
   "dependencies": {
     "@mosaicstack/brain": "workspace:*",

packages/mosaic/src/commands/launch.ts

@@ -28,6 +28,7 @@ import { readRegularFileSecure } from '../fleet/secure-file.js';
 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';
 
 const MOSAIC_HOME = process.env['MOSAIC_HOME'] ?? join(homedir(), '.config', 'mosaic');
 const MAX_INSTALLED_TOOLS_BYTES = 256 * 1024;
@@ -1237,7 +1238,6 @@ export function registerLaunchCommands(program: Command): void {
   // Direct framework script delegates
   const directCommands: Record<string, { desc: string; script: string }> = {
     init: { desc: 'Generate SOUL.md (agent identity contract)', script: 'mosaic-init' },
-    doctor: { desc: 'Health audit — detect drift and missing files', script: 'mosaic-doctor' },
     sync: { desc: 'Sync skills from canonical source', script: 'mosaic-sync-skills' },
     bootstrap: {
       desc: 'Bootstrap a repo with Mosaic standards',
@@ -1256,4 +1256,67 @@ export function registerLaunchCommands(program: Command): void {
         delegateToScript(fwScript(script), cmd.args);
       });
   }
+
+  // `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
+  // to force a non-zero exit on its own — a silent pass on "enforcement
+  // hooks wired but activation absent" would leave a bricked host
+  // undiagnosed (see lease-doctor-check.ts docstring).
+  program
+    .command('doctor')
+    .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);
+      runDoctorScriptAndExit(fwScript('mosaic-doctor'), cmd.args, leaseCheckFailed);
+    });
+}
+
+/**
+ * Print the #869 C5 lease-enforcement doctor result using the same
+ * `[mosaic-doctor]` prefix the bash audit script uses, but with a distinct
+ * `[ERROR]` severity token (louder than the script's own `[WARN]`) — this is
+ * a hard, actionable brick warning, not a soft drift warning, and must never
+ * read as just one more line among the script's routine warnings. Silent on
+ * an `ok` result, matching this file's other pre-flight checks
+ * (`checkMosaicHome`, `checkFile`, `checkRuntime`) which only print on
+ * failure. Returns whether the check failed, so the caller can force a
+ * non-zero exit regardless of the bash script's own exit code.
+ */
+function printLeaseDoctorCheck(
+  result: Awaited<ReturnType<typeof runLeaseEnforcementDoctorCheck>>,
+): boolean {
+  if (result.status === 'error') {
+    console.error(`[mosaic-doctor] [ERROR] ${result.message}`);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Run the bash `mosaic-doctor` audit script (inheriting stdio, same as
+ * {@link delegateToScript}) and exit with a non-zero code if EITHER the
+ * script itself reported failure OR the lease-enforcement check above did —
+ * so `--fail-on-warn` and other script-level exit semantics are preserved,
+ * but the lease-enforcement ERROR can never be masked by an otherwise-green
+ * script run.
+ */
+function runDoctorScriptAndExit(scriptPath: string, args: string[], forceFailure: boolean): never {
+  if (!existsSync(scriptPath)) {
+    console.error(`[mosaic] Script not found: ${scriptPath}`);
+    process.exit(1);
+  }
+  let scriptExitCode = 0;
+  try {
+    execFileSync('bash', [scriptPath, ...args], { stdio: 'inherit', env: process.env });
+  } catch (err) {
+    scriptExitCode = (err as { status?: number }).status ?? 1;
+  }
+  process.exit(forceFailure ? 1 : scriptExitCode);
 }

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

@@ -0,0 +1,196 @@
+import { describe, expect, it } from 'vitest';
+import {
+  detectEnforcementHooksWired,
+  runLeaseEnforcementDoctorCheck,
+} from './lease-doctor-check.js';
+
+/**
+ * Red-first tests for issue #869 Point-1 C5 — the `mosaic doctor`
+ * lease-enforcement surfacing check.
+ *
+ * Root cause under test: enforcement hooks (`mutator-gate.py`,
+ * `receipt-observer-client.py`) can be wired into `~/.claude/settings.json`
+ * on a host where C1's `leaseEnforcementActivatable()` is false and/or C3's
+ * `checkBrokerSupervisorHealth()` reports unhealthy. That combination fails
+ * closed correctly, but must be surfaced LOUDLY by `mosaic doctor` rather
+ * than silently passing — this test suite exercises the three primary
+ * branches (wired+not-activatable, wired+healthy, not-wired) plus the
+ * broker-unhealthy variant.
+ *
+ * Every dependency is injected — no real `~/.claude/settings.json` and no
+ * real broker are ever touched.
+ */
+
+const WIRED_SETTINGS_JSON = JSON.stringify({
+  hooks: {
+    PreToolUse: [
+      {
+        matcher: '.*',
+        hooks: [
+          {
+            type: 'command',
+            command: 'python3 ~/.config/mosaic/tools/lease-broker/mutator-gate.py --runtime claude',
+          },
+        ],
+      },
+    ],
+    Stop: [
+      {
+        hooks: [
+          {
+            type: 'command',
+            command:
+              'python3 ~/.config/mosaic/tools/lease-broker/receipt-observer-client.py --runtime claude --latest-entry',
+          },
+        ],
+      },
+    ],
+  },
+});
+
+const UNWIRED_SETTINGS_JSON = JSON.stringify({
+  hooks: {
+    PostToolUse: [
+      {
+        matcher: 'Edit|MultiEdit|Write',
+        hooks: [{ type: 'command', command: '~/.config/mosaic/tools/qa/qa-hook-stdin.sh' }],
+      },
+    ],
+  },
+});
+
+describe('detectEnforcementHooksWired', () => {
+  it('detects the mutator-gate + receipt-observer markers when wired', () => {
+    const result = detectEnforcementHooksWired(JSON.parse(WIRED_SETTINGS_JSON));
+    expect(result.wired).toBe(true);
+    expect(result.matchedMarkers).toEqual(
+      expect.arrayContaining(['mutator-gate.py', 'receipt-observer-client.py']),
+    );
+  });
+
+  it('reports not wired when no enforcement markers are present', () => {
+    const result = detectEnforcementHooksWired(JSON.parse(UNWIRED_SETTINGS_JSON));
+    expect(result.wired).toBe(false);
+    expect(result.matchedMarkers).toEqual([]);
+  });
+
+  it('reports not wired for an empty settings object', () => {
+    expect(detectEnforcementHooksWired({}).wired).toBe(false);
+  });
+
+  it('detects wiring from just ONE marker (partial wiring is still dangerous)', () => {
+    const onlyMutatorGate = JSON.stringify({
+      hooks: {
+        PreToolUse: [
+          {
+            hooks: [{ type: 'command', command: 'python3 .../mutator-gate.py --runtime claude' }],
+          },
+        ],
+      },
+    });
+    const result = detectEnforcementHooksWired(JSON.parse(onlyMutatorGate));
+    expect(result.wired).toBe(true);
+    expect(result.matchedMarkers).toEqual(['mutator-gate.py']);
+  });
+});
+
+describe('runLeaseEnforcementDoctorCheck', () => {
+  it('RED: wired + not-activatable ⇒ LOUD error (not a silent pass)', async () => {
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => WIRED_SETTINGS_JSON,
+      isActivatable: () => false,
+      isBrokerHealthy: async () => true,
+    });
+
+    expect(result.status).toBe('error');
+    expect(result.wired).toBe(true);
+    expect(result.activatable).toBe(false);
+    expect(result.message).toMatch(/activation absent/);
+    expect(result.message).toMatch(/#869/);
+    expect(result.message.toLowerCase()).toMatch(/brick/);
+  });
+
+  it('wired + activatable + broker-unhealthy ⇒ LOUD error', async () => {
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => WIRED_SETTINGS_JSON,
+      isActivatable: () => true,
+      isBrokerHealthy: async () => false,
+    });
+
+    expect(result.status).toBe('error');
+    expect(result.wired).toBe(true);
+    expect(result.brokerHealthy).toBe(false);
+    expect(result.message).toMatch(/broker not healthy/);
+  });
+
+  it('wired + not-activatable + broker-unhealthy ⇒ LOUD error citing both reasons', async () => {
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => WIRED_SETTINGS_JSON,
+      isActivatable: () => false,
+      isBrokerHealthy: async () => false,
+    });
+
+    expect(result.status).toBe('error');
+    expect(result.message).toMatch(/activation absent/);
+    expect(result.message).toMatch(/broker not healthy/);
+  });
+
+  it('GREEN: wired + activatable + broker-healthy ⇒ ok', async () => {
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => WIRED_SETTINGS_JSON,
+      isActivatable: () => true,
+      isBrokerHealthy: async () => true,
+    });
+
+    expect(result.status).toBe('ok');
+    expect(result.wired).toBe(true);
+    expect(result.activatable).toBe(true);
+    expect(result.brokerHealthy).toBe(true);
+  });
+
+  it('GREEN: not-wired ⇒ ok, no false alarm (activation/broker never probed)', async () => {
+    let activatableCalled = false;
+    let brokerCalled = false;
+
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => UNWIRED_SETTINGS_JSON,
+      isActivatable: () => {
+        activatableCalled = true;
+        return false;
+      },
+      isBrokerHealthy: async () => {
+        brokerCalled = true;
+        return false;
+      },
+    });
+
+    expect(result.status).toBe('ok');
+    expect(result.wired).toBe(false);
+    expect(result.activatable).toBeNull();
+    expect(result.brokerHealthy).toBeNull();
+    // Not wired must short-circuit — never even consult activation/broker.
+    expect(activatableCalled).toBe(false);
+    expect(brokerCalled).toBe(false);
+  });
+
+  it('GREEN: settings.json absent ⇒ ok (never touches a real file — readSettingsRaw is injected)', async () => {
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => null,
+      isActivatable: () => false,
+      isBrokerHealthy: async () => false,
+    });
+
+    expect(result.status).toBe('ok');
+    expect(result.wired).toBe(false);
+  });
+
+  it('GREEN: malformed settings.json ⇒ ok (parse errors are not this card’s failure class)', async () => {
+    const result = await runLeaseEnforcementDoctorCheck({
+      readSettingsRaw: () => '{ not valid json',
+      isActivatable: () => false,
+      isBrokerHealthy: async () => false,
+    });
+
+    expect(result.status).toBe('ok');
+  });
+});

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

@@ -0,0 +1,210 @@
+/**
+ * Lease-enforcement doctor check (issue #869, Point-1 card C5).
+ *
+ * Root cause this guards against (#828 version skew, the same one C1/C3
+ * exist for): the Claude Code enforcement hooks (`mutator-gate.py` gating
+ * PreToolUse, `receipt-observer-client.py` observing Stop) can be WIRED into
+ * `~/.claude/settings.json` on a host where the ACTIVATION half is absent —
+ * no compatible CLI build (C1's `leaseEnforcementActivatable()`), or no
+ * healthy broker supervisor (C3's `checkBrokerSupervisorHealth()`). That
+ * combination is a silent brick: every gated tool call denies with
+ * GATE_UNAVAILABLE, and the fail-closed behavior is *correct* — but nothing
+ * surfaces it to an operator running `mosaic doctor` on an already-bricked
+ * host.
+ *
+ * This module answers one question — "if I ran right now, would I be
+ * bricked?" — by combining:
+ *
+ *   1. wiring detection: does `~/.claude/settings.json` reference either
+ *      enforcement-hook marker (`mutator-gate.py` / `receipt-observer-client.py`)?
+ *   2. C1's `leaseEnforcementActivatable()` — could activation satisfy
+ *      enforcement if it were exercised right now?
+ *   3. C3's `checkBrokerSupervisorHealth()` — is the broker supervisor
+ *      actually healthy?
+ *
+ * Not wired ⇒ ok (nothing to activate, no false alarm). Wired AND activatable
+ * AND broker-healthy ⇒ ok. Wired AND (NOT activatable OR broker unhealthy) ⇒
+ * a LOUD, actionable error — this module never silently passes that state.
+ *
+ * Every dependency (settings read, activation probe, broker-health check) is
+ * injectable so tests can drive every branch without ever touching a real
+ * `~/.claude/settings.json` or a real broker.
+ */
+
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { leaseEnforcementActivatable, type ActivationProbeDeps } from './lease-activation-probe.js';
+import {
+  checkBrokerSupervisorHealth,
+  resolveBrokerSupervisorPaths,
+} from '../lease-broker/broker-supervisor.js';
+import { DEFAULT_MOSAIC_HOME } from '../constants.js';
+
+/** Markers identifying the two enforcement-hook halves wired via the
+ * framework reseed. Either marker's presence in `settings.json` means
+ * enforcement is wired — a host can be bricked with just one half present. */
+const ENFORCEMENT_HOOK_MARKERS = ['mutator-gate.py', 'receipt-observer-client.py'] as const;
+
+export interface EnforcementHooksWiredResult {
+  readonly wired: boolean;
+  readonly matchedMarkers: readonly string[];
+}
+
+/**
+ * Detect whether the Claude Code enforcement hooks (mutator-gate /
+ * receipt-observer) are wired into an already-parsed `settings.json`.
+ * Pure/testable — takes parsed JSON, never touches the filesystem itself.
+ */
+export function detectEnforcementHooksWired(settings: unknown): EnforcementHooksWiredResult {
+  const serialized = JSON.stringify(settings ?? {});
+  const matchedMarkers = ENFORCEMENT_HOOK_MARKERS.filter((marker) => serialized.includes(marker));
+  return { wired: matchedMarkers.length > 0, matchedMarkers };
+}
+
+export interface LeaseDoctorCheckDeps {
+  /**
+   * Read raw `settings.json` text; return `null` if the file is absent.
+   * Defaults to reading the real `~/.claude/settings.json`. ALWAYS inject a
+   * fake in tests — never point this at a real host's settings file.
+   */
+  readSettingsRaw?: () => string | null;
+  /** Defaults to {@link leaseEnforcementActivatable} (C1). Inject for tests. */
+  isActivatable?: (deps?: ActivationProbeDeps) => boolean;
+  /**
+   * Defaults to a real broker-supervisor health check (C3) rooted at
+   * `mosaicHome`. Inject for tests — never point this at a real broker.
+   */
+  isBrokerHealthy?: () => Promise<boolean>;
+  /** Mosaic home used to resolve default broker-supervisor paths. Defaults to
+   * `$MOSAIC_HOME` or `~/.config/mosaic`. */
+  mosaicHome?: string;
+}
+
+export type LeaseDoctorCheckStatus = 'ok' | 'error';
+
+export interface LeaseDoctorCheckResult {
+  readonly status: LeaseDoctorCheckStatus;
+  readonly wired: boolean;
+  /** `null` when hooks are not wired (activation/broker were never probed). */
+  readonly activatable: boolean | null;
+  /** `null` when hooks are not wired (activation/broker were never probed). */
+  readonly brokerHealthy: boolean | null;
+  readonly message: string;
+}
+
+function defaultReadSettingsRaw(): string | null {
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  try {
+    return readFileSync(settingsPath, 'utf8');
+  } catch (error) {
+    if (isEnoent(error)) return null;
+    throw error;
+  }
+}
+
+function isEnoent(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    (error as NodeJS.ErrnoException).code === 'ENOENT'
+  );
+}
+
+function defaultMosaicHome(): string {
+  return process.env['MOSAIC_HOME'] ?? DEFAULT_MOSAIC_HOME;
+}
+
+async function defaultIsBrokerHealthy(mosaicHome: string): Promise<boolean> {
+  // `frameworkRoot` only feeds SOURCE paths (unit/wrapper/daemon file
+  // locations for `applyBrokerSupervisor`); the health check only reads
+  // TARGET paths (`unitTargetPath`, `socketPath`), both derived from
+  // `mosaicHome`/`homeDir`/`env` alone. Passing `mosaicHome` again here is
+  // therefore safe and never resolves or touches a framework checkout.
+  const paths = resolveBrokerSupervisorPaths({ mosaicHome, frameworkRoot: mosaicHome });
+  return (await checkBrokerSupervisorHealth(paths)).healthy;
+}
+
+/**
+ * Surface the #869 fail-closed brick scenario as a LOUD `mosaic doctor`
+ * error. See module docstring for the full decision table.
+ */
+export async function runLeaseEnforcementDoctorCheck(
+  deps: LeaseDoctorCheckDeps = {},
+): Promise<LeaseDoctorCheckResult> {
+  const readSettingsRaw = deps.readSettingsRaw ?? defaultReadSettingsRaw;
+  const mosaicHome = deps.mosaicHome ?? defaultMosaicHome();
+  const isActivatable = deps.isActivatable ?? leaseEnforcementActivatable;
+  const isBrokerHealthy = deps.isBrokerHealthy ?? (() => defaultIsBrokerHealthy(mosaicHome));
+
+  const raw = readSettingsRaw();
+  if (raw === null) {
+    return {
+      status: 'ok',
+      wired: false,
+      activatable: null,
+      brokerHealthy: null,
+      message: 'Claude Code settings.json not found — lease-enforcement hooks not wired.',
+    };
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    // Malformed settings.json is a different failure class than this card
+    // owns (C2 guards install-time writes); report ok rather than
+    // misattributing a parse error to the #869 activation gap.
+    return {
+      status: 'ok',
+      wired: false,
+      activatable: null,
+      brokerHealthy: null,
+      message:
+        'Claude Code settings.json could not be parsed — skipping lease-enforcement wiring check.',
+    };
+  }
+
+  const { wired, matchedMarkers } = detectEnforcementHooksWired(parsed);
+  if (!wired) {
+    return {
+      status: 'ok',
+      wired: false,
+      activatable: null,
+      brokerHealthy: null,
+      message:
+        'Lease-enforcement hooks not wired in ~/.claude/settings.json — nothing to activate.',
+    };
+  }
+
+  const activatable = isActivatable();
+  const brokerHealthy = await isBrokerHealthy();
+
+  if (activatable && brokerHealthy) {
+    return {
+      status: 'ok',
+      wired: true,
+      activatable,
+      brokerHealthy,
+      message: `Lease-enforcement hooks wired (${matchedMarkers.join(', ')}) — activation capability present and broker healthy.`,
+    };
+  }
+
+  const reasons: string[] = [];
+  if (!activatable) reasons.push('activation absent (leaseEnforcementActivatable() is false)');
+  if (!brokerHealthy) {
+    reasons.push('broker not healthy (checkBrokerSupervisorHealth() reports unhealthy)');
+  }
+
+  return {
+    status: 'error',
+    wired: true,
+    activatable,
+    brokerHealthy,
+    message:
+      `Lease-enforcement hooks (${matchedMarkers.join(', ')}) are wired in ~/.claude/settings.json, but ${reasons.join(' and ')}. ` +
+      'Every gated tool call will fail closed and BRICK this agent (see #869). ' +
+      'Remediate by activating the lease-broker supervisor (systemd unit + socket) or by removing the enforcement hooks from ~/.claude/settings.json.',
+  };
+}