@skyramp/mcp 0.2.7 → 0.2.8

package/build/types/TestbotReport.d.ts

@@ -0,0 +1,68 @@
+import type { DriftAction } from "./TestAnalysis.js";
+import type { TestExecutionStatus } from "./TestExecution.js";
+import type { HttpMethod, TestType } from "./TestTypes.js";
+/**
+ * Shape of the JSON report written by skyramp_submit_report and read by testbot
+ * for rendering as Markdown. All fields mirror the corresponding Zod schemas in
+ * submitReportTool.ts — keep the two in sync.
+ */
+export interface TestbotReport {
+    businessCaseAnalysis: string;
+    newTestsCreated: {
+        testId: string;
+        testType: TestType;
+        endpoint: string;
+        fileName: string;
+        reasoning: string;
+        description?: string;
+        scenarioFile?: string;
+        traceFile?: string;
+        frontendTrace?: string;
+    }[];
+    /** Omitted when no existing tests were found (agent omits the field). */
+    testMaintenance?: {
+        testType: TestType;
+        endpoint: string;
+        fileName: string;
+        description: string;
+        action: DriftAction;
+        beforeStatus: TestExecutionStatus;
+        beforeDetails: string;
+        afterStatus: TestExecutionStatus;
+        afterDetails: string;
+    }[];
+    testResults: {
+        testType: TestType;
+        endpoint: string;
+        status: "Pass" | "Fail" | "Skipped";
+        details: string;
+        videoPath?: string;
+    }[];
+    additionalRecommendations?: {
+        testId: string;
+        testType: TestType;
+        category?: string;
+        primaryEndpoint?: string;
+        scenarioName?: string;
+        steps: {
+            method?: HttpMethod;
+            path?: string;
+            description: string;
+            expectedStatusCode?: number;
+            requestBody?: Record<string, unknown>;
+            responseBody?: Record<string, unknown>;
+        }[];
+        description: string;
+        priority: "high" | "medium" | "low";
+        reasoning: string;
+        openApiSpec?: string;
+        backendTrace?: string;
+        frontendTrace?: string;
+    }[];
+    issuesFound: {
+        description: string;
+        severity?: "critical" | "high" | "medium" | "low";
+    }[];
+    nextSteps: string[];
+    commitMessage: string;
+}

package/build/types/TestbotReport.js

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

package/build/types/index.d.ts

@@ -0,0 +1,4 @@
+export { TestExecutionStatus } from "./TestExecution.js";
+export { DriftAction } from "./TestAnalysis.js";
+export { TestType, HttpMethod } from "./TestTypes.js";
+export type { TestbotReport } from "./TestbotReport.js";

package/build/types/index.js

@@ -0,0 +1,3 @@
+export { TestExecutionStatus } from "./TestExecution.js";
+export { DriftAction } from "./TestAnalysis.js";
+export { TestType, HttpMethod } from "./TestTypes.js";

package/build/utils/AnalysisStateManager.d.ts

@@ -6,6 +6,10 @@ import type { CandidateUiPage } from "./uiPageEnumerator.js";
 export type { CandidateUiPage } from "./uiPageEnumerator.js";
 export declare function setTestsRepoDir(dir: string | undefined): void;
 export declare function getTestsRepoDir(): string | undefined;
+export declare function setActiveRunStatePath(stateFilePath: string): void;
+export declare function getActiveRunStatePath(): string | undefined;
+/** Reset the run anchor — for tests, and as a safety hook between runs. */
+export declare function clearActiveRunStatePath(): void;
 export declare function registerSession(sessionId: string, stateFilePath: string): void;
 export declare function getSessionFilePath(sessionId: string): string | undefined;
 export declare function getRegisteredSessions(): ReadonlyMap<string, string>;
