@@ -71,8 +71,9 @@ public static async Task<IncrementalOutcome> RunIncrementalAsync(
         var diff = SchemaDiff.Diff(expected, actual, allow);
         var emitted = PostgresEmit.Render(diff.Changes);
 
+        // Nested-record Type.Name is already the short form ("DropColumn"); no Change+ prefix.
         var blocked = diff.Blocked
-            .Select(c => $"{c.GetType().Name.Replace("Change+", "")}: {c.Status.BlockedReason}")
+            .Select(c => $"{c.GetType().Name}: {c.Status.BlockedReason}")
             .ToList();
 
         if (upOutFile is not null) File.WriteAllText(upOutFile, emitted.Up);
 
@@ -17,12 +17,21 @@ public sealed class NpgsqlIntrospector : IPgIntrospector, IAsyncDisposable
 
     private NpgsqlIntrospector(NpgsqlConnection conn) => _conn = conn;
 
-    /// <summary>Open a connection and return a ready-to-use introspector.</summary>
+    /// <summary>Open a connection and return a ready-to-use introspector.
+    /// Disposes the half-open connection if <see cref="NpgsqlConnection.OpenAsync()"/> throws.</summary>
     public static async Task<NpgsqlIntrospector> ConnectAsync(string connectionString)
     {
         var conn = new NpgsqlConnection(connectionString);
-        await conn.OpenAsync();
-        return new NpgsqlIntrospector(conn);
+        try
+        {
+            await conn.OpenAsync();
+            return new NpgsqlIntrospector(conn);
+        }
+        catch
+        {
+            await conn.DisposeAsync();
+            throw;
+        }
     }
 
     public async Task<IReadOnlyList<PgRow>> QueryAsync(string sql, params (string Name, object? Value)[] parameters)
 
@@ -59,7 +59,14 @@ static int RunMigrate(string[] rest)
 
 static async Task<int> RunIncrementalMigrate(string metadataDir, string upFile, string connString, string? downFile)
 {
-    await using var db = await NpgsqlIntrospector.ConnectAsync(connString);
+    NpgsqlIntrospector db;
+    try { db = await NpgsqlIntrospector.ConnectAsync(connString); }
+    catch (Exception ex)
+    {
+        Console.Error.WriteLine($"meta migrate: could not connect to Postgres: {ex.Message}");
+        return 1;
+    }
+    await using var _ = db;
     var outcome = await MigrateCommand.RunIncrementalAsync(metadataDir, db, upFile, downFile);
 
     foreach (var e in outcome.LoadErrors) Console.Error.WriteLine($"  load error: {e}");
 
@@ -5,6 +5,27 @@ namespace MetaObjects.Codegen.Tests.Migrate;
 
 public class PostgresIntrospectTests
 {
+    // Information_schema.columns row shaped like the production ReadColumnsAsync
+    // query expects. Keeps every field visible at the call-site via named args.
+    // Defaults mirror the most common "plain bigint NOT NULL with no default,
+    // not an identity" shape so unrelated tests don't have to repeat seven nulls.
+    private static PgRow ColRow(
+        string columnName,
+        string dataType = "bigint",
+        string udtName = "int8",
+        long? maxLength = null,
+        string isNullable = "NO",
+        string? columnDefault = null,
+        string isIdentity = "NO") =>
+        PgRow.Of(
+            ("column_name", columnName),
+            ("data_type", dataType),
+            ("udt_name", udtName),
+            ("character_maximum_length", maxLength),
+            ("is_nullable", isNullable),
+            ("column_default", columnDefault),
+            ("is_identity", isIdentity));
+
     // -----------------------------------------------------------------------
     // PgTypeToSqlType — pure string → canonical SqlType
     // -----------------------------------------------------------------------
@@ -170,18 +191,10 @@ public async Task Single_table_with_columns_pk_index_and_fk_round_trips()
         fake.OnTables(("public", "posts"));
         // 2) columns (id pk via nextval, title varchar(200) NOT NULL, score numeric(10,2) NULL, body text NULL DEFAULT 'x')
         fake.OnColumns("public", "posts",
-            PgRow.Of(("column_name", "id"), ("data_type", "bigint"), ("udt_name", "int8"),
-                     ("character_maximum_length", null), ("is_nullable", "NO"),
-                     ("column_default", "nextval('public.posts_id_seq'::regclass)")),
-            PgRow.Of(("column_name", "title"), ("data_type", "character varying"), ("udt_name", "varchar"),
-                     ("character_maximum_length", 200L), ("is_nullable", "NO"),
-                     ("column_default", null)),
-            PgRow.Of(("column_name", "score"), ("data_type", "numeric(10,2)"), ("udt_name", "numeric"),
-                     ("character_maximum_length", null), ("is_nullable", "YES"),
-                     ("column_default", null)),
-            PgRow.Of(("column_name", "body"), ("data_type", "text"), ("udt_name", "text"),
-                     ("character_maximum_length", null), ("is_nullable", "YES"),
-                     ("column_default", "'x'::text")));
+            ColRow("id", columnDefault: "nextval('public.posts_id_seq'::regclass)"),
+            ColRow("title", dataType: "character varying", udtName: "varchar", maxLength: 200L),
+            ColRow("score", dataType: "numeric(10,2)", udtName: "numeric", isNullable: "YES"),
+            ColRow("body", dataType: "text", udtName: "text", isNullable: "YES", columnDefault: "'x'::text"));
         // 3) PK
         fake.OnPrimaryKey("public", "posts", "id");
         // 4) indexes (the PK index appears here too — orchestrator must drop is_primary=true)
@@ -237,10 +250,7 @@ public async Task Non_public_schema_is_preserved()
     {
         var fake = new FakePgIntrospector();
         fake.OnTables(("billing", "invoices"));
-        fake.OnColumns("billing", "invoices",
-            PgRow.Of(("column_name", "id"), ("data_type", "bigint"), ("udt_name", "int8"),
-                     ("character_maximum_length", null), ("is_nullable", "NO"),
-                     ("column_default", null)));
+        fake.OnColumns("billing", "invoices", ColRow("id"));
         fake.OnPrimaryKey("billing", "invoices", "id");
 
         var t = Assert.Single((await PostgresIntrospect.IntrospectAsync(fake)).Tables);
@@ -252,17 +262,90 @@ public async Task Composite_pk_preserves_ordinal_order()
     {
         var fake = new FakePgIntrospector();
         fake.OnTables(("public", "links"));
-        fake.OnColumns("public", "links",
-            PgRow.Of(("column_name", "a"), ("data_type", "bigint"), ("udt_name", "int8"),
-                     ("character_maximum_length", null), ("is_nullable", "NO"), ("column_default", null)),
-            PgRow.Of(("column_name", "b"), ("data_type", "bigint"), ("udt_name", "int8"),
-                     ("character_maximum_length", null), ("is_nullable", "NO"), ("column_default", null)));
+        fake.OnColumns("public", "links", ColRow("a"), ColRow("b"));
         fake.OnPrimaryKey("public", "links", "b", "a"); // order matters
 
         var t = Assert.Single((await PostgresIntrospect.IntrospectAsync(fake)).Tables);
         Assert.Equal(["b", "a"], t.PrimaryKey.ToArray());
     }
 
+    [Fact]
+    public async Task Composite_fk_preserves_column_pairing()
+    {
+        var fake = new FakePgIntrospector();
+        fake.OnTables(("public", "child"));
+        fake.OnColumns("public", "child", ColRow("p_a"), ColRow("p_b"));
+        fake.OnForeignKeys("public", "child",
+            PgRow.Of(("fk_name", "child_parent_fk"), ("column_name", "p_a"),
+                     ("ref_table", "parent"), ("ref_column", "a"),
+                     ("update_rule", "RESTRICT"), ("delete_rule", "CASCADE"), ("ordinal", 1)),
+            PgRow.Of(("fk_name", "child_parent_fk"), ("column_name", "p_b"),
+                     ("ref_table", "parent"), ("ref_column", "b"),
+                     ("update_rule", "RESTRICT"), ("delete_rule", "CASCADE"), ("ordinal", 2)));
+
+        var t = Assert.Single((await PostgresIntrospect.IntrospectAsync(fake)).Tables);
+        var fk = Assert.Single(t.ForeignKeys);
+        Assert.Equal(["p_a", "p_b"], fk.Columns.ToArray());
+        Assert.Equal(["a", "b"], fk.RefColumns.ToArray());
+        Assert.Equal(FkAction.Cascade, fk.OnDelete);
+        Assert.Equal(FkAction.Restrict, fk.OnUpdate);
+    }
+
+    [Fact]
+    public async Task Non_unique_and_multi_column_indexes_are_carried()
+    {
+        var fake = new FakePgIntrospector();
+        fake.OnTables(("public", "t"));
+        fake.OnColumns("public", "t", ColRow("x"));
+        fake.OnIndexes("public", "t",
+            // Non-unique single-column.
+            PgRow.Of(("index_name", "t_x_idx"), ("is_unique", false), ("is_primary", false),
+                     ("column_name", "x"), ("ordinal", 1)),
+            // Multi-column unique — rows arrive ordered by `ordinal` from the SQL's ORDER BY.
+            PgRow.Of(("index_name", "t_ab_uq"), ("is_unique", true), ("is_primary", false),
+                     ("column_name", "a"), ("ordinal", 1)),
+            PgRow.Of(("index_name", "t_ab_uq"), ("is_unique", true), ("is_primary", false),
+                     ("column_name", "b"), ("ordinal", 2)));
+
+        var t = Assert.Single((await PostgresIntrospect.IntrospectAsync(fake)).Tables);
+        var idx = t.Indexes.Single(i => i.Name == "t_x_idx");
+        Assert.False(idx.Unique);
+        Assert.Equal(["x"], idx.Columns.ToArray());
+        var uq = t.Indexes.Single(i => i.Name == "t_ab_uq");
+        Assert.True(uq.Unique);
+        Assert.Equal(["a", "b"], uq.Columns.ToArray());
+    }
+
+    [Fact]
+    public async Task Serial_detected_via_udt_name_when_default_is_absent()
+    {
+        // Belt-and-suspenders: covers the udt_name-only branch (a serial column whose
+        // sequence default has been stripped or unmapped). The PG10+ identity branch
+        // (is_identity=YES) is covered by the next test.
+        var fake = new FakePgIntrospector();
+        fake.OnTables(("public", "t"));
+        fake.OnColumns("public", "t", ColRow("id", udtName: "bigserial"));
+
+        var t = Assert.Single((await PostgresIntrospect.IntrospectAsync(fake)).Tables);
+        var id = Assert.Single(t.Columns);
+        Assert.Equal(IdentityKind.Increment, id.Identity);
+        Assert.Null(id.Default);
+    }
+
+    [Fact]
+    public async Task Pg10_identity_column_detected_via_is_identity()
+    {
+        // PG 10+ GENERATED ... AS IDENTITY columns surface as is_identity='YES' with
+        // no nextval(...) default. Must still mark the column identity=increment.
+        var fake = new FakePgIntrospector();
+        fake.OnTables(("public", "t"));
+        fake.OnColumns("public", "t", ColRow("id", isIdentity: "YES"));
+
+        var t = Assert.Single((await PostgresIntrospect.IntrospectAsync(fake)).Tables);
+        var id = Assert.Single(t.Columns);
+        Assert.Equal(IdentityKind.Increment, id.Identity);
+    }
+
     [Fact]
     public async Task Snapshot_round_trips_through_diff_against_expected()
     {
@@ -271,10 +354,7 @@ public async Task Snapshot_round_trips_through_diff_against_expected()
         // confirm SchemaDiff finds no changes.
         var fake = new FakePgIntrospector();
         fake.OnTables(("public", "t"));
-        fake.OnColumns("public", "t",
-            PgRow.Of(("column_name", "id"), ("data_type", "bigint"), ("udt_name", "int8"),
-                     ("character_maximum_length", null), ("is_nullable", "NO"),
-                     ("column_default", "nextval('t_id_seq'::regclass)")));
+        fake.OnColumns("public", "t", ColRow("id", columnDefault: "nextval('t_id_seq'::regclass)"));
         fake.OnPrimaryKey("public", "t", "id");
 
         var actual = await PostgresIntrospect.IntrospectAsync(fake);
@@ -313,7 +393,9 @@ public void OnColumns(string schema, string table, params PgRow[] rows) =>
 
     public void OnPrimaryKey(string schema, string table, params string[] cols) =>
         _routes.Add(((sql, p) =>
-            sql.Contains("PRIMARY KEY")
+            // Match the constraint_type literal anchor — narrower than "PRIMARY KEY"
+            // alone so a future SQL comment can't accidentally collide.
+            sql.Contains("'PRIMARY KEY'")
                 && p.Any(x => x is { Name: "schema" } && Equals(x.Value, schema))
                 && p.Any(x => x is { Name: "table" } && Equals(x.Value, table)),
             cols.Select((c, i) => PgRow.Of(("column_name", c), ("ordinal_position", (long)(i + 1)))).ToList()));
 
@@ -90,8 +90,7 @@ public static SqlType PgTypeToSqlType(string dataType, long? maxLength = null)
               or "int2" or "smallint" or "smallserial")
             return new SqlType.Integer(32);
 
-        if (dt is "float4" or "real") return new SqlType.Real();
-        if (dt is "float8" or "double precision") return new SqlType.Real();
+        if (dt is "float4" or "real" or "float8" or "double precision") return new SqlType.Real();
 
         var num = NumericInline.Match(dt);
         if (num.Success)
@@ -105,6 +104,11 @@ public static SqlType PgTypeToSqlType(string dataType, long? maxLength = null)
         if (dt == "date") return new SqlType.Date();
         if (dt is "timestamp" or "timestamp without time zone") return new SqlType.Timestamp(false);
         if (dt is "timestamptz" or "timestamp with time zone") return new SqlType.Timestamp(true);
+        // SqlType has no Time variant (see SqlType.cs; intentional per TS). Pinned
+        // explicitly here so the time→text mapping isn't a quiet accident of the
+        // catch-all fallback below.
+        if (dt is "time" or "time without time zone" or "timetz" or "time with time zone")
+            return new SqlType.Text();
         if (dt is "json" or "jsonb") return new SqlType.Json();
         if (dt == "bytea") return new SqlType.Blob();
         if (dt == "uuid") return new SqlType.Uuid();
@@ -162,6 +166,16 @@ public static SqlType PgTypeToSqlType(string dataType, long? maxLength = null)
         _ => null,
     };
 
+    // udt_name values Postgres reports for the legacy auto-increment forms
+    // (bigserial / serial / smallserial and their internal aliases). Used by
+    // ReadColumnsAsync's identity-detection.
+    private static readonly HashSet<string> SerialUdtNames = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "bigserial", "serial8",
+        "serial",    "serial4",
+        "smallserial", "serial2",
+    };
+
     // -----------------------------------------------------------------------
     // Orchestrator
     // -----------------------------------------------------------------------
@@ -218,7 +232,8 @@ AND table_schema NOT LIKE 'pg_%'
           udt_name,
           character_maximum_length,
           is_nullable,
-          column_default
+          column_default,
+          is_identity
         FROM information_schema.columns
         WHERE table_schema = @schema
           AND table_name = @table
@@ -297,15 +312,15 @@ private static async Task<List<ColumnDescriptor>> ReadColumnsAsync(IPgIntrospect
             var nullable = string.Equals(r.GetString("is_nullable"), "YES", StringComparison.OrdinalIgnoreCase);
             var rawDefault = r.GetString("column_default");
             var def = ParsePgDefault(rawDefault);
-            // bigserial / serial / smallserial surface as a nextval(...) default OR
-            // as the udt_name. Belt-and-suspenders detection.
-            var isSerial = (rawDefault is not null && rawDefault.StartsWith("nextval(", StringComparison.OrdinalIgnoreCase))
-                || udtName.Equals("bigserial", StringComparison.OrdinalIgnoreCase)
-                || udtName.Equals("serial8", StringComparison.OrdinalIgnoreCase)
-                || udtName.Equals("serial4", StringComparison.OrdinalIgnoreCase)
-                || udtName.Equals("serial", StringComparison.OrdinalIgnoreCase)
-                || udtName.Equals("smallserial", StringComparison.OrdinalIgnoreCase)
-                || udtName.Equals("serial2", StringComparison.OrdinalIgnoreCase);
+            // Identity detection covers two PG generations:
+            //   * legacy `bigserial`/`serial`/`smallserial` — surfaces as a nextval(...)
+            //     default OR as the udt_name.
+            //   * PG 10+ `GENERATED ... AS IDENTITY` — surfaces as
+            //     information_schema.columns.is_identity = 'YES'.
+            var isIdentity = string.Equals(r.GetString("is_identity"), "YES", StringComparison.OrdinalIgnoreCase);
+            var isSerial = isIdentity
+                || (rawDefault is not null && rawDefault.StartsWith("nextval(", StringComparison.OrdinalIgnoreCase))
+                || SerialUdtNames.Contains(udtName);
             // When a column's default is the sequence-feeder (nextval(...)) and we've
             // already flagged the column as identity=increment, suppress the default so
             // the snapshot matches ExpectedSchema (which models the serial column as
@@ -334,7 +349,7 @@ private static async Task<List<string>> ReadPrimaryKeyAsync(IPgIntrospector db,
     private static async Task<List<IndexDescriptor>> ReadIndexesAsync(IPgIntrospector db, string schema, string table)
     {
         var rows = await db.QueryAsync(IndexesSql, ("schema", schema), ("table", table));
-        // Group rows by index name, ordered by `ordinal` (already done by ORDER BY).
+        // Group rows by index name; the SQL's ORDER BY ordinal handles in-index column order.
         var byName = new Dictionary<string, (bool IsUnique, bool IsPrimary, List<string> Cols)>(StringComparer.Ordinal);
         foreach (var r in rows)
         {
@@ -344,9 +359,9 @@ private static async Task<List<IndexDescriptor>> ReadIndexesAsync(IPgIntrospecto
                 entry = (r.GetBool("is_unique"), r.GetBool("is_primary"), new List<string>());
                 byName[name] = entry;
             }
+            // Cols is a reference type — mutating the List here mutates the one stored
+            // in the dictionary entry; no re-store needed.
             entry.Cols.Add(r.GetString("column_name")!);
-            // re-store the tuple since we mutated the List inside it (tuple value-copy)
-            byName[name] = entry;
         }
         return byName
             .Where(kv => !kv.Value.IsPrimary) // PK is carried separately on TableDescriptor
@@ -371,9 +386,9 @@ private static async Task<List<FkDescriptor>> ReadForeignKeysAsync(IPgIntrospect
                     PgRuleToAction(r.GetString("update_rule") ?? ""));
                 byName[name] = entry;
             }
+            // Both lists are reference types; mutating in place is enough (no re-store).
             entry.Cols.Add(r.GetString("column_name")!);
             entry.RefCols.Add(r.GetString("ref_column")!);
-            byName[name] = entry;
         }
         return byName
             .Select(kv => new FkDescriptor(