@bugmole/cli 0.5.0 → 0.6.0

package/src/runtime/cloud-secrets.test.ts

@@ -0,0 +1,201 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import worker from "../registry-worker/index.js";
+import { call, createContext, createTestEnv, seedProject, seedVerifiedDomain } from "../registry-worker/testing/harness.js";
+import { runnerLauncher, type LaunchRequest } from "../registry-worker/runner/dispatch.js";
+import { ControlPlaneClient } from "../registry/control-plane-client.js";
+import { createObjectStore } from "../storage/create-object-store.js";
+import { json } from "../storage/object-store.js";
+import { interpolateTemplate } from "./flow-language.js";
+import { forgetSecretValues, redactBody, redactSecrets, registerSecretValue, REDACTED } from "./secret-redaction.js";
+import { injectFlowSecrets, missingSecretsMessage, signInWithFlow } from "./cloud-secrets.js";
+import { runOnce } from "./run-once.js";
+
+const KEY = Buffer.alloc(32, 3).toString("base64");
+
+test("remembered secret values are redacted from text, JSON, URLs and text uploads", () => {
+  forgetSecretValues();
+  try {
+    assert.equal(redactSecrets("nothing to hide"), "nothing to hide");
+    registerSecretValue("p@ss\"word/1");
+    registerSecretValue("abc");
+    assert.equal(redactSecrets("typed p@ss\"word/1 into the field"), `typed ${REDACTED} into the field`);
+    assert.equal(redactSecrets(JSON.stringify({ error: "value p@ss\"word/1" })), JSON.stringify({ error: `value ${REDACTED}` }));
+    assert.equal(redactSecrets(`https://x.test/?p=${encodeURIComponent("p@ss\"word/1")}`), `https://x.test/?p=${REDACTED}`);
+    assert.equal(redactSecrets("abc stays: too short to be a real secret"), "abc stays: too short to be a real secret");
+    assert.ok(!json({ message: "p@ss\"word/1" }).includes("word/1"), "manifests and results");
+    const log = redactBody(new TextEncoder().encode("line p@ss\"word/1"), "text/plain; charset=utf-8");
+    assert.equal(new TextDecoder().decode(log as Uint8Array), `line ${REDACTED}`);
+    const png = new TextEncoder().encode("p@ss\"word/1");
+    assert.equal(redactBody(png, "image/png"), png, "binary evidence is left alone");
+  } finally {
+    forgetSecretValues();
+  }
+});
+
+test("a secret a flow types is redacted from uploads and registry updates from then on", async () => {
+  forgetSecretValues();
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "bugmole-redact-"));
+  const originalFetch = globalThis.fetch;
+  const sent: string[] = [];
+  try {
+    assert.equal(interpolateTemplate("{{secret.APP_PASSWORD}}", {}, { allowSecrets: true, env: { BUGMOLE_FLOW_SECRET_APP_PASSWORD: "typed-secret-1" } }), "typed-secret-1");
+    const store = createObjectStore({ provider: "local", localDirectory: directory });
+    await store.put("projects/p/runs/r/playwright.log", "ERROR: typed-secret-1 rejected", "text/plain");
+    assert.equal(await store.getText("projects/p/runs/r/playwright.log"), `ERROR: ${REDACTED} rejected`);
+
+    globalThis.fetch = (async (_url: RequestInfo | URL, init?: RequestInit) => {
+      sent.push(String(init?.body));
+      return Response.json({ updated: true });
+    }) as typeof fetch;
+    await new ControlPlaneClient({ registryUrl: "https://r.test", apiKey: "k", projectId: "p" })
+      .updateRun("run_1", { status: "error", errorMessage: "Login failed for typed-secret-1" });
+    assert.ok(!sent[0].includes("typed-secret-1") && sent[0].includes(REDACTED));
+  } finally {
+    globalThis.fetch = originalFetch;
+    forgetSecretValues();
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("secrets live in the environment only while the job runs", () => {
+  const env: Record<string, string | undefined> = { BUGMOLE_FLOW_SECRET_KEEP: "mine" };
+  const remove = injectFlowSecrets({ APP_PASSWORD: "cloud-value", KEEP: "cloud-keep" }, env);
+  assert.equal(env.BUGMOLE_FLOW_SECRET_APP_PASSWORD, "cloud-value");
+  assert.equal(redactSecrets("cloud-value"), REDACTED);
+  remove();
+  assert.deepEqual(env, { BUGMOLE_FLOW_SECRET_KEEP: "mine" });
+  assert.equal(redactSecrets("cloud-value"), "cloud-value");
+});
+
+test("a sign-in flow that uses a secret the project doesn't have fails naming it", async () => {
+  const flow = "url: https://shop.test\n---\n- launchApp\n- inputText: \"{{secret.APP_EMAIL}}\"\n- inputText: \"{{secret.APP_PASSWORD}}\"\n";
+  const released = { secrets: { APP_EMAIL: "qa@shop.test" }, unreadable: [], available: true };
+  assert.match(missingSecretsMessage(flow, released)!, /no secret named APP_PASSWORD is set/);
+  assert.equal(missingSecretsMessage(flow, { ...released, secrets: { APP_EMAIL: "a", APP_PASSWORD: "b" } }), null);
+  assert.match(missingSecretsMessage(flow, { secrets: {}, unreadable: [], available: false })!, /turned off/);
+  assert.match(missingSecretsMessage(flow, { ...released, unreadable: ["APP_PASSWORD"] })!, /APP_PASSWORD couldn't be decrypted/);
+  let ran = false;
+  await assert.rejects(signInWithFlow({
+    flow, baseUrl: "https://shop.test", workdir: os.tmpdir(), projectId: "shop", jobId: "t", released,
+    driver: { run: async () => { ran = true; return { status: "passed", message: "", artifacts: [] }; } },
+  }), /APP_PASSWORD/);
+  assert.equal(ran, false, "no browser opens for a flow that can't finish");
+});
+
+/** Sends every fetch to the in-process registry. */
+function registryFetch(env: ReturnType<typeof createTestEnv>["env"]): typeof fetch {
+  return (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const { ctx, flush } = createContext();
+    const reply = await worker.fetch(new Request(input, init), env, ctx);
+    await flush();
+    return reply;
+  }) as typeof fetch;
+}
+
+function withEnv<T>(values: Record<string, string>, body: () => Promise<T>): Promise<T> {
+  const saved = Object.fromEntries(Object.keys(values).map((key) => [key, process.env[key]]));
+  Object.assign(process.env, values);
+  return body().finally(() => {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  });
+}
+
+async function queuedExploration(signInFlow: string, secrets: Record<string, string>) {
+  const setup = createTestEnv({ RUNNER_TOKEN_SECRET: "s", FEATURE_CLOUD_RUNNERS: "on", PROJECT_SECRETS_KEY: KEY });
+  const { env, db } = setup;
+  const project = await seedProject(env, { storageProvider: "bugmole" });
+  seedVerifiedDomain(db, project.workspaceId, "shop.test");
+  for (const [name, value] of Object.entries(secrets)) {
+    assert.equal((await call(env, "PUT", `/api/projects/${project.projectId}/secrets/${name}`, { as: project.owner, body: { value } })).status, 201);
+  }
+  assert.equal((await call(env, "PUT", `/api/projects/${project.projectId}/sign-in-flow`, { as: project.owner, body: { content: signInFlow } })).status, 200);
+  const launches: LaunchRequest[] = [];
+  const original = runnerLauncher.start;
+  runnerLauncher.start = async (_env, launch) => {
+    launches.push(launch);
+  };
+  try {
+    const created = await call(env, "POST", `/api/projects/${project.projectId}/tasks`, {
+      as: project.owner, body: { title: "Explore https://shop.test", description: "Explore https://shop.test/", taskType: "discovery", idempotencyKey: "d", executionMode: "cloud" },
+    });
+    assert.equal(created.status, 201);
+  } finally {
+    runnerLauncher.start = original;
+  }
+  const launch = launches.find((item) => item.kind === "task")!;
+  const runnerEnv = { BUGMOLE_REGISTRY_URL: launch.registryUrl, BUGMOLE_TASK_ID: launch.id, BUGMOLE_RUN_TOKEN: launch.token };
+  const taskOf = async () => {
+    const tasks = await call(env, "GET", `/api/projects/${project.projectId}/tasks`, { as: project.owner });
+    return tasks.json.tasks.find((item: { id: string }) => item.id === launch.id);
+  };
+  return { ...setup, ...project, launch, runnerEnv, taskOf };
+}
+
+const FLOW = "url: https://shop.test/login\n---\n- launchApp\n- inputText: \"{{secret.APP_EMAIL}}\"\n- inputText: \"{{secret.APP_PASSWORD}}\"\n";
+
+test("cloud exploration signs in with the project's flow and secrets, then explores signed in", async () => {
+  const { env, runnerEnv, taskOf } = await queuedExploration(FLOW, { APP_EMAIL: "qa@shop.test", APP_PASSWORD: "hunter2-cloud" });
+  const seen: { flow?: string; typed?: string; storageState?: string } = {};
+  const signIn = (async (options: Parameters<typeof signInWithFlow>[0]) => {
+    seen.flow = options.flow;
+    // What the flow would type, read the way the driver reads it.
+    seen.typed = interpolateTemplate("{{secret.APP_PASSWORD}}", {}, { allowSecrets: true });
+    return path.join(options.workdir, "session.json");
+  }) as typeof signInWithFlow;
+  const discover = (async (url: string, options: { storageState?: string; onEvent?: (event: unknown, snapshot: unknown) => Promise<void> }) => {
+    seen.storageState = options.storageState;
+    const result = {
+      baseUrl: url,
+      // A page that echoes what was typed must not carry it anywhere.
+      events: [{ at: new Date().toISOString(), kind: "page", text: "Found Account for hunter2-cloud" }],
+      pages: [{ route: "/account", title: "Account", path: [], links: [], forms: [] }],
+      flows: [],
+    };
+    await options.onEvent?.(result.events[0], result);
+    return result;
+  }) as never;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = registryFetch(env);
+  try {
+    const code = await withEnv(runnerEnv, () => runOnce(process.env, { discover, signIn, log: () => undefined }));
+    assert.equal(code, 0);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+  assert.equal(seen.flow, FLOW);
+  assert.equal(seen.typed, "hunter2-cloud", "the secret is in the flow's environment during the job");
+  assert.match(String(seen.storageState), /session\.json$/, "exploration starts from the signed-in session");
+  assert.equal(process.env.BUGMOLE_FLOW_SECRET_APP_PASSWORD, undefined, "and gone afterwards");
+  const task = await taskOf();
+  assert.equal(task.status, "completed", JSON.stringify(task));
+  const text = JSON.stringify(task);
+  assert.ok(!text.includes("hunter2-cloud"), "no secret in the task's progress");
+  assert.ok(text.includes("Signed in"), text);
+});
+
+test("cloud exploration stops with a clear message when the sign-in flow needs a secret that isn't set", async () => {
+  const { env, runnerEnv, taskOf } = await queuedExploration(FLOW, { APP_EMAIL: "qa@shop.test" });
+  let explored = false;
+  const discover = (async () => {
+    explored = true;
+    throw new Error("should not explore");
+  }) as never;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = registryFetch(env);
+  try {
+    await withEnv(runnerEnv, () => runOnce(process.env, { discover, log: () => undefined }));
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+  assert.equal(explored, false);
+  const task = await taskOf();
+  assert.equal(task.status, "error");
+  assert.match(JSON.stringify(task), /no secret named APP_PASSWORD is set for this project/);
+});

package/src/runtime/cloud-secrets.ts

@@ -0,0 +1,210 @@
+// Sign-in for cloud runs, on the runner's side. A Bugmole Cloud container
+// fetches its project's secrets for the one run or exploration it holds,
+// puts them in its own environment as BUGMOLE_FLOW_SECRET_<NAME> for as long
+// as the job lasts, and redacts them from everything it reports. Cloud
+// exploration also runs the project's sign-in flow first, so it explores
+// what is behind the sign-in page.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FLOW_SECRET_ENV_PREFIX, referencedSecretNames } from "./flow-language.js";
+import { forgetSecretValues, redactSecrets, registerSecretValue } from "./secret-redaction.js";
+import type { DriverContext, DriverResult } from "./driver.js";
+import { describeReference, parseSecretReference, resolveSecret, type SecretDeps, type SecretReference } from "./secret-sources.js";
+import { awsWebIdentityCredentials, googleFederatedToken, type IdentityTokenSource } from "./vault-federation.js";
+
+export type ReleasedSecrets = {
+  secrets: Record<string, string>;
+  unreadable: string[];
+  available: boolean;
+  /** Secrets whose value is a reference into the project's own vault that couldn't be read, and why. */
+  vaultErrors?: Record<string, string>;
+};
+
+/** Project settings for reading the project's own vault: never typed by a flow. */
+export const VAULT_CREDENTIAL = /^VAULT_/;
+
+/** Stored cloud keys Bugmole no longer accepts: a cloud trusts Bugmole's identity token instead. */
+const STORED_KEYS = ["VAULT_AWS_ACCESS_KEY_ID", "VAULT_AWS_SECRET_ACCESS_KEY", "VAULT_AWS_SESSION_TOKEN", "VAULT_GCP_SERVICE_ACCOUNT_KEY"];
+
+/**
+ * Bring your own vault on Bugmole Cloud: a project secret's value may be a
+ * reference into Google Secret Manager (gcpsm://…) or AWS Secrets Manager
+ * (awssm://…) instead of the value itself. Nobody stores a key for it: the
+ * runner signs in to the project's cloud with a short-lived Bugmole identity
+ * token the cloud was set up to trust (vault-federation.ts), using the
+ * project's settings VAULT_GCP_WORKLOAD_PROVIDER (+ VAULT_GCP_SERVICE_ACCOUNT)
+ * and VAULT_AWS_ROLE_ARN. Local, keychain and env references only exist on a
+ * person's own machine.
+ */
+export async function resolveVaultReferences(
+  released: ReleasedSecrets,
+  deps: SecretDeps & { identityToken?: IdentityTokenSource; sessionName?: string } = {},
+): Promise<ReleasedSecrets> {
+  const settings: Record<string, string> = {};
+  const secrets: Record<string, string> = {};
+  for (const [name, value] of Object.entries(released.secrets)) {
+    if (VAULT_CREDENTIAL.test(name)) settings[name] = value;
+    else secrets[name] = value;
+  }
+  const vaultErrors: Record<string, string> = { ...(released.vaultErrors ?? {}) };
+  const references: Array<[string, Extract<SecretReference, { kind: "aws" | "gcp" }>]> = [];
+  for (const [name, value] of Object.entries(secrets)) {
+    const reference = parseSecretReference(value);
+    if (!reference) continue;
+    delete secrets[name];
+    if (reference.kind !== "aws" && reference.kind !== "gcp") {
+      vaultErrors[name] = `${describeReference(reference)} can only be read on your own machine; on Bugmole Cloud use the value, or a gcpsm:// or awssm:// reference`;
+      continue;
+    }
+    references.push([name, reference]);
+  }
+  const storedKeys = STORED_KEYS.filter((name) => settings[name]);
+  // One sign-in per cloud, shared by every secret it holds, and only if one is used.
+  const sessions = new Map<"gcp" | "aws", Promise<SecretDeps>>();
+  const session = (kind: "gcp" | "aws"): Promise<SecretDeps> => {
+    if (!sessions.has(kind)) {
+      sessions.set(kind, (async (): Promise<SecretDeps> => {
+        if (!deps.identityToken) throw new Error("This runner can't get an identity token for your cloud");
+        if (kind === "gcp") {
+          const provider = settings.VAULT_GCP_WORKLOAD_PROVIDER;
+          if (!provider) {
+            throw new Error(`Set VAULT_GCP_WORKLOAD_PROVIDER to your Workload Identity provider so Bugmole Cloud can read Google Secret Manager${storedKeys.length ? " (a stored service account key isn't used)" : ""}`);
+          }
+          const token = await googleFederatedToken({ provider, serviceAccount: settings.VAULT_GCP_SERVICE_ACCOUNT || undefined, identityToken: deps.identityToken, fetch: deps.fetch });
+          registerSecretValue(token);
+          return { ...deps, env: { GOOGLE_OAUTH_ACCESS_TOKEN: token }, allowCli: false };
+        }
+        const roleArn = settings.VAULT_AWS_ROLE_ARN;
+        if (!roleArn) {
+          throw new Error(`Set VAULT_AWS_ROLE_ARN to the IAM role Bugmole Cloud may assume to read AWS Secrets Manager${storedKeys.length ? " (stored access keys aren't used)" : ""}`);
+        }
+        const credentials = await awsWebIdentityCredentials({ roleArn, sessionName: deps.sessionName ?? "bugmole", identityToken: deps.identityToken, fetch: deps.fetch });
+        for (const value of Object.values(credentials)) registerSecretValue(value);
+        return {
+          ...deps,
+          env: { CLOUD_AWS_ACCESS_KEY_ID: credentials.accessKeyId, CLOUD_AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey, CLOUD_AWS_SESSION_TOKEN: credentials.sessionToken },
+          awsPrefixes: ["CLOUD_AWS_"],
+          allowCli: false,
+        };
+      })());
+    }
+    return sessions.get(kind)!;
+  };
+  for (const [name, reference] of references) {
+    try {
+      secrets[name] = await resolveSecret(reference, await session(reference.kind));
+    } catch (error) {
+      vaultErrors[name] = redactSecrets(error instanceof Error ? error.message : String(error));
+    }
+  }
+  for (const value of Object.values(settings)) registerSecretValue(value);
+  return { ...released, secrets, ...(Object.keys(vaultErrors).length ? { vaultErrors } : {}) };
+}
+
+/**
+ * Asks the registry for the job's secrets. A registry with project secrets
+ * turned off (503) releases none; any other refusal is an error.
+ */
+export async function fetchRunnerSecrets(
+  doFetch: typeof fetch,
+  registryUrl: string,
+  token: string,
+  job: { kind: "run" | "task"; id: string },
+): Promise<ReleasedSecrets> {
+  const reply = await doFetch(`${registryUrl}/api/runner/${job.kind}s/${encodeURIComponent(job.id)}/secrets`, {
+    headers: { authorization: `Bearer ${token}` },
+  });
+  if (reply.status === 503) return { secrets: {}, unreadable: [], available: false };
+  if (!reply.ok) throw new Error(`The registry refused this ${job.kind}'s secrets (${reply.status})`);
+  const body = await reply.json() as { secrets?: Record<string, unknown>; unreadable?: unknown };
+  const secrets: Record<string, string> = {};
+  for (const [name, value] of Object.entries(body.secrets ?? {})) {
+    if (typeof value === "string") secrets[name] = value;
+  }
+  const unreadable = Array.isArray(body.unreadable) ? body.unreadable.filter((name): name is string => typeof name === "string") : [];
+  return { secrets, unreadable, available: true };
+}
+
+/**
+ * Puts the secrets in the process environment and remembers them for
+ * redaction. The returned function takes them out again.
+ */
+export function injectFlowSecrets(secrets: Record<string, string>, env: Record<string, string | undefined> = process.env): () => void {
+  const saved = new Map<string, string | undefined>();
+  for (const [name, value] of Object.entries(secrets)) {
+    const variable = `${FLOW_SECRET_ENV_PREFIX}${name}`;
+    saved.set(variable, env[variable]);
+    env[variable] = value;
+    registerSecretValue(value);
+  }
+  return () => {
+    for (const [variable, previous] of saved) {
+      if (previous === undefined) delete env[variable];
+      else env[variable] = previous;
+    }
+    forgetSecretValues();
+  };
+}
+
+/** A clear message for a sign-in flow that uses a secret the project doesn't have. */
+export function missingSecretsMessage(flow: string, released: ReleasedSecrets): string | null {
+  const names = referencedSecretNames(flow);
+  if (names.length && !released.available) {
+    return `The sign-in flow uses ${names.map((name) => `{{secret.${name}}}`).join(", ")}, but project secrets are turned off on this Bugmole registry.`;
+  }
+  const fromVault = names.filter((name) => released.vaultErrors?.[name] && !(name in released.secrets));
+  if (fromVault.length) {
+    return fromVault.map((name) => `${name} couldn't be read from your vault: ${released.vaultErrors![name]}`).join(" ");
+  }
+  const unreadable = names.filter((name) => released.unreadable.includes(name) && !(name in released.secrets));
+  if (unreadable.length) {
+    return `The secret${unreadable.length === 1 ? "" : "s"} ${unreadable.join(", ")} couldn't be decrypted. Set ${unreadable.length === 1 ? "it" : "them"} again under Settings → Sign-in for cloud runs.`;
+  }
+  const missing = names.filter((name) => !(name in released.secrets));
+  if (!missing.length) return null;
+  const list = missing.join(", ");
+  return `The sign-in flow uses ${missing.map((name) => `{{secret.${name}}}`).join(", ")}, but no secret named ${list} is set for this project`
+    + " (or its run's environment). Add it under Settings → Sign-in for cloud runs.";
+}
+
+type FlowRunner = { run(context: DriverContext): Promise<DriverResult> };
+
+/**
+ * Runs the project's sign-in flow in a fresh browser and returns the saved
+ * session (cookies and local storage) for exploration to start from. Its
+ * evidence stays in the container's working directory, which is deleted with
+ * the job: nothing of the sign-in is uploaded.
+ */
+export async function signInWithFlow(options: {
+  flow: string;
+  baseUrl: string;
+  workdir: string;
+  projectId: string;
+  jobId: string;
+  released: ReleasedSecrets;
+  driver?: FlowRunner;
+  timeoutMs?: number;
+}): Promise<string> {
+  const problem = missingSecretsMessage(options.flow, options.released);
+  if (problem) throw new Error(problem);
+  const directory = path.join(options.workdir, "sign-in");
+  await fs.mkdir(directory, { recursive: true });
+  const flowPath = path.join(directory, "sign-in.yaml");
+  await fs.writeFile(flowPath, options.flow, "utf8");
+  const sessionStatePath = path.join(directory, "session-state.json");
+  const driver = options.driver ?? new (await import("./playwright-driver.js")).PlaywrightDriver({ headless: true });
+  const result = await driver.run({
+    runId: `sign-in-${options.jobId}`,
+    projectId: options.projectId,
+    journeyId: "sign-in",
+    flowPath,
+    platform: "web",
+    target: { baseUrl: options.baseUrl },
+    rebaseOrigin: true,
+    timeoutMs: options.timeoutMs ?? 60_000,
+    artifactsDir: path.join(directory, "artifacts"),
+    sessionStatePath,
+  });
+  if (result.status !== "passed") throw new Error(`The sign-in flow did not pass: ${redactSecrets(result.message)}`);
+  return sessionStatePath;
+}

package/src/runtime/config-validate.ts

@@ -80,8 +80,10 @@ export function validateConfig(cfg: Config): ValidationResult {
   const env = classifyEnvironment(cfg.runtime.env);
 
   // Required fields
-  if (!cfg.runtime?.env) {
-    errors.push("runtime.env is required");
+  // A missing env is treated as STAGING, the safest default, rather than
+  // refusing to start: `bugmole init` doesn't ask for one.
+  if (!cfg.runtime?.env && !(cfg.runtime as { environment?: string } | undefined)?.environment) {
+    warnings.push("runtime.env is not set; treating this environment as staging");
   }
   if (!cfg.runtime?.artifacts_dir) {
     errors.push("runtime.artifacts_dir is required");
@@ -89,11 +91,11 @@ export function validateConfig(cfg: Config): ValidationResult {
   if (!cfg.runtime?.spec_dir) {
     errors.push("runtime.spec_dir is required");
   }
-  if (!cfg.llm?.provider) {
-    errors.push("llm.provider is required");
-  }
-  if (!cfg.llm?.api_key) {
-    errors.push("llm.api_key is required (set LLM_API_KEY in .env)");
+  // Your own model key is optional: without one, steps that need AI use
+  // Bugmole AI (with a Bugmole API key) or say what's missing when they run.
+  const provider = cfg.llm?.provider;
+  if (provider && provider !== "manual" && provider !== "cursor" && !cfg.llm?.api_key) {
+    warnings.push(`llm.provider is "${provider}" but llm.api_key is empty; set LLM_API_KEY in .bugmole.env to use your own model`);
   }
   const driver = cfg.execution?.driver || "maestro";
   if (!["maestro", "playwright", "simulation"].includes(driver)) {
@@ -118,10 +120,11 @@ export function validateConfig(cfg: Config): ValidationResult {
     storageProvider && typeof cfg.storage?.[storageProvider] === "object"
       ? (cfg.storage[storageProvider] as { bucket?: string; account_id?: string })
       : undefined;
-  if (storageProvider && !["local", "gcs", "s3", "r2"].includes(storageProvider)) {
+  if (storageProvider && !["local", "gcs", "s3", "r2", "bugmole"].includes(storageProvider)) {
     errors.push(`storage.provider "${storageProvider}" is unsupported`);
   }
-  if (storageProvider && storageProvider !== "local" && !storageDetails?.bucket) {
+  // Bugmole storage needs no bucket of yours: it goes through your Bugmole account.
+  if (storageProvider && storageProvider !== "local" && storageProvider !== "bugmole" && !storageDetails?.bucket) {
     errors.push(`storage.${storageProvider}.bucket is required`);
   }
   if (storageProvider === "r2" && !storageDetails?.account_id && !process.env.R2_ACCOUNT_ID) {

package/src/runtime/cursor-driver-run.ts

@@ -18,7 +18,7 @@ import {
 import { injectPrompt, isCursorRunning, openCursorInDirectory } from "./cursor-applescript.js";
 import { waitForCommitResponse } from "./cursor-mcp-monitor.js";
 import { runCursorCliDriver, type CursorCliDriverOptions } from "./cursor-cli-driver.js";
-import { ControlPlaneClient, isClaimableTask, type RegistryTask } from "../registry/control-plane-client.js";
+import { ControlPlaneClient, RegistryRequestError, isClaimableTask, workerApprovalMode, type RegistryTask } from "../registry/control-plane-client.js";
 
 /**
  * Main CURSOR_DRIVER function - acts as an LLM API adapter
@@ -219,7 +219,7 @@ export async function runNextAgentTask(
   });
   const available = await client.listTasks();
   // Discovery tasks are run by the worker's own browser, not a coding agent.
-  const next = available.tasks.find((task) => task.taskType !== "discovery" && isClaimableTask(task));
+  const next = available.tasks.find((task) => task.taskType !== "discovery" && isClaimableTask(task, Date.now(), workerApprovalMode()));
   if (!next) return { task: null, message: "No queued agent task is available." };
   // Losing a claim is a normal race, not a failure: another worker got
   // there first, or the task changed state between listing and claiming.
@@ -240,6 +240,10 @@ export async function runNextAgentTask(
     "",
     next.description,
     "",
+    // A person sent this back from review: their note is what to fix.
+    next.reviewNote && next.status === "queued"
+      ? `A reviewer sent this task back after your last attempt. Address their note before completing again:\n${next.reviewNote}\n`
+      : "",
     "Read bugmole://guidance/agent-task-queue before acting.",
     "Report progress as you work and use bugmole_task_update for the final status.",
     next.taskType === "ui"
@@ -273,6 +277,12 @@ export async function runNextAgentTask(
       status: "blocked",
       errorMessage: response.error ?? "Cursor task execution failed",
       progressMessage: "Cursor execution stopped; task can be continued.",
+    }).catch((error) => {
+      // The agent finished and the task went into review before the CLI
+      // exited (a timeout after the final update): the registry keeps the
+      // reviewed work rather than marking it blocked.
+      if (error instanceof RegistryRequestError && error.status === 409) return undefined;
+      throw error;
     });
     return { task: claimed.task, response };
   }
@@ -284,7 +294,8 @@ export async function runNextAgentTask(
   // status (with its parity evidence and summary) always wins.
   const after = await client.listTasks().catch(() => null);
   const current = after?.tasks.find((task) => task.id === next.id);
-  if (current && current.status !== "completed" && current.status !== "error") {
+  // A task in review was closed by the agent and now waits for a person.
+  if (current && current.status !== "completed" && current.status !== "error" && current.status !== "in_review") {
     await client.updateTask(next.id, {
       workerId: options.workerId,
       status: "completed",

package/src/runtime/discovery-task.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { discoveryPersona, discoveryUrl, discoveryUsesAi, withPersonaMarker } from "./discovery-task.js";
+import { discoveryPersona, discoveryUrl, discoveryUsesAi, runDiscoveryTask, withPersonaMarker } from "./discovery-task.js";
 
 test("discoveryUsesAi and discoveryUrl read the title and description a task was queued with", () => {
   assert.equal(discoveryUsesAi({ title: "Explore with AI shop.test" }), true);
@@ -27,3 +27,28 @@ test("no persona marker, or one that doesn't decode to a persona, means no perso
   const garbage = Buffer.from("not json", "utf8").toString("base64");
   assert.equal(discoveryPersona({ description: `<!-- persona:${garbage} -->` }), null);
 });
+
+test("exploration that stops at a sign-in wall suggests guest and member roles", async () => {
+  const proposed: Array<{ name: string; source: string; evidence?: string }> = [];
+  const updates: Array<Record<string, unknown>> = [];
+  const client = {
+    claimTask: async () => ({}),
+    updateTask: async (_id: string, body: Record<string, unknown>) => { updates.push(body); return {}; },
+    publishPlan: async () => ({}),
+    proposeRole: async (input: { name: string; source: string; evidence?: string }) => {
+      proposed.push(input);
+      return { role: { name: input.name, status: "suggested" }, alreadyDecided: false };
+    },
+  };
+  const task = { id: "t1", projectId: "p", title: "Explore", description: "Explore https://app.example.com/", taskType: "discovery", priority: 1, status: "queued" };
+  const wall = {
+    baseUrl: "https://app.example.com/",
+    pages: [{ url: "https://app.example.com/login", route: "/login", title: "Sign in", heading: "Sign in", forms: [{ fields: [{ type: "password" }] }], links: [], controls: [] }],
+    flows: [],
+    events: [],
+  };
+  await runDiscoveryTask({ project: { id: "p" }, runtime: { spec_dir: "/nonexistent" } }, client as never, task as never, "w", (async () => wall) as never, { claimed: true });
+  assert.deepEqual(proposed.map((role) => [role.name, role.source]), [["guest", "sign_in_wall"], ["member", "sign_in_wall"]]);
+  assert.match(proposed[0].evidence ?? "", /reached only a sign-in page/);
+  assert.ok(updates.some((body) => /Suggested the roles guest and member/.test(String(body.progressMessage))));
+});