donobu 5.27.4 → 5.28.0

package/dist/esm/lib/test/testExtension.js

@@ -13,14 +13,21 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = void 0;
 const test_1 = require("@playwright/test");
 const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
 const v4_1 = require("zod/v4");
 const envVars_1 = require("../../envVars");
 const DonobuFlowsManager_1 = require("../../managers/DonobuFlowsManager");
+const fileUploadWorkerRegistry_1 = require("../../persistence/files/fileUploadWorkerRegistry");
 const BrowserUtils_1 = require("../../utils/BrowserUtils");
 const FlowLogBuffer_1 = require("../../utils/FlowLogBuffer");
 const Logger_1 = require("../../utils/Logger");
@@ -32,6 +39,181 @@ const tbd_1 = require("../page/tbd");
 const selfHealing_1 = require("./utils/selfHealing");
 const triageTestFailure_1 = require("./utils/triageTestFailure");
 __exportStar(require("@playwright/test"), exports);
+// ---------------------------------------------------------------------------
+// Playwright-recorded video → flow persistence
+// ---------------------------------------------------------------------------
+// Playwright records videos when `use.video` is configured (`'on'`,
+// `'retain-on-failure'`, `'on-first-retry'`). Those videos live in the
+// Playwright `testInfo.outputDir` and ship with the Playwright HTML report,
+// but without explicit wiring they never make it into Donobu's flow
+// persistence (so the Studio UI's flow detail view shows no video).
+//
+// The integration here:
+//   1. Inside `finalizeTest`, decide whether to persist based on the
+//      effective `video` option AND `testInfo.status`. The decision matrix
+//      mirrors Playwright's own retain semantics so we never persist a
+//      video the user told Playwright to discard (e.g.,
+//      `'retain-on-failure'` + passing test = no persist).
+//   2. If we should persist, we kick off an async block that uses
+//      `Video.saveAs` (which internally waits for the BrowserContext to
+//      close before writing the .webm to a tmp path). After the file is
+//      finalized we read the bytes and forward them to `setVideo` on the
+//      flow's persistence layer (which routes through the FileUploadCache
+//      → cloud upload pipeline).
+//   3. The deferred persist promise is registered in a module-level set so
+//      the worker-scoped drain guard can await it before the Playwright
+//      worker exits — without this, fast tests would beat the saveAs-after-
+//      close to the punch and the worker would terminate mid-write.
+/**
+ * Maximum time the worker-scoped drain guard waits for in-flight video
+ * persists to settle before continuing on to the file-upload drain. Each
+ * video persist needs the BrowserContext to close (Playwright's video
+ * pipeline only finalizes the .webm at that point); for a normal test
+ * teardown that's near-instant.
+ */
+const VIDEO_PERSIST_TIMEOUT_MS = 30_000;
+/**
+ * Promises tracking deferred video saves. Each entry resolves once the
+ * test's BrowserContext has closed AND we've copied bytes from the
+ * finalized .webm into the flow's persistence layer. The worker-scoped
+ * `donobuFileUploadDrainGuard` awaits all of these before draining cloud
+ * uploads, so we don't lose end-of-session videos.
+ */
+const pendingVideoPersists = new Set();
+function trackVideoPersist(p) {
+    pendingVideoPersists.add(p);
+    void p.finally(() => {
+        pendingVideoPersists.delete(p);
+    });
+}
+async function waitForPendingVideoPersists(timeoutMs) {
+    const initial = pendingVideoPersists.size;
+    if (initial === 0) {
+        return { initial: 0, remaining: 0, timedOut: false };
+    }
+    const all = Array.from(pendingVideoPersists);
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), timeoutMs);
+    });
+    const settled = Promise.allSettled(all).then(() => 'done');
+    const winner = await Promise.race([timeout, settled]);
+    if (timer) {
+        clearTimeout(timer);
+    }
+    return {
+        initial,
+        remaining: pendingVideoPersists.size,
+        timedOut: winner === 'timeout',
+    };
+}
+/**
+ * Returns true iff Playwright would have RETAINED the video file for this
+ * test under the given `video` option, given the test's outcome. Mirrors
+ * Playwright's retain semantics (see Playwright `VideoMode` docs):
+ *
+ *   - `'off'` / `undefined`        → no video at all; never persist.
+ *   - `'on'`                       → always retain → always persist.
+ *   - `'retain-on-failure'`        → retain only on non-passing → persist
+ *                                    only when status !== 'passed'.
+ *   - `'on-first-retry'`           → recorded only on retries; if a video
+ *                                    exists, we're on a retry → persist.
+ *   - any unknown future mode      → conservatively SKIP, with a warn log.
+ *                                    Better to under-persist than violate
+ *                                    user intent for a mode we don't yet
+ *                                    understand.
+ */
+function shouldPersistVideo(videoOption, status) {
+    const mode = typeof videoOption === 'string' ? videoOption : videoOption?.mode;
+    switch (mode) {
+        case 'on':
+            return true;
+        case 'on-first-retry':
+            // When set, Playwright only records on retries; if a video exists
+            // it implies we're on a retry — always retain.
+            return true;
+        case 'retry-with-video':
+            // Deprecated alias for 'on-first-retry' that Playwright still
+            // accepts on the type. Same retain semantics.
+            return true;
+        case 'retain-on-failure':
+            return status !== 'passed';
+        case 'off':
+        case undefined:
+            return false;
+        default:
+            Logger_1.appLogger.warn(`Unknown Playwright video mode "${String(mode)}"; skipping video ` +
+                `persistence to avoid violating user intent. If this is a real ` +
+                `Playwright mode, add it to shouldPersistVideo() in testExtension.ts.`);
+            return false;
+    }
+}
+function describeVideoMode(videoOption) {
+    if (typeof videoOption === 'string') {
+        return videoOption;
+    }
+    if (videoOption && typeof videoOption === 'object' && 'mode' in videoOption) {
+        return videoOption.mode;
+    }
+    return 'off';
+}
+/**
+ * If Playwright recorded a video for this test AND the effective video
+ * mode says we should retain it, kicks off an async save+persist and
+ * tracks the promise so the worker-scoped drain guard can await it.
+ *
+ * This function does NOT block on the actual file write — `Video.saveAs`
+ * internally waits for the BrowserContext to close (which can't happen
+ * until our page fixture's teardown returns). Awaiting it here would
+ * deadlock. Instead we defer and let the worker-scoped fixture await all
+ * pending persists at end-of-worker.
+ */
+function persistVideoIfApplicable(page, testInfo, videoOption) {
+    const flowId = page._dnb.donobuFlowMetadata.id;
+    const video = page.video();
+    if (!video) {
+        // No video being recorded. Either video is 'off', or 'on-first-retry'
+        // and this isn't a retry, etc. Nothing to do.
+        return;
+    }
+    if (!shouldPersistVideo(videoOption, testInfo.status)) {
+        Logger_1.appLogger.info(`Skipping video persist for flow ${flowId}: video mode ` +
+            `"${describeVideoMode(videoOption)}" + status "${testInfo.status}" ` +
+            `means Playwright will discard the file and we'd be violating user ` +
+            `intent by keeping a copy.`);
+        return;
+    }
+    const persistence = page._dnb.persistence;
+    const persistPromise = (async () => {
+        const tmpPath = path_1.default.join((0, os_1.tmpdir)(), `donobu-test-video-${flowId}.webm`);
+        try {
+            // Video.saveAs blocks until the BrowserContext closes and the .webm
+            // is fully written. Playwright closes the context as part of its own
+            // fixture teardown, AFTER our page fixture body returns — so this
+            // promise unblocks once the test is fully torn down.
+            await video.saveAs(tmpPath);
+            const bytes = await fs_1.promises.readFile(tmpPath);
+            await persistence.setVideo(flowId, bytes);
+            Logger_1.appLogger.info(`Persisted video for flow ${flowId} ` +
+                `(${(bytes.length / 1024).toFixed(0)} KB) — queued for cloud upload.`);
+        }
+        catch (err) {
+            Logger_1.appLogger.warn(`Failed to persist video for flow ${flowId}: ${err.message}`);
+        }
+        finally {
+            await fs_1.promises.unlink(tmpPath).catch(() => undefined);
+        }
+    })();
+    trackVideoPersist(persistPromise);
+}
+/**
+ * Maximum time the worker-scoped post-test-session upload drain will wait
+ * for cloud uploads to complete before letting the worker exit. Bytes that
+ * aren't uploaded within this window stay on disk and are picked up by the
+ * next `donobu` process to start with the same data dir (via the file-upload
+ * cache's stale-claim reclaim).
+ */
+const UPLOAD_DRAIN_TIMEOUT_MS = 30_000;
 exports.test = test_1.test.extend({
     /**
      * Establish a logging scope for the entire Playwright test *before* any other
@@ -75,13 +257,98 @@ exports.test = test_1.test.extend({
         },
         { scope: 'test', auto: true },
     ],
+    /**
+     * Drain in-flight file uploads (videos, screenshots, etc.) to Donobu
+     * Cloud at the end of every Playwright worker's lifetime.
+     *
+     * The {@link FileUploadWorker} runs continuously while tests execute,
+     * uploading flow artifacts to the cloud asynchronously. When the worker
+     * process exits, any uploads still mid-flight are abandoned at whatever
+     * stage they reached. The bytes survive on disk as `.uploading.<token>`
+     * markers, but for ephemeral CI runners — where the box gets torn down
+     * after the test session — there's no future process to resume them.
+     *
+     * This auto fixture closes that gap by waiting for the queue to drain
+     * before letting the worker exit.
+     */
+    donobuFileUploadDrainGuard: [
+        async ({}, use) => {
+            await use();
+            // ── Teardown — runs ONCE per Playwright worker, after every test ──
+            // First, wait for any deferred video persists from finalizeTest to
+            // complete. Each one is gated on a BrowserContext close (Playwright
+            // finalizes the .webm at that point) and then forwards the bytes to
+            // setVideo. Without this wait, fast tests would beat the
+            // saveAs-after-close to the punch and the worker would exit
+            // mid-write — meaning the cloud upload below would never be queued
+            // for the missing video.
+            const videoWait = await waitForPendingVideoPersists(VIDEO_PERSIST_TIMEOUT_MS);
+            if (videoWait.initial > 0) {
+                if (videoWait.timedOut) {
+                    Logger_1.appLogger.warn(`donobuFileUploadDrainGuard: ${videoWait.remaining} of ` +
+                        `${videoWait.initial} video persist(s) still pending after ` +
+                        `${Math.round(VIDEO_PERSIST_TIMEOUT_MS / 1000)}s; proceeding ` +
+                        `with upload drain anyway. Those video files (if any) will ` +
+                        `not be uploaded this session.`);
+                }
+                else {
+                    Logger_1.appLogger.info(`donobuFileUploadDrainGuard: completed ${videoWait.initial} ` +
+                        `pending video persist(s) before upload drain.`);
+                }
+            }
+            let initialActive;
+            try {
+                const status = await (0, fileUploadWorkerRegistry_1.getFileUploadAggregateStatus)();
+                initialActive = status.totalPending + status.totalInFlight;
+            }
+            catch (err) {
+                Logger_1.appLogger.warn(`donobuFileUploadDrainGuard: failed to read upload status; ` +
+                    `skipping drain. Error: ${err.message}`);
+                return;
+            }
+            if (initialActive === 0) {
+                Logger_1.appLogger.info('donobuFileUploadDrainGuard: no pending file uploads at end of test ' +
+                    'session; worker is exiting.');
+                return;
+            }
+            Logger_1.appLogger.info(`donobuFileUploadDrainGuard: test session complete; ${initialActive} ` +
+                `file upload(s) still syncing to Donobu Cloud. ` +
+                `Waiting up to ${Math.round(UPLOAD_DRAIN_TIMEOUT_MS / 1000)}s for ` +
+                `the queue to drain before exit. ` +
+                `(Any uploads not finished within the timeout stay on disk and ` +
+                `resume on the next \`donobu\` process start.)`);
+            const startedAt = Date.now();
+            let result;
+            try {
+                result = await (0, fileUploadWorkerRegistry_1.shutdownFileUploadWorkers)(UPLOAD_DRAIN_TIMEOUT_MS);
+            }
+            catch (err) {
+                Logger_1.appLogger.warn(`donobuFileUploadDrainGuard: drain threw; letting worker exit. ` +
+                    `Error: ${err.message}`);
+                return;
+            }
+            const elapsedMs = Date.now() - startedAt;
+            if (result.drained) {
+                Logger_1.appLogger.info(`donobuFileUploadDrainGuard: all ${initialActive} file upload(s) ` +
+                    `completed in ${Math.round(elapsedMs / 1000)}s. Worker exiting.`);
+            }
+            else {
+                Logger_1.appLogger.warn(`donobuFileUploadDrainGuard: drain timed out after ` +
+                    `${Math.round(elapsedMs / 1000)}s with ${result.totalRemaining} ` +
+                    `upload(s) still pending. The bytes are on disk and will resume ` +
+                    `the next time a \`donobu\` process starts with the same data ` +
+                    `directory. Worker exiting now.`);
+            }
+        },
+        { scope: 'worker', auto: true },
+    ],
     // 1) Declare `gptClient` as an "option" fixture with a default of `undefined`.
     gptClient: [
         undefined, // default
         { option: true }, // so that test.use({ gptClient: ... }) can override
     ],
     // Override the default page fixture
-    page: async ({ page, gptClient, headless, flowLoggingContext }, use, testInfo) => {
+    page: async ({ page, gptClient, headless, flowLoggingContext, video }, use, testInfo) => {
         Logger_1.appLogger.info(`Test started: "${testInfo.title}"`);
         const overallObjective = testInfo.annotations.find((v) => v.type === 'objective')?.description ??
             null;
@@ -132,7 +399,7 @@ exports.test = test_1.test.extend({
             throw error;
         }
         finally {
-            await finalizeTest(extendedPage, testInfo, logBuffer);
+            await finalizeTest(extendedPage, testInfo, logBuffer, video);
         }
     },
 });
@@ -244,8 +511,17 @@ async function attachStepScreenshots(sharedState, testInfo) {
         contentType: 'application/json',
     });
 }
