sweet-search 2.6.16 → 2.7.0

package/README.md

@@ -23,7 +23,7 @@ Every coding agent today reaches for grep + Read by reflex. *sweet-search* chall
 ## ✨ Highlights
 
 - **Hybrid retrieval** — one of the six tools uses BM25F lexical + dense semantic + structural graph signals, fused per query and reranked by late-interaction
-- **Agent-native by design** — token-budgeted output tiers, an optional MCP server (and default zero-overhead CLI), and a GEPA-evolved system prompt installed into Claude Code, Codex, Gemini CLI, and Cursor with one command
+- **Agent-native by design** — token-budgeted output tiers, an optional MCP server (and default zero-overhead CLI), and a GEPA-evolved system prompt — one `init` installs it into Claude Code by default (Codex, Gemini CLI, and Cursor via flags)
 - **Indexed grep, ~10× faster than ripgrep** — a sparse n-gram prefilter skips the files that provably can't match
 - **ColBERT-style reranking, locally** — per-token MaxSim late interaction on hand-written SIMD kernels
 - **GPU-accelerated indexing** — Apple Metal, CUDA, CoreML Neural Engine, or plain CPU via ORT; same engine, auto-selected
@@ -263,6 +263,7 @@ We're SOTA in June 2026 on 3/4 attempted benchmarks at HARDER settings (running
 - **Reproduction:** result artifacts live in [`eval/results/`](eval/results/); rerun via `eval/run_all.js`. The canonical full-pool loaders are in `eval/download_data.py`.
 - **Full corpus, not distractors.** Published baselines for GCSN- and CoSQA-style benchmarks typically rank the gold against 99 sampled distractors; every number here ranks against the benchmark's *full* corpus (6k–19k candidates) — strictly harder.
 - **Zero-shot + docstring-stripped.** We never fine-tune on these tasks. For docstring-derived benchmarks (AdvTest, M2CRB) we strip the docstring from the indexed code — otherwise the NL query matches itself verbatim (a no-strip AdvTest run scores a meaningless 0.98). This is the standard protocol; it is also why our AdvTest is lower than naïve setups that leave the docstring in.
+- **Dev/held-out split.** Our ranking work iterates against a fixed dev split of each benchmark (e.g. GCSN: 600 dev + 400 held-out per language, stratified, seed=42) and treats the remainder as held-out, inspected aggregate-only at milestones. The table figures are full-corpus runs — they include the dev portion we tuned against; a held-out-only breakdown ships with the next results refresh.
 - **What we deliberately don't claim yet.** CoIR (official metric NDCG@10 over per-subtask corpora up to ~1M docs), CoSQA+ (multi-positive, MAP-primary), and CLARC (per-group pools) use protocols and metrics our single-pool MRR@10 harness doesn't currently match. Rather than publish apples-to-oranges numbers, we omit them; faithful per-subtask CoIR (NDCG@10) runs are queued.
 - **M2CRB** — the paper's metric is *auMRRc* (area under the MRR-vs-pool-size curve; best published **52.7**, fine-tuned). Because that area averages over easier small pools, `auMRRc ≥ full-pool MRR` for any model — so our **54.0 full-pool MRR@10** (all 5,795 functions, zero-shot) clears their best on a strictly harder measure. No one publishes a plain full-corpus MRR@10 on M2CRB, so ours is the best available.
 - **AdvTest honesty note.** We could not reproduce the commonly-cited 59.5 for the bare CodeRankEmbed encoder on our corpus: the reference FP32 model scores 54.7 on our leak-free, docstring-stripped, full-19,210 setup, and our shipped INT8 build 51.4. We report our measured numbers and the reference check rather than the leaderboard figure.
@@ -399,7 +400,7 @@ flowchart TD
 | 🎯 **Intent Rerank** | • demote docs / tests / config when you want implementation<br/>• log-scaled call-site boosts surface the most-referenced function |
 | 🕸️ **Graph Expansion** | • typed-edge walks (`imports`/`extends`/`calls`/`uses`) · adaptive 2-hop on the AST graph · edges picked by intent<br/>• **PathRAG** flow pruning + degree normalization → hubs can't dominate |
 | 🧮 **Late interaction Rerank** | • Query embedded per-token by **LateOn-Code** (149M; a 17M **edge** variant auto-selected on low-RAM hosts)<br/>• **MaxSim** against the pre-indexed quantized token vectors<br/>• native Rust+Rayon MaxSim kernel ⚡ · WASM-SIMD fallback (1.26 s → 27 ms on a 231-candidate rerank) |
