donobu 5.36.0 → 5.36.2

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

@@ -22,6 +22,7 @@ import type { RunConfig } from '../models/RunConfig';
 import type { RunMode } from '../models/RunMode';
 import type { ToolCall } from '../models/ToolCall';
 import type { FlowsPersistenceRegistry } from '../persistence/flows/FlowsPersistenceRegistry';
+import type { TestsPersistenceRegistry } from '../persistence/tests/TestsPersistenceRegistry';
 import type { TargetRuntimePluginRegistry } from '../targets/TargetRuntimePlugin';
 import type { Tool } from '../tools/Tool';
 import type { FlowLogSnapshot } from '../utils/FlowLogBuffer';
@@ -45,17 +46,22 @@ export declare class DonobuFlowsManager {
     private readonly environ;
     private readonly toolRegistry;
     private readonly targetRuntimePlugins;
+    private readonly testsPersistenceRegistry;
     static readonly DEFAULT_MESSAGE_DURATION = 2247;
     static readonly DEFAULT_MAX_TOOL_CALLS = 50;
     static readonly DEFAULT_BROWSER_STATE_FILENAME = "browserstate.json";
     static readonly FLOW_NAME_MAX_LENGTH = 255;
     private readonly flowRuntime;
     private readonly flowCatalog;
-    constructor(deploymentEnvironment: DonobuDeploymentEnvironment, gptClientFactory: GptClientFactory, gptConfigsManager: GptConfigsManager, agentsManager: AgentsManager, flowsPersistenceRegistry: FlowsPersistenceRegistry, envDataManager: EnvDataManager, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME'>, toolRegistry: ToolRegistry, targetRuntimePlugins: TargetRuntimePluginRegistry);
+    constructor(deploymentEnvironment: DonobuDeploymentEnvironment, gptClientFactory: GptClientFactory, gptConfigsManager: GptConfigsManager, agentsManager: AgentsManager, flowsPersistenceRegistry: FlowsPersistenceRegistry, envDataManager: EnvDataManager, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME'>, toolRegistry: ToolRegistry, targetRuntimePlugins: TargetRuntimePluginRegistry, testsPersistenceRegistry: TestsPersistenceRegistry);
     /**
      * Create a flow with the given parameters and invoke its `DonobuFlow#run`
      * method, adding it to list of active flows.
      *
+     * If `flowParams.testId` is set, the new flow is persisted to the same
+     * layer as the referenced test so the `flow_metadata.test_id` foreign
+     * key holds. Otherwise the primary layer is used.
+     *
      * @param gptClient If present, will use this as the associated GPT client for
      *          this flow instead of instantiating a new one. If so, the
      *          gptConfigNameOverride field will be ignored.
@@ -168,6 +174,20 @@ export declare class DonobuFlowsManager {
      * {@link BrowserStateNotFoundException} if it is not found.
      */
     getBrowserStorageState(browserStateRef: BrowserStateReference): Promise<BrowserStorageState>;
+    /**
+     * Picks the flows persistence layer to use when creating a new flow.
+     *
+     * - If `testId` is null/undefined: use the primary flows layer.
+     * - If `testId` is set: look up the test's layer key and use the matching
+     *   flows layer. If no flows layer matches the test's key (rare —
+     *   asymmetric registry config), fall back to the primary layer; the FK
+     *   won't hold but the flow is at least persisted.
+     * - If `testId` is set but no test exists with that ID anywhere: fall
+     *   back to the primary layer (the SQLite FK will reject if applicable;
+     *   non-DB layers will accept the dangling reference).
+     */
+    private resolveLayerForFlowCreate;
+    private findTestLayerKey;
     private isLocallyRunning;
 }
 /**

package/dist/esm/managers/DonobuFlowsManager.js

@@ -47,6 +47,7 @@ const BrowserStateNotFoundException_1 = require("../exceptions/BrowserStateNotFo
 const CannotDeleteRunningFlowException_1 = require("../exceptions/CannotDeleteRunningFlowException");
 const FlowNotFoundException_1 = require("../exceptions/FlowNotFoundException");
 const InvalidParamValueException_1 = require("../exceptions/InvalidParamValueException");
+const TestNotFoundException_1 = require("../exceptions/TestNotFoundException");
 const ToolRequiresGptException_1 = require("../exceptions/ToolRequiresGptException");
 const UnknownToolException_1 = require("../exceptions/UnknownToolException");
 const GptConfig_1 = require("../models/GptConfig");
@@ -64,7 +65,7 @@ const FlowRuntime_1 = require("./FlowRuntime");
 const InteractionVisualizer_1 = require("./InteractionVisualizer");
 const ToolManager_1 = require("./ToolManager");
 class DonobuFlowsManager {
-    constructor(deploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, toolRegistry, targetRuntimePlugins) {
+    constructor(deploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, toolRegistry, targetRuntimePlugins, testsPersistenceRegistry) {
         this.deploymentEnvironment = deploymentEnvironment;
         this.gptClientFactory = gptClientFactory;
         this.gptConfigsManager = gptConfigsManager;
@@ -75,6 +76,7 @@ class DonobuFlowsManager {
         this.environ = environ;
         this.toolRegistry = toolRegistry;
         this.targetRuntimePlugins = targetRuntimePlugins;
+        this.testsPersistenceRegistry = testsPersistenceRegistry;
         this.flowRuntime = new FlowRuntime_1.FlowRuntime();
         this.flowCatalog = new FlowCatalog_1.FlowCatalog(this.flowsPersistenceRegistry, this.flowRuntime, this.deploymentEnvironment);
     }
@@ -82,6 +84,10 @@ class DonobuFlowsManager {
      * Create a flow with the given parameters and invoke its `DonobuFlow#run`
      * method, adding it to list of active flows.
      *
+     * If `flowParams.testId` is set, the new flow is persisted to the same
+     * layer as the referenced test so the `flow_metadata.test_id` foreign
+     * key holds. Otherwise the primary layer is used.
+     *
      * @param gptClient If present, will use this as the associated GPT client for
      *          this flow instead of instantiating a new one. If so, the
      *          gptConfigNameOverride field will be ignored.
@@ -179,7 +185,7 @@ class DonobuFlowsManager {
                     ...targetRuntime.getMetadataFields(),
                     provenance: (0, buildProvenance_1.buildProvenance)('DONOBU_STUDIO'),
                 };
-                const flowsPersistence = await this.flowsPersistenceRegistry.get();
+                const flowsPersistence = await this.resolveLayerForFlowCreate(flowParams.testId ?? null);
                 const envData = await this.envDataManager.getByNames(flowMetadata.envVars ?? []);
                 const donobuFlow = new DonobuFlow_1.DonobuFlow(this, envData, flowsPersistence, gptClientData.gptClient, toolManager, interactionVisualizer, toolCallsOnStart, [], [], targetRuntime.inspector, flowMetadata, targetRuntime.controlPanel);
                 await flowsPersistence.setFlowMetadata(flowMetadata);
@@ -652,6 +658,49 @@ class DonobuFlowsManager {
         }
         throw new BrowserStateNotFoundException_1.BrowserStateNotFoundException(flowMetadata.id);
     }
+    /**
+     * Picks the flows persistence layer to use when creating a new flow.
+     *
+     * - If `testId` is null/undefined: use the primary flows layer.
+     * - If `testId` is set: look up the test's layer key and use the matching
+     *   flows layer. If no flows layer matches the test's key (rare —
+     *   asymmetric registry config), fall back to the primary layer; the FK
+     *   won't hold but the flow is at least persisted.
+     * - If `testId` is set but no test exists with that ID anywhere: fall
+     *   back to the primary layer (the SQLite FK will reject if applicable;
+     *   non-DB layers will accept the dangling reference).
+     */
+    async resolveLayerForFlowCreate(testId) {
+        if (!testId) {
+            return this.flowsPersistenceRegistry.get();
+        }
+        let testLayerKey;
+        try {
+            testLayerKey = await this.findTestLayerKey(testId);
+        }
+        catch (error) {
+            if (!(error instanceof TestNotFoundException_1.TestNotFoundException)) {
+                throw error;
+            }
+            return this.flowsPersistenceRegistry.get();
+        }
+        const matched = await this.flowsPersistenceRegistry.getByKey(testLayerKey);
+        return matched ?? (await this.flowsPersistenceRegistry.get());
+    }
+    async findTestLayerKey(testId) {
+        for (const { key, persistence, } of await this.testsPersistenceRegistry.getEntries()) {
+            try {
+                await persistence.getTestById(testId);
+                return key;
+            }
+            catch (error) {
+                if (!(error instanceof TestNotFoundException_1.TestNotFoundException)) {
+                    throw error;
+                }
+            }
+        }
+        throw TestNotFoundException_1.TestNotFoundException.forId(testId);
+    }
     isLocallyRunning() {
         return this.deploymentEnvironment === 'LOCAL';
     }

package/dist/esm/managers/DonobuStack.js

@@ -46,12 +46,12 @@ async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory
     const agentsPersistence = await AgentsPersistenceSqlite_1.AgentsPersistenceSqlite.create(sqliteDb);
     const agentsManager = await AgentsManager_1.AgentsManager.create(agentsPersistence, gptConfigsManager);
     const flowsPersistenceRegistry = await FlowsPersistenceRegistry_1.FlowsPersistenceRegistryImpl.fromEnvironment(environ, persistencePlugins);
-    const envPersistenceFactory = await EnvPersistenceRegistry_1.EnvPersistenceRegistryImpl.fromEnvironment(envPersistenceVolatile ?? null, environ, persistencePlugins);
-    const envDataManager = new EnvDataManager_1.EnvDataManager(envPersistenceFactory);
-    const flowsManager = new DonobuFlowsManager_1.DonobuFlowsManager(donobuDeploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, resolvedToolRegistry, targetRuntimePlugins);
     const testsPersistenceRegistry = await TestsPersistenceRegistry_1.TestsPersistenceRegistryImpl.fromEnvironment(environ, flowsPersistenceRegistry);
-    const testsManager = new TestsManager_1.TestsManager(testsPersistenceRegistry, flowsManager);
     const suitesPersistenceRegistry = await SuitesPersistenceRegistry_1.SuitesPersistenceRegistryImpl.fromEnvironment(environ);
+    const envPersistenceFactory = await EnvPersistenceRegistry_1.EnvPersistenceRegistryImpl.fromEnvironment(envPersistenceVolatile ?? null, environ, persistencePlugins);
+    const envDataManager = new EnvDataManager_1.EnvDataManager(envPersistenceFactory);
+    const flowsManager = new DonobuFlowsManager_1.DonobuFlowsManager(donobuDeploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, resolvedToolRegistry, targetRuntimePlugins, testsPersistenceRegistry);
+    const testsManager = new TestsManager_1.TestsManager(testsPersistenceRegistry, suitesPersistenceRegistry, flowsManager);
     const suitesManager = new SuitesManager_1.SuitesManager(suitesPersistenceRegistry, testsPersistenceRegistry);
     return {
         toolRegistry: resolvedToolRegistry,

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

@@ -1,31 +1,61 @@
 import type { PaginatedResult } from '../models/PaginatedResult';
+/**
+ * Per-layer pagination state, carried across pages inside the composite
+ * page token. `cursor` is the layer's own opaque page token; `resumeAfterId`
+ * is the id of the last item from this layer kept on the previous page (in
+ * the layer's own order). `exhausted` becomes true once a layer has nothing
+ * more to give and we've already returned everything it contributed.
+ */
+interface SourceState {
+    cursor?: string;
+    resumeAfterId?: string;
+    exhausted: boolean;
+}
 /**
  * Internal state tracked across pages when federating results from multiple
- * persistence layers.
+ * persistence layers. Serialized as base64(JSON(...)) into the composite
+ * page token.
  */
 interface FederatedPaginationState {
-    sourceTokens: Record<number, string>;
-    exhaustedSources: number[];
-    cursorTimestamp: number | null;
+    sources: SourceState[];
 }
 export declare function createCompositePageToken(state: FederatedPaginationState): string;
 export declare function parseCompositePageToken(token?: string): FederatedPaginationState;
 /**
- * Federate a paginated listing across multiple persistence layers.
+ * Federate a paginated listing across multiple persistence layers
+ * (resume-by-id).
+ *
+ * Each layer holds an opaque cursor and an optional `resumeAfterId`. On
+ * each page request, federation fetches from each non-exhausted layer
+ * (advancing through batches as needed until it has at least `limit`
+ * candidates per layer), stable-sorts the merged contributions with the
+ * caller's `comparator`, and trims to `limit`. For each layer, the
+ * **last kept item in that layer's order** becomes the new
+ * `resumeAfterId`, with `cursor` set to the layer-token used to fetch
+ * that item's batch. Layers whose contribution is wholly dropped by the
+ * trim retain their pre-call state so their items remain reachable on
+ * later pages.
  *
- * Each layer is queried with up to 2× the requested limit, results are merged,
- * sorted by the provided comparator, and trimmed to the requested limit.
- * A composite page token tracks per-source pagination state.
+ * **Critical contract: the comparator must NOT tiebreak by id.** Ties
+ * on the sort key must return 0 from `comparator`. `Array.sort` is
+ * stable since ES2019, and federation feeds the merge in
+ * `[layer0..., layer1..., ...]` insertion order, so ties resolve by
+ * `(layerIndex, layer-internal position)` — exactly the property that
+ * keeps each layer's kept items as a *prefix* of its own order, which
+ * is what makes a single `resumeAfterId` representable. An id
+ * tiebreaker would silently break this and lose items.
  *
- * @param layers    The persistence layers to query.
- * @param query     The query object (must have `limit`, `pageToken`).
- * @param fetcher   Function that queries a single layer.
- * @param comparator Sort comparator for merging results across layers.
+ * **Layer contract.** Layers must return the same items in the same
+ * order for the same `(query, pageToken)` pair across calls. Their
+ * internal ordering does not need to match federation's tiebreaker —
+ * just be deterministic.
  */
 export declare function federatedList<TQuery extends {
     limit?: number;
     pageToken?: string;
-}, TItem>(layers: {
+}, TItem extends {
+    id: string;
+}>(layers: {
     getItems: (query: TQuery) => Promise<PaginatedResult<TItem>>;
 }[], query: TQuery, comparator: (a: TItem, b: TItem) => number): Promise<PaginatedResult<TItem>>;
 export {};

package/dist/esm/managers/FederatedPagination.js

@@ -8,67 +8,150 @@ function createCompositePageToken(state) {
 }
 function parseCompositePageToken(token) {
     if (!token) {
-        return { sourceTokens: {}, exhaustedSources: [], cursorTimestamp: null };
+        return { sources: [] };
     }
     try {
-        return JSON.parse(Buffer.from(token, 'base64').toString());
+        const decoded = JSON.parse(Buffer.from(token, 'base64').toString());
+        if (decoded && Array.isArray(decoded.sources)) {
+            return decoded;
+        }
     }
     catch {
-        return { sourceTokens: {}, exhaustedSources: [], cursorTimestamp: null };
+        // fall through
     }
+    return { sources: [] };
 }
 /**
- * Federate a paginated listing across multiple persistence layers.
+ * Federate a paginated listing across multiple persistence layers
+ * (resume-by-id).
+ *
+ * Each layer holds an opaque cursor and an optional `resumeAfterId`. On
+ * each page request, federation fetches from each non-exhausted layer
+ * (advancing through batches as needed until it has at least `limit`
+ * candidates per layer), stable-sorts the merged contributions with the
+ * caller's `comparator`, and trims to `limit`. For each layer, the
+ * **last kept item in that layer's order** becomes the new
+ * `resumeAfterId`, with `cursor` set to the layer-token used to fetch
+ * that item's batch. Layers whose contribution is wholly dropped by the
+ * trim retain their pre-call state so their items remain reachable on
+ * later pages.
  *
- * Each layer is queried with up to 2× the requested limit, results are merged,
- * sorted by the provided comparator, and trimmed to the requested limit.
- * A composite page token tracks per-source pagination state.
+ * **Critical contract: the comparator must NOT tiebreak by id.** Ties
+ * on the sort key must return 0 from `comparator`. `Array.sort` is
+ * stable since ES2019, and federation feeds the merge in
+ * `[layer0..., layer1..., ...]` insertion order, so ties resolve by
+ * `(layerIndex, layer-internal position)` — exactly the property that
+ * keeps each layer's kept items as a *prefix* of its own order, which
+ * is what makes a single `resumeAfterId` representable. An id
+ * tiebreaker would silently break this and lose items.
  *
- * @param layers    The persistence layers to query.
- * @param query     The query object (must have `limit`, `pageToken`).
- * @param fetcher   Function that queries a single layer.
- * @param comparator Sort comparator for merging results across layers.
+ * **Layer contract.** Layers must return the same items in the same
+ * order for the same `(query, pageToken)` pair across calls. Their
+ * internal ordering does not need to match federation's tiebreaker —
+ * just be deterministic.
  */
 async function federatedList(layers, query, comparator) {
-    const paginationState = parseCompositePageToken(query.pageToken);
     const requestedLimit = Math.min(Math.max(1, query.limit ?? 100), 100);
-    const combinedResults = [];
-    let layersThatReturnedResults = 0;
+    const incomingState = parseCompositePageToken(query.pageToken);
+    const initialFor = (i) => {
+        const s = incomingState.sources[i];
+        return s ? { ...s } : { exhausted: false };
+    };
+    const work = [];
     for (let i = 0; i < layers.length; i++) {
-        if (paginationState.exhaustedSources.includes(i)) {
+        const init = initialFor(i);
+        const w = { contribution: [], layerExhausted: false };
+        work.push(w);
+        if (init.exhausted) {
+            w.layerExhausted = true;
             continue;
         }
-        const sourceLimit = Math.min(requestedLimit * 2, 100);
-        const sourceQuery = {
-            ...query,
-            limit: sourceLimit,
-            pageToken: paginationState.sourceTokens[i],
-        };
-        const sourceResult = await layers[i].getItems(sourceQuery);
-        if (sourceResult.items.length > 0) {
-            layersThatReturnedResults++;
+        let cursor = init.cursor;
+        let resume = init.resumeAfterId;
+        while (w.contribution.length < requestedLimit) {
+            const layerQuery = {
+                ...query,
+                limit: requestedLimit,
+                pageToken: cursor,
+            };
+            const batch = await layers[i].getItems(layerQuery);
+            let items = batch.items;
+            if (resume !== undefined) {
+                const idx = items.findIndex((it) => it.id === resume);
+                if (idx >= 0) {
+                    items = items.slice(idx + 1);
+                }
+                // The skip is one-shot: clear `resume` regardless of whether we
+                // found it. If found, we've passed it; if not, it was in a
+                // previously-fetched batch and won't reappear in subsequent
+                // batches we fetch in this loop.
+                resume = undefined;
+            }
+            for (const it of items) {
+                w.contribution.push({
+                    item: it,
+                    layerIndex: i,
+                    fetchCursor: cursor,
+                });
+            }
+            if (!batch.nextPageToken) {
+                w.layerExhausted = true;
+                break;
+            }
+            cursor = batch.nextPageToken;
         }
-        combinedResults.push(...sourceResult.items);
-        if (sourceResult.nextPageToken) {
-            paginationState.sourceTokens[i] = sourceResult.nextPageToken;
+    }
+    // Stable sort: ties resolve by insertion order = (layerIndex, layer
+    // position). Do NOT add an id tiebreaker (see header comment).
+    const merged = [];
+    for (const w of work) {
+        merged.push(...w.contribution);
+    }
+    merged.sort((a, b) => comparator(a.item, b.item));
+    const page = merged.slice(0, requestedLimit);
+    const newSources = [];
+    for (let i = 0; i < layers.length; i++) {
+        const init = initialFor(i);
+        if (init.exhausted) {
+            newSources.push({ exhausted: true });
+            continue;
+        }
+        const keptFromLayer = page.filter((w) => w.layerIndex === i);
+        if (keptFromLayer.length === 0) {
+            if (work[i].contribution.length === 0 && work[i].layerExhausted) {
+                // Layer truly has nothing — empty stream. Mark exhausted so
+                // we don't re-query it forever.
+                newSources.push({ exhausted: true });
+            }
+            else {
+                // Layer's items were all outranked by other layers. Roll back
+                // to the incoming state so they remain reachable on later
+                // pages, when the outranking layers have moved on.
+                newSources.push(init);
+            }
+            continue;
+        }
+        const lastKept = keptFromLayer[keptFromLayer.length - 1];
+        const allFromLayer = work[i].contribution;
+        const allKept = allFromLayer.length === keptFromLayer.length;
+        if (work[i].layerExhausted && allKept) {
+            newSources.push({ exhausted: true });
         }
         else {
-            paginationState.exhaustedSources.push(i);
+            newSources.push({
+                cursor: lastKept.fetchCursor,
+                resumeAfterId: lastKept.item.id,
+                exhausted: false,
+            });
         }
     }
-    // Only re-sort when results came from multiple layers; a single layer's
-    // results are already in the order it returned them, and re-sorting can
-    // disturb fields the comparator can't fully account for.
-    if (layersThatReturnedResults > 1) {
-        combinedResults.sort(comparator);
-    }
-    const limitedResults = combinedResults.slice(0, requestedLimit);
-    const hasMore = combinedResults.length > requestedLimit ||
-        paginationState.exhaustedSources.length < layers.length;
+    const someUnconsumed = merged.length > requestedLimit;
+    const someNotExhausted = newSources.some((s) => !s.exhausted);
+    const hasMore = someUnconsumed || someNotExhausted;
     return {
-        items: limitedResults,
+        items: page.map((w) => w.item),
         nextPageToken: hasMore
-            ? createCompositePageToken(paginationState)
+            ? createCompositePageToken({ sources: newSources })
             : undefined,
     };
 }

package/dist/esm/managers/SuitesManager.js

@@ -108,16 +108,21 @@ class SuitesManager {
      * behavior for non-DB persistence layers (Volatile, S3, GCS).
      */
     async deleteSuite(suiteId) {
-        const suiteLayers = await this.suitesPersistenceRegistry.getAll();
-        const testLayers = await this.testsPersistenceRegistry.getAll();
-        for (let i = 0; i < suiteLayers.length; i++) {
+        for (const { key, persistence, } of await this.suitesPersistenceRegistry.getEntries()) {
             try {
-                await suiteLayers[i].deleteSuite(suiteId);
+                await persistence.deleteSuite(suiteId);
                 // Orphan tests in this layer after successfully deleting the suite.
                 // This mirrors the DB-level ON DELETE SET NULL for non-DB layers.
-                const testsResult = await testLayers[i].getTests({ suiteId });
+                // Pair by key — the suites and tests registries can have different
+                // sets of layers (e.g. plugin-only suites persistence) so positional
+                // indexing isn't safe.
+                const testsPersistence = await this.testsPersistenceRegistry.getByKey(key);
+                if (!testsPersistence) {
+                    continue;
+                }
+                const testsResult = await testsPersistence.getTests({ suiteId });
                 for (const test of testsResult.items) {
-                    await testLayers[i].updateTest({ ...test, suiteId: null });
+                    await testsPersistence.updateTest({ ...test, suiteId: null });
                 }
             }
             catch {

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

@@ -2,14 +2,30 @@ import type { CreateDonobuFlow } from '../models/CreateDonobuFlow';
 import type { CreateTest } from '../models/CreateTest';
 import type { PaginatedResult } from '../models/PaginatedResult';
 import type { TestListItem, TestMetadata, TestsQuery } from '../models/TestMetadata';
+import type { SuitesPersistenceRegistry } from '../persistence/suites/SuitesPersistenceRegistry';
 import type { TestsPersistenceRegistry } from '../persistence/tests/TestsPersistenceRegistry';
 import type { DonobuFlowsManager } from './DonobuFlowsManager';
 export declare class TestsManager {
     private readonly testsPersistenceRegistry;
+    private readonly suitesPersistenceRegistry;
     private readonly flowsManager;
-    constructor(testsPersistenceRegistry: TestsPersistenceRegistry, flowsManager: DonobuFlowsManager);
+    constructor(testsPersistenceRegistry: TestsPersistenceRegistry, suitesPersistenceRegistry: SuitesPersistenceRegistry, flowsManager: DonobuFlowsManager);
     createTest(params: CreateTest): Promise<TestMetadata>;
     getTestById(testId: string): Promise<TestMetadata>;
+    /**
+     * Picks the tests persistence layer to use when creating a new test.
+     *
+     * - If `suiteId` is null/undefined: use the primary tests layer.
+     * - If `suiteId` is set: look up the suite's layer key and use the matching
+     *   tests layer. If no tests layer matches the suite's key (rare — would
+     *   require asymmetric registry config), fall back to the primary tests
+     *   layer; the FK won't hold but at least the test is persisted somewhere.
+     * - If `suiteId` is set but the suite doesn't exist anywhere: fall back
+     *   to the primary tests layer (the SQLite FK will reject if applicable;
+     *   non-DB layers will accept the dangling reference).
+     */
+    private resolveLayerForTestCreate;
+    private findSuiteLayerKey;
     getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     /**
      * Update a test in the persistence layer where it exists.
@@ -38,7 +54,9 @@ export declare class TestsManager {
     private getTestToolCalls;
     /**
      * Creates a new flow (config) for the given test, which should be passed to
-     * `flowsManager.createFlow` to execute the test.
+     * `flowsManager.createFlow` to execute the test. The returned config's
+     * `testId` is set, which `createFlow` uses to route the flow to the same
+     * persistence layer as the test.
      *
      * @param testId - The ID of the test to create a new flow for
      *

package/dist/esm/managers/TestsManager.js

@@ -3,13 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestsManager = void 0;
 const crypto_1 = require("crypto");
 const CannotDeleteRunningFlowException_1 = require("../exceptions/CannotDeleteRunningFlowException");
+const SuiteNotFoundException_1 = require("../exceptions/SuiteNotFoundException");
 const TestNotFoundException_1 = require("../exceptions/TestNotFoundException");
 const buildProvenance_1 = require("../utils/buildProvenance");
 const displayName_1 = require("../utils/displayName");
 const FederatedPagination_1 = require("./FederatedPagination");
 class TestsManager {
-    constructor(testsPersistenceRegistry, flowsManager) {
+    constructor(testsPersistenceRegistry, suitesPersistenceRegistry, flowsManager) {
         this.testsPersistenceRegistry = testsPersistenceRegistry;
+        this.suitesPersistenceRegistry = suitesPersistenceRegistry;
         this.flowsManager = flowsManager;
     }
     async createTest(params) {
@@ -38,9 +40,12 @@ class TestsManager {
             videoDisabled: params.videoDisabled,
             provenance: (0, buildProvenance_1.buildProvenance)('DONOBU_STUDIO'),
         };
-        // Create in the primary persistence layer only.
-        const primary = await this.testsPersistenceRegistry.get();
-        await primary.createTest(testMetadata);
+        // If the test is part of a suite, write it to the same persistence layer
+        // as the suite — otherwise the suite_id foreign key fails (in SQLite)
+        // or leaves a dangling reference (in non-DB layers). When standalone,
+        // fall back to the primary layer.
+        const persistence = await this.resolveLayerForTestCreate(testMetadata.suiteId);
+        await persistence.createTest(testMetadata);
         return testMetadata;
     }
     async getTestById(testId) {
@@ -56,6 +61,49 @@ class TestsManager {
         }
         throw TestNotFoundException_1.TestNotFoundException.forId(testId);
     }
+    /**
+     * Picks the tests persistence layer to use when creating a new test.
+     *
+     * - If `suiteId` is null/undefined: use the primary tests layer.
+     * - If `suiteId` is set: look up the suite's layer key and use the matching
+     *   tests layer. If no tests layer matches the suite's key (rare — would
+     *   require asymmetric registry config), fall back to the primary tests
+     *   layer; the FK won't hold but at least the test is persisted somewhere.
+     * - If `suiteId` is set but the suite doesn't exist anywhere: fall back
+     *   to the primary tests layer (the SQLite FK will reject if applicable;
+     *   non-DB layers will accept the dangling reference).
+     */
+    async resolveLayerForTestCreate(suiteId) {
+        if (!suiteId) {
+            return this.testsPersistenceRegistry.get();
+        }
+        let suiteLayerKey;
+        try {
+            suiteLayerKey = await this.findSuiteLayerKey(suiteId);
+        }
+        catch (error) {
+            if (!(error instanceof SuiteNotFoundException_1.SuiteNotFoundException)) {
+                throw error;
+            }
+            return this.testsPersistenceRegistry.get();
+        }
+        const matched = await this.testsPersistenceRegistry.getByKey(suiteLayerKey);
+        return matched ?? (await this.testsPersistenceRegistry.get());
+    }
+    async findSuiteLayerKey(suiteId) {
+        for (const { key, persistence, } of await this.suitesPersistenceRegistry.getEntries()) {
+            try {
+                await persistence.getSuiteById(suiteId);
+                return key;
+            }
+            catch (error) {
+                if (!(error instanceof SuiteNotFoundException_1.SuiteNotFoundException)) {
+                    throw error;
+                }
+            }
+        }
+        throw SuiteNotFoundException_1.SuiteNotFoundException.forId(suiteId);
+    }
     async getTests(query) {
         const layers = (await this.testsPersistenceRegistry.getAll()).map((persistence) => ({
             getItems: (q) => persistence.getTests(q),
@@ -65,13 +113,6 @@ class TestsManager {
         // TestMetadata has no `created_at` field — fall back to "now" so newly
         // returned items sort to the most-recent end. For other sort columns,
         // map the snake_case API name to the camelCase JS field.
-        //
-        // `flow_count` and `latest_flow_created_at` are only known at the
-        // persistence layer (SQLite computes them via JOIN; the cloud handles
-        // them server-side). Returning 0 here means each layer's pre-sorted
-        // results stay in their own order during the federated merge, but
-        // ordering across layers degrades to "first seen wins" — fine for the
-        // common single-primary-layer case.
         const fieldFor = (test) => {
             switch (sortBy) {
                 case 'created_at':
@@ -83,8 +124,9 @@ class TestsManager {
                 case 'next_run_mode':
                     return test.nextRunMode;
                 case 'flow_count':
+                    return test.flowCount ?? 0;
                 case 'latest_flow_created_at':
-                    return 0;
+                    return test.latestFlow?.startedAt ?? Date.now();
                 default:
                     return '';
             }
@@ -196,7 +238,9 @@ class TestsManager {
     }
     /**
      * Creates a new flow (config) for the given test, which should be passed to
-     * `flowsManager.createFlow` to execute the test.
+     * `flowsManager.createFlow` to execute the test. The returned config's
+     * `testId` is set, which `createFlow` uses to route the flow to the same
+     * persistence layer as the test.
      *
      * @param testId - The ID of the test to create a new flow for
      *
@@ -210,7 +254,16 @@ class TestsManager {
             try {
                 toolCallsOnStart = await this.getTestToolCalls(test);
             }
-            catch {
+            catch (error) {
+                // Fallback to AUTONOMOUS is only viable when the test has an
+                // overallObjective for the agent to work toward. For tests without
+                // one (e.g. Playwright-imported tests, or AI tests where the user
+                // cleared the objective), AUTONOMOUS would just fail downstream
+                // with a misleading "overallObjective is required" — propagate the
+                // original error instead so the user sees the real cause.
+                if ((test.overallObjective?.trim().length ?? 0) === 0) {
+                    throw error;
+                }
                 runMode = 'AUTONOMOUS';
             }
         }