@skyramp/mcp 0.4.0 → 0.4.1-rc.2

package/build/types/ReuseOutcome.d.ts

@@ -1,4 +1,5 @@
 import type { TestExecutionStatus } from "./TestExecution.js";
+import type { UtilsViolationKind } from "../utils/utils-verify/allow.js";
 /**
  * The code-reuse observability shape carried in a TestbotReport — the wire contract
  * between this server and the consumers that render it (test-bot.git). It covers
@@ -86,6 +87,26 @@ export declare enum HelperVerificationOutcome {
     /** The test neither wrote nor imports a shared utils file. */
     NoUtilsFile = "no-utils-file"
 }
+/** Every blocking kind a report-time reuse verification can find. Shared-helper
+ *  path: the `UtilsViolationKind`s, plus `malformed-allow-marker` for an allow
+ *  marker the grammar cannot read (which fails a verify on its own). Page-object
+ *  path: a POM member the spec calls that its source does not define, a spec that
+ *  does not parse, a spec whose Skyramp runtime imports were stripped, and a spec
+ *  with no page-object reuse whose selectors match detected page objects and carry
+ *  no `// kept inline:` decline. A union, so a misspelled kind is a compile error. */
+export type ReuseVerificationFailureKind = UtilsViolationKind | "malformed-allow-marker" | "pom-member-missing" | "parse-error" | "skyramp-infra-missing" | "zero-reuse";
+/** One blocking kind a failed reuse verification found in the delivered files,
+ *  aggregated: the verifier reports a finding per helper, import line or POM call,
+ *  and the row states the kind once with its count. `detail` is the findings' own
+ *  detail text (joined with `; ` when there are several) — for an `assertion-loss`
+ *  that is the sentence `verify.ts` builds with the counts behind the verdict
+ *  (baseline, delivered, in the test, in the helpers); it is NOT the gate's
+ *  PASSED/FAILED prose. */
+export interface ReuseVerificationFailure {
+    kind: ReuseVerificationFailureKind;
+    count: number;
+    detail: string;
+}
 /** A pre-existing Skyramp-generated test the reuse pass edited to import from the
  *  shared utils file. `execution` is the recorded post-edit run; a retrofit without
  *  one cannot be reported (skyramp_submit_report refuses). */
