@flyingrobots/graft 0.6.0 → 0.7.0

package/src/mcp/tool-registry.ts

@@ -1,6 +1,7 @@
 import type { ToolDefinition } from "./context.js";
 
 import { safeReadTool } from "./tools/safe-read.js";
+import { graftEditTool } from "./tools/graft-edit.js";
 import { fileOutlineTool } from "./tools/file-outline.js";
 import { readRangeTool } from "./tools/read-range.js";
 import { changedSinceTool } from "./tools/changed-since.js";
@@ -16,15 +17,23 @@ import { mapTool } from "./tools/map.js";
 import { codeShowTool } from "./tools/code-show.js";
 import { codeFindTool } from "./tools/code-find.js";
 import { codeRefsTool } from "./tools/code-refs.js";
+import { structuralChurnTool } from "./tools/structural-churn.js";
+import { exportSurfaceDiffTool } from "./tools/export-surface-diff.js";
+import { structuralLogTool } from "./tools/structural-log.js";
+import { structuralBlameTool } from "./tools/structural-blame.js";
+import { refactorDifficultyTool } from "./tools/refactor-difficulty.js";
+import { structuralReviewTool } from "./tools/structural-review.js";
 import { daemonMonitorsTool } from "./tools/daemon-monitors.js";
 import { daemonReposTool } from "./tools/daemon-repos.js";
 import { daemonSessionsTool } from "./tools/daemon-sessions.js";
 import { daemonStatusTool } from "./tools/daemon-status.js";
 import { monitorPauseTool } from "./tools/monitor-pause.js";
 import { monitorResumeTool } from "./tools/monitor-resume.js";
+import { monitorNudgeTool } from "./tools/monitor-nudge.js";
 import { monitorStartTool } from "./tools/monitor-start.js";
 import { monitorStopTool } from "./tools/monitor-stop.js";
 import { activityViewTool } from "./tools/activity-view.js";
+import { knowledgeMapTool } from "./tools/knowledge-map.js";
 import { causalStatusTool } from "./tools/causal-status.js";
 import { causalAttachTool } from "./tools/causal-attach.js";
 import { workspaceAuthorizeTool } from "./tools/workspace-authorize.js";
