@@ -142,10 +142,13 @@ private async Task<IReadOnlyDictionary<string, bool>> OverridesAsync(
     /// <para>
     /// <c>BEGIN; SET TRANSACTION READ ONLY; SET LOCAL app.tenant_id; SELECT; COMMIT</c> —
     /// the announcement is the point, and it is why this cannot ride the request's
-    /// connection, which has none at step 3. Read-only, so the transaction exists for the
-    /// <c>SET LOCAL</c> rather than for atomicity: a <c>SET LOCAL</c> outside a transaction
-    /// lasts for the statement and would leave the pooled connection announcing a tenant
-    /// afterwards.
+    /// connection, which has none at step 3. The transaction exists so the announcement is
+    /// still in effect for the <c>SELECT</c> that follows it, not for atomicity:
+    /// <c>set_config(…, true)</c> is transaction-local, so outside an explicit transaction it
+    /// belongs to its own single-statement one and is gone before the read runs. The
+    /// alternative — announcing at session level — would survive the read and then ride the
+    /// pooled connection to whoever got it next. Read-only, because neither this nor any
+    /// reader like it writes.
     /// </para>
     /// <para>
     /// The <c>SELECT</c> names its tenant too, bound from the trusted argument. Row
 
@@ -202,10 +202,13 @@ private bool Unreadable(FeatureDescriptor descriptor, string raw)
     /// <remarks>
     /// <para>
     /// <c>BEGIN; SET TRANSACTION READ ONLY; SET LOCAL app.tenant_id; SELECT; COMMIT</c> —
-    /// the announcement is the point. Read-only, so the transaction exists for the
-    /// <c>SET LOCAL</c> rather than for atomicity: a <c>SET LOCAL</c> outside a transaction
-    /// lasts for the statement and would leave the pooled connection announcing a tenant
-    /// afterwards.
+    /// the announcement is the point. The transaction exists so the announcement is
+    /// still in effect for the <c>SELECT</c> that follows it, not for atomicity:
+    /// <c>set_config(…, true)</c> is transaction-local, so outside an explicit transaction it
+    /// belongs to its own single-statement one and is gone before the read runs. The
+    /// alternative — announcing at session level — would survive the read and then ride the
+    /// pooled connection to whoever got it next. Read-only, because neither this nor any
+    /// reader like it writes.
     /// </para>
     /// <para>
     /// The <c>SELECT</c> names its tenant too, bound from the trusted argument rather than
 
@@ -358,6 +358,8 @@ public void The_AuditLog_Write_Scan_Can_Actually_Fail()
         ComposedTableName().IsMatch("$\"update {Table} SET tenant_id = @tenant\"").Should().BeTrue(
             "a statement's target is its target in either case");
         ComposedTableName().IsMatch("$\"copy {Table} FROM STDIN\"").Should().BeTrue();
+        ComposedTableName().IsMatch("$\"INSERT INTO public.{Table} (id) VALUES (@id)\"").Should().BeTrue(
+            "a literal schema in front of a composed name composes the same name");
         ComposedTableName().IsMatch("SELECT * FROM audit_log WHERE id = @id").Should().BeFalse(
             "a literal name is what every other leg here reads");
         ComposedTableName().IsMatch("$\"SELECT * FROM audit_log WHERE tenant_id = {tenant}\"").Should().BeFalse(
@@ -431,7 +433,7 @@ private static bool MayNameTheAuditEntry(Type type)
     /// </remarks>
     [GeneratedRegex(
         @"\b(?:(?i:INSERT\s+INTO|MERGE\s+INTO|DELETE\s+FROM|TRUNCATE(?:\s+TABLE)?|COPY|UPDATE)"
-        + @"|FROM|JOIN)\s+(?:\{|""\s*\+)")]
+        + @"|FROM|JOIN)\s+(?:""?[A-Za-z_][A-Za-z0-9_]*""?\s*\.\s*)?(?:\{|""\s*\+)")]
     private static partial Regex ComposedTableName();
 
     /// <summary>
 
@@ -27,3 +27,16 @@ internal readonly partial struct BorrowedNameProbeId
 {
     internal sealed class EfCoreValueReader;
 }
