@skyramp/mcp 0.4.2 → 0.4.3-rc.1

package/build/tools/code-refactor/reuse-state.js

@@ -1,11 +1,11 @@
 import * as fsp from "fs/promises";
 import * as path from "path";
-import { readFile, stat, access, constants as fsConstants } from "fs/promises";
-import { realpathSync } from "fs";
+import { readFile, stat } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { logger } from "../../utils/logger.js";
-import { resolveRunStatePath, StateManager, } from "../../utils/AnalysisStateManager.js";
+import { resolveRunStatePath, } from "../../utils/AnalysisStateManager.js";
+import { isAbsentFromHead } from "../../utils/utils-verify/head.js";
 import { verifyReuse, } from "../../utils/pom-verify/index.js";
 import { buildSkipped, findUnparsableKeptInline, flaggedFrom, mergeFlagged, verificationFrom, ReuseVerificationOutcome, HelperVerificationOutcome, } from "./reuse-outcome.js";
 import { verifyUtils, realpath, utilsSpecFor, countAssertions, hasPageErrorGuard, utilsSpecForFile, } from "../../utils/utils-verify/index.js";
@@ -18,6 +18,11 @@ const execFileAsync = promisify(execFile);
 import { resolvePomCatalogPath } from "../../utils/pom-catalog.js";
 import { parsePomCatalog, findMissedReuse, } from "../../utils/pom-catalog-parse.js";
 import { ProgrammingLanguage } from "../../types/TestTypes.js";
+import { canonPath, freshRecord, owns, readHandOff, readReuseRecord, readRunState, runStateWritable, samePath, updateReuseOutcome, } from "./reuse-record-store.js";
+import { combineRederivations, pomFirstHandOff } from "./pom-pass-state.js";
+/** The canonical path comparison the records use — declared in the store, re-exported
+ *  here for the readers that always imported it from this module. */
+export { samePath, canonPath } from "./reuse-record-store.js";
 /**
  * Persistence for the server-derived POM-reuse outcome, keyed by test-file
  * basename (what `newTestsCreated[].fileName` carries, so
@@ -28,52 +33,6 @@ import { ProgrammingLanguage } from "../../types/TestTypes.js";
  * file degrades to "no reuse summary in the report" — the same outcome as running
  * outside a Testbot run, where there is no run state to record into.
  */
-/**
- * Read-modify-write one spec's outcome. `patch` receives the entry recorded so
- * far, so a caller that needs prior state (the verify pass, which accumulates
- * flagged members) uses the same path as one that does not.
- *
- * Fields the patch omits are preserved: the prompt-generation call knows the
- * candidate count, each verify pass knows the counts and verdict.
- */
-async function updateReuseOutcome(testFile, patch, explicitStateFile) {
-    const stateFile = resolveRunStatePath(explicitStateFile);
-    if (!stateFile)
-        return false;
-    try {
-        const manager = StateManager.fromStatePath(stateFile);
-        const data = await manager.readData();
-        if (!data)
-            return false;
-        const key = path.basename(testFile);
-        const existing = data.reuseOutcomes?.[key] ?? {};
-        await manager.appendData({
-            ...data,
-            reuseOutcomes: {
-                ...data.reuseOutcomes,
-                [key]: { ...existing, ...patch(existing) },
-            },
-        });
-        return true;
-    }
-    catch (err) {
-        logger.warning("Could not record POM-reuse outcome — report will omit the reuse summary", {
-            testFile,
-            error: String(err),
-        });
-        return false;
-    }
-}
-/** Read one spec's record, or `undefined` when there is no run state, no record, or the
- * state file cannot be read. Shares `updateReuseOutcome`'s resolve-read-basename plumbing
- * so the two cannot disagree about which key a spec maps to. */
-async function readReuseRecord(testFile, explicitStateFile) {
-    const stateFile = resolveRunStatePath(explicitStateFile);
-    if (!stateFile)
-        return undefined;
-    const data = await StateManager.fromStatePath(stateFile).readData();
-    return data?.reuseOutcomes?.[path.basename(testFile)];
-}
 /**
  * Record the tier-1 candidate count STEP 1 detected, plus the identity needed to
  * re-derive the counts from the delivered spec later.
@@ -221,17 +180,6 @@ export async function recordUtilsReuseIssued(testFile, language, framework, test
         },
     }), explicitStateFile);
 }
-/** Every field cleared — the patch spread onto a record owned by another spec. */
-function freshRecord() {
-    return {
-        candidatesDetected: undefined,
-        verification: undefined,
-        flagged: undefined,
-        language: undefined,
-        utils: undefined,
-        modularized: undefined,
-    };
-}
 /** A verify pass that threw. Recorded so the debt FAILS OPEN — a verifier that cannot
  *  run must not leave a debt nothing can pay — and cleared by the next successful pass. */
 export async function recordUtilsVerifyError(testFile, explicitStateFile) {
@@ -239,20 +187,6 @@ export async function recordUtilsVerifyError(testFile, explicitStateFile) {
         ? { utils: { ...existing.utils, verifyError: true } }
         : {}, explicitStateFile);
 }
