Merge branch 'master' into feat/issue-665-restart-audit

#930 inventoried stdio coupling; nothing stated what the adversary is, what
each boundary protects, or why one process may hold credentials for several
services. This adds that document as child 2 of epic #929.

Adds docs/remote-mcp/threat-model.md covering 10 assets, the 5 adversaries
#956 names, 9 trust boundaries, the data flows between them, a 14-entry
per-boundary credential inventory, and an explicit decomposition ruling.

Findings established from live native evidence at this commit:

- Four prgs roles (reviewer, merger, reconciler, controller) resolve to one
  Gitea account, so separation of duty between approving and landing is
  enforced only by which process a call reaches. The mdcps tenant has no role
  separation at all: author, reviewer, and merger share one account.
- Any one role process can resolve every other role's credential.
  gitea_list_profiles reports "credentials present" for other roles because it
  calls resolve_token on each one.
- The Gitea server reads Jenkins and GlitchTip secrets out of the keychain to
  produce the "authenticated" word in gitea_audit_config's service summaries.
- Jenkins and GlitchTip were already decomposed into separate MCP servers; the
  credential references were left behind in the Gitea configuration.

Ruling D1 forbids a single integration process from holding credentials for
unrelated services, with one time-boxed dual-run exception for the local fleet
that expires with #939. D2 requires separation of duty to be credential-backed,
D3 scopes credential resolution to the request principal, and D4 gives
coordination state its own authority. Every #929 child from 2 through 10 is
mapped to the boundary it implements.

Anchors are enforced rather than asserted. #930's inventory anchors into
gitea_mcp_server.py had already drifted between 7bf4f125 and aad5c8b4 with
nothing detecting it, so this change ships the guard that was missing:
docs/remote-mcp/threat-model-anchors.json declares all 58 anchors with the
substring each must contain, and tests/test_issue_956_threat_model.py fails if
any anchor does not resolve, if the document cites an anchor the fixture does
not cover, or if the structural obligations regress.

Documentation only. No server behavior changes.

Tests:
- tests/test_issue_956_threat_model.py: 17 passed.
- Four sabotage probes confirm the validator is not passing vacuously
  (shifted anchor, undeclared citation, broken count tally, and a blanked
  boundary owner). The last two probes exposed real weaknesses in the checks
  themselves, which were fixed: the section slice now stops at the next
  heading, and boundary ownership is read only from mapping table rows.
- Docs-sensitive sweep (17 modules referencing docs/): 559 passed.
- Full suite: 30 failed, 5799 passed, 6 skipped. All 30 reproduce on a clean
  base worktree at aad5c8b4; branch failures are a strict subset of base
  failures. No production file is modified by this change.

Closes #956

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

docs/mcp-restart-audit.md

