@mknrt/autotests-overkill 1.1.3 → 1.1.5

package/README.md

@@ -1,6 +1,6 @@
 # Autotests Overkill
 
-`Autotests Overkill` is a standalone AI-assisted testing platform for `autotests2`, `caseplatform-web`, and CI artifacts. It is designed for Codex-style work: inspect existing coverage, extract frontend contracts and runtime logic, generate draft specs, triage failures, and narrow rerun scope without silently mutating consumer repositories.
+`Autotests Overkill` is a standalone AI-assisted testing platform for `autotests2`, `caseplatform-web`, optional `fis_platform` backend context, and CI artifacts. It is designed for Codex-style work: inspect existing coverage, extract frontend/backend contracts and runtime logic, generate draft specs, triage failures, and narrow rerun scope without silently mutating consumer repositories.
 
 ## What v1.1 adds
 
@@ -8,6 +8,7 @@
 - Stronger spec blueprints that reuse real `autotests2` setup, commands, helpers, and selector patterns
 - Acceptance coverage for both modern and legacy widgets
 - Knowledge-store-backed retrieval for asset search, area context, impact analysis, and blueprint support
+- Optional `fis_platform` backend knowledge through an evidence-driven `ApiDiscoveryCatalog`, `api-interaction` documents, and `backend-endpoint` contracts
 - Optional ReportPortal and GitLab adapters with graceful artifacts-first fallback
 - Codex plugin packaging via `.codex-plugin/plugin.json` and `.mcp.json`
 
@@ -28,14 +29,14 @@ Published npm package install:
 
 1. Run `npm install -D @mknrt/autotests-overkill`.
 2. Copy `node_modules/@mknrt/autotests-overkill/overkill.config.example.json` to `overkill.config.json`.
-3. Set `repos.autotests2`, `repos.caseplatformWeb`, and `ci.artifactsRoot`.
+3. Set `repos.autotests2`, `repos.caseplatformWeb`, optional `repos.fisPlatform`, and `ci.artifactsRoot`.
 4. Run `npx autotests-overkill index`.
 
 Repository-local development:
 
 1. Run `npm install`.
 2. Copy `overkill.config.example.json` to `overkill.config.json`.
-3. Set `repos.autotests2`, `repos.caseplatformWeb`, and `ci.artifactsRoot`.
+3. Set `repos.autotests2`, `repos.caseplatformWeb`, optional `repos.fisPlatform`, and `ci.artifactsRoot`.
 4. Run `npm run build`.
 5. Run `npm run index`.
 
@@ -44,8 +45,9 @@ Repository-local development:
 1. Refresh local knowledge with `npm run index`.
 2. Start the MCP server through the checked-in MCP manifest or by running `npx autotests-overkill mcp`.
 3. Use `find_frontend_contract`, `find_existing_test_assets`, and `generate_spec_blueprint` for a new feature draft.
-4. Use `summarize_ci_context`, `triage_failed_run`, and `analyze_diff_impact` for failure or change triage.
-5. Review generated output manually before editing `autotests2`.
+4. Use `find_backend_test_context` when a request flow needs backend validation, params, async completion, or contract-drift evidence.
+5. Use `summarize_ci_context`, `triage_failed_run`, and `analyze_diff_impact` for failure or change triage.
+6. Review generated output manually before editing `autotests2`.
 
 CLI commands:
 
@@ -70,6 +72,7 @@ The platform reads `overkill.config.json` with these keys:
 
 - `repos.autotests2`
 - `repos.caseplatformWeb`
+- `repos.fisPlatform` optional path to `../fis_platform`
 - `ci.artifactsRoot`
 - `ci.reportPortal.endpoint`
 - `ci.reportPortal.project`
@@ -81,9 +84,18 @@ The platform reads `overkill.config.json` with these keys:
 
 The default path is local and artifacts-first. Missing ReportPortal or GitLab credentials do not break tools; the platform keeps using local stats, screenshots, videos, and captured API payloads.
 