-/** Whether `record` describes `testFile` (or nobody yet). Basename-keyed run state
- *  means two specs can share one record; only the owner's history carries over. */
-function owns(record, testFile) {
-    return !record.testFilePath || samePath(record.testFilePath, testFile);
-}
-/** Canonical comparison: a record written through a symlinked path (macOS /var →
- *  /private/var) must still be recognised as this spec's when checked by realpath. */
-export function samePath(a, b) {
-    return canon(a) === canon(b);
-}
-/** Exported for retrofit-state: the same canonicalisation the records use. */
-export function canonPath(p) {
-    return canon(p);
-}
 /**
  * The label a report row shows for a set of utils files: each file's path relative
  * to its repository root, posix-separated, joined with `, `.
@@ -273,7 +207,7 @@ function repoRelativeLabel(file) {
         return path.basename(file);
     // Both sides canonical: git reports the REAL root, and a path through a symlink
     // (macOS /tmp → /private/tmp) would otherwise relativise to `../../…`.
-    const rel = path.relative(canon(root), canon(file));
+    const rel = path.relative(canonPath(root), canonPath(file));
     // Outside the root means a leading `..` SEGMENT — not any name starting with two
     // dots (`..generated/SkyrampUtils.py` is a valid in-repository path).
     const outside = rel === ".." || rel.startsWith(`..${path.sep}`);
@@ -281,14 +215,6 @@ function repoRelativeLabel(file) {
         return path.basename(file);
     return rel.split(path.sep).join("/");
 }
-function canon(p) {
-    try {
-        return realpathSync(p);
-    }
-    catch {
-        return path.resolve(p);
-    }
-}
 /** Verdict of one utils verify pass. The verdict alone is stored — counts and the
  *  file list are re-derived from the delivered files at report time. */
 export async function recordUtilsVerifyOutcome(testFile, r, language, framework, testType, explicitStateFile, 
@@ -333,20 +259,6 @@ inHouseDeclared) {
         };
     }, explicitStateFile);
 }
