@skyramp/mcp 0.4.2-rc.1 → 0.4.2-rc.2

package/build/commands/localDevTestChangesCommand.js

@@ -111,7 +111,7 @@ Fallback service routing inputs from the one-click invocation:
 Three rules apply in fallback mode at all times:
 1. **No hand-written tests or mocks**: do NOT use Write, Edit, or any file-writing tool to create test or mock files manually. ALL test and mock files MUST be produced by Skyramp MCP generation tools (\`skyramp_batch_scenario_test_generation\`, \`skyramp_integration_test_generation\`, \`skyramp_generate_enriched_integration_test\`, \`skyramp_contract_test_generation\`, \`skyramp_mock_generation\`, \`skyramp_batch_mock_generation\`). If a generation tool fails, fix the inputs and retry — do not fall back to writing tests by hand.
 2. **Mock scope**: if the user said "mock all downstream services", "mock all", "mock everything", or "mock all except X", treat all discovered downstream dependencies as selected for mocking (same as passing \`servicesToMock: "all"\`). Do not silently default to the third-party-only policy when the user expressed broad mock intent.
-3. **No pytest fallback**: if \`skyramp_execute_test\` becomes unavailable at any point (tool not found, MCP disconnected, context compaction), stop immediately and ask the user to reconnect the Skyramp MCP server. Do not fall back to \`pytest\`, \`python3\`, or any direct runtime — doing so bypasses mock deployment and produces results that cannot be trusted as Skyramp-validated.
+3. **Prefer skyramp_execute_test**: run tests through \`skyramp_execute_test\` rather than the repository's test runner directly: the server records the run, and a run it did not record cannot appear in the report.
 
 ---
 

package/build/commands/recommendTestsAndExecuteCommand.js

@@ -1,3 +1,4 @@
+import { RUN_TEST_COMMAND_RULES } from "../skills/runTestSkill.js";
 /**
  * Predefined One-Click Command: Recommend tests and generate and execute top recommended tests
  *
@@ -65,7 +66,11 @@ const fullRepoRecommendGenerateExecuteSteps = [
             toolName: "skyramp_execute_test",
             description: "Execute each generated test; resolve token before calling. For each generated test file path returned directly by the generation tools in step 2, invoke this tool with testFile set to that path.",
             inputs: {
-                workspacePath: { source: "user", paramKey: "repositoryPath" },
+                commandOverride: {
+                    source: "literal",
+                    value: `the shell command that runs this one test file with the repository's own test runner (${RUN_TEST_COMMAND_RULES})`,
+                },
+                cwd: { source: "user", paramKey: "repositoryPath" },
                 language: { source: "literal", value: "from workspace" },
                 testType: {
                     source: "literal",
@@ -75,6 +80,10 @@ const fullRepoRecommendGenerateExecuteSteps = [
                     source: "literal",
                     value: "path to a single generated test file; for each test path returned by generation tools in step 2, call skyramp_execute_test separately with testFile set to that path",
                 },
+                repository: {
+                    source: "literal",
+                    value: "owner/repo of the checkout, from its origin remote",
+                },
                 token: { source: "user", paramKey: "token" },
             },
         },

package/build/commands/testThisEndpointCommand.js