@@ -96,17 +100,39 @@ interface StateMetadata {
     sessionId: string;
     stateType: StateType;
     repositoryPath?: string;
+    /** owner/repo of the PRIMARY repo, recorded on the root so related-repo writes
+     *  can be distinguished from the primary. Absent only for legacy single-repo
+     *  state files written before explicit tagging. */
+    repository?: string;
     createdAt: string;
     updatedAt: string;
     step?: string;
 }
 /**
- * State file format - data fields at root level with metadata
+ * One related repo's analysis section in a run-scoped (multi-repo) state file.
+ * The primary repo's analysis stays at the root for backward compatibility; each
+ * related repo's analysis is stored here keyed by its `owner/repo`.
+ */
+interface RepoStateSection<T> {
+    /** Analysis payload — same shape as the root (e.g. UnifiedAnalysisState). */
+    data: T;
+    /** Absolute checkout path of this repo (used to re-absolutize test paths). */
+    repositoryPath?: string;
+}
+/**
+ * State file format - data fields at root level with metadata.
  * Example: { tests: [...], metadata: {...} }
  * Example: { repositoryPath: "...", analysis: {...}, mapping: {...}, metadata: {...} }
+ *
+ * Multi-repo (run-scoped) files additionally carry `relatedRepos`: a map of
+ * `owner/repo` → that repo's analysis section. State is per-RUN, not per-repo —
+ * one file holds the primary (at root) plus every related repo's section, so
+ * there is exactly one stateFile per Testbot run. A file with no `relatedRepos`
+ * key is a single-repo file and behaves exactly as before.
  */
 type StateFile<T> = T & {
     metadata: StateMetadata;
+    relatedRepos?: Record<string, RepoStateSection<T>>;
 };
 /**
  * Generic State Manager for persisting workflow data
@@ -150,7 +176,41 @@ export declare class StateManager<T = any> {
     writeData(data: T, options?: {
         repositoryPath?: string;
         step?: string;
+        /** owner/repo recorded on the root metadata — identifies the PRIMARY repo
+         *  so later section routing (isPrimaryRepo) can compare against it.
+         *  Preserved when omitted. */
+        repository?: string;
+    }): Promise<void>;
+    /** Is `repo` the primary section? Primary when `repo` is falsy (single-repo /
+     *  legacy callers), when no state file exists yet (the FIRST write of a run is
+     *  the primary — the testbot prompt mandates the primary is analyzed first), or
+     *  when `repo` matches the `repo` recorded on the root metadata. A non-empty
+     *  `repo` that doesn't match an already-recorded root is a RELATED repo. */
+    private isPrimaryRepo;
+    /**
+     * Write one repo's analysis into the run-scoped state file. The primary repo
+     * (repo absent, or matching the root's recorded repo, or the first write of the
+     * run) is written to the root via writeData(); a related repo is upserted into
+     * `relatedRepos[repo]`, preserving the primary + other sections. Used by
+     * skyramp_analyze_changes — every repo in the run writes the SAME stateFile path.
+     */
+    writeRepoData(data: T, options: {
+        repo?: string;
+        repositoryPath?: string;
+        step?: string;
     }): Promise<void>;
+    /**
+     * Read one repo's analysis payload from the run-scoped state file. `repo`
+     * undefined → the primary (root) section (identical to readData()).
+     */
+    readRepoData(repo?: string): Promise<T | null>;
+    /**
+     * Resolve the checkout path for a repo's section — used to re-absolutize test
+     * paths. `repo` undefined → the primary's metadata.repositoryPath.
+     */
+    getRepoRepositoryPath(repo?: string): Promise<string | undefined>;
+    /** List the related repo keys present in the run-scoped file (empty if single-repo). */
+    listRelatedRepos(): Promise<string[]>;
     getStatePath(): string;
     getSessionId(): string;
     getStateType(): StateType;

package/build/utils/AnalysisStateManager.js