+
+/// <summary>
+/// Names a namespace through a <c>typeof(…)</c> in an attribute argument and nowhere else.
+/// </summary>
+/// <remarks>
+/// The shape <c>Il.Attributes</c> could not see: it read each attribute's own type and
+/// dropped the arguments, so a reference written this way was invisible to every namespace
+/// sweep built on it. Never instantiated.
+/// </remarks>
+[System.ComponentModel.DefaultValue(typeof(Microsoft.EntityFrameworkCore.DbContext))]
+internal sealed class NamesInAnAttributeArgument
+{
+}
@@ -88,13 +88,24 @@ public void Every_Implemented_Rule_Names_A_Test_That_Exists()
             "the subject of this rule is every rule the catalogue reports Implemented in this "
             + "assembly, and § Implemented today publishes that number");
 
-        var missing = implemented
-            .Where(rule => !methods.Contains(rule))
+        // The pair, not the name. A flat set of every method in the assembly let an entry
+        // saying "Implemented — `FooTests`" be satisfied by a method of that name in
+        // `BarTests`, which is the entry being wrong in the one way it is most likely to be
+        // wrong: the rule moved and the Status line did not.
+        var declared = DeclaredMethods();
+
+        var missing = ImplementedEntries()
+            .Where(entry => NamedClasses(entry.Status).Any(SuiteClasses().Contains))
+            .Where(entry => !NamedClasses(entry.Status).Any(name =>
+                declared.TryGetValue(name, out var names) && names.Contains(entry.Rule)))
+            .Select(entry => entry.Rule)
             .ToList();
 
         missing.Should().BeEmpty(
             "every rule the catalogue reports Implemented in this assembly is a test method of "
-            + "that exact name (Standards 21 § Canonical names and superseded spellings)");
+            + "that exact name, in a class its Status line names (Standards 21 § Canonical "
+            + "names and superseded spellings)");
+
 
         // And the other direction of the same failure: an entry naming a test class that exists
         // in no suite at all. Without this a renamed or deleted file drops its entries out of
@@ -363,6 +374,16 @@ [.. typeof(CorpusConsistencyTests).Assembly.GetTypes()
     private static HashSet<string> TestMethods() =>
         [.. TestMethodInfos().Select(method => method.Name)];
 
+    /// <summary>The test method names this assembly declares, per declaring class.</summary>
+    private static Dictionary<string, HashSet<string>> DeclaredMethods() =>
+        TestMethodInfos()
+            .Where(method => method.DeclaringType is not null)
+            .GroupBy(method => method.DeclaringType!.Name, StringComparer.Ordinal)
+            .ToDictionary(
+                group => group.Key,
+                group => group.Select(method => method.Name).ToHashSet(StringComparer.Ordinal),
+                StringComparer.Ordinal);
+
     /// <summary>The number words the index's summary sentence uses.</summary>
     private static readonly Dictionary<string, int> Words = new(StringComparer.OrdinalIgnoreCase)
     {
 
@@ -379,7 +379,9 @@ internal static bool WiresTheAnalyzer(string projectXml)
             .Select(match => match.Groups["attributes"].Value)
             .Where(attributes => attributes.Contains("LearnStack.Analyzers.csproj", StringComparison.Ordinal))
             .Any(attributes =>
-                Regex.IsMatch(attributes, @"OutputItemType\s*=\s*""Analyzer""")
+                // Either quote: XML admits both, MSBuild reads both, and requiring double
+                // ones reported a correctly wired project as unwired.
+                Regex.IsMatch(attributes, @"OutputItemType\s*=\s*(?:""|')Analyzer(?:""|')")
                 && !Regex.IsMatch(attributes, @"\bCondition\s*="));
     }
 
@@ -469,6 +471,8 @@ public static Outcome Value()
         WiresTheAnalyzer(Reference + """OutputItemType="Analyzer" />""").Should().BeTrue();
         WiresTheAnalyzer("""<ProjectReference OutputItemType="Analyzer" Include="..\LearnStack.Analyzers.csproj" />""")
             .Should().BeTrue("the attributes may be written in either order");
+        WiresTheAnalyzer("""<ProjectReference Include="..\LearnStack.Analyzers.csproj" OutputItemType='Analyzer' />""")
+            .Should().BeTrue("and in either quote, which is XML's rule and not ours");
         WiresTheAnalyzer(Reference + """/>""").Should().BeFalse("a plain reference is not an analyzer");
         WiresTheAnalyzer("""<ProjectReference Condition="'$(CI)' == 'true'" Include="..\LearnStack.Analyzers.csproj" OutputItemType="Analyzer" />""")
             .Should().BeFalse("a conditional analyzer does not run in the configuration the condition excludes");
 
@@ -97,6 +97,20 @@ public void The_Domain_Term_Scan_Can_Actually_Fail()
         MigratedNames().Should().Contain("outbox_messages")
             .And.Contain("idempotency_keys", "a table created in raw SQL belongs to no DbContext");
 
+        // A schema qualifier used to take the table AND its columns out of the scan: the name
+        // group captured the schema, and the pattern then failed at the dot.
+        var qualified = CreateTable().Match("""
+            CREATE TABLE public.yoga_levels (
+                id uuid NOT NULL,
+                asana_name text NOT NULL
+            );
+            """);
+        qualified.Success.Should().BeTrue();
+        qualified.Groups["table"].Value.Should().Be("yoga_levels");
+        ColumnName().Matches(qualified.Groups["columns"].Value)
+            .Select(match => match.Groups["column"].Value)
+            .Should().BeEquivalentTo(["id", "asana_name"]);
+
         var created = CreateTable().Match("""
             CREATE TABLE kata_sequences (
                 id uuid NOT NULL,
@@ -493,7 +507,8 @@ private static List<string> Declarators(string code, Match declaration)
 
     /// <summary>A <c>CREATE TABLE</c> statement and the body that declares its columns.</summary>
     [GeneratedRegex(
-        @"CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?""?(?<table>[A-Za-z_][A-Za-z0-9_]*)""?\s*\((?<columns>.*?)\n\s*\)\s*;",
+        @"CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:""?[A-Za-z_][A-Za-z0-9_]*""?\s*\.\s*)?"
+        + @"""?(?<table>[A-Za-z_][A-Za-z0-9_]*)""?\s*\((?<columns>.*?)\n\s*\)\s*;",
         RegexOptions.Singleline | RegexOptions.IgnoreCase)]
     private static partial Regex CreateTable();
 
 