@@ -1,3 +1,4 @@
+import { RUN_TEST_COMMAND_RULES } from "../skills/runTestSkill.js";
 /**
  * Predefined One-Click Command: Test this endpoint
  *
@@ -73,7 +74,11 @@ const comprehensivelyTestGivenEndpointSteps = [
             toolName: "skyramp_execute_test",
             description: "Execute each generated test; resolve token before calling. For each generated test file path returned directly by the generation tools in step 3, invoke this tool with testFile set to that path.",
             inputs: {
-                workspacePath: { source: "user", paramKey: "repositoryPath" },
+                commandOverride: {
+                    source: "literal",
+                    value: `the shell command that runs this one test file with the repository's own test runner (${RUN_TEST_COMMAND_RULES})`,
+                },
+                cwd: { source: "user", paramKey: "repositoryPath" },
                 language: { source: "literal", value: "from workspace" },
                 testType: {
                     source: "literal",
@@ -83,6 +88,10 @@ const comprehensivelyTestGivenEndpointSteps = [
                     source: "literal",
                     value: "path to a single generated test file; for each test path returned by generation tools in step 3, call skyramp_execute_test separately with testFile set to that path",
                 },
+                repository: {
+                    source: "literal",
+                    value: "owner/repo of the checkout, from its origin remote",
+                },
                 token: { source: "user", paramKey: "token" },
             },
         },
@@ -110,7 +119,11 @@ const comprehensivelyTestGivenEndpointSteps = [
             toolName: "skyramp_execute_test",
             description: "Optionally run existing tests individually; iterate over tests from stateFile and write results back",
             inputs: {
-                workspacePath: { source: "user", paramKey: "repositoryPath" },
+                commandOverride: {
+                    source: "literal",
+                    value: `the shell command that runs this one test file with the repository's own test runner (${RUN_TEST_COMMAND_RULES})`,
+                },
+                cwd: { source: "user", paramKey: "repositoryPath" },
                 testFile: {
                     source: "literal",
                     value: "path from stateFile existingTests array",
@@ -123,6 +136,10 @@ const comprehensivelyTestGivenEndpointSteps = [
                     source: "literal",
                     value: "testType from stateFile existingTests array",
                 },
+                repository: {
+                    source: "literal",
+                    value: "owner/repo of the checkout, from its origin remote",
+                },
                 token: { source: "user", paramKey: "token" },
                 stateFile: { source: "step", stepIndex: 1, outputKey: "stateFile" },
             },

package/build/execution/wrapperConfig.d.ts

@@ -0,0 +1,56 @@
+/** Playwright's `--browser` names the implicit project itself, so the wrapper must not
+ *  declare one: it refuses the flag when the config defines projects. */
+export declare function commandPassesBrowserFlag(command: string): boolean;
+/** The nearest Playwright config at or above the test file, up to the git root of `cwd`. */
+export declare function findRepoPlaywrightConfig(testFile: string, cwd: string): string | undefined;
+/**
+ * A config that imports the repo's own and overlays only:
+ * - `video: "on"`, top level and per project — Playwright has no `--video` flag, and a
+ *   project's `use` overrides the top level.
+ * - a per-run `outputDir`, so two runs in one checkout keep their videos apart.
+ * - `reuseExistingServer: true` on every `webServer` — the app is already running, and
+ *   `!process.env.CI` would refuse its port.
+ * - the file under test appended to a declared `testMatch`. A repository that names its
+ *   tests `*.test.ts` collects no `*.spec.ts`, so the file Skyramp generated is not a
+ *   test to it and Playwright answers "No tests found" whatever the config or filter.
+ *   Only the top level is widened: a project that declares its own `testMatch` keeps it,
+ *   so the file runs once.
+ * - a project named `chromium`, ONLY when the repository declares no projects and the
+ *   command passes no `--browser`. The Skyramp executor always runs
+ *   `--browser=chromium`, which Playwright turns into a project of that name, so every
+ *   baseline it has written is `<stem>-chromium-linux.png`. With neither a project nor
+ *   the flag the host resolves `<stem>-linux.png`, finds no baseline, and writes a fresh
+ *   one instead of comparing -- a visual regression then passes silently.
+ *   The flag case needs nothing: `--browser=firefox` names the project `firefox` by
+ *   itself. Declaring a project there would not help but throw, because Playwright
+ *   refuses `--browser` when the config defines projects (`common/config.js`:
+ *   "Cannot use --browser option when configuration file defines projects").
+ *   See `utils/rebaselineSnapshots.ts` for the layout.
+ * No reporter: the verdict is the exit code.
+ */
+export declare function buildWrapperConfig(opts: {
+    repoConfigBasename?: string;
+    outputDir: string;
+    /** Absolute path of the file this run executes. */
+    testFile?: string;
+    /** True when the command already passes `--browser`, which names the project itself. */
+    commandPassesBrowserFlag: boolean;
+}): string;
+/**
+ * Writes the wrapper beside the config it imports, because Playwright resolves `testDir`,
+ * `globalSetup` and `webServer.cwd` from the config file's directory. A dotfile with a
+ * random suffix: runs cannot collide and `testMatch` cannot collect it.
+ */
+export declare function writeWrapperConfig(opts: {
+    repoConfigPath?: string;
+    /** Where to write when there is no repo config. */
+    fallbackDir: string;
+    outputDir: string;
+    /** Absolute path of the file this run executes. */
+    testFile?: string;
+    /** True when the command already passes `--browser`, which names the project itself. */
+    commandPassesBrowserFlag: boolean;
+}): {
+    path: string;
+    cleanup: () => void;
+};

package/build/execution/wrapperConfig.js

