@mrclrchtr/supi-code-intelligence 2.0.6 → 2.1.0

package/src/tool/find/orchestrate.ts

@@ -9,14 +9,10 @@ import {
   type StructuredPatternKind,
 } from "../../analysis/search/pattern.ts";
 import type { RgMatch } from "../../analysis/search/ripgrep.ts";
-import {
-  normalizePath,
-  runRipgrep,
-  runRipgrepDetailed,
-  toDisplayPath,
-} from "../../analysis/search/ripgrep.ts";
-import type { CodeIntelResult, SearchDetails } from "../../types/index.ts";
+import { runRipgrep, runRipgrepDetailed, toDisplayPath } from "../../analysis/search/ripgrep.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
 import type { CodeQueryParams } from "../params.ts";
+import { assembleFindResult } from "../result/find.ts";
 import {
   renderPatternResults,
   renderPatternSummary,
@@ -28,7 +24,10 @@ import { executeSemanticSearch } from "./semantic-search.ts";
 
 export interface PatternInput {
   pattern: string;
-  path?: string;
+  /** One or more resolved search roots. */
+  paths?: string[];
+  /** Human-readable requested scope label for markdown/details. */
+  scopeLabel?: string | null;
   regex?: boolean;
   kind?: string;
   mode?: "text" | "regex" | "ast" | "semantic";
@@ -45,7 +44,6 @@ export interface PatternDeps {
 }
 
 /** Execute the pattern search use-case. */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: mode dispatch branches are linear, not nested
 export async function executePattern(
   input: PatternInput,
   deps: PatternDeps,
@@ -64,16 +62,15 @@ export async function executePattern(
 
   const maxResults = input.maxResults ?? 8;
   const contextLines = input.contextLines ?? 1;
-  const scopePath = input.path ? normalizePath(input.path, deps.cwd) : deps.cwd;
-  const relScope = input.path ?? ".";
+  const scope = getPatternScope(input, deps.cwd);
 
   if (isStructuredPatternKind(input.kind)) {
     return executeStructuredSearch(
       input,
       input.kind,
-      scopePath,
+      scope.paths,
       deps.cwd,
-      relScope,
+      scope.label,
       maxResults,
       deps.provider,
     );
@@ -82,14 +79,14 @@ export async function executePattern(
   const matches = input.regex
     ? await getRegexMatches({
         pattern: input.pattern,
-        scopePath,
+        scopePath: scope.paths,
         cwd: deps.cwd,
         maxResults,
         contextLines,
         summary: input.summary,
         signal: deps.signal,
       })
-    : await runRipgrep(input.pattern, scopePath, deps.cwd, {
+    : await runRipgrep(input.pattern, scope.paths, deps.cwd, {
         contextLines,
         literal: true,
         filterLowSignal: true,
@@ -97,18 +94,22 @@ export async function executePattern(
       });
 
   if (typeof matches === "string") {
-    const errorDetails: SearchDetails = {
-      confidence: "unavailable",
-      scope: input.path ?? null,
-      candidateCount: 0,
-      omittedCount: 0,
-      nextQueries: ["Fix the regex pattern and retry"],
+    return {
+      content: matches,
+      details: {
+        type: "search",
+        data: assembleFindResult({
+          confidence: "unavailable",
+          scope: getDetailScope(input),
+          candidateCount: 0,
+          nextQueries: ["Fix the regex pattern and retry"],
+        }),
+      },
     };
-    return { content: matches, details: { type: "search", data: errorDetails } };
   }
 
   if (matches.length === 0) {
-    return formatEmptyResult(input, relScope);
+    return formatEmptyResult(input, scope.label);
   }
 
   const displayMatches = matches.map((m) => ({
@@ -118,21 +119,21 @@ export async function executePattern(
 
   const rendered = input.summary
     ? {
-        content: renderPatternSummary(input.pattern, relScope, displayMatches, maxResults),
+        content: renderPatternSummary(input.pattern, scope.label, displayMatches, maxResults),
         evidenceList: undefined,
       }
-    : renderPatternResults(input.pattern, relScope, displayMatches, maxResults);
+    : renderPatternResults(input.pattern, scope.label, displayMatches, maxResults);
 
-  const details: SearchDetails = {
+  const details = assembleFindResult({
     confidence: "heuristic",
-    scope: input.path ?? null,
+    scope: getDetailScope(input),
     candidateCount: matches.length,
     omittedCount: rendered.evidenceList?.omittedCount ?? 0,
     evidenceLists: rendered.evidenceList ? [rendered.evidenceList] : [],
     nextQueries: input.regex
       ? ["Set `regex: false` for literal matching"]
       : ["Set `regex: true` for regex matching"],
-  };
+  });
   return { content: rendered.content, details: { type: "search" as const, data: details } };
 }
 
@@ -142,7 +143,7 @@ export async function executePattern(
 async function executeStructuredSearch(
   input: PatternInput,
   kind: StructuredPatternKind,
-  scopePath: string,
+  scopePaths: readonly string[],
   cwd: string,
   relScope: string,
   maxResults: number,
@@ -157,21 +158,25 @@ async function executeStructuredSearch(
 
   const structured = await getStructuredPatternMatches(
     { ...input, pattern: input.pattern, kind },
-    scopePath,
+    scopePaths,
     cwd,
     relScope,
     provider,
   );
 
   if (typeof structured === "string") {
-    const errorDetails: SearchDetails = {
-      confidence: "unavailable",
-      scope: input.path ?? null,
-      candidateCount: 0,
-      omittedCount: 0,
-      nextQueries: ["Fix the regex pattern and retry"],
+    return {
+      content: structured,
+      details: {
+        type: "search",
+        data: assembleFindResult({
+          confidence: "unavailable",
+          scope: getDetailScope(input),
+          candidateCount: 0,
+          nextQueries: ["Fix the regex pattern and retry"],
+        }),
+      },
     };
-    return { content: structured, details: { type: "search", data: errorDetails } };
   }
 
   if (!structured || structured.matches.length === 0) {
@@ -186,16 +191,16 @@ async function executeStructuredSearch(
       content,
       details: {
         type: "search",
-        data: {
+        data: assembleFindResult({
           confidence: "structural",
-          scope: input.path ?? null,
+          scope: getDetailScope(input),
           candidateCount: 0,
           omittedCount: structured?.omittedCount ?? 0,
           nextQueries: [
             "Try a broader `pattern`, or omit `kind` for plain text search",
             "Narrow `path` if the structured scan was partial",
           ],
-        },
+        }),
       },
     };
   }
@@ -206,9 +211,9 @@ async function executeStructuredSearch(
     content: rendered.content,
     details: {
       type: "search",
-      data: {
+      data: assembleFindResult({
         confidence: "structural",
-        scope: input.path ?? null,
+        scope: getDetailScope(input),
         candidateCount: structured.matches.length,
         omittedCount: structured.omittedCount + (rendered.evidenceList.omittedCount ?? 0),
         evidenceLists: [rendered.evidenceList],
@@ -222,13 +227,24 @@ async function executeStructuredSearch(
                 "Omit `kind` for plain text matches",
                 "Widen `scope` or raise `maxResults` for broader coverage",
               ],
-      },
+      }),
     },
   };
 }
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
+function getPatternScope(input: PatternInput, cwd: string): { paths: string[]; label: string } {
+  if (input.paths && input.paths.length > 0) {
+    return { paths: input.paths, label: input.scopeLabel ?? input.paths.join(", ") };
+  }
+  return { paths: [cwd], label: "." };
+}
+
+function getDetailScope(input: PatternInput): string | null {
+  return input.scopeLabel ?? null;
+}
+
 const REGEX_HINT_CHARS = /[|.*+?^${}()[\]\\]/;
 
 function hasRegexChars(pattern: string): boolean {
@@ -236,15 +252,14 @@ function hasRegexChars(pattern: string): boolean {
 }
 
 function formatEmptyResult(input: PatternInput, relScope: string): CodeIntelResult {
-  const emptyDetails: SearchDetails = {
+  const emptyDetails = assembleFindResult({
     confidence: "heuristic",
-    scope: input.path ?? null,
+    scope: getDetailScope(input),
     candidateCount: 0,
-    omittedCount: 0,
     nextQueries: input.regex
       ? ["Set `regex: false` for literal matching"]
       : ["Set `regex: true` for regex matching"],
-  };
+  });
   const hint = input.regex
     ? ""
     : hasRegexChars(input.pattern)
@@ -258,7 +273,7 @@ function formatEmptyResult(input: PatternInput, relScope: string): CodeIntelResu
 
 async function getRegexMatches(options: {
   pattern: string;
-  scopePath: string;
+  scopePath: string | readonly string[];
   cwd: string;
   maxResults: number;
   contextLines: number;
@@ -278,12 +293,9 @@ async function getRegexMatches(options: {
   return result.matches;
 }
 
-// ── Backward-compatible wrapper for test migrations ────────────────
+// ── Test helper wrapper ─────────────────────────────────────────────
 
-/**
- * Backward-compatible wrapper for tests that call the old (params, cwd) signature.
- * Prefer {@link executePattern} with the typed PatternInput/PatternDeps interface.
- */
+/** Prefer {@link executePattern} with the typed PatternInput/PatternDeps interface. */
 export async function executePatternAction(
   params: CodeQueryParams,
   cwd: string,
@@ -292,7 +304,8 @@ export async function executePatternAction(
   return executePattern(
     {
       pattern: params.pattern ?? "",
-      path: params.path,
+      paths: params.path ? [params.path] : undefined,
+      scopeLabel: params.path ?? null,
       regex: params.regex,
       kind: params.kind,
       maxResults: params.maxResults,

package/src/tool/find/semantic-search.ts

@@ -10,8 +10,8 @@ import type { CodeSymbol } from "@mrclrchtr/supi-code-runtime/api";
 import { isWithinOrEqual } from "@mrclrchtr/supi-core/project";
 import { createEvidenceList, renderEvidenceListDisclosure } from "../../analysis/evidence.ts";
 import type { CodeProvider } from "../../analysis/provider.ts";
-import { normalizePath } from "../../analysis/search/ripgrep.ts";
-import type { CodeIntelResult, SearchDetails } from "../../types/index.ts";
+import type { CodeIntelResult } from "../../types/index.ts";
+import { assembleFindResult } from "../result/find.ts";
 import type { PatternInput } from "./orchestrate.ts";
 
 export async function executeSemanticSearch(
@@ -32,35 +32,49 @@ export async function executeSemanticSearch(
     );
   }
 
-  const scopePath = input.path ? normalizePath(input.path, cwd) : cwd;
-  const scopedSymbols = filterSymbolsByScope(symbols, scopePath);
+  const scope = getSemanticScope(input, cwd);
+  const scopedSymbols = filterSymbolsByScopes(symbols, scope.paths);
   if (scopedSymbols.length === 0) {
-    return renderSemanticEmptyResult(input);
+    return renderSemanticEmptyResult(input, scope.label);
   }
 
   return renderSemanticResults(input, scopedSymbols, cwd);
 }
 
-function filterSymbolsByScope<T extends { file: string }>(symbols: T[], scopePath: string): T[] {
-  return symbols.filter((symbol) => isWithinOrEqual(scopePath, symbol.file));
+function filterSymbolsByScopes<T extends { file: string }>(
+  symbols: T[],
+  scopePaths: string[],
+): T[] {
+  return symbols.filter((symbol) =>
+    scopePaths.some((scopePath) => isWithinOrEqual(scopePath, symbol.file)),
+  );
 }
 
-function renderSemanticEmptyResult(input: PatternInput): CodeIntelResult {
-  const relPath = input.path ?? ".";
+function getSemanticScope(input: PatternInput, cwd: string): { paths: string[]; label: string } {
+  if (input.paths && input.paths.length > 0) {
+    return { paths: input.paths, label: input.scopeLabel ?? input.paths.join(", ") };
+  }
+  return { paths: [cwd], label: "." };
+}
+
+function getDetailScope(input: PatternInput): string | null {
+  return input.scopeLabel ?? null;
+}
+
+function renderSemanticEmptyResult(input: PatternInput, relPath: string): CodeIntelResult {
   return {
     content: `**Semantic search** — \`${input.pattern}\`\n\nNo semantic results found in \`${relPath}\`.`,
     details: {
       type: "search",
-      data: {
+      data: assembleFindResult({
         confidence: "semantic",
-        scope: input.path ?? null,
+        scope: getDetailScope(input),
         candidateCount: 0,
-        omittedCount: 0,
         nextQueries: [
           'Use `mode: "text"` for literal text search',
           'Use `mode: "ast"` with `kind` for structural filtering',
         ],
-      } satisfies SearchDetails,
+      }),
     },
   };
 }
@@ -98,9 +112,9 @@ function renderSemanticResults(
     content: lines.join("\n"),
     details: {
       type: "search",
-      data: {
+      data: assembleFindResult({
         confidence: "semantic",
-        scope: input.path ?? null,
+        scope: getDetailScope(input),
         candidateCount: symbols.length,
         omittedCount: evidence.metadata.omittedCount ?? 0,
         evidenceLists: [evidence.metadata],
@@ -108,7 +122,7 @@ function renderSemanticResults(
           'Use `mode: "text"` for literal text search',
           'Use `mode: "ast"` with `kind` for structural filtering',
         ],
-      } satisfies SearchDetails,
+      }),
     },
   };
 }

package/src/tool/graph/collect-relation.ts

@@ -19,12 +19,13 @@ import {
   renderRankedTestLabelsForMarkdown,
 } from "../../analysis/tests/test-discovery.ts";
 import type { AnchorKind } from "../../session/target-store.ts";
+import type { GraphSection } from "../result/graph.ts";
 import { collectCallees } from "./callees.ts";
 import { renderCallsResult } from "./calls-md.ts";
 import type { GraphRelation } from "./execute.ts";
 import { collectImplementations } from "./implementations.ts";
 import { renderImplementationsResult } from "./implementations-md.ts";
-import { type GraphSection, renderExportsResult, renderImportsResult } from "./markdown-base.ts";
+import { renderExportsResult, renderImportsResult } from "./markdown-base.ts";
 import { collectCallers } from "./references.ts";
 import { renderReferencesResult } from "./references-md.ts";
 import type { CallEntry } from "./types.ts";

package/src/tool/graph/execute.ts

@@ -5,21 +5,15 @@
  * and code_implementations. Resolves one target, then dispatches to the
  * appropriate analysis service per requested relation.
  *
- * Thin executor: validates params via pipeline, then delegates to the
- * graph use-case for target resolution, data collection, and rendering.
+ * Thin executor: resolves target via session target workflow (deep seam),
+ * validates params via pipeline, then delegates to the graph use-case.
  */
 
 import type { AnchorKind } from "../../session/target-store.ts";
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
 import { composeRules, focusedToolRules, requireAtLeastOne } from "../infra/cross-field.ts";
 import { searchErrorResult } from "../infra/error-results.ts";
-import {
-  expandTargetId,
-  gateCapability,
-  resolveScopeParam,
-  runPipe,
-  validateParams,
-} from "../infra/pipeline.ts";
+import { gateCapability, resolveScopeParam, runPipe, validateParams } from "../infra/pipeline.ts";
 import { emitToolProgress } from "../infra/progress.ts";
 import { executeGraph } from "./orchestrate.ts";
 
@@ -43,23 +37,57 @@ export interface CodeGraphToolParams {
   relations?: GraphRelation[];
   calleeDepth?: "direct" | "deep";
   maxResults?: number;
-  /** Set by pipeline expandTargetId stage. */
+  /** Set by target-workflow resolution. */
   _expandedName?: string | null;
-  /** Set by pipeline expandTargetId stage. */
+  /** Set by target-workflow resolution. */
   _expandedAnchorKind?: string | null;
 }
 
+/** Graph target-workflow policy: no file-level targets, name anchor optional. */
+const GRAPH_TARGET_POLICY = {
+  fileLevelAllowed: false,
+  nameAnchorRequired: false,
+  waitForSemantic: false,
+} as const;
+
 export async function executeGraphTool(
   params: CodeGraphToolParams,
   ctx: CodeIntelToolExecCtx,
 ): Promise<CodeIntelResult> {
   emitToolProgress(ctx.onUpdate, "code_graph: resolving target...");
 
+  // ── Deep seam: resolve targetId through the session target workflow ──
+  // Replaces expandTargetId pipeline stage. Anchored coordinates and
+  // symbol queries still use the orchestrate's own resolution.
+  if (params.targetId) {
+    const outcome = await ctx.session.resolveTarget(
+      { targetId: params.targetId },
+      GRAPH_TARGET_POLICY,
+    );
+
+    if (outcome.kind === "resolved") {
+      params.file = outcome.entry.file;
+      params.line = outcome.entry.displayLine;
+      params.character = outcome.entry.displayCharacter;
+      params._expandedName = outcome.entry.name;
+      params._expandedAnchorKind = outcome.entry.anchorKind;
+      // targetId wins — drop conflicting scope to avoid validation error
+      params.scope = undefined;
+    } else if (outcome.kind !== "no-target") {
+      const msg =
+        outcome.kind === "invalid-input"
+          ? outcome.message
+          : outcome.kind === "unavailable"
+            ? outcome.reason
+            : "Target resolution failed. Verify the targetId is valid.";
+      return searchErrorResult(`**Error:** ${msg}`);
+    }
+  }
+
   return runPipe(
     params,
     ctx,
     [
-      expandTargetId((msg) => searchErrorResult(msg)),
       resolveScopeParam((reason) => searchErrorResult(`**Error:** ${reason}`)),
       validateParams(
         composeRules(focusedToolRules(), requireAtLeastOne("file", "symbol", "scope")),

package/src/tool/graph/markdown-base.ts

@@ -5,10 +5,10 @@ import {
   type EvidenceListMetadata,
   renderEvidenceListDisclosure,
 } from "../../analysis/evidence.ts";
-import { type ReadNextItem, renderReadNextSection } from "../../analysis/read-next.ts";
+import { renderReadNextSection } from "../../analysis/read-next.ts";
 import type { ReferenceCollection } from "../../analysis/references/semantic-refs.ts";
 import { formatReferenceList } from "../../analysis/references/semantic-refs.ts";
-import type { TestSurfaceDetails } from "../../analysis/tests/test-discovery.ts";
+import type { GraphResultAssembly, GraphSection } from "../result/graph.ts";
 
 // ── Callers ──────────────────────────────────────────────────────────
 
@@ -152,46 +152,14 @@ export function renderExportsResult(
 
 // ── Combined graph ───────────────────────────────────────────────────
 
-/** Relation families accepted by code_graph. */
-export type GraphRelationKind =
-  | "all"
-  | "references"
-  | "callees"
-  | "imports"
-  | "exports"
-  | "implements"
-  | "tests";
-
-/** A section in the combined graph output. */
-export type GraphSection =
-  | {
-      kind: "ok";
-      rel: GraphRelationKind;
-      count: number;
-      content: string;
-      evidenceLists?: EvidenceListMetadata[];
-      tests?: TestSurfaceDetails;
-      readNext?: ReadNextItem[];
-    }
-  | { kind: "unavailable"; rel: GraphRelationKind; message: string; tests?: TestSurfaceDetails }
-  | {
-      kind: "not-implemented";
-      rel: GraphRelationKind;
-      message: string;
-      tests?: TestSurfaceDetails;
-    };
-
 /**
- * Render a combined graph result from multiple relation sections.
+ * Render an assembled graph result.
  *
  * Produces a unified markdown output with a summary header, per-section
  * pre-rendered content, and a footer with follow-up hints.
  */
-export function renderGraphResult(
-  displayName: string,
-  sections: GraphSection[],
-  resolvedFile: string,
-): string {
+export function renderGraphResult(assembly: GraphResultAssembly): string {
+  const { displayName, sections, resolvedDisplayFile: resolvedFile } = assembly;
   const lines: string[] = [];
 
   // Header

package/src/tool/graph/orchestrate.ts

@@ -17,6 +17,7 @@ import type { CodeIntelResult } from "../../types/index.ts";
 import { searchErrorResult } from "../infra/error-results.ts";
 import { emitToolProgress } from "../infra/progress.ts";
 import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
+import { assembleGraphResult } from "../result/graph.ts";
 import { type CollectRelationOptions, collectRelation } from "./collect-relation.ts";
 import type { GraphRelation } from "./execute.ts";
 import { renderGraphResult } from "./markdown-base.ts";
@@ -231,46 +232,19 @@ function buildGraphResult(
   resolvedDisplayFile: string,
   scope: string | undefined,
 ): CodeIntelResult {
-  const content = renderGraphResult(displayName, sections, resolvedDisplayFile);
-
-  const hasStructural = sections.some(
-    (s) =>
-      s.kind === "ok" &&
-      (s.rel === "callees" ||
-        s.rel === "imports" ||
-        s.rel === "exports" ||
-        (s.rel === "tests" && s.count > 0)),
-  );
-  const hasSemantic = sections.some(
-    (s) => s.kind === "ok" && (s.rel === "references" || s.rel === "implements"),
-  );
-  const confidence = hasSemantic ? "semantic" : hasStructural ? "structural" : "unavailable";
-
-  const tests = sections.find((section) => section.rel === "tests")?.tests;
-  const evidenceLists = sections.flatMap((section) =>
-    section.kind === "ok" ? (section.evidenceLists ?? []) : [],
-  );
-  const omittedCount = evidenceLists.reduce(
-    (sum, evidenceList) => sum + (evidenceList.omittedCount ?? 0),
-    0,
-  );
+  const assembly = assembleGraphResult({
+    displayName,
+    sections,
+    resolvedDisplayFile,
+    scope,
+  });
+  const content = renderGraphResult(assembly);
 
   return {
     content,
     details: {
       type: "search",
-      data: {
-        confidence,
-        scope: scope ?? null,
-        candidateCount: sections.reduce((sum, s) => (s.kind === "ok" ? sum + s.count : sum), 0),
-        omittedCount,
-        evidenceLists,
-        nextQueries: [
-          "`code_orientation` on individual results for deeper orientation",
-          "`code_impact` for impact analysis",
-        ],
-        tests,
-      },
+      data: assembly.details,
     },
   };
 }

package/src/tool/graph/tui.ts

@@ -15,6 +15,7 @@ import {
   renderEvidenceLines,
   renderMarkdownDetail,
   renderPartial,
+  renderStructuredDetailBody,
   type ToolResult,
 } from "../../ui/tui/common.ts";
 import type { CodeGraphToolParams, GraphRelation } from "./execute.ts";
@@ -83,6 +84,7 @@ export function renderGraphResult(
     container.addChild(buildTestsSection(details.tests as Record<string, unknown>, theme));
   }
 
+  renderStructuredDetailBody(container, details ?? undefined, theme);
   renderMarkdownDetail(container, result, theme);
 
   return container;

package/src/tool/guidance.ts

@@ -70,7 +70,7 @@ export const CODE_INTELLIGENCE_TOOL_PROMPT_SURFACES: CodeIntelligenceToolPromptS
   },
   code_find: {
     description:
-      'Unified ranked code search with strict mode dispatch: default/`mode: "text"` is literal ripgrep, `mode: "regex"` is ripgrep regex, `mode: "semantic"` is LSP workspace-symbol search, and `mode: "ast"` is tree-sitter structured search. `mode: "ast"` requires `kind` and currently supports `definition`, `import`, `export`, `call`, `type`, `interface`, `class`, `method`, `enum`, and `test`. `mode: "text"`, `mode: "regex"`, and `mode: "semantic"` do not accept `kind`. `code_find` with `mode: "semantic"` does not silently fall back to text search, and unsupported mode/kind combinations fail. AST `call` mode matches call-site identifiers by name, not by symbol identity; use `code_graph` references for identity-aware callers of a resolved target. Output is truncated to 2000 lines / 50KB.',
+      'Unified ranked code search with strict mode dispatch: default/`mode: "text"` is literal ripgrep, `mode: "regex"` is ripgrep regex, `mode: "semantic"` is LSP workspace-symbol search, and `mode: "ast"` is tree-sitter structured search. `mode: "ast"` requires `kind` and currently supports `definition`, `import`, `export`, `call`, `type`, `interface`, `class`, `method`, `enum`, and `test`. `mode: "text"`, `mode: "regex"`, and `mode: "semantic"` do not accept `kind`. `scope` accepts one workspace-relative path or an array of paths; delimiter-separated strings are split only when no exact path exists. `code_find` with `mode: "semantic"` does not silently fall back to text search, and unsupported mode/kind combinations fail. AST `call` mode matches call-site identifiers by name, not by symbol identity; use `code_graph` references for identity-aware callers of a resolved target. Output is truncated to 2000 lines / 50KB.',
     promptSnippet: "code_find — unified ranked code search",
     promptGuidelines: [
       "Use code_find as the sole code search tool for literal text, regex, semantic workspace-symbol, or AST structured search.",