@skyramp/mcp 0.4.2 → 0.4.3-rc.1

package/build/recommendation/verifierContracts.js

@@ -305,11 +305,25 @@ export const REQUIREMENT_SOURCED_CONTRACT = {
             suggestion: "Cite a change you read in the pull request or in a requirements file, or report this test as something other than a requirement conflict.",
         },
         // The server rendered the prompt, so it holds the title and description the run
-        // was given. A requirements file the pull request never names is a file the agent
-        // found by looking, which is reading the repository, not reading a requirement.
+        // was given, and it holds the diff. A requirements file the pull request neither
+        // names nor changes is a file the agent found by looking, which is reading the
+        // repository, not reading a requirement.
         notNamed: {
-            message: "Change `{change}` cites `{source}`, and the pull request names no such file.",
-            suggestion: "Cite a file the title or description names. If neither names it, you read the change in the repository, so set `source` to `diff`.",
+            message: "Change `{change}` cites `{source}`, and the pull request neither names nor changes such a file.",
+            suggestion: "Cite a file the title or description names, or one the diff changes. If none does, you read the change in the repository, so set `source` to `diff`.",
+        },
+        // `{item}` is one top-level list line of the cited file or the description,
+        // `{number}` its number, `{source}` that source as the first change citing it
+        // spelled it, without its `#` anchor. The check
+        // reads only whether some change names the number, not whether a test covers it.
+        itemUnlinked: {
+            message: '`{source}` lists item {number}, "{item}", and no change in this plan names it.',
+            suggestion: "Set `source` to `{source}#{number}` on the change that covers this item, or answer with the reason it needs no test.",
+        },
+        // `{count}` is the number of top-level list items in `{source}`.
+        unnumbered: {
+            message: "`{source}` lists {count} items, and no change names one of them by its number.",
+            suggestion: "Name the item each change covers in its source, as `{source}#<number>` (`#7,8` for two), so each item can be checked.",
         },
         // Says only what was read: this pull request arrived with no words in it.
         emptyPullRequest: {
@@ -368,6 +382,20 @@ export const DEFECTS_CONTRACT = {
     },
     suggestion: "Which planned test proves each defect the review found, and for one nothing proves, why does it need no test?",
 };
+export const CHANGED_LINES_CLAIMED_CONTRACT = {
+    id: "changedLinesClaimed",
+    objections: {
+        unclaimed: {
+            message: "These changed lines are in a file a planned test covers, and no change in the plan names them in its `lines`.",
+            suggestion: "Add these lines to the `lines` of the change they belong to, or declare a change for them, with a case that states what a test must see. If the lines change nothing a test can observe, say so as the answer.",
+        },
+        noCase: {
+            message: "These changed lines belong to a change that states no case, so no test is held to what they do.",
+            suggestion: "Give the change a case whose `expectedValue` or `derived` states what a test must see after these lines. If the lines change nothing a test can observe, say so as the answer.",
+        },
+    },
+    suggestion: "Which change owns each run of changed lines in a tested file, and what must a test see because of it?",
+};
 /** Fills a contract sentence's `{placeholder}` spans from the run's or the
  *  planned test's own values. A placeholder with no value is left as written rather
  *  than blanked, so a missed key shows up as `{knob}` instead of reading as a gap

package/build/recommendation/verifiers/changedLinesClaimed.d.ts

@@ -0,0 +1,17 @@
+import { PlanChange, PlanInput, Verifier, VerifyContext } from "../types.js";
+import type { ChangedRun } from "../../utils/changedRuns.js";
+/** Whether a change's `lines` reach this run. Any overlap counts: a run that the
+ *  claimed range touches is the change's to answer for. */
+export declare function changeCoversRun(change: PlanChange, run: ChangedRun): boolean;
+/** The changed runs in files a planned test names as its changed file, each with
+ *  the changes that can claim it: a change counts in the repositories of the tests
+ *  that cite it, and in every repository when no test cites it. */
+export declare function runsInTestedFiles(registration: PlanInput, ctx: VerifyContext): Array<{
+    repository: string;
+    run: ChangedRun;
+    changes: PlanChange[];
+}>;
+/** Every changed run in a file a planned test covers belongs to a change that
+ *  states what a test must see. The server reads which lines changed; the agent
+ *  says what they do. One objection per run. */
+export declare const changedLinesClaimed: Verifier;

