@beryl-so/cli 0.47.0 → 0.50.0

package/dist/beryl-test-skill.js

@@ -13,6 +13,40 @@ const indent = (text) => text
     .join("\n");
 export const BERYL_TEST_SKILL_FILENAME = "SKILL.md";
 export const BERYL_TEST_SKILL_DIR = "beryl-test";
+// The prose both editor pointers share. Cursor and Copilot read neither `.agents/skills/`
+// nor `.claude/skills/`, so `init` writes them their own pointer instead. Thin on purpose:
+// it sends the agent to the `guide` MCP tool rather than inlining the 500-line skill, and
+// `guide` ships with the CLI so the real guidance never drifts from the installed version.
+const BERYL_GUIDE_POINTER = `When writing, editing, or debugging Beryl tests in this repo, call the \`guide\`
+MCP tool first. It returns the full authoring guide: the ActionPlan shape, outcome
+assertions, test accounts and the project mailbox, and the local run-fix loop.
+
+Then use the Beryl MCP tools: \`projects_list\` to find the project, and \`tests_create\`
+to author a plan and replay it locally before it is banked.
+
+The \`guide\` tool ships with the CLI and always matches the installed version, so treat
+it as the source of truth over anything cached here.`;
+// Cursor reads its own `.cursor/rules/*.mdc`, auto-loaded when alwaysApply is set.
+export const BERYL_CURSOR_RULE_FILENAME = "beryl.mdc";
+export const BERYL_CURSOR_RULE = `---
+description: Authoring and editing Beryl end-to-end tests
+alwaysApply: true
+---
+
+# Beryl test authoring
+
+${BERYL_GUIDE_POINTER}
+`;
+// GitHub Copilot reads `.github/copilot-instructions.md`, a file the repo may already own,
+// so our content lives in a marked section that `init` appends once and refreshes in place.
+// The markers must stay byte-stable across releases or the refresh can't find the block.
+export const BERYL_COPILOT_MARK_BEGIN = "<!-- BEGIN beryl (managed by beryl init) -->";
+export const BERYL_COPILOT_MARK_END = "<!-- END beryl -->";
+export const BERYL_COPILOT_SECTION = `${BERYL_COPILOT_MARK_BEGIN}
+## Beryl test authoring
+
+${BERYL_GUIDE_POINTER}
+${BERYL_COPILOT_MARK_END}`;
 // The example plan the skill shows verbatim. Exported so the test suite lints it with
 // lintPlan — the skill's documented shape must pass `beryl tests lint` on the first try.
 export const BERYL_TEST_SKILL_EXAMPLE_PLAN = {
@@ -147,19 +181,35 @@ The trade is drift — run 200 has 200 of everything run 1 created. So:
 - **Assert relatively, never absolutely.** "The row I just created is present"
   (\`expect.persisted\` on a \`{{unique}}\`-named row), not "there are 3 rows" — a count
   assertion goes stale by itself.
-- **Own the resource lifecycle, both directions.** Creating? Delete it in \`after\`
-  (runs on pass AND fail, unlike a trailing step inside \`steps\`). Deleting? Create
-  your own victim first — in \`before\` or the opening steps, \`{{unique}}\`-named —
-  then delete it and assert \`gone\`. Never aim a delete at standing data: run 2 would
-  have nothing to delete, and it eats the account's accumulated coverage.
-- **Every test is \`read\` or \`write\`.** \`read\` (the default) only looks. A test
-  that creates, saves, deletes, renames, invites, toggles or uploads anything is
-  \`write\`: bank it with \`--access write\`, and end its \`after\` with an \`expect\`
-  that proves the undo: \`gone\`, \`hidden\`, \`have_count\` or \`count_delta\` for a
-  removal, \`have_text\`, \`have_value\` or \`persisted\` for a restored value.
-  Create refuses a plan that writes without the label and a \`write\` plan
-  without that closing proof; a \`write\` test whose teardown found nothing to remove
-  fails the run. Flip a banked test with \`beryl tests set-access <id> write\`.
+- **Cleanup lives in \`after\`, and it returns the account to the exact state you found
+  it.** \`after\` runs on pass AND fail; a trailing step inside \`steps\` does not, so
+  never put cleanup in \`steps\`.
+  - **Created something?** Delete it in \`after\`.
+  - **Deleting something?** Create your own victim first (in \`before\` or the opening
+    steps, \`{{unique}}\`-named), then delete it and prove \`gone\`; when the deleted thing
+    must persist, re-create it in \`after\` as it was. Never aim a delete at standing data:
+    run 2 has nothing to delete, and it eats the account's accumulated coverage.
+  - **Changed a value (rename, toggle)?** Restore it in \`after\`: set it back to what it
+    was. Capture the original BEFORE you change it with \`capture_text\` (or \`capture_value\`
+    for a form input), banking it under \`capture_as\`, then \`fill {{handle}}\` in \`after\`
+    to put it back.
+- **You label each test \`read\` or \`write\`; Beryl takes your word for it.** Set it with
+  \`--access\` (default \`read\`). Beryl does NOT infer it from your selectors, so YOU
+  decide, by one test: **would the app be different after this test runs?**
+  - **\`write\`** = it leaves a change behind: it creates, edits, deletes, renames, moves,
+    uploads or toggles a record or setting that is still different once the test ends. A
+    \`write\` must undo itself: end \`after\` with an \`expect\` proving the undo: \`gone\`,
+    \`hidden\`, \`have_count\` or \`count_delta\` for a removal, \`have_text\`,
+    \`have_value\` or \`persisted\` for a restore.
+  - **\`read\`** = it only observes: navigating, searching, filtering, sorting, opening a
+    menu or dialog and reading it, or clicking a destructive button and then CANCELLING.
+    Nothing is committed. Opening a confirm dialog and cancelling is a \`read\`; a submit
+    that stays disabled is a \`read\`.
+  A flow that both changes and reads is a \`write\`. Only the \`write\` label is checked
+  (its closing teardown proof, and a \`write\` whose teardown removes nothing fails the
+  run); \`read\` is taken at your word, so a real write you mislabel \`read\` silently
+  drifts the account. Label deliberately, and flip a banked test with
+  \`beryl tests set-access <id> read|write\`.
 
 ### If there is no account yet
 

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { BERYL_TEST_SKILL, BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME, } from "../beryl-test-skill.js";
+import { BERYL_COPILOT_MARK_BEGIN, BERYL_COPILOT_MARK_END, BERYL_COPILOT_SECTION, BERYL_CURSOR_RULE, BERYL_CURSOR_RULE_FILENAME, BERYL_TEST_SKILL, BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME, } from "../beryl-test-skill.js";
 import { loadConfig } from "../config.js";
 import { AuthError, CliError } from "../errors.js";
 import { ApiClient } from "../http.js";
@@ -27,8 +27,14 @@ 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.
+const VSCODE_MCP_SERVER_ENTRY = { type: "stdio", ...MCP_SERVER_ENTRY };
+const VSCODE_PLAYWRIGHT_SERVER_ENTRY = { type: "stdio", ...PLAYWRIGHT_SERVER_ENTRY };
 const ACTION_PLAN_SCHEMA_URL = "https://api.beryl.so/api/v1/schemas/action-plan.schema.json";
-function mergeMcpConfig(file) {
+// `key` is the container the editor expects: `mcpServers` for Claude/Cursor, `servers` for
+// VS Code. `entries` are the editor-shaped server objects (VS Code tags them with `type`).
+function mergeMcpConfig(file, key, entries) {
     let existing = {};
     if (fs.existsSync(file)) {
         try {
@@ -38,16 +44,16 @@ function mergeMcpConfig(file) {
             throw new CliError(`${file} exists but is not valid JSON (${err.message})`);
         }
     }
-    const servers = (existing.mcpServers ?? {});
-    const beryl = JSON.stringify(servers.beryl) !== JSON.stringify(MCP_SERVER_ENTRY);
+    const servers = (existing[key] ?? {});
+    const beryl = JSON.stringify(servers.beryl) !== JSON.stringify(entries.beryl);
     if (beryl)
-        servers.beryl = MCP_SERVER_ENTRY;
+        servers.beryl = entries.beryl;
     // Never clobber a playwright server the user already wired up.
     const playwright = servers.playwright === undefined;
     if (playwright)
-        servers.playwright = PLAYWRIGHT_SERVER_ENTRY;
+        servers.playwright = entries.playwright;
     if (beryl || playwright) {
-        existing.mcpServers = servers;
+        existing[key] = servers;
         fs.mkdirSync(path.dirname(file), { recursive: true });
         fs.writeFileSync(file, JSON.stringify(existing, null, 2) + "\n");
     }
@@ -83,25 +89,54 @@ function claudeAddHint(name, entry) {
 function cursorUserConfigPath() {
     return path.join(os.homedir(), ".cursor", "mcp.json");
 }
-// Write the skill to one `.../beryl-test/SKILL.md` file. The skill is generated content
-// that ships with the CLI and changes every release, so anything that differs is
-// overwritten: a stale copy silently feeds agents months-old guidance, which is worse than
-// losing a local edit the user can redo (and `beryl guide` still prints the same content).
-function writeSkillFile(file) {
+// Write generated content that ships with the CLI and changes every release, so anything
+// that differs is overwritten: a stale copy silently feeds agents months-old guidance,
+// which is worse than losing a local edit the user can redo (and `beryl guide` still prints
+// the same content). CRLF is normalized so a CRLF copy of our own content counts as current
+// and isn't rewritten on every run; we always write LF.
+function writeGeneratedFile(file, content) {
     let outcome = "installed";
     if (fs.existsSync(file)) {
-        // Compare with line endings normalized so a CRLF copy of our own content counts as
-        // current and isn't rewritten on every run — we always write LF.
         const norm = (s) => s.replace(/\r\n/g, "\n");
-        const current = fs.readFileSync(file, "utf8");
-        if (norm(current) === norm(BERYL_TEST_SKILL))
+        if (norm(fs.readFileSync(file, "utf8")) === norm(content))
             return { outcome: "unchanged", file };
         outcome = "updated";
     }
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, BERYL_TEST_SKILL);
+    fs.writeFileSync(file, content);
     return { outcome, file };
 }
+const writeSkillFile = (file) => writeGeneratedFile(file, BERYL_TEST_SKILL);
+// Cursor's equivalent of the skill: a repo-local `.cursor/rules/beryl.mdc`. Always repo-local
+// even at `--scope user`, because Cursor has no global rules FILE (User Rules live in its
+// settings UI), so there is nowhere else to put it.
+const writeCursorRule = (cwd) => writeGeneratedFile(path.join(cwd, ".cursor", "rules", BERYL_CURSOR_RULE_FILENAME), BERYL_CURSOR_RULE);
+const copilotInstructionsPath = (cwd) => path.join(cwd, ".github", "copilot-instructions.md");
+// Copilot's `.github/copilot-instructions.md` may already hold the repo's own instructions,
+// so we own only a marked section: refresh it in place when present, append it once when the
+// file exists without it, create the file when it doesn't. Never rewrites the user's prose.
+function writeCopilotInstructions(cwd) {
+    const file = copilotInstructionsPath(cwd);
+    const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    const begin = current.indexOf(BERYL_COPILOT_MARK_BEGIN);
+    if (begin !== -1) {
+        const endAt = current.indexOf(BERYL_COPILOT_MARK_END, begin);
+        const endFull = endAt === -1 ? current.length : endAt + BERYL_COPILOT_MARK_END.length;
+        if (current.slice(begin, endFull) === BERYL_COPILOT_SECTION)
+            return { outcome: "unchanged", file };
+        fs.writeFileSync(file, current.slice(0, begin) + BERYL_COPILOT_SECTION + current.slice(endFull));
+        return { outcome: "updated", file };
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const body = current ? current.replace(/\n*$/, "\n\n") + BERYL_COPILOT_SECTION + "\n" : BERYL_COPILOT_SECTION + "\n";
+    fs.writeFileSync(file, body);
+    return { outcome: "installed", file };
+}
+const outcomeLabel = (o) => o === "installed"
+    ? "installed"
+    : o === "updated"
+        ? "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 default) it lands in the HOME `.agents/skills/` + `.claude/skills/` dirs, so the
@@ -126,7 +161,18 @@ export function refreshInstalledSkills(cwd) {
         skillLeaf(path.join(root, ".agents", "skills")),
         skillLeaf(path.join(root, ".claude", "skills")),
     ]));
-    return [...files].filter((file) => fs.existsSync(file)).map(writeSkillFile);
+    const refreshed = [...files].filter((file) => fs.existsSync(file)).map(writeSkillFile);
+    // The Cursor rule and Copilot section are repo-local pointers; refresh them the same way so
+    // a reworded pointer reaches those editors on the next MCP spawn, matching the skill. Both
+    // are refreshed only when already installed, and the Copilot writer touches only its block.
+    const cursorRule = path.join(cwd, ".cursor", "rules", BERYL_CURSOR_RULE_FILENAME);
+    if (fs.existsSync(cursorRule))
+        refreshed.push(writeGeneratedFile(cursorRule, BERYL_CURSOR_RULE));
+    const copilot = copilotInstructionsPath(cwd);
+    if (fs.existsSync(copilot) && fs.readFileSync(copilot, "utf8").includes(BERYL_COPILOT_MARK_BEGIN)) {
+        refreshed.push(writeCopilotInstructions(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:
@@ -169,7 +215,11 @@ export const initCommands = [
             "locally), since browser authoring and local runs depend on it. By default the " +
             "servers are wired per-user (matching where your login token lives) via `claude mcp add " +
             "-s user`; pass --scope project to write a committed .mcp.json for a shared repo " +
-            "instead. No workspace/project pin and no URL prompt: ask Claude to write tests for " +
+            "instead. With --cursor the same two servers are also wired into Cursor and a repo-local " +
+            ".cursor/rules/beryl.mdc authoring rule is written (Cursor's equivalent of the skill, " +
+            "since it reads neither skills dir); --vscode does the same for VS Code / GitHub Copilot " +
+            "(.vscode/mcp.json plus a marked section in .github/copilot-instructions.md). No " +
+            "workspace/project pin and no URL prompt: ask Claude to write tests for " +
             "your site and it resolves the workspace, project, and URL. Safe to re-run: every run " +
             "refreshes the authoring skill to this CLI's version (overwriting an older or edited " +
             "copy; `beryl guide` prints the same content), and skips whatever else is already set " +
@@ -188,13 +238,21 @@ export const initCommands = [
             {
                 name: "cursor",
                 type: "boolean",
-                description: "Also write the same two MCP servers to Cursor's config",
+                description: "Also wire the same two MCP servers into Cursor's config and write a repo-local " +
+                    ".cursor/rules/beryl.mdc authoring rule (Cursor's equivalent of the skill)",
+            },
+            {
+                name: "vscode",
+                type: "boolean",
+                description: "Also wire the two MCP servers into .vscode/mcp.json and add a Beryl section to " +
+                    ".github/copilot-instructions.md for GitHub Copilot (both repo-local)",
             },
         ],
         examples: [
             "npx @beryl-so/cli@latest init",
             "beryl init --scope project",
             "beryl init --cursor",
+            "beryl init --vscode",
         ],
         async run(ctx, input) {
             const cwd = process.cwd();
@@ -256,17 +314,43 @@ export const initCommands = [
             }
             else {
                 const file = path.join(cwd, ".mcp.json");
-                const wrote = mergeMcpConfig(file);
+                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);
             }
             if (input.flags.cursor) {
                 const file = scope === "user" ? cursorUserConfigPath() : path.join(cwd, ".cursor", "mcp.json");
-                const wrote = mergeMcpConfig(file);
+                const wrote = mergeMcpConfig(file, "mcpServers", {
+                    beryl: MCP_SERVER_ENTRY,
+                    playwright: PLAYWRIGHT_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") {
+                    ctx.err(dim("  • The rule is repo-local (Cursor has no global rules file); commit it to share it."));
+                }
+            }
+            // VS Code (Copilot) is always repo-local: `.vscode/mcp.json` for the servers and a
+            // marked section in `.github/copilot-instructions.md` for the guide pointer. VS Code's
+            // per-user MCP config is managed through its UI, not a portable file, so scope is moot.
+            if (input.flags.vscode) {
+                const file = path.join(cwd, ".vscode", "mcp.json");
+                const wrote = mergeMcpConfig(file, "servers", {
+                    beryl: VSCODE_MCP_SERVER_ENTRY,
+                    playwright: VSCODE_PLAYWRIGHT_SERVER_ENTRY,
+                });
+                const where = path.relative(cwd, file);
+                report("vscode beryl MCP", wrote.beryl, where);
+                report("vscode playwright MCP", wrote.playwright, where);
+                const inst = writeCopilotInstructions(cwd);
+                ctx.err(`${green("✓")} copilot instructions ${outcomeLabel(inst.outcome)} ${dim(path.relative(cwd, inst.file))}`);
             }
             const skills = writeSkills(cwd, scope);
             for (const skill of skills) {

package/dist/commands/tests.js

@@ -110,8 +110,8 @@ export const testCommands = [
             {
                 name: "access",
                 type: "string",
-                description: "The label the plan will be banked with, read (default) or write; a plan that " +
-                    "creates, edits, deletes or toggles something must be write",
+                description: "The label the plan will be banked with: read (default) or write. It is yours to " +
+                    "set; Beryl does not infer it. Only a write is checked (its closing teardown proof)",
             },
         ],
         examples: [
@@ -580,9 +580,9 @@ export const testCommands = [
     {
         name: "tests set-access",
         summary: "Mark a test read or write",
-        description: "read: the test only reads the app. write: any step creates, edits, renames, deletes " +
-            "or toggles something. The server refuses a plan that writes on a read test, so flip " +
-            "the label before re-authoring such a plan. A write test must clean up in `after`.",
+        description: "read: the test only reads the app. write: it creates, edits, renames, deletes or " +
+            "toggles something that persists. The label is yours to set; Beryl does not infer it " +
+            "from the plan. A write test must clean up in `after`, ending with a proof expect.",
         scope: "project",
         args: [
             { name: "test-id", description: "Test id", required: true },

package/dist/lint.js

@@ -9,9 +9,6 @@ export const MAILBOX_ADDRESS_IN_TEST = "This plan types the standing account's a
     "and rides the account's session; one that needs an address the site can mail cites " +
     "{{inbox_address}}, an alias only this test reads. Only the account's own signup and " +
     "sign-in plans (accounts signup, accounts set-login) may fill {{mailbox_address}}.";
-export const WRITE_NEEDS_LABEL = (label, detail) => `${label} (${detail}) changes the app, so this test must be marked access 'write' ` +
-    "(tests create --access write, or tests set-access <id> write) and clean up in " +
-    "'after'. A 'read' test only reads.";
 export const WRITE_NEEDS_CLOSING_TEARDOWN = (detail) => "A 'write' test must end with an 'after' section that undoes what it changed and " +
     "proves it: the last step of 'after' is an expect with expect_kind 'gone', 'hidden', " +
     "'have_count', 'count_delta' (something removed) or 'have_text', 'have_value', " +
@@ -177,31 +174,6 @@ function identityIssues(plan, provisioning) {
         ? [{ path: "(root)", message: MINTED_IDENTITY_NEEDS_TEARDOWN }]
         : [];
 }
-// Same verb list as the server's write_signal (api/app/ta_shared/schemas.py).
-const WRITE_VERBS_RE = /\b(create|save|delete|remove|rename|revoke|enable|disable|invite|add|publish|archive|restore|quarantine|un-quarantine|turn on|turn off|join|decline)\b/i;
-function writeSignal(plan) {
-    if (typeof plan !== "object" || plan === null)
-        return null;
-    const { before, steps: main, after } = plan;
-    if (steps(after).length > 0)
-        return ["after", "a teardown means something was created"];
-    const sectioned = steps(before).length > 0 || steps(after).length > 0;
-    const label = (section, i) => (sectioned ? `${section}[${i}]` : `step[${i}]`);
-    const all = [
-        ...steps(before).map((s, i) => [label("before", i), s]),
-        ...steps(main).map((s, i) => [label("steps", i), s]),
-    ];
-    for (const [where, s] of all) {
-        if (s.action === "upload")
-            return [where, "upload"];
-        if (s.action === "click" && typeof s.selector === "string") {
-            const hit = WRITE_VERBS_RE.exec(s.selector);
-            if (hit)
-                return [where, `click on '${hit[0]}'`];
-        }
-    }
-    return null;
-}
 const TEARDOWN_PROOF_KINDS = new Set([
     "gone",
     "hidden",
@@ -211,11 +183,11 @@ const TEARDOWN_PROOF_KINDS = new Set([
     "have_value",
     "persisted",
 ]);
+// The read/write label is the author's call; Beryl no longer infers it from the plan.
+// Only a `write` label is checked here: it must close its teardown with a proof.
 function accessIssues(plan, access) {
-    if (access !== "write") {
-        const signal = writeSignal(plan);
-        return signal ? [{ path: "(root)", message: WRITE_NEEDS_LABEL(signal[0], signal[1]) }] : [];
-    }
+    if (access !== "write")
+        return [];
     if (typeof plan !== "object" || plan === null)
         return [];
     const after = steps(plan.after);
@@ -232,7 +204,8 @@ function accessIssues(plan, access) {
 }
 // `provisioning`: the plan is an account's own signup or sign-in plan, the one place
 // {{mailbox_address}} is legal (mirrors the server's validate_editable_plan flag).
-// `access`: the label the plan will be banked with; given, a writing plan needs 'write'.
+// `access`: the label the plan will be banked with. It is the author's call (Beryl no
+// longer infers it from the plan); given, only a `write` is checked, for its closing proof.
 export function lintPlan(plan, opts = {}) {
     const issues = validate(plan, ACTION_PLAN_SCHEMA, ACTION_PLAN_SCHEMA, "");
     // The identity rules read a well-formed plan; a shape error is reported alone.

package/dist/schema.generated.js

@@ -15,6 +15,8 @@ export const ACTION_PLAN_SCHEMA = {
                 "wait_for",
                 "expect",
                 "capture_count",
+                "capture_text",
+                "capture_value",
                 "await_email",
                 "upload",
                 "dialog",
@@ -325,6 +327,62 @@ export const ACTION_PLAN_SCHEMA = {
                         ]
                     }
                 },
+                {
+                    "if": {
+                        "properties": {
+                            "action": {
+                                "const": "capture_text"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "capture_as": {
+                                "minLength": 1,
+                                "type": "string"
+                            },
+                            "selector": {
+                                "minLength": 1,
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "capture_as",
+                            "selector"
+                        ]
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "action": {
+                                "const": "capture_value"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "capture_as": {
+                                "minLength": 1,
+                                "type": "string"
+                            },
+                            "selector": {
+                                "minLength": 1,
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "capture_as",
+                            "selector"
+                        ]
+                    }
+                },
                 {
                     "if": {
                         "properties": {

package/dist/skill-tables.js

@@ -27,6 +27,8 @@ export const ACTION_DOCS = {
     wait_for: "Wait for the `selector` element to appear",
     expect: "Assert — kinds in the expect table below",
     capture_count: "Bank the live count of `selector` matches under `capture_as` for a later `count_delta`",
+    capture_text: "Bank the `selector` element's visible text under `capture_as`, to restore it later via `{{handle}}`",
+    capture_value: "Bank the `selector` input's value under `capture_as`, to restore it later via `{{handle}}`",
     await_email: "Await mail in the run inbox, bank the extracted value under `capture_as` (§5)",
     upload: "Set a file input: `value` names a project config file — see below",
     dialog: "Arm a one-shot accept/dismiss handler for the NEXT step's dialog — see below",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beryl-so/cli",
-  "version": "0.47.0",
+  "version": "0.50.0",
   "description": "Beryl on the command line — projects, runs, the exploring agent, and an MCP server over the same commands.",
   "license": "MIT",
   "type": "module",