@danielblomma/cortex-mcp 2.2.5 → 2.4.0

package/scaffold/mcp/src/embed.ts

@@ -31,6 +31,31 @@ const MODEL_CACHE_DIR = PATHS.embeddingsModelCache;
 const EMBEDDINGS_DIR = path.dirname(EMBEDDINGS_PATH);
 
 export const DEFAULT_MODEL_ID = "jinaai/jina-embeddings-v2-base-code";
+export const COMPACT_FILE_TEXT_STRATEGY = "compact_files_v1";
+export const COMPACT_FILE_TEXT_THRESHOLD_CHARS = 32768;
+export const COMPACT_FILE_TEXT_TARGET_CHARS = 16000;
+
+const COMPACT_FILE_SIGNAL_BUDGET_CHARS = 4096;
+const COMPACT_FILE_SIGNAL_MAX_LINE_CHARS = 512;
+const COMPACT_FILE_MIN_HEAD_CHARS = 4096;
+const COMPACT_FILE_MIN_TAIL_CHARS = 2048;
+
+export type EmbedTextProfile = "full" | "compact-files";
+
+type FileEmbeddingTextResult = {
+  text: string;
+  profile: EmbedTextProfile;
+  compacted: boolean;
+  original_chars: number;
+  text_chars: number;
+  omitted_chars: number;
+};
+
+type ParseFileEntitiesOptions = {
+  textProfile?: EmbedTextProfile;
+};
+
+type SignatureEntityType = "File" | "Rule" | "ADR" | "Module" | "Project" | "Chunk";
 
 export function resolveModelId(): string {
   return (process.env.CORTEX_EMBED_MODEL ?? DEFAULT_MODEL_ID).trim() || DEFAULT_MODEL_ID;
@@ -48,6 +73,11 @@ type FileEntity = {
   updated_at: string;
   text: string;
   signature: string;
+  text_profile: EmbedTextProfile;
+  text_compacted: boolean;
+  text_original_chars: number;
+  text_chars: number;
+  text_omitted_chars: number;
 };
 
 type RuleEntity = {
@@ -155,6 +185,129 @@ function normalizeText(value: string): string {
   return value.replace(/\s+/g, " ").trim();
 }
 
+export function resolveEmbedTextProfile(raw = process.env.CORTEX_EMBED_TEXT_PROFILE): EmbedTextProfile {
+  const value = (raw ?? "").trim().toLowerCase();
+  if (!value || value === "full") {
+    return "full";
+  }
+  if (value === "compact-files") {
+    return "compact-files";
+  }
+  throw new Error(
+    `Unsupported CORTEX_EMBED_TEXT_PROFILE=${JSON.stringify(raw)}; expected "full" or "compact-files"`
+  );
+}
+
+function isSignalLine(line: string): boolean {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return (
+    /^(import|export)\b/.test(trimmed) ||
+    /^(abstract\s+|async\s+|public\s+|private\s+|protected\s+|static\s+|readonly\s+|override\s+)*(class|interface|type|enum|function)\b/.test(trimmed) ||
+    /^(const|let|var)\s+[$A-Z_a-z][$\w]*\s*=/.test(trimmed) ||
+    /^(describe|it|test)\s*\(/.test(trimmed) ||
+    /^(@[A-Z_a-z][$\w]*|#[#\s])/.test(trimmed) ||
+    /^```[A-Za-z0-9_-]+/.test(trimmed) ||
+    /\b(route|router|endpoint|controller|handler|middleware|permission|auth|token|secret|security|todo|fixme)\b/i.test(trimmed)
+  );
+}
+
+function collectSignalLines(content: string, budgetChars: number): string {
+  const lines: string[] = [];
+  const seen = new Set<string>();
+  let used = 0;
+
+  for (const line of content.split(/\r?\n/)) {
+    if (!isSignalLine(line)) {
+      continue;
+    }
+    const normalized = line.trimEnd();
+    const signalLine = normalized.length > COMPACT_FILE_SIGNAL_MAX_LINE_CHARS
+      ? `${normalized.slice(0, COMPACT_FILE_SIGNAL_MAX_LINE_CHARS)} [cortex ${COMPACT_FILE_TEXT_STRATEGY} signal_line_truncated_chars=${normalized.length - COMPACT_FILE_SIGNAL_MAX_LINE_CHARS}]`
+      : normalized;
+    if (seen.has(signalLine)) {
+      continue;
+    }
+    const next = used + signalLine.length + 1;
+    if (next > budgetChars) {
+      continue;
+    }
+    lines.push(signalLine);
+    seen.add(signalLine);
+    used = next;
+  }
+
+  return lines.join("\n");
+}
+
+export function buildFileEmbeddingText(
+  filePath: string,
+  excerpt: string,
+  content: string,
+  profile: EmbedTextProfile = "full"
+): FileEmbeddingTextResult {
+  const fullText = `${filePath}\n${excerpt}\n${content}`;
+  if (profile === "full" || fullText.length <= COMPACT_FILE_TEXT_THRESHOLD_CHARS) {
+    return {
+      text: fullText,
+      profile,
+      compacted: false,
+      original_chars: fullText.length,
+      text_chars: fullText.length,
+      omitted_chars: 0
+    };
+  }
+
+  const signalText = collectSignalLines(content, COMPACT_FILE_SIGNAL_BUDGET_CHARS);
+  const markerPrefix = `[cortex ${COMPACT_FILE_TEXT_STRATEGY} omitted_chars=`;
+  const staticChars =
+    filePath.length +
+    excerpt.length +
+    signalText.length +
+    markerPrefix.length +
+    64;
+  const available = Math.max(
+    COMPACT_FILE_MIN_HEAD_CHARS + COMPACT_FILE_MIN_TAIL_CHARS,
+    COMPACT_FILE_TEXT_TARGET_CHARS - staticChars
+  );
+  const headChars = Math.max(COMPACT_FILE_MIN_HEAD_CHARS, Math.floor(available * 0.62));
+  const tailChars = Math.max(COMPACT_FILE_MIN_TAIL_CHARS, available - headChars);
+  const head = content.slice(0, headChars);
+  const tail = content.slice(-tailChars);
+  const omittedChars = Math.max(0, content.length - head.length - tail.length);
+  const marker = `${markerPrefix}${omittedChars}]`;
+  const compactText = [
+    filePath,
+    excerpt,
+    head,
+    marker,
+    signalText ? `[cortex ${COMPACT_FILE_TEXT_STRATEGY} signal_lines]\n${signalText}` : "",
+    tail
+  ].filter((part) => part.length > 0).join("\n");
+
+  if (compactText.length >= fullText.length) {
+    return {
+      text: fullText,
+      profile,
+      compacted: false,
+      original_chars: fullText.length,
+      text_chars: fullText.length,
+      omitted_chars: 0
+    };
+  }
+
+  return {
+    text: compactText,
+    profile,
+    compacted: true,
+    original_chars: fullText.length,
+    text_chars: compactText.length,
+    omitted_chars: fullText.length - compactText.length
+  };
+}
+
 function ensureRequiredFiles(): void {
   const required = [
     path.join(CACHE_DIR, "documents.jsonl"),
@@ -169,7 +322,8 @@ function ensureRequiredFiles(): void {
   }
 }
 
-export function parseFileEntities(raw: JsonObject[]): FileEntity[] {
+export function parseFileEntities(raw: JsonObject[], options: ParseFileEntitiesOptions = {}): FileEntity[] {
+  const textProfile = options.textProfile ?? "full";
   return raw
     .map((item) => {
       const id = asString(item.id);
@@ -182,7 +336,7 @@ export function parseFileEntities(raw: JsonObject[]): FileEntity[] {
       const excerpt = asString(item.excerpt);
       const updatedAt = asString(item.updated_at);
       const checksum = asString(item.checksum, hashText(content));
-      const text = `${filePath}\n${excerpt}\n${content}`;
+      const embeddingText = buildFileEmbeddingText(filePath, excerpt, content, textProfile);
 
       return {
         id,
@@ -194,8 +348,13 @@ export function parseFileEntities(raw: JsonObject[]): FileEntity[] {
         source_of_truth: asBoolean(item.source_of_truth, false),
         trust_level: asNumber(item.trust_level, 50),
         updated_at: updatedAt,
-        text,
-        signature: hashText(`file|${checksum}|${updatedAt}|${hashText(text)}`)
+        text: embeddingText.text,
+        signature: hashText(`file|${checksum}|${updatedAt}|${hashText(embeddingText.text)}`),
+        text_profile: embeddingText.profile,
+        text_compacted: embeddingText.compacted,
+        text_original_chars: embeddingText.original_chars,
+        text_chars: embeddingText.text_chars,
+        text_omitted_chars: embeddingText.omitted_chars
       };
     })
     .filter((value): value is FileEntity => value !== null);
@@ -408,8 +567,24 @@ function roundVector(values: number[]): number[] {
   return values.map((value) => Number(value.toFixed(6)));
 }
 
-function resolveSignatureProfile(maxTokenCap: number | null): string {
-  return maxTokenCap ? `embed|max_tokens=${maxTokenCap}` : "";
+export function resolveSignatureProfile(
+  maxTokenCap: number | null,
+  textProfile: EmbedTextProfile = "full",
+  entityType?: SignatureEntityType
+): string {
+  const parts: string[] = [];
+  if (maxTokenCap) {
+    parts.push(`max_tokens=${maxTokenCap}`);
+  }
+  if (textProfile === "compact-files" && (entityType === undefined || entityType === "File")) {
+    parts.push(
+      "text_profile=compact-files",
+      COMPACT_FILE_TEXT_STRATEGY,
+      `threshold_chars=${COMPACT_FILE_TEXT_THRESHOLD_CHARS}`,
+      `target_chars=${COMPACT_FILE_TEXT_TARGET_CHARS}`
+    );
+  }
+  return parts.length ? `embed|${parts.join("|")}` : "";
 }
 
 function embeddingSignature(entitySignature: string, profile: string): string {
@@ -434,8 +609,19 @@ async function main(): Promise<void> {
   fs.mkdirSync(MODEL_CACHE_DIR, { recursive: true });
 
   const modelId = resolveModelId();
-
-  const documents = parseFileEntities(readJsonl(path.join(CACHE_DIR, "documents.jsonl")));
+  const textProfile = resolveEmbedTextProfile();
+
+  const documents = parseFileEntities(readJsonl(path.join(CACHE_DIR, "documents.jsonl")), { textProfile });
+  const textProfileStats = {
+    strategy: textProfile === "compact-files" ? COMPACT_FILE_TEXT_STRATEGY : null,
+    threshold_chars: textProfile === "compact-files" ? COMPACT_FILE_TEXT_THRESHOLD_CHARS : null,
+    target_chars: textProfile === "compact-files" ? COMPACT_FILE_TEXT_TARGET_CHARS : null,
+    file_entities: documents.length,
+    compacted_files: documents.filter((doc) => doc.text_compacted).length,
+    original_chars: documents.reduce((total, doc) => total + doc.text_original_chars, 0),
+    text_chars: documents.reduce((total, doc) => total + doc.text_chars, 0),
+    saved_chars: documents.reduce((total, doc) => total + doc.text_omitted_chars, 0)
+  };
   const rules = parseRuleEntities(readJsonl(path.join(CACHE_DIR, "entities.rule.jsonl")));
   const adrs = parseAdrEntities(readJsonl(path.join(CACHE_DIR, "entities.adr.jsonl")));
   const modules = parseModuleEntities(readJsonl(path.join(CACHE_DIR, "entities.module.jsonl")));
@@ -483,7 +669,10 @@ async function main(): Promise<void> {
     memoryBytes: memoryHeadroom,
     sessions: previewPoolConfig.sessions
   });
-  const signatureProfile = resolveSignatureProfile(tokenBudget.cap);
+  const defaultSignatureProfile = resolveSignatureProfile(tokenBudget.cap, "full");
+  const fileSignatureProfile = resolveSignatureProfile(tokenBudget.cap, textProfile, "File");
+  const signatureProfileForEntity = (entity: SearchEntity) =>
+    entity.type === "File" ? fileSignatureProfile : defaultSignatureProfile;
 
   const existing = parseExistingEmbeddings(readJsonlRecords(EMBEDDINGS_PATH), modelId);
 
@@ -494,6 +683,7 @@ async function main(): Promise<void> {
   let dimensions = 0;
 
   entities.forEach((entity, index) => {
+    const signatureProfile = signatureProfileForEntity(entity);
     const signature = embeddingSignature(entity.signature, signatureProfile);
     const previous = existing.get(entity.id);
     if (previous && previous.signature === signature && previous.vector.length > 0) {
@@ -628,6 +818,7 @@ async function main(): Promise<void> {
       maxInFlightTokens,
       onVector(index, rawVector) {
         const entity = entities[index];
+        const signatureProfile = signatureProfileForEntity(entity);
         const vector = roundVector(rawVector);
         embedded += 1;
         dimensions = dimensions || vector.length;
@@ -662,6 +853,13 @@ async function main(): Promise<void> {
     mode,
     model: modelId,
     dimensions,
+    text_profile: textProfile,
+    signature_profile: fileSignatureProfile === defaultSignatureProfile ? defaultSignatureProfile : "per_entity",
+    signature_profiles: {
+      default: defaultSignatureProfile,
+      file: fileSignatureProfile
+    },
+    text_profile_stats: textProfileStats,
     counts: {
       entities: entities.length,
       output: outputCount,
@@ -675,7 +873,10 @@ async function main(): Promise<void> {
   fs.writeFileSync(EMBEDDINGS_MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
 
   console.log(
-    `[embed] mode=${mode} model=${modelId} dim=${dimensions} pool=${poolConfig.sessions}x${poolConfig.threadsPerSession} batch<=${schedulerOptions.batchMaxItems} max_tokens<=${modelMaxTokensUsed || tokenBudget.cap || "model"} token_budget=${tokenBudget.mode} reason=${tokenBudget.reason}`
+    `[embed] mode=${mode} model=${modelId} dim=${dimensions} pool=${poolConfig.sessions}x${poolConfig.threadsPerSession} batch<=${schedulerOptions.batchMaxItems} max_tokens<=${modelMaxTokensUsed || tokenBudget.cap || "model"} token_budget=${tokenBudget.mode} reason=${tokenBudget.reason} text_profile=${textProfile}`
+  );
+  console.log(
+    `[embed] text_profile=${textProfile} compacted_files=${textProfileStats.compacted_files}/${textProfileStats.file_entities} saved_chars=${textProfileStats.saved_chars}`
   );
   console.log(
     `[embed] entities=${entities.length} embedded=${embedded} reused=${reused} failed=${failed}`

package/scaffold/mcp/src/enterprise/index.ts

@@ -21,7 +21,7 @@ import { pushWorkflowSnapshot, setWorkflowPushContext } from "./workflow/push.js
 import { hasWorkflowState, loadWorkflowState } from "./workflow/state.js";
 
 const require = createRequire(import.meta.url);
-const pkg = require("../package.json") as { version: string };
+const pkg = require("../../package.json") as { version: string };
 
 export const name = "cortex-enterprise";
 export const version: string = pkg.version;

package/scaffold/mcp/src/enterprise/reviews/changed-files.ts

@@ -0,0 +1,34 @@
+import { execFileSync } from "node:child_process";
+
+function gitLines(projectRoot: string, args: string[]): string[] {
+  const output = execFileSync("git", args, {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  return output.split("\n").map((value) => value.trim()).filter(Boolean);
+}
+
+function trackedChangedFiles(projectRoot: string): string[] {
+  try {
+    return gitLines(projectRoot, ["diff", "--name-only", "HEAD"]);
+  } catch {
+    // No HEAD yet (repo without commits): every tracked file is new.
+    return [
+      ...gitLines(projectRoot, ["diff", "--name-only"]),
+      ...gitLines(projectRoot, ["ls-files"]),
+    ];
+  }
+}
+
+export function resolveChangedReviewFiles(projectRoot: string): string[] | null {
+  try {
+    gitLines(projectRoot, ["rev-parse", "--is-inside-work-tree"]);
+    const tracked = trackedChangedFiles(projectRoot);
+    const untracked = gitLines(projectRoot, ["ls-files", "--others", "--exclude-standard"]);
+    return [...new Set([...tracked, ...untracked])].sort();
+  } catch {
+    return null;
+  }
+}

package/scaffold/mcp/src/enterprise/reviews/pattern-context.ts

@@ -0,0 +1,231 @@
+import { loadContextData } from "../../graph.js";
+import { normalizeRepoPath, runLocalPatternEvidence } from "../../patternEvidence.js";
+import { compareText } from "../../searchResults.js";
+import type { ContextData, PatternEvidenceParams, ToolPayload } from "../../types.js";
+
+type PatternEvidenceRunner = (input: PatternEvidenceParams) => Promise<ToolPayload>;
+
+// Loads context data lazily on first use and shares it across all targets in
+// one review, instead of re-reading the index from disk per target. Load
+// failures surface per target, matching the per-file error handling below.
+export function createLocalPatternRunner(
+  loadData: () => Promise<ContextData> = loadContextData,
+): PatternEvidenceRunner {
+  let shared: Promise<ContextData> | undefined;
+  return async (params) => {
+    shared ??= loadData();
+    return runLocalPatternEvidence(params, { data: await shared });
+  };
+}
+
+export const PATTERN_REVIEW_QUESTION =
+  "Does this change follow the established pattern for this kind of problem in this repository, or does it introduce a second way to solve something that already has a local convention?";
+
+const PATTERN_EVIDENCE_ORDER = ["same_file", "same_module", "same_feature_area", "repo_wide"] as const;
+
+// Canonicalizes like the pattern evidence engine, then rejects paths that
+// must never appear in review citations (absolute, drive-letter, or
+// parent-escaping paths).
+function normalizeReviewPath(value: string): string | null {
+  const normalized = normalizeRepoPath(value);
+  if (
+    !normalized ||
+    normalized.startsWith("/") ||
+    /^[A-Za-z]:\//.test(normalized) ||
+    normalized.split("/").includes("..")
+  ) {
+    return null;
+  }
+  return normalized;
+}
+
+function safeIdentifier(value: unknown): string | null {
+  if (typeof value !== "string" || value.length === 0 || value.length > 1000) return null;
+  if (/(?:^|:)\/|[A-Za-z]:[\\/]|(?:^|[:/])\.\.(?:[:/]|$)/u.test(value)) return null;
+  return value;
+}
+
+function emptyTiers(): ToolPayload[] {
+  return PATTERN_EVIDENCE_ORDER.map((name) => ({ name, evidence: [] }));
+}
+
+function sanitizeEvidenceTiers(value: unknown): { tiers: ToolPayload[]; dropped: number } {
+  const inputTiers = Array.isArray(value) ? value : [];
+  let dropped = 0;
+  const tiers = PATTERN_EVIDENCE_ORDER.map((name) => {
+    const source = inputTiers.find((candidate) =>
+      candidate && typeof candidate === "object" && (candidate as Record<string, unknown>).name === name
+    ) as Record<string, unknown> | undefined;
+    const rawEvidence = Array.isArray(source?.evidence) ? source.evidence : [];
+    const evidence: ToolPayload[] = [];
+    for (const candidate of rawEvidence) {
+      if (!candidate || typeof candidate !== "object") {
+        dropped += 1;
+        continue;
+      }
+      const row = candidate as Record<string, unknown>;
+      const citationPath = typeof row.path === "string" ? normalizeReviewPath(row.path) : null;
+      const id = safeIdentifier(row.id);
+      if (!citationPath || !id) {
+        dropped += 1;
+        continue;
+      }
+      evidence.push({
+        id,
+        entity_type: typeof row.entity_type === "string" ? row.entity_type.slice(0, 100) : "",
+        kind: typeof row.kind === "string" ? row.kind.slice(0, 100) : "",
+        title: typeof row.title === "string" ? row.title.slice(0, 500) : id,
+        path: citationPath,
+        start_line: Number.isInteger(row.start_line) ? row.start_line : null,
+        end_line: Number.isInteger(row.end_line) ? row.end_line : null,
+        excerpt: typeof row.excerpt === "string" ? row.excerpt.slice(0, 1000) : "",
+        score: typeof row.score === "number" && Number.isFinite(row.score) ? row.score : null,
+        matched_rules: Array.isArray(row.matched_rules)
+          ? row.matched_rules.filter((item): item is string => typeof item === "string").slice(0, 50)
+          : [],
+      });
+    }
+    return { name, evidence };
+  });
+  return { tiers, dropped };
+}
+
+function emptyTarget(file: string, status: "not_indexed" | "error", query?: string): ToolPayload {
+  return {
+    path: file,
+    status,
+    review_question: PATTERN_REVIEW_QUESTION,
+    query: query ?? null,
+    query_source: query ? "explicit" : null,
+    local_pattern_found: false,
+    fallback_used: false,
+    evidence_order: [...PATTERN_EVIDENCE_ORDER],
+    tiers: emptyTiers(),
+    warning: null,
+    message: status === "not_indexed"
+      ? "Target is not present as a file-backed entity in the current Cortex index. Run cortex update before reviewing it."
+      : "Pattern evidence could not be produced for this target.",
+    citations_dropped: 0,
+  };
+}
+
+function disabledPatternReview(requested: number, limit: number, topK: number): ToolPayload {
+  return {
+    enabled: false,
+    non_blocking: true,
+    affects_policy_summary: false,
+    review_question: PATTERN_REVIEW_QUESTION,
+    limit,
+    top_k_per_tier: topK,
+    targets: [],
+    summary: {
+      requested,
+      eligible: 0,
+      analyzed: 0,
+      local_evidence: 0,
+      repo_fallback: 0,
+      no_evidence: 0,
+      not_indexed: 0,
+      errors: 0,
+      omitted: 0,
+      invalid_paths: 0,
+    },
+  };
+}
+
+export async function buildPatternReviewContext(input: {
+  files: string[];
+  enabled: boolean;
+  query?: string;
+  topK: number;
+  limit: number;
+  runner?: PatternEvidenceRunner;
+}): Promise<ToolPayload> {
+  if (!input.enabled) {
+    return disabledPatternReview(input.files.length, input.limit, input.topK);
+  }
+
+  const normalized = input.files.map(normalizeReviewPath);
+  const invalidPaths = normalized.filter((value) => value === null).length;
+  const eligible = [...new Set(normalized.filter((value): value is string => value !== null))]
+    .sort(compareText);
+  const selected = eligible.slice(0, input.limit);
+  const runner = input.runner ?? createLocalPatternRunner();
+  const targets: ToolPayload[] = [];
+  const counts = {
+    local_evidence: 0,
+    repo_fallback: 0,
+    no_evidence: 0,
+    not_indexed: 0,
+    errors: 0,
+  };
+
+  for (const file of selected) {
+    try {
+      const evidence = await runner({
+        target: file,
+        query: input.query,
+        top_k: input.topK,
+        include_deprecated: false,
+      });
+      const sanitized = sanitizeEvidenceTiers(evidence.tiers);
+      const localPatternFound = sanitized.tiers.slice(0, 3).some((tier) =>
+        Array.isArray(tier.evidence) && tier.evidence.length > 0
+      );
+      const repoEvidence = sanitized.tiers[3].evidence;
+      const fallbackUsed = !localPatternFound && Array.isArray(repoEvidence) && repoEvidence.length > 0;
+      const status = localPatternFound
+        ? "local_evidence"
+        : fallbackUsed
+          ? "repo_fallback"
+          : "no_evidence";
+      counts[status] += 1;
+      const warning = status === "local_evidence"
+        ? typeof evidence.warning === "string" ? "Pattern evidence completed with local runtime warnings." : null
+        : status === "repo_fallback"
+          ? "No applicable local pattern evidence was found; repository-wide fallback evidence is provided."
+          : "No applicable local pattern evidence was found.";
+      targets.push({
+        path: file,
+        status,
+        review_question: PATTERN_REVIEW_QUESTION,
+        query: typeof evidence.query === "string" ? evidence.query.slice(0, 1000) : input.query ?? null,
+        query_source: evidence.query_source === "explicit" || evidence.query_source === "derived_from_target"
+          ? evidence.query_source
+          : input.query ? "explicit" : null,
+        local_pattern_found: localPatternFound,
+        fallback_used: fallbackUsed,
+        evidence_order: [...PATTERN_EVIDENCE_ORDER],
+        tiers: sanitized.tiers,
+        warning,
+        message: null,
+        citations_dropped: sanitized.dropped,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const notIndexed = /not found in indexed context|not file-backed/u.test(message);
+      const status = notIndexed ? "not_indexed" : "error";
+      counts[notIndexed ? "not_indexed" : "errors"] += 1;
+      targets.push(emptyTarget(file, status, input.query));
+    }
+  }
+
+  return {
+    enabled: true,
+    non_blocking: true,
+    affects_policy_summary: false,
+    review_question: PATTERN_REVIEW_QUESTION,
+    query: input.query ?? null,
+    limit: input.limit,
+    top_k_per_tier: input.topK,
+    targets,
+    summary: {
+      requested: input.files.length,
+      eligible: eligible.length,
+      analyzed: selected.length,
+      ...counts,
+      omitted: Math.max(0, eligible.length - selected.length),
+      invalid_paths: invalidPaths,
+    },
+  };
+}