package/build/recommendation/verifiers/changedLinesClaimed.js

@@ -0,0 +1,88 @@
+import { normalizeCitedPath } from "./citedPath.js";
+import { CHANGED_LINES_CLAIMED_CONTRACT as CONTRACT } from "../verifierContracts.js";
+/** One `lines` entry read as a file and a line range: `path:12` or `path:12-20`. */
+function readLines(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const match = /^(.+):(\d+)(?:-(\d+))?$/.exec(raw.trim());
+    if (!match)
+        return undefined;
+    const file = normalizeCitedPath(match[1]);
+    const start = Number(match[2]);
+    const end = match[3] === undefined ? start : Number(match[3]);
+    return file && end >= start ? { file, start, end } : undefined;
+}
+/** Whether a change's `lines` reach this run. Any overlap counts: a run that the
+ *  claimed range touches is the change's to answer for. */
+export function changeCoversRun(change, run) {
+    const lines = Array.isArray(change?.lines) ? change.lines : [];
+    return lines.some((raw) => {
+        const range = readLines(raw);
+        return (range !== undefined &&
+            range.file === run.file &&
+            range.start <= run.end &&
+            range.end >= run.start);
+    });
+}
+/** Whether a change states what its test must see: some case carries an
+ *  `expectedValue` or a `derived` rule. */
+function statesAnOutput(change) {
+    return (change.testCases ?? []).some((entry) => entry &&
+        (entry.expectedValue !== undefined ||
+            String(entry.derived ?? "").trim().length > 0));
+}
+/** The changed runs in files a planned test names as its changed file, each with
+ *  the changes that can claim it: a change counts in the repositories of the tests
+ *  that cite it, and in every repository when no test cites it. */
+export function runsInTestedFiles(registration, ctx) {
+    const touched = new Set();
+    const citedIn = new Map();
+    for (const plannedTest of registration.plannedTests) {
+        const file = normalizeCitedPath(plannedTest.declarations.changedFile);
+        if (file)
+            touched.add(`${plannedTest.repository}\u0000${file}`);
+        for (const id of plannedTest.declarations.changes ?? []) {
+            const key = String(id ?? "").trim();
+            if (!citedIn.has(key))
+                citedIn.set(key, new Set());
+            citedIn.get(key)?.add(plannedTest.repository);
+        }
+    }
+    return Object.entries(ctx.changedRuns).flatMap(([repository, runs]) => runs
+        .filter((run) => touched.has(`${repository}\u0000${run.file}`))
+        .map((run) => ({
+        repository,
+        run,
+        changes: registration.changes.filter((change) => {
+            const repos = citedIn.get(String(change.id ?? "").trim());
+            return ((!repos || repos.has(repository)) && changeCoversRun(change, run));
+        }),
+    })));
+}
+/** Every changed run in a file a planned test covers belongs to a change that
+ *  states what a test must see. The server reads which lines changed; the agent
+ *  says what they do. One objection per run. */
+export const changedLinesClaimed = {
+    name: "changedLinesClaimed",
+    run(registration, ctx) {
+        const objections = [];
+        for (const { repository, run, changes } of runsInTestedFiles(registration, ctx)) {
+            if (changes.some(statesAnOutput))
+                continue;
+            const kind = changes.length === 0 ? "unclaimed" : "noCase";
+            const where = `${run.file}:${run.start}${run.end > run.start ? `-${run.end}` : ""}`;
+            objections.push({
+                objectionId: `changedLinesClaimed:${kind}:${repository}/${run.file}:${run.start}`,
+                verifier: "changedLinesClaimed",
+                message: CONTRACT.objections[kind].message,
+                evidence: kind === "unclaimed"
+                    ? `${repository} ${where} (\`${run.firstLine.trim().slice(0, 120)}\`): no change's \`lines\` covers it`
+                    : `${repository} ${where} (\`${run.firstLine.trim().slice(0, 120)}\`): covered by ${changes
+                        .map((change) => String(change.id ?? "?"))
+                        .join(", ")}, and none of them has a case with \`expectedValue\` or \`derived\``,
+                suggestion: CONTRACT.objections[kind].suggestion,
+            });
+        }
+        return objections;
+    },
+};

