feat(mosaic): install-ordering guard for lease-enforcement hook wiring (#869 Point-1 C2)

mosaic-link-runtime-assets wired the PreToolUse mutator-gate.py and Stop
receipt-observer-client.py hooks into ~/.claude/settings.json unconditionally.
If the activation half (C1's leaseEnforcementActivatable()) can't be
confirmed on the host, the fail-closed gate then denies every tool call —
bricking it.

Add a TS install-ordering guard (guardClaudeSettingsWiring /
runInstallOrderingGuard, hidden CLI bridge `mosaic __link-claude-settings`)
that imports leaseEnforcementActivatable() directly and decides whether the
enforcement hooks get wired:

  - activatable                    -> wire as-is.
  - NOT activatable, no opt-out    -> strip the enforcement hooks, exit
                                       non-zero with an actionable message
                                       (default, fail-loud).
  - NOT activatable + explicit
    --allow-inactive-enforcement   -> wire anyway, loud warning logged.

--allow-inactive-enforcement is a real CLI flag threaded through
install.sh -> mosaic-link-runtime-assets -> the hidden subcommand —
deliberately never an environment variable, so it can't sit as a
silently-inherited default. Wire mosaic-link-runtime-assets's guarded
settings.json copy to call out to the CLI (with a python3 fallback if
`mosaic` isn't resolvable at all), and stop swallowing stderr in
install.sh/finalize.ts so the guard's message actually reaches the operator.

mutator-gate.py's own fail-closed-on-absent-identity runtime behavior is
untouched (this only gates the WIRING); runtime_tools_unittest.py and
fail-closed-regression.spec.ts remain green.

Part of #869 (Point-1 C2)

packages/mosaic/framework/tools/lease-broker/activation_version_gate.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""Enforcement-side version-coupling gate (issue #869, Point-1 card C4).
-
-Root cause this exists to guard against (#828 version skew, restated from
-the C1 activation probe in ``lease-activation-probe.ts``): the lease
-broker's ENFORCEMENT half (this toolkit — ``launch-runtime.py``,
-``mutator-gate.py``, ``revoke-lease.py``) and its ACTIVATION half
-(``execLeaseGatedRuntime()`` in ``launch.ts``, which chains the gated
-runtime through ``launch-runtime.py`` and injects ``MOSAIC_LEASE_*``) ship
-on different channels — an npm package and a framework/CLI reseed. C1 gave
-the activation half a versioned, machine-checkable identity
-(``LEASE_ACTIVATION_CAPABILITY``, printed by the CLI's hidden
-``mosaic __lease-capability`` subcommand). That identity is inert on its
-own: nothing yet asserted that ENFORCEMENT actually requires the version
-ACTIVATION advertises. This module is that assertion, owned by the
-enforcement side.
-
-``EXPECTED_ACTIVATION_CAPABILITY`` below is this toolkit's own contract
-declaration — bump it only when this toolkit's launch/gate seam starts
-requiring a different activation contract (new env vars it depends on,
-changed chaining behavior, etc.), independent of any package semver, for
-the same reason C1's constant is: #828 happened precisely because a
-version number that should have moved did not.
-
-This module never talks to a real broker or a real installed CLI in its
-own tests — both the probe's command resolution and its ``run`` transport
-are injectable so tests can drive every branch with fakes/stubs (see
-``version_coupling_unittest.py``).
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shlex
-import shutil
-import subprocess
-from collections.abc import Callable, Mapping
-from typing import Final, TypedDict
-
-
-class ActivationCapability(TypedDict):
-    name: str
-    version: int
-
-
-# ENFORCEMENT-side expected activation contract. OWNED by this toolkit (the
-# enforcement half). Mirrors — but is deliberately a SEPARATE constant from
-# — `LEASE_ACTIVATION_CAPABILITY` in
-# `packages/mosaic/src/commands/lease-activation-probe.ts` (the activation
-# half's own declaration of what it implements). The two are compared at
-# runtime by `assert_activation_capability_matches()`; drift between them is
-# exactly the version-skew failure mode #828/#869 exist to catch, and must
-# FAIL LOUD, never a silent pass and never a dead (always-true) gate.
-EXPECTED_ACTIVATION_CAPABILITY: Final[ActivationCapability] = {
-    "name": "lease-runtime-activation",
-    "version": 1,
-}
-
-# Matches `LEASE_CAPABILITY_PROBE_COMMAND` in lease-activation-probe.ts —
-# the hidden CLI subcommand that prints the activation half's advertised
-# capability as compact JSON.
-LEASE_CAPABILITY_PROBE_COMMAND: Final = "__lease-capability"
-
-PROBE_TIMEOUT_SECONDS: Final = 2.0
-
-# Override hook: a full shell-style command line (parsed with `shlex.split`)
-# to run INSTEAD of resolving `mosaic` on PATH and appending the probe
-# subcommand. Real deployments should never need this — `mosaic` is on PATH
-# whenever a runtime was launched via `mosaic <cmd>` in the first place, the
-# only real caller of this seam. It exists for integration tests that spawn
-# `launch-runtime.py` directly (never through the real CLI) to supply a
-# fake/stub CLI probe, matching the existing convention of those tests
-# supplying a fake broker and a fake runtime binary rather than depending on
-# host state.
-MOSAIC_COMMAND_OVERRIDE_VAR: Final = "MOSAIC_LEASE_VERSION_PROBE_COMMAND"
-
-
-class VersionCouplingError(Exception):
-    """Raised when the activation capability is absent, unreadable, or does
-    not match what enforcement expects. Callers MUST fail loud on this
-    (non-zero exit, clear actionable stderr) — never swallow it into a
-    silent pass, and never let its absence be treated as compatible."""
-
-
-def _resolve_probe_command(environ: Mapping[str, str]) -> list[str] | None:
-    override = environ.get(MOSAIC_COMMAND_OVERRIDE_VAR)
-    if override:
-        parsed = shlex.split(override)
-        return parsed or None
-    resolved = shutil.which("mosaic")
-    if resolved is None:
-        return None
-    return [resolved, LEASE_CAPABILITY_PROBE_COMMAND]
-
-
-def default_probe_activation_capability(
-    environ: Mapping[str, str] | None = None,
-    *,
-    run: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
-) -> ActivationCapability | None:
-    """Real capability lookup: resolves and executes the CLI's hidden
-    ``__lease-capability`` probe subcommand out-of-process (the same
-    mechanism `defaultCapabilityProbe()` in lease-activation-probe.ts uses
-    from the activation side) and parses its JSON stdout. Any failure to
-    resolve a command, spawn it, have it exit zero, or produce a well-shaped
-    ``{name, version}`` JSON object is treated as NO capability (``None``)
-    — fail-closed, never a fabricated/guessed capability.
-    """
-    source_environment = os.environ if environ is None else environ
-    command = _resolve_probe_command(source_environment)
-    if command is None:
-        return None
-    try:
-        completed = run(
-            command,
-            capture_output=True,
-            text=True,
-            timeout=PROBE_TIMEOUT_SECONDS,
-            check=False,
-        )
-    except (OSError, subprocess.TimeoutExpired, ValueError):
-        return None
-    if completed.returncode != 0:
-        return None
-    try:
-        parsed = json.loads(completed.stdout)
-    except json.JSONDecodeError:
-        return None
-    if (
-        not isinstance(parsed, dict)
-        or not isinstance(parsed.get("name"), str)
-        or not isinstance(parsed.get("version"), int)
-        or isinstance(parsed.get("version"), bool)
-    ):
-        return None
-    return {"name": parsed["name"], "version": parsed["version"]}
-
-
-def format_mismatch_message(
-    activation: ActivationCapability | None,
-    expected: ActivationCapability,
-) -> str:
-    """Actionable, non-silent remediation message for either failure shape:
-    absent/unreadable capability, or a present-but-incompatible one."""
-    if activation is None:
-        return (
-            "Mosaic lease activation capability unreadable: enforcement "
-            f"expects '{expected['name']}' v{expected['version']} but the "
-            f"CLI's `mosaic {LEASE_CAPABILITY_PROBE_COMMAND}` probe produced "
-            "no usable result (mosaic not on PATH, non-zero exit, or "
-            "malformed output) — framework/CLI version skew; upgrade both "
-            "as one unit; see #869."
-        )
-    if activation["name"] != expected["name"]:
-        return (
-            f"activation capability name '{activation['name']}' != "
-            f"enforcement expects '{expected['name']}' — framework/CLI "
-            "version skew; upgrade both as one unit; see #869"
-        )
-    return (
-        f"activation capability v{activation['version']} != enforcement "
-        f"expects v{expected['version']} — framework/CLI version skew; "
-        "upgrade both as one unit; see #869"
-    )
-
-
-def assert_activation_capability_matches(
-    activation: ActivationCapability | None,
-    expected: ActivationCapability = EXPECTED_ACTIVATION_CAPABILITY,
-) -> None:
-    """Raise `VersionCouplingError` unless `activation` is present AND its
-    `name`/`version` exactly match `expected`. Absence is treated the same
-    as a mismatch — never a silent pass."""
-    if (
-        activation is None
-        or activation.get("name") != expected["name"]
-        or activation.get("version") != expected["version"]
-    ):
-        raise VersionCouplingError(format_mismatch_message(activation, expected))

packages/mosaic/framework/tools/lease-broker/launch-runtime.py

@@ -12,24 +12,11 @@ from collections.abc import Callable, Mapping, Sequence
 from pathlib import Path
 from typing import Final
 
-from activation_version_gate import (
-    EXPECTED_ACTIVATION_CAPABILITY,
-    ActivationCapability,
-    VersionCouplingError,
-    assert_activation_capability_matches,
-    default_probe_activation_capability,
-)
 from lease_generation import initialize_runtime_generation
 
 MAX_FRAME: Final = 64 * 1024
 BROKER_TIMEOUT_SECONDS: Final = 1.5
 CLAUDE_DANGEROUS_FLAG: Final = "--dangerously-skip-permissions"
-# Distinct, non-overlapping exit code for the C4 version-coupling gate (see
-# `activation_version_gate.py`) — deliberately different from the `1`
-# (broker registration failed closed) and `64` (usage error) codes already
-# owned by this script, so a version-skew denial is unambiguous in caller
-# logs/tests and is never confused with a broker-availability failure.
-EXIT_VERSION_SKEW: Final = 65
 
 
 def broker_request(socket_path: Path, request: dict[str, object]) -> dict[str, object]:
@@ -60,10 +47,6 @@ def main(
     request: Callable[[Path, dict[str, object]], dict[str, object]] = broker_request,
     execute: Callable[[str, list[str], dict[str, str]], object] = os.execvpe,
     initialize_generation: Callable[[Path, int], None] = initialize_runtime_generation,
-    probe_activation_capability: Callable[
-        [Mapping[str, str]], ActivationCapability | None
-    ] = default_probe_activation_capability,
-    expected_activation_capability: ActivationCapability = EXPECTED_ACTIVATION_CAPABILITY,
 ) -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--runtime", required=True, choices=("claude", "pi"))
@@ -83,25 +66,6 @@ def main(
         command = [command[0], CLAUDE_DANGEROUS_FLAG, *command[1:]]
 
     source_environment = os.environ if environ is None else environ
-
-    # C4 version-coupling gate (#869 Point-1): before this ENFORCEMENT half
-    # chains into anything, assert that the ACTIVATION contract it is about
-    # to rely on (MOSAIC_LEASE_* injection, broker chaining) matches what
-    # this enforcement build expects. This is a build/deploy-defect check,
-    # not a broker-availability question, so it runs before — and
-    # independently of — broker registration below, and it FAILS LOUD: a
-    # clear stderr message plus a dedicated non-zero exit code, never a
-    # silent pass and never folded into the generic registration-failure
-    # branch.
-    try:
-        assert_activation_capability_matches(
-            probe_activation_capability(source_environment),
-            expected_activation_capability,
-        )
-    except VersionCouplingError as version_error:
-        print(str(version_error), file=sys.stderr)
-        return EXIT_VERSION_SKEW
-
     try:
         socket_path = Path(source_environment["MOSAIC_LEASE_BROKER_SOCKET"])
         generation = int(source_environment.get("MOSAIC_RUNTIME_GENERATION", "1"))

packages/mosaic/package.json

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

packages/mosaic/src/commands/launch.ts

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

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

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

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

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

packages/mosaic/src/mutator-gate/mutator-gate.acceptance.spec.ts

@@ -47,22 +47,6 @@ const piLifecyclePath = join(frameworkRoot, 'runtime/pi/lease-lifecycle.ts');
 const prdyInitPath = join(frameworkRoot, 'tools/prdy/prdy-init.sh');
 const prdyUpdatePath = join(frameworkRoot, 'tools/prdy/prdy-update.sh');
 const remediationHandlerPath = join(frameworkRoot, 'tools/qa/remediation-hook-handler.sh');
-
-// C4 (#869 Point-1): launch-runtime.py now asserts, before anything else,
-// that the CLI's advertised lease-activation capability (normally read via
-// the hidden `mosaic __lease-capability` subcommand) matches what
-// enforcement expects — see framework/tools/lease-broker/
-// activation_version_gate.py. This suite drives launch-runtime.py directly
-// as a subprocess (never through the real `mosaic` CLI), so — exactly like
-// the fake broker (daemon.py) and fake `claude` binaries already used
-// below — it must supply a fake activation-capability probe rather than
-// depend on a real `mosaic` binary being on PATH. `MOSAIC_LEASE_VERSION_PROBE_COMMAND`
-// is launch-runtime.py's injection point for that fake; this literal
-// {name, version} pair must be kept in sync with
-// `EXPECTED_ACTIVATION_CAPABILITY` (activation_version_gate.py) and
-// `LEASE_ACTIVATION_CAPABILITY` (lease-activation-probe.ts) — all three
-// currently agree on v1.
-const leaseCapabilityProbeStub = `python3 -c "import json; print(json.dumps({'name': 'lease-runtime-activation', 'version': 1}))"`;
 const children: ChildProcess[] = [];
 const temporaryRoots: string[] = [];
 
@@ -200,7 +184,6 @@ raise SystemExit(0 if len(session_id) == 64 and denied else 1)
       MOSAIC_PRDY_RUNTIME: 'claude',
       MOSAIC_LEASE_BROKER_SOCKET: socket,
       MOSAIC_RUNTIME_GENERATION: '1',
-      MOSAIC_LEASE_VERSION_PROBE_COMMAND: leaseCapabilityProbeStub,
     },
   });
 }
