@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/prompts/code-reuse.js

@@ -2,24 +2,21 @@ import { generateSkyrampHeader, SKYRAMP_UTILS_HEADER } from "../utils/utils.js";
 import { isUtilsReuseEnabled } from "../utils/featureFlags.js";
 import { isModularizeFirstTarget, isPomAwareTarget, } from "../utils/reuseRouting.js";
 import { getPomAwareCodeReusePrompt } from "./pom-aware-code-reuse.js";
-import { NO_SHADOWING_RULE, selectHelperPolicy, } from "./shared-helper-policy.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";
+/** The prescribed module name comes from the verifier's language table, which is the
+ *  ONE declaration of it: the instruction the agent reads and the name the verify pass
+ *  demands cannot drift apart. Java is stated here because utils reuse is disabled for
+ *  it, so the verifier has no entry to read. */
 const LANGUAGE_MAP = {
-    python: {
-        extension: "py",
-        fileName: "SkyrampUtils.py",
-    },
+    ...Object.fromEntries(Object.entries(UTILS_LANGUAGE_SPECS).map(([language, spec]) => [
+        language,
+        { extension: spec.extensions[0].slice(1), fileName: spec.fileName },
+    ])),
     java: {
         extension: "java",
         fileName: "SkyrampUtils.java",
     },
-    javascript: {
-        extension: "js",
-        fileName: "skyrampUtils.js",
-    },
-    typescript: {
-        extension: "ts",
-        fileName: "skyrampUtils.ts",
-    },
 };
 function genericNearDupExample(testFile) {
     return `### Worked example
@@ -52,18 +49,16 @@ export async function uploadFileToRFI(page, fileName, tabName) {
 }
 \`\`\`
 
-These ARE near-duplicates. Same primitive sequence; the only material difference is the \`.first()\` qualifier on the locator. \`tabName\` is unused in the body — recorder noise, drop it. Correct merge:
+These ARE near-duplicates. Same primitive sequence; the only material difference is the \`.first()\` qualifier on the locator. \`tabName\` is unused in the body — recorder noise, drop it. The \`waitForTimeout\` lines are recorder noise too: a fixed sleep is not a structural wait, and in a shared helper every importer pays it on every run. The \`waitForResponse\` correlation and the \`filechooser\` event already cover this step, so the merged helper waits on those; where a step has no such signal, wait on the element the next line touches. Correct merge:
 
 \`\`\`ts
 export async function uploadFileViaChooser(page: Page, fileName: string) {
-    await page.waitForTimeout(1500);
     const responsePromise = page.waitForResponse("**/api/files/upload**");
     const fileUploadPromise = page.waitForEvent("filechooser");
     await page.getByText("Choose a file").first().click();
     const fileChooser = await fileUploadPromise;
     await fileChooser.setFiles(fileName);
     await responsePromise;
-    await page.waitForTimeout(1500);
 }
 \`\`\`
 
@@ -101,6 +96,11 @@ export function getCodeReusePrompt(testFile, language, framework, scopedPoms, te
     // file. STEP 5b seeds the utils file from the current test's own helpers so
     // this run's output carries it and later tests import instead of re-defining.
     const seedsUtils = modularizeFirst;
+    // The name is prescribed in LANGUAGE_MAP and, until the verify pass checked it,
+    // nothing held a run to it: testplan-run-9 delivered `skyrampUiUtils.ts` on one
+    // fixture and `skyrampUtils.ts` on another, for the same role on one repository.
+    // Stated once and rendered at both places that create the file.
+    const moduleNameRule = `**THE MODULE'S NAME IS NOT A CHOICE.** The shared module for ${lang} is \`${fileName}\`, and a module you create carries exactly that name — a later run against this repository then finds and extends it instead of writing a second module beside it under another name. A module that ALREADY EXISTS keeps the name it has: never rename it, whatever it is called, because tests you cannot see import it. Only where \`${fileName}\` is already large may a SECOND module carry another name.`;
     // Naming, equivalence and assertion rules for helpers headed to the shared
     // file are the helper policy's — selected once by test type, stated once.
     const policy = selectHelperPolicy(testType);
@@ -115,13 +115,31 @@ export function getCodeReusePrompt(testFile, language, framework, scopedPoms, te
         ? `**IF NO OTHER SKYRAMP-GENERATED TEST FILES ARE FOUND, SKIP DIRECTLY TO STEP 5b — do not process STEP 4b or STEP 5.**`
         : `**STOP HERE IF NO OTHER SKYRAMP-GENERATED TEST FILES FOUND**
 **IF NO OTHER SKYRAMP-GENERATED TEST FILES ARE FOUND, SKIP TO STEP 6 - DO NOT CREATE ANY UTILS FILES.**`;
+    // The repository's own browser helper modules. UI only, and only on the seeded
+    // (utils reuse on, page-object reuse off) flow: a browser test and the helpers it
+    // calls drive one library, so the verifier's action key compares a step to the
+    // customer's helper; the API side has no such key and is a separate change.
+    const inHouseBrowser = seedsUtils && policy.kind === "browser";
+    const inHouseDiscoveryStep = inHouseBrowser
+        ? inHouseDiscovery(testFile, fileName)
+        : "";
+    const inHouseMatchStep = inHouseBrowser
+        ? inHouseMatch(testFile, fileName, policy)
+        : "";
+    const inHouseSeedRule = inHouseBrowser
+        ? `
+**IF STEP 2b FOUND A QUALIFYING IN-HOUSE MODULE, SKIP THIS STEP.** STEP 3b already placed each of this test's helpers: replaced by a call to one of theirs, or added to their module in their style. A helper STEP 3b left local (their matching helper's key is undefined) stays local in ${testFile} — it is not moved into \`${fileName}\`, and \`${fileName}\` is not created beside their module. Where a \`${fileName}\` from an earlier run already sits beside their module, leave it as it is. This step runs only when STEP 2b found no qualifying module.
+`
+        : "";
     const seedStepBlock = seedsUtils
         ? `## STEP 5b: MOVE THIS TEST'S OWN HELPERS INTO \`${fileName}\`
 
-skyramp_modularization already ran on ${testFile} and extracted its steps into named helper functions. Those helpers belong in the shared \`${fileName}\` so later tests import them instead of re-defining them.
-
+skyramp_modularization already ran on ${testFile} and extracted its steps into named helper functions. Those helpers belong in a shared module${inHouseBrowser ? " — the repository's own browser helper module when STEP 2b found one (STEP 3b), otherwise" : ", "} \`${fileName}\`${inHouseBrowser ? " —" : ","} so later tests import them instead of re-defining them.
+${inHouseSeedRule}
 ${pyImportRuleLine(fileName)}
 
+${moduleNameRule}
+
 For each helper function still defined locally in ${testFile} (i.e. not already merged by STEP 4b):
 1. **CREATE** \`${fileName}\` if it does not exist, with the standard header:
    \`\`\`${ext}
@@ -148,7 +166,7 @@ This step MOVES helpers that skyramp_modularization already created — it does
     // 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 body literals, \`data_override\` values, or expected status): REPLACE the block with a call to the helper, passing the block's own literals as arguments, and lift any literal the helper does not yet take to a parameter DEFAULTED to the helper's current value (existing call sites unchanged). 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.`
+        ? `**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.`
         : "";
     // 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
@@ -169,7 +187,7 @@ ${pyImportRuleLine(fileName)} (this applies to the import you add to the SIBLING
 `
         : "";
     const finalReminderScope = seedsUtils
-        ? `**ONLY MOVE HELPERS THAT ALREADY EXIST IN TEST FILES — NEVER AUTHOR NEW ONES**`
+        ? `**ONLY MOVE HELPERS THAT ALREADY EXIST IN TEST FILES — NEVER AUTHOR NEW ONES**${inHouseBrowser ? " (adding one of THIS test's helpers to the repository's own module in STEP 3b is a move, not authoring; an inline step with no matching helper of theirs stays inline)" : ""}`
         : `**ONLY MOVE EXISTING HELPERS FROM OTHER TEST FILES**`;
     const decisionTreeTail = seedsUtils
         ? `3. Found other test files with only repetitive patterns? → Step 5b (seed utils from this test's own helpers)
@@ -181,7 +199,7 @@ ${pyImportRuleLine(fileName)} (this applies to the import you add to the SIBLING
 5. Other test files identical to current? → SKIP to Step 6, NO utils file`;
     const precondition = modularizeFirst
         ? `
-**PRECONDITION — check your own tool-call history, not the file**: this flow moves the helpers skyramp_modularization created into \`${fileName}\` (STEP 5b). If you have NOT called skyramp_modularization on ${testFile} in this run, STOP: call it now with \`testFile\` set to ${testFile}, \`testType: "${testType}"\`, and \`isTraceBased: true\`, apply its instructions, then call skyramp_reuse_code again with the same arguments as this call. If you HAVE called it and the file still defines no helper functions, that is a legitimate outcome — proceed; STEP 5b will simply have nothing to move.
+**PRECONDITION — check your own tool-call history, not the file**: this flow moves the helpers skyramp_modularization created into \`${fileName}\` (STEP 5b)${inHouseBrowser ? " — or into the repository's own browser helper module when it has one (STEP 3b)" : ""}. If you have NOT called skyramp_modularization on ${testFile} in this run, STOP: call it now with \`testFile\` set to ${testFile}, \`testType: "${testType}"\`, and \`isTraceBased: true\`, apply its instructions, then call skyramp_reuse_code again with the same arguments as this call. If you HAVE called it and the file still defines no helper functions, that is a legitimate outcome — proceed; STEP 5b will simply have nothing to move.
 `
         : "";
     return `# CODE REUSE - 6 CLEAR STEPS 
@@ -214,7 +232,7 @@ Use the Grep tool to search for files containing "${SKYRAMP_UTILS_HEADER}":
 - Output mode: "files_with_matches"
 **CRITICAL: Only look for util files with header ${SKYRAMP_UTILS_HEADER}** - exclude test files (files with "test", "spec", ".test.", ".spec." in the name).
 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" : ""}:
 - Import them into ${testFile}
@@ -223,8 +241,7 @@ ${inlineRequestRule
         ? `- ${inlineRequestRule} This applies to every request step 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}
-
+${utilsMergeRule}${inHouseMatchStep}
 ## STEP 4: FIND LOCAL HELPERS IN OTHER SKYRAMP-GENERATED TEST FILES
 
 You are looking for sibling test files generated by Skyramp's codegen. They start with the comment line \`${codegenMarker}…\` (note: the version suffix is what distinguishes them from the SkyrampUtils header). The substring \`${SKYRAMP_UTILS_HEADER}\` is contained in that line, so:
@@ -300,7 +317,7 @@ For each helper defined locally in ${testFile}:
 - **Conservative bias**: a wrong merge breaks both tests; a missed merge leaves a duplicate. When in doubt, do NOT merge.
 - **No "cleanup"**: the merged body must mirror the original primitive sequence — same waits, same correlation patterns, same order. This is not refactoring.
 ${pyImportRuleLine(fileName)}
-- **Typed parameters (TypeScript)**: the merged helper types every parameter (\`page: Page\`, values by their type); add \`import type { Page } from '@playwright/test'\` to the utils file if it is missing. Never \`page: any\` or an untyped \`page\` — that fails a repo that type-checks its tests under \`noImplicitAny\`.
+- **Typed parameters (TypeScript)**: the merged helper types every parameter (\`page: Page\`, values by their type); add \`import type { Page } from '@playwright/test'\` to the utils file if it is missing. Never \`page: any\`, \`page: unknown\`, or an untyped \`page\` — an untyped one fails a repo that type-checks its tests under \`noImplicitAny\`, and \`unknown\` fails at its first use under every setting.
 - **Don't merge with helpers already in \`${fileName}\`**: those are STEP 3's territory. STEP 4b is strictly cross-test merge between sibling Skyramp-generated test files.
 
 ---
@@ -328,7 +345,7 @@ ${pyImportRuleLine(fileName)}
    \`\`\`${ext}
    ${generateSkyrampHeader(lang)}
    \`\`\`
-**CRITICAL: IF \`${fileName}\` is already big, create a new file with a different name and add the header to the new file.**
+${moduleNameRule}
 2. **COPY** those local helper functions from original test source files to \`${fileName}\` without modifying them${seedsUtils ? ` — with ONE exception, checked BEFORE the copy: ${policy.assertionRule} Relocate a trailing excluded assertion into the owning test's body first; the copy that lands in \`${fileName}\` carries none.${policy.moveRule ? ` ${policy.moveRule}` : ""}` : ""}
 3. **DELETE** those local helper functions from test source files (REMOVE THEM COMPLETELY) WITHOUT ANY OTHER CHANGES.
 4. **IMPORT** those local helper functions from \`${fileName}\` back into test source files WITHOUT MAKING ANY OTHER CHANGE.
@@ -357,14 +374,14 @@ ${finalReminderScope}
 
 **IMPORTANT NOTES:**
 - The process is designed to REUSE existing helper functions, not create new ones
-- ${seedsUtils ? `If no existing helpers are found in utils or sibling tests, STEP 5b still moves this test's own helpers into \`${fileName}\` and imports them back — that is the expected first-run outcome, not a no-op` : "If no existing helpers are found, the test file should remain unchanged"}
+- ${seedsUtils ? `If no existing helpers are found in utils or sibling tests, STEP 5b still moves this test's own helpers into \`${fileName}\` and imports them back — that is the expected first-run outcome, not a no-op${inHouseBrowser ? "; when STEP 2b found the repository's own browser helper module, STEP 3b does that placement into THEIR module instead and STEP 5b is skipped" : ""}` : "If no existing helpers are found, the test file should remain unchanged"}
 - Code reuse is about moving existing, working helper functions between files
 - Never create helper functions based on patterns you see in the current test file
 - Helper functions must have explicit function signatures/definitions
 - Repetitive inline test code is NOT a helper function
 
 **DECISION TREE:**
-1. Found existing utils file with helpers? → Import and use them (Step 3)
+${inHouseBrowser ? "0. STEP 2b found a qualifying in-house browser helper module? → call its helpers and add this test's helpers to it (Step 3b); Step 5b is skipped and no `" + fileName + "` is created\n" : ""}1. Found existing utils file with helpers? → Import and use them (Step 3)
 2. Found other test files with ACTUAL helper functions? → Move to utils (Step 5)
 ${decisionTreeTail}
 
@@ -374,9 +391,58 @@ ${
     // Gated with the debt it describes: with SkyrampUtils reuse off nothing refuses, and
     // this text would send the agent to spend a call being told the feature is disabled.
     isUtilsReuseEnabled()
-        ? `**MANDATORY FINAL STEP — VERIFY**: once every edit above is written, call skyramp_reuse_code again with the SAME testFile, language, framework and testType and \`verify: true\`. It stages the shared utils file for the output commit and checks its invariants (for API helpers: one helper per method+path, status-code-only assertions, method+resource names; for browser helpers: actions and structural waits only, intent names). Resolve anything it reports and re-verify; finish only when it reports PASSED. It passes immediately when no utils file was written. skyramp_enhance_assertions and skyramp_execute_test refuse this test until that verify pass has run.\n`
+        ? `**MANDATORY FINAL STEP — VERIFY**: once every edit above is written, call skyramp_reuse_code again with the SAME testFile, language, framework and testType and \`verify: true\`. It stages the shared utils file for the output commit and checks its invariants (for API helpers: one helper per method+path, status-code-only assertions, method+resource names; for browser helpers: actions and structural waits only, intent names).${inHouseBrowser
+            ? ` It also checks every in-house module this test imports: each imported name must exist there with an argument count its signature accepts, and every change this run made to their module must add a helper or add a defaulted parameter — anything else is refused and you restore it. On that call pass \`inHouse: { filesRead: [...], declined: [{ file, helper, reason }, ...] }\` — every file STEP 2b read, and every helper STEP 3b read and did not call, with the reason. These are your declarations and the report labels them as such.`
+            : ""} Resolve anything it reports and re-verify; finish only when it reports PASSED. It passes immediately when no utils file was written${inHouseBrowser ? " and no in-house module is imported" : ""}. skyramp_enhance_assertions and skyramp_execute_test refuse this test until that verify pass has run.\n`
         : ""}
 
 SUMMARIZE THE CODE REUSE PROCESS AND THE RESULTS.
 `;
 }
+/**
+ * STEP 2b — find the repository's own browser helper modules. The agent searches;
+ * the search is a sample, and the report carries that cost: every file read is
+ * declared on the verify call. No fixed list of file names and no language filter,
+ * so a module nobody enumerated is still found; a module not written for Playwright
+ * is then reported as unreadable rather than filtered out in silence.
+ */
+function inHouseDiscovery(testFile, fileName) {
+    return `
+## STEP 2b: FIND THE REPOSITORY'S OWN BROWSER HELPER MODULES
+
+The header grep in STEP 2 finds only modules Skyramp wrote. The repository may already hold browser helpers of its own — a module the team wrote, carrying no Skyramp header — and a test that ignores it ends with two helper layers for the same steps. Find them.
+
+1. **Search the directory of ${testFile} and each of its parent directories up to the repository root.** Use Grep for Playwright locator and action calls (\`getBy\`, \`.locator(\`, \`page.\`, \`.click(\`, \`.fill(\`) in files that are NOT test files. Do NOT limit the search to a fixed list of file or directory names (\`pages/\`, \`helpers/\`, \`*.page.ts\` are hints, not the search), and do NOT limit it to one extension or language. Exclude \`node_modules\`, \`${fileName}\` and every other file carrying the \`${SKYRAMP_UTILS_HEADER}\` header (STEP 2 owns those), and test files — by BASENAME only: a basename ending in \`.spec.ts\`, \`.spec.js\`, \`.test.ts\`, \`.test.js\` is a test; a directory called \`tests/\` is not.
+2. **Read every candidate.** ${SELECTOR_OWNING_MODULE_RULE} A module written for a browser library other than Playwright shares no vocabulary with this test: read it, record it, and report it as unreadable — do not call it and do not extend it.
+3. **Catalog each qualifying module** to chat before changing anything: for each helper its name, **whether the module exports it UNDER THAT NAME** (an \`export\` on the definition, or an unaliased entry in an \`export { … }\` list of its own bindings — a default export and an aliased one export something else, and a helper this test cannot import is one it cannot call), its parameters (with defaults), what it returns, and its ACTION KEY — the sequence of Playwright actions it performs, in body order, each as the verb plus the locator chain it is called on (\`fill page.getByTestId("email"); click page.getByRole("button", { name: "Sign in" })\`). Argument VALUES are not part of the key, with two exceptions that ARE: a \`goto\` target and a \`dragTo\` destination — where a navigation goes and where a drag lands are the identity of those steps, so a helper that opens another page never matches. The key is UNDEFINED for a helper whose locator is not built from plain string literals — a variable, a template literal, a regex, a parameter; record it as undefined.
+4. **Record every file the search read** — qualifying or not — as a repository-relative path. You pass this list to the verify call at the end (\`inHouse.filesRead\`). A file you did not read is not on it.
+
+**Which module to extend when there is more than one:** the module the tests in this directory already import; of those, the one holding the helpers STEP 3b matches; otherwise the module nearest to ${testFile}.
+
+**Decision:** no qualifying module → continue to STEP 3 as written; STEP 3b and the in-house rule in STEP 5b then have nothing to do. One or more → continue to STEP 3, then STEP 3b.
+`;
+}
+/**
+ * STEP 3b — match each step to the customer's helpers by the action key, call
+ * theirs where the keys agree, and add to their module where nothing does. The
+ * two edits their file may receive are stated here and enforced by the verify
+ * call's additive gate; the header rule is stated because the old verify text told
+ * the agent the opposite.
+ */
+function inHouseMatch(testFile, fileName, policy) {
+    return `
+## STEP 3b: CALL THE REPOSITORY'S OWN HELPERS, AND ADD TO THEIR MODULE WHAT IT LACKS
+
+Run this step only if STEP 2b found a qualifying module. Match every helper skyramp_modularization extracted in ${testFile} AND every action sequence still inline in it; ADD to their module only for the extracted helpers — an inline step with no match stays inline, as modularization left it (single-use steps are not helpers).
+
+**Match by the action key, not by name or by intent.** Compute the key of the step exactly as STEP 2b computed the helpers' keys, and compare:
+
+- **Keys equal → call their helper.** Replace the step (or delete the local helper and replace its calls) with a call to their helper, passing this test's values as arguments where their signature takes them. Where their helper hardcodes a value this test needs to differ (a filled text, an option label) and takes no parameter for it, ADD a parameter to their helper — APPENDED AFTER its existing parameters, never inserted among them, which would shift every caller they already have onto the wrong argument — whose DEFAULT is exactly the literal it replaces, and pass this test's value — every existing caller keeps its behaviour, and the verify call checks that with the default substituted back the helper reads as it did at HEAD. That is the ONLY edit an existing helper of theirs may receive.
+- **Their key is undefined** (a variable, template-literal or regex locator) **→ do not call it and do not extend it.** Leave the step as it is and record the helper with the reason (\`inHouse.declined\` on the verify call).
+- **No key matches (an extracted helper) → add it to THEIR module.** Move its body into their module written in that file's own style: its naming convention, its parameter style (positional, options object, defaults), the browser API and the import forms it already uses; delete the local definition and import it, keeping the call sites. It carries the action sequence and structural waits only — a value assertion stays in ${testFile} right after the call (${policy.assertionRule}). Do not add a helper whose key equals a helper the module already holds; call that one. Do not import the Skyramp runtime into their file.
+
+**Never change what an existing helper of theirs does** — no edited body, no renamed helper, no removed line, no parameter without a default. **Never write the \`${SKYRAMP_UTILS_HEADER}\` header into their file.** It stays their file; the verify call compares it against HEAD and refuses any other change, and you undo it.
+
+A step their helper covers is NOT moved into \`${fileName}\` in STEP 5b. Record, for the verify call, each helper of theirs you read and did not call, with the reason.
+`;
+}

package/build/prompts/fix-error-prompt.d.ts

@@ -1 +1,9 @@
-export declare function getFixErrorsPrompt(): string;
+import { ProgrammingLanguage } from "../types/TestTypes.js";
+interface FixErrorsPromptParams {
+    testFile: string;
+    language: `${ProgrammingLanguage}`;
+    framework: string;
+}
+/** Render the repair skill for clients that do not load the plugin. */
+export declare function getFixErrorsPrompt(params: FixErrorsPromptParams): string;
+export {};

package/build/prompts/fix-error-prompt.js

@@ -1,29 +1,32 @@
-export function getFixErrorsPrompt() {
-    return `
-**Fix errors in refactored code.**
-
-1. **Parameter Passing:** Identify functions using variables from outside scope (like 'page' object). Pass these as parameters.
-2. **Validate Correctness:** Ensure code is free of reference errors, undefined variables, runtime issues.
-3. **Import Paths:** Ensure import paths are correct and there are no circular imports.
-4. **Import Validation:** Ensure all remaining imports are necessary and no missing imports cause reference errors.
-5. **Unused Import Cleanup:** Verify that unused imports were properly removed without breaking functionality.
-6. **UI State Management:** Check for UI state conflicts, modal interference, or element interaction issues.
-7. **Sequential Operations:** Ensure UI operations don't interfere with each other when called in sequence.
-
-**IMPORT ERROR DEBUGGING:**
-- Check for missing imports that cause undefined reference errors
-- Verify that import removal didn't break existing functionality
-- Ensure all imported modules are actually available in the project
-- Confirm that import syntax is correct for the target language
-
-**CRITICAL CONSTRAINTS:**
-- DO NOT CREATE/UPDATE package.json or requirements.txt or pom.xml or build.gradle file
-- NEVER create dependency management files, even when linting errors suggest missing dependencies
-- Focus on fixing code errors within existing files only
-
-**KEY: Variables not defined within function scope MUST be passed as parameters.**
-**UI KEY: Helper functions that perform UI operations must be self-contained and not leave modals/dialogs open.**
-**IMPORT KEY: All imports must be either used in the code or properly removed.**
-**DEPENDENCY KEY: DO NOT create package.json, requirements.txt, or any dependency files regardless of linting errors.**
-`;
+import { FIX_TEST_IMPORT_ERRORS_SKILL } from "../skills/fixTestImportErrorsSkill.js";
+import { readSkillBody, section, sliceBetween } from "../skills/skillFiles.js";
+import { ProgrammingLanguage } from "../types/TestTypes.js";
+/** Render the repair skill for clients that do not load the plugin. */
+export function getFixErrorsPrompt(params) {
+    let languageHeading;
+    switch (params.language) {
+        case ProgrammingLanguage.PYTHON:
+            languageHeading = "### Python";
+            break;
+        case ProgrammingLanguage.JAVASCRIPT:
+        case ProgrammingLanguage.TYPESCRIPT:
+            languageHeading = "### JavaScript and TypeScript";
+            break;
+        case ProgrammingLanguage.JAVA:
+            languageHeading = "### Java";
+            break;
+        default:
+            throw new Error(`Unsupported repair language: ${params.language}`);
+    }
+    const skill = readSkillBody(FIX_TEST_IMPORT_ERRORS_SKILL);
+    const instructions = [
+        sliceBetween(skill, "## Workflow", "## Steps for"),
+        // Match the whole heading: "Java" must not select "JavaScript".
+        section(skill, `${languageHeading}\n`),
+        section(skill, "## Execution guidance"),
+    ].join("\n\n");
+    const values = [params.testFile, params.language, params.framework];
+    // Replace once: dollar signs in a supplied path must not become placeholders.
+    // Named shell variables in the Java example are left intact.
+    return instructions.replace(/\$([012])(?!\d)/g, (_match, index) => values[Number(index)]);
 }

package/build/prompts/local-dev/local-dev-plan.d.ts

@@ -17,6 +17,9 @@ export declare const GRPC_SERVICE_NAME_GUIDANCE = "the bare service name as decl
 export declare const ASSERTION_API_GUIDANCE = "Use the SDK helper for all field-level assertions: Python `skyramp.get_response_value(response, \"json.path\")`, TypeScript `getResponseValue(response, \"json.path\")`. The helper supports dot-path notation for nested access (e.g., `\"data.items[0].name\"`). Do NOT use dict/attribute access on the response variable (`response[\"field\"]`, `response.field`) or `json.loads(response.response_body)`";
 export interface LocalDevPlanCtx {
     repositoryPath: string;
+    /** `owner/repo` of the checkout at repositoryPath. skyramp_analyze_changes and
+     *  skyramp_execute_test both name their repository on every call. */
+    repository: string;
     baseCommit: string;
     maxRecommendations: number;
     maxGenerate: number;

package/build/prompts/local-dev/local-dev-plan.js

@@ -25,6 +25,7 @@ export const localDevPlan = new PromptPlan()
 })
     .step("ANALYZE_DIFF", "Analyze branch diff", (ctx) => `Call \`skyramp_analyze_changes\` with:
 - \`repositoryPath\`: "${ctx.repositoryPath}"
+- \`repository\`: "${ctx.repository}"
 - \`scope\`: "branch_diff"
 - \`baseBranch\`: "${ctx.baseCommit}"
 - \`includeUncommitted\`: true
@@ -297,7 +298,7 @@ This injects import statements from the generated mock files — no data duplica
 - \`testType\`: "integration", "contract", or "ui" (match the scenario table)
 - \`enhanceType\`: "generation"
 
-The tool returns instructions — it does NOT edit the file automatically. Apply every returned instruction yourself: read the test file and add the suggested assertions. For assertions on server-generated IDs (e.g., account IDs, order IDs), prefer a domain prefix check (e.g., \`.startswith("acc_")\`) over \`is not None\` when the application uses a known ID format.`)
+The tool returns instructions — it does NOT edit the file automatically. Apply every returned instruction yourself: read the test file and add the suggested assertions.`)
     .step("CROSS_REFERENCE", "Cross-reference scenarios vs test files", (_ctx) => `Compare the scenario table from Phase 2 against the generated test files:
 
 1. For each generated scenario, verify a corresponding test file exists with the correct SCENARIO_NAME or generated test name.
@@ -388,6 +389,7 @@ skyramp_execute_test({
   language: "<from workspace config>",
   testType: "<'integration' or 'contract' — match the scenario table>",
   workspacePath: "${ctx.repositoryPath}",
+  repository: "${ctx.repository}",
   token: "",
 })
 \`\`\`

package/build/prompts/local-dev/local-dev-prompts.d.ts

@@ -1,4 +1,4 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type Service } from "../../workspace/workspace.js";
-export declare function getLocalDevPrompt(baseCommit: string, repositoryPath: string, sandboxWorkerUrl?: string, maxRecommendations?: number, maxGenerate?: number, services?: Service[], stateOutputFile?: string, servicesToMock?: string[], realServices?: string[], mockProtocols?: string[], proxyKubeconfig?: string, proxyNamespace?: string): string;
+export declare function getLocalDevPrompt(baseCommit: string, repositoryPath: string, repository: string, sandboxWorkerUrl?: string, maxRecommendations?: number, maxGenerate?: number, services?: Service[], stateOutputFile?: string, servicesToMock?: string[], realServices?: string[], mockProtocols?: string[], proxyKubeconfig?: string, proxyNamespace?: string): string;
 export declare function registerLocalDevPrompt(server: McpServer): void;

package/build/prompts/local-dev/local-dev-prompts.js

@@ -3,7 +3,9 @@ import * as path from "path";
 import { logger } from "../../utils/logger.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { buildServiceContext, escapeXml, readWorkspaceServices, } from "../prompt-utils.js";
-import { localDevPlan, GRPC_SERVICE_NAME_GUIDANCE, ASSERTION_API_GUIDANCE } from "./local-dev-plan.js";
+import { localDevPlan, GRPC_SERVICE_NAME_GUIDANCE, ASSERTION_API_GUIDANCE, } from "./local-dev-plan.js";
+import { tryRepositorySlug } from "../../utils/repositorySlug.js";
+import { setPrimaryRepository } from "../../utils/AnalysisStateManager.js";
 const LOCAL_DEV_MAX_RECOMMENDATIONS = 8;
 const LOCAL_DEV_MAX_TESTS_TO_GENERATE = 5;
 /**
@@ -37,7 +39,7 @@ function buildServiceRoutingBlock(servicesToMock, realServices, mockProtocols) {
     lines.push("</SERVICE_ROUTING>");
     return lines.join("\n");
 }
-export function getLocalDevPrompt(baseCommit, repositoryPath, sandboxWorkerUrl, maxRecommendations = LOCAL_DEV_MAX_RECOMMENDATIONS, maxGenerate = LOCAL_DEV_MAX_TESTS_TO_GENERATE, services, stateOutputFile, servicesToMock, realServices, mockProtocols, proxyKubeconfig, proxyNamespace) {
+export function getLocalDevPrompt(baseCommit, repositoryPath, repository, sandboxWorkerUrl, maxRecommendations = LOCAL_DEV_MAX_RECOMMENDATIONS, maxGenerate = LOCAL_DEV_MAX_TESTS_TO_GENERATE, services, stateOutputFile, servicesToMock, realServices, mockProtocols, proxyKubeconfig, proxyNamespace) {
     maxGenerate = Math.min(Math.max(maxGenerate, 0), maxRecommendations);
     const serviceContext = services?.length ? buildServiceContext(services) : "";
     // Proxy access lets the workflow query a running Skyramp worker proxy for real
@@ -101,6 +103,7 @@ ${sandboxWorkerBlock ? sandboxWorkerBlock + "\n" : ""}${serviceContext ? service
     // ── Render the plan phases ────────────────────────────────────────────────
     const ctx = {
         repositoryPath,
+        repository,
         baseCommit,
         maxRecommendations,
         maxGenerate,
@@ -167,13 +170,37 @@ export function registerLocalDevPrompt(server) {
         },
     }, async (args) => {
         const services = await readWorkspaceServices(args.repositoryPath);
+        // skyramp_analyze_changes and skyramp_execute_test both name their repository
+        // on every call. This is a local checkout, so read it off the origin remote.
+        const repository = await tryRepositorySlug(args.repositoryPath);
+        if (!repository) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Cannot read owner/repo from the origin remote of ${args.repositoryPath}. The Skyramp tools name the repository on every call, so add an origin remote to this checkout and retry.`,
+                        },
+                    },
+                ],
+            };
+        }
+        // Rendering the prompt is where this run declares its primary checkout, the
+        // same as the testbot entry point. Set, not set-if-unset: one server can
+        // render a second run for a different checkout, and keeping the first would
+        // route the second one as a related repository of it.
+        setPrimaryRepository({
+            repositoryPath: args.repositoryPath,
+            repo: repository,
+        });
         const parseCsv = (v) => v
             ? v
                 .split(",")
                 .map((s) => s.trim())
                 .filter(Boolean)
             : undefined;
