@ultimat3/cli 1.2.0 → 3.0.0

package/src/index.ts

@@ -2,6 +2,8 @@
 // on these, and a barrel that re-exports everything would make every internal a compatibility
 // promise.
 
+/** The app's own API over HTTP — the one table `x dev` and a container both mount. */
+export { apiRoutes } from './api-routes';
 export type { BoundaryCode, SourceFile } from './app-boundaries';
 export {
   appImportGraph,
@@ -32,7 +34,8 @@ export {
   readTarget,
   requireEntry,
 } from './cmd-build';
-export { branchDatabaseName, branchSql, dbCommand, previewUrl } from './cmd-db';
+export { dbCommand } from './cmd-db';
+export { runBranchCommand } from './cmd-db-branch';
 export type { DeployPlan } from './cmd-deploy';
 export { deployCommand, planDeploy } from './cmd-deploy';
 export type { DevServer, StartDevOptions } from './cmd-dev';
@@ -50,14 +53,30 @@ export type { McpHttpServer } from './cmd-mcp';
 export { mcpCommand, startMcpHttp } from './cmd-mcp';
 export type { NewAppOptions, WrittenApp } from './cmd-new';
 export { newCommand, planNewApp, writeNewApp } from './cmd-new';
-export type { PlannedCommand } from './cmd-planned';
-export { PLANNED_COMMANDS, plannedCommands } from './cmd-planned';
+export type { PlannedCommand, PlannedSubcommand } from './cmd-planned';
+export {
+  PLANNED_COMMANDS,
+  PLANNED_SUBCOMMANDS,
+  plannedCommands,
+  plannedSubcommand,
+} from './cmd-planned';
 export { actionsCommand, entitiesCommand, queriesCommand } from './cmd-registries';
 export { renderRouteTable, routesCommand } from './cmd-routes';
-export { availableCpus, testCommand } from './cmd-test';
+export { testCommand } from './cmd-test';
 export { runVerify, VERIFY_STEPS, verifyCommand, verifyStepNames } from './cmd-verify';
 export type { CliCommand, CommandContext } from './command';
 export { failed, ok } from './command';
+export type { BranchRow, BranchSubcommand } from './db-branch';
+export {
+  BRANCH_SUBCOMMANDS,
+  branchDatabaseName,
+  branchNameOf,
+  isBranchSubcommand,
+  pgliteBranchName,
+  previewUrl,
+} from './db-branch';
+export type { GeneratedFiles, GenerateMigrationOptions, GenerateOutcome } from './db-generate';
+export { generateAppMigration, migrationSql } from './db-generate';
 export type { AssetRoutesOptions } from './dev-assets';
 export {
   assetRoutes,
@@ -80,7 +99,14 @@ export type { DevServices, ServiceBinding } from './dev-services';
 export { describeServices, resolveServices } from './dev-services';
 export type { DispatchOptions } from './dispatch';
 export { dispatch } from './dispatch';
-export { checkDrift, recordedHashes, schemaHash, writeSchemaHash } from './drift';
+export type { DeclaredEntityCount, HashReconciliation } from './drift';
+export {
+  checkSourceDrift,
+  reconcileSchemaHash,
+  recordedHashes,
+  schemaHash,
+  writeSchemaHash,
+} from './drift';
 export type { ErrorCatalog } from './error-catalog';
 export {
   buildErrorCatalog,
@@ -89,6 +115,8 @@ export {
   registeredErrorCodes,
   resetErrorCatalog,
 } from './error-catalog';
+export type { CliErrorCode } from './error-codes';
+export { CLI_ERROR_CODES, CLI_ERROR_TITLES } from './error-codes';
 export {
   BANNED_PHRASES,
   COMMAND_TOKENS,
@@ -102,19 +130,26 @@ export {
   RESERVED_HEADING,
   staticFix,
 } from './error-contract';
-export type { CliErrorCode } from './errors';
+export type { CodeFixIndex, CodeFixScan } from './error-fixes';
+export {
+  codeFixes,
+  codeFixScan,
+  loadCodeFixes,
+  resetCodeFixes,
+  scanScopeFixes,
+} from './error-fixes';
 export {
   BadFlagError,
   BuildEntryMissingError,
   BunVersionError,
   CatalogExistsError,
-  CLI_ERROR_CODES,
-  CLI_ERROR_TITLES,
   CliNotImplementedError,
   DeclarationUnknownError,
   ErrorCodeUnknownError,
   FixTargetUnknownError,
   JobUnknownError,
+  MissingPositionalError,
+  MissingSubcommandError,
   NoTestFilesError,
   NotInAppError,
   PortInvalidError,
@@ -124,6 +159,16 @@ export {
 } from './errors';
 export type { ExecOptions, ExecResult, Runner } from './exec';
 export { exec, execOutput } from './exec';
+export type { CitationFault, CitationRules, CommandCatalog, FixCitation } from './fix-command';
+export {
+  citationFault,
+  citationProblem,
+  citedCommandProblem,
+  fixCitations,
+  loadCommandCatalog,
+} from './fix-command';
+export type { Guard } from './guards';
+export { findingProblem, GUARD_DIR, guardFindings, guardPaths } from './guards';
 export type { DrainFailure, DrainOutcome, DrainSkip } from './jobs-drain';
 export { drainJobs } from './jobs-drain';
 export type { JobsListFilter, JobsListResult } from './jobs-report';
@@ -134,7 +179,14 @@ export { createDevMcpServer, DEV_TOOL_SCOPES, localCaller } from './mcp-host';
 export { messageKeys, msg } from './messages';
 export type { MetricsEndpoint, MetricsEndpointOptions } from './metrics-endpoint';
 export { DEFAULT_METRICS_PORT, startMetricsEndpoint } from './metrics-endpoint';
-export { MIGRATIONS_DIR, migrationName, parseMigrationSql, readMigrations } from './migrations';
+export {
+  hashFileName,
+  MIGRATIONS_DIR,
+  migrationName,
+  parseMigrationSql,
+  readMigrations,
+  snapshotFileName,
+} from './migrations';
 export type { CommandResult, Finding, JsonValue, StepResult } from './output';
 export {
   exitCodeFor,
@@ -148,9 +200,14 @@ export {
 } from './output';
 export type { CommandSpec, FlagSpec, ParsedArgs } from './parse';
 export { flagBool, flagList, flagString, GLOBAL_FLAGS, nearest, parseArgs } from './parse';
-export type { PrerenderedPage, PrerenderOptions, PrerenderReport } from './prerender';
+export type {
+  PrerenderedPage,
+  PrerenderOptions,
+  PrerenderReport,
+  UnmeasuredRoute,
+} from './prerender';
 export { DEFAULT_ORIGIN, isPrerenderable, prerenderSite } from './prerender';
-export { CLI_VERSION, COMMANDS, commandFor, SPECS } from './registry';
+export { COMMANDS, cliVersion, commandFor, SPECS } from './registry';
 export type { MigratedApp, ServedApp, ServeOptions, StartedApp } from './serve';
 export {
   CONTAINER_BINDING,
@@ -162,6 +219,7 @@ export {
   runRole,
   serveApp,
 } from './serve';
+export { quoteArg } from './shell-quote';
 export {
   eachSourceFile,
   isGenerated,
@@ -169,19 +227,36 @@ export {
   isVendored,
   SOURCE_GLOBS,
 } from './source-files';
+export type { TestCounts } from './test-counts';
+export { countsOf } from './test-counts';
 export type { TestFile } from './test-select';
 export { belongsToType, discoverTests, sampleFiles } from './test-select';
 export type { ReproduceOptions, RunShardsOptions, Shard } from './test-shards';
-export { planShards, quoteArg, reproduceFor, runShards, shardArgs } from './test-shards';
-export type { CodeSite, FixSite, SourceSite } from './ts-scan';
+export { planShards, reproduceFor, runShards, shardArgs } from './test-shards';
+export { availableCpus, defaultWorkers, WORKER_CEILING } from './test-workers';
+export type { CodeFixSite, CodeSite, FixSite, SourceSite } from './ts-scan';
 export {
   isCodeRegistry,
   maskLiterals,
   scanBorrowedCodes,
+  scanCodeFixSites,
   scanCodes,
   scanFixes,
   stripComments,
 } from './ts-scan';
+// The one spelling rule for a `references` entry. Exported because the two gate scripts ask the
+// same question this package's `package-shape` step does, and three answers is a duplicate entry.
+export { normalizeReferencePath } from './tsconfig-references';
+export type { VerifyFloor } from './verify-floor';
+export {
+  floorProblemFindings,
+  floorRequires,
+  parseVerifyFloor,
+  readVerifyFloor,
+  skippedSuiteFinding,
+  VERIFY_FLOOR_FILE,
+  vanishedSuiteFinding,
+} from './verify-floor';
 export type {
   HostCheck,
   StepOutcome,
@@ -191,8 +266,8 @@ export type {
 } from './verify-step';
 export { VERIFY_STEP_NAMES } from './verify-step';
 export type { TestType } from './verify-tests';
-export { TEST_STEPS, TEST_TYPES, testStepCommand, typeFilterOf } from './verify-tests';
-export type { ManifestFacts } from './workspace-checks';
+export { TEST_STEPS, TEST_TYPES, testStepCommand, typeFiltersOf } from './verify-tests';
+export type { ManifestFacts, PackageShapeOptions } from './workspace-checks';
 export {
   checkFileSizes,
   checkLockstep,
@@ -201,5 +276,7 @@ export {
   hasWorkspacePackages,
   LINE_CEILING,
   PACKAGE_FILES,
+  SEMVER,
   workspacePackages,
 } from './workspace-checks';
+export { writeLine } from './write-line';

package/src/island-bundle.ts

@@ -0,0 +1,166 @@
+// The island chunk table: every `*.island.tsx` in the app compiled as its OWN bundle entry point,
+// content-hashed, plus the resolver that turns a page's `src` specifier into the URL its
+// `data-x-entry` carries. One entry point per island is axiom 6 made mechanical — the page's graph
+// never reaches an island, so a `site/` document stays at 0kb whatever the island imports.
+
+// Bun ships no path API. `posix` does the specifier arithmetic (an app-relative route file is
+// POSIX by construction), `join`/`basename` the filesystem side.
+import { basename, join, posix, relative, sep } from 'node:path';
+import {
+  contentHash,
+  ISLAND_EXTENSION,
+  IslandInvalidError,
+  islandModuleId,
+} from '@ultimat3/render';
+import { IslandBuildFailedError } from './errors';
+
+/**
+ * Where a chunk is served from, in `x dev`, in the container and in a static export — one base
+ * path, because the URL is minted by one resolver and baked into the document. Sits beside
+ * `ICON_BASE_PATH` and `MEDIA_BASE_PATH`, deliberately outside the dev-only `/_x` namespace.
+ */
+export const ISLAND_BASE_PATH = '/islands';
+
+/**
+ * `shared/` is in and `api/` is out: an island is markup, and an API route has no document to put
+ * it in. The glob is the whole discovery rule — a file ships to the browser if and only if its
+ * name says so, which is what makes "what ships JS?" answerable without opening a file.
+ */
+export const ISLAND_GLOB = `apps/*/{site,app,shared}/**/*${ISLAND_EXTENSION}`;
+
+export interface IslandChunk {
+  /** App-root-relative POSIX path of the client entry it was built from. */
+  readonly file: string;
+  /** `islandModuleId` of the filename — the id the document, the budget and a finding all name. */
+  readonly moduleId: string;
+  /** Immutable, content-addressed URL. What `data-x-entry` carries and what a route serves. */
+  readonly url: string;
+  /** The built JavaScript. Held in memory so `x dev` and the container serve without a disk hop. */
+  readonly code: string;
+  readonly bytes: number;
+}
+
+export interface IslandBundle {
+  readonly chunks: readonly IslandChunk[];
+  /**
+   * The `resolve` a collector is built with, bound to the route file the specifier is relative to.
+   * Every island on that page goes through it, so an unbuildable specifier fails the render rather
+   * than emitting a `data-x-entry` no browser can import.
+   */
+  resolverFor(routeFile: string): (src: string) => string;
+  /** The chunk a URL names — for serving it, and for naming the island a budget finding blames. */
+  chunkAt(url: string): IslandChunk | undefined;
+}
+
+/** App-root-relative POSIX paths of every client entry, sorted, so a build is reproducible. */
+export async function discoverIslands(root: string): Promise<readonly string[]> {
+  const files: string[] = [];
+  for await (const absolute of new Bun.Glob(ISLAND_GLOB).scan({ cwd: root, absolute: true })) {
+    if (absolute.includes('node_modules')) continue;
+    files.push(relative(root, absolute).split(sep).join('/'));
+  }
+  return files.sort();
+}
+
+/**
+ * One `Bun.build` per island, never one call with N entry points: splitting is off, so each chunk
+ * is self-contained and its size is the whole answer to "what does booting this island cost?" —
+ * a shared chunk would make the honest number a graph walk, and the budget compares against bytes.
+ */
+async function buildOne(root: string, file: string): Promise<IslandChunk> {
+  // `Bun.build` REJECTS on a failed bundle, it does not answer `success: false` — so the catch is
+  // the real path here and the `success` test below is the belt for a future default.
+  let built: Awaited<ReturnType<typeof Bun.build>>;
+  try {
+    built = await Bun.build({
+      entrypoints: [join(root, file)],
+      target: 'browser',
+      format: 'esm',
+      splitting: false,
+      minify: true,
+    });
+  } catch (error) {
+    throw new IslandBuildFailedError({ file, logs: describeBuildError(error) });
+  }
+  const output = built.outputs.find((artifact) => artifact.kind === 'entry-point');
+  if (!built.success || output === undefined) {
+    throw new IslandBuildFailedError({
+      file,
+      logs: built.logs.map((log) => String(log)).join('; '),
+    });
+  }
+  const code = await output.text();
+  const moduleId = islandModuleId(basename(file));
+  return {
+    file,
+    moduleId,
+    // Hashed with the framework's own `contentHash`, the function that already stamps an ETag and
+    // a precache revision — one identity for a byte string, not a third.
+    url: `${ISLAND_BASE_PATH}/${moduleId}-${contentHash(code)}.js`,
+    code,
+    bytes: new TextEncoder().encode(code).byteLength,
+  };
+}
+
+/**
+ * The bundler's own diagnostics, kept verbatim. An `AggregateError` holds one entry per unresolved
+ * import or syntax error, and flattening them is what puts the line number in the cause instead of
+ * the word "Bundle failed".
+ */
+function describeBuildError(error: unknown): string {
+  if (error instanceof AggregateError) {
+    return error.errors.map((one: unknown) => String(one)).join('; ');
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Build every island in the app. An app with none returns an empty bundle and costs one glob. */
+export async function buildIslands(root: string): Promise<IslandBundle> {
+  const files = await discoverIslands(root);
+  const chunks = await Promise.all(files.map((file) => buildOne(root, file)));
+  return islandBundle(chunks);
+}
+
+export function islandBundle(chunks: readonly IslandChunk[]): IslandBundle {
+  const byFile = new Map(chunks.map((chunk) => [chunk.file, chunk]));
+  const byUrl = new Map(chunks.map((chunk) => [chunk.url, chunk]));
+  return {
+    chunks,
+    resolverFor(routeFile: string): (src: string) => string {
+      const dir = posix.dirname(routeFile);
+      return (src: string): string => {
+        const target = posix.normalize(posix.join(dir, src));
+        const chunk = byFile.get(target);
+        if (chunk === undefined) throw entryMissing(routeFile, src, target, chunks);
+        return chunk.url;
+      };
+    },
+    chunkAt: (url: string): IslandChunk | undefined => byUrl.get(url),
+  };
+}
+
+/**
+ * The specifier named no file the build could bundle. `X_ISLAND_INVALID` is render's and is
+ * borrowed rather than renamed here: "this src cannot become a client entry" is the condition that
+ * code already means, and a second name for it is a second thing to look up.
+ */
+function entryMissing(
+  routeFile: string,
+  src: string,
+  target: string,
+  chunks: readonly IslandChunk[],
+): IslandInvalidError {
+  const known = chunks.map((chunk) => chunk.file);
+  return new IslandInvalidError(
+    `${routeFile} declares island src ${JSON.stringify(src)}, which resolves to ${target} — a ` +
+      `file this build did not bundle (${known.length === 0 ? 'it found no islands at all' : `it found ${known.join(', ')}`})`,
+    `x g island ${posix.basename(target, ISLAND_EXTENSION)} --at ${posix.dirname(target)}`,
+  );
+}
+
+/** Write every chunk under the static export, at the same URL the documents already carry. */
+export async function writeIslands(bundle: IslandBundle, out: string): Promise<void> {
+  for (const chunk of bundle.chunks) {
+    await Bun.write(join(out, chunk.url.slice(1)), chunk.code);
+  }
+}

package/src/island-routes.ts

@@ -0,0 +1,50 @@
+// Serving the island chunks a build produced. `x dev` and the container mount the same route over
+// the same table, because a chunk URL is baked into the document by one resolver — a dev-only path
+// would be a page that boots in `x dev` and 404s in the image.
+
+import type { Route, UltimateRequest } from '@ultimat3/http';
+import { applyCacheHeaders, json } from '@ultimat3/http';
+import type { IslandBundle } from './island-bundle';
+import { ISLAND_BASE_PATH } from './island-bundle';
+
+/**
+ * A getter, not the bundle: `x dev` rebuilds the chunks on the same watcher tick that rebuilds the
+ * manifest, and a table captured when the route was mounted would serve the island as it was at
+ * boot for the rest of the session.
+ */
+export type IslandSource = () => IslandBundle;
+
+/**
+ * The URL is content-addressed, so the bytes behind it never change and the answer is immutable.
+ * A miss can only be a document older than this process's chunks — which is a fact worth stating,
+ * not a bare 404 whose meaning an agent has to guess.
+ */
+export function islandRoutes(source: IslandSource): readonly Route[] {
+  return [
+    {
+      method: 'GET',
+      path: `${ISLAND_BASE_PATH}/*file`,
+      meta: { name: 'assets.island', auth: 'public', tags: ['assets'] },
+      handler: (request: UltimateRequest): Response => {
+        const chunk = source().chunkAt(request.pathname);
+        if (chunk === undefined) {
+          return json(
+            {
+              ok: false,
+              error: {
+                code: 'X_ROUTE_NOT_FOUND',
+                cause: `no island chunk is built at ${request.pathname} — the document that asked for it was rendered against an older build`,
+                fix: 'x build --target static --json   # then reload, so the page carries this build’s chunk URLs',
+              },
+            },
+            { status: 404 },
+          );
+        }
+        return applyCacheHeaders(
+          new Response(chunk.code, { headers: { 'content-type': 'text/javascript' } }),
+          { mode: 'immutable' },
+        );
+      },
+    },
+  ];
+}

package/src/jobs-driver.ts

@@ -0,0 +1,33 @@
+// The one place a CLI command gets hold of the app's job queue. `x jobs` and `x db backfill`
+// both need a `JobDriver` and neither owns one — a second copy of this boot would be two answers
+// to "which queue is this command talking to", which is the drift axiom 1 refuses.
+
+import type { JobDriver } from '@ultimat3/jobs';
+import { jobDriver } from '@ultimat3/jobs';
+import type { CommandContext } from './command';
+import { startQueue } from './dev-queue';
+import { resolveServices } from './dev-services';
+import type { CommandResult } from './output';
+
+/**
+ * `x jobs` needs the app's real driver. Reuse an already-running one first — inside `x dev` or
+ * `x mcp serve`, `jobDriver()` is already set and booting a second queue on top of it would talk
+ * to the wrong database. Otherwise boot just the db + jobs half (`startQueue`, not the full
+ * `startServices`: these commands touch no transport, storage or mail) and always release it, or
+ * a CLI that exits holding the PGlite lock breaks the next command run against this app.
+ */
+export async function withJobDriver(
+  root: string,
+  ctx: CommandContext,
+  fn: (driver: JobDriver) => Promise<CommandResult>,
+): Promise<CommandResult> {
+  const ambient = jobDriver();
+  if (ambient !== undefined) return fn(ambient);
+  const services = resolveServices(root, ctx.env);
+  const queue = await startQueue(services);
+  try {
+    return await fn(queue.jobs);
+  } finally {
+    await queue.stop();
+  }
+}

package/src/jobs-json.ts

@@ -3,6 +3,7 @@
 // enforceable if the projections sit together where one missing `?? null` is visible.
 
 import type {
+  BackfillProgress,
   DeadLetterEntry,
   JobRecord,
   JobTrace,
@@ -26,6 +27,26 @@ function stepTraceToJson(step: StepTrace): JsonValue {
   };
 }
 
+/**
+ * One `x_backfills` row. Every absent value is already `null` at the source (`toBackfillProgress`
+ * makes it so), which is what lets this be a straight field list — and it is spelled out rather
+ * than spread so a field added upstream arrives here as a decision, not as untyped passthrough.
+ */
+export function backfillToJson(progress: BackfillProgress): JsonValue {
+  return {
+    runId: progress.runId,
+    name: progress.name,
+    status: progress.status,
+    checksum: progress.checksum,
+    appVersion: progress.appVersion,
+    rows: progress.rows,
+    cursor: progress.cursor,
+    startedAt: progress.startedAt,
+    completedAt: progress.completedAt,
+    durationMs: progress.durationMs,
+  };
+}
+
 export function jobTraceToJson(trace: JobTrace): JsonValue {
   return {
     id: trace.id,
@@ -41,6 +62,9 @@ export function jobTraceToJson(trace: JobTrace): JsonValue {
     tenantId: trace.tenantId,
     steps: trace.steps.map(stepTraceToJson),
     retryDelaysMs: trace.retryDelaysMs.map((ms) => ms),
+    // `null` for every job that is not a `backfill()` pass. Dropped, `x jobs show <id> --json`
+    // would answer "how far has it got" with silence for the one job kind that can say.
+    backfill: trace.backfill === null ? null : backfillToJson(trace.backfill),
   };
 }
 

package/src/jobs-report.ts

@@ -3,6 +3,7 @@
 // alone. Drain is `jobs-drain.ts`, the `--json` shapes `jobs-json.ts`, the table `jobs-table.ts`.
 
 import type {
+  BackfillProgress,
   DeadLetterEntry,
   JobDriver,
   JobFilter,
@@ -12,6 +13,7 @@ import type {
   QueueDepthReport,
 } from '@ultimat3/jobs';
 import {
+  inspectBackfills,
   inspectDeadLetters,
   inspectJob,
   inspectJobList,
@@ -48,15 +50,18 @@ export function parseStateFlag(value: string | undefined): JobState | undefined
  * A digit string is not yet a limit: past `Number.MAX_SAFE_INTEGER` the parse silently lands on a
  * different integer, and `1e400`-shaped input yields `Infinity`. Either way the driver would be
  * handed a bound other than the one typed, so the safe-integer check is the flag's real contract.
+ *
+ * `command` exists because `x db backfill --list` takes the same `--limit` and must not report it
+ * as a flag on `x jobs` — one parser, and the error still names the command that was typed.
  */
-export function parseLimitFlag(value: string | undefined): number | undefined {
+export function parseLimitFlag(value: string | undefined, command = 'jobs'): number | undefined {
   if (value === undefined) return undefined;
   const digits = value.trim();
   const limit = /^\d+$/.test(digits) ? Number(digits) : Number.NaN;
   if (!Number.isSafeInteger(limit) || limit <= 0) {
     throw new BadFlagError({
       flag: 'limit',
-      command: 'jobs',
+      command,
       reason: `expects an integer from 1 to ${Number.MAX_SAFE_INTEGER}, got "${value}"`,
     });
   }
@@ -76,12 +81,19 @@ export interface JobsListResult {
   readonly depth: QueueDepthReport;
   readonly rows: readonly JobRecord[];
   readonly deadLetters: readonly DeadLetterEntry[];
+  /** The sweeps still in flight — see below for why finished ones are not this command's answer. */
+  readonly backfills: readonly BackfillProgress[];
 }
 
 /**
  * The depth report AND the filtered rows, plus dead letters unconditionally: a dead job that a
  * `--state ready` filter (or the default 100-row cap) pushes out of view is the exact failure
  * mode this command exists to prevent.
+ *
+ * Backfills are read `running` only. `x jobs ls` is a LIVE view of the queue — a pass that
+ * finished last week is history, and `x db backfill --list` is where that question is asked and
+ * answered with the whole ledger. A driver with no ledger answers `[]` rather than throwing, so
+ * the queue view never fails over a fact nobody asked about.
  */
 export async function listJobs(
   driver: JobDriver,
@@ -95,12 +107,13 @@ export async function listJobs(
     ...(state === undefined ? {} : { state }),
     ...(limit === undefined ? {} : { limit }),
   };
-  const [depth, rows, deadLetters] = await Promise.all([
+  const [depth, rows, deadLetters, backfills] = await Promise.all([
     inspectQueues(driver),
     inspectJobList(driver, jobFilter),
     inspectDeadLetters(driver),
+    inspectBackfills(driver, { status: 'running' }),
   ]);
-  return { depth, rows, deadLetters };
+  return { depth, rows, deadLetters, backfills };
 }
 
 // ── show ──────────────────────────────────────────────────────────────────