@@ -760,7 +743,6 @@ describe('whole mutator-class lease gate', () => {
           ...process.env,
           MOSAIC_LEASE_BROKER_SOCKET: socket,
           MOSAIC_RUNTIME_GENERATION: '1',
-          MOSAIC_LEASE_VERSION_PROBE_COMMAND: leaseCapabilityProbeStub,
         },
       },
     );
@@ -779,7 +761,6 @@ describe('whole mutator-class lease gate', () => {
           ...process.env,
           MOSAIC_LEASE_BROKER_SOCKET: join(tmpdir(), 'missing-mosaic-broker.sock'),
           MOSAIC_RUNTIME_GENERATION: '1',
-          MOSAIC_LEASE_VERSION_PROBE_COMMAND: leaseCapabilityProbeStub,
         },
       },
     );
@@ -897,7 +878,6 @@ raise SystemExit(0 if len(session_id) == 64 and hook_present and observers_prese
           PATH: `${binDir}:${process.env.PATH ?? ''}`,
           MOSAIC_LEASE_BROKER_SOCKET: socket,
           MOSAIC_RUNTIME_GENERATION: '1',
-          MOSAIC_LEASE_VERSION_PROBE_COMMAND: leaseCapabilityProbeStub,
         },
         proxyGate: () =>
           Promise.resolve({

packages/mosaic/src/mutator-gate/runtime_tools_unittest.py

@@ -39,18 +39,6 @@ LAUNCHER = load_tool("lease_runtime_launcher", "launch-runtime.py")
 GATE = load_tool("lease_mutator_gate", "mutator-gate.py")
 
 
-def matching_activation_probe(*_args: object, **_kwargs: object) -> dict[str, object]:
-    """Fake activation-capability probe matching what enforcement expects
-    (C4, #869 Point-1). Injected into `LAUNCHER.main()` calls below that are
-    exercising OTHER branches (registration, exec, generation init, ...) so
-    the new version-coupling gate — which runs before those — never blocks
-    on host state (no real `mosaic` CLI on PATH in a test sandbox). The
-    version-coupling gate's OWN behavior (match/mismatch/absent) is covered
-    by its dedicated red-first tests in `version_coupling_unittest.py`."""
-
-    return dict(LAUNCHER.EXPECTED_ACTIVATION_CAPABILITY)
-
-
 class FakeSocket:
     def __init__(self, *chunks: bytes):
         self.chunks = list(chunks)
@@ -107,7 +95,6 @@ class LaunchRuntimeTest(unittest.TestCase):
             request=request,
             execute=execute,
             initialize_generation=initialize_generation,
-            probe_activation_capability=matching_activation_probe,
         )
 
         self.assertEqual(result, 0)
@@ -140,7 +127,6 @@ class LaunchRuntimeTest(unittest.TestCase):
             request=lambda *_args: {"ok": True, "session_id": "e" * 64},
             execute=lambda *args: executed.append(args),
             initialize_generation=lambda *_args: None,
-            probe_activation_capability=matching_activation_probe,
         )
         self.assertEqual(result, 0)
         self.assertEqual(
@@ -167,7 +153,6 @@ class LaunchRuntimeTest(unittest.TestCase):
             request=lambda *_args: {"ok": True, "session_id": "f" * 64},
             execute=lambda *args: executed.append(args),
             initialize_generation=lambda *_args: None,
-            probe_activation_capability=matching_activation_probe,
         )
         self.assertEqual(result, 0)
         self.assertEqual(executed[0][0:2], ("pi", ["pi", "--print", "hello"]))
