fix(pg): auto-migrate schema on pg serve startup (#252)

## Summary

- Run `EnsureSchema` before `CheckSchemaCompat` in `pg serve` so missing
tables (e.g. `tool_result_events` after upgrading from 0.16.x to 0.17.0)
are created automatically
- Read-only PG roles gracefully fall through to the existing compat
check error
- Add `TestEnsureSchemaMigratesLegacySchema` integration test that
simulates a legacy schema upgrade

Closes #251

## Test plan

- [ ] `make test` passes
- [ ] `make test-postgres` passes (exercises
`TestEnsureSchemaMigratesLegacySchema`)
- [ ] Manual: upgrade from 0.16.x schema, verify `pg serve` starts
without manual SQL

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Tom Maloney <tom@supermaloney.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 3 people

cmd/agentsview/pg.go

@@ -235,6 +235,20 @@ func runPGServe(args []string) {
 	)
 	defer stop()
 
+	// Attempt to apply any missing schema migrations before
+	// the compatibility check. This handles upgrades (e.g.
+	// new tables like tool_result_events) without requiring a
+	// manual schema drop. If the PG role is read-only the
+	// migration is skipped and the compat check reports what
+	// is missing.
+	if err := postgres.EnsureSchema(
+		ctx, store.DB(), pgCfg.Schema,
+	); err != nil {
+		if !postgres.IsReadOnlyError(err) {
+			fatal("pg serve: schema migration failed: %v", err)
+		}
+	}
+
 	if err := postgres.CheckSchemaCompat(
 		ctx, store.DB(),
 	); err != nil {

internal/postgres/sync_test.go

@@ -69,6 +69,100 @@ func TestEnsureSchemaIdempotent(t *testing.T) {
 	}
 }
 
+func TestEnsureSchemaMigratesLegacySchema(t *testing.T) {
+	pgURL := testPGURL(t)
+	cleanPGSchema(t, pgURL)
+	t.Cleanup(func() { cleanPGSchema(t, pgURL) })
+
+	pg, err := Open(pgURL, "agentsview", true)
+	if err != nil {
+		t.Fatalf("connecting to pg: %v", err)
+	}
+	defer pg.Close()
+
+	ctx := context.Background()
+
+	// Simulate a 0.16.x schema: create the schema and core
+	// tables but omit tool_result_events.
+	if _, err := pg.ExecContext(ctx,
+		"CREATE SCHEMA IF NOT EXISTS agentsview",
+	); err != nil {
+		t.Fatalf("creating schema: %v", err)
+	}
+	legacyDDL := `
+CREATE TABLE IF NOT EXISTS sync_metadata (
+    key   TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS sessions (
+    id                 TEXT PRIMARY KEY,
+    machine            TEXT NOT NULL,
+    project            TEXT NOT NULL,
+    agent              TEXT NOT NULL,
+    first_message      TEXT,
+    display_name       TEXT,
+    created_at         TIMESTAMPTZ,
+    started_at         TIMESTAMPTZ,
+    ended_at           TIMESTAMPTZ,
+    deleted_at         TIMESTAMPTZ,
+    message_count      INT NOT NULL DEFAULT 0,
+    user_message_count INT NOT NULL DEFAULT 0,
+    parent_session_id  TEXT,
+    relationship_type  TEXT NOT NULL DEFAULT '',
+    updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+CREATE TABLE IF NOT EXISTS messages (
+    session_id     TEXT NOT NULL,
+    ordinal        INT NOT NULL,
+    role           TEXT NOT NULL,
+    content        TEXT NOT NULL,
+    timestamp      TIMESTAMPTZ,
+    has_thinking   BOOLEAN NOT NULL DEFAULT FALSE,
+    has_tool_use   BOOLEAN NOT NULL DEFAULT FALSE,
+    content_length INT NOT NULL DEFAULT 0,
+    is_system      BOOLEAN NOT NULL DEFAULT FALSE,
+    PRIMARY KEY (session_id, ordinal),
+    FOREIGN KEY (session_id)
+        REFERENCES sessions(id) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS tool_calls (
+    id                    BIGSERIAL PRIMARY KEY,
+    session_id            TEXT NOT NULL,
+    tool_name             TEXT NOT NULL,
+    category              TEXT NOT NULL,
+    call_index            INT NOT NULL DEFAULT 0,
+    tool_use_id           TEXT NOT NULL DEFAULT '',
+    input_json            TEXT,
+    skill_name            TEXT,
+    result_content_length INT,
+    result_content        TEXT,
+    subagent_session_id   TEXT,
+    message_ordinal       INT NOT NULL,
+    FOREIGN KEY (session_id)
+        REFERENCES sessions(id) ON DELETE CASCADE
+);`
+	if _, err := pg.ExecContext(ctx, legacyDDL); err != nil {
+		t.Fatalf("creating legacy tables: %v", err)
+	}
+
+	// Verify tool_result_events does not exist yet.
+	if err := CheckSchemaCompat(ctx, pg); err == nil {
+		t.Fatal("expected CheckSchemaCompat to fail on legacy schema")
+	}
+
+	// Run EnsureSchema — should create the missing table.
+	if err := EnsureSchema(ctx, pg, "agentsview"); err != nil {
+		t.Fatalf("EnsureSchema on legacy schema: %v", err)
+	}
+
+	// Now the compat check should pass.
+	if err := CheckSchemaCompat(ctx, pg); err != nil {
+		t.Fatalf(
+			"CheckSchemaCompat after migration: %v", err,
+		)
+	}
+}
+
 func TestPushSingleSession(t *testing.T) {
 	pgURL := testPGURL(t)
 	cleanPGSchema(t, pgURL)