@mknrt/autotests-overkill 1.1.4 → 1.2.0

package/README.md

@@ -45,9 +45,10 @@ 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 `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`.
+4. Use `review_test_draft` to critique a draft for reuse, selector stability, setup drift, and likely gap coverage before editing `autotests2`.
+5. Use `find_backend_test_context` when a request flow needs backend validation, params, async completion, or contract-drift evidence.
+6. Use `summarize_ci_context`, `triage_failed_run`, and `analyze_diff_impact` for failure or change triage.
+7. Review generated output manually before editing `autotests2`.
 
 CLI commands:
 
@@ -55,6 +56,7 @@ CLI commands:
 - `npx autotests-overkill mcp`
 - `npx autotests-overkill acceptance coverage caption`
 - `npx autotests-overkill acceptance blueprint dateRangeField`
+- `npx autotests-overkill acceptance review caption`
 
 ## Verification commands
 
@@ -63,6 +65,7 @@ CLI commands:
 - `npm run acceptance:coverage`
 - `npm run acceptance:coverage:legacy`
 - `npm run acceptance:blueprint`
+- `npm run acceptance:review`
 - `npm run acceptance:failure`
 - `npm run acceptance:impact`
 
@@ -95,6 +98,7 @@ Only high-confidence links (`confidence >= 0.7`) drive blueprint, triage, and im
 ## MCP tools
 
 - `find_existing_test_assets`
+- `review_test_draft`
 - `find_backend_test_context`
 - `find_test_area_context`
 - `find_frontend_contract`

package/dist/src/cli/runAcceptance.d.ts

@@ -1,6 +1,6 @@
 import { type AppContext } from '../appContext.js';
 import type { NormalizedToolOutput } from '../contracts/toolOutput.js';
