config + store: remove dead knobs and stale schema

Three drift items surfaced in review, each dead on arrival and each
worth trusting a little more at v0.1.0.

config: drop MetricsPollInterval. The field was parsed from TOML
(metrics_poll_interval), stored on DaemonConfig, and ignored by every
consumer — only StatsPollInterval drives the background poll loop.
Users setting it in config.toml saw zero effect. Removed from the TOML
surface, the model constant, and the config test.

daemon: delete ensureDefaultImage. No callers, body was `_ = ctx;
return nil`. Dead since whatever flow used to call it got removed.

store: drop packages_path from the images table. The column was
carried by the baseline migration but never referenced by UpsertImage
(no INSERT / UPDATE mention) or any Go model field — a ghost from a
build pipeline that no longer exists. Added migration id=2
(drop_dead_image_columns) with an idempotent dropColumnIfExists
helper: fresh installs run baseline (creates the column) + 2 (drops
it); legacy DBs where the column was never added get a no-op. Updated
the direct-INSERT SQL in TestGetImageRejectsMalformedTimestamp to
drop the column reference, and added a migration test covering both
install paths (fresh + legacy).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

internal/store/migrations.go

@@ -24,6 +24,7 @@ type migration struct {
 // entries — installed DBs key off the id column.
 var migrations = []migration{
 	{id: 1, name: "baseline", up: migrateBaseline},
+	{id: 2, name: "drop_dead_image_columns", up: migrateDropDeadImageColumns},
 }
 
 // runMigrations ensures schema_migrations exists, then applies every
@@ -163,6 +164,55 @@ func migrateBaseline(tx *sql.Tx) error {
 	return nil
 }
 
+// migrateDropDeadImageColumns removes image-table columns that the
+// store never reads or writes. `packages_path` was introduced for a
+// build pipeline that no longer exists; the baseline migration still
+// creates it for historical fidelity, and this migration drops it on
+// new installs + any upgrader that still carries it. Idempotent via
+// dropColumnIfExists so running the migration twice (or against a
+// DB where the column was already gone) is a no-op.
+func migrateDropDeadImageColumns(tx *sql.Tx) error {
+	return dropColumnIfExists(tx, "images", "packages_path")
+}
+
+// dropColumnIfExists is SQLite's "ALTER TABLE DROP COLUMN IF EXISTS"
+// (which the dialect lacks) as a library function. modernc.org/sqlite
+// bundles SQLite 3.42+, which supports plain DROP COLUMN — we add the
+// existence guard so the statement is idempotent across repeat runs
+// and legacy DBs that never had the column in the first place.
+func dropColumnIfExists(tx *sql.Tx, table, column string) error {
+	rows, err := tx.Query(fmt.Sprintf("PRAGMA table_info(%s)", table))
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+	var found bool
+	for rows.Next() {
+		var (
+			cid       int
+			name      string
+			valueType string
+			notNull   int
+			defaultV  sql.NullString
+			pk        int
+		)
+		if err := rows.Scan(&cid, &name, &valueType, &notNull, &defaultV, &pk); err != nil {
+			return err
+		}
+		if name == column {
+			found = true
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return err
+	}
+	if !found {
+		return nil
+	}
+	_, err = tx.Exec(fmt.Sprintf("ALTER TABLE %s DROP COLUMN %s", table, column))
+	return err
+}
+
 // addColumnIfMissing is SQLite's "ALTER TABLE ADD COLUMN IF NOT EXISTS"
 // (which the dialect lacks) as a library function. Used inside
 // migrations when a column needs to survive a database that went

internal/store/migrations_test.go

@@ -141,6 +141,80 @@ func TestApplyMigrationRollsBackOnBodyError(t *testing.T) {
 	}
 }
 
+// TestMigrateDropDeadImageColumns_AcrossInstallPaths verifies the
+// drop-column migration is correct on both paths it can land on:
+// a fresh install (baseline created the column, migration 2 drops
+// it) and a legacy DB that somehow lost or never had the column
+// (migration 2 is a no-op). Runs migrations end-to-end so the
+// invariant-check is the real system, not the helper in isolation.
+func TestMigrateDropDeadImageColumns_AcrossInstallPaths(t *testing.T) {
+	hasColumn := func(t *testing.T, db *sql.DB, table, column string) bool {
+		t.Helper()
+		rows, err := db.Query("PRAGMA table_info(" + table + ")")
+		if err != nil {
+			t.Fatalf("PRAGMA table_info: %v", err)
+		}
+		defer rows.Close()
+		for rows.Next() {
+			var (
+				cid       int
+				name      string
+				valueType string
+				notNull   int
+				defaultV  sql.NullString
+				pk        int
+			)
+			if err := rows.Scan(&cid, &name, &valueType, &notNull, &defaultV, &pk); err != nil {
+				t.Fatalf("scan table_info row: %v", err)
+			}
+			if name == column {
+				return true
+			}
+		}
+		if err := rows.Err(); err != nil {
+			t.Fatalf("rows.Err: %v", err)
+		}
+		return false
+	}
+
+	t.Run("fresh install drops packages_path", func(t *testing.T) {
+		db := openRawDB(t)
+		if err := runMigrations(db); err != nil {
+			t.Fatalf("runMigrations: %v", err)
+		}
+		if hasColumn(t, db, "images", "packages_path") {
+			t.Fatal("packages_path column survived migration 2 on fresh install")
+		}
+	})
+
+	t.Run("legacy DB without column is a no-op", func(t *testing.T) {
+		db := openRawDB(t)
+		// Simulate a DB whose baseline was applied against a modified
+		// schema that never had packages_path: seed schema_migrations,
+		// run baseline, drop the column out-of-band, then run
+		// runMigrations and expect migration 2 to succeed regardless.
+		if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS schema_migrations (
+			id INTEGER PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TEXT NOT NULL
+		)`); err != nil {
+			t.Fatalf("seed schema_migrations: %v", err)
+		}
+		if err := applyMigration(db, migrations[0]); err != nil {
+			t.Fatalf("apply baseline: %v", err)
+		}
+		if _, err := db.Exec("ALTER TABLE images DROP COLUMN packages_path"); err != nil {
+			t.Fatalf("pre-drop packages_path: %v", err)
+		}
+		if err := runMigrations(db); err != nil {
+			t.Fatalf("runMigrations after manual pre-drop: %v", err)
+		}
+		if hasColumn(t, db, "images", "packages_path") {
+			t.Fatal("packages_path reappeared after runMigrations")
+		}
+	})
+}
+
 func TestRunMigrationsRejectsDuplicateID(t *testing.T) {
 	db := openRawDB(t)
 	orig := migrations

internal/store/store_test.go

@@ -178,8 +178,8 @@ func TestGetImageRejectsMalformedTimestamp(t *testing.T) {
 	_, err := store.db.ExecContext(ctx, `
 		INSERT INTO images (
 			id, name, managed, artifact_dir, rootfs_path, kernel_path, initrd_path,
-			modules_dir, packages_path, build_size, docker, created_at, updated_at
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			modules_dir, build_size, docker, created_at, updated_at
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 		"image-bad-time",
 		"image-bad-time",
 		0,
@@ -189,7 +189,6 @@ func TestGetImageRejectsMalformedTimestamp(t *testing.T) {
 		"",
 		"",
 		"",
-		"",
 		0,
 		"not-a-time",
 		"not-a-time",