-/** Whether the run state file can be written — the precondition for any debt this
- *  module holds, since only a write clears it. */
-async function runStateWritable(explicitStateFile) {
-    const stateFile = resolveRunStatePath(explicitStateFile);
-    if (!stateFile)
-        return false;
-    try {
-        await access(stateFile, fsConstants.W_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /** `skyramp_modularization` was called for this spec. Ownership on the write, like
  *  the utils debt: a same-basename spec elsewhere does not inherit the mark. */
 export async function recordModularized(testFile, explicitStateFile) {
@@ -399,14 +311,11 @@ export async function utilsBaselineFor(testFile, explicitStateFile) {
  */
 export async function pendingModularization(testFile, explicitStateFile) {
     try {
-        const stateFile = resolveRunStatePath(explicitStateFile);
-        if (!stateFile)
-            return undefined;
-        const data = await StateManager.fromStatePath(stateFile).readData();
-        const handOff = data?.reuseHandOffs?.[await realpath(testFile)];
-        if (!handOff)
+        const read = await readHandOff(testFile, explicitStateFile);
+        if (!read?.handOff)
             return undefined;
-        const record = data?.reuseOutcomes?.[path.basename(testFile)];
+        const { data, handOff } = read;
+        const record = data.reuseOutcomes?.[path.basename(testFile)];
         if (record && !owns(record, testFile))
             return undefined;
         if (record?.modularized)
@@ -506,14 +415,11 @@ export async function recordReuseHandOff(files, testType, language, framework, e
     // nothing on the reuse side records for it — so no hand-off is owed either.
     if (!utilsSpecFor(language))
         return;
-    const stateFile = resolveRunStatePath(explicitStateFile);
-    if (!stateFile)
-        return;
     try {
-        const manager = StateManager.fromStatePath(stateFile);
-        const data = await manager.readData();
-        if (!data)
+        const state = await readRunState(explicitStateFile);
+        if (!state)
             return;
+        const { manager, data } = state;
         // A REGENERATE marks its file as maintenance before the generation call it
         // prescribes records the same file as generation. The rewrite is still the
         // maintenance of a file at HEAD, so the origin is never demoted.
@@ -567,9 +473,7 @@ async function isNewInRepo(file) {
         // Only "absent from HEAD" (or no HEAD yet) means new. Anything else — git missing,
         // a corrupt object store, a permission error — is git not answering, and the
         // documented answer to that is false: never block, never accuse, on a malfunction.
-        const e = err;
-        const text = `${e.stderr ?? ""} ${String(err)}`;
-        if (/does not exist|Not a valid object name|bad revision|exists on disk, but not in/i.test(text))
+        if (isAbsentFromHead(err))
             return true;
         logger.warning("Could not determine whether a file is new in the repository — treating it as pre-existing", {
             file,
@@ -596,17 +500,14 @@ async function isNewInRepo(file) {
  */
 export async function pendingReuseChain(testFile, explicitStateFile, testType) {
     try {
-        const stateFile = resolveRunStatePath(explicitStateFile);
-        if (!stateFile)
-            return undefined;
-        const data = await StateManager.fromStatePath(stateFile).readData();
         // Keyed by the GENERATED FILE: generation snapshots its outputDir before and after
         // the codegen call and records exactly the files it wrote, so a test generated
         // without codeReuse into the same directory owes nothing, and neither does a
         // pre-existing test beside it.
-        const handOff = data?.reuseHandOffs?.[await realpath(testFile)];
-        if (!handOff)
+        const read = await readHandOff(testFile, explicitStateFile);
+        if (!read?.handOff)
             return undefined;
+        const { data, handOff } = read;
         // A caller that knows the file's type and disagrees with the hand-off is exempt;
         // an unknown type still owes (the hand-off is authoritative for this file).
         if (testType && testType !== handOff.testType)
@@ -619,7 +520,7 @@ export async function pendingReuseChain(testFile, explicitStateFile, testType) {
         // and execute.
         if (record && !owns(record, testFile))
             return undefined;
-        if (record && reuseRan(record))
+        if (record && reuseRan(record, pomFirstHandOff(handOff)))
             return undefined;
         const maintained = handOff.source === "maintenance";
         if (!maintained && !(await isNewInRepo(testFile)))
@@ -674,7 +575,7 @@ handOffs) {
         if (record) {
             if (!owns(record, file))
                 continue; // foreign basename — fail open for this file
-            if (reuseRan(record))
+            if (reuseRan(record, pomFirstHandOff(h)))
                 return undefined;
         }
         try {
@@ -693,8 +594,12 @@ handOffs) {
 }
 /** Whether a record shows the reuse tool ran for its spec: the utils path issued its
  *  instructions, or the POM path recorded detection/verification. A modularization mark
- *  alone, or a verify verdict recorded without a prior discovery, is NOT reuse. */
-function reuseRan(record) {
+ *  alone, or a verify verdict recorded without a prior discovery, is NOT reuse. When the
+ *  page-object pass ran first (`pomFirst`), its verdict is only the first half of the
+ *  chain: the pair it owes is paid by the utils path's instructions alone. */
+function reuseRan(record, pomFirst) {
+    if (pomFirst)
+        return record.utils?.issued === true;
     return (record.utils?.issued === true ||
         record.candidatesDetected !== undefined ||
         record.verification !== undefined);
@@ -826,6 +731,13 @@ async function rederiveHelperOutcome(record, carriedAllows) {
                 ...(r.inlineCallSites.length > 0
                     ? { siblingInlineCallSites: r.inlineCallSites.length }
                     : {}),
+                // Helpers nothing imports — the code a deleted test leaves behind for the
+                // customer to maintain. Reported, never removed and never gated: the caller
+                // list behind it is a lower bound, and removing a helper that is still called
+                // is far worse than leaving a dead one. When the walk could not read every
+                // file beside the module it reports NO orphan and says so, rather than let an
+                // unreadable directory read as "nothing imports this".
+                ...orphanFields(r),
                 verification: r.ok
                     ? HelperVerificationOutcome.Passed
                     : HelperVerificationOutcome.Failed,
@@ -836,6 +748,22 @@ async function rederiveHelperOutcome(record, carriedAllows) {
         blocking,
     };
 }
+/** The orphan fields of a report row: the helpers nothing imports, or the statement
+ *  that the walk could not tell. Exactly one of the two, and neither when the walk ran
+ *  and found none. Exported for its tests — the derivation is the whole behaviour. */
+export function orphanFields(r) {
+    if (!r.importersComplete)
+        return { orphanScanIncomplete: true };
+    const orphans = r.singleImporters.filter((h) => h.importers.length === 0);
+    if (orphans.length === 0)
+        return {};
+    return {
+        orphanedHelpers: orphans.map((h) => ({
+            utilsFile: utilsFileLabel([h.file]),
+            helper: h.helper,
+        })),
+    };
+}
 /**
  * The reason behind a failed shared-helper verdict, one entry per blocking kind in
  * the order the verifier found them. The verify pass had these in hand and dropped
@@ -948,18 +876,36 @@ export async function deriveReuseFromDelivered(testFile, language) {
     };
 }
 export async function rederiveReuse(record, carriedAllows) {
-    const { candidatesDetected, verification, flagged, testFilePath, language } = record;
-    // A SkyrampUtils-path record has nothing for the POM verifier to measure; its
-    // outcome is re-derived from the utils file instead.
+    // A SkyrampUtils-path record is re-derived from the utils file. With both reuse
+    // settings on, the same spec also went through the page-object pass first, and its
+    // row carries both halves: the page-object fields and `helpers`/`inHouse`.
     if (record.utils) {
+        let helper;
         try {
-            return await rederiveHelperOutcome(record, carriedAllows);
+            helper = await rederiveHelperOutcome(record, carriedAllows);
         }
         catch (err) {
-            logger.warning("Could not re-derive the shared-helper outcome from the delivered files — omitting it rather than reporting a stale verdict", { testFile: testFilePath, error: String(err) });
-            return { outcome: undefined };
+            logger.warning("Could not re-derive the shared-helper outcome from the delivered files — omitting it rather than reporting a stale verdict", { testFile: record.testFilePath, error: String(err) });
+            helper = { outcome: undefined };
         }
+        if (!record.pomPassFinished)
+            return helper;
+        return combineRederivations(await rederivePomOutcome(record, carriedAllows, true), helper, (carriedAllows ?? []).some((c) => c.keptInline !== undefined), record.testFilePath
+            ? utilsVerifyCall(record, record.testFilePath)
+            : undefined);
     }
+    return rederivePomOutcome(record, carriedAllows);
+}
+/** The page-object half of a row, re-derived from the delivered spec. `composed`
+ *  says the spec also took the SkyrampUtils flow after this pass: the report-time
+ *  gates then split candidates by owner exactly as the live ones did. */
+async function rederivePomOutcome(record, carriedAllows, composed = false) {
+    const { candidatesDetected, verification, flagged, testFilePath, language } = record;
+    // No page-object layer was found: that detection-time fact is the whole half. A
+    // composed spec whose SkyrampUtils flow wrote its identity must not be measured
+    // into page-object counts it never had.
+    if (composed && verification === ReuseVerificationOutcome.SkippedNoPom)
+        return { outcome: { candidatesDetected, verification } };
     // No spec identity was ever recorded, so there is nothing to measure — only the
     // detection-time facts, which no spec change can invalidate. Reached by the
     // no-POM-layer path; a run that detected candidates always records the identity
@@ -971,7 +917,7 @@ export async function rederiveReuse(record, carriedAllows) {
         const specContent = await readFile(testFilePath, "utf8");
         const carriedKeptInline = (carriedAllows ?? []).filter((c) => c.keptInline !== undefined);
         const classification = { covered: new Set(), ran: false };
-        const blocking = await pomBlockingVerdict(testFilePath, language, r, carriedKeptInline.map((c) => c.keptInline), classification);
+        const blocking = await pomBlockingVerdict(testFilePath, language, r, carriedKeptInline.map((c) => c.keptInline), classification, composed);
         // Diagnose the file the report is actually built from. A marker the zero-reuse
         // gate accepts but this cannot parse satisfies the escape hatch while its
         // decline never reaches the report — silent signal loss is the failure class
@@ -1071,7 +1017,7 @@ async function pomBlockingVerdict(testFile, language, r, carriedKeptInline,
 /** Filled with what the zero-reuse gate did — see `zeroReuseGateFailure`. `ran`
  *  stays false on every path that returns before the candidate walk, including the
  *  unknown language and the infra-gate precedence below. */
-classification) {
+classification, composed) {
     // The record's language was written from the reuse tool's validated `language`
     // param, but the record type keeps it a string: a value outside the enum means a
     // check that cannot run, and a check that cannot run does not block.
@@ -1084,6 +1030,7 @@ classification) {
         testFile,
         language: language,
         framework: "playwright",
+        composed,
     };
     let infra;
     let zero;

package/build/tools/code-refactor/utils-verify-gates.js

@@ -36,7 +36,7 @@ export function formatUtilsVerifyText(r, ctx = {}) {
         return ((unchecked.length > 0
             ? `VERIFICATION PASSED — no Skyramp utils file; this test imports ${unchecked.length} module${unchecked.length === 1 ? "" : "s"} the pass read and does not check: ${unchecked
                 .map((f) => path.basename(f))
-                .join(", ")} — the repository's own, tracked without a Skyramp header. The in-house resolve and additive checks did not run: ${r.inHouseChecksSkipped ?? "they run for a UI test with page-object reuse off"}. Continue.`
+                .join(", ")} — the repository's own, tracked without a Skyramp header. The in-house resolve and additive checks did not run: ${r.inHouseChecksSkipped ?? "they run for a UI test in TypeScript or JavaScript with utils reuse on"}. Continue.`
             : "VERIFICATION PASSED — no shared utils file is written or imported for this test; nothing to verify.") +
             tail +
             unextractedDuplicatesAdvisory(r));
@@ -286,11 +286,11 @@ function singleImporterAdvisory(r) {
     const single = r.singleImporters;
     if (single.length === 0 || r.helpers === 0)
         return "";
-    const dead = single.filter((h) => h.importers === 0);
+    const dead = single.filter((h) => h.importers.length === 0);
     const lines = ["", ""];
     if (dead.length > 0)
         lines.push(`ADVISORY — ${dead.length} helper${dead.length === 1 ? " is" : "s are"} imported by NOTHING, not even the test that wrote ${dead.length === 1 ? "it" : "them"} (does not block):`, ...dead.map((h) => `- ${show(h.file, r)}:${h.line} · ${h.helper}`), "A dead helper is always actionable: call it from the test it belongs to, or delete it.");
-    const once = single.filter((h) => h.importers === 1);
+    const once = single.filter((h) => h.importers.length === 1);
     if (once.length === 0)
         return lines.join("\n");
     lines.push(`ADVISORY — ${once.length} of ${r.helpers} shared helper${r.helpers === 1 ? "" : "s"} ${once.length === 1 ? "is" : "are"} imported by exactly one test (does not block):`, ...once.map((h) => `- ${show(h.file, r)}:${h.line} · ${h.helper}`), "Other delivered tests exist and do not call these. Inline a helper back into its test only if it wraps a step specific to this scenario's narrative that no other test would perform as-is; a request wrapper or a cross-test action (sign-in, open a form, apply a filter) stays shared.");

package/build/tools/code-refactor/verify-gates.d.ts

@@ -14,6 +14,10 @@ import { languageSchema } from "../../types/TestTypes.js";
 export type VerifyTarget = Pick<z.infer<typeof languageSchema>, "language" | "framework"> & {
     testFile: string;
     testType?: string;
+    /** Both reuse settings on for this target (the route's `composed`): the in-house
+     *  path owns free-function modules, so only a class module is a candidate this
+     *  pass skipped. Stated by the caller, which resolved the route; never inferred. */
+    composed: boolean;
 };
 /** Renders a `VerifyResult` (from `verifyReuse`) as the text report returned to the agent. */
 export declare function formatVerifyReport(r: VerifyResult): string;

package/build/tools/code-refactor/verify-gates.js

@@ -2,6 +2,7 @@ import { readFile } from "fs/promises";
 import * as path from "path";
 import { logger } from "../../utils/logger.js";
 import { isPomAwareTarget } from "../../utils/reuseRouting.js";
+import { pageObjectCandidates } from "../../utils/pom-scope/ownership.js";
 import { selectScopedPoms, } from "../../utils/pom-scope/index.js";
 import { stripComments, stripStrings } from "../../utils/pom-scope/strip.js";
 import { escapeRegExp } from "../../utils/regex.js";
@@ -174,10 +175,16 @@ classification = {
         return undefined;
     try {
         const specContent = await readFile(params.testFile, "utf8");
-        const { tier1, diagnostics } = await selectScopedPoms({
+        const scoped = await selectScopedPoms({
             testFile: params.testFile,
             specContent,
         });
+        const { diagnostics } = scoped;
+        // Both settings on: a free-function module is the in-house path's, so it is not
+        // a candidate this pass skipped — the same split discovery applied.
+        const tier1 = params.composed
+            ? await pageObjectCandidates(scoped.tier1)
+            : scoped.tier1;
         // Only fire on candidates found via conventional POM dirs (globs) — the selector-grep
         // discovery fallback also matches ordinary in-repo frontend source (app components
         // legitimately contain the spec's test-ids by construction), which is not evidence of

package/build/tools/generate-tests/generateContractRestTool.js

@@ -399,14 +399,14 @@ const CHAINING_SECTION = CONSUMER_MODE_ENABLED
 - \`parentStatusCode\`: expected HTTP status code for each parent provisioning call (e.g. \`{"id": "201"}\`). Not allowed with \`skipProvisionParents\`.`;
 export function registerContractTestTool(server) {
     server.registerTool(TOOL_NAME, {
-        description: `${getPersonaPrefix()}Before calling this tool, you MUST output a <thinking> block that covers:
+        description: `${getPersonaPrefix()}Before calling this tool, verify these test inputs and requirements against the codebase, workspace config, API schema, or user input:
 1. The endpoint URL and HTTP method being tested
-2. Whether the endpoint is a nested resource (URL contains a path parameter like \`{id}\`, \`{flow_id}\`, etc.) — if YES, decide: do I have the request body to provision the parent, or should I use skipProvisionParents?
-3. Assertion planning — answer all four:
-   a. Echo-back fields: which fields in the response are returned unchanged from the request body? (e.g. name, email, status) — these must be asserted with the exact sent value, not just not-null
-   b. Computed fields: are there any numeric fields derived from other values? (e.g. total_amount, discount_amount) — these must be asserted with the formula, never a hardcoded number
-   c. Test data isolation: does this test create its own resources via parentRequestData, or does it depend on pre-existing data? All IDs must come from provisioned resources, never hardcoded.
-   d. Edge cases and business logic bugs: if \`skyramp_analyze_changes\` already ran and returned recommendations for this endpoint, revisit them now — did the recommendation phase flag any boundary conditions, invalid-input behaviors, or business logic bugs? Each flagged risk should map to a targeted assertion in this test. A test that doesn't target a known risk is low-value.
+2. For a nested resource (URL contains a path parameter like \`{id}\`, \`{flow_id}\`, etc.), use the request body to provision the parent, or use skipProvisionParents when it cannot be provisioned.
+3. Assertion requirements:
+   a. Echo-back fields: assert response fields returned unchanged from the request body (e.g. name, email, status) with the exact sent value, not just not-null.
+   b. Computed fields: assert numeric fields derived from other values (e.g. total_amount, discount_amount) with the formula, never a hardcoded number.
+   c. Test data isolation: create the test's own resources via parentRequestData. All IDs must come from provisioned resources, never hardcoded.
+   d. Edge cases and business logic bugs: if \`skyramp_analyze_changes\` already ran and returned recommendations for this endpoint, map each flagged boundary condition, invalid-input behavior, or business logic risk to a targeted assertion in this test.
 4. Each required parameter and what value it will take, with source (workspace config / diff / schema / user input)
 NEVER use a hardcoded ID (UUID or integer) as a path parameter value. If a real resource ID is needed and cannot be provisioned, use skipProvisionParents instead.
 

package/build/tools/generate-tests/generateIntegrationRestTool.js

@@ -89,15 +89,15 @@ ${enhanceAssertionsStep("integration", "generated test file")}
 const TOOL_NAME = TOOL_INTEGRATION_TEST_GENERATION;
 export function registerIntegrationTestTool(server) {
     server.registerTool(TOOL_NAME, {
-        description: `${getPersonaPrefix()}Before calling this tool, you MUST output a <thinking> block that covers:
+        description: `${getPersonaPrefix()}Before calling this tool, verify these test inputs and requirements against the codebase, workspace config, API schema, or user input:
 1. The endpoint URL(s) and HTTP method(s) involved in this multi-step workflow
-2. Why an integration test (multi-step workflow validation) is the right choice for this intent
-3. Assertion planning — answer all four for each step:
-   a. Echo-back fields: which response fields are returned unchanged from the request body? List them by name — these get exact-value assertions, not just not-null checks
-   b. Computed fields: are there derived numeric fields (e.g. total_amount = price × quantity)? Name the formula — these get formula-based assertions, never hardcoded numbers
-   c. Chaining: which IDs in step N+1 come from step N's response? Name the JSON path (e.g. POST /orders response → order_id → GET /orders/{order_id}). Every ID must be dynamically chained — no hardcoded IDs anywhere in the test
-   d. Edge cases and business logic bugs: if \`skyramp_analyze_changes\` already ran and returned recommendations for these endpoints, revisit them now — did the recommendation phase flag any boundary conditions, invalid-input behaviors, or business logic bugs? Each flagged risk should map to a targeted assertion in this test. A test that doesn't target a known risk is low-value.
-4. Test data isolation: does this test create all its own resources from scratch, or does it depend on pre-existing database state? All prerequisite resources must be created within the test setup.
+2. The requested test exercises a multi-step workflow.
+3. Assertion requirements for each step:
+   a. Echo-back fields: assert response fields returned unchanged from the request body with the exact sent value, not just not-null.
+   b. Computed fields: assert derived numeric fields (e.g. total_amount = price × quantity) with the formula, never hardcoded numbers.
+   c. Chaining: use the relevant JSON path in step N's response for IDs in step N+1 (e.g. POST /orders response → order_id → GET /orders/{order_id}). Every ID must be dynamically chained — no hardcoded IDs anywhere in the test.
+   d. Edge cases and business logic bugs: if \`skyramp_analyze_changes\` already ran and returned recommendations for these endpoints, map each flagged boundary condition, invalid-input behavior, or business logic risk to a targeted assertion in this test.
+4. Test data isolation: create all prerequisite resources within the test setup, without depending on pre-existing database state.
 If any required parameter cannot be determined without guessing, STOP and ask the user before calling the tool.
 
 ---

package/build/tools/generate-tests/generateUIRestTool.js

@@ -101,10 +101,10 @@ export const uiTestSchema = {
 };
 export function registerUITestTool(server) {
     server.registerTool(TOOL_NAME, {
-        description: `${getPersonaPrefix()}Before calling this tool, you MUST output a <thinking> block that covers:
+        description: `${getPersonaPrefix()}Before calling this tool, verify these test inputs against the Playwright trace, codebase, and filesystem:
 1. The user-facing flow(s) captured in the Playwright trace (pages visited, actions taken)
-2. Why a UI test (Playwright-based interaction replay) is the right choice for this intent
-3. Which assertions this test should validate (page content, element state, navigation results)
+2. The intended behavior is covered by the recorded Playwright interactions.
+3. The expected page content, element state, or navigation results the test must assert
 4. The absolute path to the trace zip and the output directory, with source confirmation
 If the trace zip path cannot be confirmed as an absolute path to an existing file, STOP and re-export before calling this tool.