@beryl-so/cli 0.9.1 → 0.11.1

package/README.md

@@ -160,7 +160,7 @@ Create and manage projects — a site Beryl explores, authors tests for, and run
 | --- | --- | --- |
 | `beryl projects list` | List projects in the workspace | `projects_list` |
 | `beryl projects get` | Show one project, including its current exploration state | `projects_get` |
-| `beryl projects create <url>` | Create a project — the agent starts exploring and authoring tests immediately | `projects_create` |
+| `beryl projects create [url]` | Create a project — with a URL the agent starts exploring; with just --name an empty one | `projects_create` |
 | `beryl projects rename <name>` | Rename a project | `projects_rename` |
 | `beryl projects delete` | Delete a project and all its tests and runs | `projects_delete` |
 | `beryl projects re-explore` | Send the agent back in — run/heal existing tests and discover new flows | — |
@@ -309,12 +309,13 @@ Drive a browser session that captures a target-site login for Beryl to reuse.
 
 ### inbox
 
-Disposable email inboxes for testing flows that send mail — signups, OTPs, receipts.
+Email inboxes for testing flows that send mail — signups, OTPs, receipts.
 
 | Command | Summary | MCP tool |
 | --- | --- | --- |
-| `beryl inbox create` | Mint a disposable email inbox that Beryl receives mail for | `inbox_create` |
+| `beryl inbox create` | Mint an email inbox that Beryl receives mail for | `inbox_create` |
 | `beryl inbox list` | List the workspace's inboxes, newest first | `inbox_list` |
+| `beryl inbox delete <inbox-id>` | Delete an inbox and every email it has received | `inbox_delete` |
 | `beryl inbox read <inbox-id>` | Read the latest email from an inbox (waits for one to arrive) | `inbox_read` |
 | `beryl inbox emails <inbox-id>` | List the emails an inbox has received | `inbox_emails` |
 

package/dist/beryl-test-skill.js

@@ -1,5 +1,7 @@
 // The `beryl-test` authoring skill, installed by `beryl init` into
-// `.agents/skills/beryl-test/SKILL.md` (vendor-neutral, editor-agnostic). Kept as an
+// `.agents/skills/beryl-test/SKILL.md` (vendor-neutral, editor-agnostic) — and, when
+// claude-code is a selected editor, ALSO into the `.claude/skills/beryl-test/SKILL.md`
+// that Claude Code actually indexes (see `writeSkills` in `commands/init.ts`). Kept as an
 // embedded string so it ships in the published package (`files: ["dist"]`) with no
 // build-time asset copy, and so there is ONE source for the guidance — not a copy in
 // the CLI and another in the docs. Edit here; `init` writes it verbatim.

package/dist/commands/inboxes.js