-| 📦 **Package** | • entity-aware expansion → whole functions (imports, docstrings, decorators)<br/>• same-file overlap demotion → diverse, non-overlapping spans<br/>• auto-selected **3k / 8k / 12k** token budget |
+| 📦 **Package** | • entity-aware expansion → whole functions (imports, docstrings, decorators)<br/>• same-file overlap demotion → diverse, non-overlapping spans<br/>• **symbol-family completion** (agent mode) — generated/width families surface as a compact indexed manifest instead of truncating silently, inside the same budget<br/>• auto-selected **3k / 8k / 12k** token budget |
 
 <details>
 <summary><b>🌶️ Extra spice — the bits that didn't fit the diagram</b></summary>
@@ -418,7 +419,7 @@ flowchart TD
 - **Quality priors:** every chunk carries a 0–1 prior from test proximity, git recency, symbol centrality (PageRank), comment density, and complexity — production code surfaces, stale fixtures sink.
 - **Community structure:** a canonical **Leiden** pass detects code communities on the entity graph at index time, feeding vocabulary prewarming and structural signals — it understands your modules, not just your directories.
 - **Multilingual:** 14 languages get full tree-sitter AST treatment; a 39-config registry covers 70+ extensions beyond that. Router features handle camelCase/snake_case, CJK density, and German compounds.
-- **Format-gated signals:** structure-aware boosts and demotions (symbol-exact, path-token, mega-entity) fire only in agent mode — they help agent-shaped queries and would hurt plain NL, so they stay gated by default.
+- **Format-gated signals:** structure-aware boosts and demotions (symbol-exact, path-token, anomalous-chunk, mega-entity) fire only in agent mode — they help agent-shaped queries and would hurt plain NL, so they stay gated by default.
 
 **🛟 Rescues & honest trade-offs.**
 - **Long-query rescue:** wordy NL queries that FTS5 would tokenize into an unsatisfiable `AND` fall back to multi-query BM25F + RRF — one query per content keyword, fused.
@@ -449,6 +450,7 @@ Every match comes back in stable `file:line` order — ripgrep-identical counts,
 
 - Full methodology, per-repo table, and the optimization log: [`docs/GREP_INDEXING_STRATEGY.md`](docs/GREP_INDEXING_STRATEGY.md).
 - Regexes with no extractable literals fall back to native grep over the indexed file set; fixed-string and glob queries use a ripgrep fallback.
+- **Dialect recovery** (agent mode): patterns written in GNU-grep BRE muscle memory (`foo\|bar`, `\(group\)`) are literals in Rust's regex dialect and used to silently match nothing — a zero-hit exact search now gets one gated auto-retry with the translated pattern instead of a false "no matches".
 
 </details>
 
@@ -553,6 +555,8 @@ without another search.
 <summary><b>More</b></summary>
 
 - The CLI/MCP form scales it up: `sweet-search read <file...>` (and the `read` MCP tool) batches **1–20 files in a single call**, each with the same symbol metadata — twenty files for the price of one tool invocation.
+- **Query-aware continuation** (agent mode): a range read that stops before EOF names the unread symbols below it — ranked by relevance to the session's recent queries, not just declaration order — plus the exact command to continue.
+- **Shown-span receipts** (agent mode, default-on): the daemon remembers what a session has already been shown; an exact re-read collapses to a one-line receipt instead of resending the bytes.
 
 </details>
 

package/core/graph/structural-context-format.js

