sweet-search 2.6.16 → 2.7.0

package/core/search/regex-dialect.js

@@ -0,0 +1,328 @@
+/**
+ * Detect grep patterns that may have been written with GNU BRE muscle memory.
+ *
+ * Sweet Search deliberately keeps Rust-regex semantics for the first search.
+ * Agent-format callers may use the translation below for one retry after that
+ * exact pattern returns zero matches. Normal users and non-zero searches remain
+ * byte-identical.
+ */
+
+const BRE_OPERATOR_LABELS = Object.freeze({
+  '|': '\\|',
+  '(': '\\(',
+  ')': '\\)',
+  '+': '\\+',
+  '?': '\\?',
+  '{': '\\{m,n\\}',
+});
+
+const BRE_RETRY_TRIGGERS = new Set(['|', '(', '+', '{']);
+const BARE_BRE_DIVERGENT_METACHARS = new Set(['(', ')', '+', '?', '{', '|']);
+const ZERO_WIDTH_ESCAPES = new Set(['A', 'b', 'B', 'z']);
+const ADDITIVE_RETRY_STATS = [
+  'candidateGenTime_ms',
+  'grepTime_ms',
+  'literalFilterTime_ms',
+  'gramLookupTime_ms',
+];
+
+function isEscapedDoublePipe(pattern, slashStart, escapedIndex) {
+  const previous = pattern.slice(Math.max(0, slashStart - 2), slashStart) === '\\|';
+  const next = pattern.slice(escapedIndex + 1, escapedIndex + 3) === '\\|';
+  return previous || next;
+}
+
+function inspectBreDialect(pattern, { fixedString = false } = {}) {
+  if (fixedString || typeof pattern !== 'string' || pattern.length < 2) return null;
+
+  const operators = new Set();
+  let retryable = false;
+  let translated = '';
+  let inClass = false;
+  let hasBareDivergentMetachar = false;
+  let hasEscapedQuestion = false;
+  let hasAmbiguousEscapeRun = false;
+  let hasEmptyAlternationArm = false;
+  const armStack = [{ hasContent: false, sawAlternation: false }];
+
+  const currentArm = () => armStack[armStack.length - 1];
+  const markContent = () => { currentArm().hasContent = true; };
+  const closeAlternationContext = () => {
+    const arm = currentArm();
+    if (arm.sawAlternation && !arm.hasContent) hasEmptyAlternationArm = true;
+    return arm;
+  };
+
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (inClass) {
+      translated += ch;
+      if (ch === '\\') {
+        let slashCount = 1;
+        while (pattern[i + slashCount] === '\\') slashCount++;
+        translated += '\\'.repeat(slashCount - 1);
+        i += slashCount - 1;
+        if (slashCount % 2 === 1 && i + 1 < pattern.length) {
+          translated += pattern[++i];
+        }
+      } else if (ch === ']') {
+        inClass = false;
+      }
+      continue;
+    }
+    if (ch === '[') {
+      inClass = true;
+      translated += ch;
+      markContent();
+      continue;
+    }
+    if (ch !== '\\') {
+      translated += ch;
+      if (BARE_BRE_DIVERGENT_METACHARS.has(ch)) {
+        hasBareDivergentMetachar = true;
+        markContent();
+      } else if (ch !== '^' && ch !== '$' && ch !== '*') {
+        markContent();
+      }
+      continue;
+    }
+
+    const slashStart = i;
+    let slashCount = 1;
+    while (pattern[i + slashCount] === '\\') slashCount++;
+    const escapedIndex = slashStart + slashCount;
+    const escaped = pattern[escapedIndex];
+    // Multiple backslashes are ambiguous (for example a literal backslash
+    // followed by an escaped operator). Preserve the run, then re-scan the
+    // following character so `\\[...\|...]` still enters the character class.
+    if (slashCount !== 1 || !escaped) {
+      translated += '\\'.repeat(slashCount);
+      if (slashCount !== 1) {
+        hasAmbiguousEscapeRun = true;
+        markContent();
+      }
+      i = slashStart + slashCount - 1;
+      continue;
+    }
+
+    const rawEscape = pattern.slice(slashStart, escapedIndex + 1);
+    if (escaped === '{') {
+      const interval = pattern.slice(slashStart).match(/^\\\{(\d+(?:,\d*)?)\\\}/);
+      if (interval) {
+        operators.add('{');
+        retryable = true;
+        translated += `{${interval[1]}}`;
+        i = slashStart + interval[0].length - 1;
+        continue;
+      }
+    }
+
+    let operator = null;
+    if (escaped === '|' && !isEscapedDoublePipe(pattern, slashStart, escapedIndex)) operator = '|';
+    else if (escaped === '(' || escaped === ')' || escaped === '+' || escaped === '?') operator = escaped;
+
+    if (operator) {
+      operators.add(operator);
+      if (BRE_RETRY_TRIGGERS.has(operator)) retryable = true;
+      if (operator === '?') hasEscapedQuestion = true;
+
+      if (operator === '|') {
+        const arm = currentArm();
+        if (!arm.hasContent) hasEmptyAlternationArm = true;
+        arm.sawAlternation = true;
+        arm.hasContent = false;
+      } else if (operator === '(') {
+        armStack.push({ hasContent: false, sawAlternation: false });
+      } else if (operator === ')') {
+        const closed = closeAlternationContext();
+        if (armStack.length > 1) {
+          armStack.pop();
+          if (closed.hasContent) markContent();
+        }
+      }
+
+      translated += operator === '?' ? rawEscape : operator;
+    } else {
+      translated += rawEscape;
+      if (!ZERO_WIDTH_ESCAPES.has(escaped)) markContent();
+    }
+    i = escapedIndex;
+  }
+
+  for (const arm of armStack) {
+    if (arm.sawAlternation && !arm.hasContent) hasEmptyAlternationArm = true;
+  }
+  if (operators.size === 0) return null;
+  return {
+    operators: [...operators].map(op => BRE_OPERATOR_LABELS[op]),
+    retryable,
+    translated,
+    translationAmbiguous: hasBareDivergentMetachar
+      || hasAmbiguousEscapeRun
+      || hasEmptyAlternationArm
+      || (hasEscapedQuestion && retryable),
+  };
+}
+
+/**
+ * @param {string} pattern
+ * @param {{ fixedString?: boolean }} [options]
+ * @returns {{ operators: string[] } | null}
+ */
+export function detectBreDialectHint(pattern, { fixedString = false } = {}) {
+  const inspection = inspectBreDialect(pattern, { fixedString });
+  return inspection ? { operators: inspection.operators } : null;
+}
+
+/**
+ * Translate only unambiguous GNU BRE operator spellings used by agents.
+ * Closing group/interval escapes are translated with their opening operator.
+ * `\?` remains diagnostic-only because it is too commonly used literally.
+ *
+ * @param {string} pattern
+ * @param {{ fixedString?: boolean }} [options]
+ * @returns {{ pattern: string, operators: string[] } | null}
+ */
+export function translateBreToRustRegex(pattern, { fixedString = false } = {}) {
+  const inspection = inspectBreDialect(pattern, { fixedString });
+  if (!inspection?.retryable || inspection.translationAmbiguous || inspection.translated === pattern) {
+    return null;
+  }
+  try {
+    if (new RegExp(inspection.translated).test('')) return null;
+  } catch { /* JavaScript cannot parse every Rust-valid regex; structural guards still apply. */ }
+  return { pattern: inspection.translated, operators: inspection.operators };
+}
+
+function collectCandidateMatches(candidateResult) {
+  return [
+    ...(candidateResult?.indexedMatches || []),
+    ...(candidateResult?.overlayMatches || []),
+  ];
+}
+
+function sumNumericFields(original = {}, retried = {}, selected = {}) {
+  const merged = { ...selected };
+  for (const key of ADDITIVE_RETRY_STATS) {
+    const left = Number.isFinite(original[key]) ? original[key] : 0;
+    const right = Number.isFinite(retried[key]) ? retried[key] : 0;
+    if (Number.isFinite(original[key]) || Number.isFinite(retried[key])) merged[key] = left + right;
+  }
+
+  const stageKeys = new Set([
+    ...Object.keys(original.stageTiming || {}),
+    ...Object.keys(retried.stageTiming || {}),
+  ]);
+  if (stageKeys.size > 0) {
+    merged.stageTiming = { ...(selected.stageTiming || {}) };
+    for (const key of stageKeys) {
+      const left = Number.isFinite(original.stageTiming?.[key]) ? original.stageTiming[key] : 0;
+      const right = Number.isFinite(retried.stageTiming?.[key]) ? retried.stageTiming[key] : 0;
+      merged.stageTiming[key] = left + right;
+    }
+  }
+  return merged;
+}
+
+function withMergedRetryStats(selected, original, retried) {
+  if (!selected?.stats && !original?.stats && !retried?.stats) return selected;
+  return {
+    ...selected,
+    stats: sumNumericFields(original?.stats, retried?.stats, selected?.stats),
+  };
+}
+
+function isRegexSyntaxError(error) {
+  const messages = [];
+  for (let current = error; current && messages.length < 3; current = current.cause) {
+    messages.push(current instanceof Error ? current.message : String(current));
+  }
+  return /invalid regex|regex parse error|error parsing regex|regex syntax|repetition operator|unclosed (?:group|character class)|unmatched (?:closing|parenthesis)/i
+    .test(messages.join('\n'));
+}
+
+/**
+ * Run one agent-only BRE respelling retry after the caller's final result
+ * shaping reports zero matches. The supplied shaper is reused for the retry so
+ * hint counts and adoption always describe the matches the caller can return.
+ *
+ * @param {{
+ *   pattern: string,
+ *   fixedString?: boolean,
+ *   agentFormat?: boolean,
+ *   originalResult: object,
+ *   shapeResult?: (candidateResult: object) => Array,
+ *   retry: (translatedPattern: string) => Promise<object>,
+ * }} options
+ * @returns {Promise<{
+ *   candidateResult: object,
+ *   matches: Array,
+ *   regexDialectHint: object|null,
+ * }>}
+ */
+export async function retryBreDialectAfterZero({
+  pattern,
+  fixedString = false,
+  agentFormat = false,
+  originalResult,
+  shapeResult = collectCandidateMatches,
+  retry,
+}) {
+  const originalMatches = shapeResult(originalResult);
+  if (!agentFormat || originalMatches.length > 0) {
+    return { candidateResult: originalResult, matches: originalMatches, regexDialectHint: null };
+  }
+
+  const fallbackHint = detectBreDialectHint(pattern, { fixedString });
+  const translation = translateBreToRustRegex(pattern, { fixedString });
+  if (!translation) {
+    return { candidateResult: originalResult, matches: originalMatches, regexDialectHint: fallbackHint };
+  }
+
+  try {
+    const retried = await retry(translation.pattern);
+    const retriedMatches = shapeResult(retried);
+    const retryMatched = retriedMatches.length > 0;
+    const selected = retryMatched ? retried : originalResult;
+    return {
+      candidateResult: withMergedRetryStats(selected, originalResult, retried),
+      matches: retryMatched ? retriedMatches : originalMatches,
+      regexDialectHint: {
+        operators: translation.operators,
+        retryAttempted: true,
+        retryMatched,
+        retryMatches: retriedMatches.length,
+        translatedPattern: translation.pattern,
+      },
+    };
+  } catch (error) {
+    if (!isRegexSyntaxError(error)) throw error;
+    return { candidateResult: originalResult, matches: originalMatches, regexDialectHint: fallbackHint };
+  }
+}
+
+/**
+ * @param {{
+ *   operators?: string[], retryAttempted?: boolean, retryMatched?: boolean,
+ *   retryMatches?: number, translatedPattern?: string,
+ * } | null | undefined} hint
+ * @returns {string}
+ */
+export function renderRegexDialectHint(hint) {
+  const operators = Array.isArray(hint?.operators) ? hint.operators : [];
+  if (operators.length === 0) return '';
+  if (hint.retryAttempted) {
+    if (hint.retryMatched) {
+      const count = Number.isInteger(hint.retryMatches) ? hint.retryMatches : 0;
+      return `regex note: zero-hit GNU BRE operators were retried with unescaped Rust operators; ` +
+        `showing ${count} retry match${count === 1 ? '' : 'es'}.`;
+    }
+    return 'regex note: GNU BRE operators were retried with unescaped Rust operators; both forms returned 0 matches.';
+  }
+  if (operators.includes('\\|')) {
+    return 'regex note: Rust syntax treats \\| as a literal pipe; use | for alternation ' +
+      '(or -F for a literal search). The original pattern was used unchanged.';
+  }
+  return `regex note: Rust syntax uses unescaped operators (${operators.join(', ')}); ` +
+    'escaped forms match punctuation. The original pattern was used unchanged.';
+}