@@ -0,0 +1,155 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { detectGitRoot } from "../utils/gitStaging.js";
+import { samePath } from "../tools/code-refactor/reuse-state.js";
+/** Playwright's own config names, in its probe order (1.59.1 `configLoader.js:314`).
+ *  A missing name silently drops the repo's config. */
+const CONFIG_NAMES = [
+    "playwright.config.ts",
+    "playwright.config.js",
+    "playwright.config.mts",
+    "playwright.config.mjs",
+    "playwright.config.cts",
+    "playwright.config.cjs",
+];
+/** Playwright's `--browser` names the implicit project itself, so the wrapper must not
+ *  declare one: it refuses the flag when the config defines projects. */
+export function commandPassesBrowserFlag(command) {
+    return /(^|\s)--browser(=|\s)/.test(command);
+}
+/** The nearest Playwright config at or above the test file, up to the git root of `cwd`. */
+export function findRepoPlaywrightConfig(testFile, cwd) {
+    const stop = detectGitRoot(cwd);
+    let dir = path.dirname(path.resolve(testFile));
+    for (;;) {
+        for (const name of CONFIG_NAMES) {
+            const candidate = path.join(dir, name);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir || (stop && samePath(dir, stop)))
+            return undefined;
+        dir = parent;
+    }
+}
+/**
+ * A config that imports the repo's own and overlays only:
+ * - `video: "on"`, top level and per project — Playwright has no `--video` flag, and a
+ *   project's `use` overrides the top level.
+ * - a per-run `outputDir`, so two runs in one checkout keep their videos apart.
+ * - `reuseExistingServer: true` on every `webServer` — the app is already running, and
+ *   `!process.env.CI` would refuse its port.
+ * - the file under test appended to a declared `testMatch`. A repository that names its
+ *   tests `*.test.ts` collects no `*.spec.ts`, so the file Skyramp generated is not a
+ *   test to it and Playwright answers "No tests found" whatever the config or filter.
+ *   Only the top level is widened: a project that declares its own `testMatch` keeps it,
+ *   so the file runs once.
+ * - a project named `chromium`, ONLY when the repository declares no projects and the
+ *   command passes no `--browser`. The Skyramp executor always runs
+ *   `--browser=chromium`, which Playwright turns into a project of that name, so every
+ *   baseline it has written is `<stem>-chromium-linux.png`. With neither a project nor
+ *   the flag the host resolves `<stem>-linux.png`, finds no baseline, and writes a fresh
+ *   one instead of comparing -- a visual regression then passes silently.
+ *   The flag case needs nothing: `--browser=firefox` names the project `firefox` by
+ *   itself. Declaring a project there would not help but throw, because Playwright
+ *   refuses `--browser` when the config defines projects (`common/config.js`:
+ *   "Cannot use --browser option when configuration file defines projects").
+ *   See `utils/rebaselineSnapshots.ts` for the layout.
+ * No reporter: the verdict is the exit code.
+ */
+export function buildWrapperConfig(opts) {
+    const outputDir = JSON.stringify(opts.outputDir);
+    const overlay = `outputDir: ${outputDir},`;
+    // Widen only what the repository declared: with no `testMatch`, Playwright's own
+    // default already collects both spellings, and setting one would narrow it.
+    // One chromium project, used by both branches below. The Skyramp executor runs
+    // --browser=chromium, so every baseline it has written is <stem>-chromium-linux.png;
+    // a wrapper with no project resolves <stem>-linux.png and compares against nothing.
+    // A command that passes --browser names the project itself, and Playwright refuses
+    // the flag when the config declares projects, so there it must stay empty.
+    const chromiumProject = (useExpr) => opts.commandPassesBrowserFlag
+        ? ""
+        : `{ name: "chromium", outputDir: ${outputDir}, use: { ...${useExpr}, browserName: "chromium" } }`;
+    const testMatchOverlay = opts.testFile
+        ? `...(base.testMatch ? { testMatch: [...asList(base.testMatch), ${JSON.stringify(opts.testFile)}] } : {}),`
+        : "";
+    if (!opts.repoConfigBasename) {
+        // No repo config: a minimal one, so video still records.
+        return `const config = {
+  testDir: ".",
+  ${overlay}
+  use: { video: "on" },${chromiumProject('{ video: "on" }')
+            ? `\n  projects: [${chromiumProject('{ video: "on" }')}],`
+            : ""}
+};
+
+export default config;
+`;
+    }
+    return `import base from ${JSON.stringify(`./${opts.repoConfigBasename}`)};
+
+const withVideo = (use) => ({ ...(use ?? {}), video: "on" });
+const reuseServer = (server) => ({ ...server, reuseExistingServer: true });
+
+const asList = (m) => (Array.isArray(m) ? m : [m]);
+
+const config = {
+  ...base,
+  ${overlay}
+  ${testMatchOverlay}
+  use: withVideo(base.use),
+  ...(base.webServer
+    ? {
+        webServer: Array.isArray(base.webServer)
+          ? base.webServer.map(reuseServer)
+          : reuseServer(base.webServer),
+      }
+    : {}),
+  ...(Array.isArray(base.projects) && base.projects.length > 0
+    ? {
+        projects: base.projects.map((p) => ({
+          ...p,
+          outputDir: ${outputDir},
+          use: withVideo(p.use),
+        })),
+      }
+    : ${chromiumProject("withVideo(base.use)")
+        ? `{ projects: [${chromiumProject("withVideo(base.use)")}] }`
+        : "{}"}),
+};
+
+export default config;
+`;
+}
+/**
+ * Writes the wrapper beside the config it imports, because Playwright resolves `testDir`,
+ * `globalSetup` and `webServer.cwd` from the config file's directory. A dotfile with a
+ * random suffix: runs cannot collide and `testMatch` cannot collect it.
+ */
+export function writeWrapperConfig(opts) {
+    const dir = opts.repoConfigPath
+        ? path.dirname(opts.repoConfigPath)
+        : opts.fallbackDir;
+    const wrapperPath = path.join(dir, `.skyramp-sut-${crypto.randomBytes(6).toString("hex")}.config.ts`);
+    fs.writeFileSync(wrapperPath, buildWrapperConfig({
+        repoConfigBasename: opts.repoConfigPath
+            ? path.basename(opts.repoConfigPath)
+            : undefined,
+        outputDir: opts.outputDir,
+        testFile: opts.testFile,
+        commandPassesBrowserFlag: opts.commandPassesBrowserFlag,
+    }));
+    return {
+        path: wrapperPath,
+        cleanup: () => {
+            try {
+                fs.rmSync(wrapperPath, { force: true });
+            }
+            catch {
+                // Best effort: never fail the run over cleanup.
+            }
+        },
+    };
+}

