feat: location detail, backfill, trigger schedules and maintenance grant counts

benchmarks/duckshop/edge_cases/orchestration/maintenance_history.json

@@ -40,14 +40,16 @@
       "destination_model": "orders",
       "event_type": "view_created",
       "created_at": "2026-02-03T04:05:07Z",
-      "column_aliases": "{\"order_id\":\"legacy_order_id\"}"
+      "column_aliases": "{\"order_id\":\"legacy_order_id\"}",
+      "grants_copied": "[\"GRANT SELECT ON main.orders_legacy TO fulfillment_readers\", \"GRANT SELECT ON main.orders_legacy TO support_analysts\"]"
     },
     {
       "event_id": "view-customers-1",
       "migration_event_id": "move-customers-1",
       "destination_model": "customers",
       "event_type": "required",
-      "created_at": "2026-02-02T04:05:06Z"
+      "created_at": "2026-02-02T04:05:06Z",
+      "grants_copied": "GRANT SELECT ON main.customers_legacy TO support_analysts"
     },
     {
       "event_id": "view-orders-old-1",

clients/typescript/src/schema.d.ts

@@ -1641,7 +1641,38 @@ export interface components {
             janitor_events: components["schemas"]["WarehouseJanitorRecord"][];
             migrations: components["schemas"]["WarehouseMigrationRecord"][];
             /** @description Every step recorded for the listed moves, oldest first; same-time steps are not in step order. */
-            old_name_views: components["schemas"]["WarehouseOldNameRecord"][];
+            old_name_views: components["schemas"]["MaintenanceOldNameView"][];
+        };
+        /** @description One old-name view step as people read it: copied grants are counted, never returned as statements. */
+        MaintenanceOldNameView: {
+            archive_name?: string | null;
+            column_aliases?: string | null;
+            /** Format: date-time */
+            created_at: string;
+            destination_model: string;
+            drop_reason?: string | null;
+            event_id: string;
+            event_type: string;
+            /** Format: date-time */
+            expires_at?: string | null;
+            /**
+             * Format: int64
+             * @description How many grants were copied onto the view; null until it exists or when the stored list is unreadable.
+             */
+            grants_copied?: number | null;
+            migration_event_id: string;
+            new_database?: string | null;
+            new_name: string;
+            new_schema: string;
+            old_database?: string | null;
+            old_name: string;
+            old_schema?: string | null;
+            run_id: string;
+            state_database?: string | null;
+            state_schema: string;
+            target_name?: string | null;
+            view_retention?: string | null;
+            view_sql?: string | null;
         };
         /** @description One bounded page of one state table from the registered reader of a published generation. */
         MetadataBatch: {
@@ -2560,33 +2591,6 @@ export interface components {
             /** Format: date-time */
             observed_at: string;
         };
-        /** @description Preserve nullable compatibility-view facts without projecting live warehouse existence. */
-        WarehouseOldNameRecord: {
-            archive_name?: string | null;
-            column_aliases?: string | null;
-            /** Format: date-time */
-            created_at: string;
-            destination_model: string;
-            drop_reason?: string | null;
-            event_id: string;
-            event_type: string;
-            /** Format: date-time */
-            expires_at?: string | null;
-            grants_copied?: string | null;
-            migration_event_id: string;
-            new_database?: string | null;
-            new_name: string;
-            new_schema: string;
-            old_database?: string | null;
-            old_name: string;
-            old_schema?: string | null;
-            run_id: string;
-            state_database?: string | null;
-            state_schema: string;
-            target_name?: string | null;
-            view_retention?: string | null;
-            view_sql?: string | null;
-        };
         /** @description Physical namespace of SQLBuild's source-freshness state table, never a source query. */
         WarehouseStateLocation: {
             database?: string | null;

crates/sqlbuild-orchestration/src/warehouse_history/_helpers/maintenance.rs

@@ -2,12 +2,13 @@
 
 use serde::Deserialize;
 use serde::de::DeserializeOwned;
+use sqlbuild_state::events::main::decoded_grants::decoded_grants;
 use uuid::Uuid;
 
 use crate::store::errors::ControlError;
 use crate::store::main::query_records::query_records;
 use crate::store::models::{ControlTransaction, Parameter};
-use crate::warehouse_history::models::MaintenanceHistory;
+use crate::warehouse_history::models::{MaintenanceHistory, MaintenanceOldNameView};
 use crate::warehouse_metadata::models::{
     WarehouseJanitorRecord, WarehouseMigrationRecord, WarehouseOldNameRecord,
 };
@@ -55,7 +56,7 @@ pub(crate) async fn maintenance_history(
             }
         };
     let mut transaction = transaction;
-    let mut old_name_views: Vec<WarehouseOldNameRecord> = Vec::new();
+    let mut stored_views: Vec<WarehouseOldNameRecord> = Vec::new();
     if !migrations.is_empty() {
         let mut parameters = scope.clone();
         parameters.extend(
@@ -64,7 +65,7 @@ pub(crate) async fn maintenance_history(
                 .map(|migration| Parameter::Text(migration.event_id.clone())),
         );
         let placeholders = Parameter::placeholders(3..=parameters.len());
-        (transaction, old_name_views) = records(transaction,
+        (transaction, stored_views) = records(transaction,
             &format!("SELECT record_json AS record FROM sqb_warehouse_old_name_views WHERE location_id=$1 AND target=$2 \
                       AND migration_event_id IN ({placeholders}) ORDER BY observed_at,event_id"),
             parameters).await?;
@@ -80,8 +81,37 @@ pub(crate) async fn maintenance_history(
         transaction,
         MaintenanceHistory {
             migrations,
-            old_name_views,
+            old_name_views: stored_views.into_iter().map(old_name_view).collect(),
             janitor_events,
         },
     ))
 }
+
+/// The stored step with its grant statements reduced to their number, read the way local `sqb` reads them.
+fn old_name_view(record: WarehouseOldNameRecord) -> MaintenanceOldNameView {
+    MaintenanceOldNameView {
+        grants_copied: decoded_grants(record.grants_copied.as_deref())
+            .map(|statements| statements.len() as u64),
+        state_database: record.state_database,
+        state_schema: record.state_schema,
+        event_id: record.event_id,
+        target_name: record.target_name,
+        event_type: record.event_type,
+        migration_event_id: record.migration_event_id,
+        destination_model: record.destination_model,
+        old_database: record.old_database,
+        old_schema: record.old_schema,
+        old_name: record.old_name,
+        new_database: record.new_database,
+        new_schema: record.new_schema,
+        new_name: record.new_name,
+        view_retention: record.view_retention,
+        archive_name: record.archive_name,
+        column_aliases: record.column_aliases,
+        view_sql: record.view_sql,
+        expires_at: record.expires_at,
+        drop_reason: record.drop_reason,
+        run_id: record.run_id,
+        created_at: record.created_at,
+    }
+}

crates/sqlbuild-orchestration/src/warehouse_history/models.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::warehouse_metadata::models::{
-    WarehouseAuditRecord, WarehouseJanitorRecord, WarehouseMigrationRecord, WarehouseOldNameRecord,
+    WarehouseAuditRecord, WarehouseJanitorRecord, WarehouseMigrationRecord,
 };
 
 /// One stored check result. Its SQL, error texts and evidence rows need their own permissions.
@@ -96,12 +96,40 @@ pub struct CheckEvidence {
     pub truncated: Option<String>,
 }
 
+/// One old-name view step as people read it: copied grants are counted, never returned as statements.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct MaintenanceOldNameView {
+    pub state_database: Option<String>,
+    pub state_schema: String,
+    pub event_id: String,
+    pub target_name: Option<String>,
+    pub event_type: String,
+    pub migration_event_id: String,
+    pub destination_model: String,
+    pub old_database: Option<String>,
+    pub old_schema: Option<String>,
+    pub old_name: String,
+    pub new_database: Option<String>,
+    pub new_schema: String,
+    pub new_name: String,
+    pub view_retention: Option<String>,
+    pub archive_name: Option<String>,
+    pub column_aliases: Option<String>,
+    /// How many grants were copied onto the view; null until it exists or when the stored list is unreadable.
+    pub grants_copied: Option<u64>,
+    pub view_sql: Option<String>,
+    pub expires_at: Option<DateTime<Utc>>,
+    pub drop_reason: Option<String>,
+    pub run_id: String,
+    pub created_at: DateTime<Utc>,
+}
+
 /// Recorded moves, their old-name view steps and janitor cleanups, newest moves first.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, utoipa::ToSchema)]
 pub struct MaintenanceHistory {
     pub migrations: Vec<WarehouseMigrationRecord>,
     /// Every step recorded for the listed moves, oldest first; same-time steps are not in step order.
-    pub old_name_views: Vec<WarehouseOldNameRecord>,
+    pub old_name_views: Vec<MaintenanceOldNameView>,
     /// Empty when the history is for one model; cleanups are not tied to models.
     pub janitor_events: Vec<WarehouseJanitorRecord>,
 }

crates/sqlbuild-orchestration/tests/api/test_maintenance.rs

@@ -110,6 +110,32 @@ fn given_moves_views_and_cleanups_when_people_read_maintenance_then_each_model_s
                 "another target's steps never appear"
             );
             assert_eq!(ids(&all, "janitor_events"), ["cleanup-2", "cleanup-1"]);
+            let grants: Vec<(&str, &Value)> = all["old_name_views"]
+                .as_array()
+                .expect("views")
+                .iter()
+                .map(|view| {
+                    (
+                        view["event_id"].as_str().expect("id"),
+                        &view["grants_copied"],
+                    )
+                })
+                .collect();
+            assert_eq!(
+                grants,
+                [
+                    ("view-orders-old-1", &Value::Null),
+                    ("view-customers-1", &Value::Null),
+                    ("view-orders-1", &Value::Null),
+                    ("view-orders-2", &json!(2))
+                ],
+                "copied grants are counted, and unreadable stored text reads as unknown"
+            );
+            let body = all.to_string();
+            assert!(
+                !body.contains("GRANT") && !body.contains("support_analysts"),
+                "no grant statement or grantee reaches people: {body}"
+            );
             assert_eq!(all["migrations"][0]["origin_model"], Value::Null);
             assert_eq!(all["migrations"][0]["discovery"], "automatic");
 

ui/src/lib/api/http-client.test.ts

@@ -354,6 +354,120 @@ describe('overview', () => {
 	});
 });
 