+## Backend integration
+
+Backend indexing is discovery-first and evidence-driven, not hardcoded. The first bridge is an `ApiDiscoveryCatalog` built from `autotests2` support code such as request wrappers, endpoint constants, `cy.request`, `fetch`, `XMLHttpRequest`, and API capture helpers. Selected high-signal families become `api-interaction` documents with `normalizedPaths`, `consumerSignalIds`, `evidencePaths`, `confidence`, and `whySelected`.
+
+When `repos.fisPlatform` points to `../fis_platform`, refresh passes that catalog explicitly into backend discovery. `fis_platform` sources are selected by REST/JAX-RS signals such as `@Path`, `@GET`, `@POST`, `@PUT`, `@DELETE`, `@QueryParam`, `@HeaderParam`, `@Consumes`, and `@Produces`; noisy directories such as `thirdparty`, `extjs`, `oryx`, `generated`, `node_modules`, and `vendor` are excluded by rule. Matching sources become `backend-endpoint` documents with endpoint paths, params, rule hints, evidence paths, confidence, and `whyMatched`.
+
+Only high-confidence links (`confidence >= 0.7`) drive blueprint, triage, and impact recommendations. Lower-confidence backend matches may be surfaced as exploratory evidence, but they are not treated as recommendations. Runtime API captures are read on demand by `triage_failed_run` in iteration 1 and are not persisted as raw knowledge-store documents.
+
 ## MCP tools
 
 - `find_existing_test_assets`
+- `find_backend_test_context`
 - `find_test_area_context`
 - `find_frontend_contract`
 - `find_frontend_runtime_logic`

package/dist/src/appContext.d.ts

@@ -1,6 +1,7 @@
 import { Autotests2Connector } from './connectors/autotests2Connector.js';
 import { CaseplatformConnector } from './connectors/caseplatformConnector.js';
 import { CiArtifactsConnector } from './connectors/ciArtifactsConnector.js';
+import { FisPlatformConnector } from './connectors/fisPlatformConnector.js';
 import { GitLabConnector } from './connectors/gitlabConnector.js';
 import { ReportPortalConnector } from './connectors/reportPortalConnector.js';
 import { type ConsumerConfig, type ConsumerConfigInput } from './config/consumerConfig.js';