@@ -0,0 +1,93 @@
+# MCP restart audit events and incidents (#665)
+
+Restarts and recovery attempts leave a forensic trail. Failed drains and
+break-glass paths also raise durable Gitea incident issues so unsafe restarts
+cannot be silently repeated.
+
+Parent umbrella: **#655**. Related: impact coordinator **#658**, drain proof
+**#661**, restart classes **#663**, break-glass **#664**, post-restart reconcile
+**#662**, vision **#652**, roadmap **#653**, console recovery **#642**.
+
+## Components
+
+| Piece | Where | Responsibility |
+|-------|-------|----------------|
+| Event schema + emission | `restart_audit.py` | `mcp.restart.*` vocabulary, redacted payload builder, append-only sink via `gitea_audit` |
+| Fail-closed privileged gate | `restart_audit.require_audit_or_deny` | When `GITEA_AUDIT_LOG` is set and the write fails, privileged apply is denied |
+| Incident descriptors | `restart_audit.build_incident_descriptor` | Durable follow-up issues (failed drain, break-glass, reconcile unresolved, unguarded) |
+| Materializer | `restart_audit.materialize_incident` | Injected `create_issue_fn` (network kept out of pure tests) |
+| Wiring | `gitea_request_mcp_restart` | Correlation id, impact-preview audit, apply-gate / break-glass audit + incident creation |
+
+## Event vocabulary
+
+| Event type | When |
+|------------|------|
+| `mcp.restart.impact_preview` | Every `gitea_request_mcp_restart` evaluation |
+| `mcp.restart.drain_enter` | Drain window starts (schema reserved; emit from drain path) |
+| `mcp.restart.drain_exit` | Drain window ends |
+| `mcp.restart.drain_proof` | Drain-proof verification result |
+| `mcp.restart.apply_gate` | Apply hard gate (`dry_run=False`) |
+| `mcp.restart.break_glass` | Authorized break-glass bypass |
+| `mcp.restart.post_restart_reconcile` | Post-restart reconcile outcome |
+| `mcp.restart.narrower_recovery` | Narrower recovery attempt recorded |
+| `mcp.restart.unguarded_detected` | Unguarded restart path detected |
+
+All free text is redacted before sink write or issue body assembly. Emission
+never raises; callers decide fail-closed policy.
+
+## Correlation
+
+Each restart lifecycle mints a short `correlation_id` (`rst-` + 16 hex) shared
+across impact preview → apply gate → incident descriptors so operators can join
+the trail.
+
+## Privileged deny-on-audit-fail
+
+Rollout policy (issue #665):
+
+1. Configure `GITEA_AUDIT_LOG` so writes land.
+2. Only then enforce deny when a privileged restart path cannot audit.
+
+When audit is **not** configured, privileged apply still proceeds (no false
+denials during rollout). When audit **is** configured and the write fails,
+`apply_authorized` is cleared.
+
+## Incidents
+
+| Kind | Trigger |
+|------|---------|
+| `restart_failed_drain` | Apply denied by drain hard gate / failed proof |
+| `restart_break_glass` | Any authorized break-glass apply |
+| `restart_reconcile_unresolved` | Post-restart reconcile left work unresolved |
+| `restart_unguarded_detected` | Unguarded restart attempt detected |
+
+Break-glass **always** creates an incident descriptor (and a Gitea issue when
+the create path is available). Failed drain does the same. Incident bodies
+include correlation id, session, class, scope, proof id, and redacted reasons.
+
+Default labels: `mcp-health`, `safety`, `observability`, `status:ready`,
+`type:bug`, `workflow-hardening`.
+
+## Tool payload surface
+
+`gitea_request_mcp_restart` returns:
+
+* `correlation_id` — lifecycle join key
+* `restart_audit.impact_preview_written` — sink success for the preview event
+* `restart_audit.apply_gate_written` — sink success for apply/break-glass (apply only)
+* `restart_audit.incident_result` — materialization outcome when an incident was required
+* `incident` — durable descriptor (when gate requires follow-up)
+
+## Security
+
+* No secrets in audit payloads or issue bodies.
+* This module never restarts a process.
+* Drain proof verification remains #661; audit only records the decision.
+* Incident creation failures are recorded in `incident_result.reasons` and never
+  crash the restart evaluation path (audit write failure still fails closed for
+  privileged apply when the sink is enabled).
+
+## Tests
+
+See `tests/test_restart_audit.py`: schema, redaction, emission, deny policy,
+incident materialization mocks, break-glass / failed-drain selection.

docs/mcp-restart-coordinator.md

@@ -33,6 +33,7 @@ recovery behavior for all nine classes.
 | `ControlPlaneDB.list_sessions` | `control_plane_db.py` | Read-only session inventory (the process-level unit a restart kills). |
 | `gitea_request_mcp_restart` | `gitea_mcp_server.py` | MCP tool: gathers inventory from the #613 DB, calls the coordinator, returns the report, and on `dry_run=False` runs the #661 drain-proof hard gate. Never restarts a process. |
 | `drain_proof.gate_apply_restart` | `drain_proof.py` | The #661 hard gate: verifies a drain proof against the current impact fingerprint, or records an authorized break-glass bypass. |
+| `restart_audit` | `restart_audit.py` | #665 forensic trail: `mcp.restart.*` events via `gitea_audit`, correlation ids, durable incidents for failed drain / break-glass. See [`mcp-restart-audit.md`](./mcp-restart-audit.md). |
 
 ## Dimensions evaluated
 

docs/remote-mcp/threat-model-anchors.json

@@ -0,0 +1,80 @@
+{
+  "_comment": [
+    "Machine-checkable anchor table for docs/remote-mcp/threat-model.md (#956).",
+    "Every file:line anchor cited in the threat model must appear here, and the",
+    "source line at that anchor must contain the 'expect' substring.",
+    "tests/test_issue_956_threat_model.py enforces both directions, so a refactor",
+    "that shifts a line number fails the suite instead of silently rotting the",
+    "document. #930's inventory had no such guard and its gitea_mcp_server.py",
+    "anchors drifted between 7bf4f125 and aad5c8b4."
+  ],
+  "generated_against_commit": "aad5c8b42361d380a8eeb07b94b90815e594c2c5",
+  "anchors": [
+    {"anchor": "gitea_mcp_server.py:24721", "expect": "bind_native_mcp_transport(transport=\"stdio\")"},
+    {"anchor": "mcp_daemon_guard.py:45", "expect": "_PRODUCTION_TRANSPORTS = frozenset({\"stdio\"})"},
+    {"anchor": "mcp_daemon_guard.py:174", "expect": "def bind_native_mcp_transport"},
+    {"anchor": "irrecoverable_provenance.py:497", "expect": "def assess_transport_for_auth_mint"},
+    {"anchor": "gitea_mcp_server.py:9129", "expect": "assess_transport_for_auth_mint()"},
+    {"anchor": "gitea_mcp_server.py:9378", "expect": "assess_transport_for_auth_mint()"},
+    {"anchor": "mcp_server.py:4", "expect": "Runs over stdio."},
+
+    {"anchor": "gitea_mcp_server.py:15412", "expect": "def _is_client_managed_process"},
+    {"anchor": "gitea_mcp_server.py:15442", "expect": "def _provenance_mutation_block"},
+    {"anchor": "gitea_mcp_server.py:15450", "expect": "unsupported_manual_launch"},
+    {"anchor": "gitea_mcp_server.py:19001", "expect": "server_provenance"},
+    {"anchor": "gitea_mcp_server.py:21442", "expect": "def _check_mcp_runtimes_diagnostics"},
+    {"anchor": "gitea_mcp_server.py:21462", "expect": "\"ps\", \"-o\", \"pid,lstart,command\""},
+    {"anchor": "gitea_mcp_server.py:21506", "expect": "\"ps\", \"eww\""},
+    {"anchor": "gitea_config.py:1172", "expect": "RECOGNIZED_GITEA_ENV_KEYS"},
+    {"anchor": "gitea_config.py:1233", "expect": "GITEA_CLIENT_MANAGED"},
+
+    {"anchor": "gitea_config.py:54", "expect": "ENV_PROFILE = \"GITEA_MCP_PROFILE\""},
+    {"anchor": "gitea_config.py:97", "expect": "_REVIEW_MERGE_OPS"},
+    {"anchor": "gitea_config.py:499", "expect": "repository authorization scope"},
+
+    {"anchor": "gitea_config.py:956", "expect": "def _keychain_token"},
+    {"anchor": "gitea_config.py:974", "expect": "def resolve_token"},
+    {"anchor": "gitea_config.py:1015", "expect": "def keychain_auth"},
+    {"anchor": "gitea_config.py:294", "expect": "def _validate_identity_auth"},
+    {"anchor": "mcp_daemon_guard.py:440", "expect": "def assert_keychain_access_allowed"},
+    {"anchor": "gitea_mcp_server.py:19258", "expect": "def gitea_list_profiles"},
+    {"anchor": "gitea_mcp_server.py:19309", "expect": "gitea_config.resolve_token(p)"},
+    {"anchor": "gitea_mcp_server.py:19552", "expect": "def gitea_audit_config"},
+    {"anchor": "gitea_mcp_server.py:19574", "expect": "service_summaries(config)"},
+
+    {"anchor": "gitea_config.py:704", "expect": "def resolve_service"},
+    {"anchor": "gitea_config.py:837", "expect": "def service_summaries"},
+    {"anchor": "gitea_config.py:851", "expect": "_keychain_token(auth.get(\"id\"))"},
+    {"anchor": "gitea_mcp_server.py:17707", "expect": "\"jenkins-mcp\""},
+    {"anchor": "gitea_mcp_server.py:17713", "expect": "external-mcp"},
+    {"anchor": "gitea_mcp_server.py:17734", "expect": "\"glitchtip-mcp\""},
+    {"anchor": "gitea_mcp_server.py:17739", "expect": "external-mcp"},
+    {"anchor": "mcp_discoverability.py:9", "expect": "EXPECTED_JENKINS_TOOLS"},
+    {"anchor": "mcp_discoverability.py:17", "expect": "EXPECTED_GLITCHTIP_TOOLS"},
+
+    {"anchor": "sentry_incident_bridge.py:36", "expect": "SENTRY_AUTH_TOKEN"},
+    {"anchor": "sentry_incident_bridge.py:190", "expect": "def resolve_token"},
+    {"anchor": "sentry_incident_bridge.py:289", "expect": "Authorization"},
+    {"anchor": "sentry_observability.py:55", "expect": "SENTRY_DSN"},
+
+    {"anchor": "master_parity_gate.py:168", "expect": "def capture_startup_parity"},
+    {"anchor": "master_parity_gate.py:255", "expect": "mutation_safe"},
+    {"anchor": "gitea_mcp_server.py:19102", "expect": "def gitea_assess_master_parity"},
+
+    {"anchor": "gitea_mcp_server.py:190", "expect": "ACTIVE_WORKTREE_ENV"},
+    {"anchor": "gitea_mcp_server.py:191", "expect": "AUTHOR_WORKTREE_ENV"},
+    {"anchor": "gitea_mcp_server.py:2348", "expect": "/tmp/gitea_issue_lock.json"},
+    {"anchor": "gitea_mcp_server.py:10894", "expect": "def gitea_bootstrap_author_issue_worktree"},
+    {"anchor": "mcp_server.py:10", "expect": "/tmp/mcp_server_stderr.log"},
+
+    {"anchor": "issue_lock_store.py:26", "expect": "DEFAULT_LOCK_DIR"},
+    {"anchor": "issue_lock_store.py:83", "expect": "def session_pointer_path"},
+    {"anchor": "issue_lock_store.py:98", "expect": "def is_process_alive"},
+    {"anchor": "mcp_session_state.py:27", "expect": "DEFAULT_STATE_DIR"},
+    {"anchor": "control_plane_db.py:47", "expect": "DEFAULT_DB_PATH"},
+    {"anchor": "control_plane_db.py:380", "expect": "mode=0o700"},
+    {"anchor": "control_plane_db.py:386", "expect": "sqlite3.connect"},
+    {"anchor": "control_plane_db.py:1145", "expect": "os.getpid()"},
+    {"anchor": "gitea_mcp_server.py:12801", "expect": "owner_pid_alive"}
+  ]
+}

docs/remote-mcp/threat-model.md

@@ -0,0 +1,403 @@
+# Remote-MCP threat model, trust boundaries, and service decomposition
+
+What the adversary is, what each boundary protects, and which services may share a process.
+
+- **Issue:** #956 (Remote-MCP threat model), child of epic #929, cross-linked to #955.
+- **Depends on:** #930 (closed) — `docs/remote-mcp/coupling-inventory.md`.
+- **Blocks:** #932, #933, #934, #938.
+- **Generated against commit:** `aad5c8b42361d380a8eeb07b94b90815e594c2c5` (`master`).
+- **Scope:** documentation only. This child changes no server behavior. It adds one
+  document, one anchor fixture, and the test that enforces them.
+
+## Relationship to #930
+
+#930 asked *what breaks when the process stops being local*. This document asks *what an
+attacker gets, and where we stop them*. The two are deliberately different axes: #930
+classifies each coupling as portable, seam, replacement, or cannot-be-remote; this document
+classifies each **credential** by blast radius and each **boundary** by what crossing it
+requires. An entry can be perfectly portable and still be a trust disaster —
+`gitea_config.py:851` is portable Python that reads a CI secret from inside the Gitea server.
+
+### Anchors are enforced, not asserted
+
+Every `file:line` in this document is declared in `docs/remote-mcp/threat-model-anchors.json`
+with the substring that must appear at that line, and
+`tests/test_issue_956_threat_model.py` fails if any anchor does not resolve or if the
+document cites an anchor the fixture does not cover.
+
+This guard exists because #930 did not have one. Its inventory was generated at
+`7bf4f125`; by `aad5c8b4` its `gitea_mcp_server.py` anchors had drifted — the transport
+bind it cited at line 23750 now lives at `gitea_mcp_server.py:24721`, and its
+client-managed provenance anchor at 14588 now lands in an unrelated function. Nothing
+failed, because nothing checked. Anchors into a ~24,700-line module rot silently, and a
+security document that cannot prove its own citations is worse than none, because it is
+trusted.
+
+---
+
+## 1. Assets
+
+What an adversary wants. Ordered by consequence, not by likelihood.
+
+| ID | Asset | Why it matters |
+| -- | ----- | -------------- |
+| A1 | Merge authority on `Scaled-Tech-Consulting/Gitea-Tools` | This repository *is* the control plane. Code merged here becomes the gate that authorizes every future mutation, so merge authority is self-amplifying: one merge can disable every other control in this document. |
+| A2 | Write authority on the `mdcps` tenant | A second, unrelated organization reachable from the same configuration. Compromise here is a cross-organization incident, not an internal one. |
+| A3 | The eight Gitea role credentials | Long-lived bearer tokens. Possession is authority; there is no second factor at the API. |
+| A4 | Jenkins read access (`mdcps`, enabled) | Build logs routinely carry deployment topology, internal hostnames, and accidentally-echoed secrets. |
+| A5 | Error-tracking read access (GlitchTip / Sentry) | Event payloads carry stack frames, request context, and production user data. |
+| A6 | Coordination-state integrity | The locks, leases, and review-decision records that make "exactly one owner" true. Corrupting them needs no Gitea credential and produces duplicate or lost work. |
+| A7 | The operator's checkout and worktrees | Unmerged code, branch state, and the filesystem the author tools write to. |
+| A8 | The macOS login keychain | The meta-credential. Everything in A3, A4, and A5 resolves from it. |
+| A9 | Separation of duty between review and merge | The property that no single actor both approves and lands a change. An *asset*, not a control, because it is what the controls exist to produce. |
+| A10 | Audit and provenance records | Determine whether an incident is reconstructable. An attacker who can forge provenance makes an intrusion indistinguishable from normal work. |
+
+## 2. Adversaries
+
+| ID | Adversary | Capability assumed | Not assumed |
+| -- | --------- | ------------------ | ----------- |
+| ADV1 | **Compromised LLM client** | Full control of one MCP client. Issues arbitrary tool calls, in any order, with any arguments, at machine speed. Sees every tool result. | Cannot read the operator's disk except through tools; cannot execute arbitrary local code outside the tool surface. |
+| ADV2 | **Prompt injection** via repository content | Controls text the model reads and treats as instruction — issue bodies, PR descriptions, review comments, commit messages, file contents. Reaches the model on any read of untrusted content. | Holds no credential and issues no call directly. Its entire power is causing an *authorized* client to act. |
+| ADV3 | **Malicious tool arguments** | Supplies hostile values to any parameter — paths, branch names, session identifiers, worktree paths, issue numbers — including traversal, injection, and confusion between look-alike identifiers. | Cannot bypass a gate that actually validates its input. |
+| ADV4 | **Network attacker** | Observes and modifies traffic between client, server, and Gitea. Attempts downgrade, replay, and endpoint impersonation. | Does not hold a valid credential at the start. |
+| ADV5 | **Curious operator** | Legitimate local access to the workstation: process table, `/tmp`, home directory, keychain prompts. Not malicious, but not authorized for every role either. | Does not defeat the OS keychain's own access control without a prompt. |
+
+ADV2 is the adversary this architecture most under-models. Every other adversary must first
+obtain something. Prompt injection obtains nothing: it borrows authority the client already
+holds and is indistinguishable at the tool boundary from legitimate work. Each boundary
+below therefore states whether it constrains ADV2 at all — and most do not, because they
+authenticate the *caller*, not the *intent*.
+
+## 3. Trust boundaries
+
+"Crossing requires today" is what the code actually enforces at
+`aad5c8b42361d380a8eeb07b94b90815e594c2c5`, not what the design intends.
+
+| ID | Boundary | Protects | Crossing requires today | Crossing must require remotely |
+| -- | -------- | -------- | ----------------------- | ------------------------------ |
+| B1 | LLM client ↔ MCP server session | A1, A3, A10 — that a mutating session was established through the sanctioned client path | A literal `stdio` bind (`gitea_mcp_server.py:24721`) inside a closed allowlist (`mcp_daemon_guard.py:45`, `mcp_daemon_guard.py:174`); client-managed provenance (`gitea_mcp_server.py:15412`) or a refusal (`gitea_mcp_server.py:15450`); production transport before recovery-authorization mint (`irrecoverable_provenance.py:497`, consumed at `gitea_mcp_server.py:9129` and `gitea_mcp_server.py:9378`) | An authenticated handshake issuing a server-side session identity bound to a principal, with the transport recorded in provenance. The physical proof (a pipe) must become a cryptographic one. |
+| B2 | Role ↔ role | A9 — that author, reviewer, merger, and reconciler are distinct authorities | **The process boundary only.** The role is a property of the process, read once from `GITEA_MCP_PROFILE` (`gitea_config.py:54`). A caller gets author permissions by connecting to the author process. Review and merge are the operations singled out for extra care (`gitea_config.py:97`) | A per-request principal, so the role follows from the credential presented and cannot be selected by reaching a different endpoint. |
+| B3 | MCP server ↔ credential store | A3, A8 — that only sanctioned code turns a profile into a token | `_keychain_token` shelling out to the login keychain (`gitea_config.py:956`), dispatched by `resolve_token` (`gitea_config.py:974`) with the reference type built at `gitea_config.py:1015`, gated by `assert_keychain_access_allowed` (`mcp_daemon_guard.py:440`). Inline secrets are rejected at config load (`gitea_config.py:294`) | A credential provider keyed by the *request* principal, returning only that principal's credential, with the source recorded and the value never returned. |
+| B4 | MCP server ↔ Gitea | A1, A2 — that only authorized calls reach the forge | A bearer token over TLS. Server-side, nothing distinguishes one role's token from another beyond the account it belongs to | Unchanged at the forge; the endpoint in front of it must refuse unauthenticated and plaintext connections before tool dispatch. |
+| B5 | MCP server ↔ caller's filesystem | A7 — that a tool acts on the *caller's* disk or refuses | Nothing. The server's disk *is* the caller's disk. Worktree bootstrap writes directly (`gitea_mcp_server.py:10894`); the active workspace is process-global (`gitea_mcp_server.py:190`, `gitea_mcp_server.py:191`) | An explicit per-tool classification, enforced at dispatch, refusing filesystem tools over a transport that cannot reach the caller's disk. A green verdict about the wrong disk is the failure to prevent. |
+| B6 | MCP server ↔ coordination state | A6, A9 — mutual exclusion | Local files and a local SQLite database, with liveness judged from the local process table (`issue_lock_store.py:98`), keyed on paths under one user's home (`issue_lock_store.py:26`, `mcp_session_state.py:27`, `control_plane_db.py:47`) and on `os.getpid()` (`control_plane_db.py:1145`, `gitea_mcp_server.py:12801`). A legacy global slot still exists at `gitea_mcp_server.py:2348`, and the session-pointer file is named per PID (`issue_lock_store.py:83`) | One authority per ownership question, with liveness from session identity and expiry, and atomic acquire, renew, and release across hosts. |
+| B7 | Gitea integration ↔ unrelated integrations | A4, A5 — that a Gitea compromise is not a CI and observability compromise | **Nothing.** See §5. The Gitea server reads Jenkins and GlitchTip secrets (`gitea_config.py:851`, reached from `gitea_config.py:837`) and holds the Sentry token (`sentry_incident_bridge.py:190`) | A hard process boundary. This is the boundary #956 exists to create. |
+| B8 | Tenant ↔ tenant (`prgs` / `mdcps` / `local-lab`) | A2 — that one organization's compromise is not another's | Convention. One configuration declares all three contexts; `resolve_service` fails closed on a *disabled* context (`gitea_config.py:704`) but the credentials of enabled ones remain reachable in-process. A per-profile repository scope exists (`gitea_config.py:499`) | Separate deployments, or at minimum per-tenant credential scopes with no process able to resolve both. |
+| B9 | Deployed code ↔ merged policy | A1, A10 — that the running server enforces the rules that were actually merged | Comparing this process's startup commit against this disk (`master_parity_gate.py:168`), conjoined into a single verdict (`master_parity_gate.py:255`) published by `gitea_mcp_server.py:19102` | Freshness defined against the deployed build identity, with an explicit fail-closed verdict when undeterminable. |
+
+### What no boundary constrains
+
+None of B1–B9 constrains **ADV2**. Every one authenticates a caller or a process; prompt
+injection supplies neither. An injected instruction that reaches an authorized author
+session crosses B1, B2, B3, and B5 legitimately, because at each of those boundaries it *is*
+the author. The only controls that bite ADV2 are those constraining what an authenticated
+principal may do regardless of what it asks for — the per-role permission split (B2), the
+repository scope at `gitea_config.py:499`, and separation of duty (A9). Sizing those
+controls correctly matters more after the migration, not less, because a remote endpoint
+raises the number of clients that can be injected into.
+
+## 4. Data flows
+
+Flows that cross a boundary. `==>` carries a credential; `-->` does not.
+
+```
+                          B1                         B4
+  [LLM client] ====================> [MCP server] ========> [Gitea]
+        ^        stdio pipe today          |  ^               (A1,A2)
+        |        session identity          |  |
+        |        after migration           |  |
+        |                                  |  | B3
+   untrusted repository content            |  +======> [macOS login keychain] (A8)
+   read back into the model (ADV2)         |              resolves A3, A4, A5
+        ^                                  |
+        +----------------------------------+
+                                           |
+                  B5                       |  B6
+   [operator checkout / worktrees] <--------+-------> [locks · leases · sqlite]
+              (A7)                         |                  (A6)
+                                           |
+                  B7  <-- boundary does not exist today
+                                           |
+                  +========================+========================+
+                  |                        |                        |
+            [Jenkins] (A4)         [GlitchTip] (A5)          [Sentry] (A5)
+        external MCP server      external MCP server      in-process bridge
+```
+
+Two flows deserve attention because neither is obvious from the code:
+
+1. **The keychain flow fans out.** B3 is drawn once but resolves credentials for *every*
+   configured profile and service, not only the active one. `gitea_list_profiles`
+   (`gitea_mcp_server.py:19258`) reports each profile's credential status by calling
+   `resolve_token` on it (`gitea_mcp_server.py:19309`), and `gitea_audit_config`
+   (`gitea_mcp_server.py:19552`) reports service credential status through
+   `service_summaries` (`gitea_mcp_server.py:19574`).
+2. **The return path is a flow too.** Content read from Gitea travels back into the model
+   and is treated as instruction. This is the ADV2 edge, and it is the only edge in the
+   diagram with no authentication on it, because it is not a request.
+
+## 5. Per-boundary credential inventory
+
+**14 credentials in total.** Blast radius is stated as what the credential yields *on its
+own*, assuming every gate not backed by the credential itself has been bypassed — because
+an attacker holding a token calls the API, not our tools.
+
+| ID | Credential | Holder | Boundary | Blast radius |
+| -- | ---------- | ------ | -------- | ------------ |
+| CR1 | `prgs-author` Gitea token — account `jcwalker3` | macOS keychain; resolved in-process (`gitea_config.py:974`) | B3 → B4 | Create branches, push, commit, open PRs, create/close/comment issues on the control-plane repo. Cannot approve or merge. The one credential whose identity is genuinely distinct. |
+| CR2 | `prgs-reviewer` Gitea token — account `sysadmin` | macOS keychain | B3 → B4 | Approve and request changes. **Shares one Gitea account with CR3, CR4, CR5.** |
+| CR3 | `prgs-merger` Gitea token — account `sysadmin` | macOS keychain | B3 → B4 | Merge to `master` — A1 in full. Same account as CR2. |
+| CR4 | `prgs-reconciler` Gitea token — account `sysadmin` | macOS keychain | B3 → B4 | Close PRs, delete branches, irrecoverable decision-lock recovery. Same account as CR2. |
+| CR5 | `prgs-controller` Gitea token — account `sysadmin` | macOS keychain | B3 → B4 | Same operation set as CR4. Same account as CR2. |
+| CR6 | `mdcps-author` Gitea token — account `913443` | macOS keychain | B3 → B4, B8 | Author operations on a second organization. **Shares one account with CR7 and CR8.** |
+| CR7 | `mdcps-reviewer` Gitea token — account `913443` | macOS keychain | B3 → B4, B8 | Approve and request changes on `mdcps`. Same account as CR6. |
+| CR8 | `mdcps-merger` Gitea token — account `913443` | macOS keychain | B3 → B4, B8 | Merge on `mdcps` — A2 in full. Same account as CR6. |
+| CR9 | MDCPS Jenkins read credential | macOS keychain, read from the Gitea server process (`gitea_config.py:851`) | B7 | Read CI jobs, builds, and logs (A4). Enabled today. |
+| CR10 | MDCPS GlitchTip read credential | macOS keychain, read from the Gitea server process (`gitea_config.py:851`) | B7 | Read error events and their payloads (A5). Enabled today. |
+| CR11 | `SENTRY_AUTH_TOKEN` | Process environment, read in-process (`sentry_incident_bridge.py:36`, `sentry_incident_bridge.py:190`), sent as a bearer header (`sentry_incident_bridge.py:289`) | B7 | Read and reconcile Sentry issues (A5). Not a keychain credential — an env var, so it is inherited by anything the process spawns. |
+| CR12 | `SENTRY_DSN` | Process environment (`sentry_observability.py:55`) | B7 | Write events into the observability project. Low read value, real forgery value: an attacker can inject fabricated events into the record (A10). |
+| CR13 | macOS login keychain access | The operator's login session; gated by `assert_keychain_access_allowed` (`mcp_daemon_guard.py:440`) | B3, ADV5 | **Every other credential in this table except CR11 and CR12.** This is the aggregation point. |
+| CR14 | Coordination-store access (no secret) | Filesystem permissions — `control_plane_db.py:47`, created `0o700` (`control_plane_db.py:380`), opened with a local file lock (`control_plane_db.py:386`) | B6, ADV5 | Full read/write of locks, leases, and decision records (A6). **There is no credential here at all** — anything running as the operator can rewrite ownership. |
+
+### Findings
+
+**Finding 1 — Role separation is not credential separation.** Four `prgs` roles resolve to
+one Gitea account (`sysadmin`): reviewer, merger, reconciler, and controller. A stolen
+reviewer credential *is* a merger credential. A9 — separation of duty between approving and
+landing — is therefore enforced entirely by which local process a call reaches (B2), and not
+at all by the forge. It survives exactly as long as B2 does, and B2 is the boundary the
+migration dissolves.
+
+**Finding 2 — The `mdcps` tenant has no role separation at all.** Author, reviewer, and
+merger all resolve to account `913443`. One credential can open a PR, approve it, and merge
+it. The in-process self-review check compares the authenticated username against the PR
+author and would refuse — but that check runs on our side of B4. It is not a property of
+the credential, and an attacker holding the token does not call our tools.
+
+**Finding 3 — Any one role process can resolve every other role's credential.** This is not
+inferred; it is demonstrated by tool output. `gitea_list_profiles`
+(`gitea_mcp_server.py:19258`) called from the **author** session reports
+`identity_status: "credentials present"` for `prgs-merger`, `prgs-reviewer`,
+`prgs-reconciler`, and every `mdcps` profile, because it calls `resolve_token` on each one
+(`gitea_mcp_server.py:19309`). The author process does not merely *have access to* the
+merger's credential — it reads it to answer a status query. B2 is not a credential boundary
+in either direction.
+
+**Finding 4 — The Gitea server reads CI and observability secrets.** `gitea_audit_config`
+(`gitea_mcp_server.py:19552`) reports `MDCPS Jenkins: enabled, read-only, authenticated`.
+That word `authenticated` is produced by `service_summaries` (`gitea_mcp_server.py:19574`,
+defined at `gitea_config.py:837`), whose default check calls `_keychain_token` on the
+service's own keychain reference (`gitea_config.py:851`). Producing that one line requires
+the Gitea MCP server to read the Jenkins secret and the GlitchTip secret out of the
+keychain. B7 does not exist.
+
+**Finding 5 — Jenkins and GlitchTip are already decomposed; the reach is residual.** Their
+tools live in separately registered servers, marked `external-mcp`
+(`gitea_mcp_server.py:17707`, `gitea_mcp_server.py:17713`, `gitea_mcp_server.py:17734`,
+`gitea_mcp_server.py:17739`) with their own expected tool sets (`mcp_discoverability.py:9`,
+`mcp_discoverability.py:17`). The correct decomposition was already chosen. What remains is
+a leak across it: the credential *references* still live in the Gitea configuration and are
+still resolved by the Gitea process. #75 bundled these services into one control-plane
+umbrella; the tools were separated afterwards, the credentials were not.
+
+**Finding 6 — Sentry is the exception that is not decomposed.** Unlike Jenkins and
+GlitchTip, the Sentry bridge runs *inside* the Gitea server, resolving its token from the
+process environment (`sentry_incident_bridge.py:190`) and sending it as a bearer header
+(`sentry_incident_bridge.py:289`). Being an environment variable rather than a keychain item
+makes it strictly worse: it needs no keychain prompt and is inherited by every subprocess the
+server spawns — including the `ps` invocations at `gitea_mcp_server.py:21462` and
+`gitea_mcp_server.py:21506`, reached from `gitea_mcp_server.py:21442`.
+
+**Finding 7 — The highest-value coordination asset has the weakest gate.** A6 is protected
+by filesystem permissions alone (CR14). Corrupting a lease requires no Gitea credential,
+produces no forge-side audit record, and breaks the mutual exclusion the entire workflow
+assumes. Every other asset costs an attacker a credential; this one costs nothing beyond
+local access, which is exactly ADV5's position.
+
+**Finding 8 — Provenance authenticates the launch, not the caller.** `server_provenance` is
+reported as exactly `client_managed` or `manual_launch` (`gitea_mcp_server.py:19001`),
+derived from environment inspection (`gitea_mcp_server.py:15412`) with the recognized-key
+allowlist at `gitea_config.py:1172` and the generator that emits the marker at
+`gitea_config.py:1233`. Every one of those facts is fixed at process start. A client that is
+trustworthy at launch and compromised a minute later remains `client_managed` for the life
+of the process, and the stdio contract that underwrites it is stated as a property of the
+server itself (`mcp_server.py:4`).
+
+## 6. Decomposition ruling
+
+This section is the ruling #956 requires. It is a decision, not a recommendation.
+
+**D1 — No unrelated co-residency.** A single integration process **must not** hold, resolve,
+or be able to resolve credentials for services it does not itself integrate with.
+Concretely: the Gitea MCP service may hold Gitea credentials and nothing else. Jenkins,
+GlitchTip, Sentry, and any database credential are **not permitted** to co-reside with Gitea
+credentials in one process.
+
+*Rationale.* A process is the smallest unit an attacker takes whole. Once ADV1 or ADV2
+controls execution in a process, every credential that process can resolve is theirs, and no
+in-process check helps, because the checks are in the process too. Blast radius is therefore
+a property of the process boundary and nothing finer. Findings 4 and 6 show that today one
+compromise of the Gitea server yields CI read access, error-tracking read access, and — via
+CR13 — every role credential on both tenants. That is the single largest reduction in blast
+radius available anywhere in epic #929, and it costs no new mechanism: the decomposition
+already exists (Finding 5) and is merely leaked across.
+
+**D2 — Separation of duty must be backed by credentials.** Two roles whose separation is a
+security property must not resolve to the same forge account. Specifically, reviewer and
+merger must be distinct accounts. Today they are not, on either tenant (Findings 1 and 2).
+
+*Rationale.* B2 is a process boundary, and the migration's entire purpose is to replace
+process boundaries with request-level ones. A separation enforced only by which process a
+call reaches does not survive that replacement — and it is already bypassable by anyone who
+holds the token and calls the API instead of the tool.
+
+**D3 — Credential resolution is scoped to the request principal.** A session must resolve its
+own credential and must have no path to any other principal's. The resolve-every-profile
+behavior behind `gitea_mcp_server.py:19309` and `gitea_mcp_server.py:19574` must report
+configured-or-not from configuration alone, without resolving the secret.
+
+*Rationale.* Finding 3. An audit surface that proves a credential exists by fetching it is a
+credential-aggregation primitive wearing a diagnostic's clothes.
+
+**D4 — Coordination state is a protected asset with its own authority.** Access to locks,
+leases, and decision records must require an authenticated session, not merely local
+filesystem access.
+
+*Rationale.* Finding 7. #937 already moves this store for concurrency reasons; the
+authorization requirement must land with it, or the store becomes remotely reachable while
+still being authorized by nothing.
+
+### Exceptions
+
+**One, time-boxed.** During the dual-run window defined by #939, the **local** stdio fleet
+may continue to resolve Jenkins and GlitchTip credential *references* from the shared
+configuration, because removing them from the local configuration is not a prerequisite for
+standing up the remote endpoint and would strand the operator's existing local workflow.
+
+This exception is bounded by all of:
+
+- It applies to the local stdio deployment only. The remote endpoint (#938) must be
+  configured with Gitea credentials and no others from its first day.
+- It expires when #939 completes. It does not survive cutover.
+- It does not extend to Sentry: CR11 and CR12 are process-environment credentials in the
+  Gitea server (Finding 6) and must be absent from the remote deployment's environment
+  regardless of dual-run state.
+
+No exception is granted to D2, D3, or D4.
+
+### Consequences for the target architecture
+
+- The remote endpoint serves **Gitea only**. It is not a general control-plane endpoint.
+- Jenkins and GlitchTip keep their existing separate servers, and their credential
+  references move out of the Gitea configuration.
+- The Sentry bridge either moves behind its own service boundary or is absent from the
+  remote deployment. It does not travel with the Gitea server.
+- Reviewer and merger accounts diverge before the endpoint is trusted for merges, or A9 is
+  recorded as unenforced.
+
+## 7. Child-to-boundary mapping
+
+Every #929 child from 2 through 10, mapped to the boundary it implements. A child
+implementing more than one boundary names its primary first.
+
+| Child | Issue | Boundaries | What it must establish | Rulings it must honor |
+| ----: | ----- | ---------- | ---------------------- | --------------------- |
+| 2 | #931 | B1, B9 | The bound transport becomes a validated value that provenance and freshness can both key on. Without it neither B1 nor B9 has an input. | — |
+| 3 | #932 | B2 | The role becomes a property of the request, not the process — the boundary the migration otherwise deletes. | D2, D3 |
+| 4 | #933 | B3, B7 | Credentials come from a provider keyed by principal. This is where D1 and D3 are either enforced or permanently lost. | D1, D3 |
+| 5 | #934 | B1 | Session provenance replaces pipe-and-process-table proof with an authenticated session identity. | — |
+| 6 | #935 | B9 | Freshness redefined against deployed build identity, with an explicit undeterminable verdict. | — |
+| 7 | #936 | B5 | Every tool classified and the filesystem boundary enforced at dispatch, so a tool cannot return green about the wrong disk. | — |
+| 8 | #937 | B6 | One authority per ownership question, with session-identity liveness and atomic transitions. | D4 |
+| 9 | #938 | B4, B1, B8 | The endpoint: authentication, principal binding, transport security, and — critically — the deployed credential set. | D1, D2, D3 |
+| 10 | #939 | B6 | Dual-run with exactly one coordination authority at every instant, and the rollback that proves the way back. | D1 exception expiry |
+
+Boundary coverage: B1 (#931, #934, #938), B2 (#932), B3 (#933), B4 (#938), B5 (#936),
+B6 (#937, #939), B7 (#933), B8 (#938), B9 (#931, #935).
+
+B7 has exactly one owner, #933, and that is deliberate. B7 is not created by standing up an
+endpoint; it is created by deciding which credentials a process may resolve, which is
+precisely what the credential-provider child does.
+
+## 8. Adversarial walkthrough: a fully compromised LLM client
+
+The required negative case. ADV1 holds one MCP client and issues arbitrary tool calls. What
+does it reach at each boundary?
+
+### Before the migration
+
+The client is attached to the local fleet over stdio.
+
+| Boundary | What ADV1 reaches | Stopped by |
+| -------- | ----------------- | ---------- |
+| B1 | Everything the fleet serves. The client *is* the sanctioned launcher: it satisfies the client-managed check (`gitea_mcp_server.py:15412`) by construction, and provenance is never re-verified after launch (Finding 8). | Nothing. The guard authenticates the launch, not the caller. |
+| B2 | All five roles — it is attached to all five namespaces. It can author a PR, approve it from the reviewer namespace, and merge it from the merger namespace. | Only the in-process self-review check, which compares `jcwalker3` (author) against `sysadmin` (reviewer) and **passes**, because Finding 1 made them different accounts while leaving reviewer and merger identical. A9 falls in one sequence of legitimate calls. |
+| B3 | Every credential in CR1–CR10 via CR13, with no additional prompt — the daemon is already sanctioned, so `assert_keychain_access_allowed` (`mcp_daemon_guard.py:440`) returns immediately. | Nothing. |
+| B4 | A1 and A2 in full. | Branch protection at the forge, to the extent configured. |
+| B5 | The operator's checkout and every worktree, through the author tools (`gitea_mcp_server.py:10894`), plus the shared stderr path at `mcp_server.py:10`. | Nothing; the server's disk is the target disk. |
+| B6 | All coordination state — no credential required (CR14). It can forge lease ownership and clear decision locks. | Filesystem permissions, which it already satisfies. |
+| B7 | Jenkins (A4) and GlitchTip (A5) secrets via Finding 4, and CR11/CR12 from its own environment. | Nothing. |
+| B8 | Both tenants. | Nothing in-process; only the disabled-context check (`gitea_config.py:704`), which does not apply to enabled contexts. |
+| B9 | Can it run stale code? Only by advancing the checkout, which parity detects (`master_parity_gate.py:255`). | This gate holds — the one boundary that behaves as designed against ADV1. |
+
+**Result: total.** One compromised client yields A1 through A8 and A10. The only asset with
+real resistance is A1 via branch protection, and the client holds the merger credential
+anyway. Nine boundaries, one meaningful stop.
+
+### After the migration
+
+The same client authenticates to the remote endpoint with one role's credential, assuming
+#931–#939 land **and honor D1–D4**.
+
+| Boundary | What ADV1 reaches | Stopped by |
+| -------- | ----------------- | ---------- |
+| B1 | One authenticated session, bound to one principal. | #934: a forged or expired session identity is refused; the client cannot mint one. |
+| B2 | **One role.** Presenting the author credential yields author permissions only. | #932: the principal comes from the credential, not from which endpoint was reached. |
+| B3 | **One credential — its own.** | #933 with D3: the provider resolves by principal, and no diagnostic resolves the others. |
+| B4 | That role's authority on the forge. | Endpoint authentication (#938); plaintext and unauthenticated attempts refused before dispatch. |
+| B5 | **Nothing.** Filesystem tools are refused over the remote transport with a named blocker. | #936. |
+| B6 | Its own leases; contention resolves to exactly one winner. | #937 with D4: authenticated session required, not filesystem access. |
+| B7 | **Nothing.** No CI or observability credential exists in the process. | D1 — the single largest reduction on this table. |
+| B8 | One tenant. | D1 and #938: the deployment carries one tenant's credentials. |
+| B9 | Cannot induce stale enforcement. | #935: explicit fail-closed verdict, including undeterminable. |
+
+**Result: bounded.** The compromise is contained to one role on one tenant, with no
+filesystem reach and no lateral credential access. A9 survives *only if D2 lands* — if
+reviewer and merger still share `sysadmin`, a compromised reviewer session still merges, and
+this row reads the same after the migration as before it.
+
+### What the migration does not fix
+
+Against **ADV2**, both tables are identical. Prompt injection does not need to cross a
+boundary: it arrives inside an authorized session and asks that session to do what it is
+already permitted to do. Every "stopped by" above authenticates a principal, and the
+injected instruction has the correct principal. The migration reduces ADV1's blast radius by
+roughly an order of magnitude and reduces ADV2's by nothing.
+
+The controls that do constrain ADV2 are per-principal permission scope (#932), repository
+scope (`gitea_config.py:499`), and credential-backed separation of duty (D2) — each limiting
+what an authenticated session may do *regardless of what it is asked for*. #955's
+secure-isolation end state should be read with that distinction in mind: removing credentials
+from clients defeats ADV1 and ADV5, and does not by itself defeat ADV2.
+
+Two further items are explicitly out of scope here and unowned by #929:
+
+- **Session-credential rotation and revocation.** #938 names rotation as documentation, but
+  no child owns proving that a revoked credential stops an in-flight session.
+- **ADV3** (malicious tool arguments) is diffused across every child rather than owned. The
+  per-request principal work in #932 is the natural place to assert that identifiers taken
+  from the request never authorize anything on their own.
+
+## 9. How to verify this document
+
+1. `PYTHONPATH=. pytest tests/test_issue_956_threat_model.py` — resolves every anchor
+   against the working tree and checks the document's structural obligations.
+2. Pick any five anchors at random and read them; the fixture states what each line must
+   contain.
+3. Reproduce Findings 3 and 4 live: call `gitea_list_profiles` and `gitea_audit_config`
+   from the **author** namespace. Credential presence reported for roles other than the
+   active one is Finding 3; `MDCPS Jenkins: enabled, read-only, authenticated` is Finding 4.
+
+If the anchor test fails after an unrelated refactor, the anchors moved and the fixture
+needs regenerating — the claims are still true, but they are no longer traceable, which
+#956 treats as the same defect.

gitea_mcp_server.py

@@ -2100,6 +2100,7 @@ import lease_policy  # noqa: E402
 import workflow_dashboard  # noqa: E402  # #605 live queue/lease dashboard
 import restart_coordinator  # noqa: E402  # #658 MCP restart coordinator/impact
 import drain_proof  # noqa: E402  # #661 pre-restart drain proof and hard gate
+import restart_audit  # noqa: E402  # #665 restart audit events + incidents
 import incident_bridge  # noqa: E402
 import sentry_observability  # noqa: E402  (#606 optional Sentry observability)
 import sentry_incident_bridge  # noqa: E402  (#607 Sentry→Gitea incident bridge)
@@ -23867,6 +23868,38 @@ def gitea_request_mcp_restart(
     # and a durable incident is raised. Break-glass is the only bypass and its
     # authorization is read from the environment, never self-asserted.
     payload["apply_supported"] = False
+    # #665: correlation id threads impact preview → apply gate → incidents.
+    correlation_id = restart_audit.new_correlation_id()
+    payload["correlation_id"] = correlation_id
+    auth_user = None
+    try:
+        # remote-only: host override is for operator diagnostics, not required here
+        auth_user = (gitea_whoami(remote=remote) or {}).get("username")
+    except Exception:  # noqa: BLE001 — identity is best-effort for audit
+        auth_user = None
+    preview_audit = restart_audit.record_restart_lifecycle(
+        event_type=restart_audit.EVENT_IMPACT_PREVIEW,
+        outcome=str(report.verdict or "unknown"),
+        correlation_id=correlation_id,
+        remote=remote,
+        org=o,
+        repo=r,
+        requesting_session_id=sid,
+        restart_class=restart_class,
+        profile_name=profile_name,
+        authenticated_username=auth_user,
+        reasons=list(report.reasons or []),
+        details={
+            "dry_run": True,
+            "allow_restart": bool(report.allow_restart),
+            "inventory_complete": inventory_complete,
+        },
+        privileged=False,
+    )
+    payload["restart_audit"] = {
+        "correlation_id": correlation_id,
+        "impact_preview_written": preview_audit["audit_written"],
+    }
     if not dry_run:
         proof_obj: dict | None = None
         proof_parse_error: str | None = None
@@ -23919,6 +23952,86 @@ def gitea_request_mcp_restart(
         )
         if not gate.allow and gate.incident is not None:
             payload["incident"] = gate.incident
+
+        # #665: audit apply-gate + materialize durable incidents for failed
+        # drain and break-glass. Privileged apply denies if audit is enabled
+        # and the sink write fails.
+        incident_desc = restart_audit.incident_from_apply_gate(
+            gate_payload={
+                **gate_payload,
+                "incident": gate.incident,
+                "allow": gate.allow,
+            },
+            break_glass=break_glass,
+            correlation_id=correlation_id,
+            requesting_session_id=sid,
+            restart_class=restart_class,
+            remote=remote,
+            org=o,
+            repo=r,
+        )
+        if incident_desc is not None:
+            payload["incident"] = incident_desc
+
+        def _create_restart_incident_issue(
+            *, title, body, labels, org=None, repo=None, **_kw
+        ):
+            return gitea_create_issue(
+                title=title,
+                body=body,
+                labels=labels,
+                remote=remote,
+                host=h,
+                org=org or o,
+                repo=repo or r,
+            )
+
+        apply_audit = restart_audit.record_restart_lifecycle(
+            event_type=(
+                restart_audit.EVENT_BREAK_GLASS
+                if break_glass
+                else restart_audit.EVENT_APPLY_GATE
+            ),
+            outcome=(
+                "break_glass"
+                if break_glass
+                else ("allow" if payload["apply_authorized"] else "deny")
+            ),
+            correlation_id=correlation_id,
+            remote=remote,
+            org=o,
+            repo=r,
+            requesting_session_id=sid,
+            restart_class=restart_class,
+            profile_name=profile_name,
+            authenticated_username=auth_user,
+            reasons=list(gate_payload.get("reasons") or []),
+            details={
+                "apply_authorized": payload["apply_authorized"],
+                "drain_gate_allow": gate_payload.get("drain_gate_allow"),
+                "restart_class_authorized": restart_class_authorized,
+                "break_glass": break_glass,
+                "proof_id": gate_payload.get("proof_id"),
+            },
+            privileged=True,
+            create_incident=incident_desc,
+            create_issue_fn=_create_restart_incident_issue
+            if incident_desc is not None
+            else None,
+            dry_run_incident=False,
+        )
+        payload["restart_audit"] = {
+            "correlation_id": correlation_id,
+            "impact_preview_written": preview_audit["audit_written"],
+            "apply_gate_written": apply_audit["audit_written"],
+            "incident_result": apply_audit.get("incident_result"),
+        }
+        if apply_audit["deny_reasons"]:
+            payload["apply_authorized"] = False
+            payload["reasons"] = list(payload.get("reasons") or []) + list(
+                apply_audit["deny_reasons"]
+            )
+            payload["success"] = True
     return payload
 
 

restart_audit.py

@@ -0,0 +1,426 @@
+"""MCP restart lifecycle audit events and incident materialization (#665).
+
+Restarts and recovery attempts must leave a forensic trail: impact previews,
+drain enter/exit, drain-proof results, apply gate verdicts, break-glass, and
+post-restart reconcile outcomes. Failed drains and break-glass must also raise
+durable Gitea incident issues so they cannot be silently repeated.
+
+This module is the pure + sink layer for that trail:
+
+* **Schema** — ``mcp.restart.*`` event names and a redacted payload builder.
+* **Emission** — append-only via :mod:`gitea_audit` (off when ``GITEA_AUDIT_LOG``
+  is unset; privileged apply can still *require* a successful write).
+* **Incidents** — descriptors for failed drain / break-glass / unguarded restart,
+  plus an optional materializer that creates a Gitea issue through an injected
+  ``create_issue_fn`` (keeps this module free of network I/O in tests).
+
+Design rules:
+
+* **No secrets.** All free text is redacted before write or issue body assembly.
+* **Never raises from emission.** ``emit_restart_event`` returns False on sink
+  failure so callers can decide fail-closed policy for privileged restarts.
+* **Does not restart.** Audit never executes a process restart.
+* **Drain proof stays #661.** This module records what the gate decided; it
+  does not re-verify proofs.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Callable, Mapping, Sequence
+
+import gitea_audit
+
+# ── Event vocabulary (stable identifiers for operators + tests) ───────────────
+
+EVENT_IMPACT_PREVIEW = "mcp.restart.impact_preview"
+EVENT_DRAIN_ENTER = "mcp.restart.drain_enter"
+EVENT_DRAIN_EXIT = "mcp.restart.drain_exit"
+EVENT_DRAIN_PROOF = "mcp.restart.drain_proof"
+EVENT_APPLY_GATE = "mcp.restart.apply_gate"
+EVENT_BREAK_GLASS = "mcp.restart.break_glass"
+EVENT_POST_RESTART_RECONCILE = "mcp.restart.post_restart_reconcile"
+EVENT_NARROWER_RECOVERY = "mcp.restart.narrower_recovery"
+EVENT_UNGUARDED_DETECTED = "mcp.restart.unguarded_detected"
+
+RESTART_EVENT_TYPES: frozenset[str] = frozenset(
+    {
+        EVENT_IMPACT_PREVIEW,
+        EVENT_DRAIN_ENTER,
+        EVENT_DRAIN_EXIT,
+        EVENT_DRAIN_PROOF,
+        EVENT_APPLY_GATE,
+        EVENT_BREAK_GLASS,
+        EVENT_POST_RESTART_RECONCILE,
+        EVENT_NARROWER_RECOVERY,
+        EVENT_UNGUARDED_DETECTED,
+    }
+)
+
+# Incident kinds (durable Gitea issues).
+INCIDENT_FAILED_DRAIN = "restart_failed_drain"
+INCIDENT_BREAK_GLASS = "restart_break_glass"
+INCIDENT_RECONCILE_UNRESOLVED = "restart_reconcile_unresolved"
+INCIDENT_UNGUARDED = "restart_unguarded_detected"
+
+DEFAULT_INCIDENT_LABELS: tuple[str, ...] = (
+    "mcp-health",
+    "safety",
+    "observability",
+    "status:ready",
+    "type:bug",
+    "workflow-hardening",
+)
+
+CreateIssueFn = Callable[..., dict[str, Any]]
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def new_correlation_id() -> str:
+    """Mint a short correlation id shared across a restart lifecycle."""
+    return f"rst-{uuid.uuid4().hex[:16]}"
+
+
+def build_restart_event(
+    *,
+    event_type: str,
+    outcome: str,
+    correlation_id: str | None = None,
+    remote: str | None = None,
+    org: str | None = None,
+    repo: str | None = None,
+    requesting_session_id: str | None = None,
+    restart_class: str | None = None,
+    profile_name: str | None = None,
+    authenticated_username: str | None = None,
+    reasons: Sequence[str] | None = None,
+    details: Mapping[str, Any] | None = None,
+    now: str | None = None,
+) -> dict[str, Any]:
+    """Build a redacted ``mcp.restart.*`` audit event.
+
+    Raises ``ValueError`` on unknown event types so a typo cannot silently land
+    under a free-form action name.
+    """
+    name = str(event_type or "").strip()
+    if name not in RESTART_EVENT_TYPES:
+        raise ValueError(
+            f"unknown restart audit event_type {name!r}; expected one of "
+            f"{sorted(RESTART_EVENT_TYPES)}"
+        )
+    redacted_reasons = [
+        gitea_audit.redact(str(r)) for r in (reasons or []) if str(r).strip()
+    ]
+    redacted_details = gitea_audit.redact(dict(details or {}))
+    if not isinstance(redacted_details, dict):
+        redacted_details = {"value": redacted_details}
+
+    event = gitea_audit.build_event(
+        action=name,
+        result=str(outcome or "unknown"),
+        remote=remote,
+        repository=f"{org}/{repo}" if org and repo else None,
+        profile_name=profile_name,
+        authenticated_username=authenticated_username,
+        reason="; ".join(redacted_reasons) if redacted_reasons else None,
+        request_metadata={
+            "event_family": "mcp.restart",
+            "correlation_id": correlation_id or new_correlation_id(),
+            "restart_class": restart_class,
+            "requesting_session_id": requesting_session_id,
+            "org": org,
+            "repo": repo,
+            "details": redacted_details,
+            "reasons": redacted_reasons,
+        },
+        now=now or _utc_now_iso(),
+        operation=name,
+    )
+    event["action_type"] = "restart_lifecycle"
+    event["event_type"] = name
+    event["correlation_id"] = (event.get("request_metadata") or {}).get(
+        "correlation_id"
+    )
+    return event
+
+
+def emit_restart_event(event: Mapping[str, Any], *, path: str | None = None) -> bool:
+    """Append *event* to the audit sink. Never raises. Returns write success."""
+    try:
+        return bool(gitea_audit.write_event(dict(event), path=path))
+    except Exception:
+        return False
+
+
+def require_audit_or_deny(
+    *,
+    privileged: bool,
+    written: bool,
+    audit_enabled: bool | None = None,
+) -> list[str]:
+    """Return deny reasons when a privileged restart path fails to audit.
+
+    When audit is not configured (``GITEA_AUDIT_LOG`` unset), privileged apply
+    still proceeds under the rollout policy "enable audit before enforcing
+    deny-on-audit-fail" — but *if* audit is enabled and the write fails,
+    privileged apply is denied (fail closed).
+    """
+    enabled = (
+        gitea_audit.audit_enabled() if audit_enabled is None else bool(audit_enabled)
+    )
+    if not privileged:
+        return []
+    if not enabled:
+        return []
+    if written:
+        return []
+    return [
+        "privileged restart path requires a successful audit write; "
+        "audit sink failed (fail closed, #665)"
+    ]
+
+
+# ── Incident descriptors ──────────────────────────────────────────────────────
+
+
+def build_incident_descriptor(
+    *,
+    kind: str,
+    reasons: Sequence[str],
+    correlation_id: str | None = None,
+    requesting_session_id: str | None = None,
+    restart_class: str | None = None,
+    remote: str | None = None,
+    org: str | None = None,
+    repo: str | None = None,
+    proof_id: str | None = None,
+    at: str | None = None,
+) -> dict[str, Any]:
+    """Build a durable incident descriptor (no network)."""
+    titles = {
+        INCIDENT_FAILED_DRAIN: "Restart denied: drain proof failed the hard gate",
+        INCIDENT_BREAK_GLASS: "Break-glass MCP restart authorized",
+        INCIDENT_RECONCILE_UNRESOLVED: "Post-restart reconcile left unresolved work",
+        INCIDENT_UNGUARDED: "Unguarded MCP restart attempt detected",
+    }
+    title = titles.get(kind, f"MCP restart incident ({kind})")
+    redacted_reasons = [
+        gitea_audit.redact(str(r)) for r in reasons if str(r).strip()
+    ]
+    return {
+        "kind": kind,
+        "title": title,
+        "labels": list(DEFAULT_INCIDENT_LABELS),
+        "reasons": redacted_reasons,
+        "correlation_id": correlation_id,
+        "requesting_session_id": requesting_session_id,
+        "restart_class": restart_class,
+        "remote": remote,
+        "org": org,
+        "repo": repo,
+        "proof_id": proof_id,
+        "at": at or _utc_now_iso(),
+        "source": "restart_audit#665",
+    }
+
+
+def incident_body(descriptor: Mapping[str, Any]) -> str:
+    """Render a redacted markdown body for a Gitea incident issue."""
+    reasons = descriptor.get("reasons") or []
+    reason_lines = "\n".join(f"- {gitea_audit.redact(str(r))}" for r in reasons) or (
+        "- (no reasons recorded)"
+    )
+    return "\n".join(
+        [
+            "<!-- mcp-restart-incident:v1 -->",
+            f"## MCP restart incident (`{descriptor.get('kind')}`)",
+            "",
+            f"**Correlation:** `{descriptor.get('correlation_id') or 'none'}`",
+            f"**Session:** `{descriptor.get('requesting_session_id') or 'none'}`",
+            f"**Class:** `{descriptor.get('restart_class') or 'none'}`",
+            f"**Scope:** `{descriptor.get('remote')}/{descriptor.get('org')}/"
+            f"{descriptor.get('repo')}`",
+            f"**At:** `{descriptor.get('at')}`",
+            f"**Proof id:** `{descriptor.get('proof_id') or 'none'}`",
+            "",
+            "### Reasons",
+            reason_lines,
+            "",
+            "### Operator next steps",
+            "- Treat this as durable follow-up work under the restart-governance umbrella (#655).",
+            "- Do not invent a second restart path; use sanctioned coordinator tools only.",
+            "- Raw secrets must never appear in this issue (already redacted).",
+            "",
+            f"_Source: {descriptor.get('source')}_",
+        ]
+    )
+
+
+def materialize_incident(
+    descriptor: Mapping[str, Any],
+    *,
+    create_issue_fn: CreateIssueFn | None,
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    """Create a Gitea issue from *descriptor* when *create_issue_fn* is provided.
+
+    Returns a result dict with ``created`` / ``issue_number`` / ``dry_run`` /
+    ``reasons``. Never raises.
+    """
+    base: dict[str, Any] = {
+        "created": False,
+        "dry_run": bool(dry_run),
+        "issue_number": None,
+        "kind": descriptor.get("kind"),
+        "reasons": [],
+        "descriptor": dict(descriptor),
+    }
+    if dry_run:
+        base["reasons"] = ["dry-run only; no Gitea issue created"]
+        return base
+    if create_issue_fn is None:
+        base["reasons"] = [
+            "create_issue_fn not provided; incident descriptor retained only"
+        ]
+        return base
+    try:
+        result = create_issue_fn(
+            title=str(descriptor.get("title") or "MCP restart incident"),
+            body=incident_body(descriptor),
+            labels=list(descriptor.get("labels") or DEFAULT_INCIDENT_LABELS),
+            org=descriptor.get("org"),
+            repo=descriptor.get("repo"),
+        )
+        number = None
+        if isinstance(result, dict):
+            number = result.get("number") or result.get("issue_number")
+        if number is not None:
+            base["created"] = True
+            base["issue_number"] = int(number)
+            base["reasons"] = [f"created incident issue #{int(number)}"]
+        else:
+            base["reasons"] = ["create_issue_fn returned no issue number"]
+    except Exception as exc:  # noqa: BLE001 — never break restart path here
+        base["reasons"] = [
+            f"incident issue creation failed: {gitea_audit.redact(str(exc))}"
+        ]
+    return base
+
+
+def record_restart_lifecycle(
+    *,
+    event_type: str,
+    outcome: str,
+    correlation_id: str,
+    remote: str | None = None,
+    org: str | None = None,
+    repo: str | None = None,
+    requesting_session_id: str | None = None,
+    restart_class: str | None = None,
+    profile_name: str | None = None,
+    authenticated_username: str | None = None,
+    reasons: Sequence[str] | None = None,
+    details: Mapping[str, Any] | None = None,
+    privileged: bool = False,
+    create_incident: Mapping[str, Any] | None = None,
+    create_issue_fn: CreateIssueFn | None = None,
+    dry_run_incident: bool = False,
+    audit_path: str | None = None,
+) -> dict[str, Any]:
+    """Emit one restart audit event and optionally materialize an incident.
+
+    Returns ``{event, audit_written, deny_reasons, incident_result}``.
+    """
+    event = build_restart_event(
+        event_type=event_type,
+        outcome=outcome,
+        correlation_id=correlation_id,
+        remote=remote,
+        org=org,
+        repo=repo,
+        requesting_session_id=requesting_session_id,
+        restart_class=restart_class,
+        profile_name=profile_name,
+        authenticated_username=authenticated_username,
+        reasons=reasons,
+        details=details,
+    )
+    written = emit_restart_event(event, path=audit_path)
+    deny = require_audit_or_deny(privileged=privileged, written=written)
+    incident_result = None
+    if create_incident is not None:
+        incident_result = materialize_incident(
+            create_incident,
+            create_issue_fn=create_issue_fn,
+            dry_run=dry_run_incident,
+        )
+    return {
+        "event": event,
+        "audit_written": written,
+        "deny_reasons": deny,
+        "incident_result": incident_result,
+        "correlation_id": correlation_id,
+    }
+
+
+def incident_from_apply_gate(
+    *,
+    gate_payload: Mapping[str, Any],
+    break_glass: bool,
+    correlation_id: str,
+    requesting_session_id: str | None,
+    restart_class: str | None,
+    remote: str | None,
+    org: str | None,
+    repo: str | None,
+) -> dict[str, Any] | None:
+    """Choose an incident descriptor from an apply-gate payload, if required."""
+    reasons = list(gate_payload.get("reasons") or [])
+    proof_id = gate_payload.get("proof_id")
+    if break_glass:
+        return build_incident_descriptor(
+            kind=INCIDENT_BREAK_GLASS,
+            reasons=reasons
+            or ["break-glass restart path used; durable incident required (#665)"],
+            correlation_id=correlation_id,
+            requesting_session_id=requesting_session_id,
+            restart_class=restart_class,
+            remote=remote,
+            org=org,
+            repo=repo,
+            proof_id=proof_id if isinstance(proof_id, str) else None,
+        )
+    # Failed drain / deny path.
+    incident = gate_payload.get("incident")
+    if isinstance(incident, Mapping) and incident:
+        # Normalize gate-provided descriptor into our schema.
+        return build_incident_descriptor(
+            kind=INCIDENT_FAILED_DRAIN,
+            reasons=list(incident.get("reasons") or reasons),
+            correlation_id=correlation_id,
+            requesting_session_id=requesting_session_id
+            or incident.get("requesting_session_id"),
+            restart_class=restart_class,
+            remote=remote,
+            org=org,
+            repo=repo,
+            proof_id=incident.get("proof_id") or proof_id,
+            at=incident.get("at"),
+        )
+    if not gate_payload.get("allow") and not gate_payload.get("drain_gate_allow", True):
+        return build_incident_descriptor(
+            kind=INCIDENT_FAILED_DRAIN,
+            reasons=reasons or ["restart apply denied"],
+            correlation_id=correlation_id,
+            requesting_session_id=requesting_session_id,
+            restart_class=restart_class,
+            remote=remote,
+            org=org,
+            repo=repo,
+            proof_id=proof_id if isinstance(proof_id, str) else None,
+        )
+    return None

tests/test_issue_956_threat_model.py

@@ -0,0 +1,323 @@
+"""Validation tooling for the remote-MCP threat model (#956).
+
+#956 requires that "every boundary claim [is] traceable to a file and line
+anchor that resolves at the reviewed commit". A prose document cannot enforce
+that about itself, and #930 demonstrated the failure mode: its inventory cited
+``gitea_mcp_server.py`` anchors generated at ``7bf4f125`` which no longer point
+at the described code at ``aad5c8b4``. Nothing failed, because nothing checked.
+
+These tests are that check. They enforce, in both directions:
+
+* every ``file.py:NNN`` anchor cited in the prose is declared in the fixture;
+* every declared anchor resolves — the file exists, the line exists, and the
+  source line actually contains the substring the fixture claims for it;
+* the document's structural obligations (assets, adversaries, boundaries,
+  credential rows, the co-residency ruling, and the child mapping) are present
+  and internally consistent.
+
+A refactor that shifts a line number therefore breaks the suite instead of
+silently rotting the security documentation.
+"""
+
+import json
+import os
+import re
+import unittest
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DOC_PATH = os.path.join(REPO_ROOT, "docs", "remote-mcp", "threat-model.md")
+FIXTURE_PATH = os.path.join(
+    REPO_ROOT, "docs", "remote-mcp", "threat-model-anchors.json"
+)
+
+# ``module.py:123`` as it appears inside markdown inline code spans.
+ANCHOR_RE = re.compile(r"`([A-Za-z0-9_./-]+\.py):(\d+)`")
+
+# The epic children this document must map to a boundary (#929 children 2-10).
+REQUIRED_CHILDREN = [931, 932, 933, 934, 935, 936, 937, 938, 939]
+
+# The adversaries #956 names explicitly.
+REQUIRED_ADVERSARIES = [
+    "compromised LLM client",
+    "prompt injection",
+    "malicious tool arguments",
+    "network attacker",
+    "curious operator",
+]
+
+
+def _read(path):
+    with open(path, "r", encoding="utf-8") as fh:
+        return fh.read()
+
+
+def _heading_re(title):
+    """Match a level-2 heading by title, with or without section numbering.
+
+    The document numbers its sections ('## 6. Decomposition ruling'), so an
+    exact-substring assertion would break on renumbering without the document
+    having actually lost anything.
+    """
+    return re.compile(
+        r"^##\s+(?:\d+\.\s+)?" + re.escape(title), re.MULTILINE
+    )
+
+
+def _section_body(doc, title):
+    """Return the text of section *title*, bounded by the next level-2 heading.
+
+    Bounding matters: an unbounded slice runs to end-of-document, so the
+    walkthrough tables in a later section leak into the child-to-boundary
+    mapping and satisfy its coverage check with rows that assign no owner.
+    """
+    match = _heading_re(title).search(doc)
+    if match is None:
+        return None
+    rest = doc[match.end():]
+    nxt = re.search(r"^##\s", rest, re.MULTILINE)
+    return rest[: nxt.start()] if nxt else rest
+
+
+def _source_line(rel_path, lineno):
+    """Return the 1-based *lineno* of *rel_path*, or None if out of range."""
+    abs_path = os.path.join(REPO_ROOT, rel_path)
+    if not os.path.exists(abs_path):
+        return None
+    with open(abs_path, "r", encoding="utf-8", errors="replace") as fh:
+        for idx, line in enumerate(fh, start=1):
+            if idx == lineno:
+                return line
+    return None
+
+
+class ThreatModelFixtureTests(unittest.TestCase):
+    """The fixture itself must be well-formed before it can prove anything."""
+
+    def setUp(self):
+        self.fixture = json.loads(_read(FIXTURE_PATH))
+
+    def test_fixture_declares_a_generation_commit(self):
+        sha = self.fixture.get("generated_against_commit") or ""
+        self.assertRegex(
+            sha,
+            r"^[0-9a-f]{40}$",
+            "the fixture must record the full commit its anchors were taken at",
+        )
+
+    def test_fixture_anchors_are_unique_and_well_formed(self):
+        seen = set()
+        for entry in self.fixture["anchors"]:
+            anchor = entry["anchor"]
+            self.assertNotIn(anchor, seen, f"duplicate anchor entry: {anchor}")
+            seen.add(anchor)
+            self.assertRegex(anchor, r"^[A-Za-z0-9_./-]+\.py:[1-9]\d*$", anchor)
+            self.assertTrue(
+                (entry.get("expect") or "").strip(),
+                f"anchor {anchor} declares no 'expect' substring, so it proves nothing",
+            )
+
+
+class ThreatModelAnchorResolutionTests(unittest.TestCase):
+    """#956 required positive test: every anchor resolves at the reviewed commit."""
+
+    def setUp(self):
+        self.fixture = json.loads(_read(FIXTURE_PATH))
+        self.doc = _read(DOC_PATH)
+
+    def test_every_declared_anchor_resolves_to_the_claimed_source_line(self):
+        failures = []
+        for entry in self.fixture["anchors"]:
+            rel_path, _, raw_lineno = entry["anchor"].partition(":")
+            lineno = int(raw_lineno)
+            line = _source_line(rel_path, lineno)
+            if line is None:
+                failures.append(f"{entry['anchor']}: file or line does not exist")
+                continue
+            if entry["expect"] not in line:
+                failures.append(
+                    f"{entry['anchor']}: expected {entry['expect']!r}, "
+                    f"found {line.strip()!r}"
+                )
+        self.assertEqual(
+            [], failures, "unresolved threat-model anchors:\n" + "\n".join(failures)
+        )
+
+    def test_every_anchor_cited_in_the_document_is_declared_in_the_fixture(self):
+        declared = {e["anchor"] for e in self.fixture["anchors"]}
+        cited = {f"{m.group(1)}:{m.group(2)}" for m in ANCHOR_RE.finditer(self.doc)}
+        undeclared = sorted(cited - declared)
+        self.assertEqual(
+            [],
+            undeclared,
+            "document cites anchors that no test verifies: " + ", ".join(undeclared),
+        )
+
+    def test_the_document_actually_cites_anchors(self):
+        cited = {f"{m.group(1)}:{m.group(2)}" for m in ANCHOR_RE.finditer(self.doc)}
+        self.assertGreaterEqual(
+            len(cited),
+            30,
+            "a boundary document with almost no anchors is not traceable",
+        )
+
+    def test_unresolvable_anchor_is_detected(self):
+        """Negative control: the checker must fail on a deliberately bad anchor.
+
+        Without this, a checker that silently passed everything would look
+        identical to a correct one.
+        """
+        self.assertIsNone(_source_line("gitea_config.py", 10**9))
+        self.assertIsNone(_source_line("no_such_module_for_956.py", 1))
+        real = _source_line("gitea_config.py", 54)
+        self.assertIsNotNone(real)
+        self.assertNotIn("this substring is not on that line", real)
+
+
+class ThreatModelStructureTests(unittest.TestCase):
+    """The document must contain what #956's acceptance criteria demand."""
+
+    def setUp(self):
+        self.doc = _read(DOC_PATH)
+
+    def test_records_the_commit_it_was_generated_against(self):
+        fixture = json.loads(_read(FIXTURE_PATH))
+        self.assertIn(
+            fixture["generated_against_commit"],
+            self.doc,
+            "the document must state the commit its anchors resolve at",
+        )
+
+    def test_names_every_required_adversary(self):
+        low = self.doc.lower()
+        for adversary in REQUIRED_ADVERSARIES:
+            self.assertIn(adversary.lower(), low, f"adversary not covered: {adversary}")
+
+    def test_maps_every_epic_child_from_two_through_ten(self):
+        for number in REQUIRED_CHILDREN:
+            self.assertIn(
+                f"#{number}",
+                self.doc,
+                f"epic child #{number} is not mapped to a boundary",
+            )
+
+    def test_credential_rows_declare_holder_boundary_and_blast_radius(self):
+        for column in ("Holder", "Boundary", "Blast radius"):
+            self.assertIn(
+                column,
+                self.doc,
+                f"the credential inventory must state each credential's {column.lower()}",
+            )
+
+    def test_states_an_explicit_co_residency_ruling(self):
+        """AC3/AC5: an explicit ruling, not an implication."""
+        self.assertIsNotNone(
+            _heading_re("Decomposition ruling").search(self.doc),
+            "the document must contain an explicit decomposition-ruling section",
+        )
+        for service in ("Jenkins", "GlitchTip", "Sentry", "database"):
+            self.assertIn(service, self.doc, f"ruling does not address {service}")
+        self.assertRegex(
+            self.doc,
+            r"D1\b.*must not",
+            "the ruling must state the prohibition, not merely discuss it",
+        )
+
+    def test_contains_the_compromised_client_walkthrough(self):
+        """#956 required negative/adversarial test."""
+        self.assertIsNotNone(
+            _heading_re("Adversarial walkthrough").search(self.doc),
+            "the required compromised-client walkthrough is missing",
+        )
+        self.assertIn("Before the migration", self.doc)
+        self.assertIn("After the migration", self.doc)
+
+    def test_every_boundary_states_what_it_protects_and_what_crossing_requires(self):
+        boundary_ids = set(re.findall(r"\bB(\d+)\b", self.doc))
+        self.assertGreaterEqual(
+            len(boundary_ids), 5, "too few trust boundaries to be a decomposition"
+        )
+        for column in (
+            "Protects",
+            "Crossing requires today",
+            "Crossing must require remotely",
+        ):
+            self.assertIn(column, self.doc, f"boundary table is missing '{column}'")
+
+    def test_declares_itself_documentation_only(self):
+        self.assertIn("documentation only", self.doc.lower())
+
+
+class ThreatModelConsistencyTests(unittest.TestCase):
+    """Counts stated in prose must match the rows actually present."""
+
+    def setUp(self):
+        self.doc = _read(DOC_PATH)
+
+    def _declared_ids(self, prefix):
+        # Table rows begin '| CR1 |' / '| B3 |' / '| A2 |'.
+        return sorted(
+            {
+                int(m)
+                for m in re.findall(
+                    r"^\|\s*%s(\d+)\s*\|" % prefix, self.doc, re.MULTILINE
+                )
+            }
+        )
+
+    def test_identifier_sequences_have_no_gaps(self):
+        for prefix, label in (
+            ("A", "assets"),
+            ("B", "boundaries"),
+            ("CR", "credentials"),
+        ):
+            ids = self._declared_ids(prefix)
+            self.assertTrue(ids, f"no {label} declared")
+            self.assertEqual(
+                list(range(1, len(ids) + 1)),
+                ids,
+                f"{label} identifiers must run 1..n with no gaps; got {ids}",
+            )
+
+    def test_stated_credential_count_matches_the_rows(self):
+        ids = self._declared_ids("CR")
+        match = re.search(r"(\d+)\s+credential(?:s)? in total", self.doc)
+        self.assertIsNotNone(match, "the credential inventory must state its own total")
+        self.assertEqual(
+            len(ids),
+            int(match.group(1)),
+            "stated credential total disagrees with the number of rows",
+        )
+
+    def test_every_boundary_is_owned_by_at_least_one_child(self):
+        """Each boundary must be owned by a child *in the mapping table*.
+
+        Scanning the whole section would let a prose summary line ("Boundary
+        coverage: ... B5 (#936)") satisfy the assertion while the table row
+        that actually assigns the owner had been emptied — verified by
+        deliberately blanking a row and watching a whole-section check still
+        pass. Only table rows count.
+        """
+        mapping_section = _section_body(self.doc, "Child-to-boundary mapping")
+        self.assertIsNotNone(
+            mapping_section, "child-to-boundary mapping section is missing"
+        )
+        rows = [
+            line
+            for line in mapping_section.splitlines()
+            if line.lstrip().startswith("|") and re.search(r"#93\d", line)
+        ]
+        self.assertGreaterEqual(
+            len(rows), len(REQUIRED_CHILDREN), "mapping table has too few child rows"
+        )
+        mapped = set(re.findall(r"\bB(\d+)\b", "\n".join(rows)))
+        declared = {str(i) for i in self._declared_ids("B")}
+        unmapped = sorted(declared - mapped, key=int)
+        self.assertEqual(
+            [],
+            unmapped,
+            "boundaries with no owning child: " + ", ".join("B" + u for u in unmapped),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_restart_audit.py

@@ -0,0 +1,342 @@
+"""Tests for MCP restart lifecycle audit events and incidents (#665)."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import gitea_audit
+import restart_audit as ra
+
+
+class TestEventSchema(unittest.TestCase):
+    def test_all_lifecycle_event_types_are_named(self):
+        expected = {
+            "mcp.restart.impact_preview",
+            "mcp.restart.drain_enter",
+            "mcp.restart.drain_exit",
+            "mcp.restart.drain_proof",
+            "mcp.restart.apply_gate",
+            "mcp.restart.break_glass",
+            "mcp.restart.post_restart_reconcile",
+            "mcp.restart.narrower_recovery",
+            "mcp.restart.unguarded_detected",
+        }
+        self.assertEqual(set(ra.RESTART_EVENT_TYPES), expected)
+
+    def test_build_restart_event_core_fields(self):
+        event = ra.build_restart_event(
+            event_type=ra.EVENT_IMPACT_PREVIEW,
+            outcome="safe",
+            correlation_id="rst-abc123",
+            remote="prgs",
+            org="Scaled-Tech-Consulting",
+            repo="Gitea-Tools",
+            requesting_session_id="sess-1",
+            restart_class="full_mcp_restart",
+            profile_name="prgs-author",
+            authenticated_username="bot",
+            reasons=["inventory complete"],
+            details={"allow_restart": True},
+            now="2026-07-25T12:00:00+00:00",
+        )
+        self.assertEqual(event["event_type"], ra.EVENT_IMPACT_PREVIEW)
+        self.assertEqual(event["action"], ra.EVENT_IMPACT_PREVIEW)
+        self.assertEqual(event["action_type"], "restart_lifecycle")
+        self.assertEqual(event["result"], "safe")
+        self.assertEqual(event["correlation_id"], "rst-abc123")
+        self.assertEqual(event["profile_name"], "prgs-author")
+        self.assertEqual(event["authenticated_username"], "bot")
+        meta = event["request_metadata"]
+        self.assertEqual(meta["event_family"], "mcp.restart")
+        self.assertEqual(meta["correlation_id"], "rst-abc123")
+        self.assertEqual(meta["restart_class"], "full_mcp_restart")
+        self.assertEqual(meta["details"]["allow_restart"], True)
+
+    def test_unknown_event_type_raises(self):
+        with self.assertRaises(ValueError) as ctx:
+            ra.build_restart_event(
+                event_type="mcp.restart.not_a_real_event",
+                outcome="x",
+                correlation_id="rst-1",
+            )
+        self.assertIn("unknown restart audit event_type", str(ctx.exception))
+
+    def test_reasons_and_details_are_redacted(self):
+        event = ra.build_restart_event(
+            event_type=ra.EVENT_APPLY_GATE,
+            outcome="deny",
+            correlation_id="rst-sec",
+            reasons=["token secret-xyz rejected", "ok"],
+            details={"token": "leak-token", "status": "denied"},
+        )
+        self.assertNotIn("secret-xyz", event.get("reason") or "")
+        meta = event["request_metadata"]
+        self.assertEqual(meta["details"]["token"], gitea_audit.REDACTED)
+        self.assertEqual(meta["details"]["status"], "denied")
+        for reason in meta["reasons"]:
+            self.assertNotIn("secret-xyz", reason)
+
+    def test_new_correlation_id_shape(self):
+        cid = ra.new_correlation_id()
+        self.assertTrue(cid.startswith("rst-"))
+        self.assertEqual(len(cid), len("rst-") + 16)
+
+
+class TestEmitAndRequire(unittest.TestCase):
+    def test_emit_appends_json_line(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "audit.log")
+            event = ra.build_restart_event(
+                event_type=ra.EVENT_DRAIN_PROOF,
+                outcome="pass",
+                correlation_id="rst-write",
+            )
+            self.assertTrue(ra.emit_restart_event(event, path=path))
+            with open(path, encoding="utf-8") as fh:
+                lines = fh.read().splitlines()
+            self.assertEqual(len(lines), 1)
+            loaded = json.loads(lines[0])
+            self.assertEqual(loaded["event_type"], ra.EVENT_DRAIN_PROOF)
+            self.assertEqual(loaded["correlation_id"], "rst-write")
+
+    def test_emit_never_raises(self):
+        self.assertFalse(
+            ra.emit_restart_event({"action": "x"}, path="/no/such/dir/audit.log")
+        )
+
+    def test_require_audit_denies_privileged_when_write_fails_and_enabled(self):
+        deny = ra.require_audit_or_deny(
+            privileged=True, written=False, audit_enabled=True
+        )
+        self.assertEqual(len(deny), 1)
+        self.assertIn("fail closed", deny[0])
+
+    def test_require_audit_allows_when_audit_disabled(self):
+        # Rollout policy: enable audit before enforcing deny-on-audit-fail.
+        deny = ra.require_audit_or_deny(
+            privileged=True, written=False, audit_enabled=False
+        )
+        self.assertEqual(deny, [])
+
+    def test_require_audit_noop_for_non_privileged(self):
+        deny = ra.require_audit_or_deny(
+            privileged=False, written=False, audit_enabled=True
+        )
+        self.assertEqual(deny, [])
+
+    def test_require_audit_allows_when_written(self):
+        deny = ra.require_audit_or_deny(
+            privileged=True, written=True, audit_enabled=True
+        )
+        self.assertEqual(deny, [])
+
+
+class TestIncidents(unittest.TestCase):
+    def test_break_glass_descriptor(self):
+        desc = ra.build_incident_descriptor(
+            kind=ra.INCIDENT_BREAK_GLASS,
+            reasons=["break-glass authorized"],
+            correlation_id="rst-bg",
+            requesting_session_id="s1",
+            restart_class="full_mcp_restart",
+            remote="prgs",
+            org="O",
+            repo="R",
+        )
+        self.assertEqual(desc["kind"], ra.INCIDENT_BREAK_GLASS)
+        self.assertIn("Break-glass", desc["title"])
+        self.assertIn("mcp-health", desc["labels"])
+        self.assertEqual(desc["source"], "restart_audit#665")
+
+    def test_incident_body_redacts_and_includes_correlation(self):
+        desc = ra.build_incident_descriptor(
+            kind=ra.INCIDENT_FAILED_DRAIN,
+            reasons=["token secret-xyz failed proof"],
+            correlation_id="rst-body",
+            remote="prgs",
+            org="O",
+            repo="R",
+            proof_id="proof-1",
+        )
+        body = ra.incident_body(desc)
+        self.assertIn("rst-body", body)
+        self.assertIn("proof-1", body)
+        self.assertIn("mcp-restart-incident:v1", body)
+        self.assertNotIn("secret-xyz", body)
+
+    def test_materialize_dry_run(self):
+        desc = ra.build_incident_descriptor(
+            kind=ra.INCIDENT_FAILED_DRAIN,
+            reasons=["denied"],
+            correlation_id="rst-dr",
+        )
+        result = ra.materialize_incident(desc, create_issue_fn=lambda **k: {}, dry_run=True)
+        self.assertFalse(result["created"])
+        self.assertTrue(result["dry_run"])
+        self.assertIn("dry-run", result["reasons"][0])
+
+    def test_materialize_without_create_fn(self):
+        desc = ra.build_incident_descriptor(
+            kind=ra.INCIDENT_FAILED_DRAIN,
+            reasons=["denied"],
+            correlation_id="rst-nfn",
+        )
+        result = ra.materialize_incident(desc, create_issue_fn=None)
+        self.assertFalse(result["created"])
+        self.assertIn("create_issue_fn not provided", result["reasons"][0])
+
+    def test_materialize_creates_issue(self):
+        created = {}
+
+        def _create(*, title, body, labels, org=None, repo=None, **_kw):
+            created["title"] = title
+            created["body"] = body
+            created["labels"] = labels
+            created["org"] = org
+            created["repo"] = repo
+            return {"number": 999}
+
+        desc = ra.build_incident_descriptor(
+            kind=ra.INCIDENT_BREAK_GLASS,
+            reasons=["break-glass"],
+            correlation_id="rst-create",
+            org="O",
+            repo="R",
+        )
+        result = ra.materialize_incident(desc, create_issue_fn=_create)
+        self.assertTrue(result["created"])
+        self.assertEqual(result["issue_number"], 999)
+        self.assertIn("Break-glass", created["title"])
+        self.assertIn("rst-create", created["body"])
+        self.assertEqual(created["org"], "O")
+
+    def test_materialize_never_raises_on_create_failure(self):
+        def _boom(**_kw):
+            raise RuntimeError("token secret-xyz network")
+
+        desc = ra.build_incident_descriptor(
+            kind=ra.INCIDENT_FAILED_DRAIN,
+            reasons=["x"],
+            correlation_id="rst-boom",
+        )
+        result = ra.materialize_incident(desc, create_issue_fn=_boom)
+        self.assertFalse(result["created"])
+        self.assertIn("failed", result["reasons"][0])
+        self.assertNotIn("secret-xyz", result["reasons"][0])
+
+
+class TestIncidentFromApplyGate(unittest.TestCase):
+    def test_break_glass_always_incident(self):
+        desc = ra.incident_from_apply_gate(
+            gate_payload={"allow": True, "reasons": [], "proof_id": None},
+            break_glass=True,
+            correlation_id="rst-bg2",
+            requesting_session_id="s",
+            restart_class="full_mcp_restart",
+            remote="prgs",
+            org="O",
+            repo="R",
+        )
+        self.assertIsNotNone(desc)
+        self.assertEqual(desc["kind"], ra.INCIDENT_BREAK_GLASS)
+
+    def test_failed_drain_from_gate_incident(self):
+        desc = ra.incident_from_apply_gate(
+            gate_payload={
+                "allow": False,
+                "drain_gate_allow": False,
+                "reasons": ["proof expired"],
+                "incident": {
+                    "reasons": ["proof expired"],
+                    "proof_id": "p1",
+                },
+            },
+            break_glass=False,
+            correlation_id="rst-fd",
+            requesting_session_id="s",
+            restart_class="full_mcp_restart",
+            remote="prgs",
+            org="O",
+            repo="R",
+        )
+        self.assertIsNotNone(desc)
+        self.assertEqual(desc["kind"], ra.INCIDENT_FAILED_DRAIN)
+        self.assertEqual(desc["proof_id"], "p1")
+
+    def test_allow_without_break_glass_no_incident(self):
+        desc = ra.incident_from_apply_gate(
+            gate_payload={
+                "allow": True,
+                "drain_gate_allow": True,
+                "reasons": [],
+            },
+            break_glass=False,
+            correlation_id="rst-ok",
+            requesting_session_id="s",
+            restart_class="full_mcp_restart",
+            remote="prgs",
+            org="O",
+            repo="R",
+        )
+        self.assertIsNone(desc)
+
+
+class TestRecordLifecycle(unittest.TestCase):
+    def test_record_emits_and_materializes(self):
+        created = []
+
+        def _create(**kwargs):
+            created.append(kwargs)
+            return {"number": 42}
+
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "audit.log")
+            with patch.dict(os.environ, {"GITEA_AUDIT_LOG": path}, clear=False):
+                incident = ra.build_incident_descriptor(
+                    kind=ra.INCIDENT_BREAK_GLASS,
+                    reasons=["bg"],
+                    correlation_id="rst-lc",
+                    org="O",
+                    repo="R",
+                )
+                out = ra.record_restart_lifecycle(
+                    event_type=ra.EVENT_BREAK_GLASS,
+                    outcome="break_glass",
+                    correlation_id="rst-lc",
+                    remote="prgs",
+                    org="O",
+                    repo="R",
+                    privileged=True,
+                    create_incident=incident,
+                    create_issue_fn=_create,
+                    audit_path=path,
+                )
+        self.assertTrue(out["audit_written"])
+        self.assertEqual(out["deny_reasons"], [])
+        self.assertTrue(out["incident_result"]["created"])
+        self.assertEqual(out["incident_result"]["issue_number"], 42)
+        self.assertEqual(len(created), 1)
+
+    def test_privileged_deny_when_audit_write_fails(self):
+        with patch.dict(
+            os.environ, {"GITEA_AUDIT_LOG": "/no/such/dir/a.log"}, clear=False
+        ):
+            with patch("restart_audit.emit_restart_event", return_value=False):
+                with patch("gitea_audit.audit_enabled", return_value=True):
+                    out = ra.record_restart_lifecycle(
+                        event_type=ra.EVENT_APPLY_GATE,
+                        outcome="deny",
+                        correlation_id="rst-deny",
+                        privileged=True,
+                        audit_path="/no/such/dir/a.log",
+                    )
+        self.assertFalse(out["audit_written"])
+        self.assertEqual(len(out["deny_reasons"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()