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

package/build/utils/featureFlags.js

@@ -39,3 +39,40 @@ export function isContractConsumerModeEnabled() {
 export function isTestbotEnabled() {
     return process.env.SKYRAMP_FEATURE_TESTBOT === "1";
 }
+/**
+ * Returns true when the local-dev workflow is enabled
+ * (SKYRAMP_FEATURE_LOCAL_DEV=1).
+ *
+ * The local-dev workflow registers the `skyramp_local_dev` prompt and
+ * one-click routing, which diffs from a base commit against the current
+ * working state, generates mock configurations and backend tests, executes
+ * them locally, and reports results — without requiring a pull request or
+ * CI environment.
+ */
+export function isLocalDevEnabled() {
+    return process.env.SKYRAMP_FEATURE_LOCAL_DEV === "1";
+}
+/**
+ * Returns true when general one-click workflows are enabled
+ * (SKYRAMP_FEATURE_ONE_CLICK=1).
+ */
+export function isOneClickEnabled() {
+    return process.env.SKYRAMP_FEATURE_ONE_CLICK === "1";
+}
+/**
+ * Gates the POM-aware path of `skyramp_reuse_code`
+ * (SKYRAMP_FEATURE_POM_REUSE=1).
+ *
+ * When OFF (default), TypeScript/JavaScript + Playwright targets are treated
+ * like every other target: `skyramp_reuse_code` returns the SkyrampUtils
+ * consolidation prompt, and none of the POM machinery runs — no deterministic
+ * POM pre-scoping, no POM catalog / mapping-table workflow, no `verify: true`
+ * compliance gates, and consequently no `reuse` summary on the report (nothing
+ * records an outcome to re-derive).
+ *
+ * When ON, the test is refactored against the repo's existing page objects and
+ * the verification gates apply.
+ */
+export function isPomReuseEnabled() {
+    return process.env.SKYRAMP_FEATURE_POM_REUSE === "1";
+}

package/build/utils/frontendIntegration.js

@@ -26,7 +26,7 @@
 import { execFileSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
-import { isTestFile } from "../prompts/test-recommendation/scopeAssessment.js";
+import { isTestFile, isI18nLocaleFile } from "../prompts/test-recommendation/scopeAssessment.js";
 import { logger } from "./logger.js";
 import { walkDir } from "./fileWalk.js";
 import { buildPathSignatures } from "./pathSignatures.js";
@@ -166,6 +166,13 @@ function checkOneFile(repositoryPath, file) {
     if (isRouteOrEntrypoint(file)) {
         return { file, integrated: true, importers: [], reason: IntegrationReason.RouteOrEntrypoint };
     }
+    // i18n/locale content is commonly loaded via a runtime-templated path (e.g.
+    // i18next-http-backend's `loadPath: '/locales/{{lng}}/{{ns}}.json'`) rather
+    // than a static quoted import — the signature grep below would never find
+    // that reference and would misreport a real, live locale file as dead code.
+    if (isI18nLocaleFile(file)) {
+        return { file, integrated: true, importers: [], reason: IntegrationReason.I18nLocaleContent };
+    }
     // A missing changed file (e.g. deleted, or an unexpected diff shape) means
     // the classification can't be trusted — fail open rather than risk wrongly
     // suppressing UI test generation.

package/build/utils/grpcMockValidation.d.ts

@@ -0,0 +1 @@
+export declare function getGrpcMockResponseValidationError(responseData?: string): string | null;

package/build/utils/grpcMockValidation.js

@@ -0,0 +1,49 @@
+const GRPC_STATUS_ERROR_NAMES = new Set([
+    "CANCELLED",
+    "UNKNOWN",
+    "INVALID_ARGUMENT",
+    "DEADLINE_EXCEEDED",
+    "NOT_FOUND",
+    "ALREADY_EXISTS",
+    "PERMISSION_DENIED",
+    "RESOURCE_EXHAUSTED",
+    "FAILED_PRECONDITION",
+    "ABORTED",
+    "OUT_OF_RANGE",
+    "UNIMPLEMENTED",
+    "INTERNAL",
+    "UNAVAILABLE",
+    "DATA_LOSS",
+    "UNAUTHENTICATED",
+]);
+export function getGrpcMockResponseValidationError(responseData) {
+    if (!responseData || responseData.trim().startsWith("@"))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(responseData);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    const candidate = record.error;
+    if (typeof candidate !== "string")
+        return null;
+    const normalized = normalizeGrpcStatusName(candidate);
+    if (!GRPC_STATUS_ERROR_NAMES.has(normalized))
+        return null;
+    return `gRPC mock responseData cannot simulate gRPC status errors such as "${normalized}". Use grpcStatusCode/grpcStatusMessage for gRPC status errors, generate a successful protobuf-shaped response, use a real failing service, or record this scenario as blocked`;
+}
+function normalizeGrpcStatusName(value) {
+    return value
+        .replace(/^GRPC::Status(?:::|\.)?/i, "")
+        .replace(/^GRPC::/i, "")
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[\s.:-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toUpperCase();
+}

package/build/utils/httpMethodValidation.d.ts

@@ -0,0 +1,4 @@
+import { HttpMethod } from "../types/TestTypes.js";
+export declare const REST_MOCK_HTTP_METHODS: HttpMethod[];
+export declare function normalizeRestMockMethod(method?: string): string;
+export declare function getRestMockMethodValidationError(method?: string): string | null;

package/build/utils/httpMethodValidation.js

@@ -0,0 +1,15 @@
+import { HttpMethod } from "../types/TestTypes.js";
+export const REST_MOCK_HTTP_METHODS = Object.values(HttpMethod);
+export function normalizeRestMockMethod(method) {
+    return method ? method.trim().toUpperCase() : "";
+}
+export function getRestMockMethodValidationError(method) {
+    if (!method)
+        return null;
+    const normalized = normalizeRestMockMethod(method);
+    if (!normalized)
+        return null; // whitespace-only → treated as empty (valid)
+    if (REST_MOCK_HTTP_METHODS.includes(normalized))
+        return null;
+    return `REST mock method must be one of ${REST_MOCK_HTTP_METHODS.join(", ")} or empty string (got "${method}")`;
+}

package/build/utils/logger.js

@@ -22,7 +22,7 @@ export class McpLogger {
         try {
             console.error(JSON.stringify(logEntry));
         }
-        catch (error) {
+        catch (_error) {
             // silently ignore
         }
     }

package/build/utils/mockCompatibility.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Mock Compatibility Pre-flight Check
+ *
+ * Validates mock protocol combinations BEFORE deployment to surface
+ * known incompatibilities early rather than at test execution time.
+ */
+import { MockProtocol } from "../types/TestTypes.js";
+export { MockProtocol };
+/** Narrow view of a mock spec used only for protocol compatibility checking. */
+export interface MockCompatibilitySpec {
+    protocol: MockProtocol;
+    endpointURL: string;
+    method?: string;
+    grpcServiceName?: string;
+    kafkaTopic?: string;
+}
+export interface CompatibilityWarning {
+    code: string;
+    message: string;
+    suggestion: string;
+    affectedMocks: string[];
+    /** When true, the affected mocks cannot intercept traffic and must not be generated or deployed. */
+    blocking?: boolean;
+}
+export interface CompatibilityResult {
+    compatible: boolean;
+    /** True when at least one warning is blocking — those mocks must be skipped entirely. */
+    hasBlockers: boolean;
+    warnings: CompatibilityWarning[];
+}
+export interface MockCompatibilityOptions {
+    /** Enable Docker local-dev checks that require mocks to intercept service DNS aliases. */
+    dockerLocalDev?: boolean;
+}
+/**
+ * Validates a set of mock specs for known protocol compatibility issues.
+ *
+ * Rules:
+ * - Any gRPC mock present → GRPC_PERSISTENT_CONN warning (DNS hijacking skips persistent conns)
+ * - Docker local-dev REST mock using loopback/host.docker.internal → REST_LOOPBACK_URL blocking warning
+ *
+ * REST mocks work correctly in Docker local-dev mode only when the mock URL uses
+ * the real Docker service hostname (e.g. "billing" from "http://billing:5001").
+ * The worker adds that hostname as a Docker network alias so DNS resolves to the mock server.
+ *
+ * `compatible` is false when any warning is blocking and the mock cannot intercept traffic.
+ * `hasBlockers` is true when at least one warning is blocking (mock must not be generated/deployed).
+ */
+export declare function validateMockCompatibility(mocks: MockCompatibilitySpec[], options?: MockCompatibilityOptions): CompatibilityResult;

package/build/utils/mockCompatibility.js

@@ -0,0 +1,82 @@
+/**
+ * Mock Compatibility Pre-flight Check
+ *
+ * Validates mock protocol combinations BEFORE deployment to surface
+ * known incompatibilities early rather than at test execution time.
+ */
+import { MockProtocol } from "../types/TestTypes.js";
+export { MockProtocol };
+function parseRestHostname(endpointURL) {
+    try {
+        const hostname = new URL(endpointURL).hostname.toLowerCase();
+        return hostname.startsWith("[") && hostname.endsWith("]")
+            ? hostname.slice(1, -1)
+            : hostname;
+    }
+    catch {
+        return null;
+    }
+}
+function isLoopbackRestEndpoint(endpointURL) {
+    const hostname = parseRestHostname(endpointURL);
+    return (hostname === "localhost" ||
+        hostname === "127.0.0.1" ||
+        hostname === "0.0.0.0" ||
+        hostname === "::1" ||
+        hostname === "host.docker.internal");
+}
+/**
+ * Validates a set of mock specs for known protocol compatibility issues.
+ *
+ * Rules:
+ * - Any gRPC mock present → GRPC_PERSISTENT_CONN warning (DNS hijacking skips persistent conns)
+ * - Docker local-dev REST mock using loopback/host.docker.internal → REST_LOOPBACK_URL blocking warning
+ *
+ * REST mocks work correctly in Docker local-dev mode only when the mock URL uses
+ * the real Docker service hostname (e.g. "billing" from "http://billing:5001").
+ * The worker adds that hostname as a Docker network alias so DNS resolves to the mock server.
+ *
+ * `compatible` is false when any warning is blocking and the mock cannot intercept traffic.
+ * `hasBlockers` is true when at least one warning is blocking (mock must not be generated/deployed).
+ */
+export function validateMockCompatibility(mocks, options = {}) {
+    const warnings = [];
+    const restMocks = mocks.filter((m) => m.protocol === MockProtocol.Rest);
+    const grpcMocks = mocks.filter((m) => m.protocol === MockProtocol.Grpc);
+    const loopbackRestMocks = options.dockerLocalDev
+        ? restMocks.filter((m) => isLoopbackRestEndpoint(m.endpointURL))
+        : [];
+    if (loopbackRestMocks.length > 0) {
+        warnings.push({
+            code: "REST_LOOPBACK_URL",
+            message: "REST mocks for Docker local-dev must use the original Docker service hostname. " +
+                "Loopback hosts such as localhost, 127.0.0.1, 0.0.0.0, ::1, or host.docker.internal " +
+                "do not give the Skyramp worker the downstream service DNS alias it needs to intercept traffic.",
+            suggestion: "Use the real Docker service origin in endpointURL, for example http://ams:4000 or " +
+                "http://billing:5001. Do not use localhost, host.docker.internal, or the Skyramp worker address " +
+                "for deployable REST mocks.",
+            affectedMocks: loopbackRestMocks.map((m) => m.endpointURL),
+            blocking: true,
+        });
+    }
+    // Rule: gRPC mocks use DNS hijacking that doesn't intercept persistent connections
+    if (grpcMocks.length > 0) {
+        warnings.push({
+            code: "GRPC_PERSISTENT_CONN",
+            message: "gRPC mocks use DNS hijacking which does not intercept persistent connections. " +
+                "If the service under test establishes a gRPC connection before mocks are applied, " +
+                "the existing connection will bypass the mock.",
+            suggestion: "Apply gRPC mocks before the service under test starts, or restart " +
+                "the service after applying mocks so it establishes a new connection through the mock DNS. " +
+                "For Docker local-dev, also verify the worker has the original downstream hostname alias " +
+                "from endpointURL (for example, partner-accounts for partner-accounts:50051).",
+            affectedMocks: grpcMocks.map((m) => m.grpcServiceName || m.endpointURL),
+        });
+    }
+    const hasBlockers = warnings.some((w) => w.blocking);
+    return {
+        compatible: !hasBlockers,
+        hasBlockers,
+        warnings,
+    };
+}

package/build/utils/pom-scope/pom-files.js

@@ -8,6 +8,13 @@ const POM_GLOBS = [
     "**/*.page.{ts,js}",
     "**/*Page.{ts,js}",
     "**/pom/**/*.{ts,js}",
+    // Selector-owning helper libraries — the free-function convention (e.g. cal.com's
+    // playwright/lib/testUtils.ts exporting bookFirstEvent(page)). Bounded to helper
+    // modules inside test trees plus the explicit testUtils basename family: candidates
+    // are tiered by selector overlap downstream, so a non-owning match costs a scan,
+    // never a false substitution target.
+    "**/{test,tests,e2e,playwright}/**/{lib,utils,helpers,support}/**/*.{ts,js}",
+    "**/{testUtils,test-utils,testHelpers,test-helpers}.{ts,js}",
 ];
 const EXCLUDED_BASENAME = /\.(spec|test|cy)\.(ts|js|tsx|jsx|mjs|cjs)$/;
 const ALL_SOURCE_GLOBS = ["**/*.{ts,js,tsx,jsx,mjs,cjs}"];

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

@@ -33,7 +33,17 @@ function resolveAgainstPomSet(fromDir, ref, pomSet, aliasMap) {
     else {
         return undefined;
     }
-    for (const cand of [base, `${base}.ts`, `${base}.js`, base.replace(/\.js$/, ".ts")]) {
+    // Directory imports are how barrels are consumed (`from '../helpers/pages/admin'` where the
+    // on-disk target is `admin/index.ts`) — without the index candidates, barrel-bound page objects
+    // never bind at all and every call through them degrades to unverifiable.
+    for (const cand of [
+        base,
+        `${base}.ts`,
+        `${base}.js`,
+        base.replace(/\.js$/, ".ts"),
+        path.join(base, "index.ts"),
+        path.join(base, "index.js"),
+    ]) {
         if (pomSet.has(cand))
             return cand;
     }

package/build/utils/pom-verify/re-exports.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Transitive closure of a file's relative import/re-export refs within the POM set, in BFS
+ * order starting from `start` itself. This is the VERIFY-side expansion: a member reached
+ * through a barrel-of-barrels (`admin/index.ts` → `export * from './members'` →
+ * `members/index.ts` → `members-list-page.ts`) must be searchable from the binding's file, or
+ * every such member false-negatives with no way to remap. Distinct from pom-scope's
+ * `expandImports`, which stays one-hop by design for scoping (expansion inherits the referrer's
+ * score; a transitive walk would over-credit distant files).
+ */
+export declare function expandReExportsTransitive(start: string, pomFiles: string[]): Promise<string[]>;

package/build/utils/pom-verify/re-exports.js

@@ -0,0 +1,61 @@
+import { readFile } from "fs/promises";
+import * as path from "path";
+const REF_RE = /(?:from\s+["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\))/g;
+/** Real-world barrel chains run 2-3 deep (Ghost: admin/index → members/index → members-list-page);
+ * the cap only exists to bound a pathological re-export cycle that the visited-set already breaks. */
+const MAX_DEPTH = 6;
+/** Resolves a relative `ref` from `fromFile` to a member of `pomSet`, trying the bare path,
+ * .ts/.js extensions, and directory index files — barrels are routinely imported as
+ * `from './members'` where the target on disk is `members/index.ts`. */
+function resolveRef(fromFile, ref, pomSet) {
+    const base = path.resolve(path.dirname(fromFile), ref);
+    const candidates = [
+        base,
+        `${base}.ts`,
+        `${base}.js`,
+        base.replace(/\.js$/, ".ts"),
+        path.join(base, "index.ts"),
+        path.join(base, "index.js"),
+    ];
+    return candidates.find((c) => pomSet.has(c));
+}
+/**
+ * Transitive closure of a file's relative import/re-export refs within the POM set, in BFS
+ * order starting from `start` itself. This is the VERIFY-side expansion: a member reached
+ * through a barrel-of-barrels (`admin/index.ts` → `export * from './members'` →
+ * `members/index.ts` → `members-list-page.ts`) must be searchable from the binding's file, or
+ * every such member false-negatives with no way to remap. Distinct from pom-scope's
+ * `expandImports`, which stays one-hop by design for scoping (expansion inherits the referrer's
+ * score; a transitive walk would over-credit distant files).
+ */
+export async function expandReExportsTransitive(start, pomFiles) {
+    const pomSet = new Set(pomFiles);
+    const visited = new Set([start]);
+    const out = [start];
+    let frontier = [start];
+    for (let depth = 0; depth < MAX_DEPTH && frontier.length > 0; depth++) {
+        const next = [];
+        for (const file of frontier) {
+            let content;
+            try {
+                content = await readFile(file, "utf8");
+            }
+            catch {
+                continue;
+            }
+            for (const m of content.matchAll(REF_RE)) {
+                const ref = m[1] ?? m[2];
+                if (!ref || !ref.startsWith("."))
+                    continue;
+                const resolved = resolveRef(file, ref, pomSet);
+                if (resolved && !visited.has(resolved)) {
+                    visited.add(resolved);
+                    out.push(resolved);
+                    next.push(resolved);
+                }
+            }
+        }
+        frontier = next;
+    }
+    return out;
+}

package/build/utils/pom-verify/resolve.d.ts

@@ -1,7 +1,10 @@
 import { type PomBinding } from "./bindings.js";
 /** Checks `member` against member-DEFINITION shapes (not a bare `\bmember\b` token match, which
  * would also "find" a local variable or parameter that merely shares the member's name) in the
- * binding's class/source file and its one-hop relative imports that are themselves POM files. */
+ * binding's class/source file and the TRANSITIVE closure of its relative imports/re-exports that
+ * are themselves POM files. Transitivity matters: repos routinely bind through a barrel-of-barrels
+ * (Ghost's `admin/index.ts` → `./members` → `members-list-page.ts`), and stopping at one hop
+ * false-negatives every member of every class behind the second barrel. */
 export declare function resolveMemberSource(binding: PomBinding, member: string, pomFiles: string[]): Promise<{
     found: boolean;
     searched: string[];

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

@@ -1,8 +1,8 @@
 import { readFile } from "fs/promises";
-import { expandImports } from "../pom-scope/import-expansion.js";
 import { stripCommentsAndStrings } from "../pom-scope/strip.js";
 import { escapeRegExp } from "../regex.js";
 import { primaryFile } from "./bindings.js";
+import { expandReExportsTransitive } from "./re-exports.js";
 // A definition site is either the very start of the file or just past a statement/block
 // delimiter -- this catches indented multi-line source AND single-line/minified class bodies
 // (`export class Foo { ctor(){...} bar(){...} }`) where a real method never lands at column 0.
@@ -26,12 +26,15 @@ function memberDefinitionRegexes(member) {
 }
 /** Checks `member` against member-DEFINITION shapes (not a bare `\bmember\b` token match, which
  * would also "find" a local variable or parameter that merely shares the member's name) in the
- * binding's class/source file and its one-hop relative imports that are themselves POM files. */
+ * binding's class/source file and the TRANSITIVE closure of its relative imports/re-exports that
+ * are themselves POM files. Transitivity matters: repos routinely bind through a barrel-of-barrels
+ * (Ghost's `admin/index.ts` → `./members` → `members-list-page.ts`), and stopping at one hop
+ * false-negatives every member of every class behind the second barrel. */
 export async function resolveMemberSource(binding, member, pomFiles) {
-    const candidates = await expandImports([primaryFile(binding)], pomFiles);
+    const candidates = await expandReExportsTransitive(primaryFile(binding), pomFiles);
     const memberRes = memberDefinitionRegexes(member);
     const searched = [];
-    for (const { file } of candidates) {
+    for (const file of candidates) {
         searched.push(file);
         let content;
         try {

package/build/utils/pom-verify/verify.d.ts

@@ -10,5 +10,10 @@ export type VerifyResult = {
     unverifiable: string[];
     parseError?: string;
     checkedCalls: number;
+    /** Every POM call found in the spec, verifiable or not. NOT checkedCalls +
+     *  unverifiable.length: `unverifiable` also absorbs `unrecognized` bindings,
+     *  which are not calls at all, so that sum overcounts. This is the count of
+     *  POM members the delivered spec actually reuses. */
+    reusedCalls: number;
 };
 export declare function verifyReuse(testFile: string, language: string): Promise<VerifyResult>;

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

@@ -4,7 +4,7 @@ import * as path from "path";
 import { promisify } from "util";
 import { findRoot } from "../pom-scope/index.js";
 import { globPomFiles, globAllSourceFiles } from "../pom-scope/pom-files.js";
-import { extractPomBindings, primaryFile } from "./bindings.js";
+import { extractPomBindings } from "./bindings.js";
 import { extractPomCalls } from "./calls.js";
 import { resolveMemberSource } from "./resolve.js";
 import { stripComments, stripCommentsAndStrings } from "../pom-scope/strip.js";
@@ -34,7 +34,14 @@ async function listMembers(file) {
         return [];
     }
     const members = new Set();
-    for (const re of [/^\s*(?:async\s+)?(\w+)\s*\(/gm, /this\.(\w+)\s*=/g, /get\s+(\w+)\s*\(/g]) {
+    for (const re of [
+        /^\s*(?:async\s+)?(\w+)\s*\(/gm,
+        /this\.(\w+)\s*=/g,
+        /get\s+(\w+)\s*\(/g,
+        // free-function helper modules: declarations and exported const arrows are members too
+        /\bfunction\s+(\w+)\s*\(/g,
+        /\bexport\s+const\s+(\w+)\s*=/g,
+    ]) {
         for (const m of content.matchAll(re)) {
             const name = m[1];
             if (name === "constructor" || NON_MEMBER_KEYWORDS.has(name))
@@ -139,7 +146,21 @@ export async function verifyReuse(testFile, language) {
         const member = call.chain[0] ?? binding.name;
         const { found, searched } = await resolveMemberSource(binding, member, pomFiles);
         if (!found) {
-            violations.push({ binding: call.binding, member, searched, availableMembers: await listMembers(primaryFile(binding)) });
+            // Candidates come from the whole searched closure, not just the binding's file: a
+            // binding through a barrel has a member-less primary file, and the members the agent
+            // could remap to live in the leaf classes the barrel re-exports.
+            const availableMembers = [...new Set((await Promise.all(searched.map(listMembers))).flat())];
+            if (availableMembers.length === 0) {
+                // "Not found, and I can enumerate nothing to remap to" is evidence about the
+                // VERIFIER's reach, not the member's existence. Emitting a violation here starts a
+                // remap/demote loop the agent cannot win (no candidates to remap to → forced demote
+                // of possibly-correct reuse). Degrade to unverifiable — the fail-open contract at
+                // the reachability level, matching resolve.ts's permissive stance on shapes.
+                unverifiable.push([call.binding, ...call.chain].join("."));
+                checkedCalls--;
+                continue;
+            }
+            violations.push({ binding: call.binding, member, searched, availableMembers });
         }
     }
     for (const u of unrecognized)
@@ -161,5 +182,6 @@ export async function verifyReuse(testFile, language) {
         unverifiable,
         parseError,
         checkedCalls,
+        reusedCalls: calls.length,
     };
 }

package/build/utils/progress.js

@@ -10,11 +10,16 @@ export function makeProgressReporter(extra) {
     return async (progress, total, message) => {
         const progressToken = extra._meta?.progressToken;
         if (progressToken !== undefined) {
-            const notification = {
-                method: "notifications/progress",
-                params: { progressToken, progress, total, message },
-            };
-            await extra.sendNotification(notification);
+            try {
+                const notification = {
+                    method: "notifications/progress",
+                    params: { progressToken, progress, total, message },
+                };
+                await extra.sendNotification(notification);
+            }
+            catch {
+                // Progress is best-effort; a disconnected client should not fail the tool.
+            }
         }
     };
 }

package/build/utils/proxy-terminal.js

@@ -334,7 +334,7 @@ export async function closeProxyTerminal() {
                             terminalPID,
                         });
                     }
-                    catch (killErr) {
+                    catch (_killErr) {
                         // Process is already dead, which is what we want
                         logger.debug("Terminal process already terminated", {
                             terminalPID,
@@ -384,14 +384,14 @@ export async function closeProxyTerminal() {
                             terminalPID,
                         });
                     }
-                    catch (killErr) {
+                    catch (_killErr) {
                         // Process is already dead, which is what we want
                         logger.debug("Terminal process already terminated", {
                             terminalPID,
                         });
                     }
                 }
-                catch (pidErr) {
+                catch (_pidErr) {
                     // Fallback to regular process kill
                     try {
                         process.kill(terminalPID, "SIGTERM");

package/build/utils/routeParsers.d.ts

@@ -59,15 +59,9 @@ export declare function isRouteLikeFile(filePath: string): boolean;
  * route that existed in the base branch.
  */
 export declare function selectRemovalCandidateFiles(diffData: BranchDiffData): string[];
-/**
- * Recover endpoints as they existed in the base branch, for the given candidate
- * files. `fetchBaseContent` returns a file's base-branch content (e.g. via
- * `git show base:<file>`); files that throw are skipped. Returns every endpoint
- * found in the base versions — callers pass the result to
- * `classifyEndpointsByChangedFiles`, whose moved/still-present filter drops any
- * endpoint that survives in the current catalog, leaving only genuine removals.
- */
-export declare function recoverRemovedEndpointsFromBase(candidateFiles: string[], fetchBaseContent: (file: string) => Promise<string>): Promise<ScannedEndpoint[]>;
+export declare function recoverRemovedEndpointsFromBase(candidateFiles: string[], fetchBaseContent: (file: string) => Promise<string>, repositoryPath?: string, baseBranch?: string): Promise<ScannedEndpoint[]>;
+/** Strip git's `a/` / `b/` diff-path prefix and normalize separators. */
+export declare function normalizeDiffPath(spec: string): string;
 /**
  * Parse a unified diff into the set of new-side (post-change) line numbers that
  * were touched, keyed by normalized file path.