@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/recommendation/budgeters/fixedNBudgeter.test.js

@@ -1,66 +0,0 @@
-import { fixedNBudgeter } from "./fixedNBudgeter.js";
-import { mkCandidate } from "../testFixtures.js";
-import { externalDedupKey } from "../../prompts/test-recommendation/recommendationShared.js";
-function ctx(over = {}) {
-    return {
-        maxGenerate: 3,
-        maxTotal: 20,
-        isUIOnlyPR: false,
-        hasFrontendChanges: false,
-        externalCoverage: new Set(),
-        ...over,
-    };
-}
-const gen = (r) => r.generate.map((c) => c.scenario.scenarioName);
-describe("fixedNBudgeter", () => {
-    it("backend-only PR fills maxGenerate slots via round-robin across test types", () => {
-        const ranked = [
-            mkCandidate("i1", { testType: "integration" }),
-            mkCandidate("i2", { testType: "integration" }),
-            mkCandidate("i3", { testType: "integration" }),
-            mkCandidate("c1", { testType: "contract" }),
-            mkCandidate("c2", { testType: "contract" }),
-        ];
-        const res = fixedNBudgeter.select(ranked, ctx());
-        expect(res.generate.length).toBe(3);
-        expect(res.reservedUISlots).toBe(0);
-        // buckets [integration, contract]; round 1 → i1, c1; round 2 → i2
-        expect(gen(res)).toEqual(["i1", "c1", "i2"]);
-    });
-    it("mixed (frontend) PR reserves one UI slot → backend count = maxGenerate - 1", () => {
-        const ranked = [
-            mkCandidate("i1", { testType: "integration" }),
-            mkCandidate("i2", { testType: "integration" }),
-            mkCandidate("c1", { testType: "contract" }),
-        ];
-        const res = fixedNBudgeter.select(ranked, ctx({ hasFrontendChanges: true }));
-        expect(res.generate.length).toBe(2);
-        expect(res.reservedUISlots).toBe(1);
-    });
-    it("UI-only PR selects no backend generate items", () => {
-        const res = fixedNBudgeter.select([mkCandidate("i1", { testType: "integration" })], ctx({ isUIOnlyPR: true }));
-        expect(res.generate.length).toBe(0);
-    });
-    it("additional = leftover candidates (rank order), excluding anything generated", () => {
-        const ranked = [
-            mkCandidate("i1", { testType: "integration" }),
-            mkCandidate("c1", { testType: "contract" }),
-            mkCandidate("i2", { testType: "integration" }),
-            mkCandidate("c2", { testType: "contract" }),
-        ];
-        const res = fixedNBudgeter.select(ranked, ctx());
-        const generated = new Set(gen(res));
-        for (const a of res.additional) {
-            expect(generated.has(a.scenario.scenarioName)).toBe(false);
-        }
-        expect(res.additional.length).toBe(1);
-    });
-    it("drops an ordinary candidate already covered by an external test", () => {
-        const covered = mkCandidate("covered", { testType: "contract" });
-        const fresh = mkCandidate("fresh", { testType: "integration" });
-        const res = fixedNBudgeter.select([covered, fresh], ctx({ maxGenerate: 5, externalCoverage: new Set([externalDedupKey(covered.scenario)]) }));
-        const all = [...res.generate, ...res.additional].map((c) => c.scenario.scenarioName);
-        expect(all).toContain("fresh");
-        expect(all).not.toContain("covered");
-    });
-});

package/build/recommendation/discriminators.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/recommendation/discriminators.test.js