@@ -22,6 +22,29 @@ export function setTestsRepoDir(dir) {
 export function getTestsRepoDir() {
     return _testsRepoDir;
 }
+/**
+ * Multi-repo run anchor: the path of the run-scoped analysis state file for the
+ * current Testbot run. One Testbot run = one MCP server process, so a single
+ * module-level value is naturally run-scoped (same pattern as _testsRepoDir and
+ * processSessionRegistry above).
+ *
+ * skyramp_analyze_changes sets this on the FIRST call of a multi-repo run (the one
+ * carrying a `repository`) and REUSES it on subsequent related-repo calls, so every
+ * repo's analysis lands in ONE state file with per-repo sections — without the agent
+ * ever passing a file path (which previously caused filename hallucinations).
+ * Single-repo / standalone calls (no `repository`) never set or read this.
+ */
+let _activeRunStatePath;
+export function setActiveRunStatePath(stateFilePath) {
+    _activeRunStatePath = stateFilePath;
+}
+export function getActiveRunStatePath() {
+    return _activeRunStatePath;
+}
+/** Reset the run anchor — for tests, and as a safety hook between runs. */
+export function clearActiveRunStatePath() {
+    _activeRunStatePath = undefined;
+}
 /**
  * In-memory session store: sessionId → { data, storedAt }.
  * Eliminates the need for the LLM to read/write state files on disk.
@@ -119,6 +142,15 @@ export class StateManager {
         if (stateFilePath) {
             this.stateFile = stateFilePath;
         }
+        else if (stateType === "analysis" && process.env.RUNNER_TEMP) {
+            // In CI (testbot action), RUNNER_TEMP is a job-isolated dir that both the
+            // action and this tool can independently derive — no LLM input needed.
+            // TODO: interim step — remove this branch when stateFile and summaryOutputFile are merged
+            // (see getTestbotPrompt TODO). RUNNER_TEMP is GitHub Actions-specific; other CI systems
+            // (Jenkins, GitLab, Buildkite) must set it explicitly. Once merged, path flows through
+            // summaryOutputFile which is already testbot-controlled and CI-agnostic.
+            this.stateFile = path.join(process.env.RUNNER_TEMP, "skyramp", "analyze-changes-state.json");
+        }
         else {
             const baseDir = stateDir || os.tmpdir();
             const prefix = STATE_FILE_PREFIXES[stateType];
@@ -161,7 +193,11 @@ export class StateManager {
         }
         try {
             const content = await fs.promises.readFile(this.stateFile, "utf-8");
-            const { metadata, ...data } = JSON.parse(content);
+            // Strip both metadata and the multi-repo relatedRepos section so callers
+            // get only the PRIMARY repo's analysis payload (unchanged single-repo shape).
+            const { metadata, relatedRepos, ...data } = JSON.parse(content);
+            void metadata;
+            void relatedRepos;
             logger.debug(`Read data from state file: ${this.stateFile}`);
             return data;
         }
@@ -192,11 +228,14 @@ export class StateManager {
      */
     async writeData(data, options) {
         try {
-            // Read existing metadata if file exists
+            // Read existing metadata + any related-repo sections if file exists, so
+            // rewriting the primary (root) payload preserves the multi-repo sections.
             let existingMetadata;
+            let existingRelated;
             if (this.exists()) {
                 const existing = await this.readFullState();
                 existingMetadata = existing?.metadata;
+                existingRelated = existing?.relatedRepos;
             }
             const state = {
                 ...data,
@@ -204,10 +243,12 @@ export class StateManager {
                     sessionId: this.sessionId,
                     stateType: this.stateType,
                     repositoryPath: options?.repositoryPath || existingMetadata?.repositoryPath,
+                    repository: options?.repository ?? existingMetadata?.repository,
                     createdAt: existingMetadata?.createdAt || new Date().toISOString(),
                     updatedAt: new Date().toISOString(),
                     step: options?.step,
                 },
+                ...(existingRelated ? { relatedRepos: existingRelated } : {}),
             };
             await fs.promises.mkdir(path.dirname(this.stateFile), { recursive: true });
             await fs.promises.writeFile(this.stateFile, JSON.stringify(state, null, 2), "utf-8");
@@ -218,6 +259,106 @@ export class StateManager {
             throw new Error(`Failed to write state file: ${error.message}`);
         }
     }
+    // -----------------------------------------------------------------------
+    // Multi-repo (run-scoped) section access
+    //
+    // State is per-RUN: one file holds the primary repo at the root plus each
+    // related repo under `relatedRepos[<owner/repo>]`. `repo` undefined (or
+    // matching the root's metadata.repo) targets the PRIMARY section, so all
+    // single-repo behavior is unchanged.
+    // -----------------------------------------------------------------------
+    /** Is `repo` the primary section? Primary when `repo` is falsy (single-repo /
+     *  legacy callers), when no state file exists yet (the FIRST write of a run is
+     *  the primary — the testbot prompt mandates the primary is analyzed first), or
+     *  when `repo` matches the `repo` recorded on the root metadata. A non-empty
+     *  `repo` that doesn't match an already-recorded root is a RELATED repo. */
+    async isPrimaryRepo(repo) {
+        if (!repo)
+            return true;
+        // First write of the run is the primary (the prompt mandates the primary is
+        // analyzed first), even when it carries an explicit owner/repo.
+        if (!this.exists())
+            return true;
+        const full = await this.readFullState();
+        // File already exists: primary only if `repo` matches the repo recorded on
+        // the root. An untagged root means the primary was written without a repo
+        // (legacy/single-repo), so any non-empty `repo` here is a RELATED repo.
+        return full?.metadata.repository === repo;
+    }
+    /**
+     * Write one repo's analysis into the run-scoped state file. The primary repo
+     * (repo absent, or matching the root's recorded repo, or the first write of the
+     * run) is written to the root via writeData(); a related repo is upserted into
+     * `relatedRepos[repo]`, preserving the primary + other sections. Used by
+     * skyramp_analyze_changes — every repo in the run writes the SAME stateFile path.
+     */
+    async writeRepoData(data, options) {
+        if (await this.isPrimaryRepo(options.repo)) {
+            await this.writeData(data, {
+                repositoryPath: options.repositoryPath,
+                step: options.step,
+                // Record the primary's owner/repo on the root so later related-repo
+                // writes can distinguish it from a section by matching this value.
+                repository: options.repo,
+            });
+            return;
+        }
+        // Related repo: read the current file (must already exist — primary is
+        // analyzed first), upsert this repo's section, write back.
+        const existing = (await this.readFullState());
+        const base = existing ??
+            {
+                metadata: {
+                    sessionId: this.sessionId,
+                    stateType: this.stateType,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                },
+            };
+        const relatedRepos = { ...(base.relatedRepos ?? {}) };
+        // Preserve a previously-stored repositoryPath when this write omits it.
+        // Callers that update a section without re-supplying the checkout path (e.g.
+        // skyramp_execute_test writing execution results) must not clobber the path
+        // that skyramp_analyze_changes recorded — getRepoRepositoryPath() relies on
+        // it to re-absolutize that repo's test paths.
+        const priorRepositoryPath = relatedRepos[options.repo]?.repositoryPath;
+        relatedRepos[options.repo] = {
+            data,
+            repositoryPath: options.repositoryPath ?? priorRepositoryPath,
+        };
+        base.relatedRepos = relatedRepos;
+        base.metadata = { ...base.metadata, updatedAt: new Date().toISOString() };
+        await fs.promises.mkdir(path.dirname(this.stateFile), { recursive: true });
+        await fs.promises.writeFile(this.stateFile, JSON.stringify(base, null, 2), "utf-8");
+        logger.debug(`Wrote ${options.repo} section to state file: ${this.stateFile}`);
+    }
+    /**
+     * Read one repo's analysis payload from the run-scoped state file. `repo`
+     * undefined → the primary (root) section (identical to readData()).
+     */
+    async readRepoData(repo) {
+        if (await this.isPrimaryRepo(repo)) {
+            return this.readData();
+        }
+        const full = await this.readFullState();
+        return full?.relatedRepos?.[repo]?.data ?? null;
+    }
+    /**
+     * Resolve the checkout path for a repo's section — used to re-absolutize test
+     * paths. `repo` undefined → the primary's metadata.repositoryPath.
+     */
+    async getRepoRepositoryPath(repo) {
+        const full = await this.readFullState();
+        if (await this.isPrimaryRepo(repo)) {
+            return full?.metadata.repositoryPath;
+        }
+        return full?.relatedRepos?.[repo]?.repositoryPath;
+    }
+    /** List the related repo keys present in the run-scoped file (empty if single-repo). */
+    async listRelatedRepos() {
+        const full = await this.readFullState();
+        return Object.keys(full?.relatedRepos ?? {});
+    }
     getStatePath() {
         return this.stateFile;
     }
@@ -260,7 +401,7 @@ export class StateManager {
      * @returns Number of files deleted
      */
     static async cleanupOldFiles(maxAgeHours = 24, stateDir, stateTypes) {
-        const baseDir = stateDir || os.tmpdir();
+        const baseDir = stateDir || (process.env.RUNNER_TEMP ? path.join(process.env.RUNNER_TEMP, "skyramp") : os.tmpdir());
         const files = await fs.promises.readdir(baseDir).catch(() => []);
         const statePrefixes = stateTypes
             ? stateTypes.map((t) => STATE_FILE_PREFIXES[t])

package/build/utils/AnalysisStateManager.test.js

@@ -34,3 +34,101 @@ describe("StateManager.writeData", () => {
         await fs.promises.rm(nestedDir, { recursive: true, force: true });
     });
 });
+describe("StateManager — run-scoped per-repo sections (SKYR-3796)", () => {
+    let stateFile;
+    const mkState = (tag) => ({
+        existingTests: [{ testFile: `${tag}.spec.ts` }],
+        analysisScope: AnalysisScope.CurrentBranchDiff,
+        newEndpoints: [],
+    });
+    beforeEach(() => {
+        stateFile = path.join(os.tmpdir(), `skyramp-analysis-sections-${Date.now()}.json`);
+    });
+    afterEach(async () => {
+        await fs.promises.rm(stateFile, { force: true });
+    });
+    it("keeps the primary at root and additional repos in relatedRepos, all in ONE file", async () => {
+        const mgr = StateManager.fromStatePath(stateFile);
+        // Primary (repo omitted) → root; additional repo → section.
+        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
+        await mgr.writeRepoData(mkState("api"), {
+            repo: "letsramp/api-insight",
+            repositoryPath: "/work/api-insight",
+        });
+        // Exactly one file on disk.
+        expect(fs.existsSync(stateFile)).toBe(true);
+        expect(fs.existsSync(`${stateFile}.1.json`)).toBe(false);
+        const raw = JSON.parse(await fs.promises.readFile(stateFile, "utf-8"));
+        // Primary analysis lives at root (backward-compatible single-repo shape).
+        expect(raw.existingTests[0].testFile).toBe("primary.spec.ts");
+        expect(raw.metadata.repositoryPath).toBe("/work/primary");
+        // Additional repo under relatedRepos, keyed by owner/repo.
+        expect(raw.relatedRepos["letsramp/api-insight"].data.existingTests[0].testFile).toBe("api.spec.ts");
+        expect(raw.relatedRepos["letsramp/api-insight"].repositoryPath).toBe("/work/api-insight");
+    });
+    it("reads back the correct section by repo (primary when omitted)", async () => {
+        const mgr = StateManager.fromStatePath(stateFile);
+        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
+        await mgr.writeRepoData(mkState("api"), { repo: "letsramp/api-insight", repositoryPath: "/work/api-insight" });
+        expect((await mgr.readRepoData()).existingTests[0].testFile).toBe("primary.spec.ts");
+        expect((await mgr.readRepoData("letsramp/api-insight")).existingTests[0].testFile).toBe("api.spec.ts");
+        expect(await mgr.getRepoRepositoryPath()).toBe("/work/primary");
+        expect(await mgr.getRepoRepositoryPath("letsramp/api-insight")).toBe("/work/api-insight");
+        expect(await mgr.listRelatedRepos()).toEqual(["letsramp/api-insight"]);
+    });
+    it("preserves additional sections when the primary root is rewritten (writeData)", async () => {
+        const mgr = StateManager.fromStatePath(stateFile);
+        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
+        await mgr.writeRepoData(mkState("api"), { repo: "letsramp/api-insight", repositoryPath: "/work/api-insight" });
+        // execute_test-style root rewrite must not drop the additional section.
+        const primary = (await mgr.readRepoData());
+        primary.existingTests[0].execution = { marker: "ran" };
+        await mgr.writeData(primary);
+        expect((await mgr.readRepoData("letsramp/api-insight")).existingTests[0].testFile).toBe("api.spec.ts");
+        expect((await mgr.readRepoData()).existingTests[0].execution.marker).toBe("ran");
+    });
+    it("preserves an additional repo's repositoryPath when a later write omits it", async () => {
+        const mgr = StateManager.fromStatePath(stateFile);
+        await mgr.writeRepoData(mkState("primary"), { repositoryPath: "/work/primary" });
+        // analyze_changes records the section WITH its checkout path.
+        await mgr.writeRepoData(mkState("api"), {
+            repo: "letsramp/api-insight",
+            repositoryPath: "/work/api-insight",
+        });
+        // A later write to the same section (e.g. execute_test) omits repositoryPath.
+        await mgr.writeRepoData(mkState("api-ran"), { repo: "letsramp/api-insight" });
+        // The path must survive so getRepoRepositoryPath can still re-absolutize.
+        expect(await mgr.getRepoRepositoryPath("letsramp/api-insight")).toBe("/work/api-insight");
+        expect((await mgr.readRepoData("letsramp/api-insight")).existingTests[0].testFile).toBe("api-ran.spec.ts");
+    });
+    it("routes the primary to root and a related repo to a section when BOTH pass an explicit repo", async () => {
+        const mgr = StateManager.fromStatePath(stateFile);
+        // The agent now always passes an explicit owner/repo, including for the
+        // primary. The FIRST write is the primary → root (tagged on metadata).
+        await mgr.writeRepoData(mkState("primary"), {
+            repo: "letsramp/primary-app",
+            repositoryPath: "/work/primary",
+        });
+        await mgr.writeRepoData(mkState("api"), {
+            repo: "letsramp/api-insight",
+            repositoryPath: "/work/api-insight",
+        });
+        const raw = JSON.parse(await fs.promises.readFile(stateFile, "utf-8"));
+        expect(raw.metadata.repository).toBe("letsramp/primary-app");
+        expect(raw.existingTests[0].testFile).toBe("primary.spec.ts");
+        expect(raw.relatedRepos["letsramp/api-insight"].data.existingTests[0].testFile).toBe("api.spec.ts");
+        // The primary is reachable BOTH by its explicit repo and by omitting it.
+        expect((await mgr.readRepoData("letsramp/primary-app")).existingTests[0].testFile).toBe("primary.spec.ts");
+        expect((await mgr.readRepoData()).existingTests[0].testFile).toBe("primary.spec.ts");
+        expect(await mgr.getRepoRepositoryPath("letsramp/primary-app")).toBe("/work/primary");
+        expect(await mgr.listRelatedRepos()).toEqual(["letsramp/api-insight"]);
+    });
+    it("reads a legacy single-section file (no relatedRepos) as the primary", async () => {
+        const mgr = StateManager.fromStatePath(stateFile);
+        // Legacy write path — no repo, no sections.
+        await mgr.writeData(mkState("legacy"), { repositoryPath: "/work/legacy" });
+        expect((await mgr.readRepoData()).existingTests[0].testFile).toBe("legacy.spec.ts");
+        expect(await mgr.getRepoRepositoryPath()).toBe("/work/legacy");
+        expect(await mgr.listRelatedRepos()).toEqual([]);
+    });
+});

package/build/utils/docker.test.js

@@ -55,7 +55,7 @@ describe("dockerImageExistsLocally", () => {
     });
 });
 describe("pullDockerImage", () => {
-    const IMAGE = "skyramp/executor:v1.3.28";
+    const IMAGE = "skyramp/executor:v1.3.29";
     beforeEach(() => jest.clearAllMocks());
     describe("on amd64 host", () => {
         const originalArch = process.arch;

package/build/utils/routeParsers.d.ts

@@ -50,14 +50,4 @@ export interface ClassifiedEndpoints {
     baseBranch: string;
     affectedServices: string[];
 }
-/**
- * Classify endpoints by cross-referencing `changedFiles` against `scannedEndpoints[].sourceFile`.
- *
- * This replaces `parseEndpointsFromDiff` — instead of regex-parsing diff hunks for route
- * annotations (fragile for 15+ frameworks), it uses the already-scanned endpoint catalog
- * which has full, resolved paths and concrete HTTP methods.
- *
- * For deleted files, the caller must supply endpoints recovered from the base branch
- * (via `parseFileEndpoints` on `git show base:<file>`) in `deletedFileEndpoints`.
- */
 export declare function classifyEndpointsByChangedFiles(diffData: BranchDiffData, scannedEndpoints: ScannedEndpoint[], deletedFileEndpoints?: ScannedEndpoint[]): ClassifiedEndpoints;

package/build/utils/routeParsers.js

@@ -406,21 +406,36 @@ const GENERIC_ROUTE_BASENAMES = new Set(["api", "app", "handler", "handlers", "i
 function normalizeSourcePath(filePath) {
     return filePath.replace(/\\/g, "/");
 }
-/**
- * Classify endpoints by cross-referencing `changedFiles` against `scannedEndpoints[].sourceFile`.
- *
- * This replaces `parseEndpointsFromDiff` — instead of regex-parsing diff hunks for route
- * annotations (fragile for 15+ frameworks), it uses the already-scanned endpoint catalog
- * which has full, resolved paths and concrete HTTP methods.
- *
- * For deleted files, the caller must supply endpoints recovered from the base branch
- * (via `parseFileEndpoints` on `git show base:<file>`) in `deletedFileEndpoints`.
- */
+function staticPathSegments(urlPath) {
+    return urlPath.split("/").filter(s => s && !/^[:{[]/.test(s)).map(s => s.toLowerCase());
+}
+function endpointSourceResource(ep) {
+    const sourceSegments = ep.sourceFile.split(/[\\/]/).filter(Boolean);
+    const filename = sourceSegments.at(-1)?.replace(/\.[^.]+$/, "") ?? "";
+    const normalizedFilename = filename.replace(/^(?:old|new)[-_]/i, "").toLowerCase();
+    const isDynamic = /^\[.*\]$/.test(normalizedFilename) || /^\{.*\}$/.test(normalizedFilename);
+    if (!isDynamic && !GENERIC_ROUTE_BASENAMES.has(normalizedFilename) && normalizedFilename) {
+        return normalizedFilename;
+    }
+    else if (GENERIC_ROUTE_BASENAMES.has(normalizedFilename)) {
+        // Generic filename: walk up the directory tree for a more specific ancestor name.
+        const parentSegments = sourceSegments.slice(0, -1).reverse();
+        const contextSegment = parentSegments
+            .map(s => s.replace(/\.[^.]+$/, "").replace(/^(?:old|new)[-_]/i, "").toLowerCase())
+            .find(s => s && !GENERIC_ROUTE_BASENAMES.has(s) && !/^\[.*\]$/.test(s) && !/^\{.*\}$/.test(s));
+        if (contextSegment)
+            return `${contextSegment}/${normalizedFilename}`;
+    }
+    // Fall back to the last static segment of the endpoint's URL path.
+    const segments = staticPathSegments(ep.path);
+    return segments.at(-1) ?? normalizedFilename;
+}
+function endpointMovedKey(path, resource, method) {
+    return method ? `${path}::${resource}::${method}` : `${path}::${resource}`;
+}
 export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, deletedFileEndpoints) {
     const newFileSet = new Set(diffData.newFiles.map(normalizeSourcePath));
     const deletedFileSet = new Set(diffData.deletedFiles.map(normalizeSourcePath));
-    // Build sourceFile -> ScannedEndpoint[] map from the post-change catalog.
-    // Git diffs use POSIX separators; scanner output can reflect OS-native paths.
     const bySourceFile = new Map();
     for (const ep of scannedEndpoints) {
         const sourceKey = normalizeSourcePath(ep.sourceFile);
@@ -435,7 +450,6 @@ export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, dele
     const unmatchedFiles = [];
     for (const file of diffData.changedFiles) {
         const fileKey = normalizeSourcePath(file);
-        // Deleted files won't appear in scanned catalog — handled separately below
         if (deletedFileSet.has(fileKey))
             continue;
         const eps = bySourceFile.get(fileKey);
@@ -454,47 +468,26 @@ export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, dele
     // Filter out endpoints that still exist in the current catalog as moved/refactored.
     // Same router-relative paths can exist in sibling files, so only treat them as moved
     // when the source resource also matches.
-    function endpointSourceResource(ep) {
-        const sourceSegments = ep.sourceFile.split(/[\\/]/).filter(Boolean);
-        const base = sourceSegments.at(-1)?.replace(/\.[^.]+$/, "") ?? "";
-        const normalizedBase = base.replace(/^(?:old|new)[-_]/i, "").toLowerCase();
-        const isDynamicBase = /^\[.*\]$/.test(normalizedBase) || /^\{.*\}$/.test(normalizedBase);
-        if (normalizedBase && !isDynamicBase && !GENERIC_ROUTE_BASENAMES.has(normalizedBase)) {
-            return normalizedBase;
-        }
-        if (normalizedBase && GENERIC_ROUTE_BASENAMES.has(normalizedBase)) {
-            const contextSegment = [...sourceSegments]
-                .slice(0, -1)
-                .reverse()
-                .map((segment) => segment.replace(/\.[^.]+$/, "").replace(/^(?:old|new)[-_]/i, "").toLowerCase())
-                .find((segment) => segment && !GENERIC_ROUTE_BASENAMES.has(segment) && !/^\[.*\]$/.test(segment) && !/^\{.*\}$/.test(segment));
-            if (contextSegment)
-                return `${contextSegment}/${normalizedBase}`;
-        }
-        const staticSegments = ep.path.split("/").filter(Boolean).filter((segment) => !/^[:{[]/.test(segment));
-        return staticSegments[staticSegments.length - 1]?.toLowerCase() ?? normalizedBase;
-    }
     const currentMethodKeys = new Set();
     const currentPathResourceKeys = new Set();
     const currentMultiKeys = new Set();
-    const movedKey = (path, resource, method) => method ? `${path}::${resource}::${method}` : `${path}::${resource}`;
     for (const current of scannedEndpoints) {
         const currentResource = endpointSourceResource(current);
-        const pathResourceKey = movedKey(current.path, currentResource);
+        const pathResourceKey = endpointMovedKey(current.path, currentResource);
         currentPathResourceKeys.add(pathResourceKey);
         for (const method of current.methods) {
             if (method === "MULTI")
                 currentMultiKeys.add(pathResourceKey);
-            currentMethodKeys.add(movedKey(current.path, currentResource, method));
+            currentMethodKeys.add(endpointMovedKey(current.path, currentResource, method));
         }
     }
     function isMovedEndpoint(deleted, method) {
         const deletedResource = endpointSourceResource(deleted);
-        const pathResourceKey = movedKey(deleted.path, deletedResource);
+        const pathResourceKey = endpointMovedKey(deleted.path, deletedResource);
         if (method === "MULTI")
             return currentPathResourceKeys.has(pathResourceKey);
         return currentMultiKeys.has(pathResourceKey) ||
-            currentMethodKeys.has(movedKey(deleted.path, deletedResource, method));
+            currentMethodKeys.has(endpointMovedKey(deleted.path, deletedResource, method));
     }
     const removedEndpoints = (deletedFileEndpoints ?? [])
         .map((ep) => ({

package/build/utils/scenarioDrafting.d.ts

@@ -41,7 +41,7 @@ export type ResourceRelationships = Map<string, Set<string>>;
  * the caller to fall back to heuristic pairing.
  */
 export declare function inferResourceRelationships(endpoints: Array<EndpointInput>): ResourceRelationships;
-export declare function draftScenariosFromEndpoints(endpoints: Array<EndpointInput>, newEndpoints?: Array<EndpointRef>, wsAuthType?: WorkspaceAuthType, options?: ScenarioDraftOptions): DraftedScenario[];
+export declare function draftScenariosFromEndpoints(endpoints: Array<EndpointInput>, newEndpoints?: Array<EndpointRef>, wsAuthType?: WorkspaceAuthType, options?: ScenarioDraftOptions, removedEndpoints?: Array<EndpointRef>): DraftedScenario[];
 /**
  * Draft scenarios that directly test each new endpoint in the branch diff.
  *