package/build/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { runnableLanguagesText } from "./types/TestTypes.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerStartTraceCollectionPrompt } from "./prompts/startTraceCollectionPrompts.js";
 import { registerTraceTool } from "./tools/trace/startTraceCollectionTool.js";
 import { registerTraceStopTool } from "./tools/trace/stopTraceCollectionTool.js";
 import { registerExecuteSkyrampTestTool } from "./tools/executeSkyrampTestTool.js";
-import { registerRunExistingTestsTool } from "./tools/runExistingTestsTool.js";
 import { AUTH_PLACEHOLDER_TOKEN } from "./types/TestTypes.js";
 import { AUTH_CONFLICT_ERROR_MSG } from "./prompts/test-recommendation/recommendationSections.js";
 import { logger } from "./utils/logger.js";
@@ -114,11 +114,12 @@ Use \`skyramp_analyze_changes\` as the single entry point for both test recommen
 1. Call \`skyramp_analyze_changes\` with \`repositoryPath\` and \`scope\` → scans endpoints, computes branch diff, discovers existing tests → returns a \`stateFile\` **and** inline ranked test recommendations.
 2. (Optional) Use the \`skyramp_recommend_tests\` prompt with \`stateFile\` in Cursor/IDE chat for a focused recommendation view.
 
-### Health Analysis (4-step)
+### Health Analysis (5-step)
 1. Call \`skyramp_analyze_changes\` with \`repositoryPath\` and \`scope\` → returns a \`stateFile\`.
-2. Call \`skyramp_analyze_test_health\` with \`stateFile\` → runs drift analysis + health scoring + LLM semantic assessment.
-3. (Optional) Execute tests using \`skyramp_execute_test\` with \`stateFile\` param → validates test status live and writes results back to stateFile for health scoring.
-4. Call \`skyramp_actions\` with \`stateFile\` → executes UPDATE/REGENERATE/ADD recommendations (with execution-aware prioritization if step 3 ran).
+2. Run each external test in ${runnableLanguagesText()} with \`skyramp_execute_test\`, \`phase: "before"\`, and \`stateFile\` → the server runs your command and writes the verdict back to stateFile. The tool takes no other language, and the gate in step 3 does not ask for those.
+3. Call \`skyramp_analyze_test_health\` with \`stateFile\` → runs drift analysis + health scoring + LLM semantic assessment. It refuses until step 2 has run.
+4. (Optional) Run Skyramp-generated tests with \`skyramp_execute_test\` and \`stateFile\` → writes each verdict back for health scoring.
+5. Call \`skyramp_actions\` with \`stateFile\` → executes UPDATE/REGENERATE/ADD recommendations (with execution-aware prioritization if step 4 ran).
 
 After \`skyramp_analyze_changes\`, inspect enriched data via MCP Resources (use the \`sessionId\` returned in the output):
 - \`skyramp://analysis/{sessionId}/summary\` — high-level overview
@@ -241,7 +242,6 @@ if (isLocalDevEnabled()) {
 }
 if (isTestbotEnabled()) {
     infrastructureTools.push(registerSubmitReportTool);
-    infrastructureTools.push(registerRunExistingTestsTool);
     logger.info("Testbot tools enabled via SKYRAMP_FEATURE_TESTBOT");
 }
 infrastructureTools.forEach((registerTool) => registerTool(server));

package/build/playwright/registerPlaywrightTools.js

@@ -7,6 +7,7 @@ import { logger } from "../utils/logger.js";
 import { PlaywrightTraceService, } from "./PlaywrightTraceService.js";
 import { blueprintJsonSpan } from "./blueprintDigest.js";
 import { recordBlueprintCapture, recordBrowserNavigation, } from "./blueprintDigestStore.js";
+import { recordTraceExport } from "./traceExportStore.js";
 let _service = null;
 export function getPlaywrightTraceService() {
     return _service;
@@ -21,6 +22,14 @@ const BLUEPRINT_TOOL = "browser_blueprint";
  * withAssertReminder.
  */
 const NAVIGATE_TOOL = "browser_navigate";
+/**
+ * The one browser tool whose CALL is counted — see traceExportStore.
+ *
+ * The count is what lets `skyramp_submit_report` tell "recorded, and it did not
+ * work" apart from "never recorded". Those two deserve opposite answers, and
+ * without the count the report check can only see the second as the first.
+ */
+const EXPORT_TOOL = "skyramp_export_zip";
 /**
  * The line the agent reads the moment it has reached a page.
  *
@@ -225,6 +234,11 @@ export async function registerPlaywrightTools(server, options) {
                 };
             }
             const result = await _service.callTool(tool.name, params);
+            // Counted BEFORE any early return and REGARDLESS of isError: an export
+            // that failed still cost the agent a recording, and the report gate that
+            // reads this has to be satisfiable by trying. Returns nothing, never throws.
+            if (tool.name === EXPORT_TOOL)
+                recordTraceExport();
             if (isNavigate) {
                 // The destination this server forwarded, so `skyramp_resolve_screen`
                 // can say where the browser actually is without asking the agent.

package/build/playwright/traceExportStore.d.ts

@@ -0,0 +1,22 @@
+/** A run recording more traces than this has a problem no counter fixes; the cap is
+ *  here so a runaway loop cannot grow the number without bound. */
+export declare const MAX_COUNTED_EXPORTS = 100;
+/** How many times the report may be refused for an unrecorded planned UI test.
+ *  The refusal is meant to cost the agent a recording, not the whole run: a
+ *  resubmission that records nothing still advances nothing, and without this cap
+ *  an agent that will not record and a job timeout are the same outcome. */
+export declare const MAX_UI_DELIVERY_REFUSALS = 3;
+/** Record one `skyramp_export_zip` call, or do nothing. NOTHING HERE MAY COST THE
+ *  EXPORT: the payload the agent receives is untouched and every failure is
+ *  swallowed with a log line. */
+export declare function recordTraceExport(): void;
+/** Recording attempts this run. */
+export declare function traceExportAttempts(): number;
+/** Count one refusal and return the new total. */
+export declare function countUiDeliveryRefusal(): number;
+/** Refusals so far, without counting one. */
+export declare function uiDeliveryRefusals(): number;
+/** Test seam. The store is module state keyed by the run; a suite that writes a
+ *  fresh state file per test reseats it anyway, but an explicit reset keeps a test
+ *  that reuses one honest. */
+export declare function resetTraceExportStoreForTests(): void;

package/build/playwright/traceExportStore.js

@@ -0,0 +1,81 @@
+import { currentRunStateFile } from "../utils/AnalysisStateManager.js";
+import { logger } from "../utils/logger.js";
+/** How many times this run called `skyramp_export_zip`, and how many times the
+ *  report was refused for a planned UI test nobody recorded. IN PROCESS, not in the
+ *  state file, for the same reason as the blueprint digests: the only reader shares
+ *  a process with the browser tools, and a read-modify-write per export buys
+ *  nothing. KEYED BY THE RUN, one slot — a new key means the previous run is over.
+ *
+ *  ATTEMPTS, never successes. An export that errored still cost the agent a
+ *  recording, and the gate reading this has to be satisfiable by TRYING: counting
+ *  only successes lets one screen that cannot be recorded refuse the report for the
+ *  rest of the run. */
+let countedRunStateFile;
+let exportAttempts = 0;
+let deliveryRefusals = 0;
+/** A run recording more traces than this has a problem no counter fixes; the cap is
+ *  here so a runaway loop cannot grow the number without bound. */
+export const MAX_COUNTED_EXPORTS = 100;
+/** How many times the report may be refused for an unrecorded planned UI test.
+ *  The refusal is meant to cost the agent a recording, not the whole run: a
+ *  resubmission that records nothing still advances nothing, and without this cap
+ *  an agent that will not record and a job timeout are the same outcome. */
+export const MAX_UI_DELIVERY_REFUSALS = 3;
+/** The slot this run writes to. NOT gated on a resolvable state file: a run whose
+ *  path cannot be resolved still records and still reports, and a counter that
+ *  stayed at zero there made the gate below refuse a report it could never let
+ *  through. `NO_RUN` is one slot like any other — a new key still clears it. */
+const NO_RUN = "<no-run>";
+function reseatRun() {
+    let runStateFile;
+    try {
+        runStateFile = currentRunStateFile() ?? NO_RUN;
+    }
+    catch {
+        runStateFile = NO_RUN;
+    }
+    if (runStateFile !== countedRunStateFile) {
+        countedRunStateFile = runStateFile;
+        exportAttempts = 0;
+        deliveryRefusals = 0;
+    }
+}
+/** Record one `skyramp_export_zip` call, or do nothing. NOTHING HERE MAY COST THE
+ *  EXPORT: the payload the agent receives is untouched and every failure is
+ *  swallowed with a log line. */
+export function recordTraceExport() {
+    try {
+        reseatRun();
+        if (exportAttempts >= MAX_COUNTED_EXPORTS)
+            return;
+        exportAttempts += 1;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        logger.warning(`recordTraceExport failed: ${detail}`);
+    }
+}
+/** Recording attempts this run. */
+export function traceExportAttempts() {
+    reseatRun();
+    return exportAttempts;
+}
+/** Count one refusal and return the new total. */
+export function countUiDeliveryRefusal() {
+    reseatRun();
+    deliveryRefusals += 1;
+    return deliveryRefusals;
+}
+/** Refusals so far, without counting one. */
+export function uiDeliveryRefusals() {
+    reseatRun();
+    return deliveryRefusals;
+}
+/** Test seam. The store is module state keyed by the run; a suite that writes a
+ *  fresh state file per test reseats it anyway, but an explicit reset keeps a test
+ *  that reuses one honest. */
+export function resetTraceExportStoreForTests() {
+    countedRunStateFile = undefined;
+    exportAttempts = 0;
+    deliveryRefusals = 0;
+}

package/build/playwright/traceRecordingPrompt.js

@@ -43,7 +43,8 @@ Then execute in strict order:
 
 - **After every action that changes the page**, call \`browser_snapshot\` before the next interaction — refs become stale after navigation, clicks that trigger page updates, and form submissions.
 - **Iframe content** appears inline in the snapshot — interact with those elements using their refs normally.
-- **Trace deduplication**: if you retry from the start URL, only the last complete attempt is exported.
+- **One recorder, and the export drains it**: every \`browser_*\` call accumulates into ONE buffer, exploration included — whatever you did before the flow is in the trace with it. A successful \`skyramp_export_zip\` writes that buffer, EMPTIES it and closes the browser, so the next recording starts clean. A trace that came out polluted is therefore a reason to record again, not a reason to stop, and the retry costs you one navigation and the flow. Record each test in its own pass: \`browser_navigate\` to the start URL, the flow, export.
+- **Trace deduplication is narrower than it sounds**: a repeated \`browser_navigate\` drops the attempt before it only when it repeats the MOST RECENT \`browser_navigate\`. Clicks and types in between are fine; another navigation is not — a detour through a sign-out page, say, and BOTH attempts are exported. Never rely on it to clean up an exploratory session: export that session to a throwaway path and discard the zip, which leaves the recorder empty for the real one.
 - **No Docker required**: the \`browser_*\` tools run a local browser session managed by the MCP server. Docker is ONLY used by \`skyramp_start_trace_collection\` (manual recording mode). Never suggest or check for Docker when using AI-driven recording.
 ${modularizeNote}
 

package/build/prompts/code-reuse.js

@@ -1,6 +1,6 @@
 import { generateSkyrampHeader, SKYRAMP_UTILS_HEADER } from "../utils/utils.js";
 import { isUtilsReuseEnabled } from "../utils/featureFlags.js";
-import { isModularizeFirstTarget, isPomAwareTarget, } from "../utils/reuseRouting.js";
+import { inlineCallSiteFamily, isModularizeFirstTarget, isPomAwareTarget, } from "../utils/reuseRouting.js";
 import { getPomAwareCodeReusePrompt } from "./pom-aware-code-reuse.js";
 import { NO_SHADOWING_RULE, SELECTOR_OWNING_MODULE_RULE, selectHelperPolicy, } from "./shared-helper-policy.js";
 import { UTILS_LANGUAGE_SPECS } from "../utils/utils-verify/language-spec.js";
@@ -159,31 +159,34 @@ This step MOVES helpers that skyramp_modularization already created — it does
 **IF \`${fileName}\` ALREADY CONTAINS A HELPER FOR ${policy.sameStep}** that differs from what ${testFile} needs only by ${policy.liftableLiterals}: do NOT define a second helper — EXTEND the utils helper by lifting the differing literals to parameters whose defaults are the utils version's current literals (existing call sites stay valid unchanged), then import and call it with this test's values. ${policy.oneHelperRule(fileName)}${policy.structuralNoise ? ` ${policy.structuralNoise}.` : ""} ${NO_SHADOWING_RULE}
 `
         : "";