@@ -10,6 +11,7 @@ export type AppContext = {
     database: ReturnType<typeof createKnowledgeDatabase>;
     autotests2: Autotests2Connector;
     caseplatform: CaseplatformConnector;
+    fisPlatform?: FisPlatformConnector;
     ciArtifacts: CiArtifactsConnector;
     gitlab: GitLabConnector;
     reportPortal: ReportPortalConnector;

package/dist/src/appContext.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { Autotests2Connector } from './connectors/autotests2Connector.js';
 import { CaseplatformConnector } from './connectors/caseplatformConnector.js';
 import { CiArtifactsConnector } from './connectors/ciArtifactsConnector.js';
+import { FisPlatformConnector } from './connectors/fisPlatformConnector.js';
 import { GitLabConnector } from './connectors/gitlabConnector.js';
 import { ReportPortalConnector } from './connectors/reportPortalConnector.js';
 import { createDefaultConsumerConfig, loadConsumerConfig, parseConsumerConfig } from './config/consumerConfig.js';
@@ -19,6 +20,9 @@ export async function createAppContext(input) {
         database,
         autotests2: new Autotests2Connector(config.repos.autotests2),
         caseplatform: new CaseplatformConnector(config.repos.caseplatformWeb),
+        fisPlatform: config.repos.fisPlatform
+            ? new FisPlatformConnector(config.repos.fisPlatform)
+            : undefined,
         ciArtifacts: new CiArtifactsConnector(),
         gitlab: new GitLabConnector(config.ci.gitlab),
         reportPortal: new ReportPortalConnector(config.ci.reportPortal),

package/dist/src/config/consumerConfig.d.ts

@@ -3,12 +3,15 @@ export declare const consumerConfigSchema: z.ZodObject<{
     repos: z.ZodObject<{
         autotests2: z.ZodString;
         caseplatformWeb: z.ZodString;
+        fisPlatform: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         autotests2: string;
         caseplatformWeb: string;
+        fisPlatform?: string | undefined;
     }, {
         autotests2: string;
         caseplatformWeb: string;
+        fisPlatform?: string | undefined;
     }>;
     ci: z.ZodObject<{
         artifactsRoot: z.ZodString;
@@ -75,6 +78,7 @@ export declare const consumerConfigSchema: z.ZodObject<{
     repos: {
         autotests2: string;
         caseplatformWeb: string;
+        fisPlatform?: string | undefined;
     };
     ci: {
         artifactsRoot: string;
@@ -97,6 +101,7 @@ export declare const consumerConfigSchema: z.ZodObject<{
     repos: {
         autotests2: string;
         caseplatformWeb: string;
+        fisPlatform?: string | undefined;
     };
     ci: {
         artifactsRoot: string;

package/dist/src/config/consumerConfig.js

@@ -15,6 +15,7 @@ export const consumerConfigSchema = z.object({
     repos: z.object({
         autotests2: z.string().min(1),
         caseplatformWeb: z.string().min(1),
+        fisPlatform: z.string().min(1).optional(),
     }).strict(),
     ci: z.object({
         artifactsRoot: z.string().min(1),
@@ -36,6 +37,9 @@ export function parseConsumerConfig(input, baseDir = process.cwd()) {
         repos: {
             autotests2: resolveRepoPath(parsed.repos.autotests2, baseDir),
             caseplatformWeb: resolveRepoPath(parsed.repos.caseplatformWeb, baseDir),
+            fisPlatform: parsed.repos.fisPlatform
+                ? resolveRepoPath(parsed.repos.fisPlatform, baseDir)
+                : undefined,
         },
         ci: {
             artifactsRoot: resolveRepoPath(parsed.ci.artifactsRoot, baseDir),
@@ -54,6 +58,7 @@ export function createDefaultConsumerConfig(baseDir = process.cwd()) {
         repos: {
             autotests2: '../autotests2',
             caseplatformWeb: '../caseplatform-web',
+            fisPlatform: '../fis_platform',
         },
         ci: {
             artifactsRoot: '../autotests2/cypress',

package/dist/src/connectors/autotests2Connector.d.ts

@@ -14,12 +14,20 @@ export type HelperMatch = {
     name: string;
     body: string;
 };
+export type ApiSupportSource = {
+    path: string;
+    body: string;
+};
 export declare class Autotests2Connector {
     private readonly root;
     private readonly fs;
     constructor(root: string);
     findSpecs(featureHint?: string): Promise<TestSpecMatch[]>;
     findCommands(): Promise<CommandMatch[]>;
+    findApiSupportSources(): Promise<{
+        path: string;
+        body: string;
+    }[]>;
     findHelpers(featureHint?: string): Promise<HelperMatch[]>;
     getAreaDocs(): {
         contextPath: string;

package/dist/src/connectors/autotests2Connector.js

@@ -40,6 +40,13 @@ export class Autotests2Connector {
         }
         return dedupeByName(results);
     }
+    async findApiSupportSources() {
+        const files = await this.fs.glob(this.root, ['cypress/support/**/*.js']);
+        const apiSignalPattern = /cy\.request|Cypress\.Commands\.add|fetch\(|XMLHttpRequest|apiCapture|request|\/platform\/|\/rs2\//i;
+        return files
+            .map((filePath) => ({ path: filePath, body: this.fs.read(filePath) }))
+            .filter((source) => apiSignalPattern.test(source.body));
+    }
     async findHelpers(featureHint) {
         const files = await this.fs.glob(this.root, ['cypress/support/functions/**/*.js']);
         const results = [];

package/dist/src/connectors/fisPlatformConnector.d.ts

@@ -0,0 +1,15 @@
+import type { ApiDiscoveryCatalog } from '../indexer/extractors/apiDiscoveryExtractor.js';
+export type FocusedFisSource = {
+    path: string;
+    body: string;
+    sourceKind: 'backend-resource' | 'backend-interface' | 'backend-openapi-config';
+    matchedFamily: string;
+    confidence: number;
+    whyMatched: string[];
+};
+export declare class FisPlatformConnector {
+    readonly root: string;
+    private readonly fs;
+    constructor(root: string);
+    listFocusedSources(apiCatalog: ApiDiscoveryCatalog): Promise<FocusedFisSource[]>;
+}

package/dist/src/connectors/fisPlatformConnector.js

@@ -0,0 +1,112 @@
+import { FilesystemConnector } from './filesystemConnector.js';
+const REST_SIGNAL_PATTERN = /@Path|@(GET|POST|PUT|DELETE)|@QueryParam|@HeaderParam|@Consumes|@Produces/;
+const NOISE_PATH_PATTERN = /(?:^|[\\/])(thirdparty|extjs|oryx|generated|node_modules|vendor)(?:[\\/]|$)/i;
+export class FisPlatformConnector {
+    root;
+    fs = new FilesystemConnector();
+    constructor(root) {
+        this.root = root;
+    }
+    async listFocusedSources(apiCatalog) {
+        const files = await this.fs.glob(this.root, [
+            '**/*.java',
+            '**/*openapi*.yaml',
+            '**/*openapi*.yml',
+            '**/*openapi*.json',
+        ]);
+        const results = [];
+        const selectedFamilies = apiCatalog.families.filter((family) => family.score > 0);
+        for (const filePath of files) {
+            if (NOISE_PATH_PATTERN.test(filePath)) {
+                continue;
+            }
+            const body = this.fs.read(filePath);
+            if (!REST_SIGNAL_PATTERN.test(body) && !/openapi|swagger/i.test(filePath)) {
+                continue;
+            }
+            for (const family of selectedFamilies) {
+                const match = matchBackendSourceToFamily({ path: filePath, body }, family);
+                if (match.confidence >= 0.4) {
+                    results.push({
+                        path: filePath,
+                        body,
+                        sourceKind: inferSourceKind(filePath, body),
+                        matchedFamily: family.family,
+                        confidence: match.confidence,
+                        whyMatched: match.whyMatched,
+                    });
+                }
+            }
+        }
+        return results.sort((left, right) => {
+            if (right.confidence !== left.confidence) {
+                return right.confidence - left.confidence;
+            }
+            return left.path.localeCompare(right.path);
+        });
+    }
+}
+function matchBackendSourceToFamily(source, family) {
+    const backendPaths = extractBackendPaths(source.body);
+    const bodyTokens = normalizeTokens(`${source.path}\n${source.body}`);
+    const familyToken = family.family.toLowerCase();
+    const whyMatched = [];
+    let score = 0;
+    if (bodyTokens.includes(familyToken)) {
+        score += 0.25;
+        whyMatched.push(`resource text contains selected API family '${family.family}'`);
+    }
+    for (const consumerPath of family.normalizedPaths) {
+        const consumerTokens = normalizeTokens(consumerPath);
+        if (backendPaths.some((backendPath) => pathsOverlap(backendPath, consumerPath))) {
+            score += 0.55;
+            whyMatched.push(`backend @Path overlaps consumer path ${consumerPath}`);
+        }
+        else if (consumerTokens.some((token) => bodyTokens.includes(token))) {
+            score += 0.3;
+            whyMatched.push(`backend source shares path token(s) with ${consumerPath}`);
+        }
+    }
+    if (/@(GET|POST|PUT|DELETE)/.test(source.body)) {
+        score += 0.15;
+        whyMatched.push('backend source declares HTTP method annotation');
+    }
+    if (/@QueryParam|@HeaderParam/.test(source.body)) {
+        score += 0.05;
+        whyMatched.push('backend source declares request parameter annotations');
+    }
+    return {
+        confidence: Math.min(1, score),
+        whyMatched,
+    };
+}
+function inferSourceKind(path, body) {
+    if (/openapi|swagger/i.test(path)) {
+        return 'backend-openapi-config';
+    }
+    if (/interface\s+\w+/.test(body)) {
+        return 'backend-interface';
+    }
+    return 'backend-resource';
+}
+function extractBackendPaths(body) {
+    return [...body.matchAll(/@Path\(\s*"([^"]+)"\s*\)/g)]
+        .map((match) => match[1])
+        .filter((value) => Boolean(value))
+        .map((value) => normalizePath(value));
+}
+function normalizePath(value) {
+    return value.startsWith('/') ? value : `/${value}`;
+}
+function pathsOverlap(left, right) {
+    const leftTokens = normalizeTokens(left);
+    const rightTokens = normalizeTokens(right);
+    const sharedTokens = leftTokens.filter((token) => rightTokens.includes(token));
+    return sharedTokens.length >= Math.min(2, rightTokens.length);
+}
+function normalizeTokens(value) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length > 1 && !/^(platform|rs2|api|rest|java|src|main)$/.test(token));
+}

package/dist/src/domain/analyzeDiffImpact.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import fs from 'node:fs';
 import { normalizeChangedFiles } from '../connectors/diffConnector.js';
 import { queryDocuments } from '../knowledge/repositories.js';
 import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
@@ -31,6 +32,41 @@ export async function analyzeDiffImpact(input, context) {
             impactedSpecs.add(spec.path);
         }
     }
+    for (const filePath of changedFiles.filter((item) => isFisPlatformPath(item, context))) {
+        const backendFeatureText = deriveFeatureTextFromBackendSource({
+            filePath,
+            fileBody: readTextIfAvailable(filePath),
+        });
+        const interactionHits = queryDocuments(context.database, backendFeatureText, {
+            repoKind: 'autotests2',
+            sourceKinds: ['api-interaction'],
+            limit: 8,
+        }).filter((item) => (parseMetadata(item.metadata_json).confidence ?? 0) >= 0.7);
+        const linkedQuery = interactionHits.flatMap((item) => {
+            const metadata = parseMetadata(item.metadata_json);
+            return [
+                item.title,
+                ...(metadata.consumerSignalIds ?? []),
+                ...(metadata.evidencePaths ?? []),
+                ...(metadata.normalizedPaths ?? []),
+            ];
+        }).join(' ');
+        const linkedSpecs = linkedQuery
+            ? queryDocuments(context.database, linkedQuery, {
+                repoKind: 'autotests2',
+                sourceKinds: ['spec'],
+                limit: 8,
+            })
+            : [];
+        for (const interaction of interactionHits) {
+            evidence.push(evidenceFile('api interaction bridge', interaction.path, undefined, {
+                confidence: parseMetadata(interaction.metadata_json).confidence,
+            }));
+        }
+        for (const spec of linkedSpecs) {
+            impactedSpecs.add(spec.path);
+        }
+    }
     return output(`Diff impact analysis mapped ${changedFiles.length} changed file(s) to ${impactedSpecs.size} affected spec candidate(s).`, [
         ...evidence,
         ...[...impactedSpecs].slice(0, 10).map((filePath) => evidenceFile('impacted spec', filePath)),
@@ -39,6 +75,36 @@ export async function analyzeDiffImpact(input, context) {
         'Inspect widget events and container variants when the diff touches shared widget files.',
     ], impactedSpecs.size === 0 ? ['No impacted specs were found via naming heuristics.'] : []);
 }
+function isFisPlatformPath(filePath, context) {
+    const fisRoot = context.config.repos.fisPlatform;
+    return Boolean(fisRoot) && path.resolve(filePath).startsWith(path.resolve(fisRoot));
+}
+function readTextIfAvailable(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function deriveFeatureTextFromBackendSource(input) {
+    const pathText = deriveFeatureHint(input.filePath) ?? input.filePath;
+    const restSignals = [
+        ...input.fileBody.matchAll(/@Path\(\s*"([^"]+)"\s*\)/g),
+        ...input.fileBody.matchAll(/@(GET|POST|PUT|DELETE)/g),
+        ...input.fileBody.matchAll(/@(?:QueryParam|HeaderParam)\(\s*"([^"]+)"\s*\)/g),
+    ].map((match) => match[1]).filter(Boolean);
+    const className = input.fileBody.match(/\b(?:class|interface)\s+([A-Za-z0-9_]+)/)?.[1];
+    return [pathText, className, ...restSignals, input.fileBody.slice(0, 2000)].filter(Boolean).join(' ');
+}
+function parseMetadata(metadataJson) {
+    try {
+        return JSON.parse(metadataJson);
+    }
+    catch {
+        return {};
+    }
+}
 function deriveFeatureHint(filePath) {
     const base = basenameWithoutExt(filePath);
     if (/caption/i.test(base)) {

package/dist/src/domain/findBackendTestContext.d.ts

@@ -0,0 +1,24 @@
+import type { AppContext } from '../appContext.js';
+type FindBackendTestContextInput = {
+    query: string;
+};
+export declare function findBackendTestContext(input: FindBackendTestContextInput, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;
+export {};

package/dist/src/domain/findBackendTestContext.js

@@ -0,0 +1,165 @@
+import { queryDocuments } from '../knowledge/repositories.js';
+import { ensureIndexed, evidenceFile, output } from './shared.js';
+export async function findBackendTestContext(input, context) {
+    await ensureIndexed(context);
+    const queryTokens = normalizeTokens(input.query);
+    const queryPaths = extractQueryPaths(input.query);
+    const interactionHits = highConfidence(queryDocuments(context.database, input.query, {
+        repoKind: 'autotests2',
+        sourceKinds: ['api-interaction'],
+        limit: 6,
+    }))
+        .filter((item) => isRelevantInteraction(item, queryTokens, queryPaths))
+        .slice(0, 3);
+    const interactionBridgeQuery = interactionHits
+        .flatMap((item) => {
+        const metadata = parseMetadata(item.metadata_json);
+        return [
+            item.title,
+            ...(metadata.normalizedPaths ?? []),
+            ...(metadata.evidencePaths ?? []),
+        ];
+    })
+        .join(' ');
+    const backendHits = highConfidence(queryDocuments(context.database, [input.query, interactionBridgeQuery].join(' '), {
+        repoKind: 'fis-platform',
+        sourceKinds: ['backend-endpoint'],
+        limit: 8,
+    }))
+        .filter((item) => isRelevantBackendEndpoint(item, interactionHits, queryTokens, queryPaths))
+        .slice(0, 6);
+    const evidencePaths = [...interactionHits, ...backendHits]
+        .flatMap((item) => parseMetadata(item.metadata_json).evidencePaths ?? []);
+    const exactLinkedAssets = findDocumentsByPaths(context, evidencePaths);
+    const linkedSpecQuery = [
+        input.query,
+        ...interactionHits.map((item) => item.title),
+        ...interactionHits.flatMap((item) => parseMetadata(item.metadata_json).normalizedPaths ?? []),
+    ].join(' ');
+    const linkedSpecAssets = queryDocuments(context.database, linkedSpecQuery, {
+        repoKind: 'autotests2',
+        sourceKinds: ['spec', 'command', 'helper'],
+        limit: 8,
+    }).filter((item) => isRelevantLinkedAsset(item, queryTokens));
+    const linkedAssets = uniqueDocumentHits([...exactLinkedAssets, ...linkedSpecAssets]).slice(0, 8);
+    const evidence = [
+        ...interactionHits.map((item) => evidenceFile('api interaction', item.path, truncate(item.body, 260), {
+            retrieval: 'knowledge-store',
+            confidence: parseMetadata(item.metadata_json).confidence,
+            whySelected: parseMetadata(item.metadata_json).whySelected,
+        })),
+        ...backendHits.map((item) => evidenceFile('backend endpoint', item.path, truncate(item.body, 260), {
+            retrieval: 'knowledge-store',
+            confidence: parseMetadata(item.metadata_json).confidence,
+            whyMatched: parseMetadata(item.metadata_json).whyMatched,
+        })),
+        ...linkedAssets.map((item) => evidenceFile('linked autotest asset', item.path, truncate(item.body, 200), {
+            retrieval: 'metadata-evidence-link',
+        })),
+    ];
+    const backendParams = backendHits
+        .flatMap((item) => parseMetadata(item.metadata_json).paramNames ?? [])
+        .filter(Boolean);
+    const warnings = evidence.length === 0
+        ? [`No high-confidence backend test context found for '${input.query}'.`]
+        : [];
+    return output(`Found ${interactionHits.length} API interaction record(s), ${backendHits.length} backend context record(s), and ${linkedAssets.length} linked autotests2 asset(s) for '${input.query}'.`, evidence, [
+        'Reuse the indexed API interaction flow before reconstructing request order by hand.',
+        backendParams.length > 0
+            ? `Check required params (${[...new Set(backendParams)].join(', ')}) and backend validation hints before debugging selectors.`
+            : 'Check required params and backend validation hints before debugging selectors.',
+        'Reuse the linked autotests2 request flow instead of rebuilding API assumptions from scratch.',
+    ], warnings);
+}
+function highConfidence(items) {
+    return items.filter((item) => (parseMetadata(item.metadata_json).confidence ?? 0) >= 0.7);
+}
+function findDocumentsByPaths(context, paths) {
+    const uniquePaths = [...new Set(paths)];
+    if (uniquePaths.length === 0) {
+        return [];
+    }
+    const statement = context.database.prepare(`
+    SELECT id, path, title, body, metadata_json, 0 AS rank
+    FROM documents
+    WHERE repo_kind = 'autotests2'
+      AND source_kind IN ('spec', 'command', 'helper')
+      AND path = ?
+  `);
+    return uniquePaths.flatMap((filePath) => statement.all(filePath));
+}
+function uniqueDocumentHits(items) {
+    const seen = new Map();
+    for (const item of items) {
+        seen.set(item.id, item);
+    }
+    return [...seen.values()];
+}
+function isRelevantLinkedAsset(item, queryTokens) {
+    const searchable = normalizeTokens(`${item.title} ${item.path} ${item.body.slice(0, 1200)}`);
+    return queryTokens.some((token) => searchable.includes(token));
+}
+function isRelevantInteraction(item, queryTokens, queryPaths) {
+    const metadata = parseMetadata(item.metadata_json);
+    const normalizedPaths = metadata.normalizedPaths ?? [];
+    if (queryPaths.length > 0) {
+        return normalizedPaths.some((indexedPath) => queryPaths.some((queryPath) => pathsOverlap(indexedPath, queryPath)));
+    }
+    const searchable = normalizeTokens(`${item.title} ${item.path} ${item.body} ${normalizedPaths.join(' ')}`);
+    return queryTokens.some((token) => searchable.includes(token));
+}
+function isRelevantBackendEndpoint(item, interactions, queryTokens, queryPaths) {
+    const metadata = parseMetadata(item.metadata_json);
+    const endpointPath = metadata.endpointPath ?? item.title;
+    const interactionPaths = interactions.flatMap((interaction) => parseMetadata(interaction.metadata_json).normalizedPaths ?? []);
+    const endpointTokens = normalizeTokens(endpointPath);
+    if (queryPaths.length > 0 || interactionPaths.length > 0) {
+        return queryPaths.some((candidate) => pathsOverlap(endpointPath, candidate))
+            || queryTokens.some((token) => endpointTokens.includes(token))
+            || (queryPaths.length === 0 && interactionPaths.some((candidate) => pathsOverlap(endpointPath, candidate)));
+    }
+    const searchable = normalizeTokens(`${item.title} ${item.path} ${item.body} ${endpointPath}`);
+    return queryTokens.some((token) => searchable.includes(token));
+}
+function extractQueryPaths(query) {
+    return [...query.matchAll(/(?:https?:\/\/[^/\s]+)?(\/[A-Za-z0-9_/${}?.=&*-]+)+/g)]
+        .map((match) => match[0])
+        .map((value) => normalizePath(value))
+        .filter((value) => normalizeTokens(value).length >= 2)
+        .filter(Boolean);
+}
+function pathsOverlap(left, right) {
+    const leftTokens = normalizeTokens(normalizePath(left));
+    const rightTokens = normalizeTokens(normalizePath(right));
+    const sharedTokens = leftTokens.filter((token) => rightTokens.includes(token));
+    return normalizePath(left).includes(normalizePath(right))
+        || normalizePath(right).includes(normalizePath(left))
+        || (leftTokens.length > 0 && rightTokens.length > 0 && sharedTokens.length >= Math.min(2, rightTokens.length));
+}
+function normalizePath(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.pathname;
+    }
+    catch {
+        return (value.split('?')[0] ?? value).replace(/^\$\{[^}]+\}/, '');
+    }
+}
+function normalizeTokens(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length > 1 && !/^(platform|rs2|api|rest|sec)$/.test(token));
+}
+function parseMetadata(metadataJson) {
+    try {
+        return JSON.parse(metadataJson);
+    }
+    catch {
+        return {};
+    }
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}