fix: remediate second-round review findings (A/#4, B/#1/#7/#8/#9)

Addresses review.md classifications from session 2:
- A/#4 Correctness: extend HasQuarryContextAttributeSyntactic with an
  AliasQualifiedNameSyntax branch so [global::QuarryContextAttribute]
  and extern-alias attribute forms pass the syntactic pre-filter.
- B/#1 Plan: drop RawSqlTypeInfo.FullyQualifiedResultTypeName — written
  but never read; ResultTypeName already carries the final display form
  (FQN for nested, short for not).
- B/#7 Tests: add alias-qualified attribute QRY044 coverage.
- B/#8 Tests: add struct-with-init-only-property QRY043 coverage.
- B/#9 Tests: add mixed RawSqlScalarAsync<int> + failing RawSqlAsync<T>
  test exercising the scalar branch in PipelineOrchestrator + FileEmitter.

3259 tests pass (+3 new).

Author: DJGosnell

_sessions/259-docs-dx-friction-points/review.md

@@ -6,7 +6,7 @@ remote: https://github.com/Dtronix/Quarry.git
 base-branch: master
 
 ## State
-phase: REVIEW
+phase: REMEDIATE
 status: active
 issue: #259
 pr: #260
@@ -64,3 +64,5 @@ Add `IsNestedType` (bool) and `FullyQualifiedResultTypeName` (string) to `RawSql
 | 1 | 2026-04-22 | - | INTAKE→DESIGN→PLAN: baseline green (3242 tests), design decisions recorded, plan.md approved. Auto-transition to IMPLEMENT. |
 | 2 | 2026-04-23 | - | Resume. Worktree had been pruned from disk; recreated at `../259-docs-dx-friction-points/` from `origin/259-docs-dx-friction-points`. PR #260 verified MERGEABLE/CLEAN, CI run 24820105388 SUCCESS. Branch 8 ahead, 0 behind origin/master — no rebase needed. Remediation already committed (`be224dd`, `25f0b5e`). REMEDIATE step 8: awaiting user finalize confirmation. |
 | 3 | 2026-04-23 | - | Back-step REMEDIATE → REVIEW at user request (declined finalize). Keep review.md + Decisions intact; re-run analysis pass over the full branch diff including remediation commits `be224dd` and `25f0b5e`. Classifications reset — rerun classification pass after. No targeted focus — general re-review. |
+| 4 | 2026-04-23 | - | REVIEW session 2 complete: 13 findings, classified 1A/4B/0C/8D (accepted Rec). Transition to REMEDIATE. A: #4 AliasQualifiedNameSyntax in `HasQuarryContextAttributeSyntactic`. B: #1 drop dead `FullyQualifiedResultTypeName`, #7 alias-qualified attribute test, #8 struct init-only row test, #9 `RawSqlScalarAsync<T>` QRY043 suppression test. |
+| 5 | 2026-04-23 | - | Session 2 remediation complete: A/#4 + B/#1/#7/#8/#9 addressed. Build clean; 3259 tests pass (+3 new: Analyzers 110, Migration 201, Quarry 2948). Next: commit + rebase on origin/master + push + verify CI. |

_sessions/259-docs-dx-friction-points/workflow.md

@@ -155,6 +155,31 @@ public partial class AppDb : QuarryContext
         Assert.That(diagnostics[0].GetMessage(), Does.Contain("MyApp.Data"));
     }
 
+    [Test]
+    public async Task EmitsQRY044_WhenAttributeUsesAliasQualifiedName()
+    {
+        // `[global::QuarryContextAttribute]` decomposes into AliasQualifiedNameSyntax at the
+        // attribute's top-level name, which the syntactic pre-filter must handle explicitly —
+        // otherwise the analyzer silently skips the class and the diagnostic never fires.
+        // This also covers extern-alias-qualified attribute forms.
+        var source = @"
+using Quarry;
+using QuarryContextAttribute = Quarry.QuarryContextAttribute;
+
+namespace MyApp.Data
+{
+    [global::QuarryContextAttribute(Dialect = SqlDialect.SQLite)]
+    public partial class AppDb : QuarryContext
+    {
+    }
+}";
+
+        var diagnostics = await GetDiagnosticsAsync(source, "Quarry.Generated");
+        Assert.That(diagnostics, Has.Length.EqualTo(1));
+        Assert.That(diagnostics[0].GetMessage(), Does.Contain("AppDb"));
+        Assert.That(diagnostics[0].GetMessage(), Does.Contain("MyApp.Data"));
+    }
+
     [Test]
     public async Task NoDiagnostic_ForNonContextClass()
     {

src/Quarry.Analyzers.Tests/InterceptorsNamespacesAnalyzerTests.cs

@@ -78,6 +78,7 @@ private static bool HasQuarryContextAttributeSyntactic(ClassDeclarationSyntax cl
                 var name = attr.Name switch
                 {
                     QualifiedNameSyntax q => q.Right.Identifier.Text,
+                    AliasQualifiedNameSyntax a => a.Name.Identifier.Text,
                     SimpleNameSyntax s => s.Identifier.Text,
                     _ => null
                 };

src/Quarry.Analyzers/InterceptorsNamespacesAnalyzer.cs

@@ -15,8 +15,7 @@ public RawSqlTypeInfo(
         bool hasCancellationToken = false,
         string? scalarReaderMethod = null,
         string? sqlLiteral = null,
-        bool isNestedType = false,
-        string? fullyQualifiedResultTypeName = null)
+        bool isNestedType = false)
     {
         ResultTypeName = resultTypeName;
         TypeKind = typeKind;
@@ -25,7 +24,6 @@ public RawSqlTypeInfo(
         ScalarReaderMethod = scalarReaderMethod;
         SqlLiteral = sqlLiteral;
         IsNestedType = isNestedType;
-        FullyQualifiedResultTypeName = fullyQualifiedResultTypeName ?? resultTypeName;
     }
 
     /// <summary>
@@ -71,13 +69,6 @@ public RawSqlTypeInfo(
     /// </summary>
     public bool IsNestedType { get; }
 
-    /// <summary>
-    /// The <c>global::</c>-prefixed fully qualified name of the result type. Always
-    /// resolves to a valid C# type reference regardless of <c>using</c> directives.
-    /// Falls back to <see cref="ResultTypeName"/> when not separately supplied.
-    /// </summary>
-    public string FullyQualifiedResultTypeName { get; }
-
     public bool Equals(RawSqlTypeInfo? other)
     {
         if (other is null) return false;
@@ -88,7 +79,6 @@ public bool Equals(RawSqlTypeInfo? other)
             && ScalarReaderMethod == other.ScalarReaderMethod
             && SqlLiteral == other.SqlLiteral
             && IsNestedType == other.IsNestedType
-            && FullyQualifiedResultTypeName == other.FullyQualifiedResultTypeName
             && EqualityHelpers.SequenceEqual(Properties, other.Properties);
     }
 

src/Quarry.Generator/Models/RawSqlTypeInfo.cs

@@ -249,8 +249,7 @@ private static void EnrichRawSqlTypeInfo(
                     rawSqlTypeInfo.HasCancellationToken,
                     rawSqlTypeInfo.ScalarReaderMethod,
                     sqlLiteral,
-                    rawSqlTypeInfo.IsNestedType,
-                    rawSqlTypeInfo.FullyQualifiedResultTypeName);
+                    rawSqlTypeInfo.IsNestedType);
             }
 
             site.RawSqlTypeInfo = rawSqlTypeInfo;
@@ -372,8 +371,7 @@ private static RawSqlTypeInfo PatchWithColumnMetadata(
             typeInfo.HasCancellationToken,
             typeInfo.ScalarReaderMethod,
             typeInfo.SqlLiteral,
-            typeInfo.IsNestedType,
-            typeInfo.FullyQualifiedResultTypeName);
+            typeInfo.IsNestedType);
     }
 
     /// <summary>

src/Quarry.Generator/Parsing/DisplayClassEnricher.cs

@@ -4032,8 +4032,7 @@ internal static RawSqlTypeInfo ResolveRawSqlTypeInfo(ITypeSymbol typeSymbol, boo
                 System.Array.Empty<RawSqlPropertyInfo>(),
                 hasCancellationToken,
                 scalarReaderMethod,
-                isNestedType: false,
-                fullyQualifiedResultTypeName: typeName);
+                isNestedType: false);
         }
 
         // T is a class/struct with properties — enumerate public settable properties
@@ -4089,8 +4088,7 @@ internal static RawSqlTypeInfo ResolveRawSqlTypeInfo(ITypeSymbol typeSymbol, boo
             RawSqlTypeKind.Dto,
             properties,
             hasCancellationToken,
-            isNestedType: isNestedType,
-            fullyQualifiedResultTypeName: typeName);
+            isNestedType: isNestedType);
     }
 
     /// <summary>

src/Quarry.Generator/Parsing/UsageSiteDiscovery.cs

@@ -629,6 +629,107 @@ public async Task Test(TestDbContext db)
         Assert.That(qry043!.GetMessage(), Does.Contain("interface"));
     }
 
+    [Test]
+    public void RawSqlAsync_StructRowWithInitOnlyProperty_EmitsQRY043()
+    {
+        // Structs skip the ctor branch in CheckRowEntityMaterializability (C# always
+        // synthesizes a public parameterless ctor). Pin that the property-loop path
+        // still rejects an init-only property on a struct row type.
+        var source = @"
+using Quarry;
+using System.Threading.Tasks;
+
+namespace TestApp;
+
+public struct UserRow
+{
+    public int Id { get; init; }
+    public string Name { get; init; }
+}
+
+public class UserSchema : Schema
+{
+    public static string Table => ""users"";
+    public Key<int> UserId => Identity();
+}
+
+[QuarryContext(Dialect = SqlDialect.SQLite)]
+public partial class TestDbContext : QuarryContext
+{
+    public partial IEntityAccessor<User> Users();
+}
+
+public class Service
+{
+    public async Task Test(TestDbContext db)
+    {
+        var rows = await db.RawSqlAsync<UserRow>(""SELECT Id, Name FROM users"");
+        foreach (var r in rows) { _ = r; }
+    }
+}
+";
+
+        var compilation = CreateCompilation(source);
+        var (diagnostics, _) = RunGeneratorWithDiagnostics(compilation);
+
+        var qry043 = diagnostics.FirstOrDefault(d => d.Id == "QRY043");
+        Assert.That(qry043, Is.Not.Null, "QRY043 should fire for a struct row with init-only properties");
+        Assert.That(qry043!.GetMessage(), Does.Contain("init-only"));
+    }
+
+    [Test]
+    public void RawSqlScalarAsync_DoesNotEmitQRY043_AndEmitsInterceptor_WhenMixedWithFailingRawSqlAsync()
+    {
+        // Pins the `Kind is RawSqlAsync or RawSqlScalarAsync` branch in
+        // PipelineOrchestrator.CollectTranslatedDiagnostics and FileEmitter for the
+        // scalar case: a failing RawSqlAsync<UserRow> must emit QRY043 exactly once
+        // while the sibling RawSqlScalarAsync<int> still produces a valid interceptor
+        // (scalars skip the materializability check entirely).
+        var source = @"
+using Quarry;
+using System.Threading.Tasks;
+
+namespace TestApp;
+
+public sealed record UserRow(int Id, string Name);
+
+public class UserSchema : Schema
+{
+    public static string Table => ""users"";
+    public Key<int> UserId => Identity();
+}
+
+[QuarryContext(Dialect = SqlDialect.SQLite)]
+public partial class TestDbContext : QuarryContext
+{
+    public partial IEntityAccessor<User> Users();
+}
+
+public class Service
+{
+    public async Task Test(TestDbContext db)
+    {
+        var rows = await db.RawSqlAsync<UserRow>(""SELECT Id, Name FROM users"");
+        foreach (var r in rows) { _ = r; }
+        var count = await db.RawSqlScalarAsync<int>(""SELECT COUNT(*) FROM users"");
+    }
+}
+";
+
+        var compilation = CreateCompilation(source);
+        var (diagnostics, result) = RunGeneratorWithDiagnostics(compilation);
+
+        var qry043s = diagnostics.Where(d => d.Id == "QRY043").ToList();
+        Assert.That(qry043s, Has.Count.EqualTo(1),
+            "QRY043 should fire once for the failing RawSqlAsync<UserRow> and not for the RawSqlScalarAsync<int>");
+        Assert.That(qry043s[0].GetMessage(), Does.Contain("UserRow"));
+
+        var code = GetInterceptorsCode(result);
+        Assert.That(code, Is.Not.Null, "Should still generate an interceptors file for the scalar call");
+        Assert.That(code, Does.Contain("RawSqlScalarAsyncWithConverter"),
+            "Scalar interceptor must still emit despite the sibling QRY043");
+    }
+
     [Test]
     public void RawSqlAsync_PlainClassRow_DoesNotEmitQRY043()
     {