package/build/recommendation/verifiers/expectedValueSourced.js

@@ -4,6 +4,7 @@ import { EXPECTED_VALUE_SOURCED_CONTRACT as CONTRACT } from "../verifierContract
 import { appearsIn, searchable } from "../pullRequestText.js";
 import { escapeRegExp } from "../../utils/regex.js";
 import { renderTestCase } from "./coverage.js";
+import { runsInTestedFiles } from "./changedLinesClaimed.js";
 function readSource(raw) {
     const source = typeof raw === "string" ? raw.trim() : "";
     if (source.length === 0)
@@ -119,6 +120,8 @@ export const expectedValueSourced = {
         const changed = changedPathSet(allChangedFiles(ctx), true);
         const prText = searchable(ctx.pullRequest);
         const raised = new Set();
+        // The changes that own a changed run in a file a planned test covers.
+        const owners = new Set(runsInTestedFiles(registration, ctx).flatMap(({ changes }) => changes));
         const changes = registration.changes;
         for (const change of changes) {
             const changeId = String(change.id ?? "?");
@@ -170,6 +173,11 @@ export const expectedValueSourced = {
                     raise("unsourced", CONTRACT.objections.missingSource, `expected value with no usable \`expectedFrom\`: ${where}`);
                 }
                 else if (source.kind === "code") {
+                    // A change read from the diff that names its changed lines has no other
+                    // source: no requirement exists for the code to disagree with.
+                    if (/^diff$/i.test(String(change.source ?? "").trim()) &&
+                        owners.has(change))
+                        return;
                     raise("code", CONTRACT.objections.sourcedFromCode, 
                     // A derived-only case pins no value, so quoting one read `expected
                     // undefined` — a sentence naming nothing the agent can act on.

package/build/recommendation/verifiers/requirementSourced.js

@@ -1,47 +1,111 @@
+import { allChangedFiles, } from "../types.js";
 import { normalizeCategory } from "../../types/TestRecommendation.js";
 import { REQUIREMENT_SOURCED_CONTRACT, fillPlaceholders, } from "../verifierContracts.js";
-import { normalizeCitedPath } from "./citedPath.js";
+import { changedPathSet, normalizeCitedPath } from "./citedPath.js";
 import { appearsIn, searchable } from "../pullRequestText.js";
 /** Verifier 10. A change names where the agent read it, and the server reads the
  *  name back.
  *
  *  `source` is the record of where a change came from, and the server holds the
  *  pull request's own words, so it reads the claim back against them: a `spec:` path
- *  has to name a file the checkout holds AND a file the pull request names, and a
+ *  has to name a file the checkout holds AND a file the pull request names or changes, and a
  *  change read from the pull request has to quote words the pull request carries.
  *
+ *  A requirements file the pull request names or changes, and the description
+ *  itself, are read for their lists: every top-level item needs a change that names
+ *  it by number (`spec:<path>#11`, `pr-description#3`), or the plan answers why it
+ *  needs no test.
+ *
  *  A conflict is a disagreement between a requirement and the code. A change read
  *  off the diff IS the code, so there is no second side for it to disagree with.
  *
  *  The plan tool always supplies the pull request: the testbot fetches its prompt
  *  from this same server, so the text is in the process. Both fields blank means
  *  the run had no title and no description. */
-const { unsourced: UNSOURCED, unreadable: UNREADABLE, fromDiff: FROM_DIFF, noChange: NO_CHANGE, notNamed: NOT_NAMED, emptyPullRequest: EMPTY_PULL_REQUEST, notQuoted: NOT_QUOTED, unquoted: UNQUOTED, } = REQUIREMENT_SOURCED_CONTRACT.objections;
+const { unsourced: UNSOURCED, unreadable: UNREADABLE, fromDiff: FROM_DIFF, noChange: NO_CHANGE, notNamed: NOT_NAMED, emptyPullRequest: EMPTY_PULL_REQUEST, notQuoted: NOT_QUOTED, unquoted: UNQUOTED, itemUnlinked: ITEM_UNLINKED, unnumbered: UNNUMBERED, } = REQUIREMENT_SOURCED_CONTRACT.objections;
 const CONFLICT_CATEGORY = "requirement_conflict";
+const itemsIn = (anchor) => anchor !== undefined && /^\s*\d+(\s*,\s*\d+)*\s*$/.test(anchor)
+    ? anchor.split(",").map((n) => Number(n.trim()))
+    : [];
 function readSource(raw) {
     const none = (kind) => ({
         kind,
         file: "",
         citedAs: "",
+        items: [],
     });
     const source = raw.trim();
     if (source.length === 0)
         return none("unknown");
-    if (/^(pr-title|pr-description)$/i.test(source))
+    if (/^pr-title$/i.test(source))
         return none("pullRequest");
+    const description = /^pr-description(?:#(.*))?$/i.exec(source);
+    if (description)
+        return { ...none("pullRequest"), items: itemsIn(description[1]) };
     if (/^diff$/i.test(source))
         return none("diff");
     const named = /^spec:(.*)$/i.exec(source);
     if (!named)
         return none("unknown");
-    const citedAs = named[1]
-        .split(/[#§]/)[0]
+    const [path, anchor] = named[1].split(/#/);
+    const citedAs = path
+        .split(/§/)[0]
         .replace(/(?::\d+)+(?:-\d+)?$/, "")
         .trim();
     const file = normalizeCitedPath(citedAs);
     // `spec:` with nothing after it names no file, so there is nothing to check and
     // nothing to trust either.
-    return file ? { kind: "spec", file, citedAs } : none("unknown");
+    return file
+        ? { kind: "spec", file, citedAs, items: itemsIn(anchor) }
+        : none("unknown");
+}
+const LIST_LINE = /^([ \t]*)(\d+(?=[.)])|[-*+•])[.)]?\s+(.*)$/;
+/** Only a prose file holds a list of requirements. A YAML or JSON file is a list of
+ *  settings, and each of its lines would read as one. */
+const PROSE_FILE = /(^|\/)[^./]+$|\.(md|markdown|txt|rst|adoc)$/i;
+/** The top-level items of a list: its numbered or bulleted lines at the smallest
+ *  indent. A nested bullet is not an item of its own. Lines inside a fenced code
+ *  block or a leading front-matter block are not items, and neither is a line with
+ *  no letter or digit (a `- - -` rule). A text with no list has no items.
+ *
+ *  An item's number is the one the text writes (`11.`), so a plan can cite it as the
+ *  reader sees it, and a bulleted list is numbered by position from 1. A text whose
+ *  numbers repeat (two numbered lists) or that mixes numbered and bulleted items
+ *  has no numbering a plan can cite, so it gives no items. */
+function topLevelListItems(text) {
+    const lines = text
+        .replace(/^\uFEFF/, "")
+        .replace(/^---\r?\n[\s\S]*?\r?\n---(\r?\n|$)/, "")
+        .split(/\r\n?|\n/);
+    // The marker that opened the fence, so ``` is closed by ``` and not by ~~~.
+    let fence;
+    const listed = lines.flatMap((line) => {
+        const marker = /^\s*(```|~~~)/.exec(line)?.[1];
+        if (marker && (fence === undefined || fence === marker))
+            fence = fence === undefined ? marker : undefined;
+        const match = fence !== undefined || marker ? null : LIST_LINE.exec(line);
+        if (!match || !/[\p{L}\p{N}]/u.test(match[3]))
+            return [];
+        return [
+            { indent: match[1].length, written: match[2], text: match[3].trim() },
+        ];
+    });
+    const top = Math.min(...listed.map((line) => line.indent));
+    const items = listed.filter((line) => line.indent === top);
+    const written = items.map((item) => Number.parseInt(item.written, 10));
+    if (written.every(Number.isInteger)) {
+        // Numbers that repeat mean two numbered lists; no single number names an item.
+        if (new Set(written).size !== written.length)
+            return [];
+        return items.map((item, index) => ({
+            number: written[index],
+            text: item.text,
+        }));
+    }
+    // A mix of numbered and bulleted lines has no numbering a reader can cite.
+    if (written.some(Number.isInteger))
+        return [];
+    return items.map((item, index) => ({ number: index + 1, text: item.text }));
 }
 /** A source that stands for a requirement: the pull request, or a requirements file. */
 const statesARequirement = (source) => source.kind === "pullRequest" || source.kind === "spec";
@@ -54,6 +118,12 @@ export const requirementSourced = {
         const sourceById = new Map();
         const quoteById = new Map();
         const pullRequestText = searchable(ctx.pullRequest);
+        const changedPaths = changedPathSet(allChangedFiles(ctx), false);
+        // The list items the changes name, per requirements file the pull request
+        // names or changes, and for the description.
+        const descriptionItems = [];
+        let descriptionCited = false;
+        const itemsBySpec = new Map();
         for (const change of changes) {
             const id = String(change.id ?? "").trim();
             const changeId = id || "(unnamed)";
@@ -75,6 +145,9 @@ export const requirementSourced = {
                 continue;
             }
             if (source.kind === "pullRequest") {
+                if (/^pr-description/i.test(written))
+                    descriptionCited = true;
+                descriptionItems.push(...source.items);
                 if (pullRequestText.length > 0)
                     continue;
                 objections.push({
@@ -103,11 +176,17 @@ export const requirementSourced = {
                 });
                 continue;
             }
-            // A requirements file the pull request never names is a file the agent found by
-            // looking through the repository, which is not reading a requirement.
+            // A requirements file the pull request neither names nor changes is a file the
+            // agent found by looking through the repository, which is not reading a
+            // requirement.
             if (appearsIn(pullRequestText, source.file) ||
-                appearsIn(pullRequestText, source.citedAs))
+                appearsIn(pullRequestText, source.citedAs) ||
+                changedPaths.has(source.file)) {
+                const cited = itemsBySpec.get(source.file) ?? { written, items: [] };
+                cited.items.push(...source.items);
+                itemsBySpec.set(source.file, cited);
                 continue;
+            }
             objections.push({
                 objectionId: `requirementSourced:notNamed:${changeId}`,
                 verifier: "requirementSourced",
@@ -115,10 +194,61 @@ export const requirementSourced = {
                     change: changeId,
                     source: written,
                 }),
-                evidence: `change ${changeId} states source \`${written}\`; neither the title nor the description names ${source.file}`,
+                evidence: `change ${changeId} states source \`${written}\`; neither the title nor the description names ${source.file}, and the diff does not change it`,
                 suggestion: NOT_NAMED.suggestion,
             });
         }
+        // Every item of a list needs a change that names it by number. A list no change
+        // numbers at all is one objection, not one per item: the plan is not citing the
+        // list by item yet, and one answer covers that.
+        const objectToUnlinked = (items, linked, where, source) => {
+            if (items.length === 0)
+                return;
+            // A number the list does not hold names nothing.
+            if (!linked.some((n) => items.some((item) => item.number === n))) {
+                objections.push({
+                    objectionId: `requirementSourced:unnumbered:${where}`,
+                    verifier: "requirementSourced",
+                    message: fillPlaceholders(UNNUMBERED.message, {
+                        source,
+                        count: String(items.length),
+                    }),
+                    evidence: `${where} lists ${items.length} item(s); no change names one as \`#<number>\``,
+                    suggestion: fillPlaceholders(UNNUMBERED.suggestion, { source }),
+                });
+                return;
+            }
+            for (const item of items) {
+                if (linked.includes(item.number))
+                    continue;
+                objections.push({
+                    objectionId: `requirementSourced:specItem:${where}#${item.number}`,
+                    verifier: "requirementSourced",
+                    message: fillPlaceholders(ITEM_UNLINKED.message, {
+                        source,
+                        number: String(item.number),
+                        item: item.text,
+                    }),
+                    evidence: `${where} lists item ${item.number}, "${item.text}"; no change names #${item.number}`,
+                    suggestion: fillPlaceholders(ITEM_UNLINKED.suggestion, {
+                        source,
+                        number: String(item.number),
+                    }),
+                });
+            }
+        };
+        for (const [file, { written, items }] of itemsBySpec) {
+            if (!PROSE_FILE.test(file))
+                continue;
+            const text = ctx.readSpecFile(file);
+            if (text === undefined)
+                continue;
+            objectToUnlinked(topLevelListItems(text), items, file, `spec:${written.slice(5).split("#")[0]}`);
+        }
+        // The description's own list is read the same way, when a change cites the
+        // description. Its sentences are not read.
+        if (descriptionCited)
+            objectToUnlinked(topLevelListItems(ctx.pullRequest.description), descriptionItems, "pr-description", "pr-description");
         for (const plannedTest of plannedTests) {
             if (normalizeCategory(plannedTest.scenario.category) !== CONFLICT_CATEGORY)
                 continue;

package/build/services/TestGenerationService.js

@@ -14,6 +14,7 @@ import { stageGeneratedPaths, resolveOutputDir } from "../utils/gitStaging.js";
 import { isInsideExecutorWorkDir, executorWorkDirRefusal, generationTargets, } from "../utils/executorWorkDir.js";
 import { getTestsRepoDir } from "../utils/AnalysisStateManager.js";
 import { recordReuseHandOff } from "../tools/code-refactor/reuse-state.js";
+import { isPomFirstTarget } from "../utils/reuseRouting.js";
 import { recordAssertionBaseline } from "../tools/code-refactor/assertion-state.js";
 import { persistGeneratedTest } from "../utils/generatedTestRecord.js";
 import { buildModularizeFirstNextSteps, isModularizeFirstHandOffTarget, reuseCodeArgsClause, } from "../prompts/reuse-hand-off.js";
@@ -166,6 +167,8 @@ export class TestGenerationService {
                     // and the report can mark it — without ever owing it for a test that was not
                     // told to run it. Keyed by the files this call wrote: a test generated into
                     // the same directory without codeReuse owes nothing.
+                    // Both reuse settings on: the page-object pass runs first (isPomFirstTarget).
+                    const pomFirst = isPomFirstTarget(params.language, reuseTestType);
                     await recordReuseHandOff(written, testType, params.language, effectiveFramework);
                     // Browser tests: the assertion enhancer anchors new assertions to
                     // selectors present in the test file, and after modularize → reuse
@@ -182,6 +185,7 @@ ${buildModularizeFirstNextSteps({
                         language: params.language,
                         framework: effectiveFramework,
                         enhanceFirst,
+                        pomFirst,
                     })}
 `;
                 }

package/build/tools/code-refactor/caller-gate.d.ts

@@ -0,0 +1,105 @@
+import type { UnifiedAnalysisState } from "../../utils/AnalysisStateManager.js";
+import { type TestExecutionStatus } from "../../types/TestExecution.js";
+import type { HelperChangeKind } from "../../types/ReuseOutcome.js";
+import type { ChangedHelperView } from "./helper-callers.js";
+/** One changed helper as a caller meets it. */
+export interface CalledChange {
+    /** Absolute path of the module it lives in — with several modules in scope, a
+     *  helper NAME alone does not say which one this caller met. */
+    utilsFile: string;
+    helper: string;
+    change: HelperChangeKind;
+}
+/** The execution recorded for one caller of a changed helper. */
+export interface CallerExecution {
+    /** Absolute path of the caller. */
+    file: string;
+    /** Present only when an execution ran the module as it stands. */
+    execution?: TestExecutionStatus;
+    /** This run delivered or edited the caller, so its own report row carries its
+     *  execution. Without this, a missing `execution` here reads as "never run" for a
+     *  file the run did run. */
+    deliveredByThisRun?: true;
+}
+/** A caller the run CAN execute that has no result against the changed module.
+ *
+ *  Carries what running it needs, because the gate has it in hand — it reads the
+ *  inventory entry to decide the file is runnable at all — and a remedy the agent has
+ *  to go and look values up for is a round spent discovering them. All three are
+ *  required on an inventory entry (`TestAnalysisResult`), and an owed caller always
+ *  has one: a caller without an entry is never owed. */
+export interface OwedCaller {
+    /** Absolute path of the caller. */
+    file: string;
+    /** The changed helpers it calls. */
+    helpers: CalledChange[];
+    language: string;
+    framework: string;
+    /** Not guessable from the path: SKYR-4435 records a shared module inventoried
+     *  with `unknown`. */
+    testType: string;
+}
+export interface ChangedHelperGateParams {
+    views: ChangedHelperView[];
+    /** `existingTests` says which callers are inventoried and runnable;
+     *  `testExecutions` holds the latest run of ANY file — the inventory's
+     *  `executionAfter` is written for a pre-existing test only, and a caller this
+     *  run created has its result nowhere else. */
+    state: Pick<UnifiedAnalysisState, "existingTests" | "testExecutions">;
+    /** Absolute paths of everything this run changed, across every checkout. */
+    changedFilesAbs: string[];
+}
+export interface ChangedHelperGateResult {
+    /** Per caller of a changed helper, by canonical path, the execution that ran the
+     *  changed module. */
+    executions: Map<string, CallerExecution>;
+    /** Callers the run can execute that have no result against the changed module.
+     *  Empty is the ordinary case. */
+    owed: OwedCaller[];
+}
+/**
+ * The report gate over the callers of a changed helper: each one the run CAN execute
+ * must have been run on the module as it stands. A caller that ran and FAILED is
+ * disclosed with its result and blocks nothing — the reviewer reads the red and
+ * decides, and SKYR-4451 adds the classification that decides for them.
+ *
+ * This is the retrofit gate's rule turned outward. A retrofit is a caller this run
+ * EDITED; a caller here is one it did not touch at all, which is why nothing ran it.
+ * The identity check differs accordingly (`freshExecution` is the same rule for
+ * both): a retrofit's execution must post-date the CALLER's last edit, and this one's
+ * must post-date the MODULE's — the caller is unchanged, and the bytes that changed
+ * under it are the module's.
+ *
+ * FAILS OPEN on every doubt, and the doubts are enumerated rather than inferred. It
+ * demands an execution only for a caller it has positive evidence about: the caller
+ * set is known, the file was inventoried as a Skyramp-generated test this run did not
+ * deliver, and the run is able to execute it. A helper whose callers could not be
+ * enumerated demands nothing; a false demand on a helper nobody calls is worse than
+ * a missing report line.
+ */
+export declare function changedHelperGate(params: ChangedHelperGateParams): Promise<ChangedHelperGateResult>;
+/**
+ * The refusal a set of unexecuted callers makes, and the exact call that clears it.
+ *
+ * GIVES the remedy rather than describing it. A sentence naming only the path and
+ * the phase produced a call missing arguments `skyramp_execute_test` requires, so the
+ * agent spent a round discovering which and could not always recover. The
+ * `unresolved-module` finding is the model: it hands over the literal header line to
+ * write, not a description of one. Here every value the server holds is printed per
+ * file, and the one it does not — the repository's own command for the file — is
+ * covered by the same instruction `skyramp_actions` gives for a before-run
+ * (`runTestCall`), so the two gates never describe the same call two ways.
+ *
+ * The arguments common to every caller are stated once above the list; a wall of
+ * eight calls × six arguments is its own way of being unreadable. A value is never
+ * dropped to shorten it.
+ *
+ * NOTHING HERE IS ABOUT A FAILING CALLER. This refuses on the ABSENCE of a result,
+ * which the agent can always remedy with one call per file. A caller that ran and
+ * failed is disclosed with its result and refuses nothing — see SKYR-4451.
+ */
+export declare function unrunCallerRefusal(owed: OwedCaller[], ctx: {
+    repoRoot: string;
+    repository: string;
+    stateFile: string;
+}): string | undefined;