package/core/search/search-format.js

@@ -13,6 +13,102 @@
 // Result formatting
 // =============================================================================
 
+const ROUTE_META_MARKER = '<<SS_ROUTE_META>>';
+const COMPACT_ROUTE_RE = /^route=([A-Za-z0-9_.:-]+) confidence=([A-Za-z0-9_.:-]+) sufficient=(YES|no|unknown) reason=([A-Za-z0-9_.:-]+) repo=(ok|mismatch|unknown) results=(\d+)\s*$/gm;
+const AGENT_HEADER_RE = /^#\s*ss-search:\s*routed=([A-Za-z0-9_.:-]+)(?:\s+conf=([-+]?(?:\d+(?:\.\d+)?|\.\d+)))?\s+budget=(\d+)\s+used=(\d+)\s+results=(\d+)\s+subMode=([A-Za-z0-9_.:-]+)\s*$/m;
+
+function routeAtom(value, fallback = 'unknown') {
+  if (value == null || value === '') return fallback;
+  const atom = String(value).trim().replace(/[^A-Za-z0-9_.:-]+/g, '_');
+  return atom.slice(0, 96) || fallback;
+}
+
+function routeSufficiency(meta) {
+  if (meta.sufficiencyVerdict === 'yes') return 'YES';
+  if (meta.sufficiencyVerdict === 'no' || meta.sufficiencyVerdict === 'unknown') {
+    return meta.sufficiencyVerdict;
+  }
+  if (meta.sufficient === true) return 'YES';
+  if (meta.sufficient === false) return 'no';
+  return 'unknown';
+}
+
+/**
+ * Serialize route metadata for an output surface.
+ *
+ * Agent output receives only fields that can change the next action. Debug
+ * and non-agent callers retain the complete machine-readable object.
+ */
+export function formatRouteMetadata(meta = {}, opts = {}) {
+  const routeMeta = meta && typeof meta === 'object' && !Array.isArray(meta) ? meta : {};
+  if (!opts._isAgentFormat || opts.debug === true) {
+    return `${ROUTE_META_MARKER}${JSON.stringify(routeMeta)}`;
+  }
+
+  const repo = routeMeta.repoMatches === true
+    ? 'ok'
+    : routeMeta.repoMatches === false ? 'mismatch' : 'unknown';
+  const count = Number.isInteger(routeMeta.resultCount) && routeMeta.resultCount >= 0
+    ? routeMeta.resultCount
+    : 0;
+  const reason = routeMeta.sufficiencyReason || routeMeta.error;
+
+  return [
+    `route=${routeAtom(routeMeta.routedMode ?? routeMeta.mode)}`,
+    `confidence=${routeAtom(routeMeta.confidence)}`,
+    `sufficient=${routeSufficiency(routeMeta)}`,
+    `reason=${routeAtom(reason)}`,
+    `repo=${repo}`,
+    `results=${count}`,
+  ].join(' ');
+}
+
+/**
+ * Parse either the complete debug marker or the compact agent contract.
+ * Header telemetry is merged into compact metadata without requiring the
+ * verbose JSON to be present in agent context.
+ */
+export function parseRouteMetadata(text) {
+  const source = typeof text === 'string' ? text : '';
+  const full = source.match(/<<SS_ROUTE_META>>(\{[^\r\n]*\})/);
+  if (full) {
+    try {
+      const parsed = JSON.parse(full[1]);
+      return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // Search result bodies can contain arbitrary source text. Prefer the final
+  // trailer-shaped line because the engine appends its metadata after results.
+  const compactMatches = [...source.matchAll(COMPACT_ROUTE_RE)];
+  const compact = compactMatches.at(-1);
+  if (!compact) return null;
+
+  const verdict = compact[3] === 'YES' ? 'yes' : compact[3];
+  const meta = {
+    routedMode: compact[1],
+    serverUsed: true,
+    repoMatches: compact[5] === 'ok' ? true : compact[5] === 'mismatch' ? false : null,
+    resultCount: Number.parseInt(compact[6], 10),
+    confidence: compact[2],
+    sufficient: verdict === 'yes' ? true : verdict === 'no' ? false : null,
+    sufficiencyVerdict: verdict,
+    sufficiencyReason: compact[4] === 'unknown' ? null : compact[4],
+  };
+
+  const header = source.match(AGENT_HEADER_RE);
+  if (header) {
+    const routeConfidence = header[2] == null ? null : Number.parseFloat(header[2]);
+    if (Number.isFinite(routeConfidence)) meta.routeConfidence = routeConfidence;
+    meta.tokenBudget = Number.parseInt(header[3], 10);
+    meta.tokensUsed = Number.parseInt(header[4], 10);
+    meta.subMode = header[6];
+  }
+  return meta;
+}
+
 /**
  * Format structural results for display
  * Uses `this` — calls this methods (none currently, but kept as regular fn).

package/core/search/search-pattern.js

@@ -20,6 +20,8 @@ import { applyGrepFileDiversity, matchesGrepFileFilter } from './grep-output-sha
 import { isRipgrepAvailable, runRipgrepJson } from './search-pattern-ripgrep.js';
 import { ensureSparseGramIndex } from './search-pattern-prefilter.js';
 import { packageForAgent } from './context-expander.js';
+import { retryBreDialectAfterZero } from './regex-dialect.js';
+import { buildIndexedGrepFamilyManifest } from './agent-pack-completion.js';
 import { applyFileKindRanking, applyResultDemotions } from '../ranking/file-kind-ranking.js';
 
 // =============================================================================
@@ -126,6 +128,24 @@ async function ensureGrepEngineAvailable(searcher, options, label) {
   );
 }
 
+const AGENT_FORMATS = new Set(['agent', 'agent_preview', 'agent_full', 'agent_full_xl']);
+
+function isAgentFormat(options) {
+  return options?._isAgentFormat === true || AGENT_FORMATS.has(options?.format);
+}
+
+function shapeBareGrepMatches(candidateResult, symbolType, searcher, fileFilter) {
+  let matches = [
+    ...(candidateResult?.indexedMatches || []),
+    ...(candidateResult?.overlayMatches || []),
+  ];
+  matches = filterMatchesBySymbolType(matches, symbolType, searcher);
+  if (fileFilter) {
+    matches = matches.filter(match => matchesGrepFileFilter(match.file, fileFilter));
+  }
+  return matches;
+}
+
 // =============================================================================
 // Bare grep (wired onto SweetSearch.prototype)
 // =============================================================================
@@ -150,14 +170,24 @@ export async function bareGrep(query, routing, options = {}) {
   await ensureGrepEngineAvailable(this, options, 'Bare grep');
 
   // Disable chunk gram for bare grep — bare grep uses file:line matches, not chunk IDs.
-  const candidateResult = await generateRegexMatches(this || {}, regex, searchDir, options);
-  let matches = [...candidateResult.indexedMatches, ...candidateResult.overlayMatches];
-  matches = filterMatchesBySymbolType(matches, symbolType, this);
-  // Agent drill-in scope (--in <file>): applied BEFORE sort/cap so a
-  // late-alphabet file's matches can never be pre-clipped by maxMatches.
-  if (options.fileFilter) {
-    matches = matches.filter(m => matchesGrepFileFilter(m.file, options.fileFilter));
-  }
+  let candidateResult = await generateRegexMatches(this || {}, regex, searchDir, options);
+  const shapeResult = result => shapeBareGrepMatches(
+    result, symbolType, this, options.fileFilter,
+  );
+  const dialectRetry = await retryBreDialectAfterZero({
+    pattern: regex,
+    fixedString: options.fixedString,
+    agentFormat: isAgentFormat(options),
+    originalResult: candidateResult,
+    shapeResult,
+    retry: translatedPattern => generateRegexMatches(
+      this || {}, translatedPattern, searchDir, options,
+    ),
+  });
+  candidateResult = dialectRetry.candidateResult;
+  // Symbol and --in filtering happen before retry adoption and before sort/cap,
+  // so hint counts always describe the matches this call can actually return.
+  let matches = dialectRetry.matches;
   matches.sort((a, b) =>
     a.file.localeCompare(b.file) ||
     a.line - b.line ||
@@ -165,6 +195,7 @@ export async function bareGrep(query, routing, options = {}) {
   );
 
   const totalMatches = matches.length;
+  const regexDialectHint = dialectRetry.regexDialectHint;
   // Agent-only k-budget file diversity (option-gated; absent → byte-identical
   // output). Streaming per-file cap: matches beyond the cap are counted, not
   // stored, so memory is bounded by perFileCap*maxFiles, never total matches.
@@ -183,10 +214,14 @@ export async function bareGrep(query, routing, options = {}) {
     projectRoot: searchDir,
     contextLines: options.contextLines ?? 0,
   });
+  const familyManifest = options._isAgentFormat === true && !options.fileFilter
+    ? buildIndexedGrepFamilyManifest(results, this?.codeGraphRepo)
+    : null;
 
   return {
     results,
     ...(fileSummary ? { fileSummary } : {}),
+    ...(familyManifest ? { familyManifest } : {}),
     stats: {
       path: 'grep',
       regex,
@@ -214,6 +249,7 @@ export async function bareGrep(query, routing, options = {}) {
       plannerRoute: candidateResult.stats.plannerRoute,
       gramSelectivity: candidateResult.stats.gramSelectivity,
       nativeGrepUsed: candidateResult.stats.nativeGrepUsed,
+      ...(regexDialectHint && { regexDialectHint }),
       symbolType,
       total_ms: Math.round(performance.now() - start),
       stageTiming: candidateResult.stats.stageTiming || null,
@@ -276,7 +312,7 @@ export async function patternSearch(query, routing, options = {}) {
   log(`Query: "${effectiveQuery}"`);
 
   const parallelStart = performance.now();
-  const [candidateResult, encodedQuery] = await Promise.all([
+  let [candidateResult, encodedQuery] = await Promise.all([
     generateRegexMatches(this, regex, searchDir, { ...options, lightweightParse: true }),
     (async () => {
       const encodeStart = performance.now();
@@ -288,11 +324,23 @@ export async function patternSearch(query, routing, options = {}) {
     })(),
   ]);
   const parallelTime = performance.now() - parallelStart;
+  const retryOptions = { ...options, lightweightParse: true };
+  const dialectRetry = await retryBreDialectAfterZero({
+    pattern: regex,
+    fixedString: options.fixedString,
+    agentFormat: isAgentFormat(options),
+    originalResult: candidateResult,
+    retry: translatedPattern => generateRegexMatches(
+      this, translatedPattern, searchDir, retryOptions,
+    ),
+  });
+  candidateResult = dialectRetry.candidateResult;
   const grepMatches = candidateResult.indexedMatches;
   const overlayMatches = candidateResult.overlayMatches;
   const queryTokens = encodedQuery.tokens;
   const encodeTime = encodedQuery.encodeTime;
   const totalRawMatches = grepMatches.length + overlayMatches.length;
+  const regexDialectHint = dialectRetry.regexDialectHint;
   log(
     `Parallel phase: ${totalRawMatches} grep matches ` +
     `(${grepMatches.length} indexed, ${overlayMatches.length} overlay), ` +
@@ -328,13 +376,15 @@ export async function patternSearch(query, routing, options = {}) {
       prefilterDiscardedCount: candidateResult.stats.prefilterDiscardedCount,
       grepStrategy: candidateResult.stats.grepStrategy,
       parallelTime_ms: Math.round(parallelTime),
+      ...(regexDialectHint && { regexDialectHint }),
       total_ms: Math.round(performance.now() - start),
     };
 
     // Agent mode: return proper agent schema even for zero results
     if (format === 'agent' || format === 'agent_preview' || format === 'agent_full' || format === 'agent_full_xl') {
       const agentResponse = packageForAgent([], emptyStats, {
-        query, regex, mode: 'pattern', format, tokenBudget, ablations, projectRoot: this.projectRoot || PROJECT_ROOT,
+        query, regex, mode: 'pattern', format, tokenBudget, ablations,
+        projectRoot: this.projectRoot || PROJECT_ROOT, _isAgentFormat: true,
       });
       agentResponse.stats = emptyStats;
       return agentResponse;
@@ -530,6 +580,7 @@ export async function patternSearch(query, routing, options = {}) {
     grepStrategy: candidateResult.stats.grepStrategy,
     plannerRoute: candidateResult.stats.plannerRoute,
     trackerLastIndex: candidateResult.stats.trackerLastIndex,
+    ...(regexDialectHint && { regexDialectHint }),
     total_ms: Math.round(totalTime),
     allCandidateIds,
     allMappedChunkIds,
@@ -549,6 +600,7 @@ export async function patternSearch(query, routing, options = {}) {
       locationMap,
       projectRoot: searchDir,
       ablations,
+      _isAgentFormat: true,
     });
     agentResponse.stats = stats;
     return agentResponse;