-export type AcceptanceMode = 'coverage' | 'failure' | 'impact' | 'blueprint';
+export type AcceptanceMode = 'coverage' | 'failure' | 'impact' | 'blueprint' | 'review';
 export type AcceptanceCheck = {
     name: string;
     passed: boolean;
@@ -17,5 +17,6 @@ export declare function evaluateCoverageAcceptance(contract: NormalizedToolOutpu
 export declare function evaluateFailureAcceptance(triage: NormalizedToolOutput): AcceptanceCheck[];
 export declare function evaluateImpactAcceptance(impact: NormalizedToolOutput, changedFile: string): AcceptanceCheck[];
 export declare function evaluateBlueprintAcceptance(blueprint: NormalizedToolOutput, feature: string): AcceptanceCheck[];
+export declare function evaluateReviewAcceptance(review: NormalizedToolOutput, feature: string): AcceptanceCheck[];
 export declare function assertPassingChecks(report: AcceptanceReport): void;
 export declare function runAcceptanceCli(argv?: string[]): Promise<void>;

package/dist/src/cli/runAcceptance.js

@@ -3,6 +3,7 @@ import { analyzeDiffImpact } from '../domain/analyzeDiffImpact.js';
 import { analyzeTestGaps } from '../domain/analyzeTestGaps.js';
 import { findFrontendContract } from '../domain/findFrontendContract.js';
 import { generateSpecBlueprint } from '../domain/generateSpecBlueprint.js';
+import { reviewTestDraft } from '../domain/reviewTestDraft.js';
 import { triageFailedRun } from '../domain/triageFailedRun.js';
 import { isDirectExecution } from './shared.js';
 export async function evaluateAcceptanceMode(mode, args, context) {
@@ -43,6 +44,25 @@ export async function evaluateAcceptanceMode(mode, args, context) {
             output: { impact },
         };
     }
+    if (mode === 'review') {
+        const feature = args[0] ?? 'caption';
+        const draft = args[1] ?? `
+describe('[Overkill] ${feature}', () => {
+  it('covers ${feature}', () => {
+    cy.wait(1000);
+    cy.get('.widget-row').eq(1).click({ force: true });
+  });
+});
+`;
+        const area = args[2];
+        const review = await reviewTestDraft({ feature, draft, area }, context);
+        return {
+            mode,
+            target: feature,
+            checks: evaluateReviewAcceptance(review, feature),
+            output: { review },
+        };
+    }
     const feature = args[0] ?? 'caption';
     const area = args[1];
     const blueprint = await generateSpecBlueprint({ feature, area }, context);
@@ -91,6 +111,17 @@ export function evaluateBlueprintAcceptance(blueprint, feature) {
         check('selector and reuse guidance', hasSelectorGuidance && hasReuseGuidance, `Blueprint acceptance for '${feature}' requires explicit selector and reuse guidance.`, 'Recommended actions include selector and reuse guidance.'),
     ];
 }
+export function evaluateReviewAcceptance(review, feature) {
+    const issueEvidence = review.evidence.filter((item) => item.label.startsWith('draft issue '));
+    const hasSeverity = issueEvidence.some((item) => item.metadata && typeof item.metadata.severity === 'string');
+    const hasHighSeveritySummary = review.summary.includes('high severity');
+    const hasActionableGuidance = review.recommended_actions.length > 0;
+    return [
+        check('review findings', issueEvidence.length > 0, `Review acceptance for '${feature}' requires evidence-backed draft findings.`, `Collected ${issueEvidence.length} review finding(s).`),
+        check('review severity summary', hasSeverity && hasHighSeveritySummary, `Review acceptance for '${feature}' requires structured severity metadata and summary counts.`, 'Review output contains structured severity metadata.'),
+        check('review actions', hasActionableGuidance, `Review acceptance for '${feature}' requires actionable remediation guidance.`, 'Review output contains actionable remediation guidance.'),
+    ];
+}
 export function assertPassingChecks(report) {
     const failedChecks = report.checks.filter((checkResult) => !checkResult.passed);
     if (failedChecks.length === 0) {
@@ -109,7 +140,7 @@ function check(name, passed, failedDetail, passedDetail) {
 export async function runAcceptanceCli(argv = process.argv.slice(2)) {
     const [rawMode, ...args] = argv;
     if (!isAcceptanceMode(rawMode)) {
-        console.error(`Unknown acceptance mode '${rawMode}'. Use coverage, failure, impact, or blueprint.`);
+        console.error(`Unknown acceptance mode '${rawMode}'. Use coverage, failure, impact, blueprint, or review.`);
         process.exit(1);
     }
     const context = await createRuntimeAppContext();
@@ -124,7 +155,7 @@ export async function runAcceptanceCli(argv = process.argv.slice(2)) {
     }
 }
 function isAcceptanceMode(value) {
-    return value === 'coverage' || value === 'failure' || value === 'impact' || value === 'blueprint';
+    return value === 'coverage' || value === 'failure' || value === 'impact' || value === 'blueprint' || value === 'review';
 }
 if (isDirectExecution(import.meta.url)) {
     await runAcceptanceCli();

package/dist/src/contracts/toolOutput.d.ts

@@ -8,14 +8,14 @@ export declare const evidenceSchema: z.ZodObject<{
     snippet: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+    type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
     label: string;
     path?: string | undefined;
     locator?: string | undefined;
     snippet?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
 }, {
-    type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+    type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
     label: string;
     path?: string | undefined;
     locator?: string | undefined;
@@ -32,14 +32,14 @@ export declare const toolOutputSchema: z.ZodObject<{
         snippet: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;
         snippet?: string | undefined;
         metadata?: Record<string, unknown> | undefined;
     }, {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;
@@ -66,7 +66,7 @@ export declare const toolOutputSchema: z.ZodObject<{
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;
@@ -84,7 +84,7 @@ export declare const toolOutputSchema: z.ZodObject<{
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

package/dist/src/contracts/toolOutput.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { confidenceFromEvidence } from './confidence.js';
+import { toPosixPath } from '../utils/pathUtils.js';
 export const evidenceSchema = z.object({
     type: z.enum(['file', 'symbol', 'test', 'artifact', 'report', 'diff', 'config']),
     label: z.string(),
@@ -22,14 +23,17 @@ export const toolOutputSchema = z.object({
 });
 export function buildToolOutput(input) {
     const warnings = input.warnings ?? [];
-    const repoPaths = input.repo_paths ?? input.evidence.flatMap((item) => item.path ? [item.path] : []);
-    const uniquePaths = [...new Set(repoPaths)];
+    const normalizedEvidence = input.evidence.map((item) => item.path
+        ? { ...item, path: toPosixPath(item.path) }
+        : item);
+    const repoPaths = input.repo_paths ?? normalizedEvidence.flatMap((item) => item.path ? [item.path] : []);
+    const uniquePaths = [...new Set(repoPaths.map((repoPath) => toPosixPath(repoPath)))];
     return {
         summary: input.summary,
-        evidence: input.evidence,
+        evidence: normalizedEvidence,
         recommended_actions: input.recommended_actions,
         repo_paths: uniquePaths,
-        confidence: input.confidence ?? confidenceFromEvidence(input.evidence.length, warnings),
+        confidence: input.confidence ?? confidenceFromEvidence(normalizedEvidence.length, warnings),
         warnings,
     };
 }

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

@@ -5,7 +5,7 @@ export declare function analyzeDiffImpact(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

package/dist/src/domain/analyzeDiffImpact.js

@@ -3,21 +3,23 @@ import fs from 'node:fs';
 import { normalizeChangedFiles } from '../connectors/diffConnector.js';
 import { queryDocuments } from '../knowledge/repositories.js';
 import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
-import { basenameWithoutExt } from '../utils/pathUtils.js';
+import { basenameWithoutExt, featureNameCandidates } from '../utils/pathUtils.js';
 import { ensureIndexed, evidenceFile, output } from './shared.js';
+import { scoreTextMatch } from '../utils/textUtils.js';
 export async function analyzeDiffImpact(input, context) {
     const changedFiles = normalizeChangedFiles(input.changedFiles);
     const featureHints = changedFiles.map((filePath) => deriveFeatureHint(filePath)).filter(Boolean);
     const uniqueFeatures = [...new Set(featureHints)];
     const evidence = changedFiles.map((filePath) => evidenceFile('changed file', filePath));
     const impactedSpecs = new Set();
+    const warnings = [];
     await ensureIndexed(context);
     for (const feature of uniqueFeatures) {
         const indexed = queryDocuments(context.database, feature, {
             repoKind: 'autotests2',
             sourceKinds: ['spec'],
             limit: 12,
-        });
+        }).filter((item) => isStrongFeatureSpecMatch(item.path, item.title, feature));
         for (const item of indexed) {
             impactedSpecs.add(item.path);
         }
@@ -28,7 +30,7 @@ export async function analyzeDiffImpact(input, context) {
             root: context.config.repos.autotests2,
             featureHint: feature,
         });
-        for (const spec of assets.specs.slice(0, 8)) {
+        for (const spec of assets.specs.filter((item) => isStrongFeatureSpecMatch(item.path, item.title, feature)).slice(0, 8)) {
             impactedSpecs.add(spec.path);
         }
     }
@@ -73,7 +75,11 @@ export async function analyzeDiffImpact(input, context) {
     ], [
         'Rerun directly impacted specs before broader regression.',
         'Inspect widget events and container variants when the diff touches shared widget files.',
-    ], impactedSpecs.size === 0 ? ['No impacted specs were found via naming heuristics.'] : []);
+    ], impactedSpecs.size === 0
+        ? ['No impacted specs were found via naming heuristics.']
+        : changedFiles.every((item) => !isFisPlatformPath(item, context))
+            ? ['Frontend impact mapping relies on feature-path heuristics; validate indirect spec candidates before rerun routing.']
+            : warnings);
 }
 function isFisPlatformPath(filePath, context) {
     const fisRoot = context.config.repos.fisPlatform;
@@ -116,3 +122,7 @@ function deriveFeatureHint(filePath) {
     const parent = path.basename(path.dirname(filePath));
     return parent;
 }
+function isStrongFeatureSpecMatch(specPath, specTitle, feature) {
+    const searchable = `${specPath}\n${specTitle}`;
+    return featureNameCandidates(feature).some((candidate) => scoreTextMatch(searchable, candidate) > 0);
+}

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

@@ -5,7 +5,7 @@ export declare function analyzeTestGaps(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

package/dist/src/domain/analyzeTestGaps.js

@@ -21,7 +21,8 @@ export async function analyzeTestGaps(input, context) {
     const specText = assets.specs.map((spec) => spec.body).join('\n');
     const uncoveredMethods = contract.methods.filter((method) => !specText.includes(method));
     const uncoveredEvents = contract.events.filter((eventName) => !specText.includes(eventName));
-    const uncoveredBranches = runtime.runtimeSignals
+    const focusedRuntimeSignals = focusRuntimeSignals(runtime.runtimeSignals, contract.files);
+    const uncoveredBranches = focusedRuntimeSignals
         .filter((signal) => signal.kind === 'branch')
         .filter((signal) => !specText.includes(signal.name));
     const repoPaths = unique([
@@ -39,3 +40,14 @@ export async function analyzeTestGaps(input, context) {
         'Review container variants separately when only the base widget appears covered.',
     ], warnings, repoPaths);
 }
+function focusRuntimeSignals(signals, contractFiles) {
+    if (contractFiles.length === 0) {
+        return signals;
+    }
+    const contractFileSet = new Set(contractFiles.map(normalizePath));
+    const focused = signals.filter((signal) => contractFileSet.has(normalizePath(signal.path)));
+    return focused.length > 0 ? focused : signals;
+}
+function normalizePath(filePath) {
+    return filePath.replaceAll('\\', '/').toLowerCase();
+}

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

@@ -6,7 +6,7 @@ export declare function buildRerunScope(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

package/dist/src/domain/buildRerunScope.js

@@ -1,5 +1,6 @@
 import { analyzeDiffImpact } from './analyzeDiffImpact.js';
 import { output } from './shared.js';
+import { unique } from '../utils/pathUtils.js';
 export async function buildRerunScope(input, context) {
     const stats = context.ciArtifacts.readStats(input.statsFile);
     const diffImpact = input.changedFiles?.length
@@ -10,8 +11,12 @@ export async function buildRerunScope(input, context) {
         ...(diffImpact?.repo_paths.filter((repoPath) => repoPath.endsWith('.cy.js')) ?? []),
     ];
     const uniqueSpecs = [...new Set(rerunSpecs)];
+    const warnings = unique([
+        ...(diffImpact?.warnings ?? []),
+        ...(uniqueSpecs.length === 0 ? ['No explicit rerun spec candidates were discovered.'] : []),
+    ]);
     return output(`Built rerun scope with ${uniqueSpecs.length} spec candidate(s).`, uniqueSpecs.map((repoPath) => ({ type: 'test', label: 'rerun spec', path: repoPath })), [
         'Run the union of failed specs and impacted specs first.',
         'Keep the rerun pack minimal before escalating to a broader suite.',
-    ], uniqueSpecs.length === 0 ? ['No explicit rerun spec candidates were discovered.'] : []);
+    ], warnings);
 }

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

@@ -6,7 +6,7 @@ export declare function buildSetupTeardownPlan(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -6,7 +6,7 @@ export declare function findBackendTestContext(input: FindBackendTestContextInpu
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

package/dist/src/domain/findBackendTestContext.js

@@ -2,11 +2,15 @@ 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);
@@ -21,20 +25,23 @@ export async function findBackendTestContext(input, context) {
         repoKind: 'fis-platform',
         sourceKinds: ['backend-endpoint'],
         limit: 8,
-    }));
-    const linkedAutotestQuery = [...interactionHits, ...backendHits]
-        .flatMap((item) => {
-        const metadata = parseMetadata(item.metadata_json);
-        return [...(metadata.consumerSignalIds ?? []), ...(metadata.evidencePaths ?? [])];
-    })
-        .join(' ');
-    const linkedAssets = linkedAutotestQuery
-        ? queryDocuments(context.database, linkedAutotestQuery, {
-            repoKind: 'autotests2',
-            sourceKinds: ['spec', 'command', 'helper'],
-            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',
@@ -67,6 +74,84 @@ export async function findBackendTestContext(input, context) {
 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);

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

@@ -5,7 +5,7 @@ export declare function findExistingTestAssets(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -5,7 +5,7 @@ export declare function findFrontendContract(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -5,7 +5,7 @@ export declare function findFrontendRuntimeLogic(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -6,7 +6,7 @@ export declare function findTestAreaContext(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -6,7 +6,7 @@ export declare function generateSpecBlueprint(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -5,7 +5,7 @@ export declare function mapFeatureToExistingCoverage(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -5,7 +5,7 @@ export declare function recommendSelectorStrategy(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -0,0 +1,26 @@
+import type { AppContext } from '../appContext.js';
+type ReviewTestDraftInput = {
+    feature: string;
+    draft: string;
+    area?: string;
+};
+export declare function reviewTestDraft(input: ReviewTestDraftInput, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "test" | "config" | "file" | "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 {};