sweet-search 2.6.11 → 2.6.13

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

@@ -1,14 +1,16 @@
 ---
 variant: mcp
-derived_from: p7-v1-mpp
-source_prompt: core/prompt-optimization/data/p7-variant-restarts/p7-gen3-candidates/Mpp.md
+derived_from: p7-v1-mpppp
+source_prompt: core/prompt-optimization/data/p7-variant-restarts/p7-gen3-candidates/Mpppp.md
 benchmarked: false
 note: >-
-  Hand-derived MCP-tool variant of the frozen M++ champion (p7-v1-mpp). The
-  STRATEGY core — routing by what-you-hold, trust-the-top-hit, sufficiency
-  stops, the two-probe absence rule, the <state_summary> gate, and the output
-  discipline — is preserved (semantics intact; the <state_summary> gate and
-  Output section are byte-identical, the rest carries only the tool-mechanics
+  Hand-derived MCP-tool variant of the M++++ champion (p7-v1-mpppp = M++ +
+  stop-discipline scoping edits: search-rules-only intro, "stop searching" /
+  "Search output" wording; routing unchanged from the frozen, benchmarked
+  M++). The STRATEGY core — routing by what-you-hold, trust-the-top-hit,
+  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
   rename). Only the tool-mechanics layer is remapped: the six ss-* CLI commands collapse onto the sweet-search MCP
   tool surface (a UNIFIED `search` that subsumes ss-search/ss-find/ss-grep, plus
   `trace` / `read-semantic` / `read` / `repo-map`). The anti-raw-scan discipline
@@ -21,9 +23,11 @@ note: >-
 ---
 # Sweet-search — code search tool guide
 
+These are code-search rules only — they never decide when the task is done; the deliverable is whatever the task/prompt asks for. When the task calls for a change, locating the right code is a means, not the finish line: apply the edit with your normal file-editing tool and never a description of the fix in place of the fix.
+
 Sweet-search indexes the working tree (uncommitted edits too) and searches it faster and cheaper than scanning files by hand. Use the sweet-search tools for all code search and navigation, in preference to native Grep/Read or shell `grep`/`find`/`cat`/`ls` — the index covers every file, so a manual scan only re-confirms a sweet-search result at higher cost, never beats it. Reach for a raw read only for an edit too recent to be reconciled (seconds old). Never re-run a sweet-search hit as a native Grep. Any sub-agent you delegate to must use these sweet-search tools, with this system prompt verbatim.
 
-## Tools
+## Tools (search tools, via the sweet-search MCP server)
 The sweet-search MCP server exposes these (call each by the name your client lists it under):
 - **search** — hybrid code search; returns ranked, self-contained code blocks. Your primary tool: it subsumes semantic search, exact-literal search, and semantic-reranked regex. Give it a natural-language query for a concept, or pass a `regex` (or lexical mode) for an exact token.
 - **trace** — a symbol's callers, callees and impact in one call.