@@ -36,6 +45,7 @@ import { workspaceRebindTool } from "./tools/workspace-rebind.js";
 
 export const TOOL_REGISTRY: readonly ToolDefinition[] = [
   safeReadTool,
+  graftEditTool,
   fileOutlineTool,
   readRangeTool,
   changedSinceTool,
@@ -55,6 +65,13 @@ export const TOOL_REGISTRY: readonly ToolDefinition[] = [
   codeShowTool,
   codeFindTool,
   codeRefsTool,
+  structuralChurnTool,
+  exportSurfaceDiffTool,
+  structuralLogTool,
+  structuralBlameTool,
+  refactorDifficultyTool,
+  structuralReviewTool,
+  knowledgeMapTool,
 ];
 
 export const DAEMON_TOOL_REGISTRY: readonly ToolDefinition[] = [
@@ -65,6 +82,7 @@ export const DAEMON_TOOL_REGISTRY: readonly ToolDefinition[] = [
   monitorStartTool,
   monitorPauseTool,
   monitorResumeTool,
+  monitorNudgeTool,
   monitorStopTool,
   workspaceAuthorizeTool,
   workspaceAuthorizationsTool,

package/src/mcp/tools/code-find.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import type { ToolDefinition, ToolContext, ToolHandler } from "../context.js";
+import { nodePathOps } from "../../adapters/node-paths.js";
+import { indexHead } from "../../warp/index-head.js";
 import { GitFileQuery, listGitFiles } from "./git-files.js";
 import {
   evaluatePrecisionPolicy,
@@ -57,6 +59,26 @@ interface CodeFindOptions {
   readonly allowWarp: boolean;
 }
 
+async function lazyIndexReadPaths(
+  ctx: ToolContext,
+  paths: readonly string[],
+  dirty: boolean,
+): Promise<void> {
+  if (dirty || paths.length === 0) return;
+  try {
+    const warp = await ctx.getWarp();
+    await indexHead({
+      cwd: ctx.projectRoot,
+      git: ctx.git,
+      pathOps: nodePathOps,
+      ctx: warp,
+      paths: [...new Set(paths)],
+    });
+  } catch {
+    // Lazy indexing must never turn a successful read/search into a failure.
+  }
+}
+
 export async function runCodeFind(
   ctx: ToolContext,
   args: Record<string, unknown>,
@@ -140,6 +162,7 @@ export async function runCodeFind(
     paths: [...new Set(visibleMatches.map((m) => m.path))],
     symbols: visibleMatches.map((m) => m.name),
   });
+  await lazyIndexReadPaths(ctx, visibleMatches.map((m) => m.path), repoState.dirty);
 
   return ctx.respond("code_find", {
     query: request.query,

package/src/mcp/tools/code-show.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { readRange } from "../../operations/read-range.js";
 import type { ToolDefinition, ToolContext, ToolHandler } from "../context.js";
+import { nodePathOps } from "../../adapters/node-paths.js";
+import { indexHead } from "../../warp/index-head.js";
 import { listProjectFiles } from "./git-files.js";
 import {
   evaluatePrecisionPolicy,
@@ -21,6 +23,26 @@ interface CodeShowOptions {
   readonly allowWarp: boolean;
 }
 
+async function lazyIndexReadPaths(
+  ctx: ToolContext,
+  paths: readonly string[],
+  dirty: boolean,
+): Promise<void> {
+  if (dirty || paths.length === 0) return;
+  try {
+    const warp = await ctx.getWarp();
+    await indexHead({
+      cwd: ctx.projectRoot,
+      git: ctx.git,
+      pathOps: nodePathOps,
+      ctx: warp,
+      paths: [...new Set(paths)],
+    });
+  } catch {
+    // Lazy indexing is a cache refresh. It must not break the read response.
+  }
+}
+
 export async function runCodeShow(
   ctx: ToolContext,
   args: Record<string, unknown>,
@@ -186,6 +208,7 @@ export async function runCodeShow(
       paths: [...new Set(visibleLocations.map((m) => m.path))],
       symbols: visibleLocations.map((m) => m.name),
     });
+    await lazyIndexReadPaths(ctx, visibleLocations.map((m) => m.path), repoState.dirty);
     return ctx.respond("code_show", {
       symbol: symbolName,
       ambiguous: true,
@@ -197,6 +220,9 @@ export async function runCodeShow(
 
   const loc = visibleLocations[0];
   if (loc?.startLine === undefined || loc.endLine === undefined) {
+    if (loc?.path !== undefined) {
+      await lazyIndexReadPaths(ctx, [loc.path], repoState.dirty);
+    }
     return ctx.respond("code_show", {
       symbol: symbolName,
       kind: loc?.kind,
@@ -228,6 +254,7 @@ export async function runCodeShow(
     symbols: [loc.name],
     regions: [{ path: loc.path, startLine: loc.startLine, endLine: loc.endLine }],
   });
+  await lazyIndexReadPaths(ctx, [loc.path], repoState.dirty);
 
   return ctx.respond("code_show", {
     symbol: loc.name,

package/src/mcp/tools/diagnostic-models.ts

@@ -12,6 +12,7 @@ import type {
 } from "../persisted-local-history.js";
 import type { RuntimeWorkspaceOverlayFooting } from "../runtime-workspace-overlay.js";
 import type { CausalSurfaceNextAction } from "../../contracts/causal-surface-next-action.js";
+import type { SludgeReport } from "../../operations/sludge-detector.js";
 
 export interface SetBudgetResponse {
   readonly budget: {
@@ -72,6 +73,7 @@ export interface DoctorResponse {
   readonly attribution: PersistedLocalHistorySummary["attribution"];
   readonly persistedLocalHistory: PersistedLocalHistorySummary;
   readonly recommendedNextAction: CausalSurfaceNextAction;
+  readonly sludge?: SludgeReport | undefined;
 }
 
 export interface RunCapturePolicyBoundary {

package/src/mcp/tools/doctor.ts

@@ -5,14 +5,30 @@ import { deriveCausalSurfaceNextAction } from "../semantic-transition-guidance.j
 import type { ToolDefinition, ToolHandler } from "../context.js";
 import { toJsonObject } from "../../operations/result-dto.js";
 import type { DoctorResponse } from "./diagnostic-models.js";
+import { detectSludge } from "../../operations/sludge-detector.js";
+import { z } from "zod";
 
 export const doctorTool: ToolDefinition = {
   name: "doctor",
   description:
     "Runtime health check. Shows project root, parser status, active " +
     "thresholds, session depth, message count, and burden summary.",
+  schema: {
+    sludge: z.boolean().optional(),
+    path: z.string().optional(),
+  },
   createHandler(): ToolHandler {
-    return async (_args, ctx) => {
+    return async (args, ctx) => {
+      const pathArg = typeof args["path"] === "string" ? args["path"] : undefined;
+      const sludge = args["sludge"] === true
+        ? await detectSludge({
+          cwd: ctx.projectRoot,
+          fs: ctx.fs,
+          git: ctx.git,
+          resolvePath: (filePath) => ctx.resolvePath(filePath),
+          ...(pathArg !== undefined ? { path: pathArg } : {}),
+        })
+        : undefined;
       const repoState = ctx.getRepoState();
       const causalContext = ctx.getCausalContext();
       const workspaceOverlayFooting = await ctx.getWorkspaceOverlayFooting();
@@ -59,6 +75,7 @@ export const doctorTool: ToolDefinition = {
         attribution: persistedLocalHistory.attribution,
         persistedLocalHistory,
         recommendedNextAction,
+        ...(sludge !== undefined ? { sludge } : {}),
       };
       return ctx.respond("doctor", toJsonObject(response));
     };

package/src/mcp/tools/export-surface-diff.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { exportSurfaceDiff, exportSurfaceDiffToJson } from "../../operations/export-surface-diff.js";
+import type { ToolDefinition, ToolHandler } from "../context.js";
+
+export const exportSurfaceDiffTool: ToolDefinition = {
+  name: "graft_exports",
+  description:
+    "Export surface diff — what changed in the public API between two " +
+    "refs? Identifies added, removed, and signature-changed exported " +
+    "symbols and derives semver impact.",
+  schema: {
+    base: z.string().optional(),
+    head: z.string().optional(),
+  },
+  createHandler(): ToolHandler {
+    return async (args, ctx) => {
+      const result = await exportSurfaceDiff({
+        cwd: ctx.projectRoot,
+        git: ctx.git,
+        base: args["base"] as string | undefined,
+        head: args["head"] as string | undefined,
+      });
+      return ctx.respond("graft_exports", exportSurfaceDiffToJson(result));
+    };
+  },
+};

package/src/mcp/tools/file-outline.ts

@@ -31,7 +31,7 @@ export const fileOutlineTool: ToolDefinition = {
       if (rawContent !== null && outlineSupported) {
         const cacheResult = ctx.cache.check(filePath, rawContent);
         if (cacheResult.hit) {
-          cacheResult.obs.touch();
+          cacheResult.obs.touch(ctx.cache.now());
           ctx.metrics.recordCacheHit(cacheResult.obs.actual.bytes);
           ctx.recordFootprint({
             symbols: cacheResult.obs.outline.map((e) => e.name),

package/src/mcp/tools/graft-edit.ts

@@ -0,0 +1,276 @@
+import { z } from "zod";
+import { evaluateMcpPolicy } from "../policy.js";
+import { RefusedResult } from "../../policy/types.js";
+import type { ToolDefinition, ToolHandler } from "../context.js";
+
+type GraftEditReason =
+  | "NOT_FOUND"
+  | "OLD_STRING_NOT_FOUND"
+  | "OLD_STRING_AMBIGUOUS"
+  | RefusedResult["reason"];
+
+type DriftPattern = "jsdoc_typedef";
+type DriftDirection = "removed" | "added";
+
+interface GraftEditDriftObservation {
+  readonly pattern: DriftPattern;
+  readonly path: string;
+  readonly direction: DriftDirection;
+}
+
+interface GraftEditDriftWarning {
+  readonly kind: "structural_pattern_reintroduced";
+  readonly severity: "advisory";
+  readonly pattern: DriftPattern;
+  readonly basis: "session_local_graft_edit";
+  readonly message: string;
+  readonly current: {
+    readonly path: string;
+    readonly direction: "added";
+  };
+  readonly previous: {
+    readonly path: string;
+    readonly direction: "removed";
+  };
+}
+
+interface GraftEditResponse {
+  readonly path: string;
+  readonly operation: "replace";
+  readonly projection: "edited" | "refused";
+  readonly status: "edited" | "refused";
+  readonly changed: boolean;
+  readonly matches: number;
+  readonly replacements: number;
+  readonly reason?: GraftEditReason;
+  readonly reasonDetail?: string;
+  readonly next?: readonly string[];
+  readonly actual?: {
+    readonly lines: number;
+    readonly bytes: number;
+  };
+  readonly driftWarnings?: readonly GraftEditDriftWarning[];
+}
+
+function countOccurrences(content: string, needle: string): number {
+  if (needle.length === 0) {
+    return content.length + 1;
+  }
+
+  let count = 0;
+  let offset = 0;
+  while (offset <= content.length) {
+    const index = content.indexOf(needle, offset);
+    if (index === -1) {
+      return count;
+    }
+    count += 1;
+    offset = index + needle.length;
+  }
+  return count;
+}
+
+async function actualForFile(
+  content: string,
+  stat: () => Promise<{ size: number }>,
+): Promise<{ lines: number; bytes: number }> {
+  const fileStat = await stat();
+  return {
+    lines: content.split("\n").length,
+    bytes: fileStat.size,
+  };
+}
+
+function refused(input: {
+  readonly path: string;
+  readonly reason: GraftEditReason;
+  readonly reasonDetail?: string;
+  readonly next?: readonly string[];
+  readonly actual?: { readonly lines: number; readonly bytes: number };
+  readonly matches?: number;
+}): GraftEditResponse {
+  return {
+    path: input.path,
+    operation: "replace",
+    projection: "refused",
+    status: "refused",
+    changed: false,
+    matches: input.matches ?? 0,
+    replacements: 0,
+    reason: input.reason,
+    ...(input.reasonDetail !== undefined ? { reasonDetail: input.reasonDetail } : {}),
+    ...(input.next !== undefined ? { next: [...input.next] } : {}),
+    ...(input.actual !== undefined ? { actual: input.actual } : {}),
+  };
+}
+
+function containsJsdocTypedef(content: string): boolean {
+  return content
+    .split(/\r?\n/u)
+    .some((line) => line.trimStart().startsWith("* @typedef "));
+}
+
+function classifyStructuralEdit(input: {
+  readonly path: string;
+  readonly oldString: string;
+  readonly newString: string;
+}): GraftEditDriftObservation | null {
+  const oldHasTypedef = containsJsdocTypedef(input.oldString);
+  const newHasTypedef = containsJsdocTypedef(input.newString);
+  if (oldHasTypedef === newHasTypedef) {
+    return null;
+  }
+  return {
+    path: input.path,
+    pattern: "jsdoc_typedef",
+    direction: oldHasTypedef ? "removed" : "added",
+  };
+}
+
+function buildDriftWarnings(
+  observation: GraftEditDriftObservation | null,
+  priorObservations: readonly GraftEditDriftObservation[],
+): GraftEditDriftWarning[] {
+  if (observation?.direction !== "added") {
+    return [];
+  }
+
+  let previous: GraftEditDriftObservation | undefined;
+  for (let i = priorObservations.length - 1; i >= 0; i--) {
+    const candidate = priorObservations[i];
+    if (candidate?.pattern === observation.pattern && candidate.direction === "removed") {
+      previous = candidate;
+      break;
+    }
+  }
+  if (previous === undefined) {
+    return [];
+  }
+
+  return [{
+    kind: "structural_pattern_reintroduced",
+    severity: "advisory",
+    pattern: observation.pattern,
+    basis: "session_local_graft_edit",
+    message: "You are adding a typedef in a session that has been removing typedefs.",
+    current: {
+      path: observation.path,
+      direction: "added",
+    },
+    previous: {
+      path: previous.path,
+      direction: "removed",
+    },
+  }];
+}
+
+export const graftEditTool: ToolDefinition = {
+  name: "graft_edit",
+  description:
+    "Perform one governed exact string replacement in a repo file. " +
+    "Requires path, old_string, and new_string. Refuses missing or " +
+    "ambiguous old_string matches and policy-denied paths.",
+  schema: {
+    path: z.string(),
+    old_string: z.string(),
+    new_string: z.string(),
+  },
+  createHandler(): ToolHandler {
+    const structuralEditObservations: GraftEditDriftObservation[] = [];
+
+    return async (args, ctx) => {
+      const filePath = ctx.resolvePath(args["path"] as string);
+      const oldString = args["old_string"] as string;
+      const newString = args["new_string"] as string;
+      ctx.recordFootprint({ paths: [filePath] });
+
+      let content: string;
+      try {
+        content = await ctx.fs.readFile(filePath, "utf-8");
+      } catch {
+        ctx.metrics.recordRefusal();
+        return ctx.respond("graft_edit", {
+          ...refused({
+            path: filePath,
+            reason: "NOT_FOUND",
+            reasonDetail: "File does not exist or cannot be read",
+            next: ["Choose an existing file; graft_edit does not create files"],
+          }),
+        });
+      }
+
+      const actual = await actualForFile(content, () => ctx.fs.stat(filePath));
+      const policy = evaluateMcpPolicy(ctx, filePath, actual);
+      if (policy instanceof RefusedResult) {
+        ctx.metrics.recordRefusal();
+        return ctx.respond("graft_edit", {
+          ...refused({
+            path: filePath,
+            reason: policy.reason,
+            reasonDetail: policy.reasonDetail,
+            next: policy.next,
+            actual,
+          }),
+        });
+      }
+
+      const matches = countOccurrences(content, oldString);
+      if (matches === 0) {
+        ctx.metrics.recordRefusal();
+        return ctx.respond("graft_edit", {
+          ...refused({
+            path: filePath,
+            reason: "OLD_STRING_NOT_FOUND",
+            reasonDetail: "old_string does not occur in the target file",
+            next: ["Inspect the current file content and provide an exact old_string"],
+            actual,
+            matches,
+          }),
+        });
+      }
+
+      if (matches !== 1) {
+        ctx.metrics.recordRefusal();
+        return ctx.respond("graft_edit", {
+          ...refused({
+            path: filePath,
+            reason: "OLD_STRING_AMBIGUOUS",
+            reasonDetail: "old_string must occur exactly once",
+            next: ["Provide a longer old_string that uniquely identifies the edit site"],
+            actual,
+            matches,
+          }),
+        });
+      }
+
+      const nextContent = content.replace(oldString, newString);
+      const changed = nextContent !== content;
+      if (changed) {
+        await ctx.fs.writeFile(filePath, nextContent, "utf-8");
+      }
+
+      const observation = classifyStructuralEdit({
+        path: filePath,
+        oldString,
+        newString,
+      });
+      const driftWarnings = buildDriftWarnings(observation, structuralEditObservations);
+      if (observation !== null) {
+        structuralEditObservations.push(observation);
+      }
+
+      const response: GraftEditResponse = {
+        path: filePath,
+        operation: "replace",
+        projection: "edited",
+        status: "edited",
+        changed,
+        matches,
+        replacements: 1,
+        actual,
+        ...(driftWarnings.length > 0 ? { driftWarnings } : {}),
+      };
+      return ctx.respond("graft_edit", { ...response });
+    };
+  },
+};

package/src/mcp/tools/knowledge-map.ts

@@ -0,0 +1,34 @@
+import { buildKnowledgeMap } from "../../operations/knowledge-map.js";
+import type { ToolDefinition, ToolHandler } from "../context.js";
+
+export const knowledgeMapTool: ToolDefinition = {
+  name: "knowledge_map",
+  description:
+    "Session knowledge map — answers \"what do I already know?\" " +
+    "Lists all files and symbols observed this session, flags stale " +
+    "files (changed since last read), and shows directory coverage. " +
+    "Use before reading more files to avoid redundant context consumption.",
+  createHandler(): ToolHandler {
+    return async (_args, ctx) => {
+      const result = await buildKnowledgeMap({
+        cache: ctx.cache,
+        fs: ctx.fs,
+        projectRoot: ctx.projectRoot,
+      });
+
+      return ctx.respond("knowledge_map", {
+        totalFiles: result.totalFiles,
+        totalSymbols: result.totalSymbols,
+        files: result.files.map((f) => ({
+          path: f.path,
+          symbols: [...f.symbols],
+          readCount: f.readCount,
+          lastReadAt: f.lastReadAt,
+          stale: f.stale,
+        })),
+        staleFiles: [...result.staleFiles],
+        directoryCoverage: result.directoryCoverage,
+      });
+    };
+  },
+};

package/src/mcp/tools/monitor-nudge.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import type { ToolDefinition, ToolHandler } from "../context.js";
+
+export const monitorNudgeTool: ToolDefinition = {
+  name: "monitor_nudge",
+  description:
+    "Trigger an immediate re-index tick for a running monitor. " +
+    "Use from post-commit hooks to notify graft that HEAD changed.",
+  schema: {
+    cwd: z.string(),
+  },
+  createHandler(): ToolHandler {
+    return async (args, ctx) => {
+      return ctx.respond("monitor_nudge", { ...await ctx.nudgeMonitor({
+        cwd: args["cwd"] as string,
+      }) });
+    };
+  },
+};

package/src/mcp/tools/precision-warp.ts

@@ -1,4 +1,6 @@
-import type { WarpHandle } from "../../ports/warp.js";
+import type { QueryResultV1 } from "@git-stunts/git-warp";
+import type { WarpContext } from "../../warp/context.js";
+import { observeGraph } from "../../warp/context.js";
 import { allSymbolsLens, commitsLens, fileSymbolsLens, symbolByNameLens } from "../../warp/observers.js";
 import type { RankedPrecisionSymbolMatch } from "./precision-query.js";
 import { PrecisionSearchRequest } from "./precision-query.js";
@@ -34,15 +36,20 @@ function toMatch(
   });
 }
 
-export async function getIndexedCommitCeilings(warp: WarpHandle): Promise<ReadonlyMap<string, number>> {
+export async function getIndexedCommitCeilings(ctx: WarpContext): Promise<ReadonlyMap<string, number>> {
   const ceilings = new Map<string, number>();
-  const observer = await warp.observer(commitsLens());
-  const nodeIds = await observer.getNodes();
+  const observer = await observeGraph(ctx, commitsLens());
 
-  for (const nodeId of nodeIds) {
-    const props = await observer.getNodeProps(nodeId);
-    const sha = typeof props?.["sha"] === "string" ? props["sha"] : null;
-    const tick = typeof props?.["tick"] === "number" ? props["tick"] : null;
+  // Slice-first: use query API instead of getNodes() + per-node getNodeProps()
+  const result = await observer.query()
+    .match("commit:*")
+    .select(["id", "props"])
+    .run() as QueryResultV1;
+
+  for (const node of result.nodes) {
+    const props = node.props ?? {};
+    const sha = typeof props["sha"] === "string" ? props["sha"] : null;
+    const tick = typeof props["tick"] === "number" ? props["tick"] : null;
     if (sha !== null && tick !== null) {
       ceilings.set(sha, tick);
     }
@@ -52,7 +59,7 @@ export async function getIndexedCommitCeilings(warp: WarpHandle): Promise<Readon
 }
 
 export async function searchWarpSymbols(
-  warp: WarpHandle,
+  ctx: WarpContext,
   request: PrecisionSearchRequest,
 ): Promise<PrecisionSymbolMatch[]> {
   const lensMode = request.selectLens();
@@ -71,19 +78,23 @@ export async function searchWarpSymbols(
     lens = allSymbolsLens();
   }
 
-  const observer = await warp.observer(
+  const observer = await observeGraph(ctx, 
     lens,
     request.ceiling !== undefined ? { source: { kind: "live", ceiling: request.ceiling } } : undefined,
   );
-  const nodeIds = await observer.getNodes();
+  // Slice-first: use query API instead of getNodes() + per-node getNodeProps()
+  const queryResult = await observer.query()
+    .match("*")
+    .select(["id", "props"])
+    .run() as QueryResultV1;
 
-  const matches = await Promise.all(nodeIds.map(async (nodeId) => {
-    const props = await observer.getNodeProps(nodeId);
-    if (props === null) return null;
-    const match = toMatch(nodeId, props);
+  const matches = queryResult.nodes.map((node) => {
+    const props = node.props ?? {};
+    if (node.id === undefined) return null;
+    const match = toMatch(node.id, props);
     if (match === null) return null;
     return request.rank(match);
-  }));
+  });
 
   const visibleMatches = matches.filter((match): match is RankedPrecisionSymbolMatch => match !== null);
   return request.sort(visibleMatches);