-async function finalizeTest(page, testInfo, logBuffer) {
+async function finalizeTest(page, testInfo, logBuffer, videoOption) {
     const sharedState = page._dnb;
+    // Kick off video persistence early in teardown. The actual file copy is
+    // deferred (it can't run until the BrowserContext closes, which happens
+    // AFTER our fixture body returns), so this just queues a tracked promise.
+    // Doing it before the rest of finalizeTest's work means the deferred
+    // saveAs has already-finalized references to flowId / persistence / video
+    // by the time it runs, regardless of what subsequent teardown does.
+    if (videoOption !== undefined) {
+        persistVideoIfApplicable(page, testInfo, videoOption);
+    }
     try {
         sharedState.donobuFlowMetadata.state =
             testInfo.status === 'failed' || testInfo.status === 'timedOut'

package/dist/esm/main.d.ts

@@ -54,6 +54,7 @@ export * from './models/ToolCallResult';
 export * from './models/ToolSchema';
 export type { VideoSegment } from './models/VideoSegment';
 export type { EnvPersistence } from './persistence/env/EnvPersistence';
+export { type FileUploadAggregateStatus, type FileUploadPlatformStatus, getFileUploadAggregateStatus, shutdownFileUploadWorkers, } from './persistence/files/fileUploadWorkerRegistry';
 export type { FlowsPersistence } from './persistence/flows/FlowsPersistence';
 export { type PersistencePlugin, PersistencePluginRegistry, } from './persistence/PersistencePlugin';
 export type { SuitesPersistence } from './persistence/suites/SuitesPersistence';

package/dist/esm/main.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TargetRuntimePluginRegistry = exports.PersistencePluginRegistry = exports.createDefaultToolRegistry = exports.ToolManager = exports.PluginLoader = exports.InteractionVisualizer = exports.setupDonobuStack = exports.prepareToolCallsForRerun = exports.DonobuFlowsManager = exports.distillAllowedEnvVariableNames = exports.DonobuFlow = exports.AdminApiController = exports.env = exports.runGenerateSiteTests = exports.VercelAiGptClient = exports.OpenAiGptClient = exports.GptClientPluginRegistry = exports.GptClient = exports.GoogleGenerativeAiGptClient = exports.fixAssertFields = exports.DonobuGptClient = exports.AnthropicGptClient = void 0;
+exports.TargetRuntimePluginRegistry = exports.PersistencePluginRegistry = exports.shutdownFileUploadWorkers = exports.getFileUploadAggregateStatus = exports.createDefaultToolRegistry = exports.ToolManager = exports.PluginLoader = exports.InteractionVisualizer = exports.setupDonobuStack = exports.prepareToolCallsForRerun = exports.DonobuFlowsManager = exports.distillAllowedEnvVariableNames = exports.DonobuFlow = exports.AdminApiController = exports.env = exports.runGenerateSiteTests = exports.VercelAiGptClient = exports.OpenAiGptClient = exports.GptClientPluginRegistry = exports.GptClient = exports.GoogleGenerativeAiGptClient = exports.fixAssertFields = exports.DonobuGptClient = exports.AnthropicGptClient = void 0;
 exports.startDonobuServer = startDonobuServer;
 const commander_1 = require("commander");
 const v4_1 = require("zod/v4");
@@ -88,6 +88,9 @@ __exportStar(require("./models/TargetConfig"), exports);
 __exportStar(require("./models/TestMetadata"), exports);
 __exportStar(require("./models/ToolCallResult"), exports);
 __exportStar(require("./models/ToolSchema"), exports);
+var fileUploadWorkerRegistry_1 = require("./persistence/files/fileUploadWorkerRegistry");
+Object.defineProperty(exports, "getFileUploadAggregateStatus", { enumerable: true, get: function () { return fileUploadWorkerRegistry_1.getFileUploadAggregateStatus; } });
+Object.defineProperty(exports, "shutdownFileUploadWorkers", { enumerable: true, get: function () { return fileUploadWorkerRegistry_1.shutdownFileUploadWorkers; } });
 var PersistencePlugin_1 = require("./persistence/PersistencePlugin");
 Object.defineProperty(exports, "PersistencePluginRegistry", { enumerable: true, get: function () { return PersistencePlugin_1.PersistencePluginRegistry; } });
 var TargetRuntimePlugin_1 = require("./targets/TargetRuntimePlugin");
@@ -177,6 +180,7 @@ if (require.main === module) {
     // never when imported as a library (where they would hijack the host
     // application's error handling).
     (0, init_1.installCrashHandlers)();
+    (0, init_1.installShutdownHandlers)();
     main(process.argv).catch((e) => {
         Logger_1.appLogger.error('Unhandled error in main', e);
         process.exit(1);

package/dist/esm/managers/AdminApiController.js

@@ -9,6 +9,7 @@ const v4_1 = require("zod/v4");
 const AgentsApi_1 = require("../apis/AgentsApi");
 const AskAiApi_1 = require("../apis/AskAiApi");
 const EnvDataApi_1 = require("../apis/EnvDataApi");
+const FileUploadsApi_1 = require("../apis/FileUploadsApi");
 const FlowsAiQueriesApi_1 = require("../apis/FlowsAiQueriesApi");
 const FlowsApi_1 = require("../apis/FlowsApi");
 const FlowsFilesApi_1 = require("../apis/FlowsFilesApi");
@@ -246,6 +247,7 @@ class AdminApiController {
             pingApi: new PingApi_1.PingApi(),
             schemaApi: new SchemaApi_1.SchemaApi(),
             targetsApi: new TargetsApi_1.TargetsApi(donobuStack.targetRuntimePlugins),
+            fileUploadsApi: new FileUploadsApi_1.FileUploadsApi(),
         };
     }
     /**
@@ -348,6 +350,7 @@ class AdminApiController {
     static registerUtilityRoutes(app, apis) {
         app.get('/api/ping', this.asyncHandler(apis.pingApi.ping.bind(apis.pingApi)));
         app.get('/api/schema', this.asyncHandler(apis.schemaApi.getSchema.bind(apis.schemaApi)));
+        app.get('/api/uploads/status', this.asyncHandler(apis.fileUploadsApi.getStatus.bind(apis.fileUploadsApi)));
     }
     static asyncHandler(fn) {
         return (req, res, next) => {

package/dist/esm/managers/DonobuFlow.d.ts

@@ -77,7 +77,7 @@ export declare class DonobuFlow {
      *          {@link metadata.result}, or `null` when the flow ended without an
      *          explicit result.
      */
-    run(): Promise<Record<string, unknown> | null>;
+    run(): Promise<FlowMetadata['result']>;
     /**
      * Delegates to the inspector to attempt recovery after the target is
      * closed. If recovery fails, the flow is marked as failed.

package/dist/esm/models/FlowHandle.d.ts

@@ -1,5 +1,6 @@
 import type { DonobuFlow } from '../managers/DonobuFlow';
 import type { FlowLogBuffer } from '../utils/FlowLogBuffer';
+import type { FlowMetadata } from './FlowMetadata';
 /**
  * Handle that pairs an active DonobuFlow with its running job promise.
  *
@@ -8,7 +9,7 @@ import type { FlowLogBuffer } from '../utils/FlowLogBuffer';
  */
 export interface FlowHandle {
     donobuFlow: DonobuFlow;
-    job: Promise<Record<string, unknown> | null>;
+    job: Promise<FlowMetadata['result']>;
     logBuffer: FlowLogBuffer;
 }
 //# sourceMappingURL=FlowHandle.d.ts.map

package/dist/esm/models/FlowMetadata.d.ts

@@ -154,7 +154,7 @@ export declare const FlowMetadataSchema: z.ZodObject<{
         DETERMINISTIC: "DETERMINISTIC";
     }>;
     isControlPanelEnabled: z.ZodBoolean;
-    result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>>;
     inputTokensUsed: z.ZodNumber;
     completionTokensUsed: z.ZodNumber;
     startedAt: z.ZodNullable<z.ZodNumber>;

package/dist/esm/models/FlowMetadata.js

@@ -60,7 +60,10 @@ exports.FlowMetadataSchema = RunConfig_1.RunConfigSchema.extend({
         .boolean()
         .describe('Set to true if the control panel should be enabled.'),
     result: v4_1.z
-        .record(v4_1.z.string(), v4_1.z.unknown())
+        .union([
+        v4_1.z.record(v4_1.z.string(), v4_1.z.unknown()),
+        v4_1.z.array(v4_1.z.record(v4_1.z.string(), v4_1.z.unknown())),
+    ])
         .nullable()
         .describe(`The final output of the flow, populated when the flow reaches a terminal state. The content
 depends on how the flow completes:

package/dist/esm/persistence/DonobuSqliteDb.js

@@ -50,6 +50,7 @@ const MiscUtils_1 = require("../utils/MiscUtils");
 const normalizeFlowMetadata_1 = require("./normalizeFlowMetadata");
 const TestConfigHash_1 = require("./TestConfigHash");
 let instance = null;
+const Hex32RegExp = /^[a-f0-9]{32}$/i;
 /**
  * ##################################################################
  * #                                                                #
@@ -517,6 +518,212 @@ CREATE INDEX IF NOT EXISTS idx_ai_queries_flow_id_started_at ON ai_queries(flow_
             }
         },
     },
+    {
+        version: 13,
+        up: (db) => {
+            // 1. Fetch all flows, oldest first.
+            const flows = v4_1.z
+                .array(v4_1.z.object({
+                id: v4_1.z.string(),
+                test_id: v4_1.z.string().nullable(),
+                metadata: v4_1.z.string(),
+            }))
+                .parse(db
+                .prepare('SELECT id, test_id, metadata FROM flow_metadata ORDER BY created_at ASC')
+                .all())
+                // We'll only consider those flows without tests, or those migrated by
+                // migration 12. Fortunately, only flows that were created as part of
+                // migration 12 have test IDs that are 32-character hexidecimals (tests
+                // generated in the app use UUIDs, and tests generated by the SDK use
+                // the Playwright testId, both of which contain hypens).
+                .filter((flow) => flow.test_id === null || Hex32RegExp.test(flow.test_id));
+            if (flows.length === 0) {
+                return;
+            }
+            // 2. Build a config hash for each flow and group by hash.
+            const groups = new Map();
+            // If 2 flows previously hashed to different tests, but now have the same
+            // hash (due to the improvements to hashTestConfig), and the user executed
+            // the test that will now be merged into the other one, we'll need to
+            // correctly move over the new flow using the same mapping, even if the
+            // hash changes (because the user edited the test, say). So we'll need to
+            // keep track of the mapping of old hash to new hash.
+            const oldHashToNewHash = new Map();
+            // We'll also want to delete the old test if it's no longer referenced by
+            // any flows.
+            const testsToDelete = new Set();
+            for (const flow of flows) {
+                try {
+                    const flowMetadata = FlowMetadata_1.FlowMetadataSchema.parse((0, normalizeFlowMetadata_1.normalizeFlowMetadata)(JSON.parse(flow.metadata)));
+                    /*
+                     * There are 7 possible scenarios, since the hashing algorithm was
+                     * improved since migration 12, and some flows will have a new hash,
+                     * matching them with flows that were previously added to a distinct
+                     * test:
+                     *
+                     * 1. The flow is a new (orphaned) flow, with no testId: use the hash
+                     *    to find or create its test.
+                     * 2. The flow was previously migrated by migration 12, and correctly:
+                     *    use the hash, which should match the existing testId, to keep it
+                     *    in the existing test.
+                     * 3. The flow was previously migrated by migration 12, but
+                     *    incorrectly (old hash): use the new hash to add it to the
+                     *    correct test.
+                     * 4. The flow was created from a previously-migrated test, which was
+                     *    created from a correct hash, and the test was not modified: use
+                     *    the hash, which should match the existing testId, to keep it in
+                     *    the existing test.
+                     * 5. The flow was created from a previously-migrated test, which was
+                     *    created from a correct hash, and the test was modified: since
+                     *    the test was modified, this will be a brand-new hash, but we
+                     *    want to keep the flow in this test, so use the existing testId
+                     *    to keep it in the existing test.
+                     * 6. The flow was created from a previously-migrated test, which was
+                     *    created from an incorrect hash, and the test was not modified:
+                     *    use the new hash to add it to the correct test.
+                     * 7. The flow was created from a previously-migrated test, which was
+                     *    created from an incorrect hash, and the test was modified: since
+                     *    the test was modified, this will be a brand-new hash, but we
+                     *    want to keep it with the other flows from this test, so use a
+                     *    old-hash-to-new-hash map to assign it the correct test based on
+                     *    its current testId.
+                     *
+                     * We have no way of distinguishing between scenarios 5 and 7, since
+                     * they both produce brand-new hashes, so we'll need to keep track of
+                     * the mapping of old hash to new hash (based on the flows that
+                     * existed prior to migration 12) to assign the flow to the correct
+                     * test. Since flows are handled in oldest-to-newest order, the map
+                     * should be populated by migration 12 flows prior to new flows being
+                     * encountered.
+                     */
+                    let hash = (0, TestConfigHash_1.hashTestConfig)(flowMetadata);
+                    if (flowMetadata.testId && flowMetadata.testId !== hash) {
+                        // Scenario 3, 5, 6
+                        if (oldHashToNewHash.has(flowMetadata.testId)) {
+                            hash = oldHashToNewHash.get(flowMetadata.testId);
+                        }
+                        else if (groups.has(flowMetadata.testId)) {
+                            // Scenario 5
+                            hash = flowMetadata.testId;
+                        }
+                        else {
+                            // Scenario 3 (first time)
+                            oldHashToNewHash.set(flowMetadata.testId, hash);
+                            testsToDelete.add(flowMetadata.testId);
+                        }
+                    }
+                    const existing = groups.get(hash);
+                    if (existing) {
+                        existing.push(flowMetadata);
+                    }
+                    else {
+                        groups.set(hash, [flowMetadata]);
+                    }
+                }
+                catch (error) {
+                    // Fail open: skip flows we can't parse/normalize so one bad row
+                    // doesn't block the rest of the migration.
+                    Logger_1.appLogger.error(`Migration 13: skipping flow ${flow.id} during grouping:`, error);
+                }
+            }
+            Logger_1.appLogger.info(`Migration 13: found ${groups.size} test groups`);
+            // 3. Create a test for each group.
+            const insertTestStmt = db.prepare(`
+        INSERT OR IGNORE INTO test_metadata (id, name, metadata, created_at, suite_id, next_run_mode)
+        VALUES (@id, @name, @metadata, @createdAt, @suiteId, @nextRunMode)
+      `);
+            const updateFlowStmt = db.prepare('UPDATE flow_metadata SET test_id = ?, metadata = ? WHERE id = ?');
+            const deleteTestStmt = db.prepare('DELETE FROM test_metadata WHERE id = ?');
+            const countFlowsByTestIdStmt = db.prepare('SELECT COUNT(*) FROM flow_metadata WHERE test_id = ?');
+            let testsCreated = 0;
+            let testsSkipped = 0;
+            let flowsLinked = 0;
+            let failures = 0;
+            let testsDeleted = 0;
+            for (const [hash, flows] of groups) {
+                try {
+                    // Flows were inserted oldest-first, so the last entry is newest.
+                    const newestFlow = flows[flows.length - 1];
+                    // `maxToolCalls` is null on every deterministic flow, so prefer the
+                    // most recent autonomous flow's value. Fall back to the newest flow's
+                    // value (likely null) if no autonomous flow exists in the group.
+                    const newestAutonomous = [...flows]
+                        .reverse()
+                        .find((f) => f.runMode === 'AUTONOMOUS');
+                    const maxToolCalls = newestAutonomous?.maxToolCalls ?? newestFlow.maxToolCalls;
+                    const testName = (0, displayName_1.getDisplayName)(newestFlow, 'Untitled Test');
+                    const testMetadata = {
+                        id: hash,
+                        name: testName,
+                        target: newestFlow.target,
+                        web: newestFlow.web,
+                        envVars: newestFlow.envVars,
+                        customTools: newestFlow.customTools,
+                        overallObjective: newestFlow.overallObjective,
+                        allowedTools: newestFlow.allowedTools,
+                        resultJsonSchema: newestFlow.resultJsonSchema,
+                        callbackUrl: newestFlow.callbackUrl,
+                        videoDisabled: newestFlow.videoDisabled,
+                        maxToolCalls,
+                        metadataVersion: newestFlow.metadataVersion,
+                        createdWithDonobuVersion: newestFlow.createdWithDonobuVersion,
+                        suiteId: null,
+                        nextRunMode: 'DETERMINISTIC',
+                    };
+                    const insertResult = insertTestStmt.run({
+                        id: hash,
+                        name: testName,
+                        metadata: JSON.stringify(testMetadata),
+                        createdAt: Date.now(),
+                        suiteId: null,
+                        nextRunMode: 'DETERMINISTIC',
+                    });
+                    if (insertResult.changes > 0) {
+                        testsCreated++;
+                    }
+                    else {
+                        testsSkipped++;
+                    }
+                    // 4. Link each flow to its test (both test_id column and testId in JSON).
+                    for (const groupedFlow of flows) {
+                        try {
+                            groupedFlow.testId = hash;
+                            updateFlowStmt.run(hash, JSON.stringify(groupedFlow), groupedFlow.id);
+                            flowsLinked++;
+                        }
+                        catch (error) {
+                            failures++;
+                            Logger_1.appLogger.error(`Migration 13: failed to link flow ${groupedFlow.id} to test ${hash}:`, error);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Fail open: skip groups we can't materialize as tests.
+                    failures++;
+                    Logger_1.appLogger.error(`Migration 13: skipping test group ${hash}:`, error);
+                }
+            }
+            // 5. Delete any tests that are no longer referenced by any flows.
+            for (const testId of testsToDelete) {
+                // Verify that there are no flows still referencing the test.
+                const flowsReferencingTest = countFlowsByTestIdStmt.get(testId);
+                if (Number(flowsReferencingTest) > 0) {
+                    Logger_1.appLogger.warn(`Migration 13: skipping deletion of test ${testId} because it is still referenced by ${flowsReferencingTest} flow(s).`);
+                    continue;
+                }
+                deleteTestStmt.run(testId);
+                testsDeleted++;
+            }
+            Logger_1.appLogger.info(`Migration 13: done:
+  - Created ${testsCreated} test(s)
+  - Skipped ${testsSkipped} pre-existing test(s)
+  - Linked ${flowsLinked} flow(s)
+  - Deleted ${testsDeleted} test(s)`);
+            if (failures > 0) {
+                Logger_1.appLogger.warn(`Migration 13: ${failures} failure(s) (see errors above).`);
+            }
+        },
+    },
 ];
 /**
  * Create the SQL schema migrations table that can be used to manage table