@@ -247,12 +247,50 @@ private static IEnumerable<TypeReference> ReferencedTypes(TypeDefinition type)
         }
     }
 
+    /// <summary>Every attribute a type carries, and every type those attributes name.</summary>
+    /// <remarks>
+    /// The arguments too, not only the attribute's own type. A <c>typeof(…)</c> in an attribute
+    /// argument — <c>[JsonConverter(typeof(SomeConverter))]</c> — is a reference like any other,
+    /// and reading the attribute type alone left it out of every namespace sweep built on this.
+    /// Arrays are walked, because an attribute argument can be one.
+    /// </remarks>
     private static IEnumerable<TypeReference> Attributes(TypeDefinition type) =>
-        type.CustomAttributes.Select(attribute => attribute.AttributeType)
-            .Concat(type.Fields.SelectMany(field => field.CustomAttributes)
-                .Concat(type.Properties.SelectMany(property => property.CustomAttributes))
-                .Concat(type.Methods.SelectMany(method => method.CustomAttributes))
-                .Select(attribute => attribute.AttributeType));
+        type.CustomAttributes
+            .Concat(type.Fields.SelectMany(field => field.CustomAttributes))
+            .Concat(type.Properties.SelectMany(property => property.CustomAttributes))
+            .Concat(type.Methods.SelectMany(method => method.CustomAttributes))
+            .SelectMany(attribute => new[] { attribute.AttributeType }.Concat(Named(attribute)));
+
+    /// <summary>The types one attribute's arguments name.</summary>
+    private static IEnumerable<TypeReference> Named(CustomAttribute attribute) =>
+        attribute.ConstructorArguments
+            .Concat(attribute.Fields.Select(field => field.Argument))
+            .Concat(attribute.Properties.Select(property => property.Argument))
+            .SelectMany(NamedBy);
+
+    private static IEnumerable<TypeReference> NamedBy(CustomAttributeArgument argument)
+    {
+        switch (argument.Value)
+        {
+            case TypeReference named:
+                yield return named;
+                break;
+            case CustomAttributeArgument nested:
+                foreach (var reference in NamedBy(nested))
+                {
+                    yield return reference;
+                }
+
+                break;
+            case CustomAttributeArgument[] array:
+                foreach (var reference in array.SelectMany(NamedBy))
+                {
+                    yield return reference;
+                }
+
+                break;
+        }
+    }
 
     /// <summary>
     /// Whether a reference, or any type argument inside it, lives under a namespace.
 