-    // SKYR-4219: an inline request block is a CALL SITE for an existing helper, not a
+    // SKYR-4219: an inline copy of a step is a CALL SITE for an existing helper, not a
     // helper to move. Without this, a direct-mode sibling (plain literals, no
-    // \`data_override\`/\`uniqueSuffix\`) never meets the scenario-mode helper for the
-    // same request, and a step still inline in the current test never meets the utils
-    // helper — reuse degrades to a no-op in any mixed directory. Explicit test-type
-    // gate, not \`seedsUtils\`: the rule is stated in API terms.
-    const inlineRequestRule = testType === "integration"
-        ? `**INLINE REQUEST BLOCKS ARE CALL SITES, NOT HELPERS.** A request step written inline — one \`client.send_request(...)\` / \`client.sendRequest(...)\` call plus its status-code assertion, not wrapped in a function — is never something to move or author a helper from. But when a helper for the SAME method+path already exists, the block is that helper's near-duplicate (judge it by the API near-duplicate criteria in STEP 4b: same method+path and call structure; differences limited to ${policy.liftableLiterals}): REPLACE the block with a call to the helper, passing the block's own literals as arguments — the status its assertion expected becomes the call's status argument, and that assertion is DELETED, not kept beside the call (the helper asserts it) — and lift anything the helper does not yet take — the block's BODY and the query parameters it sends included, not only the scalars inside them — to a parameter DEFAULTED to the helper's current value, so every existing call site sends what it sent before. The expected status is the one exception to that default: a helper that pins a literal status lifts it to a parameter with NO default, and every existing call site of that helper is updated to pass the literal it pinned. KEEP the block's response variable — \`<same variable> = <helper>(...)\` — so the assertions that read it afterwards are unchanged. A value the block wraps in \`uniqueSuffix(...)\` or routes through \`data_override\` where the helper uses a plain literal (or vice versa) is a LITERAL difference, not a structural one — pass the expression as the argument. A block whose request differs structurally (extra step, different method or path) stays as it is.`
+    // `data_override`/`uniqueSuffix`) never meets the scenario-mode helper for the
+    // same request, a step still inline in the current test never meets the utils
+    // helper, and a browser spec that repeats a helper's action sequence keeps its copy
+    // — reuse degrades to a no-op in any mixed directory. The text is the policy's, in
+    // the kind's own terms; the gate is inlineCallSiteFamily, which the verify pass runs
+    // its sibling scan on, so the rule and the scan cannot drift apart.
+    const inlineCallSiteRule = inlineCallSiteFamily(testType, lang)
+        ? policy.inlineCallSiteRule
         : "";