@@ -25,25 +25,35 @@ function extractCode(email) {
 export const inboxCommands = [
     {
         name: "inbox create",
-        summary: "Mint a disposable email inbox that Beryl receives mail for",
-        groupSummary: "Disposable email inboxes for testing flows that send mail — signups, OTPs, receipts.",
+        summary: "Mint an email inbox that Beryl receives mail for",
+        groupSummary: "Email inboxes for testing flows that send mail — signups, OTPs, receipts.",
         description: "Creates a receiving address under Beryl's inbound email domain and returns it. " +
             "Use it wherever a test needs a real, readable mailbox — e.g. as the --email for " +
-            "`beryl signup`, then read the code back with `beryl inbox read --extract-code`.",
+            "`beryl signup`, then read the code back with `beryl inbox read --extract-code`. " +
+            "Pass --permanent to mint the workspace's single permanent mailbox (no TTL).",
         scope: "workspace",
         flags: [
+            {
+                name: "permanent",
+                type: "boolean",
+                description: "Mint the workspace's permanent mailbox (no TTL); one per workspace",
+            },
             {
                 name: "ttl-hours",
                 type: "number",
-                description: "Hours before the inbox expires and stops receiving (1-168, default 24)",
+                description: "Hours before the inbox expires and stops receiving (1-168, default 24; ignored with --permanent)",
             },
             { name: "project", type: "string", description: "Attach the inbox to a project id" },
         ],
-        examples: ["beryl inbox create --json", "beryl inbox create --ttl-hours 2"],
+        examples: [
+            "beryl inbox create --json",
+            "beryl inbox create --ttl-hours 2",
+            "beryl inbox create --permanent",
+        ],
         async run(ctx, input) {
             const ws = await ctx.requireWorkspace(input);
             const inbox = (await ctx.client.post(`/workspaces/${ws}/inboxes`, {
-                ttl_hours: flagNum(input, "ttl-hours") ?? 24,
+                ttl_hours: flagBool(input, "permanent") ? null : (flagNum(input, "ttl-hours") ?? 24),
                 project_id: flagStr(input, "project") ?? null,
             }));
             return {
@@ -58,11 +68,33 @@ export const inboxCommands = [
         summary: "List the workspace's inboxes, newest first",
         description: "Every inbox the workspace has minted with `beryl inbox create`. Expired inboxes " +
             "stop receiving and are hard-deleted by a background sweep, so they drop off " +
-            "this list shortly after their TTL.",
+            "this list shortly after their TTL. Pass --permanent for just the permanent mailbox.",
+        scope: "workspace",
+        flags: [
+            {
+                name: "permanent",
+                type: "boolean",
+                description: "Only the workspace's permanent mailbox (no TTL, not run/project scoped)",
+            },
+        ],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            const query = flagBool(input, "permanent") ? { permanent: true } : undefined;
+            return { data: await ctx.client.get(`/workspaces/${ws}/inboxes`, query) };
+        },
+    },
+    {
+        name: "inbox delete",
+        summary: "Delete an inbox and every email it has received",
         scope: "workspace",
+        args: [{ name: "inbox-id", description: "Inbox id from `beryl inbox create`", required: true }],
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
         async run(ctx, input) {
             const ws = await ctx.requireWorkspace(input);
-            return { data: await ctx.client.get(`/workspaces/${ws}/inboxes`) };
+            const id = arg(input, "inbox-id");
+            await ctx.confirm(`Delete inbox ${id} and its emails?`, flagBool(input, "force"));
+            await ctx.client.del(`/workspaces/${ws}/inboxes/${id}`);
+            return { human: "Deleted." };
         },
     },
     {
@@ -118,11 +150,16 @@ export const inboxCommands = [
         args: [{ name: "inbox-id", description: "Inbox id from `beryl inbox create`", required: true }],
         flags: [
             { name: "since", type: "string", description: "Only emails received after this ISO timestamp" },
+            {
+                name: "limit",
+                type: "number",
+                description: "Return only the most recent N emails (newest first)",
+            },
         ],
         async run(ctx, input) {
             const ws = await ctx.requireWorkspace(input);
             return {
-                data: await ctx.client.get(`/workspaces/${ws}/inboxes/${arg(input, "inbox-id")}/emails`, { since: flagStr(input, "since") }),
+                data: await ctx.client.get(`/workspaces/${ws}/inboxes/${arg(input, "inbox-id")}/emails`, { since: flagStr(input, "since"), limit: flagNum(input, "limit") }),
             };
         },
     },

package/dist/commands/init.js

@@ -6,7 +6,8 @@ import { BERYL_TEST_SKILL, BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME, } fr
 import { loadConfig } from "../config.js";
 import { CliError } from "../errors.js";
 import { ApiClient } from "../http.js";
-import { bold, cyan, dim, green, yellow } from "../output.js";
+import { bold, cyan, dim, green, red, yellow } from "../output.js";
+import { confirmInstall, hasPlaywrightTest, installPlaywright, PLAYWRIGHT_INSTALL_COMMANDS, } from "../playwright-install.js";
 import { cliVersion, warnIfStale } from "../version-check.js";
 import { authCommands } from "./auth.js";
 import { flagStr } from "./util.js";
@@ -92,12 +93,10 @@ function detectEditors(cwd) {
         editors.push("cursor");
     return editors;
 }
-// The authoring skill lives in the vendor-neutral `.agents/skills/` dir (mirroring
-// Momentic), NOT `.claude/` — any coding agent that reads `.agents/skills/` picks it up.
-// Idempotent: an identical copy is left alone; a customer-EDITED copy is never clobbered —
-// we notice and skip so their changes survive a re-run.
-function writeSkill(cwd) {
-    const file = path.join(cwd, ".agents", "skills", BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME);
+// Write the skill to one `.../beryl-test/SKILL.md` file. Idempotent: an identical copy is
+// left alone; a customer-EDITED copy is never clobbered — we notice and skip so their
+// changes survive a re-run.
+function writeSkillFile(file) {
     if (fs.existsSync(file)) {
         // Compare with line endings normalized so a CRLF checkout of our own content still
         // reads as unchanged (not falsely "customized") — we always write LF.
@@ -111,6 +110,49 @@ function writeSkill(cwd) {
     fs.writeFileSync(file, BERYL_TEST_SKILL);
     return { outcome: "wrote", file };
 }
+const skillLeaf = (root) => path.join(root, BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME);
+// The authoring skill always lands in the vendor-neutral `.agents/skills/` dir (mirroring
+// Momentic) — any coding agent that reads `.agents/skills/` picks it up. Claude Code does
+// NOT index `.agents/skills/`; it auto-discovers skills from `~/.claude/skills/` (user
+// scope) and the repo's `.claude/skills/` (project scope). So when `claude-code` is a
+// selected editor we ALSO write the same skill string to the `.claude/skills/` location
+// that matches the MCP `--scope`, or the user never sees it. Each destination is written
+// with the same idempotent / never-clobber-a-customer-edit behavior.
+function writeSkills(cwd, editors, scope) {
+    const results = [writeSkillFile(skillLeaf(path.join(cwd, ".agents", "skills")))];
+    if (editors.includes("claude-code")) {
+        const claudeRoot = scope === "user"
+            ? path.join(os.homedir(), ".claude", "skills")
+            : path.join(cwd, ".claude", "skills");
+        results.push(writeSkillFile(skillLeaf(claudeRoot)));
+    }
+    return results;
+}
+// Local authoring drives a real browser via `@playwright/test` + chromium. init wires the
+// Playwright MCP but historically installed neither, so the first `beryl runs local` hit a wall.
+// On a TTY we offer to install now; non-interactively we print the exact commands rather than
+// running installs unprompted (which would be a surprise in CI). Never throws — a declined or
+// failed install must not fail `init`, which has already done its wiring.
+async function ensureLocalPlaywright(ctx, cwd) {
+    if (hasPlaywrightTest(cwd)) {
+        ctx.err(`${green("✓")} @playwright/test already installed ${dim("(local runs ready)")}`);
+        return;
+    }
+    const hint = () => ctx.err(`${dim("•")} To run tests locally, install Playwright in this project:\n` +
+        `    ${cyan(PLAYWRIGHT_INSTALL_COMMANDS)}`);
+    if (!ctx.interactive || !(await confirmInstall(ctx.prompt))) {
+        hint();
+        return;
+    }
+    try {
+        await installPlaywright(cwd, (line) => ctx.err(dim(line)));
+        ctx.err(`${green("✓")} Local Playwright installed ${dim("(local runs ready)")}`);
+    }
+    catch (err) {
+        ctx.err(`${red("✗")} Playwright install failed: ${err.message}`);
+        hint();
+    }
+}
 export const initCommands = [
     {
         name: "init",
@@ -142,9 +184,9 @@ export const initCommands = [
             {
                 name: "local",
                 type: "boolean",
-                description: "Also wire the Playwright MCP so your coding agent can drive a local browser " +
-                    "(for authoring tests yourself). Default: on whenever a coding agent is wired; " +
-                    "pass --no-local to skip it",
+                description: "Also wire the Playwright MCP so your coding agent can drive a local browser, and " +
+                    "offer to install @playwright/test + chromium so local runs work (for authoring tests " +
+                    "yourself). Default: on whenever a coding agent is wired; pass --no-local to skip it",
             },
         ],
         examples: [
@@ -212,14 +254,25 @@ export const initCommands = [
             }
             if (choice === "auto" && editors.length === 0)
                 ctx.err(dim("No coding agent detected — pass --editor-tools claude-code|cursor to wire one."));
-            // Editor-agnostic: the authoring skill goes to `.agents/skills/` regardless of which
-            // (if any) editor MCP config we wrote, so any `.agents/skills/`-aware harness gets it.
-            const skill = writeSkill(cwd);
-            const skillRel = path.relative(cwd, skill.file);
-            if (skill.outcome === "customized")
-                ctx.err(`${dim("•")} Beryl authoring skill left as-is ${dim(`(${skillRel} — you edited it; delete it to reinstall)`)}`);
-            else
-                ctx.err(`${green("✓")} Beryl authoring skill ${skill.outcome === "wrote" ? "installed" : "already installed"} ${dim(skillRel)}`);
+            // The authoring skill always goes to `.agents/skills/` (any `.agents/skills/`-aware
+            // harness gets it); when claude-code is selected it ALSO goes to the `.claude/skills/`
+            // location Claude Code actually indexes (per --scope), or the user never sees it.
+            const skills = writeSkills(cwd, editors, scope);
+            for (const skill of skills) {
+                // Repo-relative for paths under cwd (`.agents/…`, project-scope `.claude/…`);
+                // absolute for a user-scope `~/.claude/…` path that lives outside the repo.
+                const rel = path.relative(cwd, skill.file);
+                const skillWhere = rel.startsWith("..") ? skill.file : rel;
+                if (skill.outcome === "customized")
+                    ctx.err(`${dim("•")} Beryl authoring skill left as-is ${dim(`(${skillWhere} — you edited it; delete it to reinstall)`)}`);
+                else
+                    ctx.err(`${green("✓")} Beryl authoring skill ${skill.outcome === "wrote" ? "installed" : "already installed"} ${dim(skillWhere)}`);
+            }
+            // Local authoring needs @playwright/test + chromium on the customer's machine; wiring the
+            // Playwright MCP alone isn't enough. Offer/print the install so the first `beryl runs local`
+            // just works instead of hitting a "Local Playwright not found" wall.
+            if (local)
+                await ensureLocalPlaywright(ctx, cwd);
             const nextSteps = `\n${bold("Beryl is set up — now open your editor and ask Claude to write tests.")}\n` +
                 `  ${dim('• Say: "write tests for https://your-app.com" — Claude picks your workspace/project')}\n` +
                 `  ${dim("  and sets the URL for you (no pin, no prompt).")}\n` +

package/dist/commands/projects.js

@@ -54,10 +54,22 @@ export const projectCommands = [
     },
     {
         name: "projects create",
-        summary: "Create a project — the agent starts exploring and authoring tests immediately",
+        summary: "Create a project — with a URL the agent starts exploring; with just --name an empty one",
         scope: "workspace",
-        args: [{ name: "url", description: "Root URL of the site to test", required: true }],
+        args: [
+            {
+                name: "url",
+                description: "Root URL of the site to test. Omit to create an empty project (see --name)",
+                required: false,
+            },
+        ],
         flags: [
+            {
+                name: "name",
+                type: "string",
+                description: "Name for an empty project when no URL is given. Add a URL later with " +
+                    "`beryl envs update <env-id>`, or author tests over the CLI/MCP",
+            },
             {
                 name: "auth",
                 type: "string",
@@ -84,13 +96,31 @@ export const projectCommands = [
             "beryl projects create https://app.example.com --watch",
             "beryl projects create https://app.example.com --auth gated",
             "beryl projects create https://app.example.com --auth public --no-explore",
+            'beryl projects create --name "Acme production"',
         ],
         async run(ctx, input) {
             const noExplore = flagBool(input, "no-explore");
             if (noExplore && flagBool(input, "watch"))
                 throw new UsageError("--no-explore cannot be combined with --watch");
             const ws = await ctx.requireWorkspace(input);
-            const url = arg(input, "url");
+            const rawUrl = input.args.url;
+            const url = typeof rawUrl === "string" ? rawUrl : "";
+            const name = flagStr(input, "name");
+            // Name-only: create a real empty project (no URL, no exploration). Set a URL
+            // later with `beryl envs update <env-id>` or author over the CLI/MCP.
+            if (!url) {
+                if (!name)
+                    throw new UsageError("Provide a URL to explore, or --name to create an empty project");
+                const created = (await ctx.client.post(`/workspaces/${ws}/projects`, {
+                    name,
+                }));
+                return {
+                    data: created,
+                    human: `${green("Project created")}: ${created.project_id} ${dim("(empty)")}\n` +
+                        `Add a site with \`beryl envs update <env-id>\`, or author tests with ` +
+                        `\`beryl tests create\`.`,
+                };
+            }
             const auth = flagStr(input, "auth") ?? (await resolveAuthChoice(ctx, ws, url));
             const created = (await ctx.client.post(`/workspaces/${ws}/projects`, {
                 root_url: url,

package/dist/commands/runs.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import { downloadRunArtifacts, failureImages, isFailing, resultsOf, } from "../artifacts.js";
 import { CliError, UsageError } from "../errors.js";
-import { runSpecLocally } from "../local-run.js";
+import { PlaywrightMissingError, runSpecLocally } from "../local-run.js";
 import { dim, green, red, yellow } from "../output.js";
+import { confirmInstall, installPlaywright } from "../playwright-install.js";
 import { arg, flagBool, flagNum, flagStr, projectPath } from "./util.js";
 import { watchRun } from "./watch.js";
 const MAX_FAILURE_SCREENSHOTS = 5;
@@ -71,8 +72,9 @@ export const runCommands = [
         name: "runs local",
         summary: "Run a banked test locally with your own Playwright (public flows)",
         description: "Unlike `runs trigger`, this runs on YOUR machine, not Beryl's cloud — fetches the test's " +
-            "rendered spec, then runs it with your local @playwright/test (install it once with " +
-            "`npm i -D @playwright/test && npx playwright install`). Point --url-override at a local " +
+            "rendered spec, then runs it with your local @playwright/test. On a terminal it offers to " +
+            "install @playwright/test + chromium for you the first time they're missing (over MCP it " +
+            "prints the install commands instead). Point --url-override at a local " +
             "dev server or preview, and --dir to keep the spec, artifacts, and JSON report on disk so " +
             "an agent can run-fix-run. v1 targets public/unauthenticated flows: an authenticated test " +
             "refuses to run locally (those run in Beryl's cloud, which holds the session) — no session " +
@@ -107,14 +109,34 @@ export const runCommands = [
                     "session) — local runs are for public/unauthenticated flows. Run it with " +
                     "`beryl runs trigger`.");
             }
+            const runOnce = () => runSpecLocally({
+                spec: script.content,
+                testName: testId,
+                dir: flagStr(input, "dir"),
+                onProgress: (line) => ctx.err(dim(line)),
+            });
             let outcome;
             try {
-                outcome = await runSpecLocally({
-                    spec: script.content,
-                    testName: testId,
-                    dir: flagStr(input, "dir"),
-                    onProgress: (line) => ctx.err(dim(line)),
-                });
+                try {
+                    outcome = await runOnce();
+                }
+                catch (err) {
+                    // Local Playwright missing: on a TTY offer to install it and retry, instead of only
+                    // printing a hint the user then has to act on by hand. Non-interactively we can't
+                    // prompt, so we re-throw and the hint surfaces as before (no unprompted install).
+                    if (err instanceof PlaywrightMissingError && ctx.interactive) {
+                        // confirmInstall swallows a prompt failure into `false`, so a broken prompt falls
+                        // back to re-throwing the actionable missing-Playwright hint, not the prompt's error.
+                        if (!(await confirmInstall(ctx.prompt)))
+                            throw err;
+                        await installPlaywright(process.cwd(), (line) => ctx.err(dim(line)));
+                        ctx.err(green("✓ Local Playwright installed — running the test…"));
+                        outcome = await runOnce();
+                    }
+                    else {
+                        throw err;
+                    }
+                }
             }
             catch (err) {
                 // Every failure to run the spec (missing Playwright, a compile error, a customer

package/dist/local-run.js

@@ -1,12 +1,13 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-// The customer already has @playwright/test (the MCP `init` wires it), so we invoke it
-// as an external rather than bundling it — the CLI's zero-runtime-dep rule. In a node_modules
-// install `playwright` is on PATH; otherwise fall back to `npx playwright`, exactly as the
-// cloud runner does.
+import { PLAYWRIGHT_INSTALL_COMMANDS } from "./playwright-install.js";
+// We invoke @playwright/test as an external rather than bundling it — the CLI's zero-runtime-dep
+// rule. In a node_modules install `playwright` is on PATH; otherwise fall back to `npx playwright`,
+// exactly as the cloud runner does. The install commands come from playwright-install.ts so the
+// hint text and the actual installer never drift apart.
 export const PLAYWRIGHT_INSTALL_HINT = "Local Playwright not found. Install it in this project, then re-run:\n" +
-    "  npm i -D @playwright/test && npx playwright install chromium";
+    `  ${PLAYWRIGHT_INSTALL_COMMANDS}`;
 // Isolate the run from any playwright.config.ts in the customer's repo: a stray `testMatch`
 // would exclude our spec (a zero-test run that reads as a false pass), and a `use.baseURL` /
 // `use.storageState` / `globalSetup` there would silently retarget or reauth the run we mean

package/dist/playwright-install.js

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+// The two commands that turn "nothing Playwright-related installed" into "local runs work":
+// the test runner as a dev dep, then its browser binary. Kept as data so the CLI can both
+// run them and print them verbatim for the non-interactive / copy-paste path.
+export const INSTALL_TEST_RUNNER = ["npm", "i", "-D", "@playwright/test"];
+export const INSTALL_CHROMIUM = ["npx", "playwright", "install", "chromium"];
+export const PLAYWRIGHT_INSTALL_COMMANDS = `${INSTALL_TEST_RUNNER.join(" ")} && ${INSTALL_CHROMIUM.join(" ")}`;
+// Resolve `@playwright/test` the way Playwright itself will at run time — from the project
+// tree, not from wherever the globally-installed CLI happens to live. `createRequire` rooted
+// at cwd walks up the same node_modules chain, so this is true iff a local run would find it.
+export function hasPlaywrightTest(cwd) {
+    try {
+        createRequire(path.join(cwd, "package.json")).resolve("@playwright/test");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const INSTALL_PROMPT = `Install local Playwright now (${PLAYWRIGHT_INSTALL_COMMANDS})? [Y/n] `;
+// Ask (default-yes) whether to install. Returns false — not throwing — when there is no answer
+// or the prompt fails, so callers uniformly fall back to printing the install hint.
+export async function confirmInstall(prompt) {
+    try {
+        return !/^n(o)?$/i.test(await prompt(INSTALL_PROMPT));
+    }
+    catch {
+        return false;
+    }
+}
+const withCmdExt = (cmd) => process.platform === "win32" && (cmd === "npm" || cmd === "npx") ? `${cmd}.cmd` : cmd;
+function runInherit(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        // stdio inherited: an install is slow and the user wants to watch npm/browser-download
+        // progress live, exactly as if they'd typed it themselves.
+        const child = spawn(withCmdExt(command), [...args], { cwd, stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (code) => code === 0
+            ? resolve()
+            : reject(new Error(`\`${command} ${args.join(" ")}\` exited with code ${code}`)));
+    });
+}
+/**
+ * Install the local Playwright test runner + chromium into `cwd`, streaming each step's output.
+ * Throws if either step exits non-zero (so the caller surfaces the failure, not a silent partial
+ * install). Skips the `@playwright/test` step when it is already resolvable, but always ensures
+ * the browser binary — an installed runner with no browser still fails a real run.
+ */
+export async function installPlaywright(cwd, onStep) {
+    if (!hasPlaywrightTest(cwd)) {
+        onStep?.(`Installing @playwright/test — ${INSTALL_TEST_RUNNER.join(" ")}`);
+        await runInherit(INSTALL_TEST_RUNNER[0], INSTALL_TEST_RUNNER.slice(1), cwd);
+    }
+    onStep?.(`Installing the Chromium browser — ${INSTALL_CHROMIUM.join(" ")}`);
+    await runInherit(INSTALL_CHROMIUM[0], INSTALL_CHROMIUM.slice(1), cwd);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beryl-so/cli",
-  "version": "0.9.1",
+  "version": "0.11.1",
   "description": "Beryl on the command line — projects, runs, the exploring agent, and an MCP server over the same commands.",
   "license": "MIT",
   "type": "module",
@@ -38,5 +38,8 @@
     "tsx": "^4.23.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
+  },
+  "overrides": {
+    "@hono/node-server": "2.0.11"
   }
 }