@@ -1,324 +0,0 @@
-import { validateDiscriminator } from "./discriminators.js";
-import { DiscriminatorKind } from "../types/Recommendation.js";
-// A diff containing the verbatim anchors each valid claim below points at.
-const DIFF = [
-    "@@ netbox/circuits/models.py",
-    "+    if install_date == termination_date:",
-    "+        raise ValidationError('same-day circuit')",
-    "+    provider.account_count = len(accounts)",
-    "+    results = Provider.objects.filter(physical_address=query)",
-    '+    circuit.status = "active"',
-].join("\n");
-function step(over = {}) {
-    return {
-        order: 0,
-        method: "GET",
-        path: "/r",
-        description: "",
-        interactionType: "success",
-        expectedStatusCode: 200,
-        ...over,
-    };
-}
-function scenario(steps) {
-    return {
-        scenarioName: "s",
-        description: "s",
-        category: "business_rule",
-        priority: "high",
-        steps,
-        chainingKeys: [],
-        requiresAuth: false,
-        estimatedComplexity: "moderate",
-    };
-}
-const claim = (kind, anchor) => ({
-    kind,
-    changedCodeAnchor: anchor,
-});
-describe("validateDiscriminator — boundary_equality", () => {
-    const anchor = "install_date == termination_date";
-    it("verifies a same-day accept-side boundary (two distinct fields, equal value, 2xx)", () => {
-        const s = scenario([
-            step({
-                method: "POST",
-                path: "/api/circuits",
-                interactionType: "success",
-                expectedStatusCode: 201,
-                requestBody: { install_date: "2024-01-15", termination_date: "2024-01-15" },
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.BOUNDARY_EQUALITY, anchor), DIFF).verified).toBe(true);
-    });
-    it("verifies the mirrored reject side (4xx + interactionType error)", () => {
-        const s = scenario([
-            step({
-                method: "POST",
-                path: "/api/circuits",
-                interactionType: "error",
-                expectedStatusCode: 422,
-                requestBody: { install_date: "2024-01-15", termination_date: "2024-01-15" },
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.BOUNDARY_EQUALITY, anchor), DIFF).verified).toBe(true);
-    });
-    it("demotes a gaming attempt (happy-path GET, no equal-value fields)", () => {
-        const s = scenario([step({ method: "GET", path: "/api/circuits", expectedStatusCode: 200 })]);
-        const res = validateDiscriminator(s, claim(DiscriminatorKind.BOUNDARY_EQUALITY, anchor), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toMatch(/boundary_equality/);
-    });
-    it("returns unverified (no throw) on malformed input with no steps", () => {
-        const res = validateDiscriminator({}, claim(DiscriminatorKind.BOUNDARY_EQUALITY, anchor), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toBeDefined();
-    });
-    it("demotes when the anchor is absent from the diff", () => {
-        const s = scenario([
-            step({
-                method: "POST",
-                path: "/api/circuits",
-                expectedStatusCode: 201,
-                requestBody: { install_date: "2024-01-15", termination_date: "2024-01-15" },
-            }),
-        ]);
-        const res = validateDiscriminator(s, claim(DiscriminatorKind.BOUNDARY_EQUALITY, "absent_anchor_symbol"), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toMatch(/absent_anchor_symbol/);
-        expect(res.reason).toMatch(/diff/);
-    });
-});
-describe("validateDiscriminator — multi_record_aggregate", () => {
-    const anchor = "provider.account_count = len(accounts)";
-    it("verifies an explicit numeric-count assertion (account_count == 2)", () => {
-        const s = scenario([
-            step({ order: 0, method: "POST", path: "/api/providers", expectedStatusCode: 201 }),
-            step({
-                order: 1,
-                method: "GET",
-                path: "/api/providers/summary",
-                expectedStatusCode: 200,
-                expectedResponseFields: ["account_count == 2"],
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.MULTI_RECORD_AGGREGATE, anchor), DIFF).verified).toBe(true);
-    });
-    it("verifies >= 2 same-path POSTs before an asserting step", () => {
-        const s = scenario([
-            step({ order: 0, method: "POST", path: "/api/providers/1/accounts", expectedStatusCode: 201 }),
-            step({ order: 1, method: "POST", path: "/api/providers/1/accounts", expectedStatusCode: 201 }),
-            step({
-                order: 2,
-                method: "GET",
-                path: "/api/providers/1/summary",
-                expectedStatusCode: 200,
-                expectedResponseFields: ["accounts"],
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.MULTI_RECORD_AGGREGATE, anchor), DIFF).verified).toBe(true);
-    });
-    it("demotes a gaming attempt (single create + read, count 1)", () => {
-        const s = scenario([
-            step({ order: 0, method: "POST", path: "/api/providers", expectedStatusCode: 201 }),
-            step({
-                order: 1,
-                method: "GET",
-                path: "/api/providers/1",
-                expectedStatusCode: 200,
-                expectedResponseFields: ["name"],
-            }),
-        ]);
-        const res = validateDiscriminator(s, claim(DiscriminatorKind.MULTI_RECORD_AGGREGATE, anchor), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toMatch(/multi_record_aggregate/);
-    });
-    it("returns unverified (no throw) on malformed input with null steps", () => {
-        const res = validateDiscriminator({ steps: null }, claim(DiscriminatorKind.MULTI_RECORD_AGGREGATE, anchor), DIFF);
-        expect(res.verified).toBe(false);
-    });
-    it("demotes when the anchor is absent from the diff", () => {
-        const s = scenario([
-            step({ method: "GET", path: "/x", expectedStatusCode: 200, expectedResponseFields: ["account_count == 2"] }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.MULTI_RECORD_AGGREGATE, "not_in_diff_anchor"), DIFF).verified).toBe(false);
-    });
-});
-describe("validateDiscriminator — negative_match", () => {
-    const anchor = "physical_address=query";
-    it("verifies a substring near-miss asserting empty results", () => {
-        const s = scenario([
-            step({
-                order: 0,
-                method: "POST",
-                path: "/api/providers",
-                expectedStatusCode: 201,
-                requestBody: { physical_address: "123 Main Street, Building A" },
-            }),
-            step({
-                order: 1,
-                method: "GET",
-                path: "/api/providers",
-                expectedStatusCode: 200,
-                queryParams: { physical_address: "123 Main Street" },
-                expectedResponseFields: ["count == 0"],
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.NEGATIVE_MATCH, anchor), DIFF).verified).toBe(true);
-    });
-    it("verifies a 404 near-miss lookup", () => {
-        const s = scenario([
-            step({
-                order: 0,
-                method: "POST",
-                path: "/api/providers",
-                expectedStatusCode: 201,
-                requestBody: { slug: "acme-corp-provider" },
-            }),
-            step({
-                order: 1,
-                method: "GET",
-                path: "/api/providers/acme-corp",
-                expectedStatusCode: 404,
-                interactionType: "error",
-                queryParams: { slug: "acme-corp" },
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.NEGATIVE_MATCH, anchor), DIFF).verified).toBe(true);
-    });
-    it("demotes a gaming attempt (exact match, non-empty 200 result)", () => {
-        const s = scenario([
-            step({
-                order: 0,
-                method: "POST",
-                path: "/api/providers",
-                expectedStatusCode: 201,
-                requestBody: { physical_address: "123 Main Street" },
-            }),
-            step({
-                order: 1,
-                method: "GET",
-                path: "/api/providers",
-                expectedStatusCode: 200,
-                queryParams: { physical_address: "123 Main Street" },
-                expectedResponseFields: ["results"],
-            }),
-        ]);
-        const res = validateDiscriminator(s, claim(DiscriminatorKind.NEGATIVE_MATCH, anchor), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toMatch(/negative_match/);
-    });
-    it("returns unverified (no throw) on malformed input with no steps", () => {
-        const res = validateDiscriminator({}, claim(DiscriminatorKind.NEGATIVE_MATCH, anchor), DIFF);
-        expect(res.verified).toBe(false);
-    });
-    it("demotes when the anchor is absent from the diff", () => {
-        const s = scenario([
-            step({ method: "GET", path: "/x", expectedStatusCode: 404, queryParams: { q: "abc" } }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.NEGATIVE_MATCH, "missing_anchor_xyz"), DIFF).verified).toBe(false);
-    });
-});
-describe("validateDiscriminator — state_transition", () => {
-    const anchor = 'circuit.status = "active"';
-    it("verifies two same-resource mutations with divergent outcomes", () => {
-        const s = scenario([
-            step({
-                order: 0,
-                method: "PATCH",
-                path: "/api/circuits/5",
-                interactionType: "success",
-                expectedStatusCode: 200,
-                requestBody: { status: "active" },
-            }),
-            step({
-                order: 1,
-                method: "DELETE",
-                path: "/api/circuits/5",
-                interactionType: "error",
-                expectedStatusCode: 409,
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.STATE_TRANSITION, anchor), DIFF).verified).toBe(true);
-    });
-    it("verifies divergent mutations linked via chainsFrom", () => {
-        const s = scenario([
-            step({
-                order: 0,
-                method: "POST",
-                path: "/api/circuits",
-                interactionType: "success",
-                expectedStatusCode: 201,
-            }),
-            step({
-                order: 1,
-                method: "PATCH",
-                path: "/api/circuits/{id}",
-                interactionType: "success",
-                expectedStatusCode: 200,
-                chainsFrom: { sourceStep: 0, sourceField: "id", sourceLocation: "body", targetParam: "id", targetLocation: "path" },
-            }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.STATE_TRANSITION, anchor), DIFF).verified).toBe(true);
-    });
-    it("demotes a gaming attempt (two identical-outcome POSTs)", () => {
-        const s = scenario([
-            step({ order: 0, method: "POST", path: "/api/circuits", interactionType: "success", expectedStatusCode: 201 }),
-            step({ order: 1, method: "POST", path: "/api/circuits", interactionType: "success", expectedStatusCode: 201 }),
-        ]);
-        const res = validateDiscriminator(s, claim(DiscriminatorKind.STATE_TRANSITION, anchor), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toMatch(/state_transition/);
-    });
-    it("returns unverified (no throw) on malformed input with no steps", () => {
-        const res = validateDiscriminator({}, claim(DiscriminatorKind.STATE_TRANSITION, anchor), DIFF);
-        expect(res.verified).toBe(false);
-    });
-    it("demotes when the anchor is absent from the diff", () => {
-        const s = scenario([
-            step({ method: "PATCH", path: "/api/circuits/5", expectedStatusCode: 200 }),
-            step({ method: "DELETE", path: "/api/circuits/5", expectedStatusCode: 409, interactionType: "error" }),
-        ]);
-        expect(validateDiscriminator(s, claim(DiscriminatorKind.STATE_TRANSITION, "anchor_not_present"), DIFF).verified).toBe(false);
-    });
-});
-describe("validateDiscriminator — anchor gate", () => {
-    it("demotes a too-short anchor before any structural check", () => {
-        const s = scenario([step()]);
-        const res = validateDiscriminator(s, claim(DiscriminatorKind.BOUNDARY_EQUALITY, "short"), DIFF);
-        expect(res.verified).toBe(false);
-        expect(res.reason).toMatch(/too short/);
-    });
-    it("never throws on wholly malformed input", () => {
-        expect(() => validateDiscriminator(undefined, undefined, DIFF)).not.toThrow();
-        const res = validateDiscriminator(undefined, undefined, DIFF);
-        expect(res.verified).toBe(false);
-    });
-});
-describe("verifyAnchor whitespace normalization (seed-2 multi-line anchor regression)", () => {
-    const multiLineDiff = [
-        "--- a/circuits.py",
-        "+++ b/circuits.py",
-        "+        raise ValidationError({",
-        "+            'termination_date': _(",
-        "+                \"Termination date cannot precede install date.\")",
-        "+        })",
-    ].join("\n");
-    it("verifies an anchor that spans wrapped diff lines (collapsed whitespace, markers stripped)", () => {
-        const s = scenario([
-            step({ requestBody: { install_date: "2024-06-01", termination_date: "2024-06-01" }, expectedStatusCode: 201, interactionType: "success" }),
-        ]);
-        const result = validateDiscriminator(s, {
-            kind: DiscriminatorKind.BOUNDARY_EQUALITY,
-            changedCodeAnchor: "raise ValidationError({ 'termination_date': _( \"Termination date cannot precede install date.\") })",
-        }, multiLineDiff);
-        expect(result.verified).toBe(true);
-    });
-    it("still rejects an anchor that occurs nowhere in the diff", () => {
-        const s = scenario([
-            step({ requestBody: { install_date: "2024-06-01", termination_date: "2024-06-01" }, expectedStatusCode: 201, interactionType: "success" }),
-        ]);
-        const result = validateDiscriminator(s, { kind: DiscriminatorKind.BOUNDARY_EQUALITY, changedCodeAnchor: "this snippet is not in the diff at all" }, multiLineDiff);
-        expect(result.verified).toBe(false);
-        expect(result.reason).toContain("does not occur verbatim");
-    });
-});

package/build/recommendation/diversity.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/recommendation/diversity.test.js

@@ -1,77 +0,0 @@
-import { roundRobinByType, prioritizeAttackSurfaceBundles } from "./diversity.js";
-import { PriorityTier } from "../types/TestRecommendation.js";
-// Minimal DraftedScenario factory — only the fields the diversity helpers read
-// (category, description, steps.length, testType) matter here.
-function scen(name, opts = {}) {
-    return {
-        scenarioName: name,
-        description: opts.description ?? name,
-        category: opts.category ?? "workflow",
-        priority: "high",
-        steps: Array.from({ length: opts.steps ?? 2 }, () => ({})),
-        chainingKeys: [],
-        requiresAuth: false,
-        estimatedComplexity: "moderate",
-        testType: opts.testType,
-    };
-}
-function cand(name, priority, opts = {}) {
-    return { scenario: scen(name, opts), priority };
-}
-const names = (items) => items.map((i) => i.scenario.scenarioName);
-describe("roundRobinByType", () => {
-    it("returns [] when count <= 0", () => {
-        const items = [cand("a", PriorityTier.HIGH), cand("b", PriorityTier.HIGH)];
-        expect(roundRobinByType(items, 0)).toEqual([]);
-        expect(roundRobinByType(items, -1)).toEqual([]);
-    });
-    it("returns the full list in rank order when count >= length (degenerate == slice)", () => {
-        const items = [cand("a", PriorityTier.HIGH), cand("b", PriorityTier.HIGH), cand("c", PriorityTier.HIGH)];
-        expect(names(roundRobinByType(items, 3))).toEqual(["a", "b", "c"]);
-        expect(names(roundRobinByType(items, 5))).toEqual(["a", "b", "c"]);
-    });
-    it("with a single test type present, returns the first `count` by rank", () => {
-        const items = [
-            cand("i1", PriorityTier.HIGH, { testType: "integration" }),
-            cand("i2", PriorityTier.HIGH, { testType: "integration" }),
-            cand("i3", PriorityTier.HIGH, { testType: "integration" }),
-        ];
-        expect(names(roundRobinByType(items, 2))).toEqual(["i1", "i2"]);
-    });
-    it("distributes one slot per present test type before a second of any type", () => {
-        const items = [
-            cand("i1", PriorityTier.HIGH, { testType: "integration" }),
-            cand("i2", PriorityTier.HIGH, { testType: "integration" }),
-            cand("c1", PriorityTier.HIGH, { testType: "contract" }),
-            cand("i3", PriorityTier.HIGH, { testType: "integration" }),
-        ];
-        // First-appearance bucket order is [integration, contract]; round 1 picks one of each.
-        expect(names(roundRobinByType(items, 2))).toEqual(["i1", "c1"]);
-    });
-    it("selects protected (CRITICAL) items first, regardless of type or rank position", () => {
-        const items = [
-            cand("i1", PriorityTier.HIGH, { testType: "integration" }),
-            cand("i2", PriorityTier.HIGH, { testType: "integration" }),
-            cand("c1", PriorityTier.CRITICAL, { testType: "contract" }),
-        ];
-        const result = names(roundRobinByType(items, 2));
-        expect(result[0]).toBe("c1");
-        expect(result).toContain("i1");
-    });
-});
-describe("prioritizeAttackSurfaceBundles", () => {
-    it("moves an attack-surface security_boundary item ahead of the first ordinary direct-auth boundary", () => {
-        const items = [
-            cand("ordinary", PriorityTier.HIGH, { category: "security_boundary", description: "Auth boundary: GET /x" }),
-            cand("attack", PriorityTier.HIGH, {
-                category: "security_boundary",
-                description: "Attack-surface auth boundary: DELETE /x",
-            }),
-        ];
-        expect(names(prioritizeAttackSurfaceBundles(items))).toEqual(["attack", "ordinary"]);
-    });
-    it("leaves ordering unchanged when there is no attack-surface item", () => {
-        const items = [cand("a", PriorityTier.HIGH), cand("b", PriorityTier.HIGH)];
-        expect(names(prioritizeAttackSurfaceBundles(items))).toEqual(["a", "b"]);
-    });
-});

package/build/recommendation/planRanker.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/recommendation/planRanker.test.js

@@ -1,110 +0,0 @@
-import { rankCandidates, selectPlan } from "./planRanker.js";
-import { Novelty, PriorityTier } from "../types/TestRecommendation.js";
-import { CandidateSource, DiscriminatorKind, computeCandidateId } from "../types/Recommendation.js";
-function cand(name, opts = {}) {
-    const steps = [
-        { order: 0, method: "GET", path: `/${name}`, description: "", interactionType: "success", expectedStatusCode: 200 },
-        { order: 1, method: "POST", path: `/${name}`, description: "", interactionType: "success", expectedStatusCode: 201 },
-    ];
-    const scenario = {
-        scenarioName: name,
-        description: name,
-        category: opts.category ?? "workflow",
-        priority: opts.agentPriority ?? "high",
-        steps,
-        chainingKeys: [],
-        requiresAuth: false,
-        estimatedComplexity: "moderate",
-        testType: opts.testType ?? "integration",
-    };
-    return {
-        scenario,
-        priority: PriorityTier.HIGH,
-        novelty: Novelty.EXISTING,
-        source: CandidateSource.AGENT,
-        candidateId: computeCandidateId(scenario),
-        verifiedDiscriminator: opts.verified,
-    };
-}
-const names = (cs) => cs.map((c) => c.scenario.scenarioName);
-const ids = (cs) => cs.map((c) => c.candidateId);
-describe("rankCandidates", () => {
-    it("floats a verified discriminator (agent priority 'low') above an unverified security_boundary (agent priority 'high') — the round-1 miscalibration regression", () => {
-        const verifiedLow = cand("verified-boundary", {
-            category: "business_rule",
-            agentPriority: "low",
-            verified: DiscriminatorKind.BOUNDARY_EQUALITY,
-        });
-        const unverifiedHigh = cand("generic-authz", {
-            category: "security_boundary",
-            agentPriority: "high",
-        });
-        const ranked = rankCandidates([unverifiedHigh, verifiedLow]);
-        expect(names(ranked)).toEqual(["verified-boundary", "generic-authz"]);
-    });
-    it("keeps bug_caught / CRITICAL carve-out first, even ahead of a verified discriminator", () => {
-        const bug = cand("bug-catcher", { category: "bug_caught" });
-        const verified = cand("verified-agg", { category: "business_rule", verified: DiscriminatorKind.MULTI_RECORD_AGGREGATE });
-        const ranked = rankCandidates([verified, bug]);
-        expect(names(ranked)[0]).toBe("bug-catcher");
-    });
-    it("orders by category priority when carve-out and verification are equal", () => {
-        const high = cand("high-cat", { category: "security_boundary" }); // HIGH
-        const low = cand("low-cat", { category: "crud" }); // LOW
-        const medium = cand("medium-cat", { category: "workflow" }); // MEDIUM
-        expect(names(rankCandidates([low, medium, high]))).toEqual(["high-cat", "medium-cat", "low-cat"]);
-    });
-    it("is deterministic: identical input and any shuffle yield the same order", () => {
-        const a = cand("alpha", { category: "business_rule", verified: DiscriminatorKind.BOUNDARY_EQUALITY });
-        const b = cand("bravo", { category: "security_boundary" });
-        const c = cand("charlie", { category: "bug_caught" });
-        const d = cand("delta", { category: "crud", agentPriority: "high" });
-        const e = cand("echo", { category: "workflow", verified: DiscriminatorKind.STATE_TRANSITION });
-        const order1 = ids(rankCandidates([a, b, c, d, e]));
-        const order2 = ids(rankCandidates([a, b, c, d, e]));
-        const shuffled = ids(rankCandidates([e, c, a, d, b]));
-        expect(order1).toEqual(order2);
-        expect(shuffled).toEqual(order1);
-    });
-    it("does not let the agent priority tag break a tie (candidateId is the stable tiebreak)", () => {
-        // Same category, same verification → agent priority is irrelevant; order is by candidateId.
-        const hi = cand("zeta", { category: "workflow", agentPriority: "high" });
-        const lo = cand("alfa", { category: "workflow", agentPriority: "low" });
-        const forward = ids(rankCandidates([hi, lo]));
-        const backward = ids(rankCandidates([lo, hi]));
-        expect(forward).toEqual(backward);
-    });
-    it("does not mutate the input array", () => {
-        const input = [cand("b", { category: "crud" }), cand("a", { category: "bug_caught" })];
-        const before = names(input);
-        rankCandidates(input);
-        expect(names(input)).toEqual(before);
-    });
-});
-describe("selectPlan", () => {
-    const ctx = (over = {}) => ({
-        maxGenerate: 3,
-        maxTotal: 20,
-        isUIOnlyPR: false,
-        hasFrontendChanges: false,
-        externalCoverage: new Set(),
-        ...over,
-    });
-    it("ranks then budgets, surfacing the supplied demotions on the result", () => {
-        const candidates = [
-            cand("gen-a", { category: "business_rule", verified: DiscriminatorKind.BOUNDARY_EQUALITY }),
-            cand("gen-b", { category: "security_boundary" }),
-            cand("gen-c", { category: "crud" }),
-        ];
-        const demotions = [{ candidateId: "faked-claim-abc12345", reason: "boundary_equality unverified" }];
-        const res = selectPlan(candidates, ctx({ demotions }));
-        expect(res.generate.length).toBeGreaterThan(0);
-        expect(res.demotions).toEqual(demotions);
-        // The verified discriminator is ranked first and lands in GENERATE.
-        expect(res.generate[0].scenario.scenarioName).toBe("gen-a");
-    });
-    it("defaults demotions to an empty array when none are supplied", () => {
-        const res = selectPlan([cand("solo", { category: "workflow" })], ctx());
-        expect(res.demotions).toEqual([]);
-    });
-});

package/build/resources/testbotResource.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/resources/testbotResource.test.js

@@ -1,44 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import * as os from "os";
-import * as path from "path";
-jest.unstable_mockModule("../utils/logger.js", () => ({
-    logger: { info: jest.fn(), error: jest.fn(), warning: jest.fn(), debug: jest.fn() },
-}));
-jest.unstable_mockModule("../services/AnalyticsService.js", () => ({
-    AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) },
-}));
-const { registerTestbotResource } = await import("./testbotResource.js");
-function captureResourceHandler() {
-    let handler;
-    const fakeServer = {
-        registerResource: (_name, _template, _meta, fn) => {
-            handler = fn;
-        },
-    };
-    registerTestbotResource(fakeServer);
-    return (uri) => handler(uri);
-}
-describe("registerTestbotResource", () => {
-    // No .skyramp/workspace.yml under a fresh tmp dir, so readWorkspaceServices
-    // resolves to [] without touching the filesystem in an unexpected way.
-    const repositoryPath = path.join(os.tmpdir(), "skyr-4023-resource-test");
-    function makeUri(params) {
-        const uri = new URL("skyramp://prompts/testbot");
-        uri.searchParams.set("repositoryPath", repositoryPath);
-        for (const [key, value] of Object.entries(params)) {
-            uri.searchParams.set(key, value);
-        }
-        return uri;
-    }
-    it("includes the report-language instruction when the URI has ?language=ja", async () => {
-        const handle = captureResourceHandler();
-        const result = await handle(makeUri({ language: "ja" }));
-        expect(result.contents[0].text).toContain("**Report language: Japanese.**");
-    });
-    it("omits the report-language instruction when language is absent", async () => {
-        const handle = captureResourceHandler();
-        const result = await handle(makeUri({}));
-        expect(result.contents[0].text).not.toContain("**Report language:");
-    });
-});

package/build/services/AnalyticsService.test.d.ts

@@ -1 +0,0 @@
-export {};