@@ -4,6 +4,11 @@ export function formatStructuralContext(result) {
   const lines = [];
   lines.push(`# trace ${t.name} [${t.type}] ${t.filePath}:${t.startLine}-${t.endLine}`);
   lines.push(`fan-in=${t.fanIn} fan-out=${t.fanOut} budget=${result.tokensUsed}/${result.tokenBudget} (${result.budgetTier}:${result.budgetReason}) latency=${result.stats.latencyMs}ms`);
+  if (t.fanIn === 0 && t.fanOut === 0 && !result.sections.callers.total && !result.sections.callees.total) {
+    lines.push(`no stored call edges for this symbol — map its sites with one broad ss-grep of the symbol stem instead.`);
+  } else if (t.fanIn === 0 && result.sections.callers.total > 0) {
+    lines.push(`note: callers below come from a same-file source scan (no stored cross-file edges).`);
+  }
   if (result.disambiguation.length) {
     lines.push(`ambiguous: using first match; alternatives: ${result.disambiguation.slice(0, 5).map(a => `${a.name} ${a.file}:${a.startLine}`).join(', ')}`);
   }

package/core/graph/structural-context.js

@@ -7,6 +7,7 @@
 
 import { DB_PATHS } from '../infrastructure/config/index.js';
 import { StructuralContextRepository } from '../infrastructure/structural-context-repository.js';
+import { isLikelyCodeEntity } from '../infrastructure/structural-context-utils.js';
 import { buildAnswerCues } from './structural-answer-cues.js';
 import { callsiteHints } from './structural-callsite-hints.js';
 import { extractHeaderContext } from './structural-header-context.js';
@@ -249,7 +250,7 @@ function addHintImpactPaths(paths, seen, repo, target, hints, limit) {
   for (const name of hints) {
     if (paths.length >= limit) break;
     const hint = repo.findEntityCandidates?.(name, { limit: 1 })?.[0];
-    if (!hint || hint.id === target.id) continue;
+    if (!hint || hint.id === target.id || !isLikelyCodeEntity(hint)) continue;
     const id = `hint:${target.id}>${hint.id}`;
     if (!seen.has(id)) {
       paths.push({ id, direction: 'downstream', path: [target, hint], edgeTypes: ['handoff'], depth: 1 });
@@ -301,9 +302,18 @@ export class StructuralContextBuilder {
     const targetSource = readFileRange(target.filePath, target.startLine, target.endLine);
     const targetHeaderContext = extractHeaderContext(readFileRange, target.filePath);
     const targetCallsiteHints = callsiteHints(targetSource, new Set([target.name]));
-    const callersRaw = [...this.repo.getCallers(target, { limit: 160 }), ...(this.repo.getAliasCallers?.(target, { limit: 80 }) || [])].map(x => ({ ...x, depth: 1 }));
+    const storedCallers = [...this.repo.getCallers(target, { limit: 160 }), ...(this.repo.getAliasCallers?.(target, { limit: 80 }) || [])];
+    // Same-file callsite scan: recovers callers the extractor stored no edge
+    // for (bare local calls, out-of-line C++ methods). Deduped against stored
+    // callers by entity id — a stored edge may carry a different context_line
+    // for the same call (multi-line invocations), and a same-entity duplicate
+    // would double-pack the caller section.
+    const storedIds = new Set(storedCallers.map(x => x.id));
+    const sameFileCallers = (this.repo.getSameFileCallers?.(target, { limit: 24 }) || [])
+      .filter(x => !storedIds.has(x.id));
+    const callersRaw = [...storedCallers, ...sameFileCallers].map(x => ({ ...x, depth: 1 }));
     let calleesRaw = this.repo.getCallees(target, { limit: 160 }).map(x => ({ ...x, depth: 1 }));
-    if (!calleesRaw.length) calleesRaw = targetCallsiteHints.map(name => this.repo.findEntityCandidates?.(name, { limit: 1 })?.[0]).filter(Boolean).map(x => ({ ...x, relationship: 'handoff', depth: 1 }));
+    if (!calleesRaw.length) calleesRaw = targetCallsiteHints.map(name => this.repo.findEntityCandidates?.(name, { limit: 1 })?.[0]).filter(isLikelyCodeEntity).map(x => ({ ...x, relationship: 'handoff', depth: 1 }));
     const impactRaw = buildImpactPaths(this.repo, target, {
       maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
       limit: 120,

package/core/infrastructure/code-graph-repository.js

@@ -13,6 +13,10 @@ import { existsSync, statSync } from 'fs';
 import { applyReadPragmas, prepareCached } from './db-utils.js';
 import { readAdjacentManifest, resolveManifestCodeGraphPath, sqlAliasPrefix } from './code-graph-visibility.js';
 
+function pathIsUnsafe(value) {
+  return value.startsWith('/') || value === '..' || value.startsWith('../') || value.includes('/../');
+}
+
 export class CodeGraphRepository {
   constructor(dbPath, options = {}) {
     this._baseDbPath = dbPath;
@@ -383,6 +387,60 @@ export class CodeGraphRepository {
     }
   }
 
+  /**
+   * Find exact indexed symbol-family candidates under a bounded directory.
+   * The search domain supplies an identifier stem discovered from indexed
+   * seeds; this adapter performs only parameterized persistence work.
+   *
+   * @param {string} stem - alphanumeric identifier fragment (3-64 chars)
+   * @param {{ filePrefix:string, types?:string[], limit?:number }} opts
+   * @returns {Array<{id,name,type,filePath,startLine,endLine,parentClass}>}
+   */
+  findFamilyCandidates(stem, opts = {}) {
+    const db = this._open();
+    if (!db || typeof stem !== 'string' || !/^[A-Za-z][A-Za-z0-9]{2,63}$/.test(stem)) return [];
+    const prefix = typeof opts.filePrefix === 'string'
+      ? opts.filePrefix.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '')
+      : '';
+    if (!prefix || prefix === '.' || pathIsUnsafe(prefix)) return [];
+    const types = Array.isArray(opts.types)
+      ? [...new Set(opts.types.filter((type) => typeof type === 'string' && /^[A-Za-z][\w-]{0,31}$/.test(type)))].slice(0, 16)
+      : [];
+    const limit = Math.max(1, Math.min(128, opts.limit ?? 64));
+    const escapeLike = (value) => value.replace(/[\\%_]/g, '\\$&');
+    try {
+      const typeSql = types.length > 0 ? `AND type IN (${types.map(() => '?').join(',')})` : '';
+      const sql = `
+        SELECT id, name, type, file_path, start_line, end_line, parent_class
+        FROM entities
+        WHERE lower(name) LIKE lower(?) ESCAPE '\\'
+          AND file_path LIKE ? ESCAPE '\\'
+          ${typeSql}
+          AND ${this._entityVisibilitySql(db)}
+        ORDER BY name ASC, file_path ASC, start_line ASC
+        LIMIT ?
+      `;
+      const args = [
+        `%${escapeLike(stem)}%`,
+        `${escapeLike(prefix)}/%`,
+        ...types,
+        ...this._entityVisibilityParams(db),
+        limit,
+      ];
+      return prepareCached(db, sql).all(...args).map((row) => ({
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        filePath: row.file_path,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        parentClass: row.parent_class || null,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
   /**
    * Get a single entity by id, with file:line metadata.
    *

package/core/infrastructure/language-patterns/registry-core.js

@@ -313,6 +313,20 @@ export const CORE_LANGUAGES = {
         function: /^(?:[\w:*&<>\s]+)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
         typedef: /^(?:typedef|using)\s+.+\s+(\w+)/,
         enum: /^enum\s+(?:class\s+)?(\w+)/,
+        // Out-of-line qualified member definitions — `Type Class::method(...)`
+        // — the dominant C++ idiom for .cpp files, previously invisible to the
+        // graph (botan's GeneralName::matches_dns / Name_Constraints::validate,
+        // E2 in the 2026-07-07 trace audit). Additive only: existing patterns
+        // above win first (one entity per line), so no current entity changes.
+        // Requires a return-type token before the qualified name (rules out
+        // statement-position calls `Foo::bar(x);`) and rejects `;` after `(`
+        // (rules out prototypes and single-line calls); tolerates params
+        // continuing on the next line and `{` on its own line (Allman style).
+        method: /^(?:template\s*<[^<>]*>\s*)?(?!(?:return|if|while|for|switch|case|throw|delete|new|else|do|goto|using|typedef|catch)\b)[\w:*&<>~,\[\]\s]*?[\w>&*]\s+[*&]?(?:\w+(?:<[^<>]*>)?::)+(~?\w+)\s*\([^;]*(?:\)\s*(?:const)?\s*(?:noexcept(?:\([^()]*\))?)?\s*(?:override|final)?\s*(?:\{.*)?)?$/,
+        // Out-of-line constructors/destructors: `Class::Class(...)` /
+        // `Class::~Class(...)` — the backreference makes the class≡member
+        // equality the discriminator, so `std::sort(...)` never matches.
+        constructor: /^(?:template\s*<[^<>]*>\s*)?(?:\w+(?:<[^<>]*>)?::)*(\w+)(?:<[^<>]*>)?::~?\1\s*\([^;]*(?:\)\s*(?:noexcept(?:\([^()]*\))?)?\s*(?::\s*[\w({].*)?(?:\{.*)?)?$/,
       },
       relationships: {
         include: /^#include\s+[<"]([^>"]+)[>"]/,

package/core/infrastructure/model-fetcher.js

@@ -292,6 +292,13 @@ export async function fetchModelFile(hfId, filePath, destDir, options = {}) {
       if (startByte > 0) {
         headers['Range'] = `bytes=${startByte}-`;
       }
+      // HF 403s anonymous downloads from datacenter IPs (CI runners), even on
+      // public files. A read token lifts that. Only sent to huggingface.co —
+      // never to a custom hfEndpoint, which may be an untrusted mirror.
+      const hfToken = process.env.HF_TOKEN || process.env.HUGGING_FACE_HUB_TOKEN;
+      if (hfToken && url.startsWith('https://huggingface.co/')) {
+        headers['Authorization'] = `Bearer ${hfToken}`;
+      }
 
       const resp = await fetch(url, { headers, signal });
 

package/core/infrastructure/structural-context-repository.js

@@ -6,10 +6,10 @@ import { applyReadPragmas } from './db-utils.js';
 import { findAliasCallers } from './structural-alias-resolver.js';
 import { rankStructuralCandidates } from './structural-candidate-ranker.js';
 import { findAssignedMemberDefinitions, findSameFileDefinition } from './structural-source-definitions.js';
-import { shouldTrustQualifiedResolution } from './structural-qualified-resolution.js';
+import { shouldTrustQualifiedResolution, trustedCallerEdge } from './structural-qualified-resolution.js';
 import { fetchPageRank, fetchFrontierBackwardEdges, fetchFrontierForwardEdges } from './structural-graph-signals.js';
 import { CodeGraphReaderVisibility } from './code-graph-visibility.js';
-import { callTargetAliases, clampLimit, isTestPath, lowerCamel, placeholders, qualifiedTargetName, rowToEntity } from './structural-context-utils.js';
+import { callTargetAliases, clampLimit, isLikelyCodeEntity, isTestPath, lowerCamel, placeholders, qualifiedTargetName, rowToEntity } from './structural-context-utils.js';
 
 export class StructuralContextRepository {
   constructor(dbPath, opts = {}) {
@@ -78,10 +78,13 @@ export class StructuralContextRepository {
       ORDER BY
         CASE WHEN file_path LIKE '%/test/%' OR file_path LIKE 'test/%' OR file_path LIKE 'tests/%' THEN 1 ELSE 0 END,
         length(name),
+        CASE WHEN end_line - start_line = 0 THEN 1 ELSE 0 END,
         (end_line - start_line) ASC
-      LIMIT 1
+      LIMIT 8
     `).all(...entityParams, ...names);
-    return this._entityFromRow(rows[0]);
+    const entity = rows.map(row => this._entityFromRow(row)).find(isLikelyCodeEntity) || null;
+    if (!entity) return null;
+    return shouldTrustQualifiedResolution(targetName, entity) ? entity : null;
   }
 
   _resolveQualifiedAlternative(targetName, excludeId) {
@@ -100,6 +103,7 @@ export class StructuralContextRepository {
       ORDER BY
         CASE WHEN file_path LIKE '%/test/%' OR file_path LIKE 'test/%' OR file_path LIKE 'tests/%' THEN 1 ELSE 0 END,
         CASE type WHEN 'method' THEN 0 WHEN 'function' THEN 1 ELSE 2 END,
+        CASE WHEN end_line - start_line = 0 THEN 1 ELSE 0 END,
         (end_line - start_line) ASC
       LIMIT 8
     `).all(...entityParams, name, excludeId);
@@ -165,6 +169,7 @@ export class StructuralContextRepository {
           WHEN 'function' THEN 2 WHEN 'method' THEN 2
           ELSE 3
         END,
+        CASE WHEN end_line - start_line = 0 THEN 1 ELSE 0 END,
         (end_line - start_line) ASC
       LIMIT ?
     `).all(...entityParams, ...params, raw, raw, limit);
@@ -215,7 +220,7 @@ export class StructuralContextRepository {
       SELECT DISTINCT
         e.id, e.name, e.type, e.file_path, e.start_line, e.end_line,
         e.signature, e.summary, e.parent_class, e.package,
-        r.context_line, r.target_name, r.weight, r.type as rel_type
+        r.target_id, r.context_line, r.target_name, r.weight, r.type as rel_type
       FROM relationships r
       JOIN entities e ON e.id = r.source_id
       WHERE r.type IN (${placeholders(types)})
@@ -237,9 +242,66 @@ export class StructuralContextRepository {
       ...this._entityFromRow(row),
       relationship: row.rel_type,
       contextLine: row.context_line || null,
+      targetId: row.target_id || null,
       targetName: row.target_name || null,
       weight: row.weight ?? 1,
-    }));
+    })).filter(edge => trustedCallerEdge(edge, target));
+  }
+
+  /**
+   * Query-time fallback for callers the extractor stored no edge for (bare
+   * local calls in JS/TS, out-of-line C++ methods, …): scan the target's own
+   * file for `name(` call sites outside the target's span and attribute each
+   * to its innermost enclosing entity. Cheap (one cached file read) and
+   * language-agnostic.
+   */
+  getSameFileCallers(target, opts = {}) {
+    const db = this._open();
+    if (!db || !target?.id || !target?.filePath || !target?.name || !target?.startLine) return [];
+    const limit = clampLimit(opts.limit, 24, 60);
+    const source = this.readFileRange(target.filePath, 1, 1000000);
+    if (!source) return [];
+    const escaped = String(target.name).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const callRe = new RegExp(`(?<![.\\w$:])${escaped}\\s*\\(`);
+    const defRe = new RegExp(`\\b(function|def|fn|func|sub|proc)\\s+${escaped}\\s*[(<]`);
+    const lines = source.split('\n');
+    const hits = [];
+    for (let i = 0; i < lines.length && hits.length < limit * 2; i++) {
+      const ln = i + 1;
+      if (ln >= target.startLine && ln <= (target.endLine || target.startLine)) continue;
+      const text = lines[i].replace(/(^|\s)(\/\/|#).*$/, '');
+      if (callRe.test(text) && !defRe.test(text)) hits.push(ln);
+    }
+    if (!hits.length) return [];
+    const entitySql = this._entitySql(db);
+    const fileEntities = db.prepare(`
+      SELECT id, name, type, file_path, start_line, end_line, signature,
+             summary, parent_class, package
+      FROM entities
+      WHERE ${entitySql} AND file_path = ? AND start_line IS NOT NULL AND end_line IS NOT NULL
+      ORDER BY start_line
+    `).all(...this._entityParams(db), target.filePath);
+    const out = [];
+    const seen = new Set();
+    for (const ln of hits) {
+      const host = fileEntities
+        .filter(r => r.start_line <= ln && r.end_line >= ln)
+        .sort((a, b) => (a.end_line - a.start_line) - (b.end_line - b.start_line))[0];
+      if (!host || host.id === target.id || host.name === target.name) continue;
+      const key = `${host.id}:${ln}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({
+        ...this._entityFromRow(host),
+        relationship: 'calls',
+        contextLine: ln,
+        targetId: target.id,
+        targetName: target.name,
+        weight: 1,
+      });
+      if (out.length >= limit) break;
+    }
+    return out;
   }
 
   getAliasCallers(target, opts = {}) {
@@ -326,6 +388,10 @@ export class StructuralContextRepository {
       LIMIT ?
     `).all(...this._entityParams(db), ...this._relationshipParams(db), ...types, ...ids, ...nameParams, limit);
 
+    // Rows admitted by the name-pattern clause (not by target_id) are subject
+    // to the same receiver-compat gate as getCallers — otherwise the phantom
+    // `this.fetch`-style edges re-enter through impact paths.
+    const idSet = new Set(ids);
     return rows.map(row => ({
       ...this._entityFromRow(row),
       relationship: row.rel_type,
@@ -333,7 +399,7 @@ export class StructuralContextRepository {
       targetName: row.target_name || null,
       contextLine: row.context_line || null,
       weight: row.weight ?? 1,
-    }));
+    })).filter(edge => (edge.targetId && idSet.has(edge.targetId)) || trustedCallerEdge(edge, target));
   }
 
   getForwardDependencies(frontierIds, opts = {}) {

package/core/infrastructure/structural-context-utils.js

@@ -49,3 +49,14 @@ export function isTestPath(filePath = '') {
 export function placeholders(values) {
   return values.map(() => '?').join(',');
 }
+
+// Entities extracted from config/doc files (TOML keys, YAML fields, …) are
+// valid search hits but must never be presented as call-graph neighbours —
+// a `calls` edge into stylua.toml is noise, not structure.
+const NON_CODE_FILE_RE = /\.(toml|ya?ml|json|json5|ini|cfg|conf|properties|lock|md|markdown|rst|txt|xml|html?|css|scss|svg)$/i;
+
+export function isLikelyCodeEntity(entity) {
+  if (!entity) return false;
+  if (entity.filePath && NON_CODE_FILE_RE.test(entity.filePath)) return false;
+  return true;
+}

package/core/infrastructure/structural-qualified-resolution.js

@@ -13,3 +13,32 @@ export function shouldTrustQualifiedResolution(targetName, entity) {
   const hay = `${entity.filePath || ''} ${entity.parentClass || ''} ${entity.package || ''} ${entity.signature || ''} ${entity.summary || ''}`.toLowerCase();
   return qualifierTerms(qualifier).some(term => hay.includes(term));
 }
+
+// Receivers that mean "the enclosing object", so a qualified edge like
+// `this.fetch` can only belong to a target in the SAME class or file as the
+// calling entity — never to an unrelated plain function that shares the name.
+const SELF_QUALIFIERS = new Set(['this', 'self', 'super', 'cls', 'me']);
+
+/**
+ * Caller-side twin of shouldTrustQualifiedResolution: decide whether a stored
+ * call edge (matched to `target` by name pattern) plausibly refers to that
+ * target. `edge` carries the CALLING entity's fields (filePath, parentClass)
+ * plus targetId/targetName from the relationship row.
+ */
+export function trustedCallerEdge(edge, target) {
+  const tn = String(edge?.targetName || '').trim();
+  if (!tn || !target?.name) return true;
+  if (edge.targetId && edge.targetId === target.id) return true;
+  const parts = tn.replace(/::/g, '.').split('.').filter(Boolean);
+  if (parts.length < 2) return true; // bare-name edge: exact match already
+  const qualifier = parts[parts.length - 2].toLowerCase();
+  if (SELF_QUALIFIERS.has(qualifier)) {
+    if (edge.filePath && target.filePath && edge.filePath === target.filePath) return true;
+    return !!(edge.parentClass && target.parentClass && edge.parentClass === target.parentClass);
+  }
+  const targetNames = [target.name, target.parentClass]
+    .filter(Boolean)
+    .map(s => String(s).toLowerCase());
+  if (targetNames.includes(qualifier)) return true;
+  return shouldTrustQualifiedResolution(tn, target);
+}

package/core/infrastructure/tree-sitter-provider.js

@@ -544,19 +544,60 @@ const TAGS_QUERIES = {
     (protocol_function_declaration name: (simple_identifier) @method.definition)
     (init_declaration) @method.definition
   `,
-  // C/C++: function name nested inside declarator chain
+  // C/C++: function name nested inside declarator chain. Captures are on the
+  // WHOLE function_definition node (not the identifier leaf) so entity spans
+  // cover the body — leaf captures gave start_line == end_line, which starved
+  // ss-trace targets of code. Names resolve via _cFunctionDefinitionName.
+  // Pointer-returning definitions (`char *foo(...)`) wrap the
+  // function_declarator in a pointer_declarator — captured separately.
   c: `
     (function_definition
       declarator: (function_declarator
-        declarator: (identifier) @function.definition))
+        declarator: (identifier))) @function.definition
+    (function_definition
+      declarator: (pointer_declarator
+        declarator: (function_declarator
+          declarator: (identifier)))) @function.definition
     (struct_specifier name: (type_identifier) @struct.definition)
     (enum_specifier name: (type_identifier) @enum.definition)
     (type_definition declarator: (type_identifier) @type.definition)
   `,
+  // C++ additionally has out-of-line qualified members
+  // (`Type Class::method(...)` — qualified_identifier), in-class definitions
+  // (field_identifier), and destructors — ALL previously invisible to the
+  // graph (E2, 2026-07-08 trace audit: botan's GeneralName::matches_dns and
+  // Name_Constraints::validate were untraceable). Patterns are mutually
+  // exclusive by declarator shape, so the startIndex:type dedupe never sees
+  // the same definition twice.
   cpp: `
     (function_definition
       declarator: (function_declarator
-        declarator: (identifier) @function.definition))
+        declarator: (identifier))) @function.definition
+    (function_definition
+      declarator: (function_declarator
+        declarator: (qualified_identifier))) @method.definition
+    (function_definition
+      declarator: (function_declarator
+        declarator: (field_identifier))) @method.definition
+    (function_definition
+      declarator: (function_declarator
+        declarator: (destructor_name))) @method.definition
+    (function_definition
+      declarator: (pointer_declarator
+        declarator: (function_declarator
+          declarator: (identifier)))) @function.definition
+    (function_definition
+      declarator: (pointer_declarator
+        declarator: (function_declarator
+          declarator: (qualified_identifier)))) @method.definition
+    (function_definition
+      declarator: (reference_declarator
+        (function_declarator
+          declarator: (identifier)))) @function.definition
+    (function_definition
+      declarator: (reference_declarator
+        (function_declarator
+          declarator: (qualified_identifier)))) @method.definition
     (class_specifier name: (type_identifier) @class.definition)
     (struct_specifier name: (type_identifier) @struct.definition)
     (enum_specifier name: (type_identifier) @enum.definition)
@@ -891,6 +932,7 @@ export class TreeSitterProvider {
         const symbolName = isLeafIdent
           ? node.text
           : (node.childForFieldName?.('name')?.text
+            || (C_FAMILY_LANGUAGES.has(languageId) ? this._cFunctionDefinitionName(node) : null)
             || this._extractNodeName(node)
             || `<anonymous:${entityType}>`);
 
@@ -1428,6 +1470,38 @@ export class TreeSitterProvider {
     return text.startsWith('///') || text.startsWith('/**');
   }
 
+  /**
+   * Resolve the leaf name of a C/C++ function_definition by walking its
+   * declarator chain: pointer/reference/parenthesized wrappers →
+   * function_declarator → identifier / field_identifier / destructor_name /
+   * operator_name / qualified_identifier (drilled to its leaf, so
+   * `ns::Class::method` yields `method`). Used ONLY by extractSymbols (graph
+   * entities) — chunker naming goes through _extractNodeName and is
+   * deliberately untouched so NL retrieval inputs stay byte-identical.
+   */
+  _cFunctionDefinitionName(node) {
+    if (!node || node.type !== 'function_definition') return null;
+    let d = node.childForFieldName?.('declarator');
+    for (let hops = 0; d && hops < 6; hops++) {
+      if (d.type === 'function_declarator') { d = d.childForFieldName?.('declarator'); break; }
+      const inner = d.childForFieldName?.('declarator')
+        || d.namedChildren?.find?.(c => /declarator/.test(c.type));
+      if (!inner) break;
+      d = inner;
+    }
+    for (let hops = 0; d && hops < 6; hops++) {
+      if (d.type === 'qualified_identifier') {
+        d = d.childForFieldName?.('name') || d.namedChildren?.[d.namedChildCount - 1];
+        continue;
+      }
+      if (/^(identifier|field_identifier|destructor_name|operator_name)$/.test(d.type)) {
+        return d.text || null;
+      }
+      break;
+    }
+    return null;
+  }
+
   /** Extract symbol name from an AST node */
   _extractNodeName(node) {
     // Try field name first (most reliable)

package/core/prompt-optimization/data/p7-final/sweet-search-system-prompt-mcp.md

@@ -1,15 +1,19 @@
 ---
 variant: mcp
-derived_from: p7-v1-mppppp
+derived_from: p7-v1-mppppp-fs
 source_prompt: core/prompt-optimization/data/p7-variant-restarts/p7-gen3-candidates/Mppppp.md
 benchmarked: false
 note: >-
-  Hand-derived MCP-tool variant of the M+++++ champion (p7-v1-mppppp = M++++ +
-  the verdict-gated trust line: trust rank 1 outright when the response
-  reports sufficiency yes, otherwise scan the already-delivered lower
-  ranks/same-file map before any new search; smoke-validated on the
+  Hand-derived MCP-tool variant of the M+++++ champion (p7-v1-mppppp-fs =
+  M++++ + the verdict-gated trust line: trust rank 1 outright when the
+  response reports sufficiency yes, otherwise scan the already-delivered
+  lower ranks/same-file map before any new search; smoke-validated on the
   task-completion bench, see memory
-  project_mppppp_conditional_trust_candidate). The STRATEGY core — routing by
+  project_mppppp_conditional_trust_candidate; + the P2 fix-surface paragraph:
+  before editing a symbol with visible siblings spend ONE mapping call —
+  trace, or one broad search regex on the stem — and read the edited
+  function to its end, single-site edits skip it; ported here against the
+  MCP tool surface, smoke codex-fixsurface-smoke10). The STRATEGY core — routing by
   what-you-hold, verdict-gated trust, sufficiency stops, the two-probe absence
   rule, the <state_summary> gate, and the search-output discipline — is
   preserved (semantics intact; the rest carries only the tool-mechanics
@@ -57,3 +61,5 @@ Before your third sweet-search probe in the current search iteration — or befo
 
 ## Search output
 Stop searching the instant your evidence answers what you're looking for — one confirmed file+symbol, or one named cross-file link, is enough; gather no corroboration you were not asked for. Name the file(s) and symbol(s) and how they answer what you need, or `no-match` — then finish whatever the task/prompt asks for.
+
+Before editing a symbol with visible siblings — multiple call sites, a name family (`IVec2`/`I64Vec2`), branch variants, a generated family — spend ONE mapping call: `trace` the symbol, or one broad `search` regex on the stem. Read the function you edit to its end; a fix covering only the first matching site is not done. Single-site edits skip this.

package/core/prompt-optimization/data/p7-final/sweet-search-system-prompt.md

@@ -1,12 +1,12 @@
 ---
-run_id: p7-v1-mppppp
+run_id: p7-v1-mppppp-fs
 score_sonnet: 0.993
 score_gpt5_5: 0.988
 joint_maximin: 0.988
 eas_factor: null
 length_penalty: null
 final_score: null
-token_count: 1221
+token_count: 1307
 scs_cwSCS: 0.931
 scs_min_paraphrase_accuracy: 1
 homp_family_pass: true
@@ -50,3 +50,5 @@ Before your third sweet-search probe in the current search iteration — or befo
 
 ## Search output
 Stop searching the instant your evidence answers what you're looking for — one confirmed file+symbol, or one named cross-file link, is enough; gather no corroboration you were not asked for. Name the file(s) and symbol(s) and how they answer what you need, or `no-match` — then finish whatever the task/prompt asks for.
+
+Before editing a symbol with visible siblings — multiple call sites, a name family (`IVec2`/`I64Vec2`), branch variants, a generated family — spend ONE mapping call: `ss-trace <symbol>`, or a broad `ss-grep` of the stem. Read the function you edit to its end; a fix covering only the first matching site is not done. Single-site edits skip this.