@skyramp/mcp 0.4.2 → 0.4.3-rc.2

package/build/types/RepositoryAnalysis.d.ts

@@ -251,15 +251,15 @@ export declare const endpointInteractionSchema: z.ZodObject<{
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, "strip", z.ZodTypeAny, {
+        queryParams?: Record<string, any> | undefined;
         body?: Record<string, any> | undefined;
         contentType?: string | undefined;
         headers?: Record<string, string> | undefined;
-        queryParams?: Record<string, any> | undefined;
     }, {
+        queryParams?: Record<string, any> | undefined;
         body?: Record<string, any> | undefined;
         contentType?: string | undefined;
         headers?: Record<string, string> | undefined;
-        queryParams?: Record<string, any> | undefined;
     }>;
     response: z.ZodObject<{
         statusCode: z.ZodNumber;
@@ -314,10 +314,10 @@ export declare const endpointInteractionSchema: z.ZodObject<{
     type: "error" | "success" | "edge-case";
     description: string;
     request: {
+        queryParams?: Record<string, any> | undefined;
         body?: Record<string, any> | undefined;
         contentType?: string | undefined;
         headers?: Record<string, string> | undefined;
-        queryParams?: Record<string, any> | undefined;
     };
     response: {
         description: string;
@@ -336,10 +336,10 @@ export declare const endpointInteractionSchema: z.ZodObject<{
     type: "error" | "success" | "edge-case";
     description: string;
     request: {
+        queryParams?: Record<string, any> | undefined;
         body?: Record<string, any> | undefined;
         contentType?: string | undefined;
         headers?: Record<string, string> | undefined;
-        queryParams?: Record<string, any> | undefined;
     };
     response: {
         description: string;
@@ -390,15 +390,15 @@ export declare const endpointMethodSchema: z.ZodObject<{
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         }, "strip", z.ZodTypeAny, {
+            queryParams?: Record<string, any> | undefined;
             body?: Record<string, any> | undefined;
             contentType?: string | undefined;
             headers?: Record<string, string> | undefined;
-            queryParams?: Record<string, any> | undefined;
         }, {
+            queryParams?: Record<string, any> | undefined;
             body?: Record<string, any> | undefined;
             contentType?: string | undefined;
             headers?: Record<string, string> | undefined;
-            queryParams?: Record<string, any> | undefined;
         }>;
         response: z.ZodObject<{
             statusCode: z.ZodNumber;
@@ -453,10 +453,10 @@ export declare const endpointMethodSchema: z.ZodObject<{
         type: "error" | "success" | "edge-case";
         description: string;
         request: {
+            queryParams?: Record<string, any> | undefined;
             body?: Record<string, any> | undefined;
             contentType?: string | undefined;
             headers?: Record<string, string> | undefined;
-            queryParams?: Record<string, any> | undefined;
         };
         response: {
             description: string;
@@ -475,10 +475,10 @@ export declare const endpointMethodSchema: z.ZodObject<{
         type: "error" | "success" | "edge-case";
         description: string;
         request: {
+            queryParams?: Record<string, any> | undefined;
             body?: Record<string, any> | undefined;
             contentType?: string | undefined;
             headers?: Record<string, string> | undefined;
-            queryParams?: Record<string, any> | undefined;
         };
         response: {
             description: string;
@@ -512,10 +512,10 @@ export declare const endpointMethodSchema: z.ZodObject<{
         type: "error" | "success" | "edge-case";
         description: string;
         request: {
+            queryParams?: Record<string, any> | undefined;
             body?: Record<string, any> | undefined;
             contentType?: string | undefined;
             headers?: Record<string, string> | undefined;
-            queryParams?: Record<string, any> | undefined;
         };
         response: {
             description: string;
@@ -551,10 +551,10 @@ export declare const endpointMethodSchema: z.ZodObject<{
         type: "error" | "success" | "edge-case";
         description: string;
         request: {
+            queryParams?: Record<string, any> | undefined;
             body?: Record<string, any> | undefined;
             contentType?: string | undefined;
             headers?: Record<string, string> | undefined;
-            queryParams?: Record<string, any> | undefined;
         };
         response: {
             description: string;
@@ -632,15 +632,15 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
                 headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
             }, "strip", z.ZodTypeAny, {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             }, {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             }>;
             response: z.ZodObject<{
                 statusCode: z.ZodNumber;
@@ -695,10 +695,10 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
             type: "error" | "success" | "edge-case";
             description: string;
             request: {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             };
             response: {
                 description: string;
@@ -717,10 +717,10 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
             type: "error" | "success" | "edge-case";
             description: string;
             request: {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             };
             response: {
                 description: string;
@@ -754,10 +754,10 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
             type: "error" | "success" | "edge-case";
             description: string;
             request: {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             };
             response: {
                 description: string;
@@ -793,10 +793,10 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
             type: "error" | "success" | "edge-case";
             description: string;
             request: {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             };
             response: {
                 description: string;
@@ -819,7 +819,6 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     path: string;
-    resourceGroup: string;
     pathParams: {
         type: string;
         name: string;
@@ -827,6 +826,7 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
         description?: string | undefined;
         constraints?: string | undefined;
     }[];
+    resourceGroup: string;
     methods: {
         method: string;
         description: string;
@@ -843,10 +843,10 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
             type: "error" | "success" | "edge-case";
             description: string;
             request: {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             };
             response: {
                 description: string;
@@ -869,7 +869,6 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
     }[];
 }, {
     path: string;
-    resourceGroup: string;
     pathParams: {
         type: string;
         name: string;
@@ -877,6 +876,7 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
         description?: string | undefined;
         constraints?: string | undefined;
     }[];
+    resourceGroup: string;
     methods: {
         method: string;
         description: string;
@@ -893,10 +893,10 @@ export declare const enrichedEndpointSchema: z.ZodObject<{
             type: "error" | "success" | "edge-case";
             description: string;
             request: {
+                queryParams?: Record<string, any> | undefined;
                 body?: Record<string, any> | undefined;
                 contentType?: string | undefined;
                 headers?: Record<string, string> | undefined;
-                queryParams?: Record<string, any> | undefined;
             };
             response: {
                 description: string;

package/build/types/ReuseOutcome.d.ts

@@ -131,6 +131,101 @@ export interface RetrofitOutcome {
     file: string;
     execution?: TestExecutionStatus;
 }
+/** What a run did to a helper that already existed in the repository. A helper the
+ *  module gained is not here: this run created it, and it has no incumbent callers
+ *  whose behaviour it could change. */
+export type HelperChangeKind = 
+/** The parameter list differs — the change a caller's own diff can be read
+ *  against, and the one an added argument or a re-defaulted argument lands in
+ *  (a helper re-defaulted to a rejection status is the recorded case). */
+"signature"
+/** The parameter list is byte-identical and the body is not. The dangerous case
+ *  for a browser helper: a selector change alters what every caller does and
+ *  appears in no calling test's diff. */
+ | "body"
+/** The incumbent defined it and the module no longer does. Every caller's import
+ *  now names something that is not there. */
+ | "removed";
+/** A helper this run changed in a module that already existed in the repository,
+ *  with the tests that call it.
+ *
+ *  A shared helper's change reaches every caller at once — that is the feature's
+ *  value and its danger. A caller the run did not touch is not delivered, so nothing
+ *  executed it, and a break in one reached the customer's own continuous integration
+ *  instead of this report. A browser helper is the worse case: its selector can
+ *  change with no signature change at all, and the change appears in no calling
+ *  test's diff. */
+export interface ChangedHelperEntry {
+    /** REPOSITORY-RELATIVE path (posix) of the module that defines it — per helper,
+     *  as {@link OrphanedHelper} names its: a delivery can carry several modules, and
+     *  the same helper name in two of them is two entries a reader must tell apart. */
+    utilsFile: string;
+    helper: string;
+    change: HelperChangeKind;
+    /** The Skyramp-generated tests that call it, by BASENAME, each with the execution
+     *  recorded against the module as it stands.
+     *
+     *  SCOPED TO THE MODULE'S OWN DIRECTORY, which is as far as the caller walk reads.
+     *  A generated test that imports the module from another directory is not here, so
+     *  this is a lower bound: read it as "the callers found beside the module", never
+     *  as "every test that calls it". The gate acts only on what is listed, so a caller
+     *  it cannot see costs a report line and an unrun test — never a false block, which
+     *  is the direction this feature chooses everywhere.
+     *
+     *  ABSENT means even that much could not be established — never "no test calls
+     *  it". An empty array is the positive statement that the walk ran and found
+     *  none beside the module. A caller with no `execution` and no `deliveredByThisRun`
+     *  was not run: the run could not execute it (a native suite, or a test the prescan
+     *  never inventoried), which is disclosed rather than blocked on. */
+    callers?: ChangedHelperCaller[];
+}
+export interface ChangedHelperCaller {
+    /** BASENAME of the calling test. */
+    file: string;
+    execution?: TestExecutionStatus;
+    /** This run delivered or edited the caller, so its own row in this report carries
+     *  its execution and its own checks judge it. Read an absent `execution` as "not
+     *  run" only when this is absent too. */
+    deliveredByThisRun?: true;
+}
+/** A helper in a shared module that NO Skyramp-generated test imports.
+ *
+ *  A run can delete a test, and a helper that test was the last importer of stays in
+ *  the module. The customer then maintains code nothing calls, and nothing in the
+ *  pull request says so — the agent was told, and the reviewer was not.
+ *
+ *  REPORTED, never removed, and never gated. Removing a helper that is still called
+ *  is far worse than leaving a dead one, and the caller list this is read from is a
+ *  lower bound scoped to the module's directory. A reader decides; the run does not. */
+export interface OrphanedHelper {
+    /** REPOSITORY-RELATIVE path (posix) of the module that defines it. Per helper, not
+     *  per row: a delivery can carry several modules, and a reader needs the file to
+     *  open. */
+    utilsFile: string;
+    helper: string;
+}
+/** A shared module this run CREATED and then REMOVED before delivery, with the
+ *  reason the run state holds for it.
+ *
+ *  A run builds a module, rewires tests onto it, and — when its verify pass keeps
+ *  failing — deletes it and restores the inline code. Nothing then locates the
+ *  module: the delivered tests import nothing, and every row reads as "nothing to
+ *  reuse", which is the silence this entry exists to break. An incumbent module the
+ *  run deleted is disclosed helper by helper under {@link ChangedHelperEntry}
+ *  (`removed`); this is the module HEAD never held, which that comparison cannot
+ *  see. Attached to every row in the module's own directory — the tests the module
+ *  was built beside. */
+export interface RemovedModuleEntry {
+    /** REPOSITORY-RELATIVE path (posix) the module had. */
+    utilsFile: string;
+    /** In a reader's words: that the run created and removed it, and what the last
+     *  verify pass that had it said. */
+    reason: string;
+    /** The failures of the last verify pass that had the module, when it failed —
+     *  the same shape as {@link HelperReuseOutcome.verificationFailures}. Absent when
+     *  that pass passed. */
+    verificationFailures?: ReuseVerificationFailure[];
+}
 /** Shared-helper reuse for an API test, re-derived from the delivered files at report
  *  time — nothing here is read back from what the agent or the verify pass recorded.
  *  Absent altogether when no utils file exists for the test (the same omission rule
@@ -159,6 +254,16 @@ export interface HelperReuseOutcome {
      *  wraps — reuse that was available and not taken. Omitted at zero. Informational,
      *  like {@link ReuseOutcome.missedReuse}. */
     siblingInlineCallSites?: number;
+    /** Helpers in `utilsFile` that no Skyramp-generated test imports — see
+     *  {@link OrphanedHelper}. Omitted when there are none, and omitted (with
+     *  `orphanScanIncomplete` set) when the walk could not establish the importers at
+     *  all. Informational: nothing gates on it. */
+    orphanedHelpers?: OrphanedHelper[];
+    /** Present — and only ever `true` — when the importer walk could not read every
+     *  file beside the module, so no helper is reported as orphaned. Absent means the
+     *  walk ran, so an absent `orphanedHelpers` then means none were found rather than
+     *  that nothing was looked for. */
+    orphanScanIncomplete?: true;
     /** Whether the delivered utils file holds the shared-helper invariants: one helper
      *  per method+path, status-code-only assertions, method+resource names — with
      *  documented declines (`reuse-verify: allow …`) counted as holding. */
@@ -296,6 +401,24 @@ export interface ReuseOutcome {
      *  not the module, and is most telling when no module exists at all — the case
      *  where `helpers` is rightly absent. Omitted at zero. Informational. */
     unextractedDuplicateSites?: number;
+    /** Helpers that already existed in the repository and that this run CHANGED, each
+     *  with the tests that call it. Omitted when the run changed no incumbent helper —
+     *  which is every first run, where the module is created rather than edited. A
+     *  helper an earlier run created and this one changed appears here as changed,
+     *  never as created.
+     *
+     *  Top level, not on the helpers row, for the same reason as
+     *  {@link unextractedDuplicateSites}: it describes what happened to a module, and
+     *  it is most telling when NO module is there to describe — a run that deleted or
+     *  renamed the shared module removes every helper at once and leaves `helpers`
+     *  rightly absent, which is exactly when a reader most needs to be told. See
+     *  {@link ChangedHelperEntry}. */
+    changedHelpers?: ChangedHelperEntry[];
+    /** Shared modules this run created beside this test and removed again before
+     *  delivery — see {@link RemovedModuleEntry}. Top level like `changedHelpers`,
+     *  and for the same reason: there is no `helpers` row left to hang it on, which
+     *  is exactly when a reader most needs to be told. Omitted when none. */
+    removedModules?: RemovedModuleEntry[];
     verification?: ReuseVerificationOutcome;
     /** Why `verification` is `failed` on the page-object path, on the same terms as
      *  {@link HelperReuseOutcome.verificationFailures}: present only when the

package/build/types/TestExecution.d.ts

@@ -14,6 +14,17 @@ export declare enum TestExecutionStatus {
     /** Execution was expected (UPDATE/REGENERATE) but no result was recorded. */
     Unknown = "Unknown"
 }
+/** Whether a status is a RESULT: the test ran and pass, fail or error is what it
+ *  did. `Skipped` is a decision not to execute and `Unknown` is an execution that was
+ *  expected and recorded nothing — neither may satisfy a demand for a run, or a run
+ *  that never touched the file would clear the debt for it. */
+export declare function isResult(status: TestExecutionStatus): boolean;
+/** The status of `record` when it is a result that ran the bytes written at
+ *  `sinceMs` or later, and `undefined` otherwise. THE freshness rule, for every gate
+ *  that asks whether a file has been run as it now stands: an execution older than
+ *  the last write to what it exercised ran bytes that no longer exist. Which write —
+ *  the file's own, or a module's under it — is the caller's to say. */
+export declare function freshExecution(record: Pick<TestExecutionData, "status" | "executedAt"> | undefined, sinceMs: number): TestExecutionStatus | undefined;
 export interface TestExecutionData {
     status: TestExecutionStatus;
     executedAt: string;

package/build/types/TestExecution.js

@@ -14,3 +14,22 @@ export var TestExecutionStatus;
     /** Execution was expected (UPDATE/REGENERATE) but no result was recorded. */
     TestExecutionStatus["Unknown"] = "Unknown";
 })(TestExecutionStatus || (TestExecutionStatus = {}));
+/** Whether a status is a RESULT: the test ran and pass, fail or error is what it
+ *  did. `Skipped` is a decision not to execute and `Unknown` is an execution that was
+ *  expected and recorded nothing — neither may satisfy a demand for a run, or a run
+ *  that never touched the file would clear the debt for it. */
+export function isResult(status) {
+    return (status === TestExecutionStatus.Pass ||
+        status === TestExecutionStatus.Fail ||
+        status === TestExecutionStatus.Error);
+}
+/** The status of `record` when it is a result that ran the bytes written at
+ *  `sinceMs` or later, and `undefined` otherwise. THE freshness rule, for every gate
+ *  that asks whether a file has been run as it now stands: an execution older than
+ *  the last write to what it exercised ran bytes that no longer exist. Which write —
+ *  the file's own, or a module's under it — is the caller's to say. */
+export function freshExecution(record, sinceMs) {
+    if (!record || !isResult(record.status))
+        return undefined;
+    return Date.parse(record.executedAt) >= sinceMs ? record.status : undefined;
+}

package/build/types/index.d.ts

@@ -4,5 +4,5 @@ export { TestType, HttpMethod } from "./TestTypes.js";
 export type { TestbotReport } from "./TestbotReport.js";
 export { IssueFoundCategory } from "./TestbotReport.js";
 export { ReuseDeclinedBy, ReuseVerificationOutcome, HelperVerificationOutcome, } from "./ReuseOutcome.js";
-export type { ReuseOutcome, ReuseSkippedEntry, ReuseMissedEntry, HelperReuseOutcome, RetrofitOutcome, } from "./ReuseOutcome.js";
+export type { ReuseOutcome, ReuseSkippedEntry, ReuseMissedEntry, HelperReuseOutcome, RetrofitOutcome, ChangedHelperEntry, ChangedHelperCaller, OrphanedHelper, } from "./ReuseOutcome.js";
 export type { RelatedRepository, TestbotPromptOptions, } from "./TestbotPromptOptions.js";

package/build/utils/branchDiff.d.ts

@@ -72,5 +72,5 @@ export declare function changedFileNames(diff: BranchDiffData): ChangedFileName[
  *  compares two commits through the three-dot form, which is the CI shape. */
 export declare function computeBranchDiff(repositoryPath: string, providedBaseBranch?: string, includeUncommitted?: boolean, 
 /** Names only: no diff text is computed, and `diffContent`/`diffStat` come back
- *  empty. The plan checks read which files changed, never what changed in them. */
+ *  empty. */
 namesOnly?: boolean): Promise<BranchDiffData>;

package/build/utils/branchDiff.js

@@ -349,7 +349,7 @@ export function changedFileNames(diff) {
  *  compares two commits through the three-dot form, which is the CI shape. */
 export async function computeBranchDiff(repositoryPath, providedBaseBranch, includeUncommitted = false, 
 /** Names only: no diff text is computed, and `diffContent`/`diffStat` come back
- *  empty. The plan checks read which files changed, never what changed in them. */
+ *  empty. */
 namesOnly = false) {
     const git = simpleGit(repositoryPath);
     const isRepo = await git.checkIsRepo();

package/build/utils/changedRuns.d.ts

@@ -0,0 +1,13 @@
+/** One run of consecutive changed lines in a file: lines removed, added, or both. */
+export interface ChangedRun {
+    file: string;
+    /** First and last line of the run in the new file. A run that only removes
+     *  lines has none of its own, so both name the line that now follows it. */
+    start: number;
+    end: number;
+    /** The run's first changed line as the diff shows it, for the evidence. */
+    firstLine: string;
+}
+/** Every run of changed lines, file by file, in the new file's numbering. A run
+ *  whose changed lines are all blank changes nothing a test can observe. */
+export declare function collectChangedRuns(rawDiff: string): ChangedRun[];

package/build/utils/changedRuns.js

@@ -0,0 +1,56 @@
+import { diffBlocksByPath } from "./branchDiff.js";
+/** Every run of changed lines, file by file, in the new file's numbering. A run
+ *  whose changed lines are all blank changes nothing a test can observe. */
+export function collectChangedRuns(rawDiff) {
+    const runs = [];
+    for (const [file, block] of diffBlocksByPath(rawDiff)) {
+        let inHunk = false;
+        let newLine = 0;
+        let open;
+        const close = () => {
+            if (open && open.lines.some((text) => text.slice(1).trim() !== "")) {
+                runs.push({
+                    file,
+                    start: open.start,
+                    end: open.added > 0 ? open.start + open.added - 1 : open.start,
+                    firstLine: open.lines.find((text) => text.slice(1).trim() !== "") ?? "",
+                });
+            }
+            open = undefined;
+        };
+        for (const text of block.split("\n")) {
+            // A path printed twice holds its header twice, and the second one is no hunk.
+            if (text.startsWith("diff ")) {
+                close();
+                inHunk = false;
+                continue;
+            }
+            const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)/.exec(text);
+            if (hunk) {
+                close();
+                inHunk = true;
+                newLine = Number(hunk[1]);
+                continue;
+            }
+            // Only the file header spells `---`/`+++`; inside a hunk they are content.
+            if (!inHunk)
+                continue;
+            if (text.startsWith("-") || text.startsWith("+")) {
+                open ??= { start: newLine, added: 0, lines: [] };
+                open.lines.push(text);
+                if (text.startsWith("+")) {
+                    open.added++;
+                    newLine++;
+                }
+            }
+            else if (!text.startsWith("\\")) {
+                // `` belongs to the line before it.
+                close();
+                if (text.startsWith(" "))
+                    newLine++;
+            }
+        }
+        close();
+    }
+    return runs;
+}

package/build/utils/featureFlags.d.ts

@@ -4,8 +4,9 @@
  * Each helper in this module reads a `SKYRAMP_FEATURE_*` env var and returns
  * a boolean. These helpers treat a flag as ON only when the env var is
  * exactly `"1"`; anything else (unset, empty, "0", "true", "false", etc.) is
- * treated as OFF. The utils-reuse flag is additionally ON for the orgs in
- * `UTILS_REUSE_DEFAULT_ORGS` regardless of the env vars.
+ * treated as OFF. The POM-reuse and utils-reuse flags are additionally ON for
+ * the orgs in `POM_REUSE_DEFAULT_ORGS` and `UTILS_REUSE_DEFAULT_ORGS`
+ * regardless of the env vars.
  */
 /**
  * Gates BOTH consumer-side contract tests AND the SDK's "default mode"
@@ -54,15 +55,12 @@ export declare function isLocalDevEnabled(): boolean;
 export declare function isOneClickEnabled(): boolean;
 /**
  * Gates the POM-aware path of `skyramp_reuse_code`
- * (SKYRAMP_FEATURE_POM_REUSE=1).
+ * (SKYRAMP_FEATURE_POM_REUSE=1, or a `POM_REUSE_DEFAULT_ORGS` org).
  *
- * Deliberately NOT defaulted on for `UTILS_REUSE_DEFAULT_ORGS`: for UI tests
- * the POM path supersedes the modularize-first flow (see
- * `isModularizeFirstTarget` in utils/reuseRouting.ts), so an org-level POM
- * default would stop those orgs' UI tests from ever seeding a SkyrampUtils
- * file — the very thing the utils org default exists to provide (SKYR-4290).
- * And an explicit-"0"-override escape hatch cannot work either, because
- * testbot normalizes an unset flag to a literal "0" before forwarding.
+ * With both flags on, a UI test takes the POM pass first and the
+ * modularize-first flow over what it left inline (see `isPomFirstTarget` in
+ * utils/reuseRouting.ts), so a `POM_REUSE_DEFAULT_ORGS` org that also has the
+ * utils default still seeds a SkyrampUtils file for its UI tests.
  *
  * When OFF (default), TypeScript/JavaScript + Playwright targets are treated
  * like every other target: `skyramp_reuse_code` returns the SkyrampUtils

package/build/utils/featureFlags.js

@@ -4,8 +4,9 @@
  * Each helper in this module reads a `SKYRAMP_FEATURE_*` env var and returns
  * a boolean. These helpers treat a flag as ON only when the env var is
  * exactly `"1"`; anything else (unset, empty, "0", "true", "false", etc.) is
- * treated as OFF. The utils-reuse flag is additionally ON for the orgs in
- * `UTILS_REUSE_DEFAULT_ORGS` regardless of the env vars.
+ * treated as OFF. The POM-reuse and utils-reuse flags are additionally ON for
+ * the orgs in `POM_REUSE_DEFAULT_ORGS` and `UTILS_REUSE_DEFAULT_ORGS`
+ * regardless of the env vars.
  */
 /**
  * Gates BOTH consumer-side contract tests AND the SDK's "default mode"
@@ -62,15 +63,12 @@ export function isOneClickEnabled() {
 }
 /**
  * Gates the POM-aware path of `skyramp_reuse_code`
- * (SKYRAMP_FEATURE_POM_REUSE=1).
+ * (SKYRAMP_FEATURE_POM_REUSE=1, or a `POM_REUSE_DEFAULT_ORGS` org).
  *
- * Deliberately NOT defaulted on for `UTILS_REUSE_DEFAULT_ORGS`: for UI tests
- * the POM path supersedes the modularize-first flow (see
- * `isModularizeFirstTarget` in utils/reuseRouting.ts), so an org-level POM
- * default would stop those orgs' UI tests from ever seeding a SkyrampUtils
- * file — the very thing the utils org default exists to provide (SKYR-4290).
- * And an explicit-"0"-override escape hatch cannot work either, because
- * testbot normalizes an unset flag to a literal "0" before forwarding.
+ * With both flags on, a UI test takes the POM pass first and the
+ * modularize-first flow over what it left inline (see `isPomFirstTarget` in
+ * utils/reuseRouting.ts), so a `POM_REUSE_DEFAULT_ORGS` org that also has the
+ * utils default still seeds a SkyrampUtils file for its UI tests.
  *
  * When OFF (default), TypeScript/JavaScript + Playwright targets are treated
  * like every other target: `skyramp_reuse_code` returns the SkyrampUtils
@@ -83,7 +81,8 @@ export function isOneClickEnabled() {
  * the verification gates apply.
  */
 export function isPomReuseEnabled() {
-    return process.env.SKYRAMP_FEATURE_POM_REUSE === "1";
+    return (process.env.SKYRAMP_FEATURE_POM_REUSE === "1" ||
+        isDefaultOrg(POM_REUSE_DEFAULT_ORGS));
 }
 /**
  * Gates SkyrampUtils code reuse for integration tests on the testbot path, and
@@ -107,27 +106,30 @@ export function isPomReuseEnabled() {
  * yields the single reuse pass it did before the feature existed.
  */
 export function isUtilsReuseEnabled() {
-    return (process.env.SKYRAMP_FEATURE_UTILS_REUSE === "1" || isUtilsReuseDefaultOrg());
+    return (process.env.SKYRAMP_FEATURE_UTILS_REUSE === "1" ||
+        isDefaultOrg(UTILS_REUSE_DEFAULT_ORGS));
 }
 /**
- * GitHub orgs where SkyrampUtils code reuse is on by default, without
- * requiring the SKYRAMP_FEATURE_UTILS_REUSE env var. Compared
- * case-insensitively (GitHub owner handles are case-insensitive, but
- * GITHUB_REPOSITORY_OWNER preserves display casing). Because this ORs with
- * the env check, these orgs cannot turn the feature off by setting the env
- * var to "0". POM reuse has no org default — see `isPomReuseEnabled`.
+ * GitHub orgs where a reuse feature is on by default, without requiring its
+ * SKYRAMP_FEATURE_* env var. Compared case-insensitively (GitHub owner handles
+ * are case-insensitive, but GITHUB_REPOSITORY_OWNER preserves display casing).
+ * Because these OR with the env check, these orgs cannot turn the feature off
+ * by setting the env var to "0" — and testbot normalizes an unset flag to a
+ * literal "0" anyway.
  *
- * "Skyramp-HandsOn" is the Wipro / IntelliAssure pilot org (SKYR-4286).
+ * "Skyramp-HandsOn" is the Wipro / IntelliAssure pilot org (SKYR-4286 for
+ * utils reuse, SKYR-4514 for POM reuse).
  */
 const UTILS_REUSE_DEFAULT_ORGS = ["skyramp-handson"];
-function isUtilsReuseDefaultOrg() {
+const POM_REUSE_DEFAULT_ORGS = ["skyramp-handson"];
+function isDefaultOrg(orgs) {
     // GITHUB_REPOSITORY_OWNER is set on GitHub Actions runners; fall back to
     // the owner half of GITHUB_REPOSITORY ("owner/repo") for environments that
     // only set the latter.
     const owner = process.env.GITHUB_REPOSITORY_OWNER ??
         process.env.GITHUB_REPOSITORY?.split("/")[0] ??
         "";
-    return UTILS_REUSE_DEFAULT_ORGS.includes(owner.toLowerCase());
+    return orgs.includes(owner.toLowerCase());
 }
 /**
  * Returns true when the calling agent has the Skyramp Agent Skills plugin

package/build/utils/normalizeSkyrampImports.d.ts

@@ -1,7 +1,10 @@
 /**
  * Ensure `expect` is imported from `@skyramp/skyramp` rather than `@playwright/test`.
  * - Strips `expect` from any `@playwright/test` import (keeps other identifiers).
- * - If the file uses `expect(...)`, ensures an `@skyramp/skyramp` import carries `expect`.
+ * - If the file uses `expect(...)`, ensures its `@skyramp/skyramp` import carries `expect`.
+ * A file with no `@skyramp/skyramp` import is not a Skyramp test (a repository's
+ * own spec), so it is left alone, as is a file that takes `expect` from another
+ * module.
  * Returns the original string if no rewrite was needed.
  */
 export declare function normalizeSkyrampExpectImport(source: string): string;