@@ -39,13 +43,13 @@ The sweet-search MCP server exposes these (call each by the name your client lis
 Trust the top ranked result; confirm with at most one narrow `read`, never a re-run of a matching hit.
 
 ## Multi-file
-Chain inside the tools: land the entry file, `read-semantic` it for the import or handoff symbol, then `search` the downstream module. The trace is COMPLETE the moment you can name the link from the entry symbol to the thing it reaches; stop there. Leaf bodies, macro expansions, and the next hop down are not the answer unless asked, and chasing them — or dropping to a native Grep/Read to "just look" — is the main multi-file cost trap.
+Chain inside the tools: land the entry file, `read-semantic` it for the import or handoff symbol, then `search` the downstream module. The trace is COMPLETE the moment you can name the link from the entry symbol to the thing it reaches; stop tracing there. Leaf bodies, macro expansions, and the next hop down are not the answer unless asked, and chasing them — or dropping to a native Grep/Read to "just look" — is the main multi-file cost trap.
 
-## A confirmed absence is a complete answer
-When what you're looking for may not exist, absence is settled once TWO complementary `search` probes come back empty for the same concept: one in natural language and one as a broad `regex` on its likeliest identifier (a short substring/prefix). A search that returns plausible-but-off-target code is the decoy, not a lead — do not chase it. Two empty index probes over the whole codebase are more conclusive than any native scan or file listing, so state the negative and stop: no third synonym, no native `grep`/`ls`/`cat` enumeration.
+## A confirmed absence is a complete search answer
+When what you're looking for may not exist, absence is settled once TWO complementary `search` probes come back empty for the same concept: one in natural language and one as a broad `regex` on its likeliest identifier (a short substring/prefix). A search that returns plausible-but-off-target code is the decoy, not a lead — do not chase it. Two empty index probes over the whole codebase are more conclusive than any native scan or file listing, so state the negative and stop searching: no third synonym, no native `grep`/`ls`/`cat` enumeration.
 
 ## Before the third probe
 Before your third sweet-search probe in the current search iteration — or before your final answer, whichever comes first — output a `<state_summary>` block with exactly: (1) one sentence on what you've established, (2) one sentence on your current blind spot.
 
-## Output
-Stop 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`.
+## 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.

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

@@ -1,12 +1,12 @@
 ---
-run_id: p7-v1-mpp
+run_id: p7-v1-mpppp
 score_sonnet: 0.993
 score_gpt5_5: 0.988
 joint_maximin: 0.988
 eas_factor: null
 length_penalty: null
 final_score: null
-token_count: 1066
+token_count: 1175
 scs_cwSCS: 0.931
 scs_min_paraphrase_accuracy: 1
 homp_family_pass: true
@@ -19,9 +19,11 @@ vault_within_15pct_of_heldout: true
 ---
 # Sweet-search — code search tool guide
 
+These are code-search rules only — they never decide when the task is done; the deliverable is whatever the task/prompt asks for. When the task calls for a change, locating the right code is a means, not the finish line: apply the edit with your normal file-editing tool and never a description of the fix in place of the fix.
+
 Sweet-search indexes the working tree (uncommitted edits too) and searches it faster and cheaper than raw shell. Use the `ss-*` tools for all code search and navigation. Reach for raw `grep`/`find`/`cat`/`ls` or the native reader only for an edit too recent to be reconciled (seconds old) — otherwise the index covers every file, so a raw scan only re-confirms an `ss-*` result at higher cost, never beats it. Never re-run an `ss-*` hit as raw grep. Any sub-agent you delegate to must use these `ss-*` tools, with this system prompt verbatim.
 
-## Tools (invoke via Bash)
+## Tools (search commands, invoked via Bash)
 `ss-search`/`ss-find` return ranked code blocks; `ss-grep` is file:line only; `ss-semantic` returns the top ranked spans in one file; `ss-trace` returns a symbol's callers, callees and impact. `ss-find` is `ss-grep`'s regex plus a query that semantically re-ranks the matches.
 - `ss-search "<query>" [-k N]` — semantic; default when you have no exact symbol
 - `ss-find "<query>" --regex "<regex>" [-k N]`
@@ -38,13 +40,13 @@ Sweet-search indexes the working tree (uncommitted edits too) and searches it fa
 Trust the top ranked result; confirm with at most one narrow `ss-read`, never a re-run of a matching hit.
 
 ## Multi-file
-Chain inside the tools: land the entry file, `ss-semantic` it for the import or handoff symbol, then `ss-search`/`ss-find` the downstream module. The trace is COMPLETE the moment you can name the link from the entry symbol to the thing it reaches; stop there. Leaf bodies, macro expansions, and the next hop down are not the answer unless asked, and chasing them — or dropping to raw `cat`/`grep` to "just look" — is the main multi-file cost trap.
+Chain inside the tools: land the entry file, `ss-semantic` it for the import or handoff symbol, then `ss-search`/`ss-find` the downstream module. The trace is COMPLETE the moment you can name the link from the entry symbol to the thing it reaches; stop tracing there. Leaf bodies, macro expansions, and the next hop down are not the answer unless asked, and chasing them — or dropping to raw `cat`/`grep` to "just look" — is the main multi-file cost trap.
 
-## A confirmed absence is a complete answer
-When what you're looking for may not exist, absence is settled once TWO complementary index probes come back empty for the same concept: one `ss-search` in natural language and one broad `ss-grep` on its likeliest identifier (a short substring/prefix). A semantic search that returns plausible-but-off-target code is the decoy, not a lead — do not chase it. Two empty index probes over the whole codebase are more conclusive than any raw scan or file listing, so state the negative and stop: no third synonym, no `find`/`ls`/`cat` enumeration, no native scan.
+## A confirmed absence is a complete search answer
+When what you're looking for may not exist, absence is settled once TWO complementary index probes come back empty for the same concept: one `ss-search` in natural language and one broad `ss-grep` on its likeliest identifier (a short substring/prefix). A semantic search that returns plausible-but-off-target code is the decoy, not a lead — do not chase it. Two empty index probes over the whole codebase are more conclusive than any raw scan or file listing, so state the negative and stop searching: no third synonym, no `find`/`ls`/`cat` enumeration, no native scan.
 
 ## Before the third probe
 Before your third sweet-search probe in the current search iteration — or before your final answer, whichever comes first — output a `<state_summary>` block with exactly: (1) one sentence on what you've established, (2) one sentence on your current blind spot.
 
-## Output
-Stop 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`.
+## 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.

package/core/search/grep-output-shaping.js

@@ -0,0 +1,193 @@
+/**
+ * Agent-facing grep output shaping: k-budget file-level diversity.
+ *
+ * Root cause (task bench, rstudio-education__gradethis-161): bareGrep returns
+ * matches sorted alphabetically by file and the agent wrapper printed the
+ * first k grouped by file — so one flooded early-alphabet file could consume
+ * the entire k budget and structurally hide every other matching file, with
+ * no signal that elision happened.
+ *
+ * These helpers are pure and option-gated: only the ss-grep agent wrapper
+ * enables them. The human-facing grep product shape and all NL ranking paths
+ * are untouched (no scoring — file order stays the engine's deterministic
+ * sorted order; raw match count is deliberately never used as a sort key).
+ */
+
+/**
+ * True when a match's repo-relative path is the drill-in target. Accepts the
+ * exact relative path as printed in grep output, a path with a leading "./",
+ * or a suffix (basename or trailing path segments) so agents can paste any
+ * reasonable spelling of the file they saw.
+ *
+ * @param {string} file - repo-relative match path (as emitted by the engine)
+ * @param {string} filter - user-supplied --in value
+ */
+export function matchesGrepFileFilter(file, filter) {
+  if (!file || !filter) return false;
+  const f = String(filter).replace(/^\.\//, '').replace(/\\/g, '/');
+  const target = String(file).replace(/\\/g, '/');
+  return target === f || target.endsWith(`/${f}`);
+}
+
+/**
+ * Streaming per-file diversification of a (file,line)-sorted match list.
+ * Keeps at most `perFileCap` matches per file and at most `maxFiles` distinct
+ * files; everything beyond is COUNTED but never stored, so memory is bounded
+ * by perFileCap*maxFiles regardless of total match count.
+ *
+ * PRECONDITION: matches must be grouped by file (bareGrep sorts by
+ * (file, line, column) before calling) — the walk uses a single per-file
+ * cursor precisely so no map proportional to distinct-file count is built.
+ *
+ * @param {Array<{file: string}>} matches - sorted by (file, line)
+ * @param {{perFileCap: number, maxFiles?: number, hiddenSampleSize?: number}} opts
+ * @returns {{kept: Array, fileSummary: {
+ *   files: Array<{file: string, total: number, kept: number}>,
+ *   hiddenFileCount: number, hiddenMatchCount: number,
+ *   hiddenSample: Array<{file: string, total: number}>,
+ * }}}
+ */
+export function applyGrepFileDiversity(matches, opts = {}) {
+  const perFileCap = Math.max(1, opts.perFileCap | 0);
+  const maxFiles = opts.maxFiles > 0 ? (opts.maxFiles | 0) : Infinity;
+  const hiddenSampleSize = opts.hiddenSampleSize ?? 3;
+
+  const kept = [];
+  const files = [];            // [{file, total, kept}] in first-appearance (sorted) order
+  const hiddenSample = [];     // first few hidden files, name + total
+  let hiddenFileCount = 0;
+  let hiddenMatchCount = 0;
+
+  let current = null;
+  for (const m of matches) {
+    if (!current || current.file !== m.file) {
+      if (files.length < maxFiles) {
+        current = { file: m.file, total: 0, kept: 0 };
+        files.push(current);
+      } else {
+        current = { file: m.file, total: 0, kept: -1 }; // hidden file: count only
+        hiddenFileCount++;
+        if (hiddenSample.length < hiddenSampleSize) {
+          hiddenSample.push(current);
+        }
+      }
+    }
+    current.total++;
+    if (current.kept >= 0 && current.kept < perFileCap) {
+      kept.push(m);
+      current.kept++;
+    } else if (current.kept < 0) {
+      hiddenMatchCount++;
+    }
+  }
+
+  return {
+    kept,
+    fileSummary: {
+      files,
+      hiddenFileCount,
+      hiddenMatchCount,
+      hiddenSample: hiddenSample.map(h => ({ file: h.file, total: h.total })),
+    },
+  };
+}
+
+/**
+ * Breadth-first budget allocation: round-robin one line per file per round,
+ * in the given (deterministic) file order, until `budget` lines are allocated
+ * or every file's available matches are exhausted. Flooding is structurally
+ * impossible — file A gets its (r+1)-th line only after every other file got
+ * its r-th — while few-files queries keep full depth (deep rounds fill just
+ * like the old flat output).
+ *
+ * @param {number[]} counts - available (fetched) matches per file
+ * @param {number} budget - total lines to allocate (k)
+ * @returns {number[]} allocation per file, same order as counts
+ */
+export function allocateGrepBudget(counts, budget) {
+  const alloc = counts.map(() => 0);
+  let remaining = Math.max(0, budget | 0);
+  let progressed = true;
+  while (remaining > 0 && progressed) {
+    progressed = false;
+    for (let i = 0; i < counts.length && remaining > 0; i++) {
+      if (alloc[i] < counts[i]) {
+        alloc[i]++;
+        remaining--;
+        progressed = true;
+      }
+    }
+  }
+  return alloc;
+}
+
+/**
+ * Render the diversified agent grep body: matches grouped per file (research:
+ * contiguous per-file blocks read better than interleaving) with allocation
+ * decided breadth-first, and a visible inline `(+N more in this file)` marker
+ * on the last shown line of every truncated file — elision is never silent
+ * and costs no extra lines.
+ *
+ * @param {Array<{file: string, line: number, matchText?: string}>} kept -
+ *   diversified matches in engine order (grouped by file)
+ * @param {{files: Array<{file, total, kept}>, hiddenFileCount, hiddenMatchCount,
+ *          hiddenSample: Array<{file, total}>}} fileSummary
+ * @param {number} k - body line budget
+ * @returns {{lines: string[], shownMatches: number, matchedFileCount: number,
+ *            truncatedFileCount: number, hiddenLine: string|null}}
+ */
+export function renderGrepBody(kept, fileSummary, k) {
+  const groups = new Map();
+  for (const m of kept) {
+    if (!groups.has(m.file)) groups.set(m.file, []);
+    groups.get(m.file).push(m);
+  }
+  const totals = new Map(fileSummary.files.map(f => [f.file, f.total]));
+  const ordered = [...groups.entries()];
+  const alloc = allocateGrepBudget(ordered.map(([, ms]) => ms.length), k);
+
+  const lines = [];
+  let shownMatches = 0;
+  let truncatedFileCount = 0;
+  const unallocated = []; // fetched files that got zero budget (more files than k)
+  ordered.forEach(([file, ms], i) => {
+    if (alloc[i] === 0) {
+      unallocated.push({ file, total: totals.get(file) ?? ms.length });
+      return;
+    }
+    const total = totals.get(file) ?? ms.length;
+    for (let j = 0; j < alloc[i]; j++) {
+      const m = ms[j];
+      const text = (m.matchText || '').replace(/\s+/g, ' ').trim().slice(0, 140);
+      let line = `${file}:${m.line}: ${text}`;
+      if (j === alloc[i] - 1 && total > alloc[i]) {
+        line += ` (+${total - alloc[i]} more in this file)`;
+        truncatedFileCount++;
+      }
+      lines.push(line);
+      shownMatches++;
+    }
+  });
+
+  // Files that matched but got no body line at all (more matching files than
+  // budget, or clipped by the engine's maxFiles fetch bound): one honest tail
+  // line naming the first few so the agent can jump straight to them.
+  const hiddenFiles = unallocated.length + fileSummary.hiddenFileCount;
+  const hiddenMatches = unallocated.reduce((a, f) => a + f.total, 0) + fileSummary.hiddenMatchCount;
+  let hiddenLine = null;
+  if (hiddenFiles > 0) {
+    const sample = [...unallocated.map(f => f.file), ...fileSummary.hiddenSample.map(f => f.file)]
+      .slice(0, 3);
+    hiddenLine = `# +${hiddenFiles} more file(s) with ${hiddenMatches} match(es)` +
+      (sample.length ? ` — e.g. ${sample.join(', ')}` : '') +
+      `; narrow the regex, raise -k, or drill in with --in <file>`;
+  }
+
+  return {
+    lines,
+    shownMatches,
+    matchedFileCount: fileSummary.files.length + fileSummary.hiddenFileCount,
+    truncatedFileCount,
+    hiddenLine,
+  };
+}

package/core/search/search-pattern.js

@@ -16,6 +16,7 @@
 import { PROJECT_ROOT } from '../infrastructure/config/index.js';
 import { generateRegexMatches } from './search-pattern-planner.js';
 import { buildBareGrepResults, filterMatchesBySymbolType, resolveSearchSymbolFilter, mapMatchesToChunks, readFileRange } from './search-pattern-chunks.js';
+import { applyGrepFileDiversity, matchesGrepFileFilter } from './grep-output-shaping.js';
 import { isRipgrepAvailable, runRipgrepJson } from './search-pattern-ripgrep.js';
 import { ensureSparseGramIndex } from './search-pattern-prefilter.js';
 import { packageForAgent } from './context-expander.js';
@@ -152,6 +153,11 @@ export async function bareGrep(query, routing, options = {}) {
   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));
+  }
   matches.sort((a, b) =>
     a.file.localeCompare(b.file) ||
     a.line - b.line ||
@@ -159,6 +165,16 @@ export async function bareGrep(query, routing, options = {}) {
   );
 
   const totalMatches = matches.length;
+  // 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.
+  let fileSummary = null;
+  if (options.perFileCap > 0) {
+    ({ kept: matches, fileSummary } = applyGrepFileDiversity(matches, {
+      perFileCap: options.perFileCap,
+      maxFiles: options.maxFiles,
+    }));
+  }
   if (maxMatches > 0) {
     matches = matches.slice(0, maxMatches);
   }
@@ -170,6 +186,7 @@ export async function bareGrep(query, routing, options = {}) {
 
   return {
     results,
+    ...(fileSummary ? { fileSummary } : {}),
     stats: {
       path: 'grep',
       regex,

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

@@ -18,6 +18,7 @@ import {
   buildGrepPattern, stripInertFlags, normalizeArgs, extractPositional,
   parseLineRange, looksLikeOption,
 } from './_ss-argparse.mjs';
+import { renderGrepBody } from '../../../core/search/grep-output-shaping.js';
 
 // Diagnostic-log isolation (agent-facing tools). The Sweet Search engine emits
 // model/index load banners via console.log → stdout ("LateInteraction: Loaded…",
@@ -115,13 +116,16 @@ async function ensureWarmServerReady({ timeoutMs = 60000, intervalMs = 500 } = {
 
 // --- subcommands ----------------------------------------------------------
 
-const GREP_USAGE = 'Usage: ss-grep <regex> [-i|--ignore-case] [-w|--word-regexp] [-F|--fixed-strings] [-k N]';
+const GREP_USAGE = 'Usage: ss-grep <regex> [-i|--ignore-case] [-w|--word-regexp] [-F|--fixed-strings] [--in <file>] [-k N]';
 async function cmdGrep(rawArgs) {
   const args = normalizeArgs(rawArgs);
   const ignoreCase = parseBoolFlag(args, ['-i', '--ignore-case']);
   const wordBound = parseBoolFlag(args, ['-w', '--word-regexp']);
   const fixedString = parseBoolFlag(args, ['-F', '--fixed-strings']);
   const k = readPositiveIntFlag(args, ['-k', '--top'], 20, GREP_USAGE);
+  // Drill-in scope: show matches from ONE file (the recovery affordance the
+  // diversified output advertises when it truncates a flooded file).
+  const inFile = readValueFlag(args, '--in', null, GREP_USAGE);
   stripInertFlags(args);
   const regex = buildGrepPattern(resolvePositional(args, GREP_USAGE), { ignoreCase, wordBound, fixedString });
   if (!regex) {
@@ -129,25 +133,47 @@ async function cmdGrep(rawArgs) {
     process.exit(2);
   }
   const s = await getSweetSearch();
-  const result = await s.bareGrep(regex, null, { regex, maxMatches: k * 5, contextLines: 0 });
-  // Group by file, take first k matches across all files (ordered as bareGrep returns).
-  const grouped = new Map();
-  for (const r of result.results.slice(0, k * 5)) {
-    if (!grouped.has(r.file)) grouped.set(r.file, []);
-    grouped.get(r.file).push(r);
-  }
-  let printed = 0;
-  process.stdout.write(`# ss-grep: ${result.results.length} total match(es) for /${regex}/\n`);
-  for (const [file, lines] of grouped) {
-    for (const r of lines) {
+
+  if (inFile) {
+    // Single-file scope: flat output, depth up to k within that file.
+    const result = await s.bareGrep(regex, null, {
+      regex, maxMatches: k, contextLines: 0, fileFilter: inFile,
+    });
+    const total = result.stats?.totalMatches ?? result.results.length;
+    process.stdout.write(`# ss-grep: ${total} total match(es) for /${regex}/ (scope: --in ${inFile})\n`);
+    result.results.forEach((r, i) => {
       const text = (r.matchText || '').replace(/\s+/g, ' ').trim().slice(0, 140);
-      process.stdout.write(`${file}:${r.line}: ${text}\n`);
-      printed++;
-      if (printed >= k) break;
-    }
-    if (printed >= k) break;
+      const marker = (i === result.results.length - 1 && total > result.results.length)
+        ? ` (+${total - result.results.length} more — raise -k)` : '';
+      process.stdout.write(`${r.file}:${r.line}: ${text}${marker}\n`);
+    });
+    if (result.results.length === 0) process.stdout.write('(no matches)\n');
+    process.exit(0);
+  }
+
+  // k-budget file diversity: fetch at most min(k,100) matches per file across
+  // at most k files (a file can never show more than k lines, and more than k
+  // files can never fit), then allocate the k body lines breadth-first so one
+  // flooded file can never hide every other matching file (the gradethis-161
+  // failure). Rendering stays grouped per file; truncation is marked inline
+  // and drillable via --in.
+  const result = await s.bareGrep(regex, null, {
+    regex, maxMatches: 0, contextLines: 0,
+    perFileCap: Math.min(k, 100), maxFiles: k,
+  });
+  const total = result.stats?.totalMatches ?? result.results.length;
+  const fileSummary = result.fileSummary
+    || { 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`);
+  if (body.truncatedFileCount > 0 || body.hiddenLine) {
+    process.stdout.write(`# ${body.matchedFileCount} file(s) matched; (+N more in this file)=truncated — ` +
+      `see the rest: ss-grep "<regex>" --in <file>\n`);
   }
-  if (printed === 0) process.stdout.write('(no matches)\n');
+  for (const line of body.lines) process.stdout.write(line + '\n');
+  if (body.hiddenLine) process.stdout.write(body.hiddenLine + '\n');
+  if (body.shownMatches === 0) process.stdout.write('(no matches)\n');
   process.exit(0);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.6.11",
+  "version": "2.6.13",
   "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.11",
-    "@sweet-search/native-darwin-x64": "2.6.11",
-    "@sweet-search/native-linux-arm64-gnu": "2.6.11",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.11",
-    "@sweet-search/native-linux-x64-gnu": "2.6.11",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.11",
-    "@sweet-search/bg-priority": "2.6.11"
+    "@sweet-search/native-darwin-arm64": "2.6.13",
+    "@sweet-search/native-darwin-x64": "2.6.13",
+    "@sweet-search/native-linux-arm64-gnu": "2.6.13",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.13",
+    "@sweet-search/native-linux-x64-gnu": "2.6.13",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.13",
+    "@sweet-search/bg-priority": "2.6.13"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/hooks/remind-tools.mjs

@@ -18,7 +18,7 @@
  * both the file and the settings entry.
  */
 
-// Tool surface mirrors the shipped M++ policy (the ss-* tools). Kept terse —
+// Tool surface mirrors the shipped M++++ policy (the ss-* tools). Kept terse —
 // the full decision tree lives in CLAUDE.md/AGENTS.md; this is just a nudge to
 // stop the agent drifting back to raw grep/read between prompts.
 const REMINDER = [
@@ -30,8 +30,9 @@ const REMINDER = [
   '- Callers/callees/impact of a symbol: ss-trace <symbol>',
   '- Known file, unclear span:           ss-semantic <file> "<query>"',
   '- Known file + line range:            ss-read <file> <start> <end>',
-  'STOP the instant your evidence answers the query — one confirmed file+symbol is enough;',
+  'STOP searching the instant your evidence answers the query — one confirmed file+symbol is enough;',
   'a second call costs more than it saves. Multi-file flow questions get one follow-up.',
+  'Search rules only — if the task asks for a change, apply the edit.',
   '</sweet-search-reminder>',
   '',
 ].join('\n');

package/scripts/inject-agent-instructions.js

@@ -46,17 +46,18 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-// ─── Canonical policy body = the frozen M++ champion (integration seam) ──────
+// ─── Canonical policy body = the M++++ champion (integration seam) ───────────
 //
 // Plan §10 / §3.7.1 step 13 / DDD "Integration seam": scripts/init.js is the
 // SOLE consumer of the prompt-optimization ship-file. We read that artifact at
-// load time and strip its YAML front-matter; the remaining body is the frozen
-// M++ champion (PHASE7), injected VERBATIM into the harness files so users get
-// exactly the prompt that was benchmarked (held-out 0.988 Maximin, OOD 0.952,
-// HOMP/SCS/counter all pass; 5-cell cross-harness validated). Per-harness shims
+// load time and strip its YAML front-matter; the remaining body is the M++++
+// 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; routing unchanged),
+// injected VERBATIM into the harness files. Per-harness shims
 // (Cursor frontmatter, @imports) are applied at write-time, not embedded here.
 //
-// The artifact is generated from Mpp.md by
+// The artifact is generated from Mpppp.md by
 // `core/prompt-optimization/sweep/finalize-mpp.mjs` and shipped via the
 // package.json "files" list. If it is missing we fail LOUDLY rather than
 // silently shipping a placeholder/older policy.
@@ -75,7 +76,7 @@ export function stripFrontMatter(text) {
   return text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
 }
 
-function readShippedPolicy(rel = SHIP_FILE_REL, { label = 'M++' } = {}) {
+function readShippedPolicy(rel = SHIP_FILE_REL, { label = 'M++++' } = {}) {
   const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/scripts
   const shipPath = join(here, '..', rel);
   let raw;
@@ -102,7 +103,7 @@ let _mcpPolicyBody = null;
 /** Lazily read + cache the MCP-variant policy body. */
 export function getMcpPolicyBody() {
   if (_mcpPolicyBody == null) {
-    _mcpPolicyBody = readShippedPolicy(MCP_SHIP_FILE_REL, { label: 'M++ (MCP variant)' });
+    _mcpPolicyBody = readShippedPolicy(MCP_SHIP_FILE_REL, { label: 'M++++ (MCP variant)' });
   }
   return _mcpPolicyBody;
 }