@skyramp/mcp 0.3.1 → 0.3.2-rc.pom-2

package/build/utils/pom-verify/verify.test.js

@@ -0,0 +1,325 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { verifyReuse } from "./verify.js";
+const OO = path.join(path.dirname(fileURLToPath(import.meta.url)), "__fixtures__", "oo-style");
+const AF = path.join(path.dirname(fileURLToPath(import.meta.url)), "__fixtures__", "af-style");
+/** Materializes a hermetic mkdtemp project (so `findRoot`/`globPomFiles` resolve deterministically
+ * against just this tree, not the real monorepo checkout) and returns its root + a cleanup fn. */
+function makeProject(files) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pom-verify-"));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = path.join(root, rel);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, content);
+    }
+    return { root, cleanup: () => fs.rmSync(root, { recursive: true, force: true }) };
+}
+const read = (dir, name) => fs.readFileSync(path.join(dir, name), "utf8");
+describe("verifyReuse -- oo-style (page-manager convention)", () => {
+    it("passes a clean spec: real method via pm binding -> ok:true, checkedCalls>0", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{"type":"module"}`,
+            "pages/page-manager.js": read(OO, "page-manager.js"),
+            "pages/loginPage.js": read(OO, "loginPage.js"),
+            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
+            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
+            "clean.spec.js": `
+        import { PageManager } from './pages/page-manager.js';
+        async function run() {
+          const pm = new PageManager(page);
+          await pm.loginPage.signInAs(user);
+        }
+        await run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "clean.spec.js"), "javascript");
+            expect(result.ok).toBe(true);
+            expect(result.violations).toEqual([]);
+            expect(result.checkedCalls).toBeGreaterThan(0);
+            expect(result.parseError).toBeUndefined();
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it("flags a hallucinated member with the real member list", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{"type":"module"}`,
+            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
+            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
+            "violation.spec.js": `
+        import { WidgetsPage } from './pages/widgetsPage.js';
+        async function run() {
+          const widgets = new WidgetsPage(page);
+          await widgets.dragWidgetFake();
+        }
+        await run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "violation.spec.js"), "javascript");
+            expect(result.violations).toEqual([
+                {
+                    binding: "widgets",
+                    member: "dragWidgetFake",
+                    searched: [path.join(root, "pages", "widgetsPage.js"), path.join(root, "pages", "widgetHelpers.js")],
+                    availableMembers: expect.arrayContaining(["addBtn"]),
+                },
+            ]);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+describe("verifyReuse -- oo-style (CJS page-manager convention)", () => {
+    it("engages on a CJS PageManager (no `export` on the class, module.exports, a default import, an extensionless require) -- real call passes, checkedCalls>0", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{}`,
+            "pages/page-manager.js": read(OO, "page-manager-cjs.js"),
+            "pages/loginPage.js": read(OO, "loginPage.js"),
+            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
+            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
+            "cjs-clean.spec.js": `
+        const PageManager = require('./pages/page-manager.js');
+        async function run() {
+          const pm = new PageManager(page);
+          await pm.loginPage.signInAs(user);
+        }
+        run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "cjs-clean.spec.js"), "javascript");
+            expect(result.ok).toBe(true);
+            expect(result.violations).toEqual([]);
+            expect(result.checkedCalls).toBeGreaterThan(0);
+            expect(result.parseError).toBeUndefined();
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it("flags a hallucinated method on a real pm member as a violation, with the real member list", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{}`,
+            "pages/page-manager.js": read(OO, "page-manager-cjs.js"),
+            "pages/loginPage.js": read(OO, "loginPage.js"),
+            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
+            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
+            "cjs-violation.spec.js": `
+        const PageManager = require('./pages/page-manager.js');
+        async function run() {
+          const pm = new PageManager(page);
+          await pm.widgetsPage.dragWidgetFake();
+        }
+        run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "cjs-violation.spec.js"), "javascript");
+            expect(result.violations).toEqual([
+                {
+                    binding: "pm.widgetsPage",
+                    member: "dragWidgetFake",
+                    searched: [path.join(root, "pages", "widgetsPage.js"), path.join(root, "pages", "widgetHelpers.js")],
+                    availableMembers: expect.arrayContaining(["addBtn"]),
+                },
+            ]);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+describe("verifyReuse -- af-style (tsconfig path-alias imports)", () => {
+    it("engages via a `@pageobjects/*` tsconfig alias -- real member passes, checkedCalls>0", async () => {
+        const { root, cleanup } = makeProject({
+            "tsconfig.json": read(AF, "alias.tsconfig.json"),
+            "src/pageobjects/asset-list-page.ts": read(AF, "pageobjects/asset-list-page.ts"),
+            "src/tests/alias.spec.ts": `
+        import { AssetListPage } from '@pageobjects/asset-list-page';
+        const list = new AssetListPage(page);
+        await list.clickSearch();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "src", "tests", "alias.spec.ts"), "typescript");
+            expect(result.ok).toBe(true);
+            expect(result.violations).toEqual([]);
+            expect(result.checkedCalls).toBeGreaterThan(0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it("flags a hallucinated method reached via the alias import as a violation", async () => {
+        const { root, cleanup } = makeProject({
+            "tsconfig.json": read(AF, "alias.tsconfig.json"),
+            "src/pageobjects/asset-list-page.ts": read(AF, "pageobjects/asset-list-page.ts"),
+            "src/tests/alias-violation.spec.ts": `
+        import { AssetListPage } from '@pageobjects/asset-list-page';
+        const list = new AssetListPage(page);
+        await list.clickSearchFake();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "src", "tests", "alias-violation.spec.ts"), "typescript");
+            expect(result.violations).toEqual([
+                {
+                    binding: "list",
+                    member: "clickSearchFake",
+                    searched: [path.join(root, "src", "pageobjects", "asset-list-page.ts")],
+                    availableMembers: expect.arrayContaining(["clickSearch"]),
+                },
+            ]);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+describe("verifyReuse -- af-style (direct instantiation)", () => {
+    it("routes deep chains and unknown bindings to unverifiable, never violations", async () => {
+        const { root, cleanup } = makeProject({
+            "components/asset-list.page.ts": read(AF, "asset-list.page.ts"),
+            "components/workflow-footer.page.ts": read(AF, "workflow-footer.page.ts"),
+            "deep.spec.ts": `
+        import { AssetListPage } from './components/asset-list.page.js';
+        import { Unknown } from './components/unknown.js';
+        const list = new AssetListPage(page);
+        const thing = new Unknown();
+        await list.footer.okBtn.click();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "deep.spec.ts"), "typescript");
+            expect(result.violations).toEqual([]);
+            expect(result.unverifiable).toEqual(expect.arrayContaining(["list.footer.okBtn.click", "thing"]));
+            expect(result.ok).toBe(true);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it("verifies a direct-instantiation class's own member against the class file", async () => {
+        const { root, cleanup } = makeProject({
+            "components/report.iframe.page.ts": read(AF, "report.iframe.page.ts"),
+            "iframe.spec.ts": `
+        import { ReportIframePage } from './components/report.iframe.page.js';
+        const report = new ReportIframePage(frame);
+        expect(report.exportBtn).toBeVisible();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "iframe.spec.ts"), "typescript");
+            expect(result.violations).toEqual([]);
+            expect(result.ok).toBe(true);
+            expect(result.checkedCalls).toBeGreaterThan(0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+describe("verifyReuse -- free-function bindings", () => {
+    it("verifies a real free-function call (empty chain) against its source file -- ok:true, checkedCalls>0", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{"type":"module"}`,
+            "pages/commonActions.js": read(OO, "commonActions.js"),
+            "clean-fn.spec.js": `
+        import { openNavFlyout } from './pages/commonActions.js';
+        async function run() {
+          await openNavFlyout(page);
+        }
+        await run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "clean-fn.spec.js"), "javascript");
+            expect(result.violations).toEqual([]);
+            expect(result.ok).toBe(true);
+            expect(result.checkedCalls).toBeGreaterThan(0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it("flags a hallucinated free-function call instead of crashing on the empty chain", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{"type":"module"}`,
+            "pages/commonActions.js": read(OO, "commonActions.js"),
+            "violation-fn.spec.js": `
+        import { fakeHelper } from './pages/commonActions.js';
+        async function run() {
+          await fakeHelper(page);
+        }
+        await run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "violation-fn.spec.js"), "javascript");
+            expect(result.violations).toEqual([
+                {
+                    binding: "fakeHelper",
+                    member: "fakeHelper",
+                    searched: [path.join(root, "pages", "commonActions.js")],
+                    availableMembers: expect.any(Array),
+                },
+            ]);
+            expect(result.ok).toBe(false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+describe("verifyReuse -- tsconfig paths with non-string values", () => {
+    it("skips a non-string paths target instead of throwing -- verification still runs", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{"type":"module"}`,
+            "tsconfig.json": `{"compilerOptions":{"paths":{"@x/*":[42]}}}`,
+            "pages/commonActions.js": read(OO, "commonActions.js"),
+            "clean-fn.spec.js": `
+        import { openNavFlyout } from './pages/commonActions.js';
+        async function run() {
+          await openNavFlyout(page);
+        }
+        await run();
+      `,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "clean-fn.spec.js"), "javascript");
+            expect(result.parseError).toBeUndefined();
+            expect(result.violations).toEqual([]);
+            expect(result.ok).toBe(true);
+            expect(result.checkedCalls).toBeGreaterThan(0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+describe("verifyReuse -- parse errors", () => {
+    it("reports a parse error for broken JS output", async () => {
+        const { root, cleanup } = makeProject({
+            "package.json": `{"type":"module"}`,
+            "broken.spec.js": `function broken( {\n`,
+        });
+        try {
+            const result = await verifyReuse(path.join(root, "broken.spec.js"), "javascript");
+            expect(result.ok).toBe(false);
+            expect(result.parseError).toBeDefined();
+            expect(result.parseError.length).toBeLessThanOrEqual(500);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});

package/build/utils/reportVerification.d.ts

@@ -0,0 +1,61 @@
+import { DriftAction } from "../types/TestAnalysis.js";
+/**
+ * Enumerate every path that differs from HEAD in the working tree — staged,
+ * unstaged, or untracked — as repo-relative paths, via `git status --porcelain`.
+ * A file the agent physically created or edited always shows up here (even if it
+ * was never `git add`ed), so a claim with no matching entry is one where no file
+ * work actually happened.
+ *
+ * Uses the NUL-delimited (`-z`) format: paths are emitted verbatim (no quoting,
+ * no backslash-escaping) and separated by NUL, so filenames containing spaces,
+ * leading/trailing whitespace, or even newlines are parsed exactly. In this
+ * format a rename/copy record spans two NUL fields — the destination path first,
+ * then the original — so we take the destination and skip the following field.
+ * `--untracked-files=all` lists each untracked file individually (otherwise git
+ * collapses a brand-new directory to "dir/", which would defeat path matching).
+ */
+export declare function listChangedFiles(repoRoot: string): Promise<string[]>;
+export interface UnbackedClaimsInput {
+    /** Absolute path of the primary repo checkout the report pertains to. */
+    repoRoot: string;
+    /** Repo-relative paths that have a working-tree change (from listChangedFiles). */
+    changedFiles: string[];
+    /** LLM-supplied created-test claims. */
+    newTests: {
+        testId?: string;
+        fileName?: string;
+        repository?: string;
+    }[];
+    /** Maintenance verdicts (server-derived from skyramp_actions). */
+    verdicts: {
+        action: DriftAction;
+        testFilePath: string;
+    }[];
+    /** owner/repo of the primary repo — used to exempt cross-repo newTest claims
+     *  whose files live in a different checkout. */
+    primaryRepository?: string;
+}
+/**
+ * Cross-check report claims against files that actually changed in the working
+ * tree, returning a human-readable description for each claim NOT backed by a
+ * real change. An empty result means every claim is backed.
+ *
+ * The delivery path can only ship what the agent actually edited (SKYR-3883), so
+ * a report must never claim file work the tree doesn't reflect. This is the
+ * source-side guard: fail `skyramp_submit_report` loudly so the agent makes the
+ * edit (or drops the claim) rather than hallucinating it into the report.
+ *
+ * Only UPDATE verdicts are gated: an UPDATE is a targeted in-place edit that
+ * reliably implies a working-tree change. Exemptions:
+ *  - REGENERATE verdicts — on an EXTERNAL (user-authored Playwright/Cypress/RTL)
+ *    test these are report-only (Skyramp can't auto-regenerate them; the developer
+ *    acts manually), so no working-tree change is expected; and even an internal
+ *    regeneration can produce byte-identical content (no diff). Gating them would
+ *    falsely reject legitimate reports.
+ *  - DELETE verdicts — applied deterministically by the delivery step, not
+ *    necessarily reflected in the tree at report time.
+ *  - IGNORE / VERIFY verdicts — assert that NO edit was needed.
+ *  - Claims for files outside this checkout (cross-repo `repository`, or an
+ *    absolute path resolving outside `repoRoot`) — a different checkout owns them.
+ */
+export declare function findUnbackedClaims(input: UnbackedClaimsInput): string[];

package/build/utils/reportVerification.js

@@ -0,0 +1,104 @@
+import path from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { testFileMatches } from "./utils.js";
+import { DriftAction } from "../types/TestAnalysis.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Enumerate every path that differs from HEAD in the working tree — staged,
+ * unstaged, or untracked — as repo-relative paths, via `git status --porcelain`.
+ * A file the agent physically created or edited always shows up here (even if it
+ * was never `git add`ed), so a claim with no matching entry is one where no file
+ * work actually happened.
+ *
+ * Uses the NUL-delimited (`-z`) format: paths are emitted verbatim (no quoting,
+ * no backslash-escaping) and separated by NUL, so filenames containing spaces,
+ * leading/trailing whitespace, or even newlines are parsed exactly. In this
+ * format a rename/copy record spans two NUL fields — the destination path first,
+ * then the original — so we take the destination and skip the following field.
+ * `--untracked-files=all` lists each untracked file individually (otherwise git
+ * collapses a brand-new directory to "dir/", which would defeat path matching).
+ */
+export async function listChangedFiles(repoRoot) {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd: repoRoot });
+    const files = [];
+    const tokens = stdout.split("\0");
+    for (let i = 0; i < tokens.length; i++) {
+        const entry = tokens[i];
+        // Each record is "XY <path>"; a trailing empty token follows the final NUL.
+        if (entry.length < 4)
+            continue;
+        const status = entry.slice(0, 2);
+        const p = entry.slice(3);
+        // Rename (R) / copy (C): the NEXT NUL field is the original path — consume
+        // and skip it; the destination path (this token) is the changed file.
+        if (/[RC]/.test(status))
+            i++;
+        if (p)
+            files.push(p);
+    }
+    return files;
+}
+/**
+ * Cross-check report claims against files that actually changed in the working
+ * tree, returning a human-readable description for each claim NOT backed by a
+ * real change. An empty result means every claim is backed.
+ *
+ * The delivery path can only ship what the agent actually edited (SKYR-3883), so
+ * a report must never claim file work the tree doesn't reflect. This is the
+ * source-side guard: fail `skyramp_submit_report` loudly so the agent makes the
+ * edit (or drops the claim) rather than hallucinating it into the report.
+ *
+ * Only UPDATE verdicts are gated: an UPDATE is a targeted in-place edit that
+ * reliably implies a working-tree change. Exemptions:
+ *  - REGENERATE verdicts — on an EXTERNAL (user-authored Playwright/Cypress/RTL)
+ *    test these are report-only (Skyramp can't auto-regenerate them; the developer
+ *    acts manually), so no working-tree change is expected; and even an internal
+ *    regeneration can produce byte-identical content (no diff). Gating them would
+ *    falsely reject legitimate reports.
+ *  - DELETE verdicts — applied deterministically by the delivery step, not
+ *    necessarily reflected in the tree at report time.
+ *  - IGNORE / VERIFY verdicts — assert that NO edit was needed.
+ *  - Claims for files outside this checkout (cross-repo `repository`, or an
+ *    absolute path resolving outside `repoRoot`) — a different checkout owns them.
+ */
+export function findUnbackedClaims(input) {
+    const { repoRoot, changedFiles, newTests, verdicts, primaryRepository } = input;
+    const unbacked = [];
+    const isBacked = (claimedPath) => {
+        let candidate = claimedPath;
+        if (path.isAbsolute(claimedPath)) {
+            const rel = path.relative(repoRoot, claimedPath);
+            // Outside this checkout — not verifiable here; treat as backed (exempt).
+            if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
+                return true;
+            candidate = rel;
+        }
+        return changedFiles.some((c) => testFileMatches(c, candidate));
+    };
+    for (const t of newTests) {
+        if (!t.fileName)
+            continue;
+        // Cross-repo finding — its file lives in a different checkout, not this tree.
+        // Exempt any claim explicitly attributed to a repo that isn't the primary.
+        // When the primary repo is unknown (primaryRepository undefined) we can't
+        // confirm the file belongs to this checkout, so any explicitly-attributed
+        // claim is exempted rather than risk a false rejection.
+        if (t.repository && t.repository !== primaryRepository)
+            continue;
+        if (!isBacked(t.fileName)) {
+            unbacked.push(`newTestsCreated "${t.testId ?? t.fileName}" claims file "${t.fileName}", but no matching file was created or modified in the working tree`);
+        }
+    }
+    for (const v of verdicts) {
+        // Only UPDATE (a targeted in-place edit) is required to have a working-tree
+        // change. REGENERATE is exempt: external report-only regenerations make no
+        // change, and internal ones may regenerate to identical content.
+        if (v.action !== DriftAction.Update)
+            continue;
+        if (!isBacked(v.testFilePath)) {
+            unbacked.push(`testMaintenance ${v.action} claims an edit to "${path.basename(v.testFilePath)}", but that file has no working-tree change`);
+        }
+    }
+    return unbacked;
+}

package/build/utils/reportVerification.test.d.ts

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

package/build/utils/reportVerification.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect } from "@jest/globals";
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { DriftAction } from "../types/TestAnalysis.js";
+import { findUnbackedClaims, listChangedFiles } from "./reportVerification.js";
+const REPO = "/repo";
+describe("findUnbackedClaims", () => {
+    it("returns [] when every claim is backed by a working-tree change", () => {
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: [
+                "tests/skyramp/products_contract_test.py",
+                "dcim/tests/test_filtersets.py",
+            ],
+            newTests: [
+                {
+                    testId: "contract-get-products",
+                    fileName: "products_contract_test.py",
+                },
+            ],
+            verdicts: [
+                {
+                    action: DriftAction.Update,
+                    testFilePath: "/repo/dcim/tests/test_filtersets.py",
+                },
+            ],
+        });
+        expect(unbacked).toEqual([]);
+    });
+    it("flags a newTestsCreated claim whose file was never created (hallucination)", () => {
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: ["tests/skyramp/products_contract_test.py"],
+            newTests: [
+                {
+                    testId: "integration-phantom",
+                    fileName: "phantom_integration_test.py",
+                },
+            ],
+            verdicts: [],
+        });
+        expect(unbacked).toHaveLength(1);
+        expect(unbacked[0]).toContain("phantom_integration_test.py");
+    });
+    it("flags an UPDATE verdict whose file has no working-tree change (the SKYR-3883 case)", () => {
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: ["tests/skyramp/site_filter_integration_test.py"],
+            newTests: [],
+            verdicts: [
+                {
+                    action: DriftAction.Update,
+                    testFilePath: "/repo/dcim/tests/test_filtersets.py",
+                },
+            ],
+        });
+        expect(unbacked).toHaveLength(1);
+        expect(unbacked[0]).toContain("test_filtersets.py");
+    });
+    it("never flags REGENERATE/DELETE/IGNORE/VERIFY verdicts even when absent from the tree", () => {
+        // REGENERATE is exempt: external (user-authored) regenerations are report-only
+        // with no working-tree change, and internal ones may regenerate identically.
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: [],
+            newTests: [],
+            verdicts: [
+                {
+                    action: DriftAction.Regenerate,
+                    testFilePath: "/repo/frontend/tests/cart_pom.spec.ts",
+                },
+                { action: DriftAction.Delete, testFilePath: "/repo/tests/gone.py" },
+                { action: DriftAction.Ignore, testFilePath: "/repo/tests/kept.py" },
+                { action: DriftAction.Verify, testFilePath: "/repo/tests/checked.py" },
+            ],
+        });
+        expect(unbacked).toEqual([]);
+    });
+    it("exempts a cross-repo newTest claim (repository differs from the primary)", () => {
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: [],
+            newTests: [
+                {
+                    testId: "contract-related",
+                    fileName: "related_contract_test.py",
+                    repository: "acme/related-repo",
+                },
+            ],
+            verdicts: [],
+            primaryRepository: "acme/primary-repo",
+        });
+        expect(unbacked).toEqual([]);
+    });
+    it("exempts a cross-repo newTest claim even when the primary repo is unknown", () => {
+        // primaryRepository omitted: we can't confirm the file belongs to this
+        // checkout, so an explicitly-attributed claim must not be validated here.
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: [],
+            newTests: [
+                {
+                    testId: "contract-related",
+                    fileName: "related_contract_test.py",
+                    repository: "acme/related-repo",
+                },
+            ],
+            verdicts: [],
+        });
+        expect(unbacked).toEqual([]);
+    });
+    it("exempts a verdict whose absolute path resolves outside the checkout", () => {
+        const unbacked = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: [],
+            newTests: [],
+            verdicts: [
+                {
+                    action: DriftAction.Update,
+                    testFilePath: "/somewhere/else/outside_test.py",
+                },
+            ],
+        });
+        expect(unbacked).toEqual([]);
+    });
+    it("matches a nested newTest fileName by basename against the changed path", () => {
+        const backed = findUnbackedClaims({
+            repoRoot: REPO,
+            changedFiles: ["tests/skyramp/deep/nested_contract_test.py"],
+            newTests: [{ testId: "c", fileName: "nested_contract_test.py" }],
+            verdicts: [],
+        });
+        expect(backed).toEqual([]);
+    });
+});
+describe("listChangedFiles", () => {
+    it("lists staged, unstaged, and untracked paths as repo-relative strings", async () => {
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "rv-repo-"));
+        const git = (args) => execFileSync("git", args, { cwd: repo, stdio: "pipe" });
+        git(["init", "-q"]);
+        git(["config", "user.email", "t@t.dev"]);
+        git(["config", "user.name", "t"]);
+        // committed baseline
+        fs.mkdirSync(path.join(repo, "dcim/tests"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "dcim/tests/test_filtersets.py"), "orig\n");
+        git(["add", "-A"]);
+        git(["commit", "-q", "-m", "base"]);
+        // modify a tracked file (unstaged) + add an untracked file
+        fs.writeFileSync(path.join(repo, "dcim/tests/test_filtersets.py"), "edited\n");
+        fs.mkdirSync(path.join(repo, "tests/skyramp"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "tests/skyramp/new_contract_test.py"), "new\n");
+        const changed = await listChangedFiles(repo);
+        expect(changed).toContain("dcim/tests/test_filtersets.py");
+        expect(changed).toContain("tests/skyramp/new_contract_test.py");
+    });
+    it("attributes a renamed file to its destination path and skips the original", async () => {
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "rv-repo-"));
+        const git = (args) => execFileSync("git", args, { cwd: repo, stdio: "pipe" });
+        git(["init", "-q"]);
+        git(["config", "user.email", "t@t.dev"]);
+        git(["config", "user.name", "t"]);
+        fs.mkdirSync(path.join(repo, "dcim/tests"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "dcim/tests/old_test.py"), "def test_x(): pass\n");
+        git(["add", "-A"]);
+        git(["commit", "-q", "-m", "base"]);
+        // Staged rename (identical content → git detects it as R100).
+        git(["mv", "dcim/tests/old_test.py", "dcim/tests/new_test.py"]);
+        const changed = await listChangedFiles(repo);
+        expect(changed).toContain("dcim/tests/new_test.py");
+        expect(changed).not.toContain("dcim/tests/old_test.py");
+    });
+    it("preserves a path containing spaces (NUL-delimited, no quoting)", async () => {
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "rv-repo-"));
+        const git = (args) => execFileSync("git", args, { cwd: repo, stdio: "pipe" });
+        git(["init", "-q"]);
+        git(["config", "user.email", "t@t.dev"]);
+        git(["config", "user.name", "t"]);
+        fs.mkdirSync(path.join(repo, "tests/skyramp"), { recursive: true });
+        fs.writeFileSync(path.join(repo, "tests/skyramp/my new test.py"), "new\n");
+        const changed = await listChangedFiles(repo);
+        expect(changed).toContain("tests/skyramp/my new test.py");
+    });
+});