Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
257 KB
Raw Blame
import { type Mock, beforeEach, describe, expect, expectTypeOf, it, vi } from 'vitest'
import * as k8s from '@kubernetes/client-node'
import type { RecordWithTtl } from 'node:dns'
import * as dns from 'node:dns/promises'
import { readFileSync } from 'node:fs'
import { join } from 'node:path'
import {
  asAppsApi,
  asCoreApi,
  asCustomApi,
  createMockAppsApi,
  createMockCoreApi,
} from '../test/__fixtures__/testMocks'
import { asApiserverNetworkPolicy } from './__tests__/asApiserverNetworkPolicy'
import { config } from './config'
import { MANAGED_BY_LABEL, MANAGED_BY_VALUE, MCPSERVER_LABEL, POLICY_TYPE_LABEL } from './constants'
import { confirmAuthoritativeMcpServerAbsence } from './mcpServerSafety'
import {
  networkPolicySafetyPassDurationSeconds,
  networkPolicySafetyPassPoliciesTotal,
} from './metrics'
import {
  DESIRED_NETWORKPOLICY_INVENTORY_CHANGED_MESSAGE,
  NetworkPolicyReconciler,
  PUBLIC_EGRESS_EXCEPT_CIDRS,
  sameContextDesiredRevision,
} from './networkPolicyReconciler'
import { McpServerReconciler } from './reconciler'
import { ContextCRD, McpServerCRD } from './types'
import { getErrorCode } from './utils'

function deferred<T = void>(): {
  promise: Promise<T>
  resolve: (value: T | PromiseLike<T>) => void
} {
  let resolve!: (value: T | PromiseLike<T>) => void
  const promise = new Promise<T>(res => {
    resolve = res
  })
  return { promise, resolve }
}

vi.mock('./mcpServerSafety', async () => {
  const actual = await vi.importActual<typeof import('./mcpServerSafety')>('./mcpServerSafety')
  return {
    ...actual,
    confirmAuthoritativeMcpServerAbsence: vi.fn(actual.confirmAuthoritativeMcpServerAbsence),
  }
})

// resolve4({ ttl: true }) returns RecordWithTtl[]; `rec` builds that shape and
// `resolve4Mock` sidesteps the string[]/RecordWithTtl[] overload inference.
const rec = (...ips: string[]): RecordWithTtl[] => ips.map(address => ({ address, ttl: 300 }))
const resolve4Mock = vi.mocked(dns.resolve4) as unknown as Mock

// Mock config
vi.mock('./config', () => ({
  config: {
    namespace: 'mcp-server',
    controlPlaneNamespace: 'control-plane',
    hostNamespace: 'mcp-host',
    rpcProxyNamespace: 'rpc-proxy',
    port: 8081,
    runtimeNamespaces: ['mcp-server', 'mcp-host', 'sandbox-recipes', 'rpc-proxy'],
    k8sApiCidrs: [],
    externalEgressDnsResolveTimeoutMs: 5_000,
    // #299 sliding-window knobs read by reconcileExternalEgress.
    externalEgressOverlapSec: 300,
    externalEgressMaxEntries: 128,
    netPolOrphanDeleteCap: 10,
    netPolOrphanDeleteCapPercent: 20,
  },
}))

// Mock dns. Production now calls resolve4(host, { ttl: true }) for the #299
// sliding window, so the resolver returns RecordWithTtl[] ({ address, ttl }),
// not string[]. `rec()` builds that shape; `resolve4Mock` is the loosely-typed
// mock accessor (resolve4's overloads otherwise infer the string[] return).
vi.mock('node:dns/promises', () => ({
  resolve4: vi.fn().mockResolvedValue([
    { address: '1.2.3.4', ttl: 300 },
    { address: '5.6.7.8', ttl: 300 },
  ]),
}))

vi.mock('./metrics', () => ({
  mcpserverMissingSecret: { set: vi.fn() },
  createsTotal: { inc: vi.fn() },
  existenceReadsTotal: { inc: vi.fn() },
  networkPolicySafetyPassDurationSeconds: { observe: vi.fn() },
  networkPolicySafetyPassPoliciesTotal: { inc: vi.fn() },
  netPolOrphansDeletedTotal: { inc: vi.fn() },
  netPolOrphanSweepCappedTotal: { inc: vi.fn() },
  writesTotal: { inc: vi.fn() },
  writeSkipsTotal: { inc: vi.fn() },
}))

function makeMockNetworkingApi() {
  return {
    createNamespacedNetworkPolicy: vi.fn().mockResolvedValue({}),
    readNamespacedNetworkPolicy: vi.fn().mockImplementation(async ({ name }) => {
      if (
        name.startsWith('ext-egress-') ||
        name === 'allow-desktop-egress-rpc-proxy' ||
        name === 'allow-rpc-proxy-to-managed-mcp-servers'
      ) {
        throw Object.assign(new Error('not found'), { code: 404 })
      }
      return { metadata: { resourceVersion: '1' } }
    }),
    replaceNamespacedNetworkPolicy: vi.fn().mockResolvedValue({}),
    listNamespacedNetworkPolicy: vi.fn().mockResolvedValue({ items: [] }),
    deleteNamespacedNetworkPolicy: vi.fn().mockResolvedValue({}),
  }
}

function makeMockCustomApi() {
  return {
    getNamespacedCustomObject: vi
      .fn()
      .mockRejectedValue(Object.assign(new Error('not found'), { code: 404 })),
    listNamespacedCustomObject: vi.fn().mockResolvedValue({ items: [] }),
    getNamespacedCustomObjectStatus: vi.fn().mockResolvedValue({
      metadata: {
        generation: 7,
        resourceVersion: 'status-rv-default',
      },
      status: {},
    }),
    patchNamespacedCustomObjectStatus: vi.fn().mockResolvedValue({}),
  }
}

function makeReconciler(
  mockApi: ReturnType<typeof makeMockNetworkingApi>,
  serverCache?: Map<string, McpServerCRD>,
  mockCustomApi: ReturnType<typeof makeMockCustomApi> = makeMockCustomApi()
): NetworkPolicyReconciler {
  const kc = new k8s.KubeConfig()
  kc.loadFromOptions({
    clusters: [{ name: 'test', server: 'https://test' }],
    users: [{ name: 'test' }],
    contexts: [{ name: 'test', cluster: 'test', user: 'test' }],
    currentContext: 'test',
  })
  const cache = serverCache ?? new Map()
  const reconciler = new NetworkPolicyReconciler(kc, cache)
  const listedPolicies = new Map<string, k8s.V1NetworkPolicy>()
  const networkingApi = {
    ...mockApi,
    listNamespacedNetworkPolicy: async (args: { namespace: string }) => {
      const response = await mockApi.listNamespacedNetworkPolicy(args)
      const items = (response.items ?? []).map((policy: k8s.V1NetworkPolicy, index: number) => {
        const name = policy.metadata?.name ?? `unnamed-${index}`
        const materialized = {
          ...policy,
          metadata: {
            ...policy.metadata,
            name,
            namespace: policy.metadata?.namespace ?? args.namespace,
            uid: policy.metadata?.uid ?? `${args.namespace}:${name}:uid`,
            resourceVersion: policy.metadata?.resourceVersion ?? '1',
          },
        }
        listedPolicies.set(`${args.namespace}/${name}`, materialized)
        return materialized
      })
      return { ...response, items }
    },
    readNamespacedNetworkPolicy: async (args: { name: string; namespace: string }) => {
      const listed = listedPolicies.get(`${args.namespace}/${args.name}`)
      let response: k8s.V1NetworkPolicy
      try {
        response = await mockApi.readNamespacedNetworkPolicy(args)
      } catch (error: unknown) {
        if (getErrorCode(error) === 404 && listed) return listed
        throw error
      }
      return {
        ...listed,
        ...response,
        metadata: {
          ...listed?.metadata,
          ...response.metadata,
          name: response.metadata?.name ?? listed?.metadata?.name ?? args.name,
          namespace: response.metadata?.namespace ?? listed?.metadata?.namespace ?? args.namespace,
          uid:
            response.metadata?.uid ?? listed?.metadata?.uid ?? `${args.namespace}:${args.name}:uid`,
          resourceVersion:
            response.metadata?.resourceVersion ?? listed?.metadata?.resourceVersion ?? '1',
        },
      }
    },
  }
  ;(reconciler as unknown as { networkingApi: unknown }).networkingApi = networkingApi
  ;(reconciler as unknown as { customApi: unknown }).customApi = mockCustomApi
  return reconciler
}

describe('NetworkPolicyReconciler Codex boundary', () => {
  it('does not derive Codex scope or proxy egress - that belongs to HostReconciler', () => {
    const source = readFileSync(join(__dirname, 'networkPolicyReconciler.ts'), 'utf8')
    expect(source).not.toContain('llm:codex:execute')
    expect(source).not.toContain('codex-llm-proxy')
    expect(source).not.toContain('codex-proxy-egress')
  })
})