+    const site = policy.inlineSite;
     // Its own step, placed after 5b: the agent routinely satisfies ${testFile} in STEP 3
     // and jumps straight to verification, never entering STEP 4 — so a sibling rule parked
     // there is never read (measured: eval run u4219b). This is where the shared helper is
     // guaranteed to exist and the agent is guaranteed to still be running.
-    const siblingCallSitesStep = testType === "integration"
-        ? `## STEP 5c: REPLACE INLINE REQUEST BLOCKS IN OTHER SKYRAMP-GENERATED TESTS WITH CALLS TO \`${fileName}\`
+    const siblingCallSitesStep = inlineCallSiteRule
+        ? `## STEP 5c: REPLACE ${site.nouns.toUpperCase()} IN OTHER SKYRAMP-GENERATED TESTS WITH ${site.target(fileName)}
 
-**Run this step EVEN IF STEP 3 already satisfied ${testFile} and STEPS 4–5b did nothing.** ${inlineRequestRule}
+**Run this step EVEN IF STEP 3 already satisfied ${testFile} and STEPS 4–5b did nothing.** ${inlineCallSiteRule}
 
 ${pyImportRuleLine(fileName)} (this applies to the import you add to the SIBLING file too — its directory is what decides the form.)
 
 1. Grep for the other Skyramp-generated test files exactly as in STEP 4 (codegen marker \`${codegenMarker}\`, excluding ${testFile} and \`${fileName}\`).
-2. In each, find every inline request block whose method+path matches a helper now defined in \`${fileName}\`.
-3. For each match: import the helper into that file and replace the block with the call, passing the block's literals (or expressions) as arguments; lift a literal the helper lacks to a defaulted parameter in \`${fileName}\`. Change NOTHING else in that file — its other steps, assertions and order stay verbatim.
-4. A block with no matching helper, or one that differs structurally, stays as it is. Conservative bias: a wrong replacement breaks a passing test; a missed one leaves a duplicate.
-
+2. In each, find every ${site.noun} ${site.match(fileName)}.
+3. For each match: import the helper into that file and replace the ${site.unit} with the call, passing the ${site.unit}'s literals (or expressions) as arguments; ${site.lift(fileName)}. Change NOTHING else in that file — ${site.keeps}.
+4. A ${site.unit} with no matching helper, or one that differs structurally, stays as it is. Conservative bias: a wrong replacement breaks a passing test; a missed one leaves a duplicate.
+${site.afterSteps}
 `
         : "";
     const finalReminderScope = seedsUtils
@@ -234,11 +237,11 @@ Use the Grep tool to search for files containing "${SKYRAMP_UTILS_HEADER}":
 Read the matching non-test files and check if any helpers can be reused in ${testFile}.
 ${inHouseDiscoveryStep}
 ## STEP 3: USE EXISTING HELPERS FROM UTILS SOURCE FILES FOUND IN STEP 2
-If helpers exist in util file that can be reused in ${testFile} without modifying them${inlineRequestRule ? " — or, for API request helpers, by EXTENDING them with defaulted parameters as the rules below allow" : ""}:
+If helpers exist in util file that can be reused in ${testFile} without modifying them${inlineCallSiteRule ? site.extendClause : ""}:
 - Import them into ${testFile}
 - Remove any duplicate code in ${testFile}
-${inlineRequestRule
-        ? `- ${inlineRequestRule} This applies to every request step still inline in ${testFile} that matches a utils helper.
+${inlineCallSiteRule
+        ? `- ${inlineCallSiteRule} This applies to every ${site.stepNoun} still inline in ${testFile} that matches a utils helper.
 `
         : ""}- Test that ${testFile} still works without any errors and logical is same as original test file.
 ${utilsMergeRule}${inHouseMatchStep}
@@ -272,8 +275,8 @@ NOT A HELPER FUNCTION (do not extract):
    - No function definition/signature
    - Example: Multiple \`await page.getByTestId("xyz").click()\` directly in test
 
-${inlineRequestRule
-        ? `(Inline request blocks in OTHER test files are not helpers to move — STEP 5c replaces them with calls to the shared helpers.)
+${inlineCallSiteRule
+        ? `(${site.nouns} in OTHER test files are not helpers to move — STEP 5c replaces them with calls to the shared helpers.)
 
 `
         : ""}**IF OTHER TEST FILES ONLY CONTAIN REPETITIVE PATTERNS (NO ACTUAL HELPER FUNCTIONS), SKIP TO ${skipTarget}**
@@ -365,7 +368,7 @@ ${seedStepBlock}${siblingCallSitesStep}## STEP 6: VERIFY AND VALIDATE
 6. **VERIFY** that no unnecessary helper functions were created (functions that duplicate existing functionality)
 7. **VERIFY** that all helper functions in utils are actually imported and used in the test files
 8. **REMOVE** any helper functions that are not being used after refactoring
-9. **NEVER** refactor, reorganize, or restructure existing source test files beyond moving helpers${inlineRequestRule ? " — and, in this flow, replacing an inline request block with a call to the shared helper it duplicates (STEP 3 / STEP 5c)" : ""}
+9. **NEVER** refactor, reorganize, or restructure existing source test files beyond moving helpers${inlineCallSiteRule ? ` — and, in this flow, replacing an ${site.noun} with a call to the shared helper it duplicates (STEP 3 / STEP 5c)` : ""}
 10. **RUN TESTS** to ensure functionality is preserved after refactoring
 11. **NEVER** drop an assertion or a cross-cutting guard (\`page.on('pageerror'...)\`, error collectors and their final \`expect\`) while moving code — the verify step compares the assertion count against the modularization hand-out and fails on a loss