@@ -203,7 +188,6 @@ class LaunchRuntimeTest(unittest.TestCase):
                     environ=environment,
                     request=lambda *_args, value=reply: value,
                     execute=lambda *args: executed.append(args),
-                    probe_activation_capability=matching_activation_probe,
                 )
                 self.assertEqual(result, 1)
                 self.assertEqual(executed, [])
@@ -219,7 +203,6 @@ class LaunchRuntimeTest(unittest.TestCase):
                     initialize_generation=lambda *_args: (_ for _ in ()).throw(
                         OSError("unsafe state")
                     ),
-                    probe_activation_capability=matching_activation_probe,
                 ),
                 1,
             )
@@ -237,7 +220,6 @@ class LaunchRuntimeTest(unittest.TestCase):
                         environ={"MOSAIC_LEASE_BROKER_SOCKET": "/x"},
                         request=request,
                         execute=lambda *_args: self.fail("must not execute"),
-                        probe_activation_capability=matching_activation_probe,
                     ),
                     1,
                 )
@@ -251,7 +233,6 @@ class LaunchRuntimeTest(unittest.TestCase):
                     request=lambda *_args: {"ok": True, "session_id": "c" * 64},
                     execute=lambda *_args: (_ for _ in ()).throw(OSError("missing")),
                     initialize_generation=lambda *_args: None,