describe('NetworkPolicyReconciler', () => {
  let mockApi: ReturnType<typeof makeMockNetworkingApi>
  let mockCustomApi: ReturnType<typeof makeMockCustomApi>
  let reconciler: NetworkPolicyReconciler

  beforeEach(() => {
    vi.useRealTimers()
    config.netPolOrphanDeleteCap = 10
    config.netPolOrphanDeleteCapPercent = 20
    mockApi = makeMockNetworkingApi()
    mockCustomApi = makeMockCustomApi()
    reconciler = makeReconciler(mockApi, undefined, mockCustomApi)
    vi.clearAllMocks()
    resolve4Mock.mockResolvedValue(rec('1.2.3.4', '5.6.7.8'))
  })

  it('compares Context desired revisions canonically and fences identity changes', () => {
    const expected: ContextCRD = {
      name: 'default',
      namespace: 'mcp-server',
      uid: 'context-uid',
      generation: 7,
      spec: {
        contextId: 'default',
        mcpServers: ['alpha'],
        sharedFileSystems: [{ name: 'workspace', mountPath: '/workspace' }],
      },
    }
    const reordered: ContextCRD = {
      namespace: 'mcp-server',
      name: 'default',
      generation: 7,
      uid: 'context-uid',
      spec: {
        sharedFileSystems: [{ mountPath: '/workspace', name: 'workspace' }],
        mcpServers: ['alpha'],
        contextId: 'default',
      },
    }

    expect(sameContextDesiredRevision(expected, reordered)).toBe(true)
    expect(sameContextDesiredRevision(expected, { ...reordered, uid: 'replacement-uid' })).toBe(
      false
    )
    expect(sameContextDesiredRevision(expected, { ...reordered, generation: 8 })).toBe(false)
  })

  describe('sameContextDesiredRevision mutation table (content identity)', () => {
    const companionServer: McpServerCRD = {
      name: 'alpha',
      namespace: 'mcp-server',
      spec: {
        contextRef: 'default',
        image: 'clerum/alpha:test',
        transport: { type: 'streamableHttp', port: 3000 },
        egressBindings: [{ cidr: '1.2.3.4/32', port: 443, protocol: 'TCP' }],
      },
    }
    const base: ContextCRD = {
      name: 'default',
      namespace: 'mcp-server',
      uid: 'context-uid',
      generation: 7,
      spec: {
        contextId: 'default',
        mcpServers: ['alpha'],
        sharedFileSystems: [{ name: 'workspace', mountPath: '/workspace' }],
      },
    }

    function stableJson(value: unknown): string {
      if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`
      if (value && typeof value === 'object') {
        const record = value as Record<string, unknown>
        return `{${Object.keys(record)
          .sort()
          .map(key => `${JSON.stringify(key)}:${stableJson(record[key])}`)
          .join(',')}}`
      }
      return JSON.stringify(value) ?? 'undefined'
    }

    function renderContextAllow(
      context: ContextCRD,
      server: McpServerCRD = companionServer
    ): string {
      return stableJson((reconciler as any).buildContextAllowPolicies(context, server))
    }

    function renderExactHostEgress(server: McpServerCRD): string {
      const binding = server.spec.egressBindings?.[0]
      if (!binding?.cidr) return 'none'
      return stableJson(
        (reconciler as any).buildExactHostEgressPolicy(server, 'exact-host-egress', binding, [
          binding.cidr,
        ])
      )
    }

    it('G8: ContextCRD compared fields have no escape hatch besides status', () => {
      type ContextCompared = 'name' | 'namespace' | 'uid' | 'generation' | 'spec'
      type ContextEscapes = Exclude<keyof ContextCRD, ContextCompared | 'status'>
      expectTypeOf<ContextEscapes>().toEqualTypeOf<never>()
    })

    it('C1: spec.contextId change fails the comparator and changes the rendered allow policies', () => {
      const mutated: ContextCRD = {
        ...base,
        spec: { ...base.spec, contextId: 'other' },
      }
      expect(sameContextDesiredRevision(base, mutated)).toBe(false)
      expect(renderContextAllow(mutated)).not.toBe(renderContextAllow(base))
    })

    it('C2: name change fails the comparator and changes the rendered allow policies', () => {
      const mutated: ContextCRD = { ...base, name: 'other-context' }
      expect(sameContextDesiredRevision(base, mutated)).toBe(false)
      expect(renderContextAllow(mutated)).not.toBe(renderContextAllow(base))
    })

    it.each([
      ['add', ['alpha', 'beta']],
      ['remove', []],
      ['rename', ['renamed']],
    ] as const)('C3: spec.mcpServers %s fails the comparator', (_label, mcpServers) => {
      const mutated: ContextCRD = {
        ...base,
        spec: { ...base.spec, mcpServers: [...mcpServers] },
      }
      expect(sameContextDesiredRevision(base, mutated)).toBe(false)
    })

    it('C4: status-only change matches and keeps the rendered allow policies identical', () => {
      const mutated: ContextCRD = {
        ...base,
        status: {
          sharedFileSystems: [{ name: 'workspace', mountPath: '/workspace', phase: 'Mounted' }],
        },
      }
      expect(sameContextDesiredRevision(base, mutated)).toBe(true)
      expect(renderContextAllow(mutated)).toBe(renderContextAllow(base))
    })

    it('C5: spec key reorder matches and keeps the rendered allow policies identical', () => {
      const mutated: ContextCRD = {
        name: base.name,
        namespace: base.namespace,
        uid: base.uid,
        generation: base.generation,
        spec: {
          sharedFileSystems: [{ mountPath: '/workspace', name: 'workspace' }],
          mcpServers: ['alpha'],
          contextId: 'default',
        },
      }
      expect(sameContextDesiredRevision(base, mutated)).toBe(true)
      expect(renderContextAllow(mutated)).toBe(renderContextAllow(base))
    })

    it('C6: undefined-valued spec key matches and keeps the rendered allow policies identical', () => {
      const mutated: ContextCRD = {
        ...base,
        spec: { ...base.spec, description: undefined },
      }
      expect(sameContextDesiredRevision(base, mutated)).toBe(true)
      expect(renderContextAllow(mutated)).toBe(renderContextAllow(base))
    })

    it('S1: server name change changes the rendered allow policies', () => {
      const mutated: McpServerCRD = { ...companionServer, name: 'beta' }
      expect(renderContextAllow(base, mutated)).not.toBe(renderContextAllow(base))
    })

    it('S3: spec.transport.port change changes the rendered allow policies', () => {
      const mutated: McpServerCRD = {
        ...companionServer,
        spec: {
          ...companionServer.spec,
          transport: { ...companionServer.spec.transport, port: 4000 },
        },
      }
      expect(renderContextAllow(base, mutated)).not.toBe(renderContextAllow(base))
    })

    it('S4: egressBindings change changes the rendered exact-host egress policy', () => {
      const mutated: McpServerCRD = {
        ...companionServer,
        spec: {
          ...companionServer.spec,
          egressBindings: [{ cidr: '8.8.8.8/32', port: 443, protocol: 'TCP' }],
        },
      }
      expect(renderExactHostEgress(mutated)).not.toBe(renderExactHostEgress(companionServer))
    })
  })

  it('records the authoritative safety-pass inventory, completed revocations, and duration', async () => {
    mockApi.listNamespacedNetworkPolicy
      .mockResolvedValueOnce({
        items: [
          {
            metadata: {
              name: 'orphan-context',
              labels: { 'clerum.io/context': 'missing-context' },
            },
          },
        ],
      })
      .mockResolvedValueOnce({
        items: [
          {
            metadata: {
              name: 'orphan-host-egress',
              labels: { 'clerum.io/context': 'missing-context' },
            },
          },
        ],
      })
      .mockResolvedValueOnce({
        items: [
          {
            metadata: {
              name: 'orphan-rpc-egress',
              labels: { 'clerum.io/context': 'missing-context' },
            },
          },
        ],
      })
      .mockResolvedValueOnce({
        items: [
          {
            metadata: {
              name: 'orphan-external-egress',
              labels: { 'clerum.io/mcpserver': 'missing-server' },
            },
          },
        ],
      })
    const complete = vi.fn()

    await reconciler.fullReconcile([], [], {
      ensureDefaults: false,
      onAuthoritativeRevocationComplete: complete,
    })

    expect(complete).toHaveBeenCalledOnce()
    expect(networkPolicySafetyPassPoliciesTotal.inc).toHaveBeenCalledWith(
      { operation: 'listed' },
      4
    )
    expect(networkPolicySafetyPassPoliciesTotal.inc).toHaveBeenCalledWith(
      { operation: 'revoked' },
      4
    )
    expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledWith(
      { outcome: 'completed' },
      expect.any(Number)
    )
    expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledTimes(1)
  })

  describe('public egress blocklist parity', () => {
    it('keeps the HCC and WRC IPv4 exclusion lists in sync', () => {
      const wrcFactory = readFileSync(
        join(process.cwd(), '..', 'workflow-recipes', 'src', 'workflow', 'networkPolicyFactory.ts'),
        'utf8'
      )
      const match = wrcFactory.match(
        /export const PUBLIC_HTTP_EGRESS_EXCEPT_CIDRS = \[([\s\S]*?)\]/
      )
      expect(match).toBeTruthy()
      const wrcCidrs = [...match![1].matchAll(/'([^']+)'/g)].map(item => item[1])

      expect([...PUBLIC_EGRESS_EXCEPT_CIDRS].sort()).toEqual([...wrcCidrs].sort())
    })
  })

  // ─── L0: Default Deny ──────────────────────────────────────────────

  describe('L0 — ensureDefaultDeny', () => {
    it('creates deny-all policies in every runtime namespace', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const denyPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.filter(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { labels: Record<string, string> } } }
          return arg.body.metadata.labels['clerum.io/policy-type'] === 'default-deny'
        }
      )
      expect(denyPolicies.length).toBe(4) // mcp-server, mcp-host, sandbox-recipes, rpc-proxy
    })

    it('includes both Ingress and Egress in policyTypes', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const denyPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls.find(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { name: string } } }
          return arg.body.metadata.name.startsWith('deny-all-')
        }
      )
      expect(denyPolicy).toBeDefined()
      const spec = (denyPolicy![0] as { body: { spec: { policyTypes: string[] } } }).body.spec
      expect(spec.policyTypes).toEqual(['Ingress', 'Egress'])
    })

    it('uses empty podSelector (selects all pods)', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const denyPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls.find(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { name: string } } }
          return arg.body.metadata.name.startsWith('deny-all-')
        }
      )
      const spec = (denyPolicy![0] as { body: { spec: { podSelector: object } } }).body.spec
      expect(spec.podSelector).toEqual({})
    })
  })

  // ─── L1: Infrastructure Policies ───────────────────────────────────

  describe('L1 — ensureInfrastructurePolicies', () => {
    it.each([
      ['deny-all-mcp-server', 'default-deny'],
      ['allow-dns-egress-mcp-server', 'infrastructure'],
      ['allow-hcc-api-egress-mcp-server', 'infrastructure'],
      ['allow-k8s-api-egress-mcp-server', 'infrastructure'],
    ])(
      'refuses to adopt a foreign policy that collides with %s',
      async (targetName, policyType) => {
        mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name, namespace }) => {
          if (name !== targetName) throw { code: 404 }
          return {
            metadata: {
              name,
              namespace,
              uid: 'foreign-baseline-uid',
              resourceVersion: '7',
              labels: {
                'clerum.io/managed-by': 'foreign-controller',
                'clerum.io/policy-type': policyType,
              },
            },
          }
        })

        await expect(reconciler.ensureDefaultPolicies()).rejects.toThrow(/ownership/i)
        expect(mockApi.readNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({ name: targetName })
        )
        expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalledWith(
          expect.objectContaining({ name: targetName })
        )
      }
    )

    it('creates DNS egress policies in every runtime namespace', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const dnsPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.filter(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { name: string } } }
          return arg.body.metadata.name.startsWith('allow-dns-egress-')
        }
      )
      expect(dnsPolicies.length).toBe(4)
    })

    it('DNS egress targets kube-system on port 53 UDP+TCP', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const dnsPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls.find((call: unknown[]) => {
        const arg = call[0] as { body: { metadata: { name: string } } }
        return arg.body.metadata.name === 'allow-dns-egress-mcp-server'
      })
      expect(dnsPolicy).toBeDefined()
      const spec = (
        dnsPolicy![0] as {
          body: { spec: { egress: Array<{ ports: Array<{ port: number; protocol: string }> }> } }
        }
      ).body.spec
      const ports = spec.egress[0].ports
      expect(ports).toContainEqual({ port: 53, protocol: 'UDP' })
      expect(ports).toContainEqual({ port: 53, protocol: 'TCP' })
    })

    it('creates HCC API egress policies', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const hccPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.filter(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { name: string } } }
          return arg.body.metadata.name.startsWith('allow-hcc-api-egress-')
        }
      )
      expect(hccPolicies.length).toBe(4)
      for (const call of hccPolicies) {
        const policy = (
          call[0] as {
            body: {
              spec: {
                egress: Array<{
                  to: Array<{
                    namespaceSelector: { matchLabels: Record<string, string> }
                    podSelector: { matchLabels: Record<string, string> }
                  }>
                }>
              }
            }
          }
        ).body
        expect(policy.spec.egress[0].to[0]).toEqual({
          namespaceSelector: {
            matchLabels: { 'kubernetes.io/metadata.name': 'control-plane' },
          },
          podSelector: {
            matchLabels: { app: 'host-context-controller-api-gateway' },
          },
        })
      }
    })

    it('creates K8s API egress policies', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const k8sPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.filter(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { name: string } } }
          return arg.body.metadata.name.startsWith('allow-k8s-api-egress-')
        }
      )
      expect(k8sPolicies.length).toBe(4)
    })

    it('scopes HCC API egress to the platform pods that need it', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const policyByName = new Map(
        mockApi.createNamespacedNetworkPolicy.mock.calls.map((call: unknown[]) => {
          const arg = call[0] as {
            body: { metadata: { name: string }; spec: { podSelector: unknown } }
          }
          return [arg.body.metadata.name, arg.body.spec.podSelector]
        })
      )

      expect(policyByName.get('allow-hcc-api-egress-mcp-server')).toEqual({
        matchLabels: { app: 'mcp-proxy' },
      })
      expect(policyByName.get('allow-hcc-api-egress-sandbox-recipes')).toEqual({
        matchLabels: { 'clerum.io/component': 'workflow-mcp-host' },
      })
      expect(policyByName.get('allow-hcc-api-egress-rpc-proxy')).toEqual({
        matchLabels: { app: 'rpc-proxy' },
      })
    })

    it('routes HCC API egress policies to the control-plane gateway', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const hccPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map((call: unknown[]) => {
          const arg = call[0] as { body: k8s.V1NetworkPolicy }
          return arg.body
        })
        .filter(policy => policy.metadata?.name?.startsWith('allow-hcc-api-egress-'))

      expect(hccPolicies).toHaveLength(4)
      for (const policy of hccPolicies) {
        const target = policy.spec!.egress![0].to![0]
        expect(target.namespaceSelector!.matchLabels!['kubernetes.io/metadata.name']).toBe(
          'control-plane'
        )
        expect(target.podSelector!.matchLabels!.app).toBe('host-context-controller-api-gateway')
      }
    })

    it('does not grant Kubernetes API egress to runtime workload namespaces by default', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const policyByName = new Map(
        mockApi.createNamespacedNetworkPolicy.mock.calls.map((call: unknown[]) => {
          const arg = call[0] as {
            body: { metadata: { name: string }; spec: { podSelector: unknown } }
          }
          return [arg.body.metadata.name, arg.body.spec.podSelector]
        })
      )

      expect(policyByName.get('allow-k8s-api-egress-mcp-server')).toEqual({
        matchLabels: { 'clerum.io/k8s-api-egress': 'true' },
      })
      expect(policyByName.get('allow-k8s-api-egress-sandbox-recipes')).toEqual({
        matchLabels: { 'clerum.io/k8s-api-egress': 'true' },
      })
      expect(policyByName.get('allow-k8s-api-egress-rpc-proxy')).toEqual({
        matchLabels: { 'clerum.io/k8s-api-egress': 'true' },
      })
    })

    it('infrastructure policies have correct policy-type label', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const infraPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.filter(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { labels: Record<string, string> } } }
          return arg.body.metadata.labels['clerum.io/policy-type'] === 'infrastructure'
        }
      )
      // 4 namespaces × 3 infra policies = 12
      expect(infraPolicies.length).toBe(12)
    })

    it('removes legacy static policies now replaced by generated scoped policies', async () => {
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name, namespace }) => {
        if (
          !['allow-desktop-egress-rpc-proxy', 'allow-rpc-proxy-to-managed-mcp-servers'].includes(
            name
          )
        )
          throw { code: 404 }
        return {
          metadata: {
            name,
            namespace,
            uid: `${name}-uid`,
            resourceVersion: '7',
            labels: {
              'clerum.io/managed-by': 'host-context-controller',
            },
          },
        }
      })

      await reconciler.ensureDefaultPolicies()

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith({
        namespace: 'rpc-proxy',
        name: 'allow-desktop-egress-rpc-proxy',
        body: {
          preconditions: {
            uid: 'allow-desktop-egress-rpc-proxy-uid',
            resourceVersion: '7',
          },
        },
      })
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith({
        namespace: 'mcp-server',
        name: 'allow-rpc-proxy-to-managed-mcp-servers',
        body: {
          preconditions: {
            uid: 'allow-rpc-proxy-to-managed-mcp-servers-uid',
            resourceVersion: '7',
          },
        },
      })
    })

    it.each([
      ['rpc-proxy', 'allow-desktop-egress-rpc-proxy'],
      ['mcp-server', 'allow-rpc-proxy-to-managed-mcp-servers'],
    ])('refuses to delete a foreign legacy policy %s/%s', async (targetNamespace, targetName) => {
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name, namespace }) => {
        if (name !== targetName) {
          throw Object.assign(new Error('not found'), { code: 404 })
        }
        return {
          metadata: {
            name,
            namespace,
            uid: 'foreign-legacy-uid',
            resourceVersion: '7',
            labels: {
              'clerum.io/managed-by': 'foreign-controller',
            },
          },
        }
      })

      await expect(reconciler.ensureDefaultPolicies()).rejects.toThrow(/ownership/i)
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalledWith(
        expect.objectContaining({ namespace: targetNamespace, name: targetName })
      )
    })

    it.each([
      ['rpc-proxy', 'allow-desktop-egress-rpc-proxy'],
      ['mcp-server', 'allow-rpc-proxy-to-managed-mcp-servers'],
    ])(
      'propagates an identity conflict deleting legacy policy %s/%s',
      async (targetNamespace, targetName) => {
        mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name, namespace }) => {
          if (name !== targetName) {
            throw Object.assign(new Error('not found'), { code: 404 })
          }
          return {
            metadata: {
              name,
              namespace,
              uid: 'legacy-policy-uid',
              resourceVersion: '7',
              labels: {
                'clerum.io/managed-by': 'host-context-controller',
              },
            },
          }
        })
        const conflict = Object.assign(new Error('identity changed'), { code: 409 })
        mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async ({ name, namespace }) => {
          if (name === targetName && namespace === targetNamespace) throw conflict
          return {}
        })

        await expect(reconciler.ensureDefaultPolicies()).rejects.toBe(conflict)
      }
    )
  })

  // ─── L1: Allow API ─────────────────────────────────────────────────

  describe('L1 — ensureAllowContextMapperApi', () => {
    it('updates the existing HCC-owned allow-api policy without requiring Context owner labels', async () => {
      mockApi.createNamespacedNetworkPolicy.mockImplementation(
        async ({ body }: { body: k8s.V1NetworkPolicy }) => {
          if (body.metadata?.name === 'allow-host-context-controller-api') {
            throw Object.assign(new Error('already exists'), { code: 409 })
          }
          return {}
        }
      )
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name, namespace }) => {
        if (name !== 'allow-host-context-controller-api') throw { code: 404 }
        return {
          metadata: {
            name,
            namespace,
            uid: 'existing-default-policy-uid',
            resourceVersion: '7',
            labels: {
              'clerum.io/managed-by': 'host-context-controller',
              'clerum.io/policy-type': 'allow-api',
            },
          },
        }
      })

      await expect(reconciler.ensureDefaultPolicies()).resolves.toBeUndefined()
      expect(mockApi.replaceNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'allow-host-context-controller-api',
          namespace: 'mcp-server',
        })
      )
    })

    it('refuses to adopt a foreign policy that collides with the allow-api policy name', async () => {
      mockApi.createNamespacedNetworkPolicy.mockImplementation(
        async ({ body }: { body: k8s.V1NetworkPolicy }) => {
          if (body.metadata?.name === 'allow-host-context-controller-api') {
            throw Object.assign(new Error('already exists'), { code: 409 })
          }
          return {}
        }
      )
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name }) => {
        if (name !== 'allow-host-context-controller-api') throw { code: 404 }
        return {
          metadata: {
            name: 'allow-host-context-controller-api',
            namespace: 'mcp-server',
            uid: 'foreign-default-policy-uid',
            resourceVersion: '7',
            labels: {
              'clerum.io/managed-by': 'foreign-controller',
              'clerum.io/policy-type': 'allow-api',
            },
          },
        }
      })

      await expect(reconciler.ensureDefaultPolicies()).rejects.toThrow(/ownership/i)
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('revalidates allow-api ownership after a replace conflict', async () => {
      mockApi.createNamespacedNetworkPolicy.mockImplementation(
        async ({ body }: { body: k8s.V1NetworkPolicy }) => {
          if (body.metadata?.name === 'allow-host-context-controller-api') {
            throw Object.assign(new Error('already exists'), { code: 409 })
          }
          return {}
        }
      )
      const readAllowApi = vi
        .fn()
        .mockResolvedValueOnce({
          metadata: {
            name: 'allow-host-context-controller-api',
            namespace: 'mcp-server',
            uid: 'owned-uid',
            resourceVersion: '7',
            labels: {
              'clerum.io/managed-by': 'host-context-controller',
              'clerum.io/policy-type': 'allow-api',
            },
          },
        })
        .mockResolvedValueOnce({
          metadata: {
            name: 'allow-host-context-controller-api',
            namespace: 'mcp-server',
            uid: 'foreign-uid',
            resourceVersion: '8',
            labels: {
              'clerum.io/managed-by': 'foreign-controller',
              'clerum.io/policy-type': 'allow-api',
            },
          },
        })
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ name }) => {
        if (name !== 'allow-host-context-controller-api') throw { code: 404 }
        return readAllowApi()
      })
      mockApi.replaceNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('conflict'), { code: 409 })
      )

      await expect(reconciler.ensureDefaultPolicies()).rejects.toThrow(/ownership/i)
      expect(mockApi.replaceNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
    })

    it('creates allow-api ingress policy using _from (K8s client convention)', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      await reconciler.ensureDefaultPolicies()

      const apiPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls.find((call: unknown[]) => {
        const arg = call[0] as { body: { metadata: { name: string } } }
        return arg.body.metadata.name === 'allow-host-context-controller-api'
      })
      expect(apiPolicy).toBeDefined()
      const spec = (apiPolicy![0] as { body: { spec: Record<string, unknown> } }).body.spec
      expect(spec.policyTypes).toEqual(['Ingress'])
      // _from is correct — K8s client ObjectSerializer maps _from → from
      const ingress = spec.ingress as Array<{ _from?: unknown[] }>
      expect(ingress[0]._from).toBeDefined()
    })
  })

  // ─── L2: Context-Based Policies ────────────────────────────────────

  describe('L2 — reconcileContext', () => {
    it('refuses to adopt a foreign policy that collides with a live Context policy name', async () => {
      const server: McpServerCRD = {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const rec = makeReconciler(mockApi, new Map([[server.name, server]]))
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: [server.name] },
      }
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValueOnce({
        metadata: {
          name: 'ctx-dev-mongo',
          namespace: 'mcp-server',
          uid: 'foreign-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'foreign-controller',
            'clerum.io/policy-type': 'context-allow',
            'clerum.io/context': 'dev',
            'clerum.io/mcpserver': 'mongo',
          },
        },
      })

      await expect(rec.reconcileContext(context, { isCurrent: () => true })).rejects.toThrow(
        /ownership/i
      )
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('refuses to replace an HCC Context policy owned by a different Context/server pair', async () => {
      const server: McpServerCRD = {
        name: 'b-c',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'a',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const rec = makeReconciler(mockApi, new Map([[server.name, server]]))
      const context: ContextCRD = {
        name: 'a',
        namespace: 'mcp-server',
        spec: { contextId: 'a', mcpServers: ['b-c'] },
      }
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValueOnce({
        metadata: {
          name: 'ctx-a-b-c',
          namespace: 'mcp-server',
          uid: 'other-hcc-owner-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'host-context-controller',
            'clerum.io/policy-type': 'context-allow',
            'clerum.io/context': 'a-b',
            'clerum.io/mcpserver': 'c',
          },
        },
      })

      await expect(rec.reconcileContext(context, { isCurrent: () => true })).rejects.toThrow(
        /ownership/i
      )
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('creates context-allow ingress policy per server in mcp-server namespace', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', url: 'http://mongo:3000', port: 3000 },
        },
      })

      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['mongo'] },
      }

      await rec.reconcileContext(context, { isCurrent: () => true })

      // First call: ingress in mcp-server namespace
      const ingressCall = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as {
        body: {
          metadata: { labels: Record<string, string>; namespace: string }
          spec: {
            policyTypes: string[]
            ingress: Array<{
              _from: Array<{
                namespaceSelector: { matchLabels: Record<string, string> }
                podSelector: { matchLabels: Record<string, string> }
              }>
            }>
          }
        }
      }
      expect(ingressCall.body.metadata.labels['clerum.io/policy-type']).toBe('context-allow')
      expect(ingressCall.body.spec.policyTypes).toEqual(['Ingress'])
      expect(ingressCall.body.spec.ingress[0]._from).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            namespaceSelector: { matchLabels: { 'kubernetes.io/metadata.name': 'mcp-host' } },
            podSelector: {
              matchLabels: {
                'clerum.io/managed-by': 'host-context-controller',
                'clerum.io/context': 'dev',
              },
            },
          }),
          expect.objectContaining({
            namespaceSelector: { matchLabels: { 'kubernetes.io/metadata.name': 'rpc-proxy' } },
            podSelector: { matchLabels: { app: 'rpc-proxy' } },
          }),
          expect.objectContaining({
            namespaceSelector: { matchLabels: { 'kubernetes.io/metadata.name': 'mcp-server' } },
            podSelector: { matchLabels: { app: 'mcp-proxy' } },
          }),
        ])
      )
    })

    it('retains the ingress policy it just replaced when the authoritative server port changes', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const oldServer: McpServerCRD = {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const cache = new Map([[oldServer.name, oldServer]])
      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: [oldServer.name] },
      }

      await rec.reconcileContext(context, { isCurrent: () => true })
      const livePolicies = new Map(
        mockApi.createNamespacedNetworkPolicy.mock.calls.map(call => {
          const policy = (call[0] as { body: k8s.V1NetworkPolicy }).body
          return [`${policy.metadata?.namespace}/${policy.metadata?.name}`, policy]
        })
      )

      vi.clearAllMocks()
      cache.set(oldServer.name, {
        ...oldServer,
        generation: 2,
        spec: {
          ...oldServer.spec,
          transport: { type: 'streamableHttp', port: 4000 },
        },
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace }: { namespace?: string }) => ({
          items: [...livePolicies.values()].filter(
            policy => policy.metadata?.namespace === namespace
          ),
        })
      )
      mockApi.createNamespacedNetworkPolicy.mockImplementation(async ({ namespace, body }) => {
        livePolicies.set(`${namespace}/${body.metadata?.name}`, body)
        return {}
      })
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, name, body }) => {
          livePolicies.set(`${namespace}/${name}`, body)
          return {}
        }
      )
      // The delete mock MUST remove from livePolicies, or the port-4000
      // assertion below survives a spurious deletion and the test passes with
      // the bug reinjected (R3-H7).
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async ({ namespace, name }) => {
        livePolicies.delete(`${namespace}/${name}`)
        return {}
      })

      await rec.reconcileContext(context, { isCurrent: () => true })

      // Filter the real calls by name+namespace: the production delete always
      // carries `preconditions`, so `not.toHaveBeenCalledWith({name,namespace})`
      // never matched any call and was vacuously true (R3-H7).
      const deletedCtxDevMongo = mockApi.deleteNamespacedNetworkPolicy.mock.calls.some(
        call =>
          (call[0] as { name?: string; namespace?: string })?.name === 'ctx-dev-mongo' &&
          (call[0] as { name?: string; namespace?: string })?.namespace === 'mcp-server'
      )
      expect(deletedCtxDevMongo).toBe(false)
      const ingress = livePolicies.get('mcp-server/ctx-dev-mongo')
      expect(ingress?.spec?.ingress?.[0]?.ports).toEqual([expect.objectContaining({ port: 4000 })])
    })

    it('stops remaining policy mutations after its combined authority lease is retired', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      })
      const firstCreateStarted = deferred()
      const releaseFirstCreate = deferred()
      mockApi.createNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        firstCreateStarted.resolve(undefined)
        await releaseFirstCreate.promise
        return {}
      })
      const rec = makeReconciler(mockApi, cache)
      let contextGeneration = 4
      let serverGeneration = 8
      const capturedContextGeneration = contextGeneration
      const capturedServerGeneration = serverGeneration
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['mongo'] },
      }

      const reconcile = rec.reconcileContext(context, {
        isCurrent: () =>
          contextGeneration === capturedContextGeneration &&
          serverGeneration === capturedServerGeneration,
      })
      await firstCreateStarted.promise

      contextGeneration = 6
      serverGeneration = 10
      releaseFirstCreate.resolve(undefined)
      await reconcile

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('does not mutate a Context policy from a mixed McpServer cache revision', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        uid: 'mongo-uid',
        generation: 1,
        spec: {
          contextRef: 'dev',
          image: 'mongo:old',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      })
      const firstCreateStarted = deferred()
      const releaseFirstCreate = deferred()
      mockApi.createNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        firstCreateStarted.resolve(undefined)
        await releaseFirstCreate.promise
        return {}
      })
      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['mongo'] },
      }

      const reconcile = rec.reconcileContext(context, { isCurrent: () => true })
      await firstCreateStarted.promise
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        uid: 'mongo-uid',
        generation: 2,
        spec: {
          contextRef: 'dev',
          image: 'mongo:new',
          transport: { type: 'streamableHttp', port: 4000 },
        },
      })
      releaseFirstCreate.resolve(undefined)
      await reconcile

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('continues a Context policy pass across a status-only McpServer replacement', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      const selected: McpServerCRD = {
        name: 'mongo',
        namespace: 'mcp-server',
        uid: 'mongo-uid',
        generation: 1,
        spec: {
          contextRef: 'dev',
          image: 'mongo:stable',
          transport: { type: 'streamableHttp', port: 3000 },
        },
        status: { conditions: [{ type: 'Ready', status: 'False' }] },
      }
      cache.set(selected.name, selected)
      const firstCreateStarted = deferred()
      const releaseFirstCreate = deferred()
      mockApi.createNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        firstCreateStarted.resolve(undefined)
        await releaseFirstCreate.promise
        return {}
      })
      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['mongo'] },
      }

      const reconcile = rec.reconcileContext(context, { isCurrent: () => true })
      await firstCreateStarted.promise
      cache.set(selected.name, {
        ...selected,
        status: { conditions: [{ type: 'Ready', status: 'True' }] },
      })
      releaseFirstCreate.resolve(undefined)
      await reconcile

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(3)
    })

    it('does not adopt an McpServer that appeared after Context selection', async () => {
      const cache = new Map<string, McpServerCRD>()
      const inventoryListed = deferred()
      const releaseInventory = deferred<{ items: k8s.V1NetworkPolicy[] }>()
      mockApi.listNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        inventoryListed.resolve(undefined)
        return releaseInventory.promise
      })
      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['late-server'] },
      }

      const reconcile = rec.reconcileContext(context, { isCurrent: () => true })
      await inventoryListed.promise
      cache.set('late-server', {
        name: 'late-server',
        namespace: 'mcp-server',
        uid: 'late-server-uid',
        generation: 1,
        spec: {
          contextRef: 'dev',
          image: 'late-server:new',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      })
      releaseInventory.resolve({ items: [] })
      await reconcile

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('creates L2 egress counterpart in mcp-host namespace (bidirectional)', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', url: 'http://mongo:3000', port: 3000 },
        },
      })

      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['mongo'] },
      }

      await rec.reconcileContext(context, { isCurrent: () => true })

      // Three calls: L2 ingress (mcp-server), L2 egress (mcp-host), L2 rpc-proxy egress (rpc-proxy)
      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(3)
      const egressCall = mockApi.createNamespacedNetworkPolicy.mock.calls[1][0] as {
        namespace: string
        body: {
          metadata: { name: string; namespace: string; labels: Record<string, string> }
          spec: {
            podSelector: { matchLabels: Record<string, string> }
            policyTypes: string[]
            egress: Array<{
              to: Array<{
                namespaceSelector: { matchLabels: Record<string, string> }
                podSelector: { matchLabels: Record<string, string> }
              }>
              ports: Array<{ port: number }>
            }>
          }
        }
      }
      expect(egressCall.namespace).toBe('mcp-host')
      expect(egressCall.body.metadata.name).toBe('ctx-dev-mongo-egress')
      expect(egressCall.body.metadata.labels['clerum.io/policy-type']).toBe('context-allow')
      expect(egressCall.body.spec.policyTypes).toEqual(['Egress'])
      expect(egressCall.body.spec.podSelector.matchLabels).toMatchObject({
        'clerum.io/managed-by': 'host-context-controller',
        'clerum.io/context': 'dev',
      })
      // Egress targets mcp-server namespace + specific server pod
      const egressRule = egressCall.body.spec.egress[0]
      expect(egressRule.to[0].namespaceSelector.matchLabels['kubernetes.io/metadata.name']).toBe(
        'mcp-server'
      )
      expect(egressRule.to[0].podSelector.matchLabels['clerum.io/mcpserver']).toBe('mongo')
      expect(egressRule.ports[0].port).toBe(3000)
    })

    it('scopes L2 mcp-host egress by Context CRD name, not namespace-wide selector', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'ctx-name',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', url: 'http://mongo:3000', port: 3000 },
        },
      })

      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'ctx-name',
        namespace: 'mcp-server',
        spec: { contextId: 'ctx-id', mcpServers: ['mongo'] },
      }

      await rec.reconcileContext(context, { isCurrent: () => true })

      const egressCall = mockApi.createNamespacedNetworkPolicy.mock.calls[1][0] as {
        body: {
          metadata: { labels: Record<string, string> }
          spec: { podSelector: { matchLabels: Record<string, string> } }
        }
      }
      expect(egressCall.body.metadata.labels['clerum.io/context']).toBe('ctx-id')
      expect(egressCall.body.spec.podSelector.matchLabels).toMatchObject({
        'clerum.io/managed-by': 'host-context-controller',
        'clerum.io/context': 'ctx-name',
      })
    })

    it('creates L2 rpc-proxy egress to one MCP server instead of relying on static namespace egress', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const cache = new Map<string, McpServerCRD>()
      cache.set('mongo', {
        name: 'mongo',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mongo:latest',
          transport: { type: 'streamableHttp', url: 'http://mongo:3000', port: 3000 },
        },
      })

      const rec = makeReconciler(mockApi, cache)
      const context: ContextCRD = {
        name: 'dev',
        namespace: 'mcp-server',
        spec: { contextId: 'dev', mcpServers: ['mongo'] },
      }

      await rec.reconcileContext(context, { isCurrent: () => true })

      const rpcProxyEgressCall = mockApi.createNamespacedNetworkPolicy.mock.calls[2][0] as {
        namespace: string
        body: {
          metadata: { name: string; namespace: string; labels: Record<string, string> }
          spec: {
            podSelector: { matchLabels: Record<string, string> }
            policyTypes: string[]
            egress: Array<{
              to: Array<{
                namespaceSelector: { matchLabels: Record<string, string> }
                podSelector: { matchLabels: Record<string, string> }
              }>
              ports: Array<{ port: number }>
            }>
          }
        }
      }

      expect(rpcProxyEgressCall.namespace).toBe('rpc-proxy')
      expect(rpcProxyEgressCall.body.metadata.name).toBe('rpc-egress-dev-mongo')
      expect(rpcProxyEgressCall.body.metadata.labels['clerum.io/policy-type']).toBe(
        'rpc-proxy-egress'
      )
      expect(rpcProxyEgressCall.body.spec.podSelector.matchLabels).toEqual({
        app: 'rpc-proxy',
      })
      const egressRule = rpcProxyEgressCall.body.spec.egress[0]
      expect(egressRule.to[0].namespaceSelector.matchLabels['kubernetes.io/metadata.name']).toBe(
        'mcp-server'
      )
      expect(egressRule.to[0].podSelector.matchLabels['clerum.io/mcpserver']).toBe('mongo')
      expect(egressRule.ports[0].port).toBe(3000)
    })
  })

  // ─── L3: External Egress ───────────────────────────────────────────

  describe('L3 — reconcileExternalEgress', () => {
    it('removes a deterministic safety policy created after its desired-state fence is lost', async () => {
      const server: McpServerCRD = {
        name: 'race-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'race:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ cidr: '104.18.0.0/16', port: 443 }],
        },
      }
      const createStarted = deferred()
      const releaseCreate = deferred()
      let current = true
      mockApi.createNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        createStarted.resolve(undefined)
        await releaseCreate.promise
        return {
          metadata: {
            name: 'ext-egress-race-server-104-18-0-0-16-443',
            namespace: server.namespace,
            uid: 'created-race-policy',
            resourceVersion: '7',
          },
        }
      })

      const safety = (reconciler as any).reconcileExternalEgressSafety(
        server,
        [{ metadata: { name: 'ext-egress-race-server-stale' } }],
        () => current
      ) as Promise<boolean>

      await createStarted.promise
      current = false
      releaseCreate.resolve(undefined)

      expect(await safety).toBe(false)
      const created = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0].body
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: created.metadata.name,
          namespace: server.namespace,
          body: { preconditions: { uid: 'created-race-policy', resourceVersion: '7' } },
        })
      )
    })

    it('refuses to adopt a foreign policy that collides with an external-egress name', async () => {
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ cidr: '104.18.0.0/16', port: 443 }],
        },
      }
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValueOnce({
        metadata: {
          name: 'ext-egress-openai-mcp-104-18-0-0-16-443',
          namespace: 'mcp-server',
          uid: 'foreign-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'foreign-controller',
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': server.name,
          },
        },
      })

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/ownership/i)
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('refuses to replace an HCC external-egress policy owned by a different server', async () => {
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ cidr: '104.18.0.0/16', port: 443 }],
        },
      }
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValueOnce({
        metadata: {
          name: 'ext-egress-openai-mcp-104-18-0-0-16-443',
          namespace: 'mcp-server',
          uid: 'other-hcc-owner-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'host-context-controller',
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': 'different-server',
          },
        },
      })

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/ownership/i)
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('creates egress policy for CIDR binding', async () => {
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ cidr: '104.18.0.0/16', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      const body = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0].body
      expect(body.metadata.labels['clerum.io/policy-type']).toBe('external-egress')
      expect(body.metadata.labels['clerum.io/egress-class']).toBe('exact-host')
      expect(body.spec.egress[0].to[0].ipBlock.cidr).toBe('104.18.0.0/16')
      expect(body.spec.egress[0].ports[0].port).toBe(443)
    })

    it('resolves DNS to IPs and creates ipBlock policies', async () => {
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        generation: 7,
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      const body = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0].body
      // DNS resolved to 1.2.3.4 and 5.6.7.8 — two egress rules
      expect(body.spec.egress.length).toBe(2)
      expect(body.metadata.labels['clerum.io/egress-class']).toBe('exact-host')
      expect(body.spec.egress[0].to[0].ipBlock.cidr).toBe('1.2.3.4/32')
      expect(body.spec.egress[1].to[0].ipBlock.cidr).toBe('5.6.7.8/32')
      expect(mockCustomApi.patchNamespacedCustomObjectStatus).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'openai-mcp',
          body: expect.arrayContaining([
            expect.objectContaining({
              path: '/status/resolvedEgressIPs',
              value: [
                expect.objectContaining({
                  dns: 'api.openai.com',
                  ips: ['1.2.3.4', '5.6.7.8'],
                }),
              ],
            }),
            expect.objectContaining({
              path: '/status/conditions',
              value: expect.arrayContaining([
                expect.objectContaining({
                  type: 'ExternalEgressReady',
                  status: 'True',
                  reason: 'Reconciled',
                  observedGeneration: 7,
                }),
              ]),
            }),
          ]),
        })
      )
    })

    it('does not mutate policy or status after its McpServer authority lease is retired', async () => {
      const dnsStarted = deferred()
      const releaseDns = deferred<string[]>()
      vi.mocked(dns.resolve4).mockImplementationOnce(async () => {
        dnsStarted.resolve(undefined)
        return releaseDns.promise
      })
      let inventoryGeneration = 7
      const capturedGeneration = inventoryGeneration
      const server: McpServerCRD = {
        name: 'authority-race-mcp',
        namespace: 'mcp-server',
        uid: 'authority-race-uid',
        generation: 3,
        spec: {
          contextRef: 'dev',
          image: 'authority-race:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      const reconcile = reconciler.reconcileExternalEgress(server, {
        isCurrent: () => inventoryGeneration === capturedGeneration,
      })
      await dnsStarted.promise

      // Retire and recover to a different generation. The recovered cache is
      // authoritative again, but never for this stale pass.
      inventoryGeneration = 9
      releaseDns.resolve(['1.2.3.4'])
      await reconcile

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockCustomApi.patchNamespacedCustomObjectStatus).not.toHaveBeenCalled()
    })

    it('identity-fences the status patch and preserves unrelated conditions', async () => {
      mockCustomApi.getNamespacedCustomObjectStatus.mockResolvedValueOnce({
        metadata: {
          uid: 'openai-mcp-uid',
          generation: 7,
          resourceVersion: 'status-rv-17',
        },
        status: {
          conditions: [
            {
              type: 'RuntimeReady',
              status: 'True',
              reason: 'DeploymentAvailable',
              message: 'Runtime deployment is available',
              lastTransitionTime: '2026-07-29T00:00:00.000Z',
              observedGeneration: 7,
            },
          ],
        },
      })
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        uid: 'openai-mcp-uid',
        generation: 7,
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      const patch = mockCustomApi.patchNamespacedCustomObjectStatus.mock.calls[0][0].body
      expect(patch.slice(0, 3)).toEqual([
        { op: 'test', path: '/metadata/uid', value: 'openai-mcp-uid' },
        { op: 'test', path: '/metadata/generation', value: 7 },
        { op: 'test', path: '/metadata/resourceVersion', value: 'status-rv-17' },
      ])
      expect(patch).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            path: '/status/conditions',
            value: expect.arrayContaining([
              expect.objectContaining({
                type: 'RuntimeReady',
                reason: 'DeploymentAvailable',
              }),
              expect.objectContaining({
                type: 'ExternalEgressReady',
                status: 'True',
                observedGeneration: 7,
              }),
            ]),
          }),
        ])
      )
    })

    it('fences every identity field read from status when synthetic input omits them', async () => {
      mockCustomApi.getNamespacedCustomObjectStatus.mockResolvedValueOnce({
        metadata: {
          uid: 'openai-mcp-uid',
          generation: 7,
          resourceVersion: 'status-rv-17',
        },
        status: {},
      })
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      const patch = mockCustomApi.patchNamespacedCustomObjectStatus.mock.calls[0][0].body
      expect(patch.slice(0, 3)).toEqual([
        { op: 'test', path: '/metadata/uid', value: 'openai-mcp-uid' },
        { op: 'test', path: '/metadata/generation', value: 7 },
        { op: 'test', path: '/metadata/resourceVersion', value: 'status-rv-17' },
      ])
    })

    it.each([
      {
        name: 'UID',
        currentMetadata: {
          uid: 'replacement-uid',
          generation: 7,
          resourceVersion: 'status-rv-18',
        },
      },
      {
        name: 'generation',
        currentMetadata: {
          uid: 'openai-mcp-uid',
          generation: 8,
          resourceVersion: 'status-rv-18',
        },
      },
    ])(
      'rejects a stale $name before patching external egress status',
      async ({ currentMetadata }) => {
        mockCustomApi.getNamespacedCustomObjectStatus.mockResolvedValueOnce({
          metadata: currentMetadata,
          status: {},
        })
        const server: McpServerCRD = {
          name: 'openai-mcp',
          namespace: 'mcp-server',
          uid: 'openai-mcp-uid',
          generation: 7,
          spec: {
            contextRef: 'dev',
            image: 'openai:latest',
            transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
            egressBindings: [{ dns: 'api.openai.com', port: 443 }],
          },
        }

        await expect(
          reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
        ).rejects.toThrow(/stale McpServer/i)

        expect(mockCustomApi.patchNamespacedCustomObjectStatus).not.toHaveBeenCalled()
      }
    )

    it('fails closed when a same-generation status writer wins the resourceVersion race', async () => {
      const conflict = Object.assign(new Error('JSON patch test failed'), { code: 409 })
      mockCustomApi.getNamespacedCustomObjectStatus.mockResolvedValueOnce({
        metadata: {
          uid: 'openai-mcp-uid',
          generation: 7,
          resourceVersion: 'status-rv-17',
        },
        status: {
          conditions: [
            {
              type: 'RuntimeReady',
              status: 'True',
              reason: 'DeploymentAvailable',
              lastTransitionTime: '2026-07-29T00:00:00.000Z',
            },
          ],
        },
      })
      mockCustomApi.patchNamespacedCustomObjectStatus.mockRejectedValueOnce(conflict)
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        uid: 'openai-mcp-uid',
        generation: 7,
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toBe(conflict)

      expect(mockCustomApi.patchNamespacedCustomObjectStatus).toHaveBeenCalledWith(
        expect.objectContaining({
          body: expect.arrayContaining([
            {
              op: 'test',
              path: '/metadata/resourceVersion',
              value: 'status-rv-17',
            },
          ]),
        })
      )
    })

    it('fails closed when ExternalEgressReady status cannot be written', async () => {
      const statusError = new Error('status update denied')
      mockCustomApi.patchNamespacedCustomObjectStatus.mockRejectedValueOnce(statusError)
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        generation: 7,
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow('status update denied')

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockCustomApi.patchNamespacedCustomObjectStatus).toHaveBeenCalled()
    })

    it('fails closed when ExternalEgressReady status cannot be read', async () => {
      const statusError = new Error('status read denied')
      mockCustomApi.getNamespacedCustomObjectStatus.mockRejectedValueOnce(statusError)
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        generation: 7,
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow('status read denied')

      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockCustomApi.patchNamespacedCustomObjectStatus).not.toHaveBeenCalled()
    })

    it('creates explicit public-web egress with private and special-use ranges excluded', async () => {
      const server: McpServerCRD = {
        name: 'search-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'search:latest',
          transport: { type: 'streamableHttp', url: 'http://search:3000', port: 3000 },
          egressBindings: [{ egressClass: 'public-web' }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(dns.resolve4).not.toHaveBeenCalled()
      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      const body = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0].body
      expect(body.metadata.name).toBe('ext-egress-search-mcp-public-web')
      expect(body.metadata.labels['clerum.io/egress-class']).toBe('public-web')
      expect(body.spec.egress).toEqual([
        expect.objectContaining({
          to: [
            {
              ipBlock: expect.objectContaining({
                cidr: '0.0.0.0/0',
                except: expect.arrayContaining([
                  '10.0.0.0/8',
                  '169.254.0.0/16',
                  '192.168.0.0/16',
                  '198.51.100.0/24',
                ]),
              }),
            },
          ],
          ports: [
            { port: 443, protocol: 'TCP' },
            { port: 80, protocol: 'TCP' },
          ],
        }),
      ])
    })

    it('rejects public-web egressBindings that include exact destination fields', async () => {
      const server: McpServerCRD = {
        name: 'search-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'search:latest',
          transport: { type: 'streamableHttp', url: 'http://search:3000', port: 3000 },
          egressBindings: [{ egressClass: 'public-web', dns: 'api.example.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/public-web external egress bindings/)
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('rejects public-web egressBindings that include protocol', async () => {
      const server: McpServerCRD = {
        name: 'search-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'search:latest',
          transport: { type: 'streamableHttp', url: 'http://search:3000', port: 3000 },
          egressBindings: [{ egressClass: 'public-web', protocol: 'TCP' }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/public-web external egress bindings/)
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('does not patch status when only resolvedAt changes across DNS resyncs', async () => {
      mockCustomApi.getNamespacedCustomObjectStatus.mockResolvedValueOnce({
        status: {
          resolvedEgressIPs: [
            {
              dns: 'api.openai.com',
              ips: ['1.2.3.4', '5.6.7.8'],
              resolvedAt: '2026-05-15T00:00:00.000Z',
            },
          ],
          conditions: [
            {
              type: 'ExternalEgressReady',
              status: 'True',
              reason: 'Reconciled',
              message: 'External egress policies reconciled',
              lastTransitionTime: '2026-05-15T00:00:00.000Z',
            },
          ],
        },
      })
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(mockCustomApi.patchNamespacedCustomObjectStatus).not.toHaveBeenCalled()
    })

    it('does not patch status when conditions are unchanged but the apiserver returned condition keys alphabetized', async () => {
      // The Kubernetes apiserver canonicalizes CRD `.status` JSON with object
      // keys in ALPHABETICAL order, whereas the controller rebuilds condition
      // objects in code insertion order ({type,status,reason,message,...}). A
      // key-order-sensitive `JSON.stringify` equality check never matches across
      // this read->rebuild round-trip, so the no-op gate would re-patch status on
      // every reconcile — and each status write self-triggers the McpServer watch,
      // producing an unbounded reconcile loop that OOMs HCC (observed in prod on
      // mcp-evenfire-brain-remote). This reproduces the apiserver key order; the
      // gate must compare by content, not serialization order.
      mockCustomApi.getNamespacedCustomObjectStatus.mockResolvedValueOnce({
        status: {
          resolvedEgressIPs: [
            {
              dns: 'api.openai.com',
              ips: ['1.2.3.4', '5.6.7.8'],
              resolvedAt: '2026-05-15T00:00:00.000Z',
            },
          ],
          conditions: [
            {
              lastTransitionTime: '2026-05-15T00:00:00.000Z',
              message: 'External egress policies reconciled',
              reason: 'Reconciled',
              status: 'True',
              type: 'ExternalEgressReady',
            },
          ],
        },
      })
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(mockCustomApi.patchNamespacedCustomObjectStatus).not.toHaveBeenCalled()
    })

    it('writes resolved egress IP status in stable DNS order', async () => {
      resolve4Mock.mockImplementation(async (hostname: string) => {
        if (hostname === 'b.example.com') return rec('5.6.7.8')
        if (hostname === 'a.example.com') return rec('1.2.3.4')
        return []
      })
      const server: McpServerCRD = {
        name: 'ordered-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'ordered:latest',
          transport: { type: 'streamableHttp', url: 'http://ordered:3000', port: 3000 },
          egressBindings: [
            { dns: 'b.example.com', port: 443 },
            { dns: 'a.example.com', port: 443 },
          ],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      const patch = mockCustomApi.patchNamespacedCustomObjectStatus.mock.calls[0][0].body
      const resolvedPatch = patch.find(
        (operation: { path?: string }) => operation.path === '/status/resolvedEgressIPs'
      )
      expect(resolvedPatch.value.map((entry: { dns: string }) => entry.dns)).toEqual([
        'a.example.com',
        'b.example.com',
      ])
    })

    it('is a NO-OP on the next resync when DNS answers are unchanged (issue #299 F2 anti-churn)', async () => {
      const server: McpServerCRD = {
        name: 'noop-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'noop:latest',
          transport: { type: 'streamableHttp', url: 'http://noop:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }

      // First reconcile bootstraps and writes the external-egress policy.
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const created = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as {
        body: k8s.V1NetworkPolicy
      }
      const written = created.body
      expect(written.metadata?.annotations?.['clerum.io/egress-fqdn-state']).toBeTruthy()

      // The policy is now live with its accumulated state annotation. Feed it back
      // as the existing policy for the next resync tick.
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [
          {
            metadata: {
              name: written.metadata?.name,
              labels: written.metadata?.labels,
              annotations: written.metadata?.annotations,
            },
            spec: written.spec,
          },
        ],
      })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      // Second resync: same DNS answers → same IP set → must NOT rewrite the
      // policy (a timestamp-only refresh is a no-op). This is the churn the audit
      // caught: before the fix, RESOLVED_AT + renewed expiry forced a write here.
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it.each(['success', 'transient'] as const)(
      'uses a fresh GET before the %s DNS no-op decision and prevents a widened live policy',
      async mode => {
        const server: McpServerCRD = {
          name: `fresh-${mode}-mcp`,
          namespace: 'mcp-server',
          spec: {
            contextRef: 'dev',
            image: 'fresh:test',
            transport: { type: 'streamableHttp', url: 'http://fresh:3000', port: 3000 },
            egressBindings: [{ dns: 'api.example.com', port: 443 }],
          },
        }
        await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
        const written = (
          mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as {
            body: k8s.V1NetworkPolicy
          }
        ).body
        const listed = structuredClone(written)
        const freshWidened = structuredClone(written)
        freshWidened.metadata = {
          ...freshWidened.metadata,
          name: written.metadata!.name!,
          namespace: 'mcp-server',
          uid: `fresh-${mode}-uid`,
          resourceVersion: '22',
        }
        freshWidened.spec!.egress!.push({
          to: [{ ipBlock: { cidr: '8.8.8.8/32' } }],
          ports: [{ port: 443, protocol: 'TCP' }],
        })
        mockApi.listNamespacedNetworkPolicy.mockResolvedValue({ items: [listed] })
        mockApi.readNamespacedNetworkPolicy.mockResolvedValue(freshWidened)
        mockApi.createNamespacedNetworkPolicy.mockReset()
        mockApi.createNamespacedNetworkPolicy.mockRejectedValue({ code: 409 })
        mockApi.replaceNamespacedNetworkPolicy.mockClear()
        mockCustomApi.patchNamespacedCustomObjectStatus.mockClear()
        if (mode === 'transient') {
          resolve4Mock.mockRejectedValueOnce(
            Object.assign(new Error('queryA ESERVFAIL api.example.com'), { code: 'ESERVFAIL' })
          )
        }

        if (mode === 'transient') {
          await expect(
            reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
          ).rejects.toThrow(/Fail-static proof failed/)
          expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
            expect.objectContaining({ name: written.metadata!.name })
          )
          expect(
            JSON.stringify(mockCustomApi.patchNamespacedCustomObjectStatus.mock.calls)
          ).toContain('ExternalEgressReconcileFailed')
        } else {
          await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
          const replacement = mockApi.replaceNamespacedNetworkPolicy.mock.calls.at(-1)?.[0]
            ?.body as k8s.V1NetworkPolicy
          expect(replacement).toBeDefined()
        }
        expect(JSON.stringify(mockApi.replaceNamespacedNetworkPolicy.mock.calls)).not.toContain(
          '8.8.8.8'
        )
      }
    )

    it('WRITES on resync when the persisted window is AGING even though the IP set is unchanged (issue #299 M1 renewalDue wiring)', async () => {
      const server: McpServerCRD = {
        name: 'renew-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'renew:latest',
          transport: { type: 'streamableHttp', url: 'http://renew:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const written = (
        mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as { body: k8s.V1NetworkPolicy }
      ).body

      // Age the persisted window: rewrite each entry's expiresAt to just above now
      // (well within overlap/2) so renewalDue fires while the IP set is unchanged.
      const annotations = { ...(written.metadata?.annotations ?? {}) }
      const state = JSON.parse(annotations['clerum.io/egress-fqdn-state']) as Array<{
        expiresAt: number
      }>
      for (const e of state) e.expiresAt = Date.now() + 1000
      annotations['clerum.io/egress-fqdn-state'] = JSON.stringify(state)

      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [
          {
            metadata: {
              name: written.metadata?.name,
              labels: written.metadata?.labels,
              annotations,
            },
            spec: written.spec,
          },
        ],
      })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      // Same DNS → set unchanged (changed=false) but window aging → renewalDue=true
      // → the policy MUST be re-persisted (deleting `|| egressRenewalDue` breaks this,
      // reintroducing the M1 overlap-grace loss).
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const wrote =
        mockApi.createNamespacedNetworkPolicy.mock.calls.length +
        mockApi.replaceNamespacedNetworkPolicy.mock.calls.length
      expect(wrote).toBeGreaterThan(0)
    })

    it('WRITES through create-409 when renewalDue so the inner no-op gate cannot veto M1', async () => {
      const server: McpServerCRD = {
        name: 'renew-409-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'renew:latest',
          transport: { type: 'streamableHttp', url: 'http://renew:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const written = (
        mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as { body: k8s.V1NetworkPolicy }
      ).body

      const annotations = { ...(written.metadata?.annotations ?? {}) }
      const state = JSON.parse(annotations['clerum.io/egress-fqdn-state']) as Array<{
        expiresAt: number
      }>
      for (const e of state) e.expiresAt = Date.now() + 1000
      annotations['clerum.io/egress-fqdn-state'] = JSON.stringify(state)

      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [
          {
            metadata: {
              name: written.metadata?.name,
              labels: written.metadata?.labels,
              annotations,
            },
            spec: written.spec,
          },
        ],
      })
      mockApi.createNamespacedNetworkPolicy.mockRejectedValue(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValue({
        apiVersion: 'networking.k8s.io/v1',
        kind: 'NetworkPolicy',
        metadata: {
          name: written.metadata?.name,
          namespace: written.metadata?.namespace,
          labels: written.metadata?.labels,
          annotations,
          resourceVersion: '9',
        },
        spec: written.spec,
      })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      expect(mockApi.readNamespacedNetworkPolicy).toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).toHaveBeenCalled()
    })

    it('DROPS a blocked/private IP rehydrated from a tampered annotation (issue #299 M3 defense-in-depth)', async () => {
      const server: McpServerCRD = {
        name: 'tamper-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'tamper:latest',
          transport: { type: 'streamableHttp', url: 'http://tamper:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const written = (
        mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as { body: k8s.V1NetworkPolicy }
      ).body

      // Simulate a tampered live policy: a private IP injected into BOTH the state
      // annotation (so it rehydrates) and the spec egress (so a write is needed).
      const future = Date.now() + 3_600_000
      const state = [
        {
          ip: '1.2.3.4',
          port: 443,
          protocol: 'TCP',
          fqdn: 'api.example.com',
          expiresAt: future,
          lastObservedAt: Date.now(),
        },
        {
          ip: '5.6.7.8',
          port: 443,
          protocol: 'TCP',
          fqdn: 'api.example.com',
          expiresAt: future,
          lastObservedAt: Date.now(),
        },
        {
          ip: '10.0.0.5',
          port: 443,
          protocol: 'TCP',
          fqdn: 'api.example.com',
          expiresAt: future,
          lastObservedAt: Date.now(),
        },
      ]
      const tampered: k8s.V1NetworkPolicy = {
        metadata: {
          name: written.metadata?.name,
          labels: written.metadata?.labels,
          annotations: { 'clerum.io/egress-fqdn-state': JSON.stringify(state) },
        },
        spec: {
          ...written.spec!,
          egress: [
            { to: [{ ipBlock: { cidr: '1.2.3.4/32' } }], ports: [{ port: 443, protocol: 'TCP' }] },
            { to: [{ ipBlock: { cidr: '5.6.7.8/32' } }], ports: [{ port: 443, protocol: 'TCP' }] },
            { to: [{ ipBlock: { cidr: '10.0.0.5/32' } }], ports: [{ port: 443, protocol: 'TCP' }] },
          ],
        },
      }
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({ items: [tampered] })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      // The reconcile must rewrite the policy WITHOUT the private IP.
      const call =
        mockApi.replaceNamespacedNetworkPolicy.mock.calls[0]?.[0] ??
        mockApi.createNamespacedNetworkPolicy.mock.calls[0]?.[0]
      const cidrs = JSON.stringify(
        (call as { body: k8s.V1NetworkPolicy })?.body?.spec?.egress ?? []
      )
      expect(call).toBeTruthy()
      expect(cidrs).not.toContain('10.0.0.5')
      expect(cidrs).toContain('1.2.3.4')
    })

    it('updates the observed min-TTL from a resolution (issue #299 M4 — feeds the TTL-aware resync)', async () => {
      resolve4Mock.mockResolvedValueOnce([{ address: '1.2.3.4', ttl: 15 }]) // ttl 15s
      const server: McpServerCRD = {
        name: 'ttl-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'ttl:latest',
          transport: { type: 'streamableHttp', url: 'http://ttl:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      // The min observed TTL (ms) must reflect the 15s answer — deleting the
      // Math.min update leaves it Infinity and the resync degrades to the fixed
      // interval (the #299 under-sampling failure mode).
      expect(reconciler.externalEgressRefreshMinTtlMs).toBe(15_000)
    })

    it('accumulates the UNION across a real A->B rotation via rehydration (issue #299 M4 — wiring not vacuous)', async () => {
      const server: McpServerCRD = {
        name: 'rot-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'rot:latest',
          transport: { type: 'streamableHttp', url: 'http://rot:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }
      // Round 1: DNS serves A only.
      resolve4Mock.mockResolvedValueOnce([{ address: '140.82.112.3', ttl: 15 }])
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const written = (
        mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as { body: k8s.V1NetworkPolicy }
      ).body
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [{ metadata: written.metadata, spec: written.spec }],
      })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      // Round 2: DNS rotates to B. The written policy must be the UNION {A, B} —
      // this only holds if previousAnnotations rehydration is actually wired in.
      resolve4Mock.mockResolvedValueOnce([{ address: '140.82.112.4', ttl: 15 }])
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const call =
        mockApi.replaceNamespacedNetworkPolicy.mock.calls[0]?.[0] ??
        mockApi.createNamespacedNetworkPolicy.mock.calls[0]?.[0]
      const egress = JSON.stringify(
        (call as { body: k8s.V1NetworkPolicy })?.body?.spec?.egress ?? []
      )
      expect(egress).toContain('140.82.112.3') // A retained (overlap)
      expect(egress).toContain('140.82.112.4') // B added
    })

    it('is a NO-OP on resync for an unchanged STATIC cidr binding (issue #299 F2 — no static churn)', async () => {
      const server: McpServerCRD = {
        name: 'cidr-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'cidr:latest',
          transport: { type: 'streamableHttp', url: 'http://cidr:3000', port: 3000 },
          egressBindings: [{ cidr: '93.184.216.0/24', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const created = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as {
        body: k8s.V1NetworkPolicy
      }
      const written = created.body
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [{ metadata: written.metadata, spec: written.spec }],
      })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('is a NO-OP when the live policy has identical egress but different KEY ORDER (issue #299 R2-1)', async () => {
      // The apiserver/client deserializes egress rules with keys ordered
      // {ports, to} while the builder emits {to, ports}. A raw JSON.stringify
      // compare would see them as different and rewrite every tick (write-storm).
      // The semantic signature must treat them as equal → no-op.
      const server: McpServerCRD = {
        name: 'keyorder-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'keyorder:latest',
          transport: { type: 'streamableHttp', url: 'http://keyorder:3000', port: 3000 },
          egressBindings: [{ cidr: '93.184.216.0/24', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const created = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as {
        body: k8s.V1NetworkPolicy
      }
      const written = created.body
      // Rebuild egress rules with keys in apiserver order {ports, to}.
      const reordered: k8s.V1NetworkPolicy = {
        metadata: written.metadata,
        spec: {
          ...written.spec!,
          egress: (written.spec!.egress ?? []).map(r => ({ ports: r.ports, to: r.to })),
        },
      }
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({ items: [reordered] })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('self-heals an external-egress policy whose live spec.egress drifted out-of-band (issue #299 L1)', async () => {
      const server: McpServerCRD = {
        name: 'drift-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'drift:latest',
          transport: { type: 'streamableHttp', url: 'http://drift:3000', port: 3000 },
          egressBindings: [{ cidr: '93.184.216.0/24', port: 443 }],
        },
      }
      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const created = mockApi.createNamespacedNetworkPolicy.mock.calls[0][0] as {
        body: k8s.V1NetworkPolicy
      }
      const written = created.body
      // Simulate out-of-band tampering: the live policy's egress was widened.
      const drifted: k8s.V1NetworkPolicy = {
        metadata: written.metadata,
        spec: {
          ...written.spec!,
          egress: [
            { to: [{ ipBlock: { cidr: '0.0.0.0/0' } }], ports: [{ port: 443, protocol: 'TCP' }] },
          ],
        },
      }
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({ items: [drifted] })
      mockApi.createNamespacedNetworkPolicy.mockClear()
      mockApi.replaceNamespacedNetworkPolicy.mockClear()

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      // The reconciler must rewrite the policy back to the declared CIDR.
      const wrote =
        mockApi.createNamespacedNetworkPolicy.mock.calls.length +
        mockApi.replaceNamespacedNetworkPolicy.mock.calls.length
      expect(wrote).toBeGreaterThan(0)
    })

    it('rejects private or special-use CIDR bindings fail-closed', async () => {
      for (const cidr of ['10.0.0.0/8', '169.254.169.254/32', '192.168.1.0/24']) {
        const server: McpServerCRD = {
          name: 'private-mcp',
          namespace: 'mcp-server',
          spec: {
            contextRef: 'dev',
            image: 'private:latest',
            transport: { type: 'streamableHttp', url: 'http://private:3000', port: 3000 },
            egressBindings: [{ cidr, port: 443 }],
          },
        }

        await expect(
          reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
        ).rejects.toThrow(/External egress reconciliation failed/)
      }

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('rejects mixed public/private DNS results for the whole hostname', async () => {
      resolve4Mock.mockResolvedValueOnce(rec('10.0.0.5', '1.2.3.4'))
      const server: McpServerCRD = {
        name: 'mixed-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'mixed:latest',
          transport: { type: 'streamableHttp', url: 'http://mixed:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/resolved disallowed address/)

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockCustomApi.patchNamespacedCustomObjectStatus).toHaveBeenCalledWith(
        expect.objectContaining({
          body: expect.arrayContaining([
            expect.objectContaining({
              path: '/status/conditions',
              value: expect.arrayContaining([
                expect.objectContaining({
                  type: 'ExternalEgressReady',
                  status: 'False',
                  reason: 'ExternalEgressRejected',
                }),
              ]),
            }),
          ]),
        })
      )
    })

    it('rejects internal DNS hostnames before resolving them', async () => {
      const server: McpServerCRD = {
        name: 'internal-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'internal:latest',
          transport: { type: 'streamableHttp', url: 'http://internal:3000', port: 3000 },
          egressBindings: [{ dns: 'kubernetes.default.svc', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/private, internal, metadata/)

      expect(dns.resolve4).not.toHaveBeenCalled()
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('does not create an external egress policy when DNS only resolves private IPs', async () => {
      resolve4Mock.mockResolvedValueOnce(rec('10.0.0.5', '192.168.1.10'))
      const server: McpServerCRD = {
        name: 'private-dns-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'private-dns:latest',
          transport: { type: 'streamableHttp', url: 'http://private-dns:3000', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/resolved disallowed address/)

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('deletes only orphaned external egress policies after applying the desired set', async () => {
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [
          {
            metadata: {
              name: 'ext-egress-openai-mcp-api.openai.com-443',
              labels: {
                [MANAGED_BY_LABEL]: MANAGED_BY_VALUE,
                [POLICY_TYPE_LABEL]: 'external-egress',
                [MCPSERVER_LABEL]: 'openai-mcp',
              },
            },
          },
          { metadata: { name: 'ext-egress-openai-mcp-old-example-com-443' } },
        ],
      })

      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ext-egress-openai-mcp-old-example-com-443',
          namespace: 'mcp-server',
        })
      )
    })

    it('fails closed when an orphaned external egress policy cannot be deleted', async () => {
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [
          {
            metadata: {
              name: 'ext-egress-openai-mcp-api.openai.com-443',
              labels: {
                [MANAGED_BY_LABEL]: MANAGED_BY_VALUE,
                [POLICY_TYPE_LABEL]: 'external-egress',
                [MCPSERVER_LABEL]: 'openai-mcp',
              },
            },
          },
          { metadata: { name: 'ext-egress-openai-mcp-old-example-com-443' } },
        ],
      })
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(new Error('delete denied'))

      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow('delete denied')
    })

    it('deletes stale policies and fails when DNS resolution for that binding fails', async () => {
      // Issue #513: this used to inject a codeless `new Error('dns timeout')` and
      // expect the prune-and-delete path. That expectation encoded the defect —
      // classifyDnsError defaults an unknown code to 'permanent', so a codeless
      // error (a programming fault as easily as a resolver one) pruned the window
      // and deleted the policy. A codeless error is now rethrown, so this test
      // injects a real no-records answer: the permanent branch it means to cover.
      vi.mocked(dns.resolve4).mockRejectedValueOnce(
        Object.assign(new Error('queryA ENOTFOUND api.openai.com'), { code: 'ENOTFOUND' })
      )
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [
          {
            metadata: {
              name: 'ext-egress-openai-mcp-api.openai.com-443',
              labels: {
                [MANAGED_BY_LABEL]: MANAGED_BY_VALUE,
                [POLICY_TYPE_LABEL]: 'external-egress',
                [MCPSERVER_LABEL]: 'openai-mcp',
              },
            },
          },
          { metadata: { name: 'ext-egress-openai-mcp-old-example-com-443' } },
        ],
      })

      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', url: 'http://openai:3000', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/ENOTFOUND/)

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(2)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ext-egress-openai-mcp-api.openai.com-443',
          namespace: 'mcp-server',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ext-egress-openai-mcp-old-example-com-443',
          namespace: 'mcp-server',
        })
      )
      expect(mockCustomApi.patchNamespacedCustomObjectStatus).toHaveBeenCalledWith(
        expect.objectContaining({
          body: expect.arrayContaining([
            expect.objectContaining({
              path: '/status/conditions',
              value: expect.arrayContaining([
                expect.objectContaining({
                  type: 'ExternalEgressReady',
                  status: 'False',
                  reason: 'ExternalEgressRejected',
                }),
              ]),
            }),
          ]),
        })
      )
    })

    it('fails closed for malformed exact-host bindings without dns or cidr', async () => {
      const server: McpServerCRD = {
        name: 'broken-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'broken:latest',
          transport: { type: 'streamableHttp', url: 'http://broken:3000', port: 3000 },
          egressBindings: [{ port: 443 }],
        },
      }

      await expect(
        reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      ).rejects.toThrow(/must declare dns or cidr/)
      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('bounds DNS resolution so a stuck resolver cannot block reconciliation indefinitely', async () => {
      vi.useFakeTimers()
      vi.mocked(dns.resolve4).mockImplementationOnce(() => new Promise(() => undefined))
      const server: McpServerCRD = {
        name: 'stuck-dns-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'stuck-dns:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }

      const reconcile = reconciler.reconcileExternalEgress(server, { isCurrent: () => true })
      const rejection = expect(reconcile).rejects.toThrow(/DNS resolution timed out after 5000ms/)
      await vi.advanceTimersByTimeAsync(5_000)
      await rejection

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('skips if no egressBindings', async () => {
      const server: McpServerCRD = {
        name: 'basic-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'basic:latest',
          transport: { type: 'streamableHttp', url: 'http://basic:3000', port: 3000 },
        },
      }

      await reconciler.reconcileExternalEgress(server, { isCurrent: () => true })

      expect(mockApi.createNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })
  })

  describe('inventory listing failures', () => {
    it('propagates context policy list failures instead of treating inventory as empty', async () => {
      mockApi.listNamespacedNetworkPolicy.mockRejectedValueOnce(new Error('api list denied'))

      await expect((reconciler as any).listPoliciesForContext('dev')).rejects.toThrow(
        'api list denied'
      )
    })

    it('propagates all-context policy list failures', async () => {
      mockApi.listNamespacedNetworkPolicy.mockRejectedValueOnce(new Error('api list denied'))

      await expect((reconciler as any).listAllContextPolicies()).rejects.toThrow('api list denied')
    })

    it('propagates all-context mcp-host egress policy list failures', async () => {
      mockApi.listNamespacedNetworkPolicy.mockRejectedValueOnce(new Error('api list denied'))

      await expect((reconciler as any).listAllContextEgressPolicies()).rejects.toThrow(
        'api list denied'
      )
    })

    it('propagates all external-egress policy list failures', async () => {
      mockApi.listNamespacedNetworkPolicy.mockRejectedValueOnce(new Error('api list denied'))

      await expect((reconciler as any).listAllExternalEgressPolicies()).rejects.toThrow(
        'api list denied'
      )
    })
  })

  describe('delete-context TOCTOU re-check', () => {
    it('stops mid-inventory when the context is recreated between two deletes', async () => {
      // deleteAllowed is a live GET, so its answer can change while the loop
      // runs. Hoisting the check out of the loop would satisfy every existing
      // test and still delete the recreated context's own policies.
      mockApi.listNamespacedNetworkPolicy.mockResolvedValueOnce({
        items: [
          { metadata: { name: 'ctx-allow-first' } },
          { metadata: { name: 'ctx-allow-second' } },
        ],
      })
      const deleteAllowed = vi
        .fn<() => Promise<boolean>>()
        .mockResolvedValueOnce(true)
        .mockResolvedValue(false)

      await reconciler.reconcileDeleteContext('dev', deleteAllowed)

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({ name: 'ctx-allow-first' })
      )
      expect(deleteAllowed).toHaveBeenCalledTimes(2)
    })

    it('re-checks before every mcp-host egress delete', async () => {
      mockApi.listNamespacedNetworkPolicy
        .mockResolvedValueOnce({ items: [] }) // context-allow
        .mockResolvedValueOnce({
          items: [
            { metadata: { name: 'host-egress-first' } },
            { metadata: { name: 'host-egress-second' } },
          ],
        })
      const deleteAllowed = vi
        .fn<() => Promise<boolean>>()
        .mockResolvedValueOnce(true)
        .mockResolvedValue(false)

      await reconciler.reconcileDeleteContext('dev', deleteAllowed)

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({ name: 'host-egress-first' })
      )
    })

    it('re-checks before every rpc-proxy egress delete', async () => {
      mockApi.listNamespacedNetworkPolicy
        .mockResolvedValueOnce({ items: [] }) // context-allow
        .mockResolvedValueOnce({ items: [] }) // mcp-host egress
        .mockResolvedValueOnce({
          items: [
            { metadata: { name: 'rpc-egress-first' } },
            { metadata: { name: 'rpc-egress-second' } },
          ],
        })
      const deleteAllowed = vi
        .fn<() => Promise<boolean>>()
        .mockResolvedValueOnce(true)
        .mockResolvedValue(false)

      await reconciler.reconcileDeleteContext('dev', deleteAllowed)

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({ name: 'rpc-egress-first' })
      )
    })
  })

  describe('L3 — DNS-derived retention by binding identity (B3)', () => {
    // Live DNS policy built through the reconciler's OWN builder so its identity
    // is exact-by-construction; each test drifts exactly one dimension.
    function makeDnsFixture() {
      const server: McpServerCRD = {
        name: 'openai-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'openai:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.openai.com', port: 443 }],
        },
      }
      const binding = server.spec.egressBindings![0]
      const name = (reconciler as any).externalEgressPolicyName(server.name, binding) as string
      const live = (reconciler as any).buildExactHostEgressPolicy(server, name, binding, [
        '1.2.3.4/32',
      ]) as k8s.V1NetworkPolicy
      live.metadata!.uid = 'live-dns-uid'
      live.metadata!.resourceVersion = '11'
      return { server, binding, name, live }
    }

    async function runSafety(server: McpServerCRD, live: k8s.V1NetworkPolicy): Promise<boolean> {
      return (reconciler as any).reconcileExternalEgressSafety(
        server,
        [live],
        () => true
      ) as Promise<boolean>
    }

    function expectRevoked(name: string) {
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name,
          namespace: 'mcp-server',
          body: { preconditions: { uid: 'live-dns-uid', resourceVersion: '11' } },
        })
      )
    }

    it('(a) retains an unchanged DNS-derived allow — no revocation', async () => {
      const { server, live } = makeDnsFixture()
      await expect(runSafety(server, live)).resolves.toBe(true)
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('(b) revokes on spec-level port drift under the same policy name', async () => {
      const { server, name, live } = makeDnsFixture()
      live.spec!.egress![0].ports = [{ port: 8443, protocol: 'TCP' }]
      await expect(runSafety(server, live)).resolves.toBe(true)
      expectRevoked(name)
    })

    it('(c) revokes on protocol drift TCP→UDP', async () => {
      const { server, name, live } = makeDnsFixture()
      live.spec!.egress![0].ports = [{ port: 443, protocol: 'UDP' }]
      await expect(runSafety(server, live)).resolves.toBe(true)
      expectRevoked(name)
    })

    it('(d) revokes a foreign-owned policy even when the spec is identical', async () => {
      const { server, name, live } = makeDnsFixture()
      live.metadata!.labels!['clerum.io/managed-by'] = 'foreign-controller'
      await expect(runSafety(server, live)).resolves.toBe(true)
      expectRevoked(name)
    })

    it('(f) revokes a degenerate zero-cidr "allow" (deny in disguise)', async () => {
      const { server, name, live } = makeDnsFixture()
      live.spec!.egress = []
      await expect(runSafety(server, live)).resolves.toBe(true)
      expectRevoked(name)
    })

    it('(e) queues recreation AT the revocation even when the pass then aborts and throws', async () => {
      const { server, binding, name } = makeDnsFixture()
      // Identity-drifted (protocol UDP) → this DNS allow is revoked (deleted).
      const live = (reconciler as any).buildExactHostEgressPolicy(server, name, binding, [
        '1.2.3.4/32',
      ]) as k8s.V1NetworkPolicy
      live.spec!.egress![0].ports = [{ port: 443, protocol: 'UDP' }]
      live.metadata!.uid = 'live-dns-uid'
      live.metadata!.resourceVersion = '11'

      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: !labelSelector && namespace === 'mcp-server' ? [live] : [],
        })
      )

      let resolved: McpServerCRD | undefined = server
      const spy = vi.fn()
      // Flip authority false AT the deletion, so the pass aborts right after the
      // revocation hook fires — reproducing the abort/throw window B3 must survive.
      mockApi.deleteNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        resolved = undefined
        return {}
      })

      const rec = makeReconciler(mockApi, new Map([[server.name, server]]), mockCustomApi)

      await expect(
        rec.fullReconcile([], [server], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          resolveCurrentServer: () => resolved,
          onExternalEgressRevoked: spy,
        })
      ).rejects.toThrow(/inventory changed during authoritative revocation/)

      expect(spy).toHaveBeenCalledTimes(1)
      expect(spy).toHaveBeenCalledWith(
        expect.objectContaining({ name: server.name, namespace: server.namespace })
      )
    })
  })

  describe('startup fullReconcile', () => {
    it('discovers and revokes orphaned policies with one missing ownership marker in every safety lane', async () => {
      const partiallyLabelledByNamespace: Record<string, k8s.V1NetworkPolicy[]> = {
        'mcp-server': [
          {
            metadata: {
              name: 'ctx-orphan-context-old-server',
              labels: {
                'clerum.io/managed-by': 'host-context-controller',
                'clerum.io/context': 'orphan-context',
                'clerum.io/mcpserver': 'old-server',
              },
            },
            spec: { podSelector: {}, policyTypes: ['Ingress'] },
          },
          {
            metadata: {
              name: 'ext-egress-orphan-server-old-example-com-443',
              labels: {
                'clerum.io/policy-type': 'external-egress',
                'clerum.io/mcpserver': 'orphan-server',
                'clerum.io/egress-class': 'exact-host',
              },
            },
            spec: { podSelector: {}, policyTypes: ['Egress'] },
          },
        ],
        'mcp-host': [
          {
            metadata: {
              name: 'ctx-orphan-context-old-server-egress',
              labels: {
                'clerum.io/policy-type': 'context-allow',
                'clerum.io/context': 'orphan-context',
                'clerum.io/mcpserver': 'old-server',
              },
            },
            spec: { podSelector: {}, policyTypes: ['Egress'] },
          },
        ],
        'rpc-proxy': [
          {
            metadata: {
              name: 'rpc-egress-orphan-context-old-server',
              labels: {
                'clerum.io/managed-by': 'host-context-controller',
                'clerum.io/context': 'orphan-context',
                'clerum.io/mcpserver': 'old-server',
              },
            },
            spec: { podSelector: {}, policyTypes: ['Egress'] },
          },
        ],
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: labelSelector ? [] : (partiallyLabelledByNamespace[namespace ?? ''] ?? []),
        })
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ctx-orphan-context-old-server',
          namespace: 'mcp-server',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ctx-orphan-context-old-server-egress',
          namespace: 'mcp-host',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'rpc-egress-orphan-context-old-server',
          namespace: 'rpc-proxy',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ext-egress-orphan-server-old-example-com-443',
          namespace: 'mcp-server',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledTimes(4)
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it('repairs one-marker live widened policies in every lane before certification', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const server: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'live-context',
          image: 'live:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ cidr: '8.8.8.8/32', port: 443 }],
        },
      }
      const context: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [server.name] },
      }
      const cache = new Map([[server.name, server]])
      const rec = makeReconciler(mockApi, cache, mockCustomApi)

      await rec.reconcileContext(context, { isCurrent: () => true })
      await rec.reconcileExternalEgress(server, { isCurrent: () => true })
      const generated = mockApi.createNamespacedNetworkPolicy.mock.calls.map(
        call => (call[0] as { body: k8s.V1NetworkPolicy }).body
      )
      const widened = generated.map((policy, index) => ({
        ...policy,
        metadata: {
          ...policy.metadata,
          labels: Object.fromEntries(
            Object.entries(policy.metadata?.labels ?? {}).filter(
              ([label]) =>
                label !== (index % 2 === 0 ? 'clerum.io/managed-by' : 'clerum.io/policy-type')
            )
          ),
        },
        spec: {
          ...policy.spec,
          policyTypes: [...(policy.spec?.policyTypes ?? []), 'Ingress'],
        },
      }))

      vi.clearAllMocks()
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: labelSelector
            ? []
            : widened.filter(policy => policy.metadata?.namespace === namespace),
        })
      )
      mockApi.createNamespacedNetworkPolicy.mockRejectedValue(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      const ordering: string[] = []
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(async ({ name }) => {
        ordering.push(`replace:${name}`)
        return {}
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => ordering.push('certify'))

      await rec.fullReconcile([context], [server], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        resolveCurrentContext: () => context,
        resolveCurrentServer: () => server,
        onAuthoritativeRevocationComplete,
      })

      const certificationIndex = ordering.indexOf('certify')
      expect(certificationIndex).toBeGreaterThanOrEqual(4)
      for (const expectedName of [
        'ctx-live-context-live-server',
        'ctx-live-context-live-server-egress',
        'rpc-egress-live-context-live-server',
        'ext-egress-live-server-8-8-8-8-32-443',
      ]) {
        expect(ordering.indexOf(`replace:${expectedName}`)).toBeGreaterThanOrEqual(0)
        expect(ordering.indexOf(`replace:${expectedName}`)).toBeLessThan(certificationIndex)
      }
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it.each([
      [
        'context ingress',
        'mcp-server',
        {
          metadata: { name: 'ctx-reserved-context-server', labels: {} },
          spec: { podSelector: {}, policyTypes: ['Ingress'] },
        },
      ],
      [
        'host egress',
        'mcp-host',
        {
          metadata: { name: 'ctx-reserved-context-server-egress', labels: {} },
          spec: { podSelector: {}, policyTypes: ['Egress'] },
        },
      ],
      [
        'rpc egress',
        'rpc-proxy',
        {
          metadata: { name: 'rpc-egress-reserved-context-server', labels: {} },
          spec: { podSelector: {}, policyTypes: ['Egress'] },
        },
      ],
      [
        'external egress',
        'mcp-server',
        {
          metadata: { name: 'ext-egress-reserved-server-example-443', labels: {} },
          spec: { podSelector: {}, policyTypes: ['Egress'] },
        },
      ],
    ])(
      'fails closed without takeover for a both-markers-missing reserved %s name',
      async (_lane, namespace, candidate) => {
        mockApi.listNamespacedNetworkPolicy.mockImplementation(
          async ({
            namespace: listedNamespace,
            labelSelector,
          }: {
            namespace?: string
            labelSelector?: string
          }) => ({
            items: !labelSelector && listedNamespace === namespace ? [candidate] : [],
          })
        )
        const onAuthoritativeRevocationComplete = vi.fn()

        await expect(
          reconciler.fullReconcile([], [], {
            ensureDefaults: false,
            contextInventoryAuthoritative: () => true,
            serverInventoryAuthoritative: () => true,
            onAuthoritativeRevocationComplete,
          })
        ).rejects.toThrow(/Ambiguous NetworkPolicy ownership/)

        expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
        expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
        expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      }
    )

    it('fails closed for an explicit foreign ownership conflict on an HCC-shaped policy', async () => {
      const candidate: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'ext-egress-live-server-api-example-com-443',
          labels: {
            'clerum.io/managed-by': 'foreign-controller',
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': 'live-server',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Egress'] },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: !labelSelector && namespace === 'mcp-server' ? [candidate] : [],
        })
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow(/Ambiguous NetworkPolicy ownership/)

      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('treats a non-reserved external policy missing its manager marker as ambiguous', async () => {
      const candidate: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'custom-egress-policy',
          labels: {
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': 'live-server',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Egress'] },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: !labelSelector && namespace === 'mcp-server' ? [candidate] : [],
        })
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow(/Ambiguous NetworkPolicy ownership/)

      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('lets the broad snapshot shadow a selected-owned object that became unrelated at the same UID', async () => {
      const selected: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'legacy-custom-policy',
          uid: 'stable-policy-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'host-context-controller',
            'clerum.io/policy-type': 'context-allow',
            'clerum.io/context': 'orphan-context',
            'clerum.io/mcpserver': 'old-server',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Ingress'] },
      }
      const broadRelabelled: k8s.V1NetworkPolicy = {
        ...selected,
        metadata: {
          ...selected.metadata,
          resourceVersion: '8',
          labels: { 'tenant.example/managed-by': 'tenant-controller' },
        },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace !== 'mcp-server') return { items: [] }
          if (labelSelector?.includes('policy-type=context-allow')) return { items: [selected] }
          if (!labelSelector) return { items: [broadRelabelled] }
          return { items: [] }
        }
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it('leaves unrelated namespace policies untouched and still certifies', async () => {
      const unrelated: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'tenant-owned-policy',
          labels: {
            'app.kubernetes.io/managed-by': 'tenant-operator',
            'tenant.example/purpose': 'custom-egress',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Egress'] },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: !labelSelector && namespace === 'mcp-server' ? [unrelated] : [],
        })
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('fails closed when the broad safety inventory LIST fails', async () => {
      mockApi.listNamespacedNetworkPolicy
        .mockResolvedValueOnce({ items: [] })
        .mockResolvedValueOnce({ items: [] })
        .mockResolvedValueOnce({ items: [] })
        .mockResolvedValueOnce({ items: [] })
        .mockRejectedValueOnce(new Error('broad inventory denied'))
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow('broad inventory denied')

      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('withholds certification and mutation when Context authority is lost during the broad LIST', async () => {
      let contextAuthoritative = true
      const candidate: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'ctx-orphan-context-old-server',
          labels: {
            'clerum.io/policy-type': 'context-allow',
            'clerum.io/context': 'orphan-context',
            'clerum.io/mcpserver': 'old-server',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Ingress'] },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (!labelSelector && namespace === 'mcp-server') {
            contextAuthoritative = false
            return { items: [candidate] }
          }
          return { items: [] }
        }
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => contextAuthoritative,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('does not reconcile a queued Context when its current contextId changed', async () => {
      const queuedContext: ContextCRD = {
        name: 'mutable-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'captured-context', mcpServers: [] },
      }
      const currentContext: ContextCRD = {
        ...queuedContext,
        spec: { contextId: 'replacement-context', mcpServers: [] },
      }
      const reconcileContext = vi.spyOn(reconciler, 'reconcileContext').mockResolvedValue(true)
      const effectKeys: string[] = []

      await reconciler.fullReconcile([queuedContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => false,
        resolveCurrentContext: () => currentContext,
        runContextEffect: async (contextId, work) => {
          effectKeys.push(contextId)
          await work()
        },
      })

      expect(effectKeys).toEqual(['captured-context', 'captured-context'])
      expect(reconcileContext).not.toHaveBeenCalled()
    })

    it('retires a full-pass Context lease when the selected object is replaced', async () => {
      const selected: ContextCRD = {
        name: 'full-pass-context',
        namespace: 'mcp-server',
        spec: { contextId: 'full-pass-context', description: 'old', mcpServers: [] },
      }
      const replacement: ContextCRD = {
        ...selected,
        spec: { ...selected.spec, description: 'new' },
      }
      let current = selected
      let selectedLease: (() => boolean) | undefined
      const mutationStarted = deferred()
      const releaseMutation = deferred()
      vi.spyOn(reconciler, 'reconcileContext').mockImplementationOnce(async (_context, options) => {
        selectedLease = options?.isCurrent
        mutationStarted.resolve(undefined)
        await releaseMutation.promise
        return true
      })

      const fullPass = reconciler.fullReconcile([selected], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        resolveCurrentContext: () => current,
      })
      await mutationStarted.promise
      expect(selectedLease?.()).toBe(true)

      current = replacement
      expect(selectedLease?.()).toBe(false)
      releaseMutation.resolve(undefined)
      await fullPass
    })

    it('deletes orphaned Context policies in all three namespaces through the canonical contextId effect key', async () => {
      const effectKeys: string[] = []
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-orphan-context-old-server',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'mcp-host' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-orphan-context-old-server-egress',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'rpc-proxy' && labelSelector?.includes('rpc-proxy-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'rpc-egress-orphan-context-old-server',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        runContextEffect: async (contextId, work) => {
          effectKeys.push(contextId)
          await work()
        },
      })

      expect(effectKeys).toEqual(['orphan-context', 'orphan-context', 'orphan-context'])
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ctx-orphan-context-old-server',
          namespace: 'mcp-server',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ctx-orphan-context-old-server-egress',
          namespace: 'mcp-host',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'rpc-egress-orphan-context-old-server',
          namespace: 'rpc-proxy',
        })
      )
    })

    it('routes desired and orphan Context policy lanes through canonical contextId effect keys', async () => {
      const desiredContext: ContextCRD = {
        name: 'desired-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'desired-context', mcpServers: [] },
      }
      const effectKeys: string[] = []
      vi.spyOn(reconciler, 'reconcileContext').mockResolvedValue(true)
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-orphan-context-old-server',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'rpc-proxy' && labelSelector?.includes('rpc-proxy-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'rpc-egress-orphan-context-old-server',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([desiredContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        runContextEffect: async (contextId, work) => {
          effectKeys.push(contextId)
          await work()
        },
      })

      expect(effectKeys).toEqual([
        'orphan-context',
        'orphan-context',
        'desired-context',
        'desired-context',
      ])
    })

    it('revokes every orphan allow lane before a slow additive Context effect', async () => {
      const desiredContext: ContextCRD = {
        name: 'desired-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'desired-context', mcpServers: [] },
      }
      const additiveStarted = deferred()
      const releaseAdditive = deferred()
      vi.spyOn(reconciler, 'reconcileContext').mockImplementationOnce(async () => {
        additiveStarted.resolve(undefined)
        await releaseAdditive.promise
        return true
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-orphan-context-old-server',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'mcp-host' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-orphan-context-old-server-egress',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'rpc-proxy' && labelSelector?.includes('rpc-proxy-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'rpc-egress-orphan-context-old-server',
                    labels: { 'clerum.io/context': 'orphan-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'mcp-server' && labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-orphan-server-old.example',
                    labels: { 'clerum.io/mcpserver': 'orphan-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      const fullPass = reconciler.fullReconcile([desiredContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
      })

      await additiveStarted.promise
      try {
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'ctx-orphan-context-old-server',
            namespace: 'mcp-server',
          })
        )
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'ctx-orphan-context-old-server-egress',
            namespace: 'mcp-host',
          })
        )
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'rpc-egress-orphan-context-old-server',
            namespace: 'rpc-proxy',
          })
        )
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'ext-egress-orphan-server-old.example',
            namespace: 'mcp-server',
          })
        )
      } finally {
        releaseAdditive.resolve(undefined)
        await fullPass
      }
    })

    it('revokes every stale allow lane for a live Context before signaling authoritative revocation', async () => {
      const liveContext: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [] },
      }
      const additiveStarted = deferred()
      const releaseAdditive = deferred()
      vi.spyOn(reconciler, 'reconcileContext').mockImplementationOnce(async () => {
        additiveStarted.resolve(undefined)
        await releaseAdditive.promise
        return true
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-live-context-removed-server',
                    labels: { 'clerum.io/context': 'live-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'mcp-host' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-live-context-removed-server-egress',
                    labels: { 'clerum.io/context': 'live-context' },
                  },
                },
              ],
            }
          }
          if (namespace === 'rpc-proxy' && labelSelector?.includes('rpc-proxy-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'rpc-egress-live-context-removed-server',
                    labels: { 'clerum.io/context': 'live-context' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      const fullPass = reconciler.fullReconcile([liveContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      await additiveStarted.promise
      try {
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'ctx-live-context-removed-server',
            namespace: 'mcp-server',
          })
        )
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'ctx-live-context-removed-server-egress',
            namespace: 'mcp-host',
          })
        )
        expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
          expect.objectContaining({
            name: 'rpc-egress-live-context-removed-server',
            namespace: 'rpc-proxy',
          })
        )
        expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      } finally {
        releaseAdditive.resolve(undefined)
        await fullPass
      }
    })

    it('revokes stale external egress for a live McpServer before readiness certification', async () => {
      const liveServer: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'live:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [],
        },
      }
      const ordering: string[] = []
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-live-server-old.example-443',
                    labels: { 'clerum.io/mcpserver': 'live-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('delete')
        return {}
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        ordering.push('certify')
      })

      await reconciler.fullReconcile([], [liveServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ext-egress-live-server-old.example-443',
          namespace: 'mcp-server',
        })
      )
      expect(ordering.slice(0, 2)).toEqual(['delete', 'certify'])
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it('does not let one post-certification Context failure starve later additive owners', async () => {
      const contexts: ContextCRD[] = ['aaa-poisoned', 'bbb-healthy'].map(contextId => ({
        name: `${contextId}-resource`,
        namespace: 'mcp-server',
        spec: { contextId, mcpServers: [] },
      }))
      const ordering: string[] = []
      const additiveFailure = new Error('poisoned additive Context')
      vi.spyOn(reconciler, 'reconcileContext').mockImplementation(async context => {
        ordering.push(`context:${context.spec.contextId}`)
        if (context.spec.contextId === 'aaa-poisoned') throw additiveFailure
        return true
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        ordering.push('certify')
      })
      const errorLog = vi.spyOn(console, 'error').mockImplementation(() => undefined)

      const error = await reconciler
        .fullReconcile(contexts, [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
        .then(
          () => undefined,
          failure => failure
        )

      expect(error).toBeInstanceOf(AggregateError)
      expect((error as AggregateError).errors).toEqual([additiveFailure])
      expect(ordering).toEqual(['certify', 'context:aaa-poisoned', 'context:bbb-healthy'])
      expect(errorLog.mock.calls.map(([line]) => JSON.parse(String(line)))).toContainEqual(
        expect.objectContaining({
          level: 'error',
          contextId: 'aaa-poisoned',
          err: { name: 'Error', message: additiveFailure.message },
        })
      )
    })

    it('replaces same-name Context allow policies in every lane before certification', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const oldServer: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'live:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          transport: { type: 'streamableHttp', port: 4000 },
        },
      }
      const liveContext: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [oldServer.name] },
      }
      const serverCache = new Map([[oldServer.name, oldServer]])
      const rec = makeReconciler(mockApi, serverCache, mockCustomApi)

      await rec.reconcileContext(liveContext, { isCurrent: () => true })
      const oldPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.map(
        call => (call[0] as { body: k8s.V1NetworkPolicy }).body
      )
      expect(oldPolicies).toHaveLength(3)

      vi.clearAllMocks()
      serverCache.set(currentServer.name, currentServer)
      mockApi.createNamespacedNetworkPolicy.mockRejectedValue(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (labelSelector?.includes('external-egress')) return { items: [] }
          return {
            items: oldPolicies.filter(policy => policy.metadata?.namespace === namespace),
          }
        }
      )
      vi.spyOn(rec, 'reconcileContext').mockResolvedValue(true)
      vi.spyOn(rec, 'reconcileExternalEgress').mockResolvedValue(undefined)
      const ordering: string[] = []
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace }: { namespace?: string }) => {
          ordering.push(`replace:${namespace}`)
          return {}
        }
      )
      const onAuthoritativeRevocationComplete = vi.fn(() => ordering.push('certify'))

      await rec.fullReconcile([liveContext], [currentServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(ordering).toEqual([
        'replace:mcp-server',
        'replace:mcp-host',
        'replace:rpc-proxy',
        'certify',
      ])
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it.each([
      ['context-ingress', 'mcp-server'],
      ['context-host-egress', 'mcp-host'],
      ['context-rpc-egress', 'rpc-proxy'],
    ])(
      'refuses a same-name %s safety replacement owned by another server',
      async (_lane, targetNamespace) => {
        // Create the original owned policies before replacing the listed owner.
        mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
        const oldServer: McpServerCRD = {
          name: 'live-server',
          namespace: 'mcp-server',
          spec: {
            contextRef: 'default',
            image: 'live:latest',
            transport: { type: 'streamableHttp', port: 3000 },
          },
        }
        const currentServer: McpServerCRD = {
          ...oldServer,
          spec: {
            ...oldServer.spec,
            transport: { type: 'streamableHttp', port: 4000 },
          },
        }
        const liveContext: ContextCRD = {
          name: 'live-context-resource',
          namespace: 'mcp-server',
          spec: { contextId: 'live-context', mcpServers: [oldServer.name] },
        }
        const serverCache = new Map([[oldServer.name, oldServer]])
        const rec = makeReconciler(mockApi, serverCache, mockCustomApi)

        await rec.reconcileContext(liveContext, { isCurrent: () => true })
        const oldPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.map(call => {
          const policy = (call[0] as { body: k8s.V1NetworkPolicy }).body
          if (policy.metadata?.namespace !== targetNamespace) return policy
          return {
            ...policy,
            metadata: {
              ...policy.metadata,
              labels: {
                ...policy.metadata?.labels,
                'clerum.io/mcpserver': 'different-server',
              },
            },
          }
        })

        vi.clearAllMocks()
        serverCache.set(currentServer.name, currentServer)
        mockApi.listNamespacedNetworkPolicy.mockImplementation(
          async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
            if (labelSelector?.includes('external-egress')) return { items: [] }
            return {
              items: oldPolicies.filter(policy => policy.metadata?.namespace === namespace),
            }
          }
        )
        const onAuthoritativeRevocationComplete = vi.fn()

        await expect(
          rec.fullReconcile([liveContext], [currentServer], {
            ensureDefaults: false,
            contextInventoryAuthoritative: () => true,
            serverInventoryAuthoritative: () => true,
            onAuthoritativeRevocationComplete,
          })
        ).rejects.toThrow(/ownership/i)

        expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalledWith(
          expect.objectContaining({ namespace: targetNamespace })
        )
        expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      }
    )

    it('fails the safety pass without certifying when a same-name Context replacement fails', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const oldServer: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'live:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          transport: { type: 'streamableHttp', port: 4000 },
        },
      }
      const liveContext: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [oldServer.name] },
      }
      const serverCache = new Map([[oldServer.name, oldServer]])
      const rec = makeReconciler(mockApi, serverCache, mockCustomApi)

      await rec.reconcileContext(liveContext, { isCurrent: () => true })
      const oldPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.map(
        call => (call[0] as { body: k8s.V1NetworkPolicy }).body
      )

      vi.clearAllMocks()
      serverCache.set(currentServer.name, currentServer)
      mockApi.createNamespacedNetworkPolicy.mockRejectedValue(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (labelSelector?.includes('external-egress')) return { items: [] }
          return {
            items: oldPolicies.filter(policy => policy.metadata?.namespace === namespace),
          }
        }
      )
      const replacementFailure = new Error('replace unavailable')
      mockApi.replaceNamespacedNetworkPolicy.mockRejectedValueOnce(replacementFailure)
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        rec.fullReconcile([liveContext], [currentServer], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toBe(replacementFailure)

      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledWith(
        { outcome: 'failed' },
        expect.any(Number)
      )
      expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledTimes(1)
    })

    it('retains authoritative same-name policies when only API object key order differs', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const server: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'live:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const liveContext: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [server.name] },
      }
      const rec = makeReconciler(mockApi, new Map([[server.name, server]]), mockCustomApi)
      const reverseObjectKeys = (value: unknown): unknown => {
        if (Array.isArray(value)) return value.map(reverseObjectKeys)
        if (value === null || typeof value !== 'object') return value
        return Object.fromEntries(
          Object.entries(value as Record<string, unknown>)
            .reverse()
            .map(([key, entry]) => [key, reverseObjectKeys(entry)])
        )
      }

      await rec.reconcileContext(liveContext, { isCurrent: () => true })
      const existingPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.map(call => {
        const policy = (call[0] as { body: k8s.V1NetworkPolicy }).body
        return { ...policy, spec: reverseObjectKeys(policy.spec) as k8s.V1NetworkPolicySpec }
      })
      vi.clearAllMocks()
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (labelSelector?.includes('external-egress')) return { items: [] }
          return {
            items: existingPolicies.filter(policy => policy.metadata?.namespace === namespace),
          }
        }
      )
      vi.spyOn(rec, 'reconcileContext').mockResolvedValue(true)
      vi.spyOn(rec, 'reconcileExternalEgress').mockResolvedValue(undefined)

      await rec.fullReconcile([liveContext], [server], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
      })

      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('revokes same-name DNS egress before certifying and leaves refresh to its coordinator', async () => {
      const oldServer: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'live:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443, protocol: 'TCP' }],
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          egressBindings: [{ dns: 'api.example.com', port: 443, protocol: 'UDP' }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[oldServer.name, oldServer]]), mockCustomApi)

      await rec.reconcileExternalEgress(oldServer, { isCurrent: () => true })
      const oldPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')
      expect(oldPolicy).toBeDefined()

      vi.clearAllMocks()
      const ordering: string[] = []
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: [oldPolicy!] } : { items: [] }
      )
      mockApi.createNamespacedNetworkPolicy.mockRejectedValue(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('replace')
        return {}
      })
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('delete')
        return {}
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        ordering.push('certify')
      })

      await rec.fullReconcile([], [currentServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(ordering.slice(0, 2)).toEqual(['delete', 'certify'])
      expect(ordering).not.toContain('replace')
      expect(dns.resolve4).not.toHaveBeenCalled()
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it('revokes a divergent same-name DNS policy when its safe replacement cannot resolve', async () => {
      const oldServer: McpServerCRD = {
        name: 'live-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'live:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443, protocol: 'TCP' }],
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          egressBindings: [{ dns: 'api.example.com', port: 443, protocol: 'UDP' }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[oldServer.name, oldServer]]), mockCustomApi)

      await rec.reconcileExternalEgress(oldServer, { isCurrent: () => true })
      const oldPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')
      expect(oldPolicy).toBeDefined()

      vi.clearAllMocks()
      const ordering: string[] = []
      vi.mocked(dns.resolve4).mockImplementation(async () => {
        ordering.push('dns')
        throw new Error('dns unavailable')
      })
      let currentPolicies = [oldPolicy!]
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: currentPolicies } : { items: [] }
      )
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('delete')
        currentPolicies = []
        return {}
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        ordering.push('certify')
      })

      await expect(
        rec.fullReconcile([], [currentServer], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).resolves.toBeUndefined()

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: oldPolicy!.metadata!.name!,
          namespace: oldServer.namespace,
        })
      )
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      expect(dns.resolve4).not.toHaveBeenCalled()
      expect(ordering).toEqual(['delete', 'certify'])
    })

    it('revokes a renamed DNS binding before certification and performs no DNS lookup on the safety path', async () => {
      const oldServer: McpServerCRD = {
        name: 'renamed-dns-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'dns:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'old.example.com', port: 443 }],
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          egressBindings: [{ dns: 'new.example.com', port: 443 }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[oldServer.name, oldServer]]), mockCustomApi)
      await rec.reconcileExternalEgress(oldServer, { isCurrent: () => true })
      const oldPolicy = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')!

      vi.clearAllMocks()
      const ordering: string[] = []
      let currentPolicies = [oldPolicy]
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: currentPolicies } : { items: [] }
      )
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async ({ name }) => {
        ordering.push('delete')
        currentPolicies = currentPolicies.filter(policy => policy.metadata?.name !== name)
        return {}
      })
      vi.mocked(dns.resolve4).mockImplementation(async () => {
        ordering.push('dns')
        return ['1.2.3.4']
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        expect(dns.resolve4).not.toHaveBeenCalled()
        ordering.push('certify')
      })

      await rec.fullReconcile([], [currentServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(ordering).toEqual(['delete', 'certify'])
      expect(dns.resolve4).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith({
        name: oldPolicy.metadata!.name!,
        namespace: oldServer.namespace,
        body: {
          preconditions: {
            uid: `${oldServer.namespace}:${oldPolicy.metadata!.name!}:uid`,
            resourceVersion: '1',
          },
        },
      })
    })

    it('replaces deterministic drift and revokes renamed DNS before certification without resolving DNS', async () => {
      const oldServer: McpServerCRD = {
        name: 'mixed-drift-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'mixed:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [
            { cidr: '8.8.8.8/32', port: 443, protocol: 'TCP' },
            { dns: 'old.example.com', port: 443, protocol: 'TCP' },
          ],
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          egressBindings: [
            { cidr: '8.8.8.8/32', port: 443, protocol: 'UDP' },
            { dns: 'new.example.com', port: 443, protocol: 'TCP' },
          ],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[oldServer.name, oldServer]]), mockCustomApi)
      await rec.reconcileExternalEgress(oldServer, { isCurrent: () => true })
      const oldPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .filter(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')

      vi.clearAllMocks()
      const ordering: string[] = []
      let currentPolicies = oldPolicies
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: currentPolicies } : { items: [] }
      )
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('replace')
        return {}
      })
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async ({ name }) => {
        ordering.push('delete')
        currentPolicies = currentPolicies.filter(policy => policy.metadata?.name !== name)
        return {}
      })
      vi.mocked(dns.resolve4).mockImplementation(async () => {
        ordering.push('dns')
        return ['1.2.3.4']
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        expect(dns.resolve4).not.toHaveBeenCalled()
        ordering.push('certify')
      })

      await rec.fullReconcile([], [currentServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(ordering).toEqual(['replace', 'delete', 'certify'])
      expect(dns.resolve4).not.toHaveBeenCalled()
    })

    it('aborts certification when an identity-drifted safety delete reports a recreate conflict', async () => {
      const server: McpServerCRD = {
        name: 'recreated-dns-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'dns:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443 }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[server.name, server]]), mockCustomApi)
      await rec.reconcileExternalEgress(server, { isCurrent: () => true })
      const existing = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')!
      // B3: identity-drift the live policy (protocol TCP→UDP) so the safety pass
      // still revokes it. A same-intent (identity-stable) DNS allow is now
      // RETAINED (see the retention pins in the B3 describe block); the revoke /
      // abort machinery this test guards fires only for a drifted policy.
      existing.spec!.egress = existing.spec!.egress!.map(rule => ({
        ...rule,
        ports: rule.ports?.map(port => ({ ...port, protocol: 'UDP' })),
      }))

      vi.clearAllMocks()
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: [existing] } : { items: [] }
      )
      const conflict = Object.assign(new Error('delete precondition conflict'), { code: 409 })
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValue(conflict)
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        rec.fullReconcile([], [server], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toBe(conflict)

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith({
        name: existing.metadata!.name!,
        namespace: server.namespace,
        body: {
          preconditions: {
            uid: `${server.namespace}:${existing.metadata!.name!}:uid`,
            resourceVersion: '1',
          },
        },
      })
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it.each([
      [
        'foreign relabel',
        {
          labels: {
            'clerum.io/managed-by': 'foreign-controller',
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': 'fresh-read-server',
          },
        },
      ],
      ['UID drift', { uid: 'replacement-uid' }],
      ['resourceVersion drift', { resourceVersion: '2' }],
    ])(
      'aborts a deterministic safety replace after fresh-read %s',
      async (_case, metadataDrift) => {
        const oldServer: McpServerCRD = {
          name: 'fresh-read-server',
          namespace: 'mcp-server',
          spec: {
            contextRef: 'default',
            image: 'fresh:test',
            transport: { type: 'streamableHttp', port: 3000 },
            egressBindings: [{ cidr: '8.8.8.8/32', port: 443, protocol: 'TCP' }],
          },
        }
        const currentServer: McpServerCRD = {
          ...oldServer,
          spec: {
            ...oldServer.spec,
            egressBindings: [{ cidr: '8.8.8.8/32', port: 443, protocol: 'UDP' }],
          },
        }
        const rec = makeReconciler(mockApi, new Map([[oldServer.name, oldServer]]), mockCustomApi)
        await rec.reconcileExternalEgress(oldServer, { isCurrent: () => true })
        const existing = mockApi.createNamespacedNetworkPolicy.mock.calls
          .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
          .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')!

        vi.clearAllMocks()
        mockApi.listNamespacedNetworkPolicy.mockImplementation(
          async ({ labelSelector }: { labelSelector?: string }) =>
            labelSelector?.includes('external-egress') ? { items: [existing] } : { items: [] }
        )
        mockApi.readNamespacedNetworkPolicy.mockResolvedValue({
          metadata: {
            ...metadataDrift,
          },
        })
        const onAuthoritativeRevocationComplete = vi.fn()

        await expect(
          rec.fullReconcile([], [currentServer], {
            ensureDefaults: false,
            contextInventoryAuthoritative: () => true,
            serverInventoryAuthoritative: () => true,
            onAuthoritativeRevocationComplete,
          })
        ).rejects.toThrow(/ownership/)

        expect(mockApi.readNamespacedNetworkPolicy).toHaveBeenCalledWith({
          name: existing.metadata!.name!,
          namespace: oldServer.namespace,
        })
        expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
        expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      }
    )

    it('uses the fresh identity to complete a deterministic safety replacement before certification', async () => {
      const oldServer: McpServerCRD = {
        name: 'fresh-success-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'fresh:test',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ cidr: '8.8.8.8/32', port: 443, protocol: 'TCP' }],
        },
      }
      const currentServer: McpServerCRD = {
        ...oldServer,
        spec: {
          ...oldServer.spec,
          egressBindings: [{ cidr: '8.8.8.8/32', port: 443, protocol: 'UDP' }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[oldServer.name, oldServer]]), mockCustomApi)
      await rec.reconcileExternalEgress(oldServer, { isCurrent: () => true })
      const existing = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')!

      vi.clearAllMocks()
      const ordering: string[] = []
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: [existing] } : { items: [] }
      )
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('read')
        return { metadata: { resourceVersion: '1' } }
      })
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(async () => {
        ordering.push('replace')
        return {}
      })
      const onAuthoritativeRevocationComplete = vi.fn(() => ordering.push('certify'))

      await rec.fullReconcile([], [currentServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(ordering.slice(0, 3)).toEqual(['read', 'replace', 'certify'])
      expect(mockApi.replaceNamespacedNetworkPolicy).toHaveBeenCalledWith({
        name: existing.metadata!.name!,
        namespace: oldServer.namespace,
        body: expect.objectContaining({
          metadata: expect.objectContaining({
            name: existing.metadata!.name!,
            namespace: oldServer.namespace,
            resourceVersion: '1',
          }),
          spec: expect.objectContaining({
            egress: expect.arrayContaining([
              expect.objectContaining({
                ports: [expect.objectContaining({ protocol: 'UDP' })],
              }),
            ]),
          }),
        }),
      })
    })

    it('revokes an identity-drifted DNS policy before readiness and defers its refresh', async () => {
      const server: McpServerCRD = {
        name: 'stable-dns-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'stable:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443, protocol: 'TCP' }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[server.name, server]]), mockCustomApi)
      await rec.reconcileExternalEgress(server, { isCurrent: () => true })
      const existing = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')
      expect(existing).toBeDefined()
      // B3: identity-drift (protocol TCP→UDP) so this policy is revoked; a
      // same-intent DNS allow is now retained. The revoke-before-readiness +
      // defer-refresh machinery this test guards still fires on the drifted one.
      existing!.spec!.egress = existing!.spec!.egress!.map(rule => ({
        ...rule,
        ports: rule.ports?.map(port => ({ ...port, protocol: 'UDP' })),
      }))

      vi.clearAllMocks()
      let currentPolicies = [existing!]
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: currentPolicies } : { items: [] }
      )
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async () => {
        currentPolicies = []
        return {}
      })
      const onAuthoritativeRevocationComplete = vi.fn()

      await rec.fullReconcile([], [server], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })
      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: existing!.metadata!.name!,
          namespace: server.namespace,
        })
      )
      expect(dns.resolve4).not.toHaveBeenCalled()
    })

    it('does not certify safety when an identity-drifted DNS policy cannot be revoked', async () => {
      const server: McpServerCRD = {
        name: 'undeletable-dns-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'stable:latest',
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ dns: 'api.example.com', port: 443, protocol: 'TCP' }],
        },
      }
      const rec = makeReconciler(mockApi, new Map([[server.name, server]]), mockCustomApi)
      await rec.reconcileExternalEgress(server, { isCurrent: () => true })
      const existing = mockApi.createNamespacedNetworkPolicy.mock.calls
        .map(call => (call[0] as { body: k8s.V1NetworkPolicy }).body)
        .find(policy => policy.metadata?.labels?.['clerum.io/policy-type'] === 'external-egress')
      expect(existing).toBeDefined()
      // B3: identity-drift (protocol TCP→UDP) so this policy is revoked; a
      // same-intent DNS allow is now retained. The no-certify-when-revoke-fails
      // machinery this test guards still fires on the drifted one.
      existing!.spec!.egress = existing!.spec!.egress!.map(rule => ({
        ...rule,
        ports: rule.ports?.map(port => ({ ...port, protocol: 'UDP' })),
      }))

      vi.clearAllMocks()
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) =>
          labelSelector?.includes('external-egress') ? { items: [existing!] } : { items: [] }
      )
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValue(new Error('delete denied'))
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        rec.fullReconcile([], [server], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow('delete denied')

      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: existing!.metadata!.name!,
          namespace: server.namespace,
        })
      )
    })

    it('does not certify revocation when an earlier Context changes while a later owner is paused', async () => {
      const contexts: ContextCRD[] = ['first', 'later'].map(contextId => ({
        name: `${contextId}-resource`,
        namespace: 'mcp-server',
        spec: { contextId, mcpServers: [] },
      }))
      const currentContexts = new Map(contexts.map(context => [context.name, context]))
      let contextDesiredRevision = 10
      let laterPaused = false
      const laterStarted = deferred()
      const releaseLater = deferred()
      const onAuthoritativeRevocationComplete = vi.fn()

      const fullPass = reconciler.fullReconcile(contexts, [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        resolveCurrentContext: name => currentContexts.get(name),
        runContextEffect: async (contextId, work) => {
          if (contextId === 'later' && !laterPaused) {
            laterPaused = true
            laterStarted.resolve(undefined)
            await releaseLater.promise
          }
          await work()
        },
        contextDesiredRevision: () => contextDesiredRevision,
        onAuthoritativeRevocationComplete,
      })

      await laterStarted.promise
      currentContexts.set('first-resource', {
        ...contexts[0],
        spec: { ...contexts[0].spec, mcpServers: ['replacement'] },
      })
      contextDesiredRevision += 1
      releaseLater.resolve(undefined)

      await expect(fullPass).rejects.toThrow(/desired NetworkPolicy inventory changed/i)
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('does not certify revocation when a new owner is added after the global inventory LISTs', async () => {
      const anchorContext: ContextCRD = {
        name: 'anchor-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'anchor', mcpServers: [] },
      }
      const currentContexts = new Map([[anchorContext.name, anchorContext]])
      let contextDesiredRevision = 21
      const safetyEffectStarted = deferred()
      const releaseSafetyEffect = deferred()
      let safetyEffectPaused = false
      const onAuthoritativeRevocationComplete = vi.fn()

      const fullPass = reconciler.fullReconcile([anchorContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        resolveCurrentContext: name => currentContexts.get(name),
        runContextEffect: async (_contextId, work) => {
          if (!safetyEffectPaused) {
            safetyEffectPaused = true
            safetyEffectStarted.resolve(undefined)
            await releaseSafetyEffect.promise
          }
          await work()
        },
        contextDesiredRevision: () => contextDesiredRevision,
        onAuthoritativeRevocationComplete,
      })

      await safetyEffectStarted.promise
      currentContexts.set('late-resource', {
        name: 'late-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'late', mcpServers: [] },
      })
      contextDesiredRevision += 1
      releaseSafetyEffect.resolve(undefined)

      await expect(fullPass).rejects.toThrow(/desired NetworkPolicy inventory changed/i)
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('does not certify revocation when a new McpServer owner is added after inventory LISTs', async () => {
      const anchorServer: McpServerCRD = {
        name: 'anchor-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'anchor:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      const currentServers = new Map([[anchorServer.name, anchorServer]])
      let serverDesiredRevision = 31
      const safetyEffectStarted = deferred()
      const releaseSafetyEffect = deferred()
      let safetyEffectPaused = false
      const onAuthoritativeRevocationComplete = vi.fn()

      const fullPass = reconciler.fullReconcile([], [anchorServer], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        resolveCurrentServer: name => currentServers.get(name),
        runServerEffect: async (_serverName, work) => {
          if (!safetyEffectPaused) {
            safetyEffectPaused = true
            safetyEffectStarted.resolve(undefined)
            await releaseSafetyEffect.promise
          }
          await work()
        },
        serverDesiredRevision: () => serverDesiredRevision,
        onAuthoritativeRevocationComplete,
      })

      await safetyEffectStarted.promise
      currentServers.set('late-server', {
        name: 'late-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: 'late:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      })
      serverDesiredRevision += 1
      releaseSafetyEffect.resolve(undefined)

      await expect(fullPass).rejects.toThrow(/desired NetworkPolicy inventory changed/i)
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('does not certify revocation when desired inventory changes while default policies are ensured', async () => {
      const context: ContextCRD = {
        name: 'default-window-context',
        namespace: 'mcp-server',
        spec: { contextId: 'default-window', mcpServers: [] },
      }
      const server: McpServerCRD = {
        name: 'default-window-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default-window',
          image: 'default-window:latest',
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }
      let contextDesiredRevision = 41
      let serverDesiredRevision = 51
      const defaultsStarted = deferred()
      const releaseDefaults = deferred()
      const onAuthoritativeRevocationComplete = vi.fn()
      vi.spyOn(reconciler, 'ensureDefaultPolicies').mockImplementation(async () => {
        defaultsStarted.resolve(undefined)
        await releaseDefaults.promise
      })

      const fullPass = reconciler.fullReconcile([context], [server], {
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        contextDesiredRevision: () => contextDesiredRevision,
        serverDesiredRevision: () => serverDesiredRevision,
        onAuthoritativeRevocationComplete,
      })

      await defaultsStarted.promise
      contextDesiredRevision += 1
      serverDesiredRevision += 1
      releaseDefaults.resolve(undefined)

      await expect(fullPass).rejects.toThrow(/desired NetworkPolicy inventory changed/i)
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('does not signal authoritative revocation when a live-owner delete fails', async () => {
      const liveContext: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [] },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-live-context-removed-server',
                    labels: { 'clerum.io/context': 'live-context' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(
        new Error('policy delete unavailable')
      )
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([liveContext], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow('policy delete unavailable')
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('does not delete or signal revocation after live Context authority is lost', async () => {
      const liveContext: ContextCRD = {
        name: 'live-context-resource',
        namespace: 'mcp-server',
        spec: { contextId: 'live-context', mcpServers: [] },
      }
      let authoritative = true
      const inventoryListed = deferred()
      const releaseInventory = deferred<{ items: k8s.V1NetworkPolicy[] }>()
      mockApi.listNamespacedNetworkPolicy.mockImplementationOnce(async () => {
        inventoryListed.resolve(undefined)
        return releaseInventory.promise
      })
      const onAuthoritativeRevocationComplete = vi.fn()

      const fullPass = reconciler.fullReconcile([liveContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => authoritative,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })
      await inventoryListed.promise
      authoritative = false
      releaseInventory.resolve({
        items: [
          {
            metadata: {
              name: 'ctx-live-context-removed-server',
              labels: { 'clerum.io/context': 'live-context' },
            },
          },
        ],
      })

      await expect(fullPass).rejects.toThrow(
        'One or more additive Context NetworkPolicy reconciliations failed'
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('uses selected lane LISTs plus one broad LIST per bounded namespace before additive convergence', async () => {
      const contexts: ContextCRD[] = ['alpha', 'beta', 'gamma'].map(contextId => ({
        name: `${contextId}-resource`,
        namespace: 'mcp-server',
        spec: { contextId, mcpServers: [] },
      }))
      const servers: McpServerCRD[] = ['one', 'two'].map(name => ({
        name,
        namespace: 'mcp-server',
        spec: {
          contextRef: 'default',
          image: `${name}:latest`,
          transport: { type: 'streamableHttp', port: 3000 },
        },
      }))
      const additiveStarted = deferred()
      const releaseAdditive = deferred()
      vi.spyOn(reconciler, 'reconcileContext').mockImplementationOnce(async () => {
        additiveStarted.resolve(undefined)
        await releaseAdditive.promise
        return true
      })
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({ items: [] })

      const fullPass = reconciler.fullReconcile(contexts, servers, {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
      })

      await additiveStarted.promise
      try {
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledTimes(7)
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'mcp-server',
          labelSelector: expect.stringContaining('policy-type=context-allow'),
        })
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'mcp-host',
          labelSelector: expect.stringContaining('policy-type=context-allow'),
        })
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'rpc-proxy',
          labelSelector: expect.stringContaining('policy-type=rpc-proxy-egress'),
        })
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'mcp-server',
          labelSelector: expect.stringContaining('policy-type=external-egress'),
        })
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'mcp-server',
        })
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'mcp-host',
        })
        expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith({
          namespace: 'rpc-proxy',
        })
      } finally {
        releaseAdditive.resolve(undefined)
        await fullPass
      }
    })

    it('leaves startup external egress creation to its dedicated coordinator', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      const server: McpServerCRD = {
        name: 'airtable-mcp',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'dev',
          image: 'airtable:latest',
          transport: { type: 'streamableHttp', url: 'http://airtable:3000', port: 3000 },
          egressBindings: [{ dns: 'api.airtable.com', port: 443 }],
        },
      }

      await reconciler.fullReconcile([], [server])

      const externalPolicies = mockApi.createNamespacedNetworkPolicy.mock.calls.filter(
        (call: unknown[]) => {
          const arg = call[0] as { body: { metadata: { labels: Record<string, string> } } }
          return arg.body.metadata.labels['clerum.io/policy-type'] === 'external-egress'
        }
      )
      expect(externalPolicies).toHaveLength(0)
      expect(dns.resolve4).not.toHaveBeenCalled()
    })

    it('deletes orphaned external egress policies for servers no longer present', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) => {
          if (labelSelector?.includes('context-allow')) return { items: [] }
          if (labelSelector?.includes('rpc-proxy-egress')) return { items: [] }
          if (labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-old-server-api-example-com-443',
                    labels: { 'clerum.io/mcpserver': 'old-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], { serverInventoryComplete: true })

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'ext-egress-old-server-api-example-com-443',
          namespace: 'mcp-server',
        })
      )
    })

    it('fails closed by deleting HCC-managed policies with missing owner labels', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          const managedLabels = { 'clerum.io/managed-by': 'host-context-controller' }
          if (labelSelector?.includes('policy-type=context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name:
                      namespace === 'mcp-host'
                        ? 'malformed-host-egress'
                        : 'malformed-context-ingress',
                    labels: managedLabels,
                  },
                },
              ],
            }
          }
          if (labelSelector?.includes('rpc-proxy-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'malformed-rpc-proxy-egress',
                    labels: managedLabels,
                  },
                },
              ],
            }
          }
          if (labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'malformed-external-egress',
                    labels: managedLabels,
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], {
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        serverInventoryComplete: true,
      })

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'malformed-context-ingress',
          namespace: 'mcp-server',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'malformed-host-egress',
          namespace: 'mcp-host',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'malformed-rpc-proxy-egress',
          namespace: 'rpc-proxy',
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          name: 'malformed-external-egress',
          namespace: 'mcp-server',
        })
      )
    })

    it('skips external egress orphan cleanup when startup server discovery is incomplete', async () => {
      // Bootstrap this scenario without policies; later LIST fixtures supply existing objects.
      mockApi.readNamespacedNetworkPolicy.mockRejectedValue({ code: 404 })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) => {
          if (labelSelector?.includes('context-allow')) return { items: [] }
          if (labelSelector?.includes('rpc-proxy-egress')) return { items: [] }
          if (labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-old-server-api-example-com-443',
                    labels: { 'clerum.io/mcpserver': 'old-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], { serverInventoryComplete: false })

      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalledWith({
        name: 'ext-egress-old-server-api-example-com-443',
        namespace: 'mcp-server',
      })
    })

    it('finishes desired Context reconciliation but stops Context and rpc-proxy orphan cleanup when authority is lost after inventory listing', async () => {
      const desiredContext: ContextCRD = {
        name: 'current',
        namespace: 'mcp-server',
        spec: { contextId: 'current', mcpServers: [] },
      }
      const reconcileContext = vi.spyOn(reconciler, 'reconcileContext').mockResolvedValue(true)
      const contextInventoryAuthoritative = vi
        .fn()
        .mockReturnValueOnce(true)
        .mockReturnValueOnce(false)
        .mockReturnValue(true)

      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('policy-type=context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-deleted-context-old-server',
                    labels: { 'clerum.io/context': 'deleted-context' },
                  },
                },
              ],
            }
          }
          if (labelSelector?.includes('external-egress')) return { items: [] }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([desiredContext], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative,
      })

      expect(reconcileContext).toHaveBeenCalledWith(desiredContext, {
        isCurrent: expect.any(Function),
      })
      expect(contextInventoryAuthoritative).toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalledWith({
        name: 'ctx-deleted-context-old-server',
        namespace: 'mcp-server',
      })
      expect(mockApi.listNamespacedNetworkPolicy).not.toHaveBeenCalledWith(
        expect.objectContaining({
          namespace: 'rpc-proxy',
          labelSelector: expect.stringContaining('policy-type=rpc-proxy-egress'),
        })
      )
    })

    it('stops external-egress orphan cleanup when authority is lost after inventory listing', async () => {
      const desiredServer: McpServerCRD = {
        name: 'current-server',
        namespace: 'mcp-server',
        spec: {
          contextRef: 'current',
          image: 'current:latest',
          transport: { type: 'streamableHttp', url: 'http://current:3000', port: 3000 },
        },
      }
      const serverInventoryAuthoritative = vi
        .fn()
        .mockReturnValueOnce(true)
        .mockReturnValueOnce(false)
        .mockReturnValue(true)

      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) => {
          if (labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-deleted-server-api-example-com-443',
                    labels: { 'clerum.io/mcpserver': 'deleted-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [desiredServer], {
        ensureDefaults: false,
        serverInventoryComplete: true,
        serverInventoryAuthoritative,
      })

      expect(serverInventoryAuthoritative).toHaveBeenCalled()
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalledWith({
        name: 'ext-egress-deleted-server-api-example-com-443',
        namespace: 'mcp-server',
      })
    })

    it('does not delete any Context policy lane when a same-contextId CRD exists before its watch event arrives', async () => {
      mockCustomApi.listNamespacedCustomObject.mockResolvedValue({
        items: [{ metadata: { name: 'recreated-context' }, spec: { contextId: 'recreated' } }],
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => {
          if (namespace === 'mcp-server' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-recreated-server',
                    labels: { 'clerum.io/context': 'recreated' },
                  },
                },
              ],
            }
          }
          if (namespace === 'mcp-host' && labelSelector?.includes('context-allow')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ctx-recreated-server-egress',
                    labels: { 'clerum.io/context': 'recreated' },
                  },
                },
              ],
            }
          }
          if (namespace === 'rpc-proxy' && labelSelector?.includes('rpc-proxy-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'rpc-egress-recreated-server',
                    labels: { 'clerum.io/context': 'recreated' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
      })

      expect(mockCustomApi.listNamespacedCustomObject).toHaveBeenCalled()
      expect(mockApi.listNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({
          namespace: 'mcp-host',
          labelSelector: expect.stringContaining('policy-type=context-allow'),
        })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('does not delete external-egress policy when a same-name McpServer exists before ADDED arrives', async () => {
      mockCustomApi.getNamespacedCustomObject.mockResolvedValue({
        metadata: { name: 'recreated-server', uid: 'new-uid' },
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) => {
          if (labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-recreated-server-api-example-com-443',
                    labels: { 'clerum.io/mcpserver': 'recreated-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        serverInventoryComplete: true,
        serverInventoryAuthoritative: () => true,
      })

      expect(mockCustomApi.getNamespacedCustomObject).toHaveBeenCalledWith(
        expect.objectContaining({ plural: 'mcpservers', name: 'recreated-server' })
      )
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('delegates startup McpServer orphan safety to the canonical absence helper', async () => {
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ labelSelector }: { labelSelector?: string }) => {
          if (labelSelector?.includes('external-egress')) {
            return {
              items: [
                {
                  metadata: {
                    name: 'ext-egress-orphan-server-api-example-com-443',
                    labels: { 'clerum.io/mcpserver': 'orphan-server' },
                  },
                },
              ],
            }
          }
          return { items: [] }
        }
      )

      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        serverInventoryComplete: true,
        serverInventoryAuthoritative: () => true,
      })

      expect(confirmAuthoritativeMcpServerAbsence).toHaveBeenCalledTimes(1)
      expect(confirmAuthoritativeMcpServerAbsence).toHaveBeenCalledWith({
        inventoryAuthoritative: expect.any(Function),
        resolveCurrent: expect.any(Function),
        readCurrent: expect.any(Function),
      })
    })
  })

  describe('L3 — cleanupExternalEgress', () => {
    it('deletes all external egress policies for a server', async () => {
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [{ metadata: { name: 'ext-egress-openai-mcp-api-443' } }],
      })

      await reconciler.cleanupExternalEgress('openai-mcp', 'mcp-server')

      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith({
        name: 'ext-egress-openai-mcp-api-443',
        namespace: 'mcp-server',
        body: {
          preconditions: {
            uid: 'mcp-server:ext-egress-openai-mcp-api-443:uid',
            resourceVersion: '1',
          },
        },
      })
    })

    it('fails closed when stale external egress policy deletion fails', async () => {
      const error = Object.assign(new Error('forbidden'), { code: 403 })
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [{ metadata: { name: 'ext-egress-openai-mcp-old-api-443' } }],
      })
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(error)

      await expect(reconciler.cleanupExternalEgress('openai-mcp', 'mcp-server')).rejects.toThrow(
        'forbidden'
      )
    })

    it('ignores NotFound when stale external egress policy is already gone', async () => {
      const error = Object.assign(new Error('not found'), { code: 404 })
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [{ metadata: { name: 'ext-egress-openai-mcp-old-api-443' } }],
      })
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(error)

      await expect(
        reconciler.cleanupExternalEgress('openai-mcp', 'mcp-server')
      ).resolves.toBeUndefined()
    })

    it('does not report a revocation when the policy was already absent', async () => {
      const error = Object.assign(new Error('not found'), { code: 404 })
      const onDeleted = vi.fn()
      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({
        items: [{ metadata: { name: 'ext-egress-openai-mcp-old-api-443' } }],
      })
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(error)

      await reconciler.cleanupExternalEgress(
        'openai-mcp',
        'mcp-server',
        undefined,
        undefined,
        onDeleted
      )

      expect(onDeleted).not.toHaveBeenCalled()
    })
  })

  describe('scoped delta certification vs. a stuck safety inventory', () => {
    const ambiguousReservedPolicy: k8s.V1NetworkPolicy = {
      metadata: { name: 'ctx-reserved-context-server', labels: {} },
      spec: { podSelector: {}, policyTypes: ['Ingress'] },
    }
    const deltaContext: ContextCRD = {
      name: 'default',
      namespace: 'mcp-server',
      spec: { contextId: 'default', mcpServers: [] },
    }

    function stickSafetyInventory(): void {
      // Only the namespace-wide safety inventory sees the foreign policy. The
      // label-scoped LISTs the delta lane uses stay clean, which is exactly why
      // the delta cannot vouch for the namespace.
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }: { namespace?: string; labelSelector?: string }) => ({
          items: !labelSelector && namespace === 'mcp-server' ? [ambiguousReservedPolicy] : [],
        })
      )
    }

    it('refuses to certify a scoped delta while the safety pass is stuck on its inventory', async () => {
      stickSafetyInventory()
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow(/Ambiguous NetworkPolicy ownership/)
      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()

      // The delta's own revocation still completes — its label-scoped LISTs are
      // clean. What it may not do is vouch for the namespace-wide inventory,
      // which the readiness lane checks separately.
      expect(await reconciler.reconcileContext(deltaContext, { isCurrent: () => true })).toBe(true)
      expect(reconciler.hasCertifiedSafetyInventory()).toBe(false)
    })

    it('certifies a scoped delta again once a later safety pass completes', async () => {
      stickSafetyInventory()
      await expect(
        reconciler.fullReconcile([], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete: vi.fn(),
        })
      ).rejects.toThrow(/Ambiguous NetworkPolicy ownership/)

      mockApi.listNamespacedNetworkPolicy.mockResolvedValue({ items: [] })
      const onAuthoritativeRevocationComplete = vi.fn()
      await reconciler.fullReconcile([], [], {
        ensureDefaults: false,
        contextInventoryAuthoritative: () => true,
        serverInventoryAuthoritative: () => true,
        onAuthoritativeRevocationComplete,
      })

      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      expect(await reconciler.reconcileContext(deltaContext, { isCurrent: () => true })).toBe(true)
      expect(reconciler.hasCertifiedSafetyInventory()).toBe(true)
    })

    it('does not certify the safety inventory until an authoritative pass has run', async () => {
      // Fail-closed default: before any authoritative safety pass certifies, the
      // namespace-wide inventory is NOT certified, even though the scoped delta's
      // own label-scoped revocation completes (returns true). A delta cannot
      // vouch for the namespace-wide inventory it never enumerated.
      expect(await reconciler.reconcileContext(deltaContext, { isCurrent: () => true })).toBe(true)
      expect(reconciler.hasCertifiedSafetyInventory()).toBe(false)
    })
  })

  describe('lost delete fence during stale-allow revocation', () => {
    const staleContext: ContextCRD = {
      name: 'default',
      namespace: 'mcp-server',
      spec: { contextId: 'default', mcpServers: [] },
    }
    const stalePolicy: k8s.V1NetworkPolicy = {
      metadata: {
        name: 'ctx-default-alpha',
        namespace: 'mcp-server',
        labels: {
          'clerum.io/managed-by': 'host-context-controller',
          'clerum.io/policy-type': 'context-allow',
          'clerum.io/context': 'default',
          'clerum.io/mcpserver': 'alpha',
        },
      },
      spec: { podSelector: {}, policyTypes: ['Ingress'] },
    }
    const lostFence = Object.assign(new Error('the UID in the precondition does not match'), {
      code: 409,
    })

    function listOnlyTheStalePolicy(): void {
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace }: { namespace?: string }) => ({
          items: namespace === 'mcp-server' ? [stalePolicy] : [],
        })
      )
    }

    it('refuses to certify a scoped delta instead of throwing the lost fence', async () => {
      listOnlyTheStalePolicy()
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(lostFence)

      // 409 is what Kubernetes returns when the uid/resourceVersion
      // preconditions no longer match: the object live under that name is not
      // the one this pass classified. Nothing was revoked, so the delta must
      // decline to certify — and it must not blow up the caller, which would
      // only force a spurious full re-convergence.
      // The scoped delta lane reads this boolean and withholds the certificate,
      // so it is the one caller allowed to take the lost fence as an outcome
      // rather than a throw.
      expect(
        await reconciler.reconcileContext(staleContext, {
          honorsLostFence: true,
          isCurrent: () => true,
        })
      ).toBe(false)
      expect(mockApi.deleteNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({ name: 'ctx-default-alpha', namespace: 'mcp-server' })
      )
    })

    it('withdraws certification when an additive revocation loses the fence after certifying', async () => {
      // The additive phase re-runs reconcileContext, which carries a second
      // revocation lane over a fresh LIST. Losing the fence there happens after
      // the pass already certified, and the outcome recorder is first-wins — so
      // the duration sample stays 'completed', which is right, but the safety
      // fence must still degrade. It is an assertion about live allows, and it
      // may only ever move toward unsafe.
      const additiveContext: ContextCRD = {
        name: 'additive',
        namespace: 'mcp-server',
        spec: { contextId: 'additive', mcpServers: [] },
      }
      const additiveStalePolicy: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'ctx-additive-alpha',
          namespace: 'mcp-server',
          labels: {
            'clerum.io/managed-by': 'host-context-controller',
            'clerum.io/policy-type': 'context-allow',
            'clerum.io/context': 'additive',
            'clerum.io/mcpserver': 'alpha',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Ingress'] },
      }
      // Self-synchronising: the stale policy only becomes visible once the pass
      // has already certified, so the safety phase is clean by construction and
      // only the additive re-LIST finds work.
      let certified = false
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace }: { namespace?: string }) => ({
          items: certified && namespace === 'mcp-server' ? [additiveStalePolicy] : [],
        })
      )
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValue(lostFence)
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        certified = true
      })

      await expect(
        reconciler.fullReconcile([additiveContext], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow()

      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      expect(reconciler.hasCertifiedSafetyInventory()).toBe(false)
    })

    it('marks the inventory uncertified the moment the authoritative pass loses the fence', async () => {
      // The doom must be visible mid-pass, not only after the unwind. A lost
      // fence is the one doom cause that does not bump a watch generation, so
      // it is the only one where the whole certification machinery stays green
      // while the pass is already condemned. A scoped delta interleaving in
      // that window would certify readiness over a stale allow.
      //
      // Two contexts, each with its own stale policy: the first loses the fence
      // and the second's delete gives an observation point while the pass is
      // condemned but still unwinding.
      const secondContext: ContextCRD = {
        name: 'second',
        namespace: 'mcp-server',
        spec: { contextId: 'second', mcpServers: [] },
      }
      const secondStalePolicy: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'ctx-second-beta',
          namespace: 'mcp-server',
          labels: {
            'clerum.io/managed-by': 'host-context-controller',
            'clerum.io/policy-type': 'context-allow',
            'clerum.io/context': 'second',
            'clerum.io/mcpserver': 'beta',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Ingress'] },
      }
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace }: { namespace?: string }) => ({
          items: namespace === 'mcp-server' ? [stalePolicy, secondStalePolicy] : [],
        })
      )
      let certifiedDuringUnwind: boolean | undefined
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(async () => {
        if (
          certifiedDuringUnwind === undefined &&
          mockApi.deleteNamespacedNetworkPolicy.mock.calls.length > 1
        ) {
          certifiedDuringUnwind = reconciler.hasCertifiedSafetyInventory()
          return {}
        }
        throw lostFence
      })

      await expect(
        reconciler.fullReconcile([staleContext, secondContext], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete: vi.fn(),
        })
      ).rejects.toThrow()

      expect(certifiedDuringUnwind).toBe(false)
    })

    it('fails the additive phase when it loses the delete fence', async () => {
      listOnlyTheStalePolicy()
      // Safety phase revokes cleanly and certifies; the additive phase then
      // races another writer and loses the fence. The additive caller discards
      // reconcileContext's boolean, so swallowing the 409 there would record
      // the pass as a success, disarm the convergence retry, and leave a stale
      // allow live with no NetworkPolicy resync to recover it.
      mockApi.deleteNamespacedNetworkPolicy
        .mockResolvedValueOnce({})
        .mockRejectedValueOnce(lostFence)
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([staleContext], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow()

      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
    })

    it('refuses to certify the safety pass instead of throwing the lost fence', async () => {
      listOnlyTheStalePolicy()
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(lostFence)
      const onAuthoritativeRevocationComplete = vi.fn()

      await expect(
        reconciler.fullReconcile([staleContext], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow(DESIRED_NETWORKPOLICY_INVENTORY_CHANGED_MESSAGE)

      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
    })

    it('still fails loud when the delete fails for any other reason', async () => {
      listOnlyTheStalePolicy()
      const forbidden = Object.assign(new Error('forbidden'), { code: 403 })
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(forbidden)

      await expect(
        reconciler.reconcileContext(staleContext, { isCurrent: () => true })
      ).rejects.toBe(forbidden)
    })

    it('still certifies when the stale policy was already gone', async () => {
      listOnlyTheStalePolicy()
      mockApi.deleteNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('not found'), { code: 404 })
      )

      expect(await reconciler.reconcileContext(staleContext, { isCurrent: () => true })).toBe(true)
    })
  })

  describe('same-name conflict creating a safety external-egress policy', () => {
    const server: McpServerCRD = {
      name: 'renamed-server',
      namespace: 'mcp-server',
      spec: {
        contextRef: 'default',
        image: 'renamed:latest',
        transport: { type: 'streamableHttp', port: 3000 },
        egressBindings: [{ cidr: '104.18.0.0/16', port: 443 }],
      },
    }
    const desiredName = 'ext-egress-renamed-server-104-18-0-0-16-443'
    const stalePredecessor: k8s.V1NetworkPolicy = {
      metadata: {
        name: 'ext-egress-renamed-server-stale',
        namespace: 'mcp-server',
        uid: 'stale-uid',
        resourceVersion: '3',
      },
    }

    function reconcileExternalEgressSafety(): Promise<boolean> {
      return (
        reconciler as unknown as {
          reconcileExternalEgressSafety: (
            server: McpServerCRD,
            existingPolicies: k8s.V1NetworkPolicy[],
            isCurrent: () => boolean
          ) => Promise<boolean>
        }
      ).reconcileExternalEgressSafety(server, [stalePredecessor], () => true)
    }

    it('BYPASS-NP-1: equivalent HCC-owned recorded policy skips replace', async () => {
      const binding = server.spec.egressBindings![0]
      const desired = (
        reconciler as unknown as {
          buildExactHostEgressPolicy: (
            server: McpServerCRD,
            name: string,
            binding: { cidr?: string; port?: number; protocol?: string },
            cidrs: string[]
          ) => k8s.V1NetworkPolicy
        }
      ).buildExactHostEgressPolicy(server, desiredName, binding, ['104.18.0.0/16'])
      mockApi.createNamespacedNetworkPolicy.mockRejectedValue(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValue(asApiserverNetworkPolicy(desired))

      expect(await reconcileExternalEgressSafety()).toBe(true)
      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalled()
      expect(mockApi.readNamespacedNetworkPolicy).toHaveBeenCalled()
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('converges an HCC-owned same-name policy instead of aborting the pass', async () => {
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValueOnce({
        metadata: {
          name: desiredName,
          namespace: server.namespace,
          uid: 'own-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'host-context-controller',
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': server.name,
          },
        },
      })

      // This is the only creation route that bypasses applyNetworkPolicy. A
      // same-name object HCC already owns is an idempotent re-run, not a
      // reason to fail the pass and hold readiness down.
      expect(await reconcileExternalEgressSafety()).toBe(true)
      expect(mockApi.replaceNamespacedNetworkPolicy).toHaveBeenCalledWith(
        expect.objectContaining({ name: desiredName, namespace: server.namespace })
      )
    })

    it('still fails closed when the same-name policy is foreign', async () => {
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(
        Object.assign(new Error('already exists'), { code: 409 })
      )
      mockApi.readNamespacedNetworkPolicy.mockResolvedValueOnce({
        metadata: {
          name: desiredName,
          namespace: server.namespace,
          uid: 'foreign-uid',
          resourceVersion: '7',
          labels: {
            'clerum.io/managed-by': 'foreign-controller',
            'clerum.io/policy-type': 'external-egress',
            'clerum.io/mcpserver': server.name,
          },
        },
      })

      await expect(reconcileExternalEgressSafety()).rejects.toThrow(/ownership/i)
      expect(mockApi.replaceNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('still fails loud when the create fails for any other reason', async () => {
      const forbidden = Object.assign(new Error('forbidden'), { code: 403 })
      mockApi.createNamespacedNetworkPolicy.mockRejectedValueOnce(forbidden)

      await expect(reconcileExternalEgressSafety()).rejects.toBe(forbidden)
    })
  })

  describe('safety-pass duration on the uncertified return path', () => {
    it('samples a failed outcome when the pass returns without certifying', async () => {
      const onAuthoritativeRevocationComplete = vi.fn()

      // Losing inventory authority ends the pass without an exception and
      // without certifying. Operators alert on "the pass never completed", so
      // this path has to produce a `failed` sample — absence is not a signal.
      await expect(
        reconciler.fullReconcile([], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => false,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).resolves.toBeUndefined()

      expect(onAuthoritativeRevocationComplete).not.toHaveBeenCalled()
      expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledWith(
        { outcome: 'failed' },
        expect.any(Number)
      )
      expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledTimes(1)
    })

    it('keeps the completed sample when a certified pass fails an additive effect afterwards', async () => {
      const context: ContextCRD = {
        name: 'default',
        namespace: 'mcp-server',
        spec: { contextId: 'default', mcpServers: [] },
      }
      const additiveFailure = new Error('additive list unavailable')
      let certified = false
      const onAuthoritativeRevocationComplete = vi.fn(() => {
        certified = true
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(async () => {
        if (certified) throw additiveFailure
        return { items: [] }
      })

      await expect(
        reconciler.fullReconcile([context], [], {
          ensureDefaults: false,
          contextInventoryAuthoritative: () => true,
          serverInventoryAuthoritative: () => true,
          onAuthoritativeRevocationComplete,
        })
      ).rejects.toThrow(/additive Context NetworkPolicy reconciliations failed/)

      expect(onAuthoritativeRevocationComplete).toHaveBeenCalledOnce()
      expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledWith(
        { outcome: 'completed' },
        expect.any(Number)
      )
      expect(networkPolicySafetyPassDurationSeconds.observe).toHaveBeenCalledTimes(1)
    })
  })

  describe('defaults-only write set vs typed sweep (#488)', () => {
    const CONTEXT_LABEL = 'clerum.io/context'
    const TYPED_SWEEP_TYPES = new Set(['context-allow', 'rpc-proxy-egress', 'external-egress'])

    function policyMatchesLabelSelector(
      policy: k8s.V1NetworkPolicy,
      selector: string | undefined
    ): boolean {
      if (!selector) return true
      const labels = policy.metadata?.labels ?? {}
      return selector.split(',').every(clause => {
        const trimmed = clause.trim()
        const eq = trimmed.indexOf('=')
        if (eq < 0) return false
        return labels[trimmed.slice(0, eq)] === trimmed.slice(eq + 1)
      })
    }

    it('ensureDefaultPolicies writes a {name, policy-type} set the typed sweep does not list or delete', async () => {
      const store = new Map<string, k8s.V1NetworkPolicy>()
      const deleted: string[] = []

      mockApi.createNamespacedNetworkPolicy.mockImplementation(
        async (args: { namespace: string; body: k8s.V1NetworkPolicy }) => {
          const name = args.body.metadata?.name
          if (!name) throw new Error('create is missing metadata.name')
          const key = `${args.namespace}/${name}`
          const stored: k8s.V1NetworkPolicy = {
            ...args.body,
            metadata: {
              ...args.body.metadata,
              name,
              namespace: args.namespace,
              uid: key,
              resourceVersion: '1',
            },
          }
          store.set(key, stored)
          return stored
        }
      )
      mockApi.readNamespacedNetworkPolicy.mockImplementation(
        async (args: { name: string; namespace: string }) => {
          const existing = store.get(`${args.namespace}/${args.name}`)
          if (!existing) {
            throw Object.assign(new Error('not found'), { code: 404 })
          }
          return existing
        }
      )
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async (args: { namespace: string; labelSelector?: string }) => ({
          items: [...store.values()].filter(
            policy =>
              policy.metadata?.namespace === args.namespace &&
              policyMatchesLabelSelector(policy, args.labelSelector)
          ),
        })
      )
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(
        async (args: { name: string; namespace: string }) => {
          const key = `${args.namespace}/${args.name}`
          deleted.push(key)
          store.delete(key)
          return {}
        }
      )
      mockCustomApi.listNamespacedCustomObject.mockResolvedValue({ items: [] })

      await reconciler.ensureDefaultPolicies()
      expect(store.size).toBeGreaterThan(0)
      const written = [...store.values()].map(policy => ({
        key: `${policy.metadata?.namespace}/${policy.metadata?.name}`,
        name: policy.metadata?.name ?? '',
        type: policy.metadata?.labels?.[POLICY_TYPE_LABEL] ?? '',
      }))
      expect(written.every(item => !TYPED_SWEEP_TYPES.has(item.type))).toBe(true)
      expect(new Set(written.map(item => item.type))).toEqual(
        new Set(['allow-api', 'default-deny', 'infrastructure'])
      )

      const orphanKey = `${config.namespace}/ctx-gone-allow`
      store.set(orphanKey, {
        apiVersion: 'networking.k8s.io/v1',
        kind: 'NetworkPolicy',
        metadata: {
          name: 'ctx-gone-allow',
          namespace: config.namespace,
          uid: orphanKey,
          resourceVersion: '1',
          labels: {
            [MANAGED_BY_LABEL]: MANAGED_BY_VALUE,
            [POLICY_TYPE_LABEL]: 'context-allow',
            [CONTEXT_LABEL]: 'ctx-gone',
            [MCPSERVER_LABEL]: 'srv-gone',
          },
        },
        spec: { podSelector: {}, policyTypes: ['Ingress'] },
      })

      await reconciler.fullReconcile([], [], { ensureDefaults: false })

      expect(deleted).toContain(orphanKey)
      expect(deleted.filter(key => written.some(item => item.key === key))).toEqual([])
      for (const item of written) {
        expect(store.has(item.key)).toBe(true)
      }
      expect(store.has(orphanKey)).toBe(false)
    })
  })
  describe('published runtime policy lifecycle (#604)', () => {
    function lifecycle() {
      config.netPolOrphanDeleteCapPercent = 100
      const store = new Map<string, k8s.V1NetworkPolicy>()
      const events: string[] = []
      let revision = 0
      const missing = () => Object.assign(new Error('not found'), { code: 404 })
      const save = (namespace: string, body: k8s.V1NetworkPolicy) => {
        const key = `${namespace}/${body.metadata!.name}`
        const previous = store.get(key)
        const result = structuredClone({
          ...body,
          metadata: {
            ...body.metadata,
            namespace,
            uid: previous?.metadata?.uid ?? `${key}-${++revision}`,
            resourceVersion: String(++revision),
          },
        })
        store.set(key, result)
        return result
      }
      mockApi.createNamespacedNetworkPolicy.mockImplementation(async ({ namespace, body }) => {
        const key = `${namespace}/${body.metadata.name}`
        if (store.has(key)) throw Object.assign(new Error('exists'), { code: 409 })
        events.push(`create:${key}`)
        return save(namespace, body)
      })
      mockApi.replaceNamespacedNetworkPolicy.mockImplementation(async ({ namespace, body }) =>
        save(namespace, body)
      )
      mockApi.readNamespacedNetworkPolicy.mockImplementation(async ({ namespace, name }) => {
        const found = store.get(`${namespace}/${name}`)
        if (!found) throw missing()
        return structuredClone(found)
      })
      mockApi.listNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, labelSelector }) => ({
          items: [...store.values()]
            .filter(
              policy =>
                policy.metadata?.namespace === namespace &&
                (!labelSelector ||
                  labelSelector.split(',').every((clause: string) => {
                    const [key, value] = clause.split('=')
                    return policy.metadata?.labels?.[key] === value
                  }))
            )
            .map(policy => structuredClone(policy)),
        })
      )
      mockApi.deleteNamespacedNetworkPolicy.mockImplementation(
        async ({ namespace, name, body }) => {
          const key = `${namespace}/${name}`
          const found = store.get(key)
          if (!found) throw missing()
          expect(body?.preconditions).toEqual({
            uid: found.metadata!.uid,
            resourceVersion: found.metadata!.resourceVersion,
          })
          events.push(`delete:${key}`)
          store.delete(key)
          return {}
        }
      )
      const initial: McpServerCRD = {
        name: 'lifecycle',
        namespace: 'mcp-server',
        uid: 'server-lifecycle',
        generation: 1,
        spec: {
          contextRef: 'ctx',
          image: 'fixture:v1',
          envSecret: { name: 'fixture-env', keys: [{ secretKey: 'required', envVar: 'VALUE' }] },
          transport: { type: 'streamableHttp', port: 3000 },
          egressBindings: [{ cidr: '1.2.3.4/32', port: 443 }],
        },
      }
      const cache = new Map([[initial.name, initial]])
      mockCustomApi.getNamespacedCustomObject.mockImplementation(async ({ name }) => {
        const server = cache.get(name)
        if (!server) throw missing()
        return {
          metadata: {
            name,
            namespace: server.namespace,
            uid: server.uid,
            generation: server.generation,
            resourceVersion: '1',
          },
          spec: server.spec,
          status: server.status,
        }
      })
      mockCustomApi.getNamespacedCustomObjectStatus.mockImplementation(
        mockCustomApi.getNamespacedCustomObject.getMockImplementation()!
      )
      const rec = makeReconciler(mockApi, cache, mockCustomApi)
      // Use the stateful API directly: the general fixture caches LIST snapshots,
      // which would mask a deleted resource during this lifecycle reproduction.
      ;(rec as any).networkingApi = mockApi
      const context: ContextCRD = {
        name: 'ctx',
        namespace: 'mcp-server',
        spec: { contextId: 'ctx', mcpServers: [initial.name] },
      }
      const run = async () => {
        const server = cache.get(initial.name)!
        await rec.fullReconcile([context], [server], {
          ensureDefaults: false,
          resolveCurrentServer: name => cache.get(name),
        })
        await rec.reconcileExternalEgress(server, {
          isCurrent: () => cache.get(server.name) === server,
        })
      }
      return { rec, initial, cache, context, store, events, run }
    }

    it.each(['Disabled', 'SecretNotFound', 'SecretMissingKey', 'SecretAccessDenied'])(
      'revokes once and restores all four families after %s',
      async reason => {
        const f = lifecycle()
        await f.run()
        expect(f.store.size).toBe(4)
        const policyKeys = [...f.store.keys()].sort()
        const failed = structuredClone(f.initial)
        if (reason === 'Disabled') failed.spec.enabled = false
        else failed.status = { conditions: [{ type: 'SecretResolved', status: 'False', reason }] }
        f.cache.set(failed.name, failed)
        mockCustomApi.patchNamespacedCustomObjectStatus.mockClear()
        await f.run()
        expect(f.store.size).toBe(0)
        const statusPatch = mockCustomApi.patchNamespacedCustomObjectStatus.mock.lastCall?.[0]
        expect(statusPatch).toMatchObject({ name: failed.name, namespace: failed.namespace })
        const conditionPatch = statusPatch?.body.find(
          (operation: { path: string }) =>
            operation.path === '/status' || operation.path === '/status/conditions'
        )
        const publishedConditions =
          conditionPatch?.path === '/status'
            ? conditionPatch.value.conditions
            : conditionPatch?.value
        expect(publishedConditions).toEqual(
          expect.arrayContaining([
            expect.objectContaining({
              type: 'ExternalEgressReady',
              status: 'False',
              reason: 'RuntimeNotDesired',
            }),
          ])
        )
        expect(f.events.filter(event => event.startsWith('delete:'))).toHaveLength(4)
        const settled = f.events.length
        for (let cycle = 0; cycle < 3; cycle++) await f.run()
        expect(f.events).toHaveLength(settled)
        f.cache.set(f.initial.name, structuredClone(f.initial))
        await f.run()
        expect([...f.store.keys()].sort()).toEqual(policyKeys)
        expect(f.events.filter(event => event.startsWith('create:'))).toHaveLength(8)
      }
    )

    it.each(['SecretNotFound', 'SecretMissingKey', 'SecretAccessDenied', 'ReadError'])(
      'keeps WRC policies stable for %s but honors disable',
      async reason => {
        const f = lifecycle()
        const server = structuredClone(f.initial)
        server.spec.managed = false
        f.cache.set(server.name, server)
        await f.run()
        expect(f.store.size).toBe(4)
        f.cache.set(server.name, {
          ...server,
          status: { conditions: [{ type: 'SecretResolved', status: 'False', reason }] },
        })
        for (let cycle = 0; cycle < 3; cycle++) await f.run()
        expect(f.store.size).toBe(4)
        expect(f.events.filter(event => event.startsWith('delete:'))).toHaveLength(0)
        f.cache.set(server.name, { ...server, spec: { ...server.spec, enabled: false } })
        await f.run()
        expect(f.store.size).toBe(0)
      }
    )

    it('runs the real runtime owner between policy passes without recreating a revoked allow', async () => {
      const f = lifecycle()
      await f.run()
      expect(f.store.size).toBe(4)
      const apps = createMockAppsApi()
      const core = createMockCoreApi()
      core.readNamespacedSecret.mockRejectedValue(
        Object.assign(new Error('missing fixture'), { code: 404 })
      )
      mockCustomApi.patchNamespacedCustomObjectStatus.mockImplementation(async ({ body }) => {
        const patch = body.find(
          (item: { path: string }) => item.path === '/status/conditions' || item.path === '/status'
        )
        if (patch)
          f.cache.set(f.initial.name, {
            ...f.cache.get(f.initial.name)!,
            status: { conditions: patch.path === '/status' ? patch.value.conditions : patch.value },
          })
        return {}
      })
      const runtimeConfig = new k8s.KubeConfig()
      vi.spyOn(runtimeConfig, 'makeApiClient').mockReturnValue(mockApi)
      const runtime = new McpServerReconciler(runtimeConfig, {
        assumeInventoryAuthorityWhenUnconfigured: true,
        appsApi: asAppsApi(apps),
        coreApi: asCoreApi(core),
        customApi: asCustomApi(mockCustomApi as any),
      })
      await runtime.reconcile(f.initial)
      expect(apps.deleteNamespacedDeployment).toHaveBeenCalledWith({
        name: f.initial.name,
        namespace: f.initial.namespace,
      })
      expect(f.cache.get(f.initial.name)?.status?.conditions).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            type: 'SecretResolved',
            status: 'False',
            reason: 'SecretNotFound',
          }),
        ])
      )
      expect(f.store.size).toBe(4) // Runtime owner has not deleted policies.
      await f.run()
      expect(f.store.size).toBe(0)
      const stationary = [...f.events]
      for (let cycle = 0; cycle < 3; cycle++) {
        await runtime.reconcile(f.cache.get(f.initial.name)!)
        await f.run()
      }
      expect(f.events).toEqual(stationary)
    })

    it('never deletes another owner policy selecting the same disabled server', async () => {
      const f = lifecycle()
      await f.run()
      const ownedElsewhere: k8s.V1NetworkPolicy = {
        metadata: {
          name: 'recipe-owned-lifecycle',
          namespace: 'mcp-server',
          uid: 'wrc-policy',
          resourceVersion: '1',
          labels: { [MANAGED_BY_LABEL]: 'workflow-recipes', 'clerum.io/recipe': 'fixture-recipe' },
        },
        spec: {
          podSelector: { matchLabels: { [MCPSERVER_LABEL]: f.initial.name } },
          policyTypes: ['Ingress'],
        },
      }
      f.store.set('mcp-server/recipe-owned-lifecycle', ownedElsewhere)
      f.cache.set(f.initial.name, { ...f.initial, spec: { ...f.initial.spec, enabled: false } })
      await f.run()
      expect([...f.store.values()]).toEqual([ownedElsewhere])
      expect(f.events.filter(event => event.startsWith('delete:'))).toHaveLength(4)
    })

    it('retries an external status publication failure without deleting healthy policies', async () => {
      const f = lifecycle()
      mockCustomApi.patchNamespacedCustomObjectStatus.mockRejectedValueOnce(
        Object.assign(new Error('temporary status failure'), { code: 503 })
      )
      await expect(f.run()).rejects.toThrow('temporary status failure')
      expect(f.store.size).toBe(4)
      await f.run()
      expect(f.store.size).toBe(4)
      expect(f.events.filter(event => event.startsWith('delete:'))).toHaveLength(0)
    })

    it('retires an in-flight Context effect when only the runtime verdict changes', async () => {
      const f = lifecycle()
      const entered = deferred()
      const release = deferred()
      const create = mockApi.createNamespacedNetworkPolicy.getMockImplementation()!
      mockApi.createNamespacedNetworkPolicy.mockImplementationOnce(async args => {
        entered.resolve()
        await release.promise
        return create(args)
      })
      const running = f.rec.reconcileContext(f.context, { isCurrent: () => true })
      await entered.promise
      f.cache.set(f.initial.name, {
        ...f.initial,
        status: {
          conditions: [{ type: 'SecretResolved', status: 'False', reason: 'SecretNotFound' }],
        },
      })
      release.resolve()
      expect(await running).toBe(false)
      expect(mockApi.createNamespacedNetworkPolicy).toHaveBeenCalledTimes(1)
      await f.run()
      expect(f.store.size).toBe(0)
    })

    it('retires revocation when recovery arrives before delete admission', async () => {
      const f = lifecycle()
      await f.run()
      expect(f.store.size).toBe(4)
      f.cache.set(f.initial.name, {
        ...f.initial,
        status: {
          conditions: [{ type: 'SecretResolved', status: 'False', reason: 'SecretNotFound' }],
        },
      })
      const entered = deferred()
      const release = deferred()
      const list = mockApi.listNamespacedNetworkPolicy.getMockImplementation()!
      mockApi.listNamespacedNetworkPolicy.mockImplementationOnce(async args => {
        entered.resolve()
        await release.promise
        return list(args)
      })
      const pending = f.rec.reconcileContext(f.context, { isCurrent: () => true })
      await entered.promise
      f.cache.set(f.initial.name, structuredClone(f.initial))
      release.resolve()
      expect(await pending).toBe(false)
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
      expect(f.store.size).toBe(4)
      await f.run()
      expect(f.store.size).toBe(4)
    })

    it('preserves HCC allows on a transient ReadError', async () => {
      const f = lifecycle()
      await f.run()
      expect(f.store.size).toBe(4)
      f.cache.set(f.initial.name, {
        ...f.initial,
        status: { conditions: [{ type: 'SecretResolved', status: 'False', reason: 'ReadError' }] },
      })
      await f.run()
      expect(f.store.size).toBe(4)
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it('preserves WRC allows when HCC rejects an absent optional mapping', async () => {
      const f = lifecycle()
      const reference = {
        name: 'fixture-env',
        keys: [{ secretKey: 'optional', envVar: 'OPTIONAL_VALUE', optional: true }],
      }
      const server = {
        ...f.initial,
        spec: { ...f.initial.spec, managed: false, envSecret: reference },
      }
      f.cache.set(server.name, server)
      await f.run()
      expect(f.store.size).toBe(4)
      const apps = createMockAppsApi()
      const core = createMockCoreApi()
      core.readNamespacedSecret.mockResolvedValue({ data: {} })
      mockCustomApi.patchNamespacedCustomObjectStatus.mockImplementation(async ({ body }) => {
        const patch = body.find(
          (item: { path: string }) => item.path === '/status/conditions' || item.path === '/status'
        )
        if (patch)
          f.cache.set(server.name, {
            ...f.cache.get(server.name)!,
            status: { conditions: patch.path === '/status' ? patch.value.conditions : patch.value },
          })
        return {}
      })
      const runtime = new McpServerReconciler({} as k8s.KubeConfig, {
        assumeInventoryAuthorityWhenUnconfigured: true,
        appsApi: asAppsApi(apps),
        coreApi: asCoreApi(core),
        customApi: asCustomApi(mockCustomApi as any),
      })
      await runtime.reconcile(server)
      expect(f.cache.get(server.name)?.status?.conditions).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            type: 'SecretResolved',
            status: 'False',
            reason: 'SecretMissingKey',
          }),
        ])
      )
      expect(runtime.getStatus(server.name)).toMatchObject({ deployed: true, ready: false })
      expect(apps.deleteNamespacedDeployment).not.toHaveBeenCalled()
      expect(core.deleteNamespacedService).not.toHaveBeenCalled()
      await f.run()
      expect(f.store.size).toBe(4)
      expect(mockApi.deleteNamespacedNetworkPolicy).not.toHaveBeenCalled()
    })

    it.each([
      { limit: 'absolute', cap: 1, percent: 100, lane: 'external-egress' },
      { limit: 'percentage', cap: 10, percent: 30, lane: 'external-egress' },
      { limit: 'absolute', cap: 1, percent: 100, lane: 'context-allow' },
      { limit: 'percentage', cap: 10, percent: 30, lane: 'context-allow' },
    ])(
      'excludes present ineligible owners from the $limit cap in $lane',
      async ({ cap, percent, lane }) => {
        const f = lifecycle()
        await f.run()
        expect(f.store.size).toBe(4)
        config.netPolOrphanDeleteCap = cap
        config.netPolOrphanDeleteCapPercent = percent
        const source = [...f.store.values()].find(
          policy =>
            policy.metadata?.namespace === 'mcp-server' &&
            policy.metadata.labels?.[POLICY_TYPE_LABEL] === lane
        )!
        const orphan = structuredClone(source)
        orphan.metadata = {
          ...orphan.metadata,
          name:
            lane === 'external-egress' ? 'ext-egress-gone-1-2-3-4-32-443' : 'ctx-gone-lifecycle',
          uid: 'orphan-policy',
          resourceVersion: '1',
          labels: { ...orphan.metadata!.labels },
        }
        if (lane === 'external-egress') {
          orphan.metadata.labels![MCPSERVER_LABEL] = 'gone'
          orphan.spec!.podSelector = { matchLabels: { [MCPSERVER_LABEL]: 'gone' } }
        } else orphan.metadata.labels!['clerum.io/context'] = 'gone'
        const key = 'mcp-server/' + orphan.metadata.name
        f.store.set(key, orphan)
        f.cache.set(f.initial.name, { ...f.initial, spec: { ...f.initial.spec, enabled: false } })
        await f.run()
        expect(f.store.has(key)).toBe(false)
        expect(f.store.size).toBe(0)
      }
    )

    it('keeps the real orphan cap while revoking a present ineligible owner', async () => {
      const f = lifecycle()
      await f.run()
      config.netPolOrphanDeleteCap = 1
      config.netPolOrphanDeleteCapPercent = 100
      const source = [...f.store.values()].find(
        policy => policy.metadata?.labels?.[POLICY_TYPE_LABEL] === 'external-egress'
      )!
      for (const name of ['gone-one', 'gone-two']) {
        const orphan = structuredClone(source)
        orphan.metadata = {
          ...orphan.metadata,
          name: `ext-egress-${name}-1-2-3-4-32-443`,
          uid: name,
          resourceVersion: '1',
          labels: { ...orphan.metadata!.labels, [MCPSERVER_LABEL]: name },
        }
        orphan.spec!.podSelector = { matchLabels: { [MCPSERVER_LABEL]: name } }
        f.store.set('mcp-server/' + orphan.metadata.name, orphan)
      }
      f.cache.set(f.initial.name, { ...f.initial, spec: { ...f.initial.spec, enabled: false } })
      await f.run()
      expect(f.store.size).toBe(2)
      expect(
        [...f.store.values()].every(policy =>
          policy.metadata?.labels?.[MCPSERVER_LABEL]?.startsWith('gone-')
        )
      ).toBe(true)
    })

    it('restores allows when envSecret is removed with its failure condition unchanged', async () => {
      const f = lifecycle()
      await f.run()
      const failed = {
        ...f.initial,
        status: {
          conditions: [
            { type: 'SecretResolved', status: 'False' as const, reason: 'SecretNotFound' },
          ],
        },
      }
      f.cache.set(failed.name, failed)
      await f.run()
      expect(f.store.size).toBe(0)
      const recovered = structuredClone(failed)
      delete recovered.spec.envSecret
      f.cache.set(recovered.name, recovered)
      await f.run()
      expect(f.store.size).toBe(4)
    })
  })
})