+describe('locations', () => {
+	const access = (target: string) => ({ location_id: '0191f0aa-orders', name: 'Orders', target, actions: [] });
+	const report = (session: string, secondsAgo: number) => ({
+		received_at: new Date(Date.now() - secondsAgo * 1000).toISOString(),
+		report: { event_id: `e-${session}-${secondsAgo}`, session_id: session, target: 'development', health: { kind: 'heartbeat' } }
+	});
+
+	/** Orders development is readable and orders preview refuses its health read, as for a partial viewer. */
+	function server() {
+		const paths: string[] = [];
+		vi.stubGlobal('document', { cookie: '' });
+		vi.stubGlobal(
+			'fetch',
+			vi.fn(async (request: Request) => {
+				const path = new URL(request.url).pathname;
+				paths.push(path);
+				if (path.endsWith('/bootstrap')) return Response.json({ login_mode: 'password', access: { name: 'ada', principal_id: 'p', actions: [], locations: [access('development'), access('preview')] } });
+				if (path.endsWith('/platform/problems'))
+					return Response.json({
+						scheduler_leader: true,
+						scheduler_lease_expires_at: '2026-11-09T10:00:30Z',
+						broken_locations: [{ location_id: '0191f0aa-orders', location_name: 'Orders', target: 'development', last_seen_at: '2026-11-09T09:00:00Z' }],
+						overdue_ticks: []
+					});
+				if (path.includes('/targets/preview/')) return Response.json({ error: 'refused' }, { status: 403 });
+				if (path.endsWith('/health')) return Response.json([report('s-2', 10), report('s-1', 400), report('s-2', 20)]);
+				return Response.json([]);
+			})
+		);
+		return { paths, client: createHttpClient({ baseUrl: 'http://ui.test', onUnauthorized: () => {} }) };
+	}
+
+	it('opens a readable location with one process per session', async () => {
+		const detail = await server().client.getLocation('0191f0aa-orders:development');
+		expect(detail?.instances.map((i) => [i.id, i.state])).toEqual([
+			['s-2', 'live'],
+			['s-1', 'stale']
+		]);
+	});
+
+	it('fails the page with the refusal when the person may not read the target health', async () => {
+		await expect(server().client.getLocation('0191f0aa-orders:preview')).rejects.toMatchObject({ status: 403 });
+	});
+
+	it('is null for a location the person is not given, without reading its health', async () => {
+		const { paths, client } = server();
+		expect(await client.getLocation('0191f0aa-orders:production')).toBeNull();
+		expect(paths.some((p) => p.endsWith('/health'))).toBe(false);
+	});
+
+	it('counts open problems per location target', async () => {
+		const listed = await server().client.listLocations();
+		expect(listed.map((l) => [l.id, l.activeProblems, l.health])).toEqual([
+			['0191f0aa-orders:development', 1, 'healthy'],
+			['0191f0aa-orders:preview', 0, null]
+		]);
+	});
+});
+
+describe('launchJob', () => {
+	function server(answer: Response) {
+		const posts: unknown[] = [];
+		vi.stubGlobal('document', { cookie: 'sqb-csrf=token-1' });
+		vi.stubGlobal(
+			'fetch',
+			vi.fn(async (request: Request) => {
+				if (request.method === 'POST') {
+					posts.push(await request.json());
+					return answer.clone();
+				}
+				return Response.json([]);
+			})
+		);
+		return { posts, client: createHttpClient({ baseUrl: 'http://ui.test', onUnauthorized: () => {} }) };
+	}
+
+	it('sends a backfill window with the job run request', async () => {
+		const { posts, client } = server(Response.json({ error: 'stop here' }, { status: 409 }));
+		await expect(client.launchJob(ORDERS, 'daily', { window: { type: 'timestamp', start: '1200', end: '1500' } })).rejects.toThrow();
+		expect(posts[0]).toMatchObject({ job_key: 'daily', target: 'development', window: { kind: 'integer', start: 1200, end: 1500 } });
+	});
+
+	it('leaves the window out of an ordinary run', async () => {
+		const { posts, client } = server(Response.json({ error: 'stop here' }, { status: 409 }));
+		await expect(client.launchJob(ORDERS, 'daily')).rejects.toThrow();
+		expect(posts[0]).not.toHaveProperty('window');
+	});
+
+	it("shows a plain-text refusal of a body the server couldn't read", async () => {
+		const text = 'Failed to deserialize the JSON body into the target type: window: input contains invalid characters';
+		const { client } = server(new Response(text, { status: 422, headers: { 'content-type': 'text/plain; charset=utf-8' } }));
+		await expect(client.launchJob(ORDERS, 'daily', { window: { type: 'timestamp', start: '2026-10-01', end: '2026-10-31T00:00:00Z' } })).rejects.toMatchObject({ status: 422, message: text });
+	});
+
+	it('shows the status, not an HTML error page from something in front of the server', async () => {
+		const { client } = server(new Response('<html><body>Bad gateway</body></html>', { status: 502, statusText: 'Bad Gateway', headers: { 'content-type': 'text/html' } }));
+		await expect(client.launchJob(ORDERS, 'daily')).rejects.toMatchObject({ status: 502, message: '502 Bad Gateway' });
+	});
+
+	it('shows only the status for a plain-text server failure, which can name internal types', async () => {
+		const text = 'Missing request extension: Extension of type `example::AuditContext` was not found.';
+		const { client } = server(new Response(text, { status: 500, statusText: 'Internal Server Error', headers: { 'content-type': 'text/plain; charset=utf-8' } }));
+		await expect(client.launchJob(ORDERS, 'daily')).rejects.toMatchObject({ status: 500, message: '500 Internal Server Error' });
+	});
+
+	it("shows the server's refusal of a window as it comes", async () => {
+		const { client } = server(Response.json({ error: 'backfill window start must not follow end' }, { status: 400 }));
+		await expect(client.launchJob(ORDERS, 'daily', { window: { type: 'timestamp', start: '20', end: '10' } })).rejects.toMatchObject({
+			status: 400,
+			message: expect.stringContaining('backfill window start must not follow end')
+		});
+	});
+});
+
 describe('administration writes', () => {
 	const ada = { principal_id: 'p-ada', name: 'ada', created_at: '2026-11-01T00:00:00Z', disabled_at: null, has_password: true, groups: [], active_sessions: 2, last_signed_in_at: null };