@@ -296,6 +296,14 @@ public void The_Domain_EF_Core_Rule_Can_Actually_Fail()
         IsVogenEmittedConverter(Probe(module, "LearnStack.Tests.Architecture.Probes.BorrowedNameProbeId/EfCoreValueReader"))
             .Should().BeFalse("Vogen emits two names, and a third one inside a value object is written by hand");
 
+        // A reference written only as a `typeof(…)` in an attribute argument is a reference.
+        // Reading the attribute's own type and dropping its arguments left this type looking
+        // as though it named nothing.
+        Il.NamesNamespace(
+            Probe(module, "LearnStack.Tests.Architecture.Probes.NamesInAnAttributeArgument"),
+            "Microsoft.EntityFrameworkCore")
+            .Should().BeTrue("an attribute argument names the type it carries");
+
         // And the exception recognises what Vogen actually emits, in every Domain assembly.
         DomainAssemblies().Select(assembly => EfCoreDependents(assembly.Location))
             .Sum(assembly => assembly.Emitted)
 
@@ -378,23 +378,39 @@ public void The_Tenant_Term_Check_Can_Actually_Fail()
             .Should().BeFalse("a USING that ignores the tenant reads every tenant's rows");
         PolicyReadsTheTenant($"CREATE POLICY p ON t USING ({Term}) WITH CHECK ({Term});", "id")
             .Should().BeFalse("the self-keyed table compares its own id, not a tenant_id it lacks");
+
+        // And the same policy in lower case, which is the same policy. SQL folds case and
+        // `pg_policies` prints what was written, so a clause-finder keyed on the upper-case
+        // spelling answers "no tenant term" for a policy that carries one — a structural rule
+        // reporting a leak that is not there, or missing one that is.
+        const string Lower = "tenant_id = nullif(current_setting('app.tenant_id', true), '')::uuid";
+
+        PolicyReadsTheTenant($"create policy p on t using ({Lower}) with check ({Lower});", "tenant_id")
+            .Should().BeTrue("a policy written in lower case reads the tenant just as well");
+        PolicyReadsTheTenant($"create policy p on t using ({Lower}) with check (true);", "tenant_id")
+            .Should().BeFalse("and it is still refused when one clause ignores the tenant");
     }
 
     /// <summary>
     /// Whether both clauses of a policy compare the key column to the announced tenant.
     /// </summary>
     private static bool PolicyReadsTheTenant(string policy, string keyColumn)
     {
-        var usingAt = policy.IndexOf("USING", StringComparison.Ordinal);
-        var checkAt = policy.IndexOf("WITH CHECK", StringComparison.Ordinal);
+        // Case-insensitively, as `PermissivePolicyFor` already reads its own keywords: SQL
+        // folds case, `pg_policies` prints what was written, and a policy spelled `using (…)`
+        // or naming `current_setting` in another case would otherwise read as absent — a
+        // structural rule answering "no tenant term" for a policy that has one.
+        var usingAt = policy.IndexOf("USING", StringComparison.OrdinalIgnoreCase);
+        var checkAt = policy.IndexOf("WITH CHECK", StringComparison.OrdinalIgnoreCase);
 
         if (usingAt < 0 || checkAt < usingAt)
         {
             return false;
         }
 
         var term = new Regex(
-            $@"(?<![A-Za-z0-9_]){Regex.Escape(keyColumn)}\s*=\s*NULLIF\(\s*current_setting\(\s*'app\.tenant_id'\s*,\s*true\s*\)\s*,\s*''\s*\)::uuid");
+            $@"(?<![A-Za-z0-9_]){Regex.Escape(keyColumn)}\s*=\s*NULLIF\(\s*current_setting\(\s*'app\.tenant_id'\s*,\s*true\s*\)\s*,\s*''\s*\)::uuid",
+            RegexOptions.IgnoreCase);
 
         return term.IsMatch(policy[usingAt..checkAt]) && term.IsMatch(policy[checkAt..]);
     }