sweet-search 2.6.16 → 2.6.17

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/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/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.

package/eval/agent-read-workflows/bin/_ss-helpers.mjs

@@ -166,9 +166,14 @@ async function cmdGrep(rawArgs) {
     || { files: [], hiddenFileCount: 0, hiddenMatchCount: 0, hiddenSample: [] };
   const body = renderGrepBody(result.results, fileSummary, k);
 
-  process.stdout.write(`# ss-grep: ${total} total match(es) for /${regex}/\n`);
+  // Sibling-surface signal (E6, 2026-07-08 trace audit): when a symbol/stem
+  // matches in more than one file, say so unconditionally in the header —
+  // the file count is the objective "visible siblings" trigger for
+  // fix-surface mapping, and it must not depend on truncation having occurred.
+  const across = body.matchedFileCount > 1 ? ` across ${body.matchedFileCount} files` : '';
+  process.stdout.write(`# ss-grep: ${total} total match(es) for /${regex}/${across}\n`);
   if (body.truncatedFileCount > 0 || body.hiddenLine) {
-    process.stdout.write(`# ${body.matchedFileCount} file(s) matched; (+N more in this file)=truncated — ` +
+    process.stdout.write(`# (+N more in this file)=truncated — ` +
       `see the rest: ss-grep "<regex>" --in <file>\n`);
   }
   for (const line of body.lines) process.stdout.write(line + '\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.6.16",
+  "version": "2.6.17",
   "description": "Sweet Search - SOTA Hybrid Code Search Engine with WASM CatBoost Query Router, Semantic/Lexical/Structural Search, and Multilingual Support",
   "type": "module",
   "main": "core/search/sweet-search.js",
@@ -167,13 +167,13 @@
     "vitest": "^4.0.16"
   },
   "optionalDependencies": {
-    "@sweet-search/native-darwin-arm64": "2.6.16",
-    "@sweet-search/native-darwin-x64": "2.6.16",
-    "@sweet-search/native-linux-arm64-gnu": "2.6.16",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.16",
-    "@sweet-search/native-linux-x64-gnu": "2.6.16",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.16",
-    "@sweet-search/bg-priority": "2.6.16"
+    "@sweet-search/native-darwin-arm64": "2.6.17",
+    "@sweet-search/native-darwin-x64": "2.6.17",
+    "@sweet-search/native-linux-arm64-gnu": "2.6.17",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.17",
+    "@sweet-search/native-linux-x64-gnu": "2.6.17",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.17",
+    "@sweet-search/bg-priority": "2.6.17"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/inject-agent-instructions.js

@@ -54,8 +54,10 @@ function escapeRegex(s) {
 // champion (PHASE7 M++ — held-out 0.988 Maximin, OOD 0.952, HOMP/SCS/counter
 // all pass, 5-cell cross-harness validated — plus the stop-discipline scoping
 // edits that fix M++'s over-stopping on FIX tasks, plus the verdict-gated
-// trust line that scans already-delivered lower ranks before any new search;
-// tool routing unchanged), injected VERBATIM into the harness files.
+// trust line that scans already-delivered lower ranks before any new search,
+// plus the P2 fix-surface paragraph that maps a multi-site edit surface in
+// ONE call before the first edit; tool routing unchanged), injected VERBATIM
+// into the harness files.
 // Per-harness shims (Cursor frontmatter, @imports) are applied at write-time,
 // not embedded here.
 //