playwright-e2e-mcp 0.6.1 → 0.8.0

package/dist/tools/probe-script.js

@@ -446,26 +446,111 @@ async function attachLocators(page, elements, budget, keep) {
 
 /* ---------------- page actions (reach a state before inspecting) ---------------- */
 
+/* save-login: {{env:NAME}} and {{totp}} in fill values. The values come
+   in through this child's environment, never through the config file, and
+   a TOTP code is generated at the moment it is typed. */
+function totpCode(t, atMs) {
+  const crypto = require('node:crypto');
+  const counter = Math.floor(atMs / 1000 / t.period);
+  const msg = Buffer.alloc(8);
+  msg.writeUInt32BE(Math.floor(counter / 0x100000000), 0);
+  msg.writeUInt32BE(counter % 0x100000000, 4);
+  const h = crypto.createHmac(t.algorithm.toLowerCase(), Buffer.from(t.key, 'hex')).update(msg).digest();
+  const o = h[h.length - 1] & 0x0f;
+  const bin = ((h[o] & 0x7f) << 24) | (h[o + 1] << 16) | (h[o + 2] << 8) | h[o + 3];
+  return String(bin % Math.pow(10, t.digits)).padStart(t.digits, '0');
+}
+
+async function fillValue(raw) {
+  const text = raw || '';
+  if (text.indexOf('{{') < 0) return text;
+  const values = JSON.parse(process.env.PW_MCP_FILL_VALUES || '{}');
+  const totp = process.env.PW_MCP_TOTP ? JSON.parse(process.env.PW_MCP_TOTP) : null;
+  if (totp && /\{\{\s*totp\s*\}\}/.test(text)) {
+    // A code with under 3 seconds left may expire before the form is sent.
+    const left = totp.period - (Math.floor(Date.now() / 1000) % totp.period);
+    if (left < 3) await new Promise((resolve) => setTimeout(resolve, left * 1000 + 200));
+  }
+  return text.replace(/\{\{\s*(totp|env:([A-Za-z0-9_]+))\s*\}\}/g, (m, all, name) => {
+    if (all === 'totp') {
+      if (!totp) throw new Error('{{totp}} needs the totp option');
+      return totpCode(totp, Date.now());
+    }
+    if (!Object.prototype.hasOwnProperty.call(values, name)) throw new Error('No value for {{env:' + name + '}}');
+    return values[name];
+  });
+}
+
+// Find the tab a switchTab step names: 'last' (default), 'first', a 1-based
+// number, or text the tab's URL or title contains. Popups open
+// asynchronously, so keep looking until the step's timeout.
+async function findTab(context, want, timeout) {
+  const target = String(want == null || want === '' ? 'last' : want).trim();
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    const pages = context.pages().filter((p) => !p.isClosed());
+    let found = null;
+    if (target === 'last') found = pages.length > 1 ? pages[pages.length - 1] : null;
+    else if (target === 'first') found = pages[0] || null;
+    else if (/^\d+$/.test(target)) found = pages[Number(target) - 1] || null;
+    else {
+      const needle = target.toLowerCase();
+      for (const p of pages) {
+        let title = '';
+        try { title = await p.title(); } catch (err) { /* navigating */ }
+        if (p.url().toLowerCase().indexOf(needle) >= 0 || title.toLowerCase().indexOf(needle) >= 0) { found = p; break; }
+      }
+    }
+    if (found) return found;
+    if (Date.now() >= deadline) {
+      const open = [];
+      for (const p of pages) open.push(p.url());
+      throw new Error('No tab matches "' + target + '"; open tabs: ' + (open.length ? open.join(', ') : 'none'));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+
+// Every open tab, for the tool output when an action opened more than one.
+async function listTabs(context, active) {
+  const tabs = [];
+  for (const p of context.pages()) {
+    if (p.isClosed()) continue;
+    let title = '';
+    try { title = await p.title(); } catch (err) { /* navigating */ }
+    tabs.push({ url: p.url(), title: String(title).slice(0, 200), active: p === active });
+  }
+  return tabs;
+}
+
 async function runActions(page, actions, timeout) {
   const done = [];
+  let current = page;
   for (let i = 0; i < actions.length; i += 1) {
     const a = actions[i];
     const label = 'step ' + (i + 1) + ' (' + (a.label || a.type) + ')';
     try {
-      const loc = a.locator ? resolveChain(page, a.locator) : null;
+      if (a.type === 'switchTab') {
+        current = await findTab(current.context(), a.value, timeout);
+        await current.bringToFront().catch(() => undefined);
+        await current.waitForLoadState('domcontentloaded', { timeout: timeout }).catch(() => undefined);
+        done.push(label);
+        continue;
+      }
+      const loc = a.locator ? resolveChain(current, a.locator) : null;
       switch (a.type) {
-        case 'goto': await page.goto(a.url, { waitUntil: cfg.waitUntil || 'domcontentloaded', timeout: timeout }); break;
+        case 'goto': await current.goto(a.url, { waitUntil: cfg.waitUntil || 'domcontentloaded', timeout: timeout }); break;
         case 'click': await loc.click({ timeout: timeout }); break;
         case 'dblclick': await loc.dblclick({ timeout: timeout }); break;
         case 'hover': await loc.hover({ timeout: timeout }); break;
-        case 'fill': await loc.fill(a.value || '', { timeout: timeout }); break;
-        case 'press': if (loc) await loc.press(a.value, { timeout: timeout }); else await page.keyboard.press(a.value); break;
+        case 'fill': await loc.fill(cfg.mode === 'login' ? await fillValue(a.value) : (a.value || ''), { timeout: timeout }); break;
+        case 'press': if (loc) await loc.press(a.value, { timeout: timeout }); else await current.keyboard.press(a.value); break;
         case 'check': await loc.check({ timeout: timeout }); break;
         case 'uncheck': await loc.uncheck({ timeout: timeout }); break;
         case 'select': await loc.selectOption(a.value, { timeout: timeout }); break;
         case 'wait':
           if (loc) await loc.first().waitFor({ state: 'visible', timeout: timeout });
-          else await page.waitForTimeout(Math.min(a.ms || 500, 10000));
+          else await current.waitForTimeout(Math.min(a.ms || 500, 10000));
           break;
         default: throw new Error('Unknown action type ' + a.type);
       }
@@ -474,7 +559,7 @@ async function runActions(page, actions, timeout) {
       const message = err && err.message ? err.message : String(err);
       const callLog = callLogOf(message);
       let where = '';
-      try { where = page.url(); } catch (urlErr) { /* page gone */ }
+      try { where = current.url(); } catch (urlErr) { /* page gone */ }
       const wrapped = new Error('Action ' + label + ' failed: ' + message.split('\n')[0] + (/intercepts pointer events/.test(callLog) ? ' (another element intercepts pointer events)' : ''));
       wrapped.actionsDone = done;
       wrapped.callLog = callLog;
@@ -482,7 +567,7 @@ async function runActions(page, actions, timeout) {
       throw wrapped;
     }
   }
-  return done;
+  return { done: done, page: current };
 }
 
 /* ---------------- performance (mode: perf) ---------------- */
@@ -712,6 +797,18 @@ function summariseRequests(requests, timings, pageUrl) {
     if (recording) contextOptions.recordHar = { path: cfg.har.path, urlFilter: cfg.har.url, mode: 'minimal' };
     const context = await browser.newContext(contextOptions);
     openContext = context;
+    // blockWrites: registered first, so it runs last, after the HAR replay
+    // and every mock below have had their chance to answer.
+    const blockedWrites = { total: 0, requests: [] };
+    if (cfg.blockWrites && !cfg.snapshotHtmlPath) {
+      await context.route('**/*', (route) => {
+        const method = route.request().method();
+        if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return route.fallback();
+        blockedWrites.total += 1;
+        if (blockedWrites.requests.length < 20) blockedWrites.requests.push({ method: method, url: route.request().url() });
+        return route.abort('blockedbyclient');
+      });
+    }
     // Replay goes first so the network mocks below, registered later, win.
     if (cfg.har && cfg.har.mode === 'replay' && !cfg.snapshotHtmlPath) {
       await context.routeFromHAR(cfg.har.path, { url: cfg.har.url, notFound: cfg.har.notFound || 'abort' });
@@ -737,7 +834,7 @@ function summariseRequests(requests, timings, pageUrl) {
     }
 
     if (cfg.mode === 'perf') await context.addInitScript(perfInit);
-    const page = await context.newPage();
+    let page = await context.newPage();
 
     // perf: count bytes per request over CDP (cross-origin sizes included)
     // and apply CPU / network throttling before the first byte.
@@ -764,12 +861,17 @@ function summariseRequests(requests, timings, pageUrl) {
     }
 
     const consoleMessages = [];
-    page.on('console', (msg) => {
-      if (consoleMessages.length < 50) consoleMessages.push({ type: msg.type(), text: String(msg.text()).slice(0, 300) });
-    });
-    page.on('pageerror', (err) => {
-      if (consoleMessages.length < 50) consoleMessages.push({ type: 'pageerror', text: String(err).slice(0, 300) });
-    });
+    // Popups and new tabs report their console too.
+    const watchConsole = (p) => {
+      p.on('console', (msg) => {
+        if (consoleMessages.length < 50) consoleMessages.push({ type: msg.type(), text: String(msg.text()).slice(0, 300) });
+      });
+      p.on('pageerror', (err) => {
+        if (consoleMessages.length < 50) consoleMessages.push({ type: 'pageerror', text: String(err).slice(0, 300) });
+      });
+    };
+    watchConsole(page);
+    context.on('page', watchConsole);
 
     if (cfg.snapshotHtmlPath) {
       // A DOM snapshot from a trace: render it with every request blocked,
@@ -783,7 +885,9 @@ function summariseRequests(requests, timings, pageUrl) {
       // perf: let late images, fonts and shifts land before anything else.
       if (cfg.mode === 'perf' && cfg.settleMs) await page.waitForTimeout(cfg.settleMs);
       if (cfg.actions && cfg.actions.length) {
-        actionsDone = await runActions(page, cfg.actions, cfg.actionTimeout || 10000);
+        const ran = await runActions(page, cfg.actions, cfg.actionTimeout || 10000);
+        actionsDone = ran.done;
+        page = ran.page;
         if (cfg.mode === 'perf') {
           await page.waitForLoadState('load', { timeout: cfg.waitTimeout || 5000 }).catch(() => undefined);
           await page.waitForTimeout(Math.min(cfg.settleMs || 1000, 2000));
@@ -791,6 +895,64 @@ function summariseRequests(requests, timings, pageUrl) {
       }
     }
 
+    if (cfg.mode === 'login') {
+      // Check the session (after logging in, or a saved one), then save it.
+      const v = cfg.loginVerify || null;
+      let verified = null;
+      let verifyNote = '';
+      if (v) {
+        if (v.url) {
+          const resp = await page.goto(v.url, { waitUntil: cfg.waitUntil || 'domcontentloaded', timeout: cfg.gotoTimeout || 15000 });
+          if (resp) httpStatus = resp.status();
+        }
+        verified = true;
+        if (v.visible) {
+          try {
+            await resolveChain(page, v.visible).first().waitFor({ state: 'visible', timeout: cfg.waitTimeout || 10000 });
+          } catch (waitErr) {
+            verified = false;
+            verifyNote = 'the signed-in marker did not appear';
+          }
+        }
+        if (verified && v.notUrl && page.url().indexOf(v.notUrl) >= 0) {
+          verified = false;
+          verifyNote = 'the page went to ' + page.url();
+        }
+      }
+      const state = await context.storageState();
+      const now = Date.now() / 1000;
+      const expiries = state.cookies.map((c) => c.expires).filter((e) => e > 0);
+      // The parent writes the file (inside the project, never through a symlink).
+      const keep = !cfg.loginCheckOnly && verified !== false;
+      send({
+        ok: true,
+        data: {
+          elementCount: 0,
+          matchCount: 0,
+          elements: [],
+          finalUrl: page.url(),
+          title: await page.title(),
+          actionsDone: actionsDone,
+          routeHits: routeHits,
+          blockedWrites: blockedWrites.total ? blockedWrites : undefined,
+          httpStatus: httpStatus,
+          durationMs: Date.now() - cfg.startedAt,
+          login: {
+            verified: verified,
+            verifyNote: verifyNote,
+            state: keep ? state : undefined,
+            cookies: state.cookies.length,
+            sessionCookies: state.cookies.length - expiries.length,
+            origins: state.origins.length,
+            firstExpiry: expiries.length ? Math.min.apply(null, expiries) : null,
+            expired: expiries.filter((e) => e <= now).length,
+          },
+        },
+      });
+      await closeBrowser();
+      process.exit(0);
+    }
+
     if (cfg.mode === 'screenshot') {
       if (cfg.selectorChain) {
         await resolveChain(page, cfg.selectorChain).first().screenshot({ path: cfg.screenshotPath });
@@ -804,11 +966,13 @@ function summariseRequests(requests, timings, pageUrl) {
           title: await page.title(),
           finalUrl: page.url(),
           viewport: page.viewportSize() || { width: 1280, height: 720 },
+          tabs: context.pages().length > 1 ? await listTabs(context, page) : undefined,
           elementCount: 0,
           matchCount: 0,
           elements: [],
           actionsDone: actionsDone,
           routeHits: routeHits,
+          blockedWrites: blockedWrites.total ? blockedWrites : undefined,
           httpStatus: httpStatus,
           durationMs: Date.now() - cfg.startedAt,
         },
@@ -1005,7 +1169,9 @@ function summariseRequests(requests, timings, pageUrl) {
 
     data.consoleMessages = consoleMessages;
     data.actionsDone = actionsDone;
+    if (context.pages().length > 1) data.tabs = await listTabs(context, page);
     data.routeHits = routeHits;
+    if (blockedWrites.total) data.blockedWrites = blockedWrites;
     data.finalUrl = data.finalUrl || page.url();
     data.httpStatus = httpStatus;
     data.durationMs = Date.now() - cfg.startedAt;

package/dist/tools/probe-script.js.map

@@ -1 +1 @@
-{"version":3,"file":"probe-script.js","sourceRoot":"","sources":["../../src/tools/probe-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAs+BrC,CAAC"}
+{"version":3,"file":"probe-script.js","sourceRoot":"","sources":["../../src/tools/probe-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4oCrC,CAAC"}

package/dist/tools/quarantine.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Tool — quarantine: keep a flaky test running and reported while its
+ * failures stop blocking the build, with an owner, a reason and an expiry
+ * date (default 14 days, at most 90). run-test and the `ci` command read
+ * the list: a quarantined failure is reported but does not fail the run;
+ * once the entry expires it blocks again.
+ */
+import { z } from 'zod';
+import type { ToolContext, ToolResponse } from '../types/index.js';
+declare const quarantineInput: z.ZodObject<{
+    action: z.ZodOptional<z.ZodEnum<{
+        add: "add";
+        list: "list";
+        remove: "remove";
+    }>>;
+    test: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    index: z.ZodOptional<z.ZodNumber>;
+    owner: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    days: z.ZodOptional<z.ZodNumber>;
+    projectRoot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type QuarantineInput = z.infer<typeof quarantineInput>;
+export declare const quarantineSchema: z.ZodObject<{
+    action: z.ZodOptional<z.ZodEnum<{
+        add: "add";
+        list: "list";
+        remove: "remove";
+    }>>;
+    test: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    index: z.ZodOptional<z.ZodNumber>;
+    owner: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    days: z.ZodOptional<z.ZodNumber>;
+    projectRoot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const quarantineTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        action: z.ZodOptional<z.ZodEnum<{
+            add: "add";
+            list: "list";
+            remove: "remove";
+        }>>;
+        test: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+        owner: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        days: z.ZodOptional<z.ZodNumber>;
+        projectRoot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    handler: (args: QuarantineInput, ctx: ToolContext) => Promise<ToolResponse>;
+};
+export {};

package/dist/tools/quarantine.js

@@ -0,0 +1,133 @@
+/**
+ * Tool — quarantine: keep a flaky test running and reported while its
+ * failures stop blocking the build, with an owner, a reason and an expiry
+ * date (default 14 days, at most 90). run-test and the `ci` command read
+ * the list: a quarantined failure is reported but does not fail the run;
+ * once the entry expires it blocks again.
+ */
+import { z } from 'zod';
+import { PlaywrightMcpError } from '../types/index.js';
+import { normalizePath, relativeToRoot, sanitizeUserPath } from '../utils/path-utils.js';
+import { addDays, DEFAULT_QUARANTINE_DAYS, isExpired, matchesEntry, MAX_QUARANTINE_DAYS, QUARANTINE_FILE, readQuarantine, today, writeQuarantine, } from '../utils/quarantine.js';
+import { readHistory, testStats } from '../utils/run-history.js';
+import { guard, markdownCell, resolveProjectRoot, toolText } from './shared.js';
+const quarantineInput = z.object({
+    action: z.enum(['list', 'add', 'remove']).optional().describe("'list' (default), 'add' or 'remove'"),
+    test: z
+        .string()
+        .optional()
+        .describe("The test as 'file › title' (as get-failure and analyze-history print it), or use file + title"),
+    file: z.string().optional().describe('Spec file, relative to the project'),
+    title: z.string().optional().describe("Test title, or its last parts ('Checkout › pays by card')"),
+    index: z.number().int().min(1).optional().describe('add: the Nth failure of the last run instead of test/file/title'),
+    owner: z.string().min(1).max(80).optional().describe('add: who will fix it (name or @handle)'),
+    reason: z.string().min(3).max(300).optional().describe('add: why it is flaky, or the issue link'),
+    days: z.number().int().min(1).max(MAX_QUARANTINE_DAYS).optional().describe(`add: how long it counts (default ${DEFAULT_QUARANTINE_DAYS}, max ${MAX_QUARANTINE_DAYS})`),
+    projectRoot: z.string().optional().describe('Project directory (default: server root)'),
+});
+export const quarantineSchema = quarantineInput;
+function target(args, root, ctx) {
+    if (args.index !== undefined) {
+        const last = ctx.store.lastRun;
+        const failure = last?.projectRoot === root ? last.result.failures[args.index - 1] : undefined;
+        if (!failure) {
+            throw new PlaywrightMcpError(`No failure #${args.index} in the last run`, 'INVALID_INPUT', {
+                hint: 'Run the tests with run-test first, or name the test with test or file + title.',
+            });
+        }
+        return { file: failure.file, title: withoutFilePrefix(failure.file, failure.title) };
+    }
+    let file = args.file;
+    let title = args.title;
+    if (args.test) {
+        const at = args.test.indexOf(' › ');
+        if (at < 0)
+            throw new PlaywrightMcpError(`test must look like 'file › title': ${args.test}`, 'INVALID_INPUT');
+        file = args.test.slice(0, at);
+        title = args.test.slice(at + 3).replace(/ \[[^\]]+\]$/, '');
+    }
+    if (!file || !title) {
+        throw new PlaywrightMcpError('Name the test', 'INVALID_INPUT', { hint: "Pass test ('tests/cart.spec.ts › adds an item'), file + title, or index." });
+    }
+    const rel = relativeToRoot(root, sanitizeUserPath(normalizePath(file), root));
+    return { file: rel, title: withoutFilePrefix(rel, title.trim()) };
+}
+/** Reported titles start with the spec's file name ('cart.spec.ts › adds'); the entry keeps the rest. */
+function withoutFilePrefix(file, title) {
+    const prefix = `${file.split('/').pop()} › `;
+    return title.startsWith(prefix) ? title.slice(prefix.length) : title;
+}
+/** The entry for this test, however much of the title path either side names. */
+function findEntry(entries, test) {
+    return entries.find((e) => matchesEntry(e, test) || matchesEntry({ ...e, title: test.title }, { file: e.file, title: e.title }));
+}
+function renderList(entries, note) {
+    const lines = [];
+    if (note)
+        lines.push(note, '');
+    if (entries.length === 0) {
+        lines.push('## 🧊 Quarantine is empty', '', 'Add a flaky test with `action: "add"`, an owner and a reason. Its failures stop blocking runs until the entry expires.');
+        return lines.join('\n');
+    }
+    const expired = entries.filter((e) => isExpired(e));
+    lines.push(`## 🧊 ${entries.length} quarantined test${entries.length === 1 ? '' : 's'}${expired.length ? ` · ⏰ ${expired.length} expired` : ''}`, '');
+    lines.push('| Test | Owner | Until | Reason |', '| --- | --- | --- | --- |');
+    for (const e of entries) {
+        lines.push(`| \`${markdownCell(e.file)}\` › ${markdownCell(e.title)} | ${markdownCell(e.owner)} | ${isExpired(e) ? `⏰ ${e.until}` : e.until} | ${markdownCell(e.reason)} |`);
+    }
+    lines.push('', `Stored in \`${QUARANTINE_FILE}\`: commit it so CI and the team use the same list. Expired entries block again.`);
+    return lines.join('\n');
+}
+export const quarantineTool = {
+    name: 'quarantine',
+    description: "Quarantine flaky tests: they keep running and being reported, but their failures stop failing run-test and the ci command until the entry expires (default 14 days, max 90). add needs owner and reason; list shows what is quarantined and what expired; remove ends it. Stored in playwright-quarantine.json (commit it).",
+    inputSchema: quarantineSchema,
+    handler: async (args, ctx) => guard('quarantine', async () => {
+        const root = await resolveProjectRoot(args.projectRoot, ctx);
+        const action = args.action ?? 'list';
+        const list = await readQuarantine(root);
+        if (action === 'list') {
+            return toolText(renderList(list.entries), { status: 'listed', total: list.entries.length });
+        }
+        if (ctx.restricted) {
+            throw new PlaywrightMcpError('Changing the quarantine is not available on this server', 'INVALID_PATH', {
+                hint: 'It writes playwright-quarantine.json in the project. Run the server locally.',
+            });
+        }
+        const test = target(args, root, ctx);
+        const existing = findEntry(list.entries, test);
+        if (action === 'remove') {
+            if (!existing) {
+                return toolText(renderList(list.entries, `> Nothing to remove: \`${test.file}\` › ${test.title} is not quarantined.`), { status: 'unchanged', total: list.entries.length });
+            }
+            list.entries = list.entries.filter((e) => e !== existing);
+            await writeQuarantine(root, list);
+            return toolText(renderList(list.entries, `> ✅ Removed \`${existing.file}\` › ${existing.title}: its failures block runs again.`), { status: 'removed', total: list.entries.length });
+        }
+        if (!args.owner || !args.reason) {
+            throw new PlaywrightMcpError('add needs owner and reason', 'INVALID_INPUT', {
+                hint: 'A quarantine without an owner is a skip nobody fixes. Name who will fix it and why it is flaky (or an issue link).',
+            });
+        }
+        const days = args.days ?? DEFAULT_QUARANTINE_DAYS;
+        const entry = {
+            file: test.file,
+            title: test.title,
+            owner: args.owner.trim(),
+            reason: args.reason.trim(),
+            until: addDays(today(), days),
+            added: existing?.added ?? today(),
+        };
+        list.entries = [...list.entries.filter((e) => e !== existing), entry];
+        await writeQuarantine(root, list);
+        // How unstable has it been? The local history answers if it has the test.
+        const history = await readHistory(root, 50).catch(() => []);
+        const stats = testStats(history).find((s) => matchesEntry(entry, s));
+        const evidence = stats
+            ? `\n\n**History:** \`${stats.strip}\` · ${Math.round(stats.failRate * 100)}% of the last ${stats.runs} runs failed or needed a retry.`
+            : '';
+        const note = `> ✅ ${existing ? 'Extended' : 'Quarantined'} \`${entry.file}\` › ${entry.title} until ${entry.until} (owner ${entry.owner}). It still runs; its failures no longer fail the run.${evidence}`;
+        return toolText(renderList(list.entries, note), { status: existing ? 'extended' : 'added', total: list.entries.length });
+    }),
+};
+//# sourceMappingURL=quarantine.js.map

package/dist/tools/quarantine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quarantine.js","sourceRoot":"","sources":["../../src/tools/quarantine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACzF,OAAO,EACL,OAAO,EACP,uBAAuB,EACvB,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,KAAK,EACL,eAAe,GAChB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEhF,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,qCAAqC,CAAC;IACpG,IAAI,EAAE,CAAC;SACJ,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,+FAA+F,CAAC;IAC5G,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oCAAoC,CAAC;IAC1E,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2DAA2D,CAAC;IAClG,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,iEAAiE,CAAC;IACrH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IAC9F,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IACjG,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oCAAoC,uBAAuB,SAAS,mBAAmB,GAAG,CAAC;IACtK,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0CAA0C,CAAC;CACxF,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,gBAAgB,GAAG,eAAe,CAAC;AAEhD,SAAS,MAAM,CAAC,IAAqB,EAAE,IAAY,EAAE,GAAgB;IACnE,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9F,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,kBAAkB,CAAC,eAAe,IAAI,CAAC,KAAK,kBAAkB,EAAE,eAAe,EAAE;gBACzF,IAAI,EAAE,gFAAgF;aACvF,CAAC,CAAC;QACL,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;IACvF,CAAC;IACD,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACrB,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACvB,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,EAAE,GAAG,CAAC;YAAE,MAAM,IAAI,kBAAkB,CAAC,uCAAuC,IAAI,CAAC,IAAI,EAAE,EAAE,eAAe,CAAC,CAAC;QAC9G,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9B,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QACpB,MAAM,IAAI,kBAAkB,CAAC,eAAe,EAAE,eAAe,EAAE,EAAE,IAAI,EAAE,0EAA0E,EAAE,CAAC,CAAC;IACvJ,CAAC;IACD,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,EAAE,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IAC9E,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,iBAAiB,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;AACpE,CAAC;AAED,yGAAyG;AACzG,SAAS,iBAAiB,CAAC,IAAY,EAAE,KAAa;IACpD,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC;IAC7C,OAAO,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACvE,CAAC;AAED,iFAAiF;AACjF,SAAS,SAAS,CAAC,OAA0B,EAAE,IAAqC;IAClF,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,YAAY,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACnI,CAAC;AAED,SAAS,UAAU,CAAC,OAA0B,EAAE,IAAa;IAC3D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,IAAI;QAAE,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAC/B,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,2BAA2B,EAAE,EAAE,EAAE,wHAAwH,CAAC,CAAC;QACtK,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,KAAK,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,oBAAoB,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,OAAO,CAAC,MAAM,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACtJ,KAAK,CAAC,IAAI,CAAC,mCAAmC,EAAE,2BAA2B,CAAC,CAAC;IAC7E,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,KAAK,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,MAAM,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC/K,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,eAAe,eAAe,kFAAkF,CAAC,CAAC;IACjI,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,6TAA6T;IAC/T,WAAW,EAAE,gBAAgB;IAC7B,OAAO,EAAE,KAAK,EAAE,IAAqB,EAAE,GAAgB,EAAyB,EAAE,CAChF,KAAK,CAAC,YAAY,EAAE,KAAK,IAAI,EAAE;QAC7B,MAAM,IAAI,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC;QACrC,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,CAAC;QACxC,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACtB,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAC9F,CAAC;QACD,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;YACnB,MAAM,IAAI,kBAAkB,CAAC,yDAAyD,EAAE,cAAc,EAAE;gBACtG,IAAI,EAAE,8EAA8E;aACrF,CAAC,CAAC;QACL,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAE/C,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;YACxB,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,0BAA0B,IAAI,CAAC,IAAI,QAAQ,IAAI,CAAC,KAAK,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;YAC9K,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;YAC1D,MAAM,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAClC,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,iBAAiB,QAAQ,CAAC,IAAI,QAAQ,QAAQ,CAAC,KAAK,kCAAkC,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACvL,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,MAAM,IAAI,kBAAkB,CAAC,4BAA4B,EAAE,eAAe,EAAE;gBAC1E,IAAI,EAAE,oHAAoH;aAC3H,CAAC,CAAC;QACL,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,uBAAuB,CAAC;QAClD,MAAM,KAAK,GAAoB;YAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;YACxB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE;YAC1B,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC;YAC7B,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI,KAAK,EAAE;SAClC,CAAC;QACF,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC;QACtE,MAAM,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAElC,0EAA0E;QAC1E,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5D,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QACrE,MAAM,QAAQ,GAAG,KAAK;YACpB,CAAC,CAAC,sBAAsB,KAAK,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC,iBAAiB,KAAK,CAAC,IAAI,iCAAiC;YACvI,CAAC,CAAC,EAAE,CAAC;QACP,MAAM,IAAI,GAAG,OAAO,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,MAAM,KAAK,CAAC,IAAI,QAAQ,KAAK,CAAC,KAAK,UAAU,KAAK,CAAC,KAAK,WAAW,KAAK,CAAC,KAAK,yDAAyD,QAAQ,EAAE,CAAC;QAC3M,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC3H,CAAC,CAAC;CACL,CAAC"}

package/dist/tools/run-test.d.ts

@@ -2,6 +2,7 @@
  * Tool 1 — run-test: execute Playwright tests and report structured
  * results (stats, failures, diagnostics, hints).
  */
+import type { QuarantineSplit } from '../utils/quarantine.js';
 import { z } from 'zod';
 import type { RunTestResult, TestFailure, ToolContext, ToolResponse } from '../types/index.js';
 declare const runTestInput: z.ZodObject<{
@@ -58,7 +59,15 @@ export interface FailureCluster {
  * tests the same way, and is fixed once.
  */
 export declare function clusterFailures(failures: TestFailure[]): FailureCluster[];
-export declare function renderRunResult(result: RunTestResult, root: string): string;
+/**
+ * Did the run pass once quarantined failures are set aside? Only test
+ * failures can be quarantined: a crash, a timeout or a config error still
+ * fails the run.
+ */
+export declare function passesWithQuarantine(result: RunTestResult, split: QuarantineSplit | undefined): boolean;
+/** Split a run's failures by the project's quarantine list; undefined when there is none. */
+export declare function quarantineSplit(root: string, result: RunTestResult): Promise<QuarantineSplit | undefined>;
+export declare function renderRunResult(result: RunTestResult, root: string, split?: QuarantineSplit): string;
 export declare const runTestTool: {
     name: string;
     description: string;

package/dist/tools/run-test.js

@@ -2,10 +2,12 @@
  * Tool 1 — run-test: execute Playwright tests and report structured
  * results (stats, failures, diagnostics, hints).
  */
+import { quarantineLines, readQuarantine, splitFailures } from '../utils/quarantine.js';
 import { z } from 'zod';
 import { PlaywrightMcpError } from '../types/index.js';
 import { detectProject, missingPlaywrightMessage } from '../utils/project-detector.js';
 import { runTests } from '../utils/playwright-runner.js';
+import { detectPytestProject } from '../utils/pytest-runner.js';
 import { normalizePath, relativeToRoot } from '../utils/path-utils.js';
 import { recordRun } from '../utils/run-history.js';
 import { startBackgroundRun } from '../utils/run-registry.js';
@@ -113,15 +115,38 @@ function renderFailures(failures) {
     }
     return lines;
 }
-export function renderRunResult(result, root) {
+/**
+ * Did the run pass once quarantined failures are set aside? Only test
+ * failures can be quarantined: a crash, a timeout or a config error still
+ * fails the run.
+ */
+export function passesWithQuarantine(result, split) {
+    if (result.ok)
+        return true;
+    if (!split || split.quarantined.length === 0 || split.blocking.length > 0)
+        return false;
+    return !result.timedOut && !result.errorKind && !result.partial && !result.failuresTruncated;
+}
+/** Split a run's failures by the project's quarantine list; undefined when there is none. */
+export async function quarantineSplit(root, result) {
+    if (result.failures.length === 0)
+        return undefined;
+    const list = await readQuarantine(root).catch(() => undefined);
+    if (!list || list.entries.length === 0)
+        return undefined;
+    return splitFailures(result.failures, list);
+}
+export function renderRunResult(result, root, split) {
     const flakyCount = result.stats?.flaky ?? 0;
     const status = result.ok
         ? flakyCount > 0
             ? `✅ PASSED (${flakyCount} flaky)`
             : '✅ PASSED'
-        : result.timedOut
-            ? '⏱️ KILLED (timeout)'
-            : '❌ FAILED';
+        : passesWithQuarantine(result, split)
+            ? `✅ PASSED (${split.quarantined.length} quarantined failure${split.quarantined.length === 1 ? '' : 's'})`
+            : result.timedOut
+                ? '⏱️ KILLED (timeout)'
+                : '❌ FAILED';
     const lines = [`## Playwright run — ${status}`, ''];
     lines.push(`**Command:** \`${result.command}\``);
     const meta = [
@@ -149,6 +174,8 @@ export function renderRunResult(result, root) {
     if (flakyCount > 0) {
         lines.push(`> ⚠️ **${flakyCount} flaky test(s)** failed first but passed on the automatic retry. Re-run to confirm they are stable before trusting them.`, '');
     }
+    if (split)
+        lines.push(...quarantineLines(split));
     if (result.failures.length > 0) {
         const more = result.failuresTruncated ? ' (showing the first ones)' : '';
         lines.push(`### ❌ ${result.failures.length} failing test(s)${more}`, '');
@@ -175,7 +202,7 @@ export const runTestTool = {
     handler: async (args, ctx) => guard('run-test', async () => {
         const root = await resolveProjectRoot(args.projectRoot, ctx);
         const detection = await detectProject(root);
-        if (!detection.hasPlaywright) {
+        if (!detection.hasPlaywright && !(await detectPytestProject(root))) {
             const { message, hint } = missingPlaywrightMessage(detection);
             return toolError('NO_PLAYWRIGHT', message, hint);
         }
@@ -238,7 +265,12 @@ export const runTestTool = {
             durationMs: result.durationMs,
             failures: result.failures.length,
         });
-        return toolText(renderRunResult(result, root), { ok: result.ok, run: runData(result) });
+        const split = await quarantineSplit(root, result);
+        const passed = passesWithQuarantine(result, split);
+        return toolText(renderRunResult(result, root, split), {
+            ok: passed,
+            run: { ...runData(result), ...(split?.quarantined.length ? { quarantined: split.quarantined.length } : {}) },
+        });
     }),
 };
 //# sourceMappingURL=run-test.js.map