-        const prompt = getLocalDevPrompt(args.baseCommit, args.repositoryPath, args.sandboxWorkerUrl, args.maxRecommendations, args.maxGenerate, services.length ? services : undefined, args.stateOutputFile, parseCsv(args.servicesToMock), parseCsv(args.realServices), parseCsv(args.mockProtocols), args.proxyKubeconfig, args.proxyNamespace);
+        const prompt = getLocalDevPrompt(args.baseCommit, args.repositoryPath, repository, args.sandboxWorkerUrl, args.maxRecommendations, args.maxGenerate, services.length ? services : undefined, args.stateOutputFile, parseCsv(args.servicesToMock), parseCsv(args.realServices), parseCsv(args.mockProtocols), args.proxyKubeconfig, args.proxyNamespace);
         AnalyticsService.pushMCPToolEvent("skyramp_local_dev_prompt", undefined, {}).catch(() => { });
         return {
             messages: [

package/build/prompts/modularization/integration-test-modularization.js

@@ -49,13 +49,16 @@ expect(response1.status).toBe(200);
 const response2 = await fetch("/api/users/2");
 expect(response2.status).toBe(200);
 
-// Correct helper (EXACT copy + parameters${p.utilsReuse ? "; the expected status is a defaulted parameter per HELPER SHAPE" : ""}):
+// Correct helper (EXACT copy + parameters${p.utilsReuse ? "; the expected status is a parameter with NO default per HELPER SHAPE — each call passes it, and the test body does not assert it again" : ""}):
 ${p.utilsReuse
-    ? `async function getUser(userId: number, expectedStatus = 200) {
+    ? `async function getUser(userId: number, expectedStatus: number) {
   const response = await fetch(\`/api/users/\${userId}\`);
   expect(response.status).toBe(expectedStatus);
   return response;
-}`
+}
+// Call sites: the status each one expects, stated once, here.
+const response1 = await getUser(1, 200);
+const response2 = await getUser(2, 200);`
     : `async function getUser(userId: number) {
   const response = await fetch(\`/api/users/\${userId}\`);
   expect(response.status).toBe(200);
@@ -101,12 +104,16 @@ If ANY answer is "no", DO NOT submit - fix the modularization first.`)
 function sharedHelperShape(p) {
     return `**HELPER SHAPE (one helper per request step from Step ${_plan.labels.IDENTIFY}):**
 - ${API_HELPERS.namingRule}
-- **PARAMETERS**: pass in the client/session object, plus every value the step reads from a previous step's response (IDs used in paths or bodies), plus every body value this scenario varies or its assertions reference (names, prices, quantities, percentages). Values that never vary and that no assertion reads may stay hardcoded — do not invent parameters nothing passes differently.
-- **SCENARIO VALUES GO THROUGH \`data_override\`, NOT THE BODY STRING**: apply each parameterized body value via the request's \`data_override\` map (that is what it is for) and leave the raw body string as generated. A scenario literal edited into the body string makes this helper unmergeable with the same step from another test.
+- **PARAMETERS**: pass in the client/session object, plus every value the step reads from a previous step's response (IDs used in paths or bodies), plus every body value this scenario varies or its assertions reference (names, prices, quantities, percentages). Values that never vary and that no assertion reads may stay hardcoded — do not invent parameters nothing passes differently. The body is the one exception: it is reachable from the signature whether or not this scenario varies it (see the body rule below).
+- **SCENARIO VALUES GO THROUGH \`data_override\`, NOT THE BODY STRING**: apply each parameterized body value via the request's \`data_override\` map (that is what it is for) and leave the raw body string as generated. A scenario literal edited into the body string makes this helper unmergeable with the same step from another test. The generated body is this helper's STARTING POINT, not a fixed value — the body rule below says what must be able to change about it.
 - **RETURN** the response object so later steps can chain and assert from it.
 - ${API_HELPERS.assertionRule} ${ASSERTION_BOUNDARY_RULE_EXTRACT}
 - Helpers are module-level named functions in ${p.filePath}; the test body becomes a sequence of helper calls plus this scenario's assertions, in the original order.
-- Keep everything else EXACTLY the same.`;
+- Keep everything else EXACTLY the same.
+
+${API_HELPERS.bodyShapeRule}
+
+${API_HELPERS.optionsShapeRule}`;
 }
 function repetitionParameterRules() {
     return `**PARAMETER CONVERSION RULES:**

package/build/prompts/modularization/ui-test-modularization.js

@@ -138,7 +138,7 @@ await addItem(page, "item3");
 \`\`\``)
     .step("USE", "CALL HELPERS WITH EXACT SAME VALUES", () => `Use the EXACT same values from the original test when calling helpers.`)
     .step("VERIFY", "VERIFY - CRITICAL CHECKS", (p) => `**BUGS TO AVOID:**
-- [ ] **EVERY PARAMETER IS TYPED (TypeScript)** - \`page: Page\` with \`import type { Page } from '@playwright/test'\` once at the top of the file; other parameters by their value type (\`name: string\`, \`quantity: number\`). An untyped parameter fails a repo that type-checks its tests under \`noImplicitAny\`. JavaScript files carry no annotations.
+- [ ] **EVERY PARAMETER IS TYPED (TypeScript)** - \`page: Page\` with \`import type { Page } from '@playwright/test'\` once at the top of the file; other parameters by their value type (\`name: string\`, \`quantity: number\`). An untyped parameter fails a repo that type-checks its tests under \`noImplicitAny\`; a parameter typed \`unknown\` fails at its first use under every setting, and \`any\` checks nothing — use the real type. JavaScript files carry no annotations.
 - [ ] **Return types are optional** - inferred returns are fine under strict mode; if you write one, it is the real type, never \`any\`
 - [ ] **ALL field mappings verified** - EVERY \`.fill()\` uses the correct parameter. Check field gets quantity parameter, NOT hardcoded
 - [ ] **No duplicate helpers** - Consolidate similar helpers (e.g., one createOrder vs createSimpleOrder + createOrderWithItems)

package/build/prompts/personas.js

@@ -20,5 +20,5 @@ export const SKYRAMP_QA_PERSONA = `You are acting as a Skyramp QA Automation Eng
  * avoid duplicating it in every tool description.
  */
 export function getPersonaPrefix() {
-    return isTestbotEnabled() ? '' : `${SKYRAMP_QA_PERSONA}\n\n`;
+    return isTestbotEnabled() ? "" : `${SKYRAMP_QA_PERSONA}\n\n`;
 }

package/build/prompts/pom-aware-code-reuse.js

@@ -1,12 +1,16 @@
 import { generateSkyrampHeader, SKYRAMP_UTILS_HEADER } from "../utils/utils.js";
 import { resolvePomCatalogPath } from "../utils/pom-catalog.js";
+import { UTILS_LANGUAGE_SPECS } from "../utils/utils-verify/language-spec.js";
+import { SELECTOR_OWNING_MODULE_RULE } from "./shared-helper-policy.js";
 export function getPomAwareCodeReusePrompt(testFile, language = "typescript", scopedPoms) {
     // Resolved here, not left to the agent: the catalog only survives to the next
     // run if it lands where delivery stages it (SKYR-4141).
     const catalogPath = resolvePomCatalogPath(testFile);
     const isJs = language.toLowerCase() === "javascript";
     const ext = isJs ? "js" : "ts";
-    const utilsFile = isJs ? "skyrampUtils.js" : "skyrampUtils.ts";
+    // Same one declaration the standard path reads, so the two prompts and the verify
+    // pass cannot name three different files.
+    const utilsFile = UTILS_LANGUAGE_SPECS[isJs ? "javascript" : "typescript"].fileName;
     const codegenMarker = "// Generated by Skyramp v";
     const headerLang = isJs ? "javascript" : "typescript";
     const scopedActive = scopedPoms && scopedPoms.tier1.length + scopedPoms.tier2.length > 0;
@@ -44,13 +48,7 @@ Use the Glob tool to search for POM files starting from the directory containing
 - Pattern 7: \`**/{test,tests,e2e,playwright}/**/{lib,utils,helpers,support}/**/*.{ts,js}\`
 - Pattern 8: \`**/{testUtils,test-utils,testHelpers,test-helpers}.{ts,js}\`
 
-**A reuse target does not have to be a class.** Patterns 7–8 catch selector-owning helper
-libraries — modules exporting free functions like \`bookFirstEvent(page)\` whose bodies contain
-the selector literals. A helper module qualifies only if its functions OWN selectors; a module
-whose functions take selectors as parameters (generic interaction utilities) owns nothing and is
-not a reuse target. Playwright fixture factories wired into the repo's own \`test\` object
-(\`test.extend\`-style) are NOT substitutable either — using them requires replacing the Skyramp
-runtime imports, which rule 3a forbids.
+${SELECTOR_OWNING_MODULE_RULE} (See rule 3a below.) Patterns 7–8 are what catch such libraries.
 
 Exclude test/spec files by **basename only** — never match on the directory path. POM layers commonly live under a \`tests/\` directory (e.g. \`tests/ui-testing/pages/\`), and path-matching would wrongly drop every POM. A file is excluded only if its **basename** ends in \`.spec.ts\`, \`.spec.js\`, \`.test.ts\`, or \`.test.js\`. Do NOT exclude on the bare substrings \`test\` or \`spec\`: they falsely match legitimate POMs (e.g. \`searchJobInspectorPage.js\` contains "spec") and directory names (\`tests/\`).
 Also exclude \`node_modules\`.
@@ -559,7 +557,7 @@ For each helper defined locally in ${testFile}:
 
 - **Conservative bias**: a wrong merge breaks both tests; a missed merge leaves a duplicate. When in doubt, do NOT merge.
 - **No "cleanup"**: the merged body must mirror the original primitive sequence — same waits, same correlation patterns, same order. This is not refactoring.
-- **Typed parameters (TypeScript)**: the merged helper types every parameter (\`page: Page\`, values by their type); add \`import type { Page } from '@playwright/test'\` if the file lacks it. Never \`page: any\` or an untyped \`page\`.
+- **Typed parameters (TypeScript)**: the merged helper types every parameter (\`page: Page\`, values by their type); add \`import type { Page } from '@playwright/test'\` if the file lacks it. Never \`page: any\`, \`page: unknown\`, or an untyped \`page\`.
 - **Don't merge with helpers already in \`${utilsFile}\`**: those are STEP 3's territory. STEP 4b is strictly cross-test merge between sibling Skyramp-generated test files.
 
 ---

package/build/prompts/reuse-hand-off.d.ts

@@ -0,0 +1,64 @@
+import { TestType } from "../types/TestTypes.js";
+import { type UtilsLanguage } from "../utils/utils-verify/index.js";
+/**
+ * The generation-call clause that asks for codeReuse, language-conditional in
+ * words, as the testbot prompt appends it to its integration generation step
+ * when utils reuse is on.
+ *
+ * States the RULE, not one exception. Naming Java as the only language left out
+ * is false — code reuse covers three languages and discovery records seventeen —
+ * and an agent in a Go repository reads "unset for Java", concludes Go is not
+ * excepted, and asks for a reuse pass that can move no helpers for Go.
+ */
+export declare const CODE_REUSE_GENERATION_CLAUSE: string;
+/**
+ * Whether the maintenance step can actually rewrite a test of this type. Its
+ * REGENERATE strategy names the integration and contract generators only and
+ * forbids skyramp_ui_test_generation, which needs a recorded trace this tool does
+ * not have. A browser test's REGENERATE is therefore advice to the developer: no
+ * call here rewrites the file, so nothing may be armed against it — a hand-off
+ * would refuse the execution of a file the plan never told anyone to rewrite.
+ */
+export declare function isMaintenanceRegenerable(testType: TestType): boolean;
+/**
+ * What the regenerate instruction asks of the generation call, as words for the
+ * summary (`clause`) and as the arguments the structured plan carries (`args`),
+ * from one decision. Undefined when the call must not ask for code reuse: utils
+ * reuse off, or a test type that is not a modularize-first target — contract, for
+ * one, whose generator accepts neither `codeReuse` nor `modularizeCode`. For a
+ * modularize-first type: the resolved clause and arguments for a language with a
+ * utils spec; the leave-unset clause and no arguments for Java; the generic clause
+ * and no arguments when the language is not cataloged.
+ */
+export declare function regenerateCodeReuse(testType: TestType, 
+/** Optional because the discovery catalog does not always carry one: an
+ *  uncataloged but real test file is accepted deliberately, and its language is
+ *  unknown. The clause is omitted in that case. */
+language: string | undefined): {
+    clause: string;
+    args?: {
+        codeReuse: true;
+        modularizeCode: false;
+    };
+} | undefined;
+/**
+ * Whether a test of this type and language owes the modularize → reuse pair.
+ * Routing (isModularizeFirstTarget) says which flows modularize first; the utils
+ * spec says which languages have a payable reuse half — recordReuseHandOff writes
+ * nothing for a language without one (Java), so instructing the pair there would
+ * be a debt nothing tracks.
+ */
+export declare function isModularizeFirstHandOffTarget(testType: TestType, 
+/** Optional because generation's own `language` param is: the predicate is the
+ *  thing that decides an absent or unsupported language owes nothing. */
+language: string | undefined): language is UtilsLanguage;
+/** The argument clause of the skyramp_reuse_code call the agent is told to make. */
+export declare function reuseCodeArgsClause(language: string | undefined, testType: TestType, framework: string): string;
+export declare function buildModularizeFirstNextSteps(params: {
+    testType: TestType;
+    /** Narrowed by isModularizeFirstHandOffTarget, which both callers apply
+     *  first: a language with no utils spec never reaches these steps. */
+    language: UtilsLanguage;
+    framework: string;
+    enhanceFirst: boolean;
+}): string;