donobu 5.52.1 → 5.52.3

package/dist/cli/donobu-cli.js

@@ -64,6 +64,9 @@ const envVars_1 = require("../envVars");
 const gptClients_1 = require("../lib/test/fixtures/gptClients");
 const donobuTestStack_1 = require("../lib/test/utils/donobuTestStack");
 const triageTestFailure_1 = require("../lib/test/utils/triageTestFailure");
+const fileUploadWorkerRegistry_1 = require("../persistence/files/fileUploadWorkerRegistry");
+const FlowsPersistenceDonobuApi_1 = require("../persistence/flows/FlowsPersistenceDonobuApi");
+const FlowsPersistenceRegistry_1 = require("../persistence/flows/FlowsPersistenceRegistry");
 const merge_1 = require("../reporter/merge");
 const model_1 = require("../reporter/model");
 const render_1 = require("../reporter/render");
@@ -1749,6 +1752,19 @@ function parseHealArgs(args) {
  * 3. Collects failure evidence and generates treatment plans.
  * 4. Optionally runs an auto-heal retry if plans suggest it.
  */
+/**
+ * Idle re-scan interval for the parent-owned upload daemon. The producers are
+ * the Playwright worker processes, so the daemon can't be woken by an
+ * in-process notify() — it polls the shared cache instead.
+ */
+const PARENT_UPLOAD_POLL_INTERVAL_MS = 1_000;
+/**
+ * How long the parent waits for artifact uploads to flush after the Playwright
+ * run finishes. Generous because — unlike the old per-worker drain — this runs
+ * in the long-lived CLI parent, free of Playwright's fixture-teardown timeout,
+ * so it blocks nothing critical and truncates no traces.
+ */
+const PARENT_UPLOAD_DRAIN_TIMEOUT_MS = 60_000;
 async function runTestCommand(cliArgs) {
     const { options, playwrightArgs } = parseTestCommandArgs(cliArgs);
     const playwrightOutputDir = resolvePlaywrightOutputDir(playwrightArgs);
@@ -1793,6 +1809,27 @@ async function runTestCommand(cliArgs) {
     if (effectiveOptions.autoHeal) {
         envOverrides.DONOBU_AUTO_HEAL_ORCHESTRATED = '1';
     }
+    // Own artifact uploads from THIS long-lived parent rather than the ephemeral,
+    // force-killable Playwright workers. When a cloud uploader starts here, flip
+    // the workers to producer-only mode: they cache artifact bytes locally but
+    // run no uploader, so worker teardown can never block on an in-flight upload.
+    // The parent's uploader drains the shared cache continuously during the run
+    // and flushes whatever's left in the finally below.
+    const donobuCloud = (0, FlowsPersistenceRegistry_1.resolveDonobuCloudConfig)(envVars_1.env.pick('DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'PERSISTENCE_PRIORITY'));
+    const parentOwnsUploads = donobuCloud !== null;
+    if (donobuCloud) {
+        // Start just the uploader — no read/write client, since the parent never
+        // reads or writes flows itself.
+        (0, FlowsPersistenceDonobuApi_1.startDonobuParentUploader)(donobuCloud.baseUrl, donobuCloud.apiKey, PARENT_UPLOAD_POLL_INTERVAL_MS);
+        // Set on process.env (not just this run's overrides) so EVERY spawned
+        // Playwright child inherits it — the initial run and the auto-heal rerun
+        // alike — via runPlaywright's `{ ...process.env, ...overrides }`. Our own
+        // parent uploader was already started above, so this late mutation (which
+        // only affects freshly-parsed child envs) doesn't touch it.
+        process.env.DONOBU_UPLOADS_OWNED_BY_PARENT = '1';
+        Logger_1.appLogger.debug(`donobu test: this process owns cloud artifact uploads; Playwright ` +
+            `workers will cache bytes and exit without waiting on uploads.`);
+    }
     const reporterSetup = await ensureJsonReporter(playwrightArgs, {
         playwrightOutputDir,
     });
@@ -1895,6 +1932,27 @@ async function runTestCommand(cliArgs) {
         return exitCode;
     }
     finally {
+        // Flush any artifact uploads this parent owns before returning. main()
+        // calls process.exit() right after runTestCommand resolves, which would
+        // otherwise abandon in-flight uploads. Runs on every return path. Skipped
+        // when no parent uploader was started (local-only runs).
+        if (parentOwnsUploads) {
+            try {
+                const result = await (0, fileUploadWorkerRegistry_1.shutdownFileUploadWorkers)(PARENT_UPLOAD_DRAIN_TIMEOUT_MS);
+                if (result.drained) {
+                    Logger_1.appLogger.debug('donobu test: all artifact uploads flushed.');
+                }
+                else {
+                    Logger_1.appLogger.warn(`donobu test: ${result.totalRemaining} artifact upload(s) did not ` +
+                        `finish within ` +
+                        `${Math.round(PARENT_UPLOAD_DRAIN_TIMEOUT_MS / 1000)}s; they ` +
+                        `remain on disk and resume on the next \`donobu\` run.`);
+                }
+            }
+            catch (error) {
+                Logger_1.appLogger.warn('donobu test: error draining parent uploads.', error);
+            }
+        }
         // Clean up the JSON artifacts Donobu created for its own internal use.
         // Runs after every return path (early-exit when tests pass / auto-heal
         // disabled, and the post-heal path) so we don't leave the state file or

package/dist/envVars.d.ts

@@ -75,6 +75,7 @@ export declare const env: Env<{
     EXPERIMENTAL_FEATURES_ENABLED: z.ZodDefault<z.ZodBoolean>;
     DONOBU_API_KEY: z.ZodOptional<z.ZodString>;
     DONOBU_PERSISTENCE_API_KEY: z.ZodOptional<z.ZodString>;
+    DONOBU_UPLOADS_OWNED_BY_PARENT: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
     GOOGLE_CLOUD_STORAGE_BUCKET: z.ZodOptional<z.ZodString>;
     SCREENSHOT_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     SELF_HEAL_TESTS_ENABLED: z.ZodOptional<z.ZodString>;
@@ -129,6 +130,7 @@ export declare const env: Env<{
     AWS_SECRET_ACCESS_KEY?: string | undefined;
     DONOBU_API_KEY?: string | undefined;
     DONOBU_PERSISTENCE_API_KEY?: string | undefined;
+    DONOBU_UPLOADS_OWNED_BY_PARENT?: boolean | undefined;
     GOOGLE_CLOUD_STORAGE_BUCKET?: string | undefined;
     SELF_HEAL_TESTS_ENABLED?: string | undefined;
     PROXY_SERVER?: string | undefined;

package/dist/envVars.js

@@ -200,6 +200,15 @@ Intended for hosts (e.g. the Donobu Studio desktop app) that drive AI
 inference through an explicit gpt-config / flow-runner agent and want
 to enable Donobu Cloud persistence without their persistence credential
 silently overriding the user's flow-runner pick.`),
+    DONOBU_UPLOADS_OWNED_BY_PARENT: v4_1.z.stringbool().optional()
+        .describe(`Internal coordination flag set by the \`donobu test\` CLI on the Playwright
+processes it spawns. When true, cloud persistence runs in producer-only
+mode inside the Playwright workers: artifact bytes are still written to the
+local upload cache, but the background upload-to-cloud worker is NOT started
+there. Instead the long-lived CLI parent owns a single uploader that drains
+the shared cache continuously and flushes it after the run. This keeps the
+ephemeral, force-killable Playwright workers out of the upload critical path
+so worker teardown never blocks on in-flight uploads.`),
     GOOGLE_CLOUD_STORAGE_BUCKET: v4_1.z.string().optional()
         .describe(`Directs Donobu flows to be persisted using this Google Cloud Storage
 bucket.`),

package/dist/esm/cli/donobu-cli.js

@@ -64,6 +64,9 @@ const envVars_1 = require("../envVars");
 const gptClients_1 = require("../lib/test/fixtures/gptClients");
 const donobuTestStack_1 = require("../lib/test/utils/donobuTestStack");
 const triageTestFailure_1 = require("../lib/test/utils/triageTestFailure");
+const fileUploadWorkerRegistry_1 = require("../persistence/files/fileUploadWorkerRegistry");
+const FlowsPersistenceDonobuApi_1 = require("../persistence/flows/FlowsPersistenceDonobuApi");
+const FlowsPersistenceRegistry_1 = require("../persistence/flows/FlowsPersistenceRegistry");
 const merge_1 = require("../reporter/merge");
 const model_1 = require("../reporter/model");
 const render_1 = require("../reporter/render");
@@ -1749,6 +1752,19 @@ function parseHealArgs(args) {
  * 3. Collects failure evidence and generates treatment plans.
  * 4. Optionally runs an auto-heal retry if plans suggest it.
  */
+/**
+ * Idle re-scan interval for the parent-owned upload daemon. The producers are
+ * the Playwright worker processes, so the daemon can't be woken by an
+ * in-process notify() — it polls the shared cache instead.
+ */
+const PARENT_UPLOAD_POLL_INTERVAL_MS = 1_000;
+/**
+ * How long the parent waits for artifact uploads to flush after the Playwright
+ * run finishes. Generous because — unlike the old per-worker drain — this runs
+ * in the long-lived CLI parent, free of Playwright's fixture-teardown timeout,
+ * so it blocks nothing critical and truncates no traces.
+ */
+const PARENT_UPLOAD_DRAIN_TIMEOUT_MS = 60_000;
 async function runTestCommand(cliArgs) {
     const { options, playwrightArgs } = parseTestCommandArgs(cliArgs);
     const playwrightOutputDir = resolvePlaywrightOutputDir(playwrightArgs);
@@ -1793,6 +1809,27 @@ async function runTestCommand(cliArgs) {
     if (effectiveOptions.autoHeal) {
         envOverrides.DONOBU_AUTO_HEAL_ORCHESTRATED = '1';
     }
+    // Own artifact uploads from THIS long-lived parent rather than the ephemeral,
+    // force-killable Playwright workers. When a cloud uploader starts here, flip
+    // the workers to producer-only mode: they cache artifact bytes locally but
+    // run no uploader, so worker teardown can never block on an in-flight upload.
+    // The parent's uploader drains the shared cache continuously during the run
+    // and flushes whatever's left in the finally below.
+    const donobuCloud = (0, FlowsPersistenceRegistry_1.resolveDonobuCloudConfig)(envVars_1.env.pick('DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'PERSISTENCE_PRIORITY'));
+    const parentOwnsUploads = donobuCloud !== null;
+    if (donobuCloud) {
+        // Start just the uploader — no read/write client, since the parent never
+        // reads or writes flows itself.
+        (0, FlowsPersistenceDonobuApi_1.startDonobuParentUploader)(donobuCloud.baseUrl, donobuCloud.apiKey, PARENT_UPLOAD_POLL_INTERVAL_MS);
+        // Set on process.env (not just this run's overrides) so EVERY spawned
+        // Playwright child inherits it — the initial run and the auto-heal rerun
+        // alike — via runPlaywright's `{ ...process.env, ...overrides }`. Our own
+        // parent uploader was already started above, so this late mutation (which
+        // only affects freshly-parsed child envs) doesn't touch it.
+        process.env.DONOBU_UPLOADS_OWNED_BY_PARENT = '1';
+        Logger_1.appLogger.debug(`donobu test: this process owns cloud artifact uploads; Playwright ` +
+            `workers will cache bytes and exit without waiting on uploads.`);
+    }
     const reporterSetup = await ensureJsonReporter(playwrightArgs, {
         playwrightOutputDir,
     });
@@ -1895,6 +1932,27 @@ async function runTestCommand(cliArgs) {
         return exitCode;
     }
     finally {
+        // Flush any artifact uploads this parent owns before returning. main()
+        // calls process.exit() right after runTestCommand resolves, which would
+        // otherwise abandon in-flight uploads. Runs on every return path. Skipped
+        // when no parent uploader was started (local-only runs).
+        if (parentOwnsUploads) {
+            try {
+                const result = await (0, fileUploadWorkerRegistry_1.shutdownFileUploadWorkers)(PARENT_UPLOAD_DRAIN_TIMEOUT_MS);
+                if (result.drained) {
+                    Logger_1.appLogger.debug('donobu test: all artifact uploads flushed.');
+                }
+                else {
+                    Logger_1.appLogger.warn(`donobu test: ${result.totalRemaining} artifact upload(s) did not ` +
+                        `finish within ` +
+                        `${Math.round(PARENT_UPLOAD_DRAIN_TIMEOUT_MS / 1000)}s; they ` +
+                        `remain on disk and resume on the next \`donobu\` run.`);
+                }
+            }
+            catch (error) {
+                Logger_1.appLogger.warn('donobu test: error draining parent uploads.', error);
+            }
+        }
         // Clean up the JSON artifacts Donobu created for its own internal use.
         // Runs after every return path (early-exit when tests pass / auto-heal
         // disabled, and the post-heal path) so we don't leave the state file or

package/dist/esm/envVars.d.ts

@@ -75,6 +75,7 @@ export declare const env: Env<{
     EXPERIMENTAL_FEATURES_ENABLED: z.ZodDefault<z.ZodBoolean>;
     DONOBU_API_KEY: z.ZodOptional<z.ZodString>;
     DONOBU_PERSISTENCE_API_KEY: z.ZodOptional<z.ZodString>;
+    DONOBU_UPLOADS_OWNED_BY_PARENT: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
     GOOGLE_CLOUD_STORAGE_BUCKET: z.ZodOptional<z.ZodString>;
     SCREENSHOT_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     SELF_HEAL_TESTS_ENABLED: z.ZodOptional<z.ZodString>;
@@ -129,6 +130,7 @@ export declare const env: Env<{
     AWS_SECRET_ACCESS_KEY?: string | undefined;
     DONOBU_API_KEY?: string | undefined;
     DONOBU_PERSISTENCE_API_KEY?: string | undefined;
+    DONOBU_UPLOADS_OWNED_BY_PARENT?: boolean | undefined;
     GOOGLE_CLOUD_STORAGE_BUCKET?: string | undefined;
     SELF_HEAL_TESTS_ENABLED?: string | undefined;
     PROXY_SERVER?: string | undefined;

package/dist/esm/envVars.js

@@ -200,6 +200,15 @@ Intended for hosts (e.g. the Donobu Studio desktop app) that drive AI
 inference through an explicit gpt-config / flow-runner agent and want
 to enable Donobu Cloud persistence without their persistence credential
 silently overriding the user's flow-runner pick.`),
+    DONOBU_UPLOADS_OWNED_BY_PARENT: v4_1.z.stringbool().optional()
+        .describe(`Internal coordination flag set by the \`donobu test\` CLI on the Playwright
+processes it spawns. When true, cloud persistence runs in producer-only
+mode inside the Playwright workers: artifact bytes are still written to the
+local upload cache, but the background upload-to-cloud worker is NOT started
+there. Instead the long-lived CLI parent owns a single uploader that drains
+the shared cache continuously and flushes it after the run. This keeps the
+ephemeral, force-killable Playwright workers out of the upload critical path
+so worker teardown never blocks on in-flight uploads.`),
     GOOGLE_CLOUD_STORAGE_BUCKET: v4_1.z.string().optional()
         .describe(`Directs Donobu flows to be persisted using this Google Cloud Storage
 bucket.`),

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

@@ -333,8 +333,11 @@ exports.test = test_1.test.extend({
             }
             let initialActive;
             try {
-                const status = await (0, fileUploadWorkerRegistry_1.getFileUploadAggregateStatus)();
-                initialActive = status.totalPending + status.totalInFlight;
+                // Owned count only: pending + this process's own in-flight claims.
+                // Claims orphaned by other/crashed processes are excluded — this
+                // process can neither upload nor release them, so waiting on them
+                // would wedge worker teardown until the grace timeout force-kills it.
+                initialActive = await (0, fileUploadWorkerRegistry_1.getOwnedActiveUploadCount)();
             }
             catch (err) {
                 Logger_1.appLogger.warn(`donobuFileUploadDrainGuard: failed to read upload status; ` +

package/dist/esm/lib/test/utils/donobuTestStack.js

@@ -20,7 +20,7 @@ function getEnvSnapshot() {
 }
 async function getOrCreateDonobuStack() {
     if (!donobuStack) {
-        donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()), envVars_1.env.pick('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_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_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', 'PERSISTENCE_PRIORITY'));
+        donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()), envVars_1.env.pick('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_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'DONOBU_UPLOADS_OWNED_BY_PARENT', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'));
         return donobuStack;
     }
     else {

package/dist/esm/main.d.ts

@@ -105,6 +105,7 @@ export declare function startDonobuServer({ port, controlPanelHost, environ, }?:
         AWS_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
         DONOBU_API_KEY: z.ZodOptional<z.ZodString>;
         DONOBU_PERSISTENCE_API_KEY: z.ZodOptional<z.ZodString>;
+        DONOBU_UPLOADS_OWNED_BY_PARENT: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
     }, {
         BASE64_GPT_CONFIG?: string | undefined;
         BROWSERBASE_API_KEY?: string | undefined;
@@ -125,6 +126,7 @@ export declare function startDonobuServer({ port, controlPanelHost, environ, }?:
         AWS_SECRET_ACCESS_KEY?: string | undefined;
         DONOBU_API_KEY?: string | undefined;
         DONOBU_PERSISTENCE_API_KEY?: string | undefined;
+        DONOBU_UPLOADS_OWNED_BY_PARENT?: boolean | undefined;
     }> | undefined;
 }): Promise<void>;
 //# sourceMappingURL=main.d.ts.map

package/dist/esm/main.js

@@ -111,7 +111,7 @@ const DEFAULT_PORT = 31000;
  * Starts a Donobu API server at the given port. The server assumes that the
  * Playwright browsers have been installed.
  */
-async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, environ = envVars_1.env.pick('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_DEPLOYMENT_ENVIRONMENT', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_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', 'PERSISTENCE_PRIORITY'), } = {}) {
+async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, environ = envVars_1.env.pick('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_DEPLOYMENT_ENVIRONMENT', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'DONOBU_UPLOADS_OWNED_BY_PARENT', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'), } = {}) {
     try {
         const adminController = await AdminApiController_1.AdminApiController.create(environ.data.DONOBU_DEPLOYMENT_ENVIRONMENT ?? 'LOCAL', controlPanelHost, environ);
         await adminController.start(port);

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

@@ -59,7 +59,7 @@ export declare class AdminApiController {
      * - no checking for flow ownership is performed, as all flows are considered owned by the
      *   local environment.
      */
-    static create(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, 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_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_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' | 'PERSISTENCE_PRIORITY'>): Promise<AdminApiController>;
+    static create(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, 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_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'DONOBU_UPLOADS_OWNED_BY_PARENT' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME' | 'PERSISTENCE_PRIORITY'>): Promise<AdminApiController>;
     private constructor();
     /**
      * Binds the API/web-asset server to `port` and resolves once the socket is

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

@@ -61,6 +61,7 @@ export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDepl
     AWS_SECRET_ACCESS_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     DONOBU_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     DONOBU_PERSISTENCE_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    DONOBU_UPLOADS_OWNED_BY_PARENT: import("zod/v4").ZodOptional<import("zod/v4").ZodCodec<import("zod/v4").ZodString, import("zod/v4").ZodBoolean>>;
 }, {
     BASE64_GPT_CONFIG?: string | undefined;
     BROWSERBASE_API_KEY?: string | undefined;
@@ -80,5 +81,6 @@ export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDepl
     AWS_SECRET_ACCESS_KEY?: string | undefined;
     DONOBU_API_KEY?: string | undefined;
     DONOBU_PERSISTENCE_API_KEY?: string | undefined;
+    DONOBU_UPLOADS_OWNED_BY_PARENT?: boolean | undefined;
 }>): Promise<DonobuStack>;
 //# sourceMappingURL=DonobuStack.d.ts.map

package/dist/esm/managers/DonobuStack.js

@@ -33,7 +33,7 @@ const ToolRegistry_1 = require("./ToolRegistry");
  *       then having this snapshot is relevant so that tests can use normal
  *       environment variables.
  */
-async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('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_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_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', 'PERSISTENCE_PRIORITY')) {
+async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('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_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'DONOBU_UPLOADS_OWNED_BY_PARENT', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY')) {
     const loadedPlugins = await loadDefaultPlugins();
     const resolvedToolRegistry = await (0, ToolRegistry_1.createDefaultToolRegistry)(loadedPlugins.tools);
     const persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry(loadedPlugins.persistencePlugins);

package/dist/esm/managers/PageInspector.js

@@ -933,24 +933,22 @@ class PageInspector {
         if (document.scrollingElement) {
             maybeAddScrollable(document.scrollingElement);
         }
-        // 2) Iterate and assign numbers
-        uniqueElements.forEach((element) => {
-            if (element === document.scrollingElement) {
-                // Special-case: always keep the root scrolling element
-                element.setAttribute(interactableAttribute, offset.toString());
-                offset++;
-                return; // skip the usual checks
-            }
-            else if (element.hasAttribute(interactableAttribute)) {
-                // Skip if this element already carries a value (e.g. assigned via <label>)
-                return;
+        /**
+         * Run the visibility / enabled / top-most checks on a single element and,
+         * if they pass, assign it the next interactable number. Returns `true` if
+         * the element (or, via the <label htmlFor> mapping, its associated control)
+         * was attributed.
+         */
+        function tryAttributeElement(element) {
+            if (element.hasAttribute(interactableAttribute)) {
+                return false;
             }
             const rect = element.getBoundingClientRect();
             const style = window.getComputedStyle(element);
             const visible = isElementVisible(rect, style) && isElementMoreThanHalfInViewport(rect);
             const enabled = isElementEnabled(element, style);
             if (!visible || !enabled) {
-                return;
+                return false;
             }
             // Check a few probe points to make sure the element is top-most
             for (const pt of getPointsToCheck(rect)) {
@@ -959,9 +957,9 @@ class PageInspector {
                     if (elToCheck === element) {
                         element.setAttribute(interactableAttribute, offset.toString());
                         offset++;
-                        return; // this element done
+                        return true; // this element done
                     }
-                    // Handle <label> -> control mapping
+                    // Handle <label> -> control mapping (explicit `for`/`htmlFor`)
                     if (elToCheck.tagName.toLowerCase() === 'label' &&
                         elToCheck.htmlFor) {
                         const forId = elToCheck.htmlFor;
@@ -972,11 +970,41 @@ class PageInspector {
                             control.setAttribute(interactableAttribute, offset.toString());
                             offset++;
                         }
-                        return;
+                        return true;
                     }
                     elToCheck = elToCheck.parentElement;
                 }
             }
+            return false;
+        }
+        // 2) Iterate and assign numbers
+        uniqueElements.forEach((element) => {
+            if (element === document.scrollingElement) {
+                // Special-case: always keep the root scrolling element
+                element.setAttribute(interactableAttribute, offset.toString());
+                offset++;
+                return; // skip the usual checks
+            }
+            else if (element.hasAttribute(interactableAttribute)) {
+                // Skip if this element already carries a value (e.g. assigned via <label>)
+                return;
+            }
+            if (tryAttributeElement(element)) {
+                return;
+            }
+            // Fallback: the element is a visually-hidden native control (e.g. a 0x0,
+            // opacity-0, pointer-events:none <input>) wrapped in a styled <label>.
+            // This is the standard pattern for Ant Design Segmented/Radio/Checkbox/
+            // Switch and many other component libraries: the native input is hidden
+            // and the surrounding <label> is the real clickable surface. Since the
+            // hidden control fails the visibility/enabled checks above, attribute the
+            // wrapping <label> instead so the toggle is still annotated.
+            const wrappingLabel = element.closest('label');
+            if (wrappingLabel &&
+                wrappingLabel !== element &&
+                !wrappingLabel.hasAttribute(interactableAttribute)) {
+                tryAttributeElement(wrappingLabel);
+            }
         });
         return offset;
     }

package/dist/esm/persistence/files/FileUploadCache.d.ts

@@ -94,6 +94,22 @@ export declare class FileUploadCache {
      * active work even though `listPending` excludes it.
      */
     countActive(): Promise<number>;
+    /**
+     * Like {@link countActive}, but scoped to the work THIS worker is
+     * responsible for finishing before its process exits: files still
+     * `.pending` (which this worker will claim and upload) plus this worker's
+     * own `.uploading.<ownToken>` claims.
+     *
+     * Foreign `.uploading.<otherToken>` markers — in-flight claims owned by
+     * OTHER (possibly long-dead) processes — are deliberately EXCLUDED. A live
+     * peer is responsible for finishing its own claims, and claims orphaned by
+     * a crashed peer are recovered by {@link reclaimStaleClaims} on the next
+     * long-lived process. Counting them here is exactly what made an
+     * end-of-worker drain block for the full timeout on a crashed peer's
+     * orphaned claim (which this process can neither upload nor release),
+     * wedging Playwright worker teardown until it was force-killed.
+     */
+    countOwnedActive(ownToken: string): Promise<number>;
     /**
      * Returns a breakdown of marker counts on disk. Used by the admin
      * "uploads status" endpoint so the desktop app can show the user how

package/dist/esm/persistence/files/FileUploadCache.js

@@ -178,6 +178,36 @@ class FileUploadCache {
         const counts = await this.getCounts();
         return counts.pending + counts.inFlight;
     }
+    /**
+     * Like {@link countActive}, but scoped to the work THIS worker is
+     * responsible for finishing before its process exits: files still
+     * `.pending` (which this worker will claim and upload) plus this worker's
+     * own `.uploading.<ownToken>` claims.
+     *
+     * Foreign `.uploading.<otherToken>` markers — in-flight claims owned by
+     * OTHER (possibly long-dead) processes — are deliberately EXCLUDED. A live
+     * peer is responsible for finishing its own claims, and claims orphaned by
+     * a crashed peer are recovered by {@link reclaimStaleClaims} on the next
+     * long-lived process. Counting them here is exactly what made an
+     * end-of-worker drain block for the full timeout on a crashed peer's
+     * orphaned claim (which this process can neither upload nor release),
+     * wedging Playwright worker teardown until it was force-killed.
+     */
+    async countOwnedActive(ownToken) {
+        const ownSuffix = `${UPLOADING_PREFIX}${ownToken}`;
+        let active = 0;
+        const flowDirs = await this.safeReaddir(this.platformDir);
+        for (const encFlow of flowDirs) {
+            const flowDir = path_1.default.join(this.platformDir, encFlow);
+            const names = await this.safeReaddir(flowDir);
+            for (const name of names) {
+                if (name.endsWith(PENDING_SUFFIX) || name.endsWith(ownSuffix)) {
+                    active += 1;
+                }
+            }
+        }
+        return active;
+    }
     /**
      * Returns a breakdown of marker counts on disk. Used by the admin
      * "uploads status" endpoint so the desktop app can show the user how

package/dist/esm/persistence/files/FileUploadWorker.d.ts

@@ -11,6 +11,15 @@ export interface FileUploadWorkerOptions {
     readonly upload: UploadFn;
     readonly platformLabel: string;
     readonly maxAttempts?: number;
+    /**
+     * When set, the idle loop re-scans the cache for new `.pending` files every
+     * `pollIntervalMs` even without a {@link notify} call. Required when the
+     * producer runs in a DIFFERENT process than this worker (the parent-owned
+     * upload daemon draining a cache that Playwright worker processes write to),
+     * because `notify()` is in-process only. Same-process workers leave this
+     * unset and stay purely notify-driven.
+     */
+    readonly pollIntervalMs?: number;
 }
 /**
  * Drains pending file uploads from a {@link FileUploadCache}, uploading each
@@ -26,6 +35,7 @@ export declare class FileUploadWorker {
     private readonly upload;
     private readonly platformLabel;
     private readonly maxAttempts;
+    private readonly pollIntervalMs?;
     private readonly token;
     private workerLoop;
     private staleScanTimer;
@@ -37,6 +47,13 @@ export declare class FileUploadWorker {
     constructor(options: FileUploadWorkerOptions);
     start(): void;
     stop(): Promise<void>;
+    /**
+     * Number of uploads THIS worker still owes before its process can exit:
+     * pending files plus this worker's own in-flight claims, excluding claims
+     * orphaned by other/crashed processes. Mirrors what {@link flush} waits on,
+     * so callers can log an accurate "N still syncing" count at shutdown.
+     */
+    countOwnedActive(): Promise<number>;
     /**
      * Returns a snapshot of the worker's current state for surfacing to the
      * UI (e.g. "N uploads still pending — wait or quit anyway?"). Reads the
@@ -50,10 +67,17 @@ export declare class FileUploadWorker {
      */
     notify(): void;
     /**
-     * Returns once the queue has drained or the timeout has elapsed. Callers
-     * use this on graceful shutdown to push outstanding uploads before exit.
-     * "Drained" means zero files in `.pending` AND zero in `.uploading.*` —
-     * a file mid-retry is still active work.
+     * Returns once THIS worker's queue has drained or the timeout has elapsed.
+     * Callers use this on graceful shutdown to push outstanding uploads before
+     * the process exits.
+     *
+     * "Drained" means zero files this worker still owes: nothing in `.pending`
+     * (which this worker will claim and upload) and none of this worker's own
+     * `.uploading.<token>` claims (a file mid-retry is still active work).
+     * Foreign `.uploading.<otherToken>` claims left by other or crashed
+     * processes are NOT waited on — see {@link FileUploadCache.countOwnedActive}
+     * — because this process can neither upload nor release them; doing so
+     * would block teardown for the full timeout on a dead peer's orphaned claim.
      */
     flush(timeoutMs: number): Promise<{
         drained: boolean;

package/dist/esm/persistence/files/FileUploadWorker.js

@@ -27,6 +27,7 @@ class FileUploadWorker {
         this.upload = options.upload;
         this.platformLabel = options.platformLabel;
         this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        this.pollIntervalMs = options.pollIntervalMs;
         let wakeResolver;
         this.wakePromise = new Promise((resolve) => {
             wakeResolver = resolve;
@@ -75,6 +76,15 @@ class FileUploadWorker {
         await this.workerLoop;
         this.workerLoop = null;
     }
+    /**
+     * Number of uploads THIS worker still owes before its process can exit:
+     * pending files plus this worker's own in-flight claims, excluding claims
+     * orphaned by other/crashed processes. Mirrors what {@link flush} waits on,
+     * so callers can log an accurate "N still syncing" count at shutdown.
+     */
+    async countOwnedActive() {
+        return this.cache.countOwnedActive(this.token);
+    }
     /**
      * Returns a snapshot of the worker's current state for surfacing to the
      * UI (e.g. "N uploads still pending — wait or quit anyway?"). Reads the
@@ -102,21 +112,28 @@ class FileUploadWorker {
         resolve?.();
     }
     /**
-     * Returns once the queue has drained or the timeout has elapsed. Callers
-     * use this on graceful shutdown to push outstanding uploads before exit.
-     * "Drained" means zero files in `.pending` AND zero in `.uploading.*` —
-     * a file mid-retry is still active work.
+     * Returns once THIS worker's queue has drained or the timeout has elapsed.
+     * Callers use this on graceful shutdown to push outstanding uploads before
+     * the process exits.
+     *
+     * "Drained" means zero files this worker still owes: nothing in `.pending`
+     * (which this worker will claim and upload) and none of this worker's own
+     * `.uploading.<token>` claims (a file mid-retry is still active work).
+     * Foreign `.uploading.<otherToken>` claims left by other or crashed
+     * processes are NOT waited on — see {@link FileUploadCache.countOwnedActive}
+     * — because this process can neither upload nor release them; doing so
+     * would block teardown for the full timeout on a dead peer's orphaned claim.
      */
     async flush(timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
-            const active = await this.cache.countActive();
+            const active = await this.cache.countOwnedActive(this.token);
             if (active === 0) {
                 return { drained: true, remaining: 0 };
             }
             await this.sleep(Math.min(200, Math.max(50, deadline - Date.now())));
         }
-        const remaining = await this.cache.countActive();
+        const remaining = await this.cache.countOwnedActive(this.token);
         return { drained: remaining === 0, remaining };
     }
     // ── internals ────────────────────────────────────────────────────
@@ -124,7 +141,14 @@ class FileUploadWorker {
         while (!this.stopping) {
             const pending = await this.cache.listPending();
             if (pending.length === 0) {
-                await Promise.race([this.wakePromise, this.stopSignal]);
+                // Wake on an in-process notify() or on stop. When draining a cache
+                // that OTHER processes write to (the parent-owned daemon), also wake
+                // on a poll timer, since notify() can't cross the process boundary.
+                const idleWaiters = [this.wakePromise, this.stopSignal];
+                if (this.pollIntervalMs !== undefined) {
+                    idleWaiters.push(this.sleep(this.pollIntervalMs));
+                }
+                await Promise.race(idleWaiters);
                 continue;
             }
             for (const entry of pending) {

package/dist/esm/persistence/files/fileUploadWorkerRegistry.d.ts

@@ -30,6 +30,15 @@ export declare function unregisterFileUploadWorker(worker: FileUploadWorker): vo
  * time.
  */
 export declare function getFileUploadAggregateStatus(): Promise<FileUploadAggregateStatus>;
+/**
+ * Total uploads still owed by every registered worker — pending files plus
+ * each worker's own in-flight claims, excluding claims orphaned by other or
+ * crashed processes (which this process can neither upload nor release). This
+ * is what a graceful shutdown actually waits on, so use it (not the global
+ * {@link getFileUploadAggregateStatus}, which counts foreign claims too) when
+ * deciding whether a drain is needed and reporting how much is left.
+ */
+export declare function getOwnedActiveUploadCount(): Promise<number>;
 /**
  * Drains and stops every registered worker. Used during graceful shutdown.
  * Returns a summary across all workers so the caller can log how many