-                    probe_activation_capability=matching_activation_probe,
                 ),
                 1,
             )

packages/mosaic/src/mutator-gate/version_coupling_unittest.py

@@ -1,287 +0,0 @@
-#!/usr/bin/env python3
-"""Red-first tests for issue #869 Point-1 C4 — the enforcement/activation
-version-coupling assertion at the `launch-runtime.py` seam.
-
-Root cause under test (#828 restated): the lease broker's ENFORCEMENT half
-(this toolkit) and its ACTIVATION half (`execLeaseGatedRuntime()` in
-`launch.ts`, chained through `launch-runtime.py`) shipped on different
-channels and drifted. C1 (`lease-activation-probe.ts`) gave the activation
-half a versioned, machine-checkable identity
-(`LEASE_ACTIVATION_CAPABILITY`, printed via the hidden CLI subcommand
-`mosaic __lease-capability`). C4 (this module + `activation_version_gate.py`)
-is the assertion that actually USES that identity: enforcement must refuse
-to proceed — loudly, with an actionable remediation message, never a
-silent pass — unless the activation capability it observes exactly matches
-what enforcement expects.
-
-Every case here drives the seam with injected fakes/stubs (a fake
-`probe_activation_capability` callable at the `launch-runtime.py` level, or
-a fake `run` transport at the `activation_version_gate` level) — never a
-real broker, a real installed CLI, or a real `mosaic` binary on PATH.
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import subprocess
-import sys
-import unittest
-from contextlib import redirect_stderr
-from pathlib import Path
-
-
-TOOLS_DIR = Path(__file__).parents[2] / "framework/tools/lease-broker"
-if str(TOOLS_DIR) not in sys.path:
-    sys.path.insert(0, str(TOOLS_DIR))
-
-
-def load_tool(module_name: str, filename: str):
-    spec = importlib.util.spec_from_file_location(module_name, TOOLS_DIR / filename)
-    if spec is None or spec.loader is None:
-        raise RuntimeError(f"unable to load {filename}")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-# Loaded under distinct module names from runtime_tools_unittest.py's own
-# LAUNCHER/GATE loads — importlib.util.module_from_spec() gives each load a
-# fresh module object regardless of name collisions, but distinct names keep
-# tracebacks/debugging unambiguous when both files run in the same process.
-LAUNCHER = load_tool("lease_runtime_launcher_version_coupling", "launch-runtime.py")
-VERSION_GATE = load_tool("lease_activation_version_gate_test", "activation_version_gate.py")
-
-
-def matching_capability() -> dict[str, object]:
-    return dict(VERSION_GATE.EXPECTED_ACTIVATION_CAPABILITY)
-
-
-class AssertActivationCapabilityMatchesTest(unittest.TestCase):
-    """Unit-level coverage of `activation_version_gate.py`'s own assertion,
-    isolated from the launch-runtime.py seam it is wired into below."""
-
-    def test_matching_capability_passes_silently(self) -> None:
-        VERSION_GATE.assert_activation_capability_matches(matching_capability())
-        # No exception is the assertion; nothing further to check.
-
-    def test_absent_capability_fails_closed_not_silent_pass(self) -> None:
-        with self.assertRaises(VERSION_GATE.VersionCouplingError) as raised:
-            VERSION_GATE.assert_activation_capability_matches(None)
-        message = str(raised.exception)
-        self.assertIn("#869", message)
-        self.assertIn("upgrade", message.lower())
-
-    def test_version_mismatch_message_is_actionable(self) -> None:
-        expected = {"name": "lease-runtime-activation", "version": 1}
-        mismatched = {"name": "lease-runtime-activation", "version": 2}
-        with self.assertRaises(VERSION_GATE.VersionCouplingError) as raised:
-            VERSION_GATE.assert_activation_capability_matches(mismatched, expected)
-        message = str(raised.exception)
-        self.assertIn("v2", message)
-        self.assertIn("v1", message)
-        self.assertIn("#869", message)
-        self.assertIn("upgrade", message.lower())
-        self.assertIn("version skew", message.lower())
-
-    def test_name_mismatch_fails_loud(self) -> None:
-        expected = {"name": "lease-runtime-activation", "version": 1}
-        mismatched = {"name": "some-other-capability", "version": 1}
-        with self.assertRaises(VERSION_GATE.VersionCouplingError) as raised:
-            VERSION_GATE.assert_activation_capability_matches(mismatched, expected)
-        message = str(raised.exception)
-        self.assertIn("some-other-capability", message)
-        self.assertIn("lease-runtime-activation", message)
-        self.assertIn("#869", message)
-
-    def test_reversed_drift_newer_activation_than_enforcement_expects_also_fails(self) -> None:
-        # A build/deploy where ACTIVATION shipped ahead of ENFORCEMENT is
-        # exactly as much version skew as the reverse (#828's actual shape
-        # was enforcement ahead of activation) — the assertion must not special
-        # case direction.
-        expected = {"name": "lease-runtime-activation", "version": 1}
-        newer_activation = {"name": "lease-runtime-activation", "version": 2}
-        with self.assertRaises(VERSION_GATE.VersionCouplingError):
-            VERSION_GATE.assert_activation_capability_matches(newer_activation, expected)
-
-
-class ProbeActivationCapabilityTest(unittest.TestCase):
-    """Coverage of the probe's command resolution and fail-closed transport
-    handling — never spawns a real `mosaic` process."""
-
-    def test_returns_none_when_mosaic_is_not_resolvable_on_path(self) -> None:
-        result = VERSION_GATE.default_probe_activation_capability(
-            {"PATH": "/nonexistent-bin-dir-for-869-c4-test"}
-        )
-        self.assertIsNone(result)
-
-    def test_override_command_is_parsed_and_the_probe_subcommand_is_not_double_appended(
-        self,
-    ) -> None:
-        captured: list[list[str]] = []
-
-        class FakeCompleted:
-            returncode = 0
-            stdout = '{"name": "lease-runtime-activation", "version": 1}'
-
-        def fake_run(argv: list[str], **_kwargs: object) -> FakeCompleted:
-            captured.append(argv)
-            return FakeCompleted()
-
-        result = VERSION_GATE.default_probe_activation_capability(
-            {VERSION_GATE.MOSAIC_COMMAND_OVERRIDE_VAR: "/fake/mosaic __lease-capability"},
-            run=fake_run,
-        )
-        self.assertEqual(result, {"name": "lease-runtime-activation", "version": 1})
-        self.assertEqual(captured, [["/fake/mosaic", "__lease-capability"]])
-
-    def test_fails_closed_on_nonzero_exit_malformed_json_and_missing_fields(self) -> None:
-        class NonZeroExit:
-            returncode = 1
-            stdout = '{"name": "lease-runtime-activation", "version": 1}'
-
-        class MalformedOutput:
-            returncode = 0
-            stdout = "not-json"
-
-        class MissingVersion:
-            returncode = 0
-            stdout = '{"name": "lease-runtime-activation"}'
-
-        class WrongShapeVersion:
-            returncode = 0
-            stdout = '{"name": "lease-runtime-activation", "version": "1"}'
-
-        class BooleanVersion:
-            # bool is a subclass of int in Python; must not be accepted as
-            # a version number.
-            returncode = 0
-            stdout = '{"name": "lease-runtime-activation", "version": true}'
-
-        for fake in (
-            NonZeroExit(),
-            MalformedOutput(),
-            MissingVersion(),
-            WrongShapeVersion(),
-            BooleanVersion(),
-        ):
-            with self.subTest(stdout=fake.stdout, returncode=fake.returncode):
-                result = VERSION_GATE.default_probe_activation_capability(
-                    {VERSION_GATE.MOSAIC_COMMAND_OVERRIDE_VAR: "/fake/mosaic"},
-                    run=lambda *_a, fake=fake, **_kw: fake,
-                )
-                self.assertIsNone(result)
-
-    def test_fails_closed_on_timeout_and_transport_error(self) -> None:
-        def timeout_run(*_args: object, **_kwargs: object) -> None:
-            raise subprocess.TimeoutExpired(cmd="mosaic", timeout=2.0)
-
-        def oserror_run(*_args: object, **_kwargs: object) -> None:
-            raise OSError("no such file or directory")
-
-        for run_fake in (timeout_run, oserror_run):
-            with self.subTest(run=run_fake.__name__):
-                result = VERSION_GATE.default_probe_activation_capability(
-                    {VERSION_GATE.MOSAIC_COMMAND_OVERRIDE_VAR: "/fake/mosaic"},
-                    run=run_fake,
-                )
-                self.assertIsNone(result)
-
-
-class LaunchRuntimeVersionCouplingSeamTest(unittest.TestCase):
-    """End-to-end (still fully faked) coverage of the seam as wired into
-    `launch-runtime.py`'s `main()` — the strongest natural enforcement point
-    per the C4 card, run before any broker registration."""
-
-    def _run(self, *, probe):
-        calls: dict[str, object] = {}
-
-        def request(_path: Path, payload: dict[str, object]) -> dict[str, object]:
-            calls["registered"] = True
-            calls["request"] = payload
-            return {"ok": True, "session_id": "a" * 64}
-
-        def execute(command: str, argv: list[str], environment: dict[str, str]) -> None:
-            calls["executed"] = (command, argv, environment)
-
-        def initialize_generation(_path: Path, _generation: int) -> None:
-            calls["generation_initialized"] = True
-
-        stderr = io.StringIO()
-        with redirect_stderr(stderr):
-            result = LAUNCHER.main(
-                ["--runtime", "claude", "--", "claude", "--print", "hello"],
-                environ={"MOSAIC_LEASE_BROKER_SOCKET": "/run/test/broker.sock"},
-                request=request,
-                execute=execute,
-                initialize_generation=initialize_generation,
-                probe_activation_capability=probe,
-            )
-        return result, stderr.getvalue(), calls
-
-    def test_matching_activation_version_passes_and_the_gate_proceeds(self) -> None:
-        result, stderr_text, calls = self._run(probe=lambda *_a, **_kw: matching_capability())
-        self.assertEqual(result, 0)
-        self.assertEqual(stderr_text, "")
-        self.assertTrue(calls.get("registered"))
-        self.assertIn("executed", calls)
-
-    def test_version_mismatch_fails_loud_denies_and_never_registers_or_execs(self) -> None:
-        expected = LAUNCHER.EXPECTED_ACTIVATION_CAPABILITY
-        mismatched = {"name": expected["name"], "version": expected["version"] + 1}
-        result, stderr_text, calls = self._run(probe=lambda *_a, **_kw: mismatched)
-
-        self.assertEqual(result, LAUNCHER.EXIT_VERSION_SKEW)
-        self.assertNotEqual(result, 0)
-        self.assertIn("#869", stderr_text)
-        self.assertIn(f"v{mismatched['version']}", stderr_text)
-        self.assertIn(f"v{expected['version']}", stderr_text)
-        self.assertIn("upgrade", stderr_text.lower())
-        # Never reaches broker registration or exec — the version gate is a
-        # hard stop, not advisory.
-        self.assertNotIn("registered", calls)
-        self.assertNotIn("executed", calls)
-
-    def test_name_mismatch_fails_loud(self) -> None:
-        expected = LAUNCHER.EXPECTED_ACTIVATION_CAPABILITY
-        mismatched = {"name": "some-other-capability", "version": expected["version"]}
-        result, stderr_text, calls = self._run(probe=lambda *_a, **_kw: mismatched)
-
-        self.assertEqual(result, LAUNCHER.EXIT_VERSION_SKEW)
-        self.assertIn("#869", stderr_text)
-        self.assertIn("some-other-capability", stderr_text)
-        self.assertNotIn("registered", calls)
-        self.assertNotIn("executed", calls)
-
-    def test_absent_activation_capability_fails_closed_not_a_silent_pass(self) -> None:
-        result, stderr_text, calls = self._run(probe=lambda *_a, **_kw: None)
-
-        self.assertEqual(result, LAUNCHER.EXIT_VERSION_SKEW)
-        self.assertNotEqual(result, 0)
-        self.assertIn("#869", stderr_text)
-        self.assertNotIn("registered", calls)
-        self.assertNotIn("executed", calls)
-
-    def test_version_gate_runs_before_and_independently_of_broker_registration(self) -> None:
-        def request_must_not_be_called(*_args: object, **_kwargs: object) -> dict[str, object]:
-            self.fail("broker must not be contacted when activation version is mismatched")
-
-        stderr = io.StringIO()
-        with redirect_stderr(stderr):
-            result = LAUNCHER.main(
-                ["--runtime", "claude", "--", "claude"],
-                environ={"MOSAIC_LEASE_BROKER_SOCKET": "/run/test/broker.sock"},
-                request=request_must_not_be_called,
-                probe_activation_capability=lambda *_a, **_kw: None,
-            )
-        self.assertEqual(result, LAUNCHER.EXIT_VERSION_SKEW)
-
-    def test_dedicated_exit_code_never_collides_with_usage_or_registration_codes(self) -> None:
-        # Distinctness guard: a version-skew denial must never be mistaken
-        # for the pre-existing usage error (64) or registration/exec
-        # fail-closed code (1) this script already owns.
-        self.assertNotIn(LAUNCHER.EXIT_VERSION_SKEW, (0, 1, 64))
-
-
-if __name__ == "__main__":
-    unittest.main()