stably 4.12.2 → 4.12.4

package/dist/node_modules/playwright/lib/cli/daemon/daemon.js

@@ -75,6 +75,49 @@ async function startMcpDaemonServer(config, contextFactory) {
     timestamp: Date.now()
   };
   const { browserContext, close } = await contextFactory.createContext(clientInfo, new AbortController().signal, {});
+  // For CDP connections: resize the browser window to show chrome (tabs, URL bar).
+  // Without this, the remote browser's viewport fills the entire window, hiding chrome.
+  if (config.browser.cdpEndpoint) {
+    try {
+      const pages = browserContext.pages();
+      const page = pages[0];
+      if (page) {
+        // Try to load viewport from the user's playwright.config (most authoritative source),
+        // then fall back to config.browser.contextOptions.viewport (which may just be the 1280x720 default).
+        let viewport = null;
+        if (config.playwrightConfigPath) {
+          try {
+            const { requireOrImport } = require("../../transform/transform");
+            let userConfig = await requireOrImport(config.playwrightConfigPath);
+            if (userConfig && typeof userConfig === "object" && "default" in userConfig)
+              userConfig = userConfig.default;
+            viewport = userConfig?.use?.viewport || userConfig?.projects?.[0]?.use?.viewport;
+            daemonDebug("extracted viewport from playwright config:", viewport);
+          } catch (e) {
+            daemonDebug("failed to load playwright config for viewport", e);
+          }
+        }
+        // Fall back to config viewport if playwright.config didn't provide one
+        if (!viewport) {
+          viewport = config.browser.contextOptions?.viewport;
+        }
+        if (viewport && viewport.width && viewport.height) {
+          await page.setViewportSize(viewport);
+        }
+        const cdpSession = await browserContext.newCDPSession(page);
+        const { windowId } = await cdpSession.send("Browser.getWindowForTarget");
+        const vp = viewport || { width: 1280, height: 720 };
+        const CHROME_HEADER_HEIGHT = 85;
+        await cdpSession.send("Browser.setWindowBounds", {
+          windowId,
+          bounds: { width: vp.width, height: vp.height + CHROME_HEADER_HEIGHT }
+        });
+        await cdpSession.detach();
+      }
+    } catch (e) {
+      daemonDebug("failed to resize window for CDP connection (best-effort)", e);
+    }
+  }
   browserContext.on("close", () => {
     daemonDebug("browser closed, shutting down daemon");
     shutdown(0);

package/dist/node_modules/playwright/lib/index.js

@@ -92,6 +92,21 @@ const playwrightFixtures = {
   browser: [async ({ playwright, browserName, _browserOptions, connectOptions }, use) => {
     if (!["chromium", "firefox", "webkit"].includes(browserName))
       throw new Error(`Unexpected browserName "${browserName}", must be one of "chromium", "firefox" or "webkit"`);
+    // CDP endpoint support via environment variable or connectOptions with /browser-cdp/ path
+    const cdpEndpoint = process.env.PLAYWRIGHT_CDP_ENDPOINT;
+    const connectWsEndpoint = connectOptions == null ? void 0 : connectOptions.wsEndpoint;
+    const isCdpWsEndpoint = typeof connectWsEndpoint === "string" && (connectWsEndpoint.includes("/browser-cdp/") || connectWsEndpoint.includes("/browser/cdp"));
+    if (cdpEndpoint || isCdpWsEndpoint) {
+      if (browserName !== "chromium")
+        throw new Error("CDP endpoint is only supported for Chromium browsers");
+      const endpoint = cdpEndpoint || connectWsEndpoint;
+      const cdpHeadersFromEnv = process.env.PLAYWRIGHT_CDP_HEADERS ? JSON.parse(process.env.PLAYWRIGHT_CDP_HEADERS) : void 0;
+      const browser2 = await playwright.chromium.connectOverCDP(endpoint, {
+        headers: cdpHeadersFromEnv || (connectOptions == null ? void 0 : connectOptions.headers)
+      });
+      await use(browser2);
+      return;
+    }
     if (connectOptions) {
       const browser2 = await playwright[browserName].connect({
         ...connectOptions,
@@ -335,7 +350,13 @@ const playwrightFixtures = {
           size: typeof video === "string" ? void 0 : video.size
         }
       } : {};
-      const context = await browser.newContext({ ...videoOptions, ...options });
+      // When connected via CDP (run-test), reuse the default context instead of
+      // creating a new one. This preserves browser state (pages, cookies, etc.)
+      // after the test completes, allowing the daemon to interact with the result.
+      const isCdpSession = !!process.env.PLAYWRIGHT_CDP_ENDPOINT;
+      const context = isCdpSession && browser.contexts().length > 0
+        ? browser.contexts()[0]
+        : await browser.newContext({ ...videoOptions, ...options });
       if (process.env.PW_CLOCK === "frozen") {
         await context._wrapApiCall(async () => {
           await context.clock.install({ time: 0 });
@@ -351,6 +372,10 @@ const playwrightFixtures = {
         if (closed)
           return;
         closed = true;
+        // Skip context.close() when connected via CDP — preserve browser state
+        // so the daemon can continue interacting with the test's pages.
+        if (isCdpSession)
+          return;
         const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
         await context.close({ reason: closeReason });
         const testFailed = testInfo.status !== testInfo.expectedStatus;
@@ -403,6 +428,12 @@ const playwrightFixtures = {
     await browserImpl._wrapApiCall(() => browserImpl._disconnectFromReusedContext(closeReason), { internal: true });
   },
   page: async ({ context, _reuseContext }, use) => {
+    // When connected via CDP, reuse the existing page (the daemon's page)
+    // instead of creating a new one, so the daemon sees the test's navigation.
+    if (process.env.PLAYWRIGHT_CDP_ENDPOINT && context.pages().length > 0) {
+      await use(context.pages()[0]);
+      return;
+    }
     if (!_reuseContext) {
       await use(await context.newPage());
       return;

package/dist/node_modules/playwright/lib/mcp/browser/browserServerBackend.js

@@ -27,6 +27,22 @@ var import_response = require("./response");
 var import_sessionLog = require("./sessionLog");
 var import_tools = require("./tools");
 var import_tool = require("../sdk/tool");
+var import_net = require("net");
+function sendRecorderEvent(event) {
+  const port = process.env.CLAUDE_RECORDER_PORT;
+  if (!port)
+    return;
+  try {
+    const socket = import_net.createConnection({
+      port: Number(port),
+      host: process.env.CLAUDE_RECORDER_HOST || "127.0.0.1"
+    });
+    const payload = JSON.stringify(event) + "\n";
+    socket.on("error", () => socket.destroy());
+    socket.write(payload, () => socket.end());
+  } catch (error) {
+  }
+}
 class BrowserServerBackend {
   constructor(config, factory, options = {}) {
     this._config = config;
@@ -64,6 +80,17 @@ Tool "${name}" not found` }],
       await tool.handle(context, parsedArguments, response);
       responseObject = await response.serialize();
       this._sessionLog?.logResponse(name, parsedArguments, responseObject);
+      // Send recorder event for user action tracking
+      const parsed = (0, import_response.parseResponse)(responseObject);
+      if (parsed && parsed.code) {
+        sendRecorderEvent({
+          type: "user-action",
+          action: { name: name, args: parsedArguments },
+          code: parsed.code,
+          url: this._context?.currentTab()?.page?.url() || "",
+          timestamp: Date.now()
+        });
+      }
     } catch (error) {
       return {
         content: [{ type: "text", text: `### Error

package/dist/node_modules/playwright/lib/mcp/browser/config.js.rej

@@ -0,0 +1,11 @@
+--- lib/mcp/browser/config.js
++++ lib/mcp/browser/config.js
+@@ -305,7 +305,7 @@
+ function outputDir(config, clientInfo) {
+   if (config.outputDir)
+     return import_path.default.resolve(config.outputDir);
+   const rootPath = (0, import_server2.firstRootPath)(clientInfo);
+   if (rootPath)
+-    return import_path.default.resolve(rootPath, config.skillMode ? ".playwright-cli" : ".playwright-mcp");
++    return import_path.default.resolve(rootPath, config.skillMode ? ".stably-browser" : ".playwright-mcp");
+   const tmpDir = process.env.PW_TMPDIR_FOR_TEST ?? import_os.default.tmpdir();

package/dist/node_modules/playwright/lib/mcp/browser/context.js

@@ -40,6 +40,55 @@ var import_log = require("../log");
 var import_tab = require("./tab");
 var import_config = require("./config");
 const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+class InputRecorder {
+  constructor(context, browserContext) {
+    this._context = context;
+    this._browserContext = browserContext;
+  }
+  static async create(context, browserContext) {
+    const recorder = new InputRecorder(context, browserContext);
+    await recorder._initialize();
+    return recorder;
+  }
+  async _initialize() {
+    const sessionLog = this._context.sessionLog;
+    if (!sessionLog) return;
+    await this._browserContext._enableRecorder({
+      mode: "recording",
+      recorderMode: "api"
+    }, {
+      actionAdded: (page, data, code) => {
+        if (this._context.isRunningTool())
+          return;
+        const tab = import_tab.Tab.forPage(page);
+        if (tab)
+          sessionLog.logUserAction(data.action, tab, code, false);
+      },
+      actionUpdated: (page, data, code) => {
+        if (this._context.isRunningTool())
+          return;
+        const tab = import_tab.Tab.forPage(page);
+        if (tab)
+          sessionLog.logUserAction(data.action, tab, code, true);
+      },
+      signalAdded: (page, data) => {
+        if (this._context.isRunningTool())
+          return;
+        if (data.signal.name !== "navigation")
+          return;
+        const tab = import_tab.Tab.forPage(page);
+        const navigateAction = {
+          name: "navigate",
+          url: data.signal.url,
+          signals: []
+        };
+        if (tab)
+          sessionLog.logUserAction(navigateAction, tab, `await page.goto('${data.signal.url}');`, false);
+      }
+    });
+  }
+}
+
 class Context {
   constructor(options) {
     this._tabs = [];
@@ -251,6 +300,9 @@ class Context {
         _live: true
       });
     }
+    // Initialize InputRecorder for user action capture
+    if (this.sessionLog)
+      await InputRecorder.create(this, browserContext);
     return result;
   }
   lookupSecret(secretName) {

package/dist/node_modules/playwright/lib/mcp/browser/sessionLog.js

@@ -33,8 +33,24 @@ __export(sessionLog_exports, {
 module.exports = __toCommonJS(sessionLog_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
+var import_net = require("net");
 var import_config = require("./config");
 var import_response = require("./response");
+function sendRecorderEvent(event) {
+  const port = process.env.CLAUDE_RECORDER_PORT;
+  if (!port)
+    return;
+  try {
+    const socket = import_net.createConnection({
+      port: Number(port),
+      host: process.env.CLAUDE_RECORDER_HOST || "127.0.0.1"
+    });
+    const payload = JSON.stringify(event) + "\n";
+    socket.on("error", () => socket.destroy());
+    socket.write(payload, () => socket.end());
+  } catch (error) {
+  }
+}
 class SessionLog {
   constructor(sessionFolder) {
     this._sessionFileQueue = Promise.resolve();
@@ -68,6 +84,40 @@ class SessionLog {
     lines.push("");
     this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
   }
+  logUserAction(action, tab, code, isUpdate) {
+    code = code.trim();
+    // Send recorder event for user action tracking
+    const actionForLog = { ...action };
+    delete actionForLog.ariaSnapshot;
+    delete actionForLog.selector;
+    actionForLog.isUpdate = !!isUpdate;
+    sendRecorderEvent({
+      type: "user-action",
+      action: actionForLog,
+      code,
+      url: tab.page.url(),
+      timestamp: Date.now()
+    });
+    // Also log to session file
+    const lines = [""];
+    lines.push(
+      `### User action: ${action.name}`,
+      "- Args",
+      "```json",
+      JSON.stringify(actionForLog, null, 2),
+      "```"
+    );
+    if (code) {
+      lines.push(
+        "- Code",
+        "```js",
+        code,
+        "```"
+      );
+    }
+    lines.push("");
+    this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/node_modules/playwright/lib/mcp/test/browserBackend.js

@@ -32,9 +32,14 @@ function createCustomMessageHandler(testInfo, context) {
     if (data.initialize) {
       if (backend)
         throw new Error("MCP backend is already initialized");
-      backend = new import_browserServerBackend.BrowserServerBackend({ ...import_config.defaultConfig, capabilities: ["testing"] }, (0, import_browserContextFactory.identityBrowserContextFactory)(context));
+      backend = new import_browserServerBackend.BrowserServerBackend({ ...import_config.defaultConfig, capabilities: ["testing"], saveSession: true }, (0, import_browserContextFactory.identityBrowserContextFactory)(context));
       await backend.initialize(data.initialize.clientInfo);
       const pausedMessage = await generatePausedMessage(testInfo, context);
+      // Ensure recorder UI appears immediately by triggering a benign action that doesn't change page state.
+      try {
+        await backend.callTool("browser_tabs", { action: "list" });
+      } catch (e) {
+      }
       return { initialize: { pausedMessage } };
     }
     if (data.listTools) {

package/dist/{playwright-cli.js → stably-browser.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../../app/node_modules/.pnpm/@stablyai-internal+playwright-cli@0.4.0/node_modules/@stablyai-internal/playwright-cli/playwright-cli.js
+// ../../app/node_modules/.pnpm/@stablyai-internal+playwright-cli@0.4.6/node_modules/@stablyai-internal/playwright-cli/playwright-cli.js
 var fs = require("fs");
 var path = require("path");
 var argv = process.argv.slice(2);
@@ -8,7 +8,7 @@ var cmdIndex = argv.findIndex((arg) => !arg.startsWith("-"));
 if (cmdIndex !== -1 && argv[cmdIndex] === "run-file") {
   const fileArg = argv[cmdIndex + 1];
   if (!fileArg) {
-    console.error("Usage: playwright-cli run-file <path>");
+    console.error("Usage: stably-browser run-file <path>");
     process.exit(1);
   }
   const filePath = path.resolve(fileArg);
@@ -23,7 +23,7 @@ if (cmdIndex !== -1 && argv[cmdIndex] === "run-file") {
 }
 if (cmdIndex !== -1 && argv[cmdIndex] === "run-test") {
   if (argv.includes("--help") || argv.includes("-h")) {
-    console.log(`Usage: playwright-cli run-test [test-filter] [options]
+    console.log(`Usage: stably-browser run-test [test-filter] [options]
 
 Runs Playwright tests connected to the managed browser via CDP.
 Tests connect to the existing browser session instead of launching a new one.
@@ -147,7 +147,7 @@ Notes:
   const cwd = process.cwd();
   const wrapperConfigPath = path.join(
     cwd,
-    `.playwright-cli-run-test-${crypto.randomUUID()}.config.js`
+    `.stably-browser-run-test-${crypto.randomUUID()}.config.js`
   );
   let userConfigImport = "";
   for (const name of ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs"]) {
@@ -161,7 +161,7 @@ const userConfig = userConfigModule.default || userConfigModule;`;
   if (!userConfigImport) {
     userConfigImport = `const userConfig = {};`;
   }
-  const tmpDir = path.join(os.tmpdir(), `playwright-cli-${crypto.randomUUID()}`);
+  const tmpDir = path.join(os.tmpdir(), `stably-browser-${crypto.randomUUID()}`);
   fs.mkdirSync(tmpDir, { recursive: true });
   let realPwTestPath;
   try {
@@ -172,7 +172,7 @@ const userConfig = userConfigModule.default || userConfigModule;`;
   }
   const fixturesPath = path.join(tmpDir, "stably-cdp-fixtures.js");
   const fixturesCode = `
-// Auto-generated by playwright-cli run-test
+// Auto-generated by stably-browser run-test
 // Overrides browser/context/page fixtures to connect via CDP and preserve state.
 const realPw = require(${JSON.stringify(realPwTestPath)});
 
@@ -226,7 +226,7 @@ module.exports = { ...realPw, test, default: test };
   fs.writeFileSync(fixturesPath, fixturesCode);
   const shimPath = path.join(tmpDir, "stably-require-shim.js");
   const shimCode = `
-// Auto-generated by playwright-cli run-test
+// Auto-generated by stably-browser run-test
 // Intercepts require('@playwright/test') to use CDP-aware fixtures.
 const Module = require('module');
 const originalResolve = Module._resolveFilename;
@@ -241,7 +241,7 @@ Module._resolveFilename = function(request, parent, isMain, options) {
 `;
   fs.writeFileSync(shimPath, shimCode);
   const wrapperConfig = `
-// Auto-generated by playwright-cli run-test \u2014 connects to daemon browser via CDP.
+// Auto-generated by stably-browser run-test \u2014 connects to daemon browser via CDP.
 const { defineConfig } = require('@playwright/test');
 ${userConfigImport}
 
@@ -282,12 +282,16 @@ module.exports = defineConfig({
 `;
   fs.writeFileSync(wrapperConfigPath, wrapperConfig);
   const testArgs = argv.slice(cmdIndex + 1).filter((a) => !a.startsWith("--config=") && !a.startsWith("--session=") && !a.startsWith("-s=") && a !== "--headed");
-  // Resolve @playwright/test CLI binary to avoid version mismatch with playwright package
-  var _runBin = "npx", _runArgs = ["playwright", "test"];
-  try { var _ptPkg = require.resolve("@playwright/test/package.json", { paths: [cwd] });
-    var _ptCli = path.join(path.dirname(_ptPkg), "cli.js");
-    if (fs.existsSync(_ptCli)) { _runBin = process.execPath; _runArgs = [_ptCli, "test"]; }
-  } catch (_) {}
+  _runBin = "npx", _runArgs = ["playwright", "test"];
+  try {
+    _ptPkg = require.resolve("@playwright/test/package.json", { paths: [cwd] });
+    _ptCli = path.join(path.dirname(_ptPkg), "cli.js");
+    if (fs.existsSync(_ptCli)) {
+      _runBin = process.execPath;
+      _runArgs = [_ptCli, "test"];
+    }
+  } catch (_) {
+  }
   let exitCode = 0;
   try {
     execFileSync(_runBin, [..._runArgs, "--config=" + wrapperConfigPath, ...testArgs], {
@@ -313,6 +317,10 @@ module.exports = defineConfig({
   }
   process.exit(exitCode);
 }
+var _runBin;
+var _runArgs;
+var _ptPkg;
+var _ptCli;
 if (cmdIndex !== -1 && argv[cmdIndex] === "open") {
   const cwd = process.cwd();
   for (const name of ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs"]) {

package/dist/stably-plugin-cli/skills/browser-interaction-guide/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: browser-interaction-guide
-description: Guide for browser interactions in Playwright tests including playwright-cli commands, wait patterns, headless mode, locator best practices, and browser cleanup. Use when setting up browser sessions, writing wait patterns, fixing locator issues, or debugging headless failures. Triggers on browser setup, playwright-cli, run-test, snapshot, wait pattern, waitFor, headless, locator, browser cleanup.
+description: Guide for browser interactions in Playwright tests including stably-browser commands, wait patterns, headless mode, locator best practices, and browser cleanup. Use when setting up browser sessions, writing wait patterns, fixing locator issues, or debugging headless failures. Triggers on browser setup, stably-browser, run-test, snapshot, wait pattern, waitFor, headless, locator, browser cleanup.
 ---
 
 # Browser Interaction Guide
@@ -9,47 +9,47 @@ Guide for browser interactions in Playwright tests.
 
 ## Browser Setup
 
-Use `playwright-cli` commands for browser interaction. The browser starts lazily on first command.
+Use `stably-browser` commands for browser interaction. The browser starts lazily on first command.
 
 ```bash
 # Open a browser and navigate
-playwright-cli open https://example.com
+stably-browser open https://example.com
 
 # Or open then navigate
-playwright-cli open
-playwright-cli goto https://example.com
+stably-browser open
+stably-browser goto https://example.com
 ```
 
 ### Browser Persists After run-test
 
-`playwright-cli run-test` auto-starts a browser if needed and preserves the session after tests finish. You can immediately use `playwright-cli snapshot`, `playwright-cli click`, etc. to inspect page state. No need to run `playwright-cli open` before or after `run-test`.
+`stably-browser run-test` auto-starts a browser if needed and preserves the session after tests finish. You can immediately use `stably-browser snapshot`, `stably-browser click`, etc. to inspect page state. No need to run `stably-browser open` before or after `run-test`.
 
 ### Reset Browser Between Independent Test Verifications
 
-**CRITICAL:** When verifying that multiple independent tests pass, you **MUST** run `playwright-cli close` between each `run-test` call. Browser state (cookies, localStorage, auth sessions) persists across runs, so a stale or logged-in state from one test will contaminate the next — causing cascading login failures or unexpected behavior.
+**CRITICAL:** When verifying that multiple independent tests pass, you **MUST** run `stably-browser close` between each `run-test` call. Browser state (cookies, localStorage, auth sessions) persists across runs, so a stale or logged-in state from one test will contaminate the next — causing cascading login failures or unexpected behavior.
 
-**IMPORTANT: `playwright-cli close` must be its own separate Bash call.** Do NOT chain it with other commands (e.g., `playwright-cli close; playwright-cli run-test ...`). The browser is only fully terminated after the Bash command finishes, so chaining means the next command runs on the old browser with stale state.
+**IMPORTANT: `stably-browser close` must be its own separate Bash call.** Do NOT chain it with other commands (e.g., `stably-browser close; stably-browser run-test ...`). The browser is only fully terminated after the Bash command finishes, so chaining means the next command runs on the old browser with stale state.
 
 This does NOT apply when intentionally using `run-test` as a setup/seed mechanism to build state for subsequent interaction.
 
 ```bash
 # CORRECT: Each command is a separate Bash call
-playwright-cli run-test tests/test-a.spec.ts
-playwright-cli close
-playwright-cli run-test tests/test-b.spec.ts
-playwright-cli close
+stably-browser run-test tests/test-a.spec.ts
+stably-browser close
+stably-browser run-test tests/test-b.spec.ts
+stably-browser close
 ```
 
 ```bash
 # WRONG: Chaining close with run-test in one command
-playwright-cli close; playwright-cli run-test tests/test-b.spec.ts  # ← run-test hits old browser
-playwright-cli close && playwright-cli run-test tests/test-b.spec.ts  # ← same problem
+stably-browser close; stably-browser run-test tests/test-b.spec.ts  # ← run-test hits old browser
+stably-browser close && stably-browser run-test tests/test-b.spec.ts  # ← same problem
 ```
 
 ```bash
 # WRONG: Running independent tests without resetting
-playwright-cli run-test tests/test-a.spec.ts
-playwright-cli run-test tests/test-b.spec.ts   # ← may fail: stale state from test-a
+stably-browser run-test tests/test-a.spec.ts
+stably-browser run-test tests/test-b.spec.ts   # ← may fail: stale state from test-a
 ```
 
 ### Tool Decision Tree
@@ -57,19 +57,19 @@ playwright-cli run-test tests/test-b.spec.ts   # ← may fail: stale state from
 ```
 What do you need to do?
 ├── Explore a page interactively
-│   └── playwright-cli open <url>
+│   └── stably-browser open <url>
 │       Read snapshot from output → interact with refs directly
 │
 ├── Run a test then explore (auth setup, state setup)
-│   └── playwright-cli run-test <seedFile> --project=<project>
+│   └── stably-browser run-test <seedFile> --project=<project>
 │       Then: click/fill/snapshot directly (browser stays open)
 │
 ├── Debug a failing test
-│   └── playwright-cli run-test <file>
-│       Read output → inspect with playwright-cli snapshot if needed
+│   └── stably-browser run-test <file>
+│       Read output → inspect with stably-browser snapshot if needed
 │
 └── Verify a test passes
-    └── playwright-cli run-test <file>
+    └── stably-browser run-test <file>
 ```
 
 For project selection (auth dependencies), see `playwright-config-auth` skill.
@@ -78,13 +78,13 @@ For project selection (auth dependencies), see `playwright-config-auth` skill.
 
 | Error Type | Action |
 |------------|--------|
-| **Test code error** (assertion failed, locator not found) | Test the locator interactively with `playwright-cli run-code` first (seconds vs minutes), then fix code and re-run with `playwright-cli run-test` |
+| **Test code error** (assertion failed, locator not found) | Test the locator interactively with `stably-browser run-code` first (seconds vs minutes), then fix code and re-run with `stably-browser run-test` |
 | **External service error** (timeout, network) | Retry up to 3 times |
 | **Same error 3+ times** | Flag as blocked service issue, do not keep retrying |
 
 ## Browser Cleanup
 
-Close the browser when done with `playwright-cli close`.
+Close the browser when done with `stably-browser close`.
 
 ## Wait Patterns
 
@@ -206,11 +206,11 @@ When you need to type or use environment variable values during browser interact
 
 ```bash
 # CORRECT — single quotes preserve the literal ${process.env.X} for substitution
-playwright-cli fill e3 '${process.env.ACCOUNT_PASSWORD}'
-playwright-cli goto 'https://${process.env.BASE_URL}/dashboard'
+stably-browser fill e3 '${process.env.ACCOUNT_PASSWORD}'
+stably-browser goto 'https://${process.env.BASE_URL}/dashboard'
 
 # WRONG — double quotes cause bash to expand ${process.env.X} as empty
-playwright-cli fill e3 "${process.env.ACCOUNT_PASSWORD}"
+stably-browser fill e3 "${process.env.ACCOUNT_PASSWORD}"
 ```
 
 ## Browser Interaction Strategy (Priority Order)
@@ -223,13 +223,13 @@ Don't prematurely optimize with custom JS. Slower but reliable `agent.act()` is
 
 ## Page State Snapshots
 
-Every `playwright-cli` command that changes page state (`open`, `goto`, `click`, `fill`, `run-test`, etc.) returns a snapshot file path in its output. **Read that snapshot file directly — do not call `playwright-cli snapshot` again.** Refs (e1, e2, etc.) are only valid from the most recent snapshot. After any command that returns a new snapshot, previous refs are stale.
+Every `stably-browser` command that changes page state (`open`, `goto`, `click`, `fill`, `run-test`, etc.) returns a snapshot file path in its output. **Read that snapshot file directly — do not call `stably-browser snapshot` again.** Refs (e1, e2, etc.) are only valid from the most recent snapshot. After any command that returns a new snapshot, previous refs are stale.
 
 **Efficient workflow:**
-1. Run a command (e.g., `playwright-cli open https://example.com`)
+1. Run a command (e.g., `stably-browser open https://example.com`)
 2. Read the snapshot `.yml` file from the command output
 3. Use the refs from that file immediately for the next interaction
 
-Only use `playwright-cli snapshot` when you need to re-inspect the page without performing any action.
+Only use `stably-browser snapshot` when you need to re-inspect the page without performing any action.
 
-For large pages, the snapshot `.yml` file may be too large for the Read tool. Use `Grep` to search within the `.playwright-cli/` directory for specific elements.
+For large pages, the snapshot `.yml` file may be too large for the Read tool. Use `Grep` to search within the `.stably-browser/` directory for specific elements.

package/dist/stably-plugin-cli/skills/bulk-test-handling/SKILL.md

@@ -73,7 +73,7 @@ Keep the user informed:
 
 ### Between Tests (Browser Reset)
 
-**CRITICAL:** When verifying independent tests, run `playwright-cli close` after each `run-test` call before starting the next test. Browser state (cookies, auth, localStorage) persists between runs, causing cascading failures if not reset. **`playwright-cli close` must be its own separate Bash call** — do NOT chain it with other commands (e.g., `close; run-test`). The browser is only fully terminated after the Bash command finishes.
+**CRITICAL:** When verifying independent tests, run `stably-browser close` after each `run-test` call before starting the next test. Browser state (cookies, auth, localStorage) persists between runs, causing cascading failures if not reset. **`stably-browser close` must be its own separate Bash call** — do NOT chain it with other commands (e.g., `close; run-test`). The browser is only fully terminated after the Bash command finishes.
 
 ### Between Batches - Check Your System Prompt
 

package/dist/stably-plugin-cli/skills/debugging-test-failures/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: debugging-test-failures
-description: Guide for debugging test execution issues including assertion failures, playwright-cli errors, test setup problems, browser errors, and flaky tests. Use when tests fail, playwright-cli fails, browser setup fails, or tests are flaky. Triggers on test failure, debug, playwright-cli error, test won't run, setup failed, CDP error, flaky test, timeout.
+description: Guide for debugging test execution issues including assertion failures, stably-browser errors, test setup problems, browser errors, and flaky tests. Use when tests fail, stably-browser fails, browser setup fails, or tests are flaky. Triggers on test failure, debug, stably-browser error, test won't run, setup failed, CDP error, flaky test, timeout.
 ---
 
 # Debugging Test Failures
@@ -55,9 +55,9 @@ Five types of issues cause test failures:
 
 **In `fix` mode**: Delegate browser-based exploration to the `debug-worker` subagent.
 
-**In `single`, `build`, `chat` modes**: Run `playwright-cli run-test` directly (no debug subagent available). Browser persists after test runs for inspection via `playwright-cli snapshot`.
+**In `single`, `build`, `chat` modes**: Run `stably-browser run-test` directly (no debug subagent available). Browser persists after test runs for inspection via `stably-browser snapshot`.
 
-**IMPORTANT:** When verifying multiple independent tests, run `playwright-cli close` between each `run-test` call. Stale browser state (cookies, auth sessions, localStorage) from one test will contaminate the next, causing cascading failures — especially at login. **`playwright-cli close` must be its own separate Bash call** — do NOT chain it with other commands (e.g., `close; run-test`). The browser is only fully terminated after the Bash command finishes.
+**IMPORTANT:** When verifying multiple independent tests, run `stably-browser close` between each `run-test` call. Stale browser state (cookies, auth sessions, localStorage) from one test will contaminate the next, causing cascading failures — especially at login. **`stably-browser close` must be its own separate Bash call** — do NOT chain it with other commands (e.g., `close; run-test`). The browser is only fully terminated after the Bash command finishes.
 
 ### When to Use Subagents
 
@@ -74,7 +74,7 @@ Five types of issues cause test failures:
 
 ## Debugging Workflow
 
-1. **Run the test** and read the error output from `playwright-cli run-test`
+1. **Run the test** and read the error output from `stably-browser run-test`
 2. **Read `error-context.md`**: On failure, check `test-results/<test-name>/error-context.md`. This is the page accessibility snapshot at the moment of failure — it shows every visible element, their roles, names, and states. This tells you what the page *actually looked like* when things went wrong.
 3. **Classify the failure by symptom:**
 
@@ -94,7 +94,7 @@ Five types of issues cause test failures:
 
 ## When to Open the Browser for Manual Exploration
 
-**Open the browser** (`playwright-cli open` or use the persisted session after `run-test`) when:
+**Open the browser** (`stably-browser open` or use the persisted session after `run-test`) when:
 - The error-context doesn't explain the failure — you can see the page state but not *why* the selector doesn't match
 - You need to discover interactive behavior (dropdowns, modals, hover states, animations) that a static snapshot can't capture
 - You're writing or rewriting a test for a flow you haven't seen before
@@ -117,17 +117,17 @@ Five types of issues cause test failures:
 
 ### Use `run-code` to Debug Locators Interactively
 
-**If a locator fails on the first `run-test`, don't immediately retry `run-test`.** Open the browser and test the locator interactively with `playwright-cli run-code` — it gives results in seconds instead of waiting for a full test run (~2 minutes).
+**If a locator fails on the first `run-test`, don't immediately retry `run-test`.** Open the browser and test the locator interactively with `stably-browser run-code` — it gives results in seconds instead of waiting for a full test run (~2 minutes).
 
 ```bash
 # Test a locator and see what it actually returns
-playwright-cli run-code "async page => {
+stably-browser run-code "async page => {
   const el = page.getByRole('button', { name: 'Submit' });
   return { count: await el.count(), text: await el.first().textContent() };
 }"
 
 # Explore DOM structure around an element
-playwright-cli run-code "async page => {
+stably-browser run-code "async page => {
   let el = page.getByText('Filters', { exact: true });
   for (let i = 1; i <= 5; i++) {
     el = el.locator('..');
@@ -162,12 +162,12 @@ If you encounter `browserType.connectOverCDP` errors like "Target page has been
 This is a stale browser session issue, NOT a test or config problem.
 
 **Fix:**
-1. Run `playwright-cli close` to stop the current browser session
-2. Retry your operation — `playwright-cli open` will start a fresh browser
+1. Run `stably-browser close` to stop the current browser session
+2. Retry your operation — `stably-browser open` will start a fresh browser
 
 ## Empty run-test Output
 
-If `playwright-cli run-test` returns empty/no output (no pass, no fail, no error):
+If `stably-browser run-test` returns empty/no output (no pass, no fail, no error):
 
 This is NOT a tool malfunction. Empty output means zero tests matched the project filters.