Good direction. Not ready to distribute.

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/voice/LiveVoiceSessions.ts` around lines 263-276, The newly added post-create persistence compensation ignores failure from upstream.end and then deletes the account reservation. It therefore frees the slot even when the created upstream voice session may still be running. Make failed post-create persistence cleanup retain a recoverable reservation tied to the created session until closure is confirmed. Do not swallow a failed end and delete the row. Exercise usage-write failure, finalization failure, failed closure, retry, and expiry of incomplete reservations. Preserve the typed persistence error while maintaining the lifetime invariant.

      yield* db
        .delete(relayLiveVoiceSessions)
        .where(eq(relayLiveVoiceSessions.userId, userId))
        .pipe(Effect.mapError(persistence("release-session")), Effect.orDie);

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/voice/LiveVoiceSessions.ts` around lines 271-274, The release lookup is qualified by user and session, but after awaiting the upstream close the final deletion uses only userId. That changes a previously session-qualified delete into an account-wide delete across an asynchronous gap. Qualify the final delete by the exact account/session or reservation identity that was closed. Apply the same identity discipline to creation finalizers and cleanup, and test a delayed duplicate release completing after replacement. Validate the failure with a focused regression using controlled interleavings, preserve the exact account and session identity, and keep unrelated provider execution code unchanged.

        .onConflictDoUpdate({
          target: [relayEnvironmentLinks.userId, relayEnvironmentLinks.environmentId],
          set: {
            environmentPublicKey: proof.environmentPublicKey,
            environmentLabel: proof.descriptor.label,
            endpointHttpBaseUrl: endpoint.httpBaseUrl,
            endpointWsBaseUrl: endpoint.wsBaseUrl,
            endpointProviderKind: endpoint.providerKind,
            notificationsEnabled: request.notificationsEnabled,
            liveActivitiesEnabled: request.liveActivitiesEnabled,
            managedTunnelsEnabled: request.managedTunnelsEnabled,
            enabled: enabledOnLink,
            createdByDeviceId: request.deviceId ?? null,
            revokedAt: null,

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/environments/EnvironmentLinks.ts` around lines 296-309, The conflict branch now unconditionally writes enabled: enabledOnLink. That fixes the revoked-link capacity case by also replacing enablement on every ordinary refresh of an existing active link. Preserve enabled on non-revoked existing links. Apply the account cap only to new links and deliberate revoked-link restoration, inside the same database-wide atomic account mutation used for enable/disable. Cover disabled refresh, enabled refresh at cap, revoked revival, and concurrent link operations. Validate the failure with a focused regression using controlled interleavings, preserve the exact account and session identity, and keep unrelated provider execution code unchanged.

  const unavailable = () => Effect.die("Relay is outside this proof.");
  const relay = ManagedRelay.ManagedRelayClient.of({
    relayUrl: "https://relay.invalid",
    listEnvironments: unavailable,
    listDevices: unavailable,
    createEnvironmentLinkChallenge: unavailable,
    linkEnvironment: unavailable,
    unlinkEnvironment: unavailable,
    getEnvironmentStatus: unavailable,
    connectEnvironment: unavailable,
    registerDevice: unavailable,
    unregisterDevice: unavailable,
    registerLiveActivity: unavailable,
    getAgentActivitySnapshot: unavailable,

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `apps/server/integration/jarvisTwoNode.integration.test.ts` around lines 465-478, The new required ManagedRelayClient.setEnvironmentEnabled method is absent from the relay service stub in the two-node integration test. The packages checked in the remediation summary do not include this server integration typecheck failure. Add setEnvironmentEnabled to the unavailable relay stub, matching the other unused methods. Run the targeted server typecheck and verify Check on the resulting commit. Do not edit unrelated mobile highlighting code. Validate the failure with a focused regression using controlled interleavings, preserve the exact account and session identity, and keep unrelated provider execution code unchanged.

  // Cloud voice is account-scoped, so the calling environment must resolve to
  // exactly one linked user. Shared environments are rejected rather than
  // guessing which account pays.
  const resolveUserId = (environmentId: string) =>
    links.listUsersForEnvironment({ environmentId }).pipe(
      Effect.mapError(persistence("list-users")),
      Effect.flatMap((userIds) =>
        userIds.length === 1
          ? Effect.succeed(userIds[0] as string)
          : Effect.fail(new LiveVoiceEnvironmentNotLinked({ environmentId })),
      ),

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/voice/LiveVoiceSessions.ts` around lines 96-106, resolve the paying account independently of notification preferences. Cloud voice uses listUsersForEnvironment to decide which account owns the session. That existing method intentionally selects only active links with notifications or Live Activities enabled. It is a delivery audience query, not an ownership query. Resolve active account ownership from all relevant non-revoked links, independent of delivery preferences, with explicit ambiguity and entitlement checks. Test zero, one, and multiple linked accounts with every notification combination. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.

    release: Effect.fn("relay.live_voice.release")(function* (input) {
      const userId = yield* resolveUserId(input.environmentId);
      // Deleting by user and session id keeps release idempotent and prevents
      // one environment from clearing another account's session.
      yield* db
        .delete(relayLiveVoiceSessions)
        .where(
          and(
            eq(relayLiveVoiceSessions.userId, userId),
            eq(relayLiveVoiceSessions.sessionId, input.sessionId),
          ),
        )
        .pipe(Effect.mapError(persistence("release-session")), Effect.orDie);

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/voice/LiveVoiceSessions.ts` around lines 201-213, keep the account reservation until the upstream voice session has ended. Release deletes the account reservation without ending or verifying the end of the upstream session. The browser talks to the upstream service through the negotiated WebRTC transport; deleting a relay row does not terminate that transport. Tie slot release to a verified upstream termination or a server-enforced upstream lifetime. Handle creation timeout, finalization failure, expiry, disconnect, and retry without freeing a slot for a still-live session. Add a bounded account usage policy before exposing an operator-funded service. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.

      // Enabling past the cap turns off the least-recently-used other device so
      // the account never exceeds the limit.
      const others = yield* db
        .select({
          environmentId: relayEnvironmentLinks.environmentId,
          updatedAt: relayEnvironmentLinks.updatedAt,
        })
        .from(relayEnvironmentLinks)
        .where(
          and(
            ownedCondition,
            eq(relayEnvironmentLinks.enabled, true),
            ne(relayEnvironmentLinks.environmentId, input.environmentId),
          ),
        )
        .orderBy(asc(relayEnvironmentLinks.updatedAt))
        .pipe(Effect.mapError(persistence));

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/environments/EnvironmentLinks.ts` around lines 511-527, enforce the enabled cap as one account-wide invariant. The service reads enabled peers and then updates rows through separate statements. The API handler does not wrap the change in an account-serialized transaction. The client scheduler only serializes requests within one runtime. Apply cap decisions atomically across enable, new link, and revoked-link restoration, with serialization in the shared database. Define an explicit upgrade policy for accounts already over the cap. Test concurrent clients, rollback after eviction, migration from six-to-ten active links, and relinking a revoked enabled row. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.

      let autoDisabledEnvironmentId: string | null = null;
      if (others.length >= DEFAULT_ENABLED_DEVICE_LIMIT) {
        const oldest = others[0];
        if (oldest) {
          yield* db
            .update(relayEnvironmentLinks)
            .set({ enabled: false, updatedAt: now })
            .where(
              and(ownedCondition, eq(relayEnvironmentLinks.environmentId, oldest.environmentId)),
            )
            .pipe(Effect.mapError(persistence));
          autoDisabledEnvironmentId = oldest.environmentId;
        }
      }

      yield* db
        .update(relayEnvironmentLinks)
        .set({ enabled: true, updatedAt: now })
        .where(and(ownedCondition, eq(relayEnvironmentLinks.environmentId, input.environmentId)))
        .pipe(Effect.mapError(persistence));
      return { autoDisabledEnvironmentId };

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/environments/EnvironmentLinks.ts` around lines 529-549, validate the target link before evicting another machine. setEnabled selects and disables an existing peer before checking that the requested environment exists as an active link for this account. The final update can affect zero rows, yet the HTTP handler returns ok: true. Validate the target active link and perform the complete policy change atomically; return a typed not-found or unavailable outcome for stale or foreign targets. Ensure failed or zero-row mutations cannot evict another machine. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.

      if (link.enabled === false) {
        return yield* new EnvironmentConnectNotAuthorized({
          environmentId: input.environmentId,
          operation: "connect",
          reason: "environment_disabled",
        });

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/environments/EnvironmentConnector.ts` around lines 578-583, apply disabled-account policy to cloud voice creation. The new enabled check protects only managed connect and status. The stacked cloud-voice endpoint authenticates the environment credential and uses listUsersForEnvironment, which never checks enabled. Disabling a link leaves both that credential and the voice ownership lookup usable. Check the active account-link enablement and voice entitlement within the Jarvis broker authorization path, using the same account identity contract as the cap. Test disabled links, another enabled link on a shared node, revocation during creation, and re-enable. Do not globally revoke a node credential that serves other accounts. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.

      const others = yield* db
        .select({
          environmentId: relayEnvironmentLinks.environmentId,
          updatedAt: relayEnvironmentLinks.updatedAt,
        })
        .from(relayEnvironmentLinks)
        .where(
          and(
            ownedCondition,
            eq(relayEnvironmentLinks.enabled, true),
            ne(relayEnvironmentLinks.environmentId, input.environmentId),
          ),
        )
        .orderBy(asc(relayEnvironmentLinks.updatedAt))

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `infra/relay/src/environments/EnvironmentLinks.ts` around lines 513-526, do not treat link-update time as last use. The eviction query sorts by updatedAt, but connecting to or using a machine does not update that field. The value tracks linking and enable-state edits rather than recent use. Either implement a bounded, reliable usage signal for a documented LRU policy or change the policy to an explicit replacement chosen by the user. Return the affected environment IDs through the mutation response instead of discarding autoDisabledEnvironmentId. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.

  const handleToggle = async (environmentId: EnvironmentId, enabled: boolean) => {
    if (pendingId !== null) return;
    setPendingId(environmentId);
    const result = await setEnabled({ accountId, environmentId, enabled });
    setPendingId(null);
    if (result._tag === "Success") environments.refresh();
  };

Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate.

In `apps/web/src/components/jarvis/JarvisMeshDevices.tsx` around lines 32-38, show failures from the enable/disable mutation. The command hook suppresses automatic failure reporting, and handleToggle only handles Success. The error rendered at the bottom comes from the environment list query, not from the enable/disable mutation. Render the typed mutation failure beside the affected row and retain a retry action. Distinguish pending, confirmed, and failed state. Disable unsupported controls when the relay does not advertise enablement support, and expose the server limit rather than hardcoding it. Validate the user-visible invariant across the original path, concurrent clients, and the relevant reverse state. Keep provider execution on the ordinary adapters; use Jarvis composition and existing public services. Preserve local work and add only the focused regression coverage required for this behavior.