@@ -99,13 +120,24 @@ export interface RetrofitOutcome {
  *  Absent altogether when no utils file exists for the test (the same omission rule
  *  as the POM fields at zero candidates: a zero says nothing "no file" does not). */
 export interface HelperReuseOutcome {
-    /** BASENAME of the shared utils file the test imports from or this run wrote —
-     *  found by its header, never by a conventional name (the reuse prompt allows "a
-     *  new file with a different name" once the conventional one is large). Several
-     *  files are joined with `, `. */
+    /** REPOSITORY-RELATIVE PATH (posix) of the shared utils file the test imports
+     *  from or this run wrote — found by its header, never by a conventional name (the
+     *  reuse prompt allows "a new file with a different name" once the conventional
+     *  one is large). A path, not a basename, so two same-named modules in one
+     *  delivery (an API and a UI `skyrampUtils.ts`) stay distinguishable; never
+     *  absolute, which would leak the runner's temp directory. Unique within ONE
+     *  repository only: in a multi-repo report the same path can occur in two
+     *  checkouts, so a renderer must key on the row's `repository` plus this field.
+     *  Several files are joined with `, `. */
     utilsFile: string;
     /** Helpers the delivered test imports from that file that the file defines. */
     helpersImported?: number;
+    /** Those helpers by name, sorted; empty when nothing is imported. Always equals
+     *  `helpersImported` in length — both come from the same set.
+     *
+     *  TODO: remove `helpersImported` once the testbot renderer reads this field. The
+     *  two carry one fact; the count stays only because testbot#349 reads it today. */
+    helperNames: string[];
     /** Inline request calls in OTHER Skyramp-generated tests beside this one that a
      *  helper in `utilsFile` already wraps — reuse that was available and not taken.
      *  Omitted at zero. Informational, like {@link ReuseOutcome.missedReuse}. */
@@ -114,13 +146,35 @@ export interface HelperReuseOutcome {
      *  per method+path, status-code-only assertions, method+resource names — with
      *  documented declines (`reuse-verify: allow …`) counted as holding. */
     verification?: HelperVerificationOutcome;
+    /** Why `verification` is `failed`: one entry per blocking kind found, with how
+     *  many findings of it and the finding's own detail text — see
+     *  {@link ReuseVerificationFailure}. Present only on a `failed` row. A bare
+     *  `failed` cannot be acted on and its cause cannot be reconstructed from the
+     *  artifacts; this is the statement of what failed.
+     *
+     *  How it reaches a report: skyramp_submit_report refuses a report carrying a
+     *  blocking verdict and names these entries to the agent, up to a bound per file
+     *  (`REUSE_SUBMIT_MAX_REFUSALS`); past the bound the report is accepted and the
+     *  row ships with this field set, so the fault is disclosed rather than delivered
+     *  in silence — or not delivered at all. */
+    verificationFailures?: ReuseVerificationFailure[];
     /** Pre-existing generated tests this spec's reuse pass rewired onto the utils
      *  file, each with its recorded execution. Omitted when none. */
     retrofits?: RetrofitOutcome[];
-    /** Whether the delivered test plus the helpers it imports still hold every
-     *  assertion (and page-error guard) present when modularization was handed out.
-     *  Present only when that baseline exists. */
+    /** Whether the delivered test plus the helpers it imports and calls still hold at
+     *  least as many assertions as when modularization was handed out. A measured
+     *  count: a documented decline (`reuse-verify: allow assertion-loss …`) clears
+     *  `verification` and leaves this `false`. Present only when that baseline exists.
+     *  Says nothing about the page-error guard — that is
+     *  {@link pageErrorGuardPreserved}; folding the two into one flag once sent an
+     *  investigation after a lost assertion when a guard had been deleted. */
     assertionsPreserved?: boolean;
+    /** Whether the `page.on('pageerror', …)` guard present at the modularization
+     *  hand-out is still registered, in the test or in a shared helper it imports and
+     *  calls. `true` when the hand-out had no guard to lose. Present whenever the
+     *  baseline exists, absent otherwise — like every optional member here, absent
+     *  means "not measured", never "false". */
+    pageErrorGuardPreserved?: boolean;
 }
 /**
  * What lands in a report's `reuse` field for a generated test. Every member is
@@ -161,7 +215,19 @@ export interface ReuseOutcome {
     /** The subset of those raw locators that a catalogued POM member covers.
      *  Informational; see {@link ReuseMissedEntry}. */
     missedReuse?: ReuseMissedEntry[];
+    /** Copies of operations written in two or more Skyramp-generated tests beside (and
+     *  including) this one that NO shared helper wraps — extraction that was due and
+     *  not performed, the counterpart of `helpers.siblingInlineCallSites` (use not
+     *  taken). Top level, not on the helpers row: it describes the spec's directory,
+     *  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;
     verification?: ReuseVerificationOutcome;
+    /** Why `verification` is `failed` on the page-object path, on the same terms as
+     *  {@link HelperReuseOutcome.verificationFailures}: present only when the
+     *  delivered spec fails the live POM check at report time and the report was
+     *  accepted past the refusal bound. */
+    verificationFailures?: ReuseVerificationFailure[];
     skipped?: ReuseSkippedEntry[];
     /** Shared-helper (SkyrampUtils) reuse. See {@link HelperReuseOutcome}. */
     helpers?: HelperReuseOutcome;

package/build/types/TestAnalysis.d.ts

@@ -53,6 +53,12 @@ export interface MaintenanceActionCore {
      *  the rewritten PNG — a listed baseline must never exempt the selector edit the same
      *  verdict claimed (SKYR-3883 stays in force). */
     rebaselineOnly?: boolean;
+    /** True when the action is a RECOMMENDATION the developer applies by hand and this run
+     *  touched nothing: a REGENERATE or DELETE on an external (user-authored) test. Part of
+     *  the core shape because the action stays REAL rather than flattening to VERIFY, so
+     *  without this a downstream stage cannot tell a regeneration that rewrote a file from
+     *  one that only advised it — and maintenance coverage would credit the advice. */
+    reportOnly?: boolean;
 }
 /** Normalized internal recommendation built from LLM-supplied args.recommendations. */
 export interface DriftRecommendation extends MaintenanceActionCore {

package/build/types/TestbotReport.d.ts

@@ -72,6 +72,10 @@ export interface TestbotReport {
         editedFileName?: string;
         description: string;
         action: DriftAction;
+        /** `owner/repo` the maintained test lives in. Always set, unlike the other
+         *  sections: `fileName` is a basename, so in a multi-repo run this is the
+         *  only thing separating two same-named test files (SKYR-4233). */
+        repository: string;
         beforeStatus: TestExecutionStatus;
         beforeDetails: string;
         afterStatus: TestExecutionStatus;
@@ -119,10 +123,14 @@ export interface TestbotReport {
     }[];
     issuesFound: {
         description: string;
-        /** The planned test this issue is about, when it is about one — set on the
-         *  issue that writes up a `requirement_conflict` so the conflict names the
-         *  test that asserts it. Absent on an issue about no particular test. */
+        /** The test that proves this issue: one that expects to fail until the issue
+         *  is fixed, or the `requirement_conflict` test that asserts the requirement.
+         *  Absent on an issue no test proves; a `bug` entry without one draws an
+         *  `issueTraceability:<n>` objection. */
         plannedTestId?: string;
+        /** The plan defect this issue reports, by the id the plan's `defects` list
+         *  gave it. Absent on an issue the plan did not declare. */
+        defectId?: string;
         severity?: "critical" | "high" | "medium" | "low";
         /** Required by the submit_report schema since 0.3.4; absent in reports
          *  written by older MCP versions. Readers treat absence as Bug. */
@@ -150,8 +158,18 @@ export interface TestbotReport {
         text: string;
         source: string;
         /** `plannedTestId` of each delivered test citing this change. Empty where the
-         *  agent answered instead of planning one. */
+         *  agent answered instead of planning one, and where the change is covered by
+         *  an existing test the run maintained — `maintainedBy` carries those. */
         testedBy: string[];
+        /** Path of each existing test the run edited that cites this change: a
+         *  `maintains` entry from the plan, kept only where a `testMaintenance` row
+         *  names the same file. Checked at name level, which is the level v2 allows
+         *  for a file, so this says the run reported editing it and not that the edit
+         *  is known to be right. A claim no maintenance row corroborates is left out
+         *  and draws `deliveredMatchesPlan:maintains:` instead. A change covered this
+         *  way has no planned test and needs no answer, so without this field the
+         *  change table would read as untested. */
+        maintainedBy?: string[];
         /** The agent's answer to `coverage:change:<id>`, where it gave one. */
         answer?: string;
     }[];

package/build/utils/AnalysisStateManager.d.ts

@@ -133,7 +133,7 @@ export interface UiAnalysisContext {
  *  PATH. Recorded in-process where staging finds the edit; skyramp_submit_report
  *  refuses a report that leaves one undisclosed or unexecuted. */
 export interface ReuseRetrofit {
-    /** BASENAME(s) of the utils file(s) it now imports from. */
+    /** Repository-relative path(s) of the utils file(s) it now imports from. */
     utilsFile: string;
     /** Absolute path of the generated test whose reuse pass caused the edit. */
     testFile: string;
@@ -184,6 +184,12 @@ export interface UnifiedAnalysisState {
     reuseHandOffs?: Record<string, ReuseHandOff>;
     /** See {@link ReuseRetrofit}. Never supplied by the LLM. */
     reuseRetrofits?: Record<string, ReuseRetrofit>;
+    /** How many times skyramp_submit_report has refused the report over a blocking
+     *  reuse verdict on each spec, keyed by the spec's ABSOLUTE PATH (the verdict's
+     *  `file`). The refusal is bounded (`REUSE_SUBMIT_MAX_REFUSALS`): past the bound
+     *  the report is accepted with the fault recorded in the row. Written by
+     *  skyramp_submit_report only; never supplied by the LLM. */
+    reuseRefusals?: Record<string, number>;
     /**
      * SKYR-4156. Recorded video per executed browser test, keyed by test-file
      * BASENAME (the same key `reuseOutcomes` uses, so matching needs no path

package/build/utils/AnalysisStateManager.js

@@ -295,7 +295,11 @@ async function writeFileAtomically(target, contents) {
         throw error;
     }
 }
-const ROOT_FIELDS_OWNED_ELSEWHERE = ["plan", "registrationCount", "reportObjections"];
+const ROOT_FIELDS_OWNED_ELSEWHERE = [
+    "plan",
+    "registrationCount",
+    "reportObjections",
+];
 function carryForwardRootFields(data, existing) {
     if (!existing)
         return {};

package/build/utils/assertion-verify/api-shared-lints.js

@@ -1,6 +1,6 @@
 import { escapeRegExp } from "../regex.js";
 import { strippedSources } from "./strip-dispatch.js";
-import { balancedCloseIndex, identifierRe, inScope, interpolationRe, lineOfOffset, } from "./lint-types.js";
+import { balancedCloseIndex, identifierRe, inScope, interpolationRe, lineOfOffset, testBlockIndex, testStartOffsets, } from "./lint-types.js";
 /**
  * Deterministic checks shared by integration and provider-contract tests — the
  * machine-checkable slice of the D5 rubric's echo_computed and array_depth
@@ -12,6 +12,12 @@ const RESPONSE_BINDING_RES = {
     python: /^[ \t]*([A-Za-z_]\w*)\s*=\s*[\w.]*send_request\s*\(/gm,
 };
 const STATUS_USE_RE = /^\s*\.\s*(?:statusCode|status_code|status)\b/;
+/** The SDK body-read call for a binding, spelled for the language. */
+function helperCall(language, varName) {
+    return language === "python"
+        ? `skyramp.get_response_value(${varName}, "json.path")`
+        : `getValue(${varName}, "json.path")`;
+}
 /** All send_request/sendRequest bindings in the stripped source. */
 function responseBindings(stripped, language) {
     const bindings = [];
@@ -148,11 +154,17 @@ function lintStatusOnlyResponses(stripped, commentless, language, bindings) {
             message: statusUses > 0
                 ? severity === "hard"
                     ? `Error response \`${varName}\` is only checked for its status code — the error body (code/message/detail) must be asserted.`
-                    : `Response \`${varName}\` is only checked for its status code — if this endpoint returns a body, assert its fields (skip only for genuinely empty-body responses).`
+                    : `Response \`${varName}\` is only checked for its status code.`
                 : `Response \`${varName}\` is captured but never asserted.`,
-            remediation: language === "python"
-                ? `Assert body fields via \`skyramp.get_response_value(${varName}, "json.path")\` after the status assertion.`
-                : `Assert body fields via \`getValue(${varName}, "json.path")\` after the status assertion.`,
+            // The advisory case is phrased as a question, not an instruction. A
+            // response no behaviour in the file depends on is CORRECT with its
+            // status code and nothing more (SKYR-4310) — telling the agent to
+            // assert the body regardless is how a 136-assertion test gets written
+            // to prove a default page size. The hard case is unchanged: an error
+            // body carries the evidence, so it is never optional.
+            remediation: severity === "warn"
+                ? `If a behaviour this file tests depends on this response's body, assert the fields it depends on via \`${helperCall(language, varName)}\`. If no behaviour depends on it, the status code alone is the right answer — leave it.`
+                : `Assert the error body's fields via \`${helperCall(language, varName)}\` after the status assertion.`,
         });
     }
     return findings;
@@ -294,6 +306,87 @@ function lintArrayDepth(commentless) {
     }
     return findings;
 }
+// An error-indicator field asserted absent on a response binding:
+//   expect(getValue(r, "error")).toBeUndefined() / .toBeNull()
+//   assert skyramp.get_response_value(r, "error") is None
+// Group 1 is the binding (JS/TS identifiers may carry `$`), group 2 the field.
+const ERROR_ABSENT_RE = /(?:getValue|getResponseValue|get_response_value)\s*\(\s*([\w$.]+)\s*,\s*['"](error|errors|message)['"]\s*\)\s*(?:(?:,\s*['"][^'"]*['"])?\s*\)\s*\.\s*toBe(?:Undefined|Null)\s*\(|is\s+None\b)/g;
+// A populated-collection claim on a binding:
+//   expect(getValue(r, "items").length).toBeGreaterThan(0)
+//   assert len(skyramp.get_response_value(r, "items")) > 0
+const NON_EMPTY_RE = /(?:getValue|getResponseValue)\s*\(\s*([\w$.]+)\s*,\s*['"][^'"]+['"]\s*\)\s*\.\s*length\s*(?:,\s*['"][^'"]*['"]\s*)?\)\s*\.\s*toBeGreaterThan\s*\(\s*0\s*\)|len\s*\(\s*[\w.]*get_response_value\s*\(\s*([\w$.]+)\s*,\s*['"][^'"]+['"]\s*\)\s*\)\s*>\s*0/g;
+/** A success shape asserted together with the absence of an error field on the
+ *  same response binding, inside the same test body. Both are legitimate on a
+ *  real success body, so this is advisory only: the pattern is exactly what a
+ *  test looks like when its expectations were written for the outcome the
+ *  author wanted rather than the body the endpoint returns (a no-match or
+ *  validation error carried in `error`). The verifier cannot see the response,
+ *  so it asks the author to confirm the classification rather than blocking. */
+function lintSuccessShapeWithErrorAbsent(commentless) {
+    const starts = testStartOffsets(commentless);
+    let m;
+    // key: `<testBlock>:<binding>` → { offset, field }
+    const errorAbsent = new Map();
+    ERROR_ABSENT_RE.lastIndex = 0;
+    while ((m = ERROR_ABSENT_RE.exec(commentless)) !== null) {
+        const key = `${testBlockIndex(starts, m.index)}:${m[1]}`;
+        if (!errorAbsent.has(key))
+            errorAbsent.set(key, { offset: m.index, field: m[2] });
+    }
+    if (errorAbsent.size === 0)
+        return [];
+    const findings = [];
+    const reported = new Set();
+    NON_EMPTY_RE.lastIndex = 0;
+    while ((m = NON_EMPTY_RE.exec(commentless)) !== null) {
+        const varName = m[1] ?? m[2];
+        const key = `${testBlockIndex(starts, m.index)}:${varName}`;
+        const absent = errorAbsent.get(key);
+        if (!absent || reported.has(key))
+            continue;
+        reported.add(key);
+        findings.push({
+            rule: "success-shape-with-error-absent",
+            severity: "warn",
+            line: lineOfOffset(commentless, absent.offset),
+            message: `\`${varName}\` is asserted to have no \`${absent.field}\` field and a non-empty collection — a success shape.`,
+            remediation: 'Confirm the recorded response for this exact request is a success body. If the endpoint answers this request with an error or no-match body (a validation 4xx, or a 2xx carrying `{"error": ...}`), assert that body\'s exact fields instead and report the gap in issuesFound. Keep the assertion as written only when the plan declared this test `expected.outcome: fail` (a bug_caught or requirement_conflict test that deliberately asserts the intended behaviour).',
+        });
+    }
+    return findings;
+}
+// The existence idiom on an SDK-helper read: `not.toBeNull()` / `is not None`.
+// Weight 1 in the strength model, and the one shape MAINTENANCE_SCOPE_NOTE
+// names by example.
+const WEAK_EXISTENCE_RE = /(?:getValue|getResponseValue)\s*\(\s*[\w$.]+\s*,\s*['"]([^'"]+)['"][^)]*\)\s*(?:,\s*['"][^'"]*['"]\s*)?\)\s*\.\s*not\s*\.\s*toBeNull\s*\(|get_response_value\s*\(\s*[\w.]+\s*,\s*['"]([^'"]+)['"]\s*\)\s*is\s+not\s+None\b/g;
+/** Maintenance only: an existence-tier assertion left standing inside a test
+ *  function the agent TOUCHED. `MAINTENANCE_SCOPE_NOTE` holds such a function
+ *  to the same standard as a new test — "an existing `is not None` on a field
+ *  the diff gives a knowable value becomes that value".
+ *
+ *  Warn, never hard: the verifier has no diff, so it cannot tell which fields
+ *  the change made knowable. It reports the candidates and lets the agent
+ *  decide, which is the honest split — the alternative is blocking a spec on a
+ *  field whose value genuinely still varies. */
+function lintWeakAssertionInTouchedTest(commentless, opts) {
+    const findings = [];
+    WEAK_EXISTENCE_RE.lastIndex = 0;
+    let m;
+    while ((m = WEAK_EXISTENCE_RE.exec(commentless)) !== null) {
+        const line = lineOfOffset(commentless, m.index);
+        if (!inScope(line, opts))
+            continue;
+        const field = m[1] ?? m[2];
+        findings.push({
+            rule: "weak-assertion-in-touched-test",
+            severity: "warn",
+            line,
+            message: `\`${field}\` is asserted only to exist, in a test function this change touches.`,
+            remediation: `A test function you touch is held to the same standard as a new one. If the diff gives \`${field}\` a knowable value, assert that value exactly. Leave the existence check only when the value genuinely varies across runs.`,
+        });
+    }
+    return findings;
+}
 /** Checks shared by integration and provider-contract tests. Java is never
  *  linted (count+hash gates only). */
 export function lintApiShared(raw, language, opts) {
@@ -302,14 +395,28 @@ export function lintApiShared(raw, language, opts) {
     const maintenance = opts?.scopeLines !== undefined;
     const { commentless, stripped } = strippedSources(raw, language);
     const findings = [];
+    // Bindings discovered once, shared by both binding-scoped lints.
+    const bindings = responseBindings(stripped, language);
+    findings.push(...lintStatusOnlyResponses(stripped, commentless, language, bindings));
+    findings.push(...lintSdkHelperBypass(stripped, bindings, language));
+    findings.push(...lintShapeOnlyChecks(commentless));
+    findings.push(...lintSuccessShapeWithErrorAbsent(commentless));
     if (!maintenance) {
-        // Bindings discovered once, shared by both binding-scoped lints.
-        const bindings = responseBindings(stripped, language);
-        findings.push(...lintStatusOnlyResponses(stripped, commentless, language, bindings));
-        findings.push(...lintSdkHelperBypass(stripped, bindings, language));
-        findings.push(...lintShapeOnlyChecks(commentless));
+        // Array-depth findings anchor to a path, not a line, so there is nothing
+        // to scope them by — running them in maintenance would report untouched
+        // customer arrays with no way to filter them out.
         findings.push(...lintArrayDepth(commentless));
     }
+    else {
+        findings.push(...lintWeakAssertionInTouchedTest(commentless, opts));
+    }
     findings.push(...lintPermissiveStatusMatchers(commentless, opts));
-    return findings;
+    // Maintenance used to skip every lint above except the status-matcher one,
+    // because line-scoping to the ADDED lines would have flagged pre-existing
+    // customer code. The scope is now the touched test FUNCTION (SKYR-4310), so
+    // these can run: each finding is kept only when it lands inside a function
+    // the agent edited. A finding with no line cannot be placed and is dropped.
+    return maintenance
+        ? findings.filter((f) => f.line !== undefined && inScope(f.line, opts))
+        : findings;
 }

package/build/utils/assertion-verify/format.js

@@ -51,8 +51,8 @@ export function formatAssertionVerifyReport(r, testFile) {
     if (r.strengthGateFailed) {
         lines.push("- Assertion strength did not increase over the generated baseline: no assertion was added and no weak matcher was strengthened (e.g. `toBeVisible` → `toHaveText`). Apply the enhancement rules. A documented decline (`assertions complete` comment) is accepted only AFTER at least one assertion was added or replaced — a marker-only edit does not pass this gate.");
     }
-    if (r.weakAdditionsOnly) {
-        lines.push("- Every assertion added since the baseline is existence/visibility-tier (`toBeVisible`, `not.toBeNull`, `is not None`, ranges). When the exact text/value/count is knowable from the trace, source, or request, assert it exactly (`toHaveText`/`toHaveCount`/`toBe`/`==`). If only existence is genuinely knowable, document the decline:", `    ${token} assertions complete: ${spec} — <reason exact values are not knowable>`);
+    if (r.weakAdditionsDominant) {
+        lines.push(`- The assertions added since the baseline are mostly existence/visibility-tier (\`toBeVisible\`, \`not.toBeNull\`, \`is not None\`, ranges)${r.meanAddedWeight !== undefined ? ` — mean strength ${r.meanAddedWeight.toFixed(1)} against a bar of 2.0` : ""}. When the exact text/value/count is knowable from the trace, source, or request, assert it exactly (\`toHaveText\`/\`toHaveCount\`/\`toBe\`/\`==\`). Adding MORE weak assertions lowers this figure — the fix is to strengthen the ones the behaviour under test depends on, and to drop the ones it does not. If only existence is genuinely knowable, document the decline:`, `    ${token} assertions complete: ${spec} — <reason exact values are not knowable>`);
     }
     lines.push(...warningsBlock(r.warnings, finding));
     lines.push("Re-run this verification (verify: true) after every fix pass — skyramp_execute_test runs the same checks automatically and will not execute this test until they pass.");

package/build/utils/assertion-verify/helper-imports.d.ts

@@ -4,3 +4,10 @@
  * uncalled helper is skipped, so its subjects don't excuse anything.
  */
 export declare function importedHelperSubjects(testFile: string, content: string): Promise<Set<string>>;
+/**
+ * The same subjects with their CAPACITY — how many removals each may excuse:
+ * one per call site of the helper function that asserts it (an assertion the
+ * parser cannot place in a function gets one per call through the import).
+ * The removal gate consumes this budget per removed baseline subject.
+ */
+export declare function importedHelperSubjectCapacities(testFile: string, content: string): Promise<Map<string, number>>;