@elench/testkit 0.1.54 → 0.1.55

package/lib/cli/commands/artifacts.mjs

@@ -1,6 +1,6 @@
 import { Args, Command } from "@oclif/core";
 import { sharedFlags } from "../command-helpers.mjs";
-import { collectArtifactEntries, loadLatestRunArtifact } from "../viewer.mjs";
+import { collectArtifactEntries, loadCurrentRunArtifact } from "../viewer.mjs";
 
 export default class ArtifactsCommand extends Command {
   static summary = "List persisted artifacts from the latest run";
@@ -19,7 +19,7 @@ export default class ArtifactsCommand extends Command {
   async run() {
     const { args, flags } = await this.parse(ArtifactsCommand);
     const productDir = flags.dir || process.cwd();
-    const runArtifact = loadLatestRunArtifact(productDir);
+    const runArtifact = loadCurrentRunArtifact(productDir);
     const entries = collectArtifactEntries(productDir, runArtifact, args.file || null, flags.service || null)
       .map((entry) => ({
         service: entry.service.name,

package/lib/cli/commands/logs.mjs

@@ -1,7 +1,7 @@
 import { Args, Command, Flags } from "@oclif/core";
 import { sharedFlags } from "../command-helpers.mjs";
 import { readLogTail } from "../../runner/logs.mjs";
-import { getServiceLogRefs, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { getServiceLogRefs, loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
 import path from "path";
 
 export default class LogsCommand extends Command {
@@ -27,7 +27,7 @@ export default class LogsCommand extends Command {
   async run() {
     const { args, flags } = await this.parse(LogsCommand);
     const productDir = flags.dir || process.cwd();
-    const runArtifact = loadLatestRunArtifact(productDir);
+    const runArtifact = loadCurrentRunArtifact(productDir);
     const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
     const logs = getServiceLogRefs(runArtifact, subject.service.name).map((entry) => ({
       ...entry,

package/lib/cli/commands/show.mjs

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from "@oclif/core";
 import { sharedFlags } from "../command-helpers.mjs";
-import { formatFileDetail, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { formatFileDetail, loadCurrentRunArtifact, resolveFileSubject } from "../viewer.mjs";
 
 export default class ShowCommand extends Command {
   static summary = "Show the most useful details for one file from the latest run";
@@ -25,7 +25,7 @@ export default class ShowCommand extends Command {
   async run() {
     const { args, flags } = await this.parse(ShowCommand);
     const productDir = flags.dir || process.cwd();
-    const runArtifact = loadLatestRunArtifact(productDir);
+    const runArtifact = loadCurrentRunArtifact(productDir);
     const subject = resolveFileSubject(runArtifact, args.file || null, flags.service || null);
     const result = {
       file: subject.file,

package/lib/cli/db.mjs

@@ -3,6 +3,9 @@ import os from "os";
 import path from "path";
 import { loadConfigs, resolveProductDir } from "../config/index.mjs";
 import { captureDatabaseTemplateSnapshot, prepareDatabaseRuntime } from "../database/index.mjs";
+import { createRunReporter } from "./presentation/run-reporter.mjs";
+import { createRunLogRegistry } from "../runner/logs.mjs";
+import { createSetupOperationRegistry } from "../runner/setup-operations.mjs";
 import { resolveRuntimeInstanceConfigs } from "../runner/template.mjs";
 
 export async function runDatabaseSnapshotCaptureCommand(options = {}) {
@@ -28,16 +31,28 @@ export async function runDatabaseSnapshotCaptureCommand(options = {}) {
   }
 
   const absoluteOutputPath = path.resolve(productDir, outputPath);
+  const reporter = createRunReporter({ outputMode: options.debug ? "debug" : "compact" });
+  const logRegistry = createRunLogRegistry(productDir);
+  const setupRegistry = createSetupOperationRegistry({ logRegistry });
   try {
     for (const config of topologicallySortConfigs(resolvedConfigs)) {
       if (config.name === resolvedTarget.name) continue;
       if (config.testkit.database?.provider === "local") {
-        await prepareDatabaseRuntime(config);
+        await prepareDatabaseRuntime(config, {
+          reporter,
+          logRegistry,
+          setupRegistry,
+        });
       }
     }
-    await captureDatabaseTemplateSnapshot(resolvedTarget, absoluteOutputPath);
+    await captureDatabaseTemplateSnapshot(resolvedTarget, absoluteOutputPath, {
+      reporter,
+      logRegistry,
+      setupRegistry,
+    });
     console.log(`Wrote ${path.relative(productDir, absoluteOutputPath)}`);
   } finally {
+    logRegistry.closeAll();
     fs.rmSync(runtimeRoot, { recursive: true, force: true });
   }
 }

package/lib/cli/presentation/run-reporter.mjs

@@ -26,6 +26,27 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
         `[testkit] ${config.runtimeLabel || config.name}:${config.name} toolchain ${resolvedToolchain.summary}\n`
       );
     },
+    setupOperationFinished(operation) {
+      if (!operation) return;
+      if (mode === "json") return;
+      if (operation.status === "cached") return;
+      const duration = formatDuration(operation.durationMs || 0);
+      if (operation.status === "failed") {
+        const detail = shortenMessage(operation.error || operation.summary || operation.stage);
+        stdout.write(
+          `${colorStatus("FAIL")} ${"SETUP"} ${operation.serviceName} ${operation.stage} ${dim(duration)} ${detail}\n`
+        );
+        return;
+      }
+      if (
+        mode === "compact" &&
+        isHighLevelSetupOperation(operation) &&
+        (operation.durationMs || 0) >= 5_000
+      ) {
+        const summary = shortenMessage(operation.summary || operation.stage);
+        stdout.write(`${colorStatus("RUN")} ${"SETUP"} ${operation.serviceName} ${summary} ${dim(duration)}\n`);
+      }
+    },
     localServiceStarting(config, command) {
       if (mode !== "debug") return;
       stdout.write(`Starting ${config.runtimeLabel}:${config.name}: ${command}\n`);
@@ -98,3 +119,7 @@ function isThresholdWrapperMessage(message) {
 function normalizePath(filePath) {
   return String(filePath).split(path.sep).join("/");
 }
+
+function isHighLevelSetupOperation(operation) {
+  return operation.kind === "database-template" || operation.kind === "runtime-prepare";
+}

package/lib/cli/presentation/run-reporter.test.mjs

@@ -0,0 +1,80 @@
+import { Writable } from "stream";
+import { describe, expect, it } from "vitest";
+import { createRunReporter } from "./run-reporter.mjs";
+
+describe("run reporter setup output", () => {
+  it("prints concise high-level setup summaries in compact mode", () => {
+    let stdout = "";
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: new Writable({
+        write(chunk, _encoding, callback) {
+          stdout += chunk.toString();
+          callback();
+        },
+      }),
+    });
+
+    reporter.setupOperationFinished({
+      serviceName: "api",
+      stage: "template",
+      kind: "database-template",
+      summary: "template rebuild",
+      status: "passed",
+      durationMs: 8_000,
+    });
+
+    expect(stdout).toContain("RUN SETUP api template rebuild");
+    expect(stdout).toContain("8s");
+  });
+
+  it("does not print low-level setup steps in compact mode", () => {
+    let stdout = "";
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: new Writable({
+        write(chunk, _encoding, callback) {
+          stdout += chunk.toString();
+          callback();
+        },
+      }),
+    });
+
+    reporter.setupOperationFinished({
+      serviceName: "api",
+      stage: "template:migrate:api:1",
+      kind: "setup-step",
+      summary: "sql-file: db/schema.sql",
+      status: "passed",
+      durationMs: 8_000,
+    });
+
+    expect(stdout).toBe("");
+  });
+
+  it("prints concise setup failures", () => {
+    let stdout = "";
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: new Writable({
+        write(chunk, _encoding, callback) {
+          stdout += chunk.toString();
+          callback();
+        },
+      }),
+    });
+
+    reporter.setupOperationFinished({
+      serviceName: "api",
+      stage: "runtime:prepare",
+      kind: "runtime-prepare",
+      summary: "runtime prepare",
+      status: "failed",
+      durationMs: 1_200,
+      error: "Command failed with exit code 1: node scripts/fail-prepare.mjs",
+    });
+
+    expect(stdout).toContain("FAIL SETUP api runtime:prepare");
+    expect(stdout).toContain("Command failed with exit code 1");
+  });
+});

package/lib/cli/tui/watch-app.mjs

@@ -1,15 +1,25 @@
+import fs from "fs";
+import path from "path";
 import React, { createElement, useEffect, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import { formatDuration } from "../../runner/formatting.mjs";
-import { formatFileDetail, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+import { formatFileDetail, loadCurrentRunArtifact } from "../viewer.mjs";
 
 export function WatchApp({ productDir, serviceFilter = null }) {
   const { exit } = useApp();
   const [artifact, setArtifact] = useState(() => safeLoadArtifact(productDir));
-  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [view, setView] = useState("files");
+  const [selectedFileIndex, setSelectedFileIndex] = useState(0);
+  const [selectedSetupIndex, setSelectedSetupIndex] = useState(0);
 
   const files = useMemo(() => collectFiles(artifact, serviceFilter), [artifact, serviceFilter]);
-  const selected = files[Math.min(selectedIndex, Math.max(0, files.length - 1))] || null;
+  const setupOperations = useMemo(
+    () => collectSetupOperations(artifact, serviceFilter),
+    [artifact, serviceFilter]
+  );
+  const selectedFile = files[Math.min(selectedFileIndex, Math.max(0, files.length - 1))] || null;
+  const selectedSetup =
+    setupOperations[Math.min(selectedSetupIndex, Math.max(0, setupOperations.length - 1))] || null;
 
   useEffect(() => {
     const timer = setInterval(() => {
@@ -18,6 +28,14 @@ export function WatchApp({ productDir, serviceFilter = null }) {
     return () => clearInterval(timer);
   }, [productDir]);
 
+  useEffect(() => {
+    setSelectedFileIndex((current) => Math.min(current, Math.max(0, files.length - 1)));
+  }, [files.length]);
+
+  useEffect(() => {
+    setSelectedSetupIndex((current) => Math.min(current, Math.max(0, setupOperations.length - 1)));
+  }, [setupOperations.length]);
+
   useInput((input, key) => {
     if (input === "q") {
       exit();
@@ -27,12 +45,27 @@ export function WatchApp({ productDir, serviceFilter = null }) {
       setArtifact(safeLoadArtifact(productDir));
       return;
     }
+    if (key.tab || input === "s") {
+      setView((current) => {
+        if (current === "files" && setupOperations.length > 0) return "setup";
+        return "files";
+      });
+      return;
+    }
     if (key.downArrow) {
-      setSelectedIndex((current) => Math.min(current + 1, Math.max(0, files.length - 1)));
+      if (view === "setup") {
+        setSelectedSetupIndex((current) => Math.min(current + 1, Math.max(0, setupOperations.length - 1)));
+      } else {
+        setSelectedFileIndex((current) => Math.min(current + 1, Math.max(0, files.length - 1)));
+      }
       return;
     }
     if (key.upArrow) {
-      setSelectedIndex((current) => Math.max(0, current - 1));
+      if (view === "setup") {
+        setSelectedSetupIndex((current) => Math.max(0, current - 1));
+      } else {
+        setSelectedFileIndex((current) => Math.max(0, current - 1));
+      }
     }
   });
 
@@ -46,7 +79,7 @@ export function WatchApp({ productDir, serviceFilter = null }) {
     createElement(
       Text,
       null,
-      `testkit watch · q quit · r reload · ${artifact.run.status} · ${formatDuration(artifact.run.durationMs)}`
+      `testkit watch · q quit · r reload · tab toggle · ${artifact.run.status} · ${formatDuration(artifact.run.durationMs)}`
     ),
     createElement(
       Box,
@@ -54,22 +87,21 @@ export function WatchApp({ productDir, serviceFilter = null }) {
       createElement(
         Box,
         { width: "40%", flexDirection: "column", marginRight: 2 },
-        createElement(Text, null, "Files"),
-        ...files.map((entry, index) => {
-          const prefix = index === selectedIndex ? ">" : " ";
-          return createElement(
-            Text,
-            { key: `${entry.service.name}:${entry.file.path}` },
-            `${prefix} ${entry.file.status.toUpperCase().padEnd(7)} ${entry.file.path}`
-          );
-        })
+        createElement(Text, null, view === "setup" ? "Setup" : "Files"),
+        ...(view === "setup"
+          ? renderSetupEntries(setupOperations, selectedSetupIndex)
+          : renderFileEntries(files, selectedFileIndex))
       ),
       createElement(
         Box,
         { width: "60%", flexDirection: "column" },
         createElement(Text, null, "Details"),
-        ...(selected
-          ? formatFileDetail(productDir, artifact, selected, { logTail: 8 })
+        ...(view === "setup"
+          ? formatSetupDetail(productDir, selectedSetup)
+              .slice(0, 28)
+              .map((line, index) => createElement(Text, { key: `${index}:${line}` }, line))
+          : selectedFile
+          ? formatFileDetail(productDir, artifact, selectedFile, { logTail: 8 })
               .slice(0, 28)
               .map((line, index) => createElement(Text, { key: `${index}:${line}` }, line))
           : [createElement(Text, { key: "empty" }, "No file results")])
@@ -80,7 +112,7 @@ export function WatchApp({ productDir, serviceFilter = null }) {
 
 function safeLoadArtifact(productDir) {
   try {
-    return loadLatestRunArtifact(productDir);
+    return loadCurrentRunArtifact(productDir);
   } catch {
     return null;
   }
@@ -102,3 +134,87 @@ function collectFiles(runArtifact, serviceFilter) {
     left.file.path.localeCompare(right.file.path)
   );
 }
+
+function renderFileEntries(files, selectedIndex) {
+  return files.map((entry, index) => {
+    const prefix = index === selectedIndex ? ">" : " ";
+    return createElement(
+      Text,
+      { key: `${entry.service.name}:${entry.file.path}` },
+      `${prefix} ${entry.file.status.toUpperCase().padEnd(7)} ${entry.file.path}`
+    );
+  });
+}
+
+function collectSetupOperations(runArtifact, serviceFilter) {
+  if (!runArtifact) return [];
+  return [...(runArtifact.setup?.operations || [])]
+    .filter((entry) => !serviceFilter || entry.serviceName === serviceFilter)
+    .sort((left, right) => {
+      return (
+        setupStatusRank(left.status) - setupStatusRank(right.status) ||
+        String(left.serviceName || "").localeCompare(String(right.serviceName || "")) ||
+        String(left.startedAt || "").localeCompare(String(right.startedAt || "")) ||
+        String(left.stage || "").localeCompare(String(right.stage || ""))
+      );
+    });
+}
+
+function renderSetupEntries(operations, selectedIndex) {
+  return operations.map((entry, index) => {
+    const prefix = index === selectedIndex ? ">" : " ";
+    const duration = entry.durationMs == null ? "" : ` ${formatDuration(entry.durationMs)}`;
+    return createElement(
+      Text,
+      { key: entry.id },
+      `${prefix} ${String(entry.status || "").toUpperCase().padEnd(7)} ${entry.serviceName} ${entry.stage}${duration}`
+    );
+  });
+}
+
+function formatSetupDetail(productDir, operation) {
+  if (!operation) return ["No setup operations"];
+  const lines = [
+    `Service: ${operation.serviceName}`,
+    `Stage: ${operation.stage}`,
+    `Status: ${operation.status}`,
+  ];
+  if (operation.durationMs != null) {
+    lines.push(`Duration: ${formatDuration(operation.durationMs)}`);
+  }
+  if (operation.summary) {
+    lines.push(`Summary: ${operation.summary}`);
+  }
+  if (operation.error) {
+    lines.push(`Error: ${operation.error}`);
+  }
+  if (operation.logRef?.path) {
+    lines.push("");
+    lines.push("Log:");
+    lines.push(`  ${operation.logRef.path}`);
+    const absolutePath = path.join(productDir, operation.logRef.path);
+    for (const line of readTailSafe(absolutePath, 12)) {
+      lines.push(`  ${line}`);
+    }
+  }
+  return lines;
+}
+
+function readTailSafe(absolutePath, maxLines) {
+  try {
+    return fs.readFileSync(absolutePath, "utf8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
+
+function setupStatusRank(status) {
+  if (status === "failed") return 1;
+  if (status === "running") return 2;
+  if (status === "passed") return 3;
+  if (status === "cached") return 4;
+  return 5;
+}

package/lib/cli/viewer.mjs

@@ -16,6 +16,14 @@ export function loadLatestRunArtifact(productDir) {
   return JSON.parse(fs.readFileSync(artifactPath, "utf8"));
 }
 
+export function loadCurrentRunArtifact(productDir) {
+  const livePath = path.join(productDir, ".testkit", "results", "live.json");
+  if (fs.existsSync(livePath)) {
+    return JSON.parse(fs.readFileSync(livePath, "utf8"));
+  }
+  return loadLatestRunArtifact(productDir);
+}
+
 export function resolveFileSubject(runArtifact, selector = null, serviceFilter = null) {
   const files = collectFiles(runArtifact, serviceFilter);
   if (files.length === 0) {
@@ -108,6 +116,25 @@ export function formatFileDetail(productDir, runArtifact, subject, options = {})
     for (const line of triageLines) lines.push(`  ${line}`);
   }
 
+  const setupOperations = getSetupOperationsForService(runArtifact, subject.service.name);
+  if (setupOperations.length > 0) {
+    lines.push("");
+    lines.push("Setup:");
+    for (const operation of setupOperations.slice(0, 8)) {
+      const duration = operation.durationMs == null ? "" : ` ${formatDuration(operation.durationMs)}`;
+      const suffix = operation.summary ? ` ${operation.summary}` : "";
+      lines.push(`  ${operation.status} ${operation.stage}${duration}${suffix}`);
+      if (operation.logRef?.path) lines.push(`    ${operation.logRef.path}`);
+      if (operation.error) lines.push(`    ${operation.error}`);
+      if (operation.logRef?.path) {
+        const setupLogPath = path.join(productDir, operation.logRef.path);
+        for (const line of readLogTail(setupLogPath, 4).slice(-4)) {
+          lines.push(`    ${line}`);
+        }
+      }
+    }
+  }
+
   const artifacts = collectArtifactEntries(productDir, runArtifact, subject.file.path, subject.service.name);
   if (artifacts.length > 0) {
     lines.push("");
@@ -148,6 +175,16 @@ export function getServiceLogRefs(runArtifact, serviceName) {
   return (runArtifact.logs?.services || []).filter((entry) => entry.serviceName === serviceName);
 }
 
+export function getSetupOperationsForService(runArtifact, serviceName) {
+  return (runArtifact.setup?.operations || [])
+    .filter((entry) => entry.serviceName === serviceName)
+    .sort(
+      (left, right) =>
+        String(left.startedAt || "").localeCompare(String(right.startedAt || "")) ||
+        String(left.stage || "").localeCompare(String(right.stage || ""))
+    );
+}
+
 export function formatArtifactPreview(payload, maxLines = 6) {
   if (!payload) return ["artifact payload missing"];
   if (payload.kind === "agentic-query") {

package/lib/database/index.mjs

@@ -36,25 +36,25 @@ const LOCAL_POLL_INTERVAL_MS = 1_000;
 const LOCAL_DROP_DATABASE_TIMEOUT_MS = 15_000;
 const LOCAL_DROP_DATABASE_POLL_INTERVAL_MS = 250;
 
-export async function prepareDatabaseRuntime(config) {
+export async function prepareDatabaseRuntime(config, options = {}) {
   const db = config.testkit.database;
   if (!db) return;
 
   fs.mkdirSync(config.stateDir, { recursive: true });
   if (db.provider === "local") {
-    await prepareLocalDatabase(config);
+    await prepareLocalDatabase(config, options);
     return;
   }
 
   throw new Error(`Unsupported database provider "${db.provider}"`);
 }
 
-export async function captureDatabaseTemplateSnapshot(config, outputPath) {
+export async function captureDatabaseTemplateSnapshot(config, outputPath, options = {}) {
   if (!config.testkit.database || config.testkit.database.provider !== "local") {
     throw new Error(`Service "${config.name}" does not use a local testkit database`);
   }
 
-  await prepareDatabaseRuntime(config);
+  await prepareDatabaseRuntime(config, options);
   const cacheDir = getLocalServiceCacheDir(config.productDir, config.name);
   const templateDbName = readStateValue(path.join(cacheDir, "template_database_name"));
   if (!templateDbName) {
@@ -66,7 +66,41 @@ export async function captureDatabaseTemplateSnapshot(config, outputPath) {
     throw new Error(`Missing local database container for service "${config.name}"`);
   }
 
-  return captureTemplateSnapshot(config, outputPath, buildDatabaseUrl(infra, templateDbName));
+  const snapshotOperation = options.setupRegistry?.start({
+    config,
+    stage: "template:snapshot",
+    kind: "database-snapshot",
+    summary: `snapshot: ${path.relative(config.productDir, outputPath)}`,
+  });
+  try {
+    const output = await captureTemplateSnapshot(
+      config,
+      outputPath,
+      buildDatabaseUrl(infra, templateDbName),
+      {
+        reporter: options.reporter || null,
+        logRecord: snapshotOperation?._logRecord || null,
+      }
+    );
+    const finished = snapshotOperation
+      ? options.setupRegistry.finish(snapshotOperation, {
+          status: "passed",
+          summary: `snapshot: ${path.relative(config.productDir, outputPath)}`,
+        })
+      : null;
+    if (finished) options.reporter?.setupOperationFinished?.(finished);
+    return output;
+  } catch (error) {
+    const finished = snapshotOperation
+      ? options.setupRegistry.finish(snapshotOperation, {
+          status: "failed",
+          summary: `snapshot: ${path.relative(config.productDir, outputPath)}`,
+          error: error?.message || error,
+        })
+      : null;
+    if (finished) options.reporter?.setupOperationFinished?.(finished);
+    throw error;
+  }
 }
 
 export async function destroyRuntimeDatabase({ productDir, stateDir }) {
@@ -138,7 +172,7 @@ export function showServiceDatabaseStatus(productDir, serviceName) {
   return true;
 }
 
-async function prepareLocalDatabase(config) {
+async function prepareLocalDatabase(config, options = {}) {
   const db = config.testkit.database;
   const productDir = config.productDir;
   const serviceName = config.name;
@@ -154,7 +188,7 @@ async function prepareLocalDatabase(config) {
   );
 
   await withLock(path.join(lockDir, `template-${serviceName}.lock`), async () => {
-    await ensureTemplateDatabase(config, infra, cacheDir, templateFingerprint);
+    await ensureTemplateDatabase(config, infra, cacheDir, templateFingerprint, options);
   });
 
   await withLock(path.join(lockDir, `runtime-${serviceName}-${hashString(bindingKey, 10)}.lock`), async () => {
@@ -162,7 +196,7 @@ async function prepareLocalDatabase(config) {
   });
 }
 
-async function ensureTemplateDatabase(config, infra, cacheDir, templateFingerprint) {
+async function ensureTemplateDatabase(config, infra, cacheDir, templateFingerprint, options = {}) {
   const serviceName = config.name;
   const existingFingerprint = readStateValue(path.join(cacheDir, "template_fingerprint"));
   const existingDbName = readStateValue(path.join(cacheDir, "template_database_name"));
@@ -173,6 +207,12 @@ async function ensureTemplateDatabase(config, infra, cacheDir, templateFingerpri
     existingDbName &&
     (await databaseExists(infra, existingDbName))
   ) {
+    options.setupRegistry?.recordCached({
+      config,
+      stage: "template",
+      kind: "database-template",
+      summary: "template cache hit",
+    });
     writeLocalCacheState(cacheDir, infra, existingDbName, templateFingerprint);
     return;
   }
@@ -186,11 +226,45 @@ async function ensureTemplateDatabase(config, infra, cacheDir, templateFingerpri
 
   const templateUrl = buildDatabaseUrl(infra, desiredDbName);
   await createEmptyDatabase(infra, desiredDbName);
+  const templateOperation = options.setupRegistry?.start({
+    config,
+    stage: "template",
+    kind: "database-template",
+    summary: "template rebuild",
+    recordLog: false,
+  });
   try {
-    await runTemplateStage(config, "migrate", templateUrl);
-    await runTemplateStage(config, "seed", templateUrl);
-    await runTemplateStage(config, "verify", templateUrl);
+    await runTemplateStage(config, "migrate", templateUrl, {
+      reporter: options.reporter || null,
+      setupRegistry: options.setupRegistry || null,
+      parentOperation: templateOperation,
+    });
+    await runTemplateStage(config, "seed", templateUrl, {
+      reporter: options.reporter || null,
+      setupRegistry: options.setupRegistry || null,
+      parentOperation: templateOperation,
+    });
+    await runTemplateStage(config, "verify", templateUrl, {
+      reporter: options.reporter || null,
+      setupRegistry: options.setupRegistry || null,
+      parentOperation: templateOperation,
+    });
+    const finished = templateOperation
+      ? options.setupRegistry.finish(templateOperation, {
+          status: "passed",
+          summary: "template rebuild",
+        })
+      : null;
+    if (finished) options.reporter?.setupOperationFinished?.(finished);
   } catch (error) {
+    const finished = templateOperation
+      ? options.setupRegistry.finish(templateOperation, {
+          status: "failed",
+          summary: "template rebuild",
+          error: error?.message || error,
+        })
+      : null;
+    if (finished) options.reporter?.setupOperationFinished?.(finished);
     await dropDatabaseIfExists(infra, desiredDbName);
     throw error;
   }