@beryl-so/cli 0.67.0 → 0.77.1

package/dist/commands/accounts.js

@@ -51,9 +51,9 @@ export const testAccountCommands = [
             if (rows.length === 0)
                 return {
                     data: rows,
-                    human: dim("No test accounts. Authenticated tests fall back to the LOGIN_EMAIL variable " +
-                        "and LOGIN_PASSWORD secret. A flow that must sign up fresh cites " +
-                        "{{inbox_address}} and deletes the account in `after`."),
+                    human: dim("No test accounts, so {{login_email}} and {{login_password}} have nothing to " +
+                        "resolve to. Add one with `beryl accounts create`. A flow that must sign up " +
+                        "fresh cites {{inbox_address}} and deletes the account in `after`."),
                 };
             return { data: rows, human: accountTable(rows) };
         },
@@ -81,7 +81,9 @@ export const testAccountCommands = [
             "`--type provisioned` reserves one Beryl will sign up itself, addressed at the project " +
             "mailbox; `--lifetime` says whether it is kept (permanent, the default) or a " +
             "throwaway. It starts `pending` and becomes usable after `beryl accounts signup`. " +
-            "A captured account (a signed-in session from the Chrome plugin) is not created here. " +
+            "A captured account (a signed-in session from the Beryl Chrome extension) is not " +
+            "created here: capture it with the extension, then give it a probe with " +
+            "`beryl accounts set-login --probe`. " +
             "Works for Google-only apps too: bank a dedicated Google test account as provided " +
             "and author its sign-in plan through Google's form. " +
             "The first account an environment gets is its default whatever you pass.",
@@ -148,6 +150,54 @@ export const testAccountCommands = [
             };
         },
     },
+    {
+        name: "accounts capture",
+        summary: "Store a signed-in session as a captured test account",
+        description: "Usually done by the Beryl Chrome extension from a signed-in tab; this takes the " +
+            "same session JSON from a file: {schema_version: 2, final_url, cookies (CDP " +
+            "shape), local_storage, session_storage, indexed_db}. Upserts by --label on the " +
+            "environment, so capturing an existing label replaces its session. Cookies for " +
+            "other domains are dropped and listed. A captured account cannot sign itself in: " +
+            "give it a probe with `beryl accounts set-login --probe`, then prove it with " +
+            "`beryl accounts check`. Its session is never served back to a client.",
+        scope: "project",
+        flags: [
+            {
+                name: "file",
+                type: "string",
+                required: true,
+                description: "The captured session, as JSON (path, or - for stdin)",
+            },
+            {
+                name: "label",
+                type: "string",
+                description: "Identity label a plan's auth_label names (default 'default')",
+            },
+            { name: "email", type: "string", description: "The signed-in user's email" },
+            { name: "env", type: "string", description: "Environment id (default: the project's)" },
+            { name: "default", type: "boolean", description: "Make this the environment's default" },
+        ],
+        examples: ["beryl accounts capture --file session.json --label admin"],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const account = (await ctx.client.put(`${accountsPath(workspaceId, projectId)}/captured`, {
+                session: readJsonFlag(input, "file"),
+                identity_label: flagStr(input, "label") ?? "default",
+                email: flagStr(input, "email") ?? null,
+                environment_id: flagStr(input, "env") ?? null,
+                is_default: flagBool(input, "default"),
+            }));
+            const ignored = account.ignored_cookie_domains.length
+                ? yellow(`\nDropped cookies for other domains: ${account.ignored_cookie_domains.join(", ")}`)
+                : "";
+            return {
+                data: account,
+                human: `${green("Captured")} ${account.identity_label} (${account.id})${ignored}\n` +
+                    dim(`Next: beryl accounts set-login ${account.id} --probe probe.json, then ` +
+                        `beryl accounts check ${account.id}`),
+            };
+        },
+    },
     {
         name: "accounts signup",
         summary: "Store a test account's signup plan and sign it up on its environment",
@@ -201,6 +251,12 @@ export const testAccountCommands = [
             "match on a redirect all pass against a logged-out page, so without a positive " +
             "signal a dead session would run every test logged-out and still report the run " +
             "green.\n\n" +
+            "A captured account (from the Beryl Chrome extension) takes --probe alone: it rides " +
+            "the captured session and cannot sign itself in, so there is no --file.\n\n" +
+            "--surface android stores the sign-in Android tests use instead, beside the web one; " +
+            "Beryl proves it on an Android worker the first time a signed-in android test runs. " +
+            "A test-creation job saves one itself when it meets the app's login screen, so this " +
+            "is for fixing or replacing it.\n\n" +
             "Storing only stores. Run `beryl accounts check` to prove it against the live app.",
         scope: "project",
         args: [
@@ -210,8 +266,8 @@ export const testAccountCommands = [
             {
                 name: "file",
                 type: "string",
-                required: true,
-                description: "The sign-in ActionPlan, as JSON (path, or - for stdin)",
+                description: "The sign-in ActionPlan, as JSON (path, or - for stdin). Required except for a " +
+                    "captured account",
             },
             {
                 name: "probe",
@@ -226,23 +282,37 @@ export const testAccountCommands = [
                 description: "The login_plan_hash from `beryl accounts get-login`. The write is rejected if " +
                     "the stored plan changed since. Omit only when writing the first plan",
             },
+            {
+                name: "surface",
+                type: "string",
+                enum: ["android", "ios"],
+                description: "An app surface: store (or read) the sign-in through the app's own screens. Both " +
+                    "plans are plans for that device (device android or ios, starting with a launch); " +
+                    "a signed-in app test restores the session this sign-in saved on the device",
+            },
         ],
         examples: [
             "beryl accounts set-login acc_123 --file signin.json --probe probe.json",
             "beryl accounts set-login acc_123 --file signin.json --probe probe.json --base-hash 9f2c…",
+            "beryl accounts set-login acc_456 --probe probe.json  # captured account",
+            "beryl accounts set-login acc_123 --surface android --file app-signin.json --probe app-probe.json",
         ],
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
             try {
                 const account = (await ctx.client.put(`${accountsPath(workspaceId, projectId)}/${arg(input, "account-id")}/login`, {
-                    plan: readJsonFlag(input, "file"),
+                    plan: flagStr(input, "file") ? readJsonFlag(input, "file") : null,
                     probe: readJsonFlag(input, "probe"),
                     base_hash: flagStr(input, "base-hash") ?? null,
+                    ...(flagStr(input, "surface") ? { surface: flagStr(input, "surface") } : {}),
                 }));
+                const surface = flagStr(input, "surface");
                 return {
                     data: account,
                     human: `${green("Stored")} — ${account.email}\n` +
-                        dim("Now run `beryl accounts check " + account.id + "` to prove it works."),
+                        dim(surface
+                            ? `Beryl proves it the first time a signed-in ${surface} test runs.`
+                            : "Now run `beryl accounts check " + account.id + "` to prove it works."),
                 };
             }
             catch (err) {
@@ -261,10 +331,22 @@ export const testAccountCommands = [
             "--base-hash on the next `accounts set-login`.",
         scope: "project",
         args: [{ name: "account-id", description: "Account id", required: true }],
+        flags: [
+            {
+                name: "surface",
+                type: "string",
+                enum: ["android", "ios"],
+                description: "An app surface: store (or read) the sign-in through the app's own screens. Both " +
+                    "plans are plans for that device (device android or ios, starting with a launch); " +
+                    "a signed-in app test restores the session this sign-in saved on the device",
+            },
+        ],
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
-            const login = (await ctx.client.get(`${accountsPath(workspaceId, projectId)}/${arg(input, "account-id")}/login`));
-            if (!login.plan)
+            const surface = flagStr(input, "surface");
+            const login = (await ctx.client.get(`${accountsPath(workspaceId, projectId)}/${arg(input, "account-id")}/login` +
+                (surface ? `?surface=${encodeURIComponent(surface)}` : "")));
+            if (!login.plan && !login.probe)
                 return {
                     data: login,
                     human: dim("No login plan stored. Author one by driving the sign-in in a browser, then " +

package/dist/commands/config-vars.js

@@ -1,7 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
-import { UsageError } from "../errors.js";
+import { CliError, UsageError } from "../errors.js";
+import { ApiError } from "../http.js";
+import { dim, green, table, timeAgo } from "../output.js";
 import { arg, flagBool, flagStr, projectPath } from "./util.js";
+const APK_RE = /\.apk$/i;
+const BUILD_KINDS = new Set(["android_build", "ios_build"]);
+const buildLabel = (f) => `${f.app_id ?? "?"} ${f.app_version ?? "?"} (${f.build_number ?? "?"})`;
 const configPath = (ws, p) => `${projectPath(ws, p)}/config`;
 function findByKey(rows, value, kind) {
     const byId = rows.find((r) => r.id === value);
@@ -86,7 +91,7 @@ export const configCommands = [
     },
     {
         name: "config secrets list",
-        summary: "List the project's secrets (values are never returned)",
+        summary: "List the project's secrets (values are never returned); a test account's password is managed on the account, not here",
         scope: "project",
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
@@ -165,11 +170,20 @@ export const configCommands = [
     },
     {
         name: "config files list",
-        summary: "List files uploaded for the agent to use (e.g. CSVs, upload fixtures)",
+        summary: "List uploaded files: fixtures tests attach and Android and iOS app builds",
         scope: "project",
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
-            return { data: await ctx.client.get(`${configPath(workspaceId, projectId)}/files`) };
+            const rows = (await ctx.client.get(`${configPath(workspaceId, projectId)}/files`));
+            const human = table(rows.map((f) => ({
+                name: f.name,
+                kind: f.kind ?? "fixture",
+                app: BUILD_KINDS.has(String(f.kind)) ? buildLabel(f) : "",
+                env: f.environment_id ?? "",
+                created: timeAgo(f.created_at),
+                id: f.id,
+            })));
+            return { data: rows, human };
         },
     },
     {
@@ -195,32 +209,89 @@ export const configCommands = [
     },
     {
         name: "config files upload",
-        summary: "Upload a file",
+        summary: "Upload a file: a fixture an upload step attaches, or an Android or iOS app build",
+        description: "The bytes go straight to storage over a short-lived URL, never through the API, up to " +
+            "1 GB. An .apk uploads as an Android build (or pass --kind android_build): Beryl reads " +
+            "its package name, version and native ABIs, refuses one the emulators cannot run (an " +
+            ".aab, a split APK, a too-new minSdk, ARM-only native code on x86 emulators). An iOS " +
+            "simulator build (the .app folder zipped, or EAS's .tar.gz) uploads with --kind " +
+            "ios_build: Beryl reads its bundle id and version and refuses an .ipa, a device build " +
+            "or one with no arm64 slice. App tests of an environment whose app id for that surface " +
+            "matches install the newest build. Beryl keeps the newest 5 builds per app per " +
+            "environment. Upload after each build, e.g. in CI.",
         scope: "project",
         args: [{ name: "file", description: "Path to the local file", required: true }],
-        flags: [{ name: "env", type: "string", description: "Scope to one environment id" }],
+        flags: [
+            { name: "env", type: "string", description: "Scope to one environment id" },
+            {
+                name: "kind",
+                type: "string",
+                enum: ["fixture", "android_build", "ios_build"],
+                description: "fixture: a file tests attach. android_build: an Android APK (the default for .apk). " +
+                    "ios_build: a zipped or tarred iOS simulator .app",
+            },
+        ],
+        examples: [
+            "beryl config files upload ./fixtures/avatar.png",
+            "beryl config files upload ./android/app/build/outputs/apk/release/app-release.apk",
+            "beryl config files upload ./MyApp.zip --kind ios_build",
+        ],
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
             const file = arg(input, "file");
-            let bytes;
+            const explicitKind = flagStr(input, "kind");
+            const kind = explicitKind ?? (APK_RE.test(file) ? "android_build" : "fixture");
+            const envId = flagStr(input, "env");
+            let blob;
             try {
-                bytes = new Uint8Array(fs.readFileSync(file));
+                if (!fs.statSync(file).isFile())
+                    throw new UsageError(`not a file: ${file}`);
+                blob = await fs.openAsBlob(file);
             }
             catch (err) {
+                if (err instanceof UsageError)
+                    throw err;
                 const code = err.code;
                 if (code === "ENOENT")
                     throw new UsageError(`file not found: ${file}`);
                 throw new UsageError(`cannot read ${file} (${code ?? err.message})`);
             }
-            const form = new FormData();
-            form.set("file", new Blob([bytes]), path.basename(file));
-            const envId = flagStr(input, "env");
-            if (envId)
-                form.set("environment_id", envId);
+            if (blob.size === 0)
+                throw new UsageError(`${file} is empty`);
+            const base = `${configPath(workspaceId, projectId)}/files`;
+            const upload = (await ctx.client.post(`${base}/uploads`, {
+                name: path.basename(file),
+                size: blob.size,
+                kind,
+                ...(envId ? { environment_id: envId } : {}),
+            }));
+            let put;
+            try {
+                put = await fetch(upload.upload_url, {
+                    method: upload.method,
+                    headers: upload.headers,
+                    body: blob,
+                });
+            }
+            catch (err) {
+                throw new CliError(`Upload of ${file} failed: ${err.message}`);
+            }
+            if (!put.ok)
+                throw new CliError(`Upload of ${file} failed: storage answered HTTP ${put.status}`);
+            let done;
+            try {
+                done = (await ctx.client.post(`${base}/uploads/${upload.file_id}/complete`));
+            }
+            catch (err) {
+                if (err instanceof ApiError && err.status === 422 && typeof err.detail === "string")
+                    throw new CliError(`Build refused: ${err.detail}`);
+                throw err;
+            }
             return {
-                data: await ctx.client.request("POST", `${configPath(workspaceId, projectId)}/files`, {
-                    form,
-                }),
+                data: done,
+                human: BUILD_KINDS.has(String(done.kind))
+                    ? `${green("Build uploaded")}: ${buildLabel(done)} ${dim(String(done.id))}`
+                    : `${green("Uploaded")}: ${String(done.name)} ${dim(String(done.id))}`,
             };
         },
     },

package/dist/commands/environments.js

@@ -72,12 +72,17 @@ export const environmentCommands = [
     },
     {
         name: "envs update",
-        summary: "Update an environment's name, URL, auth settings, Site Health screen sizes, schedule, CI and pages, or issue tracker settings",
+        summary: "Update an environment's name, URL, app ids, auth settings, Site Health screen sizes, schedule, CI and pages, or issue tracker settings",
         scope: "project",
         args: [{ name: "env-id", description: "Environment id", required: true }],
         flags: [
             { name: "name", type: "string", description: "New name" },
             { name: "url", type: "string", description: "New root URL" },
+            {
+                name: "app-id",
+                type: "strings",
+                description: 'App id for an app surface, as surface=id (android=com.acme.app, ios=com.acme.App), repeatable: that surface\'s tests install the newest uploaded build of it; "ios=" clears it',
+            },
             { name: "auth", type: "string", enum: ["public", "gated"], description: "New auth choice" },
             {
                 name: "viewport",
@@ -91,6 +96,7 @@ export const environmentCommands = [
         ],
         examples: [
             "beryl envs update <env-id> --tracker linear --tracker-team <team-id>",
+            "beryl envs update <env-id> --app-id android=com.acme.app --app-id ios=com.acme.App",
             "beryl envs update <env-id> --tracker-threshold medium --tracker-max-tickets 5",
             "beryl envs update <env-id> --tracker-priority high=urgent --tracker-pause on",
             "beryl envs update <env-id> --health-schedule daily --health-time 06:00 --health-timezone Europe/Berlin",
@@ -104,6 +110,17 @@ export const environmentCommands = [
                 body.name = flagStr(input, "name");
             if (flagStr(input, "url"))
                 body.root_url = flagStr(input, "url");
+            const appIds = flagStrings(input, "app-id");
+            if (appIds) {
+                const parsed = {};
+                for (const pair of appIds) {
+                    const [surface, ...rest] = pair.split("=");
+                    if (!surface || rest.length === 0)
+                        throw new UsageError(`--app-id must be surface=id (android=com.acme.app), got ${pair}`);
+                    parsed[surface] = rest.join("=");
+                }
+                body.app_ids = parsed;
+            }
             if (flagStr(input, "auth"))
                 body.requires_auth_choice = flagStr(input, "auth");
             const viewports = flagStrings(input, "viewport");

package/dist/commands/init.js

@@ -6,31 +6,22 @@ import { BERYL_COPILOT_MARK_BEGIN, BERYL_COPILOT_MARK_END, BERYL_COPILOT_SECTION
 import { loadConfig } from "../config.js";
 import { AuthError, CliError, UsageError } from "../errors.js";
 import { ApiClient } from "../http.js";
-import { bold, cyan, dim, green, red, yellow } from "../output.js";
-import { anyGap, describeGaps, installCommandsFor, installPlaywright, playwrightGaps, } from "../playwright-install.js";
+import { bold, cyan, dim, green, yellow } from "../output.js";
 import { aliasMachineToAccount, captureCliEvent, flushTelemetry, shutdownTelemetry, } from "../telemetry.js";
 import { cliVersion, warnIfStale } from "../version-check.js";
 import { authCommands } from "./auth.js";
 import { flagStr } from "./util.js";
-// Pinned to @latest (like the Playwright entry below) — an unpinned spec lets npx
-// serve whatever stale global/cache install already resolves, so the agent's MCP
-// server would silently miss newer tools. mergeMcpConfig compares entries verbatim,
-// so re-running init also upgrades an old unpinned entry in place.
+// Pinned to @latest: an unpinned spec lets npx serve whatever stale global/cache
+// install already resolves, so the agent's MCP server would silently miss newer tools.
+// mergeMcpConfig compares entries verbatim, so re-running init also upgrades an old
+// unpinned entry in place.
 const MCP_SERVER_ENTRY = {
     command: "npx",
     args: ["-y", "@beryl-so/cli@latest", "mcp"],
 };
-// Headless: the coding agent drives this browser to author tests — nobody watches the
-// window, and a headed default breaks on CI / headless boxes. Matches how most devs
-// already wire their own user-scoped playwright.
-const PLAYWRIGHT_SERVER_ENTRY = {
-    command: "npx",
-    args: ["@playwright/mcp@latest", "--headless"],
-};
 // VS Code's `.vscode/mcp.json` uses a top-level `servers` key and tags each stdio server
-// with `type`, unlike Cursor/Claude's `mcpServers`. Same pinned commands, different shape.
+// with `type`, unlike Cursor/Claude's `mcpServers`. Same pinned command, different shape.
 const VSCODE_MCP_SERVER_ENTRY = { type: "stdio", ...MCP_SERVER_ENTRY };
-const VSCODE_PLAYWRIGHT_SERVER_ENTRY = { type: "stdio", ...PLAYWRIGHT_SERVER_ENTRY };
 // opencode flattens command + args into one array under `mcp`.
 function opencodeEntry(entry) {
     return { type: "local", command: [entry.command, ...entry.args], enabled: true };
@@ -45,14 +36,14 @@ function snippetEntry(name, entry) {
 const MANUAL_CONFIG_SNIPPET = [
     "    {",
     '      "mcpServers": {',
-    `${snippetEntry("beryl", MCP_SERVER_ENTRY)},`,
-    snippetEntry("playwright", PLAYWRIGHT_SERVER_ENTRY),
+    snippetEntry("beryl", MCP_SERVER_ENTRY),
     "      }",
     "    }",
 ].join("\n");
 // `key` is the container the editor expects: `mcpServers` for Claude/Cursor, `servers` for
-// VS Code, `mcp` for opencode. `entries` are the editor-shaped server objects.
-function mergeMcpConfig(file, key, entries) {
+// VS Code, `mcp` for opencode. Only the beryl entry is ours; every other server (including
+// a user-wired playwright) is left untouched.
+function mergeMcpConfig(file, key, entry) {
     let existing = {};
     if (fs.existsSync(file)) {
         try {
@@ -63,19 +54,14 @@ function mergeMcpConfig(file, key, entries) {
         }
     }
     const servers = (existing[key] ?? {});
-    const beryl = JSON.stringify(servers.beryl) !== JSON.stringify(entries.beryl);
-    if (beryl)
-        servers.beryl = entries.beryl;
-    // Never clobber a playwright server the user already wired up.
-    const playwright = servers.playwright === undefined;
-    if (playwright)
-        servers.playwright = entries.playwright;
-    if (beryl || playwright) {
+    const beryl = JSON.stringify(servers.beryl) !== JSON.stringify(entry);
+    if (beryl) {
+        servers.beryl = entry;
         existing[key] = servers;
         fs.mkdirSync(path.dirname(file), { recursive: true });
         fs.writeFileSync(file, JSON.stringify(existing, null, 2) + "\n");
     }
-    return { beryl, playwright };
+    return { beryl };
 }
 function claudeUserAdd(name, entry) {
     try {
@@ -194,7 +180,7 @@ const outcomeLabel = (o) => o === "installed"
         ? "updated (refreshed to this CLI's version)"
         : "already current";
 const skillLeaf = (root) => path.join(root, BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME);
-// The authoring skill follows the `--scope` flag, same as the MCP servers: under `user`
+// The beryl-test skill follows the `--scope` flag, same as the MCP servers: under `user`
 // (the default) it lands in the HOME `.agents/skills/` + `.claude/skills/` dirs, so the
 // knowledge travels with the user into every session the user-scoped MCP tools do —
 // otherwise an agent outside this repo has all the tools and none of the guide. Under
@@ -230,33 +216,6 @@ export function refreshInstalledSkills(cwd) {
     }
     return refreshed;
 }
-// Local authoring drives a real browser, and the whole authoring workflow (walk the flow
-// first, then bank the plan) depends on it — so the install is mandatory, not offered:
-// missing means install now, no prompt, no opt-out. The runner ships with the CLI; the
-// browser is the per-machine half, fetched for the runner's own revision. Never throws — a
-// failed install must not fail `init`, which has already done its wiring; it prints the
-// exact commands instead.
-async function ensureLocalPlaywright(ctx, cwd) {
-    const gaps = playwrightGaps(cwd);
-    if (!anyGap(gaps)) {
-        ctx.err(`${green("✓")} Playwright + Chromium already installed ${dim("(local runs ready)")}`);
-        return;
-    }
-    try {
-        await installPlaywright(cwd, (line) => ctx.err(dim(line)));
-        // Believe the check, not the exit code — "local runs ready" is only honest if both
-        // halves are actually there afterwards.
-        const left = playwrightGaps(cwd);
-        if (anyGap(left))
-            throw new Error(`${describeGaps(left)} still missing afterwards`);
-        ctx.err(`${green("✓")} ${describeGaps(gaps)} installed ${dim("(local runs ready)")}`);
-    }
-    catch (err) {
-        ctx.err(`${red("✗")} Playwright install failed: ${err.message}`);
-        ctx.err(`${dim("•")} Finish the install by hand — local runs and browser authoring need it:\n` +
-            `    ${cyan(installCommandsFor(gaps, cwd))}`);
-    }
-}
 const CLIENTS = [
     ["claude", "Claude Code + Claude desktop app"],
     ["cursor", "Cursor"],
@@ -291,8 +250,8 @@ export const initCommands = [
     {
         name: "init",
         summary: "Set up Beryl in this repo: sign in and wire up your coding agent",
-        description: "Signs you in, wires the beryl and playwright MCP servers into the coding agent you " +
-            "pick, writes the beryl-test authoring skill, and installs Chromium if it is missing. " +
+        description: "Signs you in, wires the beryl MCP server into the coding agent you pick, and writes " +
+            "the beryl-test skill. " +
             "Pick an agent with --claude, --cursor, --vscode and/or --opencode. With no flag it " +
             "prompts (Enter picks Claude); with no flag and no TTY it wires nothing and prints the " +
             "flags. --claude also wires the Claude DESKTOP app when installed, which needs a quit " +
@@ -395,51 +354,35 @@ export const initCommands = [
             if (clients.has("claude") && scope === "user") {
                 // Claude Code owns ~/.claude.json — shell out to `claude mcp add` rather than write it.
                 const beryl = claudeUserAdd("beryl", MCP_SERVER_ENTRY);
-                const playwright = claudeUserAdd("playwright", PLAYWRIGHT_SERVER_ENTRY);
-                if (beryl.ok && playwright.ok) {
-                    ctx.err(`${green("✓")} beryl + playwright MCP configured ${dim("(user scope)")}`);
+                if (beryl.ok) {
+                    ctx.err(`${green("✓")} beryl MCP configured ${dim("(user scope)")}`);
                 }
                 else {
-                    const failure = [beryl, playwright].find((r) => !r.ok && r.reason === "failed");
-                    ctx.err(yellow(failure
-                        ? `• \`claude mcp add\` failed (${failure.detail}); run these to wire user-scope MCP servers:`
-                        : "• `claude` not on PATH; run these to wire user-scope MCP servers:"));
+                    ctx.err(yellow(beryl.reason === "failed"
+                        ? `• \`claude mcp add\` failed (${beryl.detail}); run this to wire the user-scope MCP server:`
+                        : "• `claude` not on PATH; run this to wire the user-scope MCP server:"));
                     ctx.err(`    ${cyan(claudeAddHint("beryl", MCP_SERVER_ENTRY))}`);
-                    ctx.err(`    ${cyan(claudeAddHint("playwright", PLAYWRIGHT_SERVER_ENTRY))}`);
                 }
             }
             else if (clients.has("claude")) {
                 const file = path.join(cwd, ".mcp.json");
-                const wrote = mergeMcpConfig(file, "mcpServers", {
-                    beryl: MCP_SERVER_ENTRY,
-                    playwright: PLAYWRIGHT_SERVER_ENTRY,
-                });
-                const where = path.relative(cwd, file);
-                report("beryl MCP", wrote.beryl, where);
-                report("playwright MCP", wrote.playwright, where);
+                const wrote = mergeMcpConfig(file, "mcpServers", MCP_SERVER_ENTRY);
+                report("beryl MCP", wrote.beryl, path.relative(cwd, file));
             }
             // Separate surface from Claude Code, read only at launch.
             const desktopFile = clients.has("claude") && scope === "user" ? claudeDesktopConfigFile() : null;
             if (desktopFile) {
-                const wrote = mergeMcpConfig(desktopFile, "mcpServers", {
-                    beryl: MCP_SERVER_ENTRY,
-                    playwright: PLAYWRIGHT_SERVER_ENTRY,
-                });
+                const wrote = mergeMcpConfig(desktopFile, "mcpServers", MCP_SERVER_ENTRY);
                 report("Claude desktop beryl MCP", wrote.beryl, "(Claude desktop app)");
-                report("Claude desktop playwright MCP", wrote.playwright, "(Claude desktop app)");
-                if (wrote.beryl || wrote.playwright) {
+                if (wrote.beryl) {
                     ctx.err(yellow("• Quit and reopen Claude desktop: it reads that config at launch."));
                 }
             }
             if (clients.has("cursor")) {
                 const file = scope === "user" ? cursorUserConfigPath() : path.join(cwd, ".cursor", "mcp.json");
-                const wrote = mergeMcpConfig(file, "mcpServers", {
-                    beryl: MCP_SERVER_ENTRY,
-                    playwright: PLAYWRIGHT_SERVER_ENTRY,
-                });
+                const wrote = mergeMcpConfig(file, "mcpServers", MCP_SERVER_ENTRY);
                 const where = scope === "user" ? file : path.relative(cwd, file);
                 report("cursor beryl MCP", wrote.beryl, where);
-                report("cursor playwright MCP", wrote.playwright, where);
                 const rule = writeCursorRule(cwd);
                 ctx.err(`${green("✓")} cursor authoring rule ${outcomeLabel(rule.outcome)} ${dim(path.relative(cwd, rule.file))}`);
                 if (scope === "user") {
@@ -456,13 +399,9 @@ export const initCommands = [
                 const file = userDir
                     ? path.join(userDir, "mcp.json")
                     : path.join(cwd, ".vscode", "mcp.json");
-                const wrote = mergeMcpConfig(file, "servers", {
-                    beryl: VSCODE_MCP_SERVER_ENTRY,
-                    playwright: VSCODE_PLAYWRIGHT_SERVER_ENTRY,
-                });
+                const wrote = mergeMcpConfig(file, "servers", VSCODE_MCP_SERVER_ENTRY);
                 const where = userDir ? file : path.relative(cwd, file);
                 report("vscode beryl MCP", wrote.beryl, where);
-                report("vscode playwright MCP", wrote.playwright, where);
                 if (scope === "user" && !userDir) {
                     ctx.err(dim("  • VS Code's user config dir was not found, so this went to a repo-local " +
                         ".vscode/mcp.json. Run --vscode from your project, or add the server via " +
@@ -480,19 +419,14 @@ export const initCommands = [
                 const { file, jsonc } = opencodeConfigFile(scope, cwd);
                 if (jsonc) {
                     ctx.err(yellow(`• ${file} is JSONC and may hold comments, so it was left alone.`));
-                    ctx.err(cyan(`    Add these under "mcp": ${JSON.stringify({
+                    ctx.err(cyan(`    Add this under "mcp": ${JSON.stringify({
                         beryl: opencodeEntry(MCP_SERVER_ENTRY),
-                        playwright: opencodeEntry(PLAYWRIGHT_SERVER_ENTRY),
                     })}`));
                 }
                 else {
-                    const wrote = mergeMcpConfig(file, "mcp", {
-                        beryl: opencodeEntry(MCP_SERVER_ENTRY),
-                        playwright: opencodeEntry(PLAYWRIGHT_SERVER_ENTRY),
-                    });
+                    const wrote = mergeMcpConfig(file, "mcp", opencodeEntry(MCP_SERVER_ENTRY));
                     const where = scope === "user" ? file : path.relative(cwd, file);
                     report("opencode beryl MCP", wrote.beryl, where);
-                    report("opencode playwright MCP", wrote.playwright, where);
                 }
             }
             const skills = writeSkills(cwd, scope);
@@ -507,9 +441,8 @@ export const initCommands = [
                 const where = skill.outcome === "updated"
                     ? `${skillWhere} (refreshed to this CLI's version)`
                     : skillWhere;
-                ctx.err(`${green("✓")} Beryl authoring skill ${what} ${dim(where)}`);
+                ctx.err(`${green("✓")} beryl-test skill ${what} ${dim(where)}`);
             }
-            await ensureLocalPlaywright(ctx, cwd);
             // Name the agent actually wired, not the raw flag: the picker sets `clients` too.
             const ed = clients.has("claude")
                 ? { open: "open your editor", agent: "Claude" }
@@ -519,7 +452,7 @@ export const initCommands = [
                         ? { open: "open VS Code", agent: "Copilot" }
                         : { open: "open opencode", agent: "opencode" };
             const nextSteps = clients.size === 0
-                ? `\n${bold("Beryl is signed in and the authoring skill is installed.")}\n` +
+                ? `\n${bold("Beryl is signed in and the beryl-test skill is installed.")}\n` +
                     `  ${dim("• No MCP server is wired yet, so no agent can reach Beryl.")}\n` +
                     `  ${dim(`• Using ${CLIENT_LABEL_LIST}? Re-run and pick it:`)}\n` +
                     `    ${cyan("npx @beryl-so/cli@latest init")}\n` +
@@ -527,10 +460,10 @@ export const initCommands = [
                     `${cyan(MANUAL_CONFIG_SNIPPET)}\n` +
                     `    ${dim("Some clients name that key `servers` or `mcp`.")}\n` +
                     `    ${yellow(`Details: ${MANUAL_SETUP_DOCS}`)}\n`
-                : `\n${bold(`Beryl is set up. Now ${ed.open} and ask ${ed.agent} to write tests.`)}\n` +
-                    `  ${dim(`• Say: "write tests for https://example.com" and ${ed.agent} picks your workspace/project`)}\n` +
-                    `  ${dim("  and sets the URL for you (no pin, no prompt).")}\n` +
-                    `  ${dim(`• Playwright MCP is wired, so ${ed.agent} can drive a real browser to author from your plan.`)}\n`;
+                : `\n${bold(`Beryl is set up. Now ${ed.open} and ask ${ed.agent} to create tests.`)}\n` +
+                    `  ${dim(`• Say: "create tests for https://example.com from docs/checkout.md" and ${ed.agent} starts`)}\n` +
+                    `  ${dim("  a cloud test-creation job (jobs create) that authors them from that document.")}\n` +
+                    `  ${dim(`• Then ask ${ed.agent} to run them in Beryl's cloud (runs trigger).`)}\n`;
             // The .mcp.json entry is pinned to @latest, but a global install / old npx cache
             // still wins resolution — so tell the user when the CLI they just ran is stale.
             await warnIfStale(cliVersion(), (msg) => ctx.err(yellow(msg)));
@@ -549,11 +482,12 @@ export const initCommands = [
     },
     {
         name: "guide",
-        summary: "Print the Beryl test-authoring guide",
-        description: "The full guide to authoring durable, healable tests: the ActionPlan shape, outcome " +
-            "assertions, natural-language intent, test accounts and the project mailbox " +
-            "({{login_email}}, {{mailbox_address}}, {{inbox_address}} + await_email), and the " +
-            "local run-fix loop. Same content as the beryl-test skill `beryl init` installs. " +
+        summary: "Print the Beryl test guide",
+        description: "The guide to durable, healable tests: where new tests come from (`jobs create`), the " +
+            "ActionPlan shape, outcome assertions, natural-language intent, test accounts and the " +
+            "project mailbox ({{login_email}}, {{mailbox_address}}, {{inbox_address}} + " +
+            "await_email), and the run-fix loop. Same content as the beryl-test skill " +
+            "`beryl init` installs. " +
             `Skip if a loaded beryl-test skill states v${cliVersion()}; else call this first ` +
             "(works without logging in).",
         examples: ["beryl guide"],