github-router 0.3.27 → 0.3.28

package/dist/main.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
+import * as path$1 from "node:path";
 import path from "node:path";
 import process$1 from "node:process";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { promisify } from "node:util";
+import fs$1, { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { createInterface } from "node:readline";
+import Parser from "web-tree-sitter";
 import { events } from "fetch-event-stream";
 import { z } from "zod";
-import fs$1 from "node:fs";
 import { Writable } from "node:stream";
 import { serve } from "srvx";
 import { getProxyForUrl } from "proxy-from-env";
@@ -19,6 +23,10 @@ import { Hono } from "hono";
 import { cors } from "hono/cors";
 import clipboard from "clipboardy";
 
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
 //#region src/lib/paths.ts
 function appDir() {
 	return path.join(os.homedir(), ".local", "share", "github-router");
@@ -1786,6 +1794,1250 @@ function launchChild(target, server$1, options = {}) {
 	});
 }
 
+//#endregion
+//#region src/lib/code-search.ts
+/**
+* BM25's `k1` term-frequency saturation parameter. Lucene's default.
+* Robertson & Zaragoza 2009 monograph recommends 1.2-2.0; Lucene
+* ships 1.2, Elasticsearch ships 1.2, we ship 1.2.
+*/
+const BM25F_K1 = 1.2;
+/**
+* Per-field BM25F boost weights (`b_f` in the CIKM 2004 paper). The
+* relative ordering follows Sourcegraph Zoekt's published signal
+* priorities — matched line first, then symbol context, then path,
+* then surrounding context.
+*/
+const FIELD_BOOSTS = {
+	match_line: 3,
+	symbol_context: 2.5,
+	file_path: 2,
+	context: 1
+};
+/**
+* Per-field length-normalization parameter (`l_f`). 0.0 disables
+* length normalization for short, uniform fields. Lucene's default
+* `b=0.75` for prose-like fields.
+*/
+const FIELD_LEN_NORMS = {
+	match_line: 0,
+	symbol_context: 0,
+	file_path: 0,
+	context: .75
+};
+/**
+* Shoulder cut: drop results below this fraction of the top score.
+* 0.5 is the convention from learning-to-rank literature (Burges
+* 2010); chosen as the deliberate single-place constant.
+*/
+const SHOULDER_THRESHOLD = .5;
+const MAX_QUERY_LEN = 1024;
+const MAX_GLOB_LEN = 512;
+const DEFAULT_LIMIT = 20;
+const MAX_CONTEXT_LINES = 10;
+const DEFAULT_CONTEXT_LINES = 2;
+const MAX_SNIPPET_BYTES = 2048;
+const MAX_STDOUT_BYTES = 10 * 1024 * 1024;
+const WALL_TIME_MS = 3e4;
+/**
+* Structural-pass settings. The wall-clock budget is checked between
+* files (NOT mid-parse — tree-sitter doesn't surface a usable cancel
+* hook in the web-tree-sitter binding we're on), so a single
+* pathological file can overrun by one file's parse-time. In practice
+* a single source file parses in well under 50ms; 200ms gives us
+* comfortable headroom for ~5-10 files even on cold cache.
+*/
+const STRUCTURAL_BUDGET_MS = 200;
+const STRUCTURAL_TOPN_FULL = 50;
+const STRUCTURAL_TOPN_FAST = 10;
+/**
+* Cap the per-file size we'll parse. 1MB of source covers all
+* reasonable hand-written files; bigger files are almost always
+* generated code or vendored bundles whose AST signal is worthless
+* for ranking real definitions.
+*/
+const STRUCTURAL_MAX_FILE_BYTES = 1024 * 1024;
+/**
+* LRU bound on the parsed-tree cache. Each Tree pins ~roughly the
+* size of its source plus tree-sitter's internal node arena. 64 is
+* comfortably under typical Node heap budgets; trees are eagerly
+* `.delete()`-ed on eviction.
+*/
+const STRUCTURAL_CACHE_MAX = 64;
+/**
+* Definition-shape heuristic for `symbol_context` field. Match this
+* against the matched line (after leading whitespace strip) to
+* detect "the match is on a definition." This is the regex fallback
+* we use when (a) tree-sitter can't reach the file (unsupported
+* language, grammar load failure, parse error), (b) the file isn't
+* in the structural pass's top-N slice, or (c) the structural budget
+* fired.
+*/
+const SYMBOL_REGEX = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:public\s+|private\s+|protected\s+|static\s+|abstract\s+|readonly\s+)*(?:function|class|interface|type|enum|def|fn|trait|impl|module|namespace|const|let|var)\s+[A-Za-z_$]/;
+let _rgResolution;
+/**
+* Tri-tier resolution. Memoized. Mirrors cc-backup
+* `src/utils/ripgrep.ts:31-65`.
+*
+*   1. System rg on PATH — use the literal command name `"rg"` (NOT
+*      the absolute path). This leverages NoDefaultCurrentDirectory-
+*      InExePath on Windows, preventing PATH-hijacking via a
+*      malicious ./rg.exe in the proxy's cwd.
+*   2. Bundled via `@vscode/ripgrep` — falls back to the per-platform
+*      binary that `optionalDependencies` installed.
+*   3. Throw — surfaced to the caller as an MCP isError response.
+*/
+function resolveRipgrep() {
+	if (_rgResolution) return _rgResolution;
+	if (hasSystemRipgrep()) {
+		_rgResolution = {
+			rgPath: "rg",
+			source: "system"
+		};
+		return _rgResolution;
+	}
+	try {
+		const mod = __require("@vscode/ripgrep");
+		if (mod.rgPath && existsSync(mod.rgPath)) {
+			_rgResolution = {
+				rgPath: mod.rgPath,
+				source: "bundled"
+			};
+			return _rgResolution;
+		}
+	} catch {}
+	throw new Error("ripgrep not found. Either install rg system-wide (brew/apt/winget) or reinstall the proxy so @vscode/ripgrep's per-platform binary is fetched. See README's code_search section.");
+}
+function hasSystemRipgrep() {
+	try {
+		return execFileSync(process.platform === "win32" ? "where" : "which", ["rg"], {
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 1e3
+		}).length > 0;
+	} catch {
+		return false;
+	}
+}
+function validateInputs(input) {
+	if (typeof input.query !== "string" || input.query.length === 0) return "code_search: arguments.query is required (non-empty string)";
+	if (input.query.length > MAX_QUERY_LEN) return `code_search: query exceeds ${MAX_QUERY_LEN} chars`;
+	if (/[\0\r\n]/.test(input.query)) return "code_search: query contains null byte or newline (rejected)";
+	if (typeof input.workspace !== "string" || input.workspace.length === 0) return "code_search: arguments.workspace is required (absolute path)";
+	if (input.mode && ![
+		"ranked",
+		"literal",
+		"regex"
+	].includes(input.mode)) return `code_search: mode must be one of "ranked", "literal", "regex"`;
+	if (input.file_glob !== void 0) {
+		if (typeof input.file_glob !== "string") return "code_search: file_glob must be a string";
+		if (input.file_glob.length > MAX_GLOB_LEN) return `code_search: file_glob exceeds ${MAX_GLOB_LEN} chars`;
+		if (/[\0\r\n]/.test(input.file_glob)) return "code_search: file_glob contains null byte or newline";
+	}
+	if (input.limit !== void 0) {
+		if (typeof input.limit !== "number" || !Number.isInteger(input.limit) || input.limit < 1) return "code_search: limit must be a positive integer";
+	}
+	if (input.context_lines !== void 0) {
+		if (typeof input.context_lines !== "number" || !Number.isInteger(input.context_lines) || input.context_lines < 0) return "code_search: context_lines must be a non-negative integer";
+	}
+	return null;
+}
+/**
+* Validate a `workspace` arg. The proxy runs as the user; any path
+* the proxy process can `stat` is a legal workspace — mirrors what
+* Claude Code's Read / Bash tools could already reach. Earlier the
+* validator enforced an allow-set + secret-shape file denylist; the
+* holistic threat model showed those were inconsistent guardrails
+* (the model already has filesystem access via its other tools), so
+* they're dropped.
+*
+* Still enforced:
+*   - Absolute path (relative paths are an integration-error footgun).
+*   - realpath canonicalization (resolves symlinks; output paths are
+*     reported relative to this).
+*   - Path must exist AND be a directory.
+*
+* Errors do NOT echo the rejected path (output of code_search flows
+* upstream to the model provider; consistent with the
+* COPILOT_HOST_ALLOWLIST pattern in `src/lib/utils.ts`).
+*/
+function validateWorkspace(workspace) {
+	if (!path$1.isAbsolute(workspace)) return {
+		ok: false,
+		error: "workspace must be an absolute path"
+	};
+	let canonical;
+	try {
+		canonical = realpathSync(workspace);
+	} catch {
+		return {
+			ok: false,
+			error: "workspace path is not accessible"
+		};
+	}
+	try {
+		if (!statSync(canonical).isDirectory()) return {
+			ok: false,
+			error: "workspace must be a directory"
+		};
+	} catch {
+		return {
+			ok: false,
+			error: "workspace path is not accessible"
+		};
+	}
+	return {
+		ok: true,
+		canonical
+	};
+}
+/**
+* Rule-based identifier splitter per the ESEC/FSE 2021 benchmark.
+*
+*   1. Split on non-word characters.
+*   2. Within each chunk, split on case boundaries with acronym
+*      lookahead — `HTTPSConnection` → [`HTTPS`, `Connection`].
+*   3. Attach trailing digit runs to letters — `parseV2Handler` →
+*      [`parse`, `V2`, `Handler`] (NOT `[parse, V, 2, Handler]`).
+*   4. Lowercase all tokens.
+*   5. Drop tokens of length < 2 to suppress single-char noise.
+*
+* Limitation: ASCII identifiers only. Unicode identifiers (Cyrillic,
+* CJK, etc.) won't be tokenized. Documented as MVP scope.
+*/
+function tokenize(text) {
+	const out = [];
+	const pieces = text.split(/[^A-Za-z0-9]+/);
+	const re = /[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+[0-9]*|[A-Z]+[0-9]*|[0-9]+/g;
+	for (const piece of pieces) {
+		if (!piece) continue;
+		const matches = piece.match(re);
+		if (!matches) continue;
+		for (const m of matches) {
+			const lc = m.toLowerCase();
+			if (lc.length >= 2) out.push(lc);
+		}
+	}
+	return out;
+}
+/**
+* Platform-aware child termination. On Unix: SIGTERM, then SIGKILL
+* after a brief grace period. On Windows: taskkill /T /F because
+* child.kill() doesn't reliably terminate descendants — a long
+* search with worker threads would leak rg.exe processes.
+*/
+function killChild(child) {
+	if (!child.pid || child.killed) return;
+	if (process.platform === "win32") {
+		try {
+			execFile("taskkill", [
+				"/T",
+				"/F",
+				"/PID",
+				String(child.pid)
+			], () => {});
+		} catch {}
+		return;
+	}
+	try {
+		child.kill("SIGTERM");
+	} catch {}
+	setTimeout(() => {
+		if (!child.killed) try {
+			child.kill("SIGKILL");
+		} catch {}
+	}, 500).unref();
+}
+/**
+* Single-identifier query matcher. We only expand queries that look
+* like a single identifier — any whitespace, regex metacharacters, or
+* structural punctuation defeats the expansion and we fall through to
+* the original rg behavior. ASCII-only on purpose (matches the
+* tokenizer's scope; Unicode identifiers are MVP-out).
+*/
+const SINGLE_IDENTIFIER_REGEX = /^[A-Za-z][A-Za-z0-9_-]{0,127}$/;
+/**
+* Split an identifier into its constituent word-pieces, recognizing
+*
+*   - snake_case   (split on `_`)
+*   - kebab-case   (split on `-`)
+*   - camelCase    (split on lowercase→uppercase boundaries)
+*   - PascalCase   (each capitalized run is a piece)
+*   - acronym runs (HTTPSConnection → [HTTPS, Connection])
+*   - trailing digits attached to letters (parseV2 → [parse, V2])
+*
+* Pieces are returned in source-order, with the original case
+* preserved per piece — re-skeletons compose by re-casing each piece.
+*/
+function splitIdentifierPieces(identifier) {
+	const pieces = [];
+	for (const chunk of identifier.split(/[-_]/)) {
+		if (!chunk) continue;
+		const matches = chunk.match(/[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+[0-9]*|[A-Z]+[0-9]*|[0-9]+/g);
+		if (matches) pieces.push(...matches);
+	}
+	return pieces;
+}
+/**
+* Produce skeleton variants for an identifier query. Returns `null`
+* when the query is not a single identifier or has only one piece
+* (no skeleton structure to vary across) — caller falls through to
+* the literal-search path.
+*
+* The variant set covers the five conventions any real codebase
+* mixes:
+*
+*   getUserName       (lowerCamelCase)
+*   GetUserName       (UpperCamelCase / PascalCase)
+*   get_user_name     (snake_case)
+*   get-user-name     (kebab-case)
+*   GET_USER_NAME     (UPPER_SNAKE_CASE)
+*
+* The set is deduplicated so identifiers that collapse skeletons
+* (e.g., single-word queries) don't bloat the regex pointlessly.
+*/
+function expandIdentifierVariants(query) {
+	if (!SINGLE_IDENTIFIER_REGEX.test(query)) return null;
+	const pieces = splitIdentifierPieces(query);
+	if (pieces.length < 2) return null;
+	const lower = pieces.map((p) => p.toLowerCase());
+	const upper = pieces.map((p) => p.toUpperCase());
+	const cap = lower.map((p) => p.charAt(0).toUpperCase() + p.slice(1));
+	const variants = /* @__PURE__ */ new Set();
+	variants.add(query);
+	variants.add(lower[0] + cap.slice(1).join(""));
+	variants.add(cap.join(""));
+	variants.add(lower.join("_"));
+	variants.add(lower.join("-"));
+	variants.add(upper.join("_"));
+	return Array.from(variants);
+}
+/**
+* Build the rg regex pattern for a set of skeleton variants. The
+* variants are already plain identifiers (no regex metacharacters),
+* so simple alternation suffices. Word boundaries are intentionally
+* NOT applied — the user's mental model for "search for getUserName"
+* is substring-anywhere, which is also what `-F getUserName` did.
+*/
+function buildExpansionPattern(variants) {
+	return "(?:" + variants.join("|") + ")";
+}
+function buildRgArgs(input) {
+	const args = ["--json", "--no-follow"];
+	if (input.contextLines > 0) args.push(`-C`, String(input.contextLines));
+	if (!input.expansionPattern && (input.mode === "literal" || input.mode === "ranked")) args.push("-F");
+	if (input.fileGlob && input.fileGlob !== "**/*") args.push("-g", input.fileGlob);
+	args.push("--", input.expansionPattern ?? input.query, ".");
+	return args;
+}
+/**
+* Stream-parse ripgrep --json output. Two load-bearing behaviors:
+*
+*   1. GLOBAL limit cap (NOT per-file — MEDIUM-10). Once we've
+*      accumulated `limit` hits, send SIGTERM and stop emitting.
+*
+*   2. CANCEL RACE short-circuit (HIGH-9, 3-lab confirmed). The
+*      moment `signal.aborted` flips, detach the line listener AND
+*      return early. A half-flushed truncated JSON line never
+*      reaches JSON.parse — that's the bug we're guarding against.
+*/
+async function parseRgJsonStream(child, opts) {
+	const hits = [];
+	let stdoutBytes = 0;
+	let truncatedByCap = false;
+	let cancelled = false;
+	let scannedFiles = 0;
+	if (opts.signal.aborted) {
+		killChild(child);
+		return {
+			hits,
+			scannedFiles: 0,
+			truncated: false,
+			cancelled: true,
+			stdoutBytes: 0
+		};
+	}
+	const pendingContextBefore = [];
+	let lastHitForContext;
+	if (!child.stdout) return {
+		hits,
+		scannedFiles: 0,
+		truncated: false,
+		cancelled: false,
+		stdoutBytes: 0
+	};
+	const rl = createInterface({
+		input: child.stdout,
+		crlfDelay: Infinity
+	});
+	const onAbort = () => {
+		cancelled = true;
+		rl.close();
+		killChild(child);
+	};
+	opts.signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		for await (const rawLine of rl) {
+			if (cancelled) break;
+			stdoutBytes += rawLine.length + 1;
+			if (stdoutBytes > MAX_STDOUT_BYTES) {
+				truncatedByCap = true;
+				killChild(child);
+				break;
+			}
+			if (rawLine.length === 0) continue;
+			let evt;
+			try {
+				evt = JSON.parse(rawLine);
+			} catch {
+				continue;
+			}
+			switch (evt.type) {
+				case "begin":
+					scannedFiles += 1;
+					pendingContextBefore.length = 0;
+					lastHitForContext = void 0;
+					break;
+				case "context": {
+					const text = stripTrailingNewline(evt.data.lines?.text ?? "");
+					if (lastHitForContext && lastHitForContext.context_after.length < opts.contextLines) lastHitForContext.context_after.push(text);
+					else {
+						pendingContextBefore.push(text);
+						if (pendingContextBefore.length > opts.contextLines) pendingContextBefore.shift();
+					}
+					break;
+				}
+				case "match": {
+					if (hits.length >= opts.limit) {
+						killChild(child);
+						break;
+					}
+					const sub = evt.data.submatches?.[0];
+					if (!evt.data.path || !evt.data.lines || !evt.data.line_number || !sub) break;
+					const hit = {
+						file: evt.data.path.text,
+						line: evt.data.line_number,
+						matched_line: stripTrailingNewline(evt.data.lines.text),
+						match_start: sub.start,
+						match_end: sub.end,
+						context_before: [...pendingContextBefore],
+						context_after: []
+					};
+					pendingContextBefore.length = 0;
+					lastHitForContext = hit;
+					hits.push(hit);
+					break;
+				}
+				case "end":
+				case "summary":
+				default: break;
+			}
+		}
+	} finally {
+		opts.signal.removeEventListener("abort", onAbort);
+	}
+	return {
+		hits,
+		scannedFiles,
+		truncated: truncatedByCap || hits.length >= opts.limit,
+		cancelled,
+		stdoutBytes
+	};
+}
+function stripTrailingNewline(s) {
+	if (s.endsWith("\r\n")) return s.slice(0, -2);
+	if (s.endsWith("\n")) return s.slice(0, -1);
+	return s;
+}
+/**
+* Extension → grammar key. Grammars not in this map skip structural
+* parsing (the hit falls back to the regex SYMBOL_REGEX heuristic for
+* `symbol_context`). Keep this list aligned with `GRAMMAR_FILES`
+* below — adding a language requires both an extension mapping and a
+* `.wasm` to load.
+*/
+const EXTENSION_TO_LANG = {
+	".ts": "typescript",
+	".tsx": "tsx",
+	".js": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".jsx": "javascript",
+	".py": "python",
+	".go": "go",
+	".rs": "rust",
+	".java": "java",
+	".c": "c",
+	".h": "c",
+	".cpp": "cpp",
+	".cc": "cpp",
+	".cxx": "cpp",
+	".hpp": "cpp",
+	".hxx": "cpp"
+};
+/**
+* Grammar key → wasm filename under `node_modules/tree-sitter-wasms/out/`.
+* Resolved at runtime from `node_modules`; the file paths are stable
+* because `tree-sitter-wasms` ships prebuilt binaries (no per-install
+* codegen).
+*/
+const GRAMMAR_FILES = {
+	typescript: "tree-sitter-typescript.wasm",
+	tsx: "tree-sitter-tsx.wasm",
+	javascript: "tree-sitter-javascript.wasm",
+	python: "tree-sitter-python.wasm",
+	go: "tree-sitter-go.wasm",
+	rust: "tree-sitter-rust.wasm",
+	java: "tree-sitter-java.wasm",
+	c: "tree-sitter-c.wasm",
+	cpp: "tree-sitter-cpp.wasm"
+};
+/**
+* Per-language definition-shape node types. When a matched identifier
+* sits inside one of these nodes AND is at the node's "name" position,
+* we have AST-confirmed evidence the line is an identifier-definition
+* site. The brief's enumeration plus a handful of language-idiomatic
+* extras (e.g., `lexical_declaration` for TS/JS top-level `const`s,
+* `mod_item` for Rust modules).
+*
+* The set lookup is per-language so a node type that means
+* "definition" in one language but "reference" in another won't
+* cross-pollute.
+*/
+const DEFINITION_NODE_TYPES = {
+	typescript: new Set([
+		"function_declaration",
+		"function_signature",
+		"function_expression",
+		"method_definition",
+		"method_signature",
+		"class_declaration",
+		"interface_declaration",
+		"type_alias_declaration",
+		"enum_declaration",
+		"variable_declarator",
+		"generator_function_declaration",
+		"abstract_method_signature",
+		"public_field_definition",
+		"property_signature"
+	]),
+	tsx: new Set([
+		"function_declaration",
+		"function_signature",
+		"function_expression",
+		"method_definition",
+		"method_signature",
+		"class_declaration",
+		"interface_declaration",
+		"type_alias_declaration",
+		"enum_declaration",
+		"variable_declarator",
+		"generator_function_declaration",
+		"abstract_method_signature",
+		"public_field_definition",
+		"property_signature"
+	]),
+	javascript: new Set([
+		"function_declaration",
+		"function_expression",
+		"method_definition",
+		"class_declaration",
+		"variable_declarator",
+		"generator_function_declaration"
+	]),
+	python: new Set([
+		"function_definition",
+		"class_definition",
+		"decorated_definition"
+	]),
+	go: new Set([
+		"function_declaration",
+		"method_declaration",
+		"type_spec",
+		"type_alias",
+		"const_spec",
+		"var_spec"
+	]),
+	rust: new Set([
+		"function_item",
+		"impl_item",
+		"trait_item",
+		"struct_item",
+		"enum_item",
+		"mod_item",
+		"type_item",
+		"const_item",
+		"static_item",
+		"macro_definition"
+	]),
+	java: new Set([
+		"class_declaration",
+		"interface_declaration",
+		"method_declaration",
+		"constructor_declaration",
+		"enum_declaration",
+		"field_declaration",
+		"annotation_type_declaration"
+	]),
+	c: new Set([
+		"function_definition",
+		"declaration",
+		"struct_specifier",
+		"enum_specifier",
+		"union_specifier",
+		"type_definition"
+	]),
+	cpp: new Set([
+		"function_definition",
+		"declaration",
+		"struct_specifier",
+		"class_specifier",
+		"enum_specifier",
+		"union_specifier",
+		"type_definition",
+		"namespace_definition",
+		"template_declaration"
+	])
+};
+/**
+* Node types that the AST exposes as "this token is an identifier".
+* The match-position lookup uses these to filter out parent-node hits
+* before checking the definition-site predicate.
+*/
+const IDENTIFIER_NODE_TYPES = new Set([
+	"identifier",
+	"type_identifier",
+	"field_identifier",
+	"property_identifier",
+	"shorthand_property_identifier_pattern",
+	"shorthand_property_identifier",
+	"scoped_identifier",
+	"name"
+]);
+let _grammarBundle;
+/**
+* Resolve the `tree-sitter-wasms/out/` directory at the package root.
+* `require.resolve` is used through a try/catch — the bundled-only
+* fallback runs in environments where node_modules has been pruned to
+* just runtime deps.
+*/
+function resolveGrammarRoot() {
+	try {
+		const pkgPath = __require.resolve("tree-sitter-wasms/package.json");
+		return path$1.join(path$1.dirname(pkgPath), "out");
+	} catch {
+		return null;
+	}
+}
+/**
+* Pre-load all grammars at module-init time so the first search
+* doesn't pay a ~500ms cold-start cost. The Promise is captured at
+* import time and awaited per-call; per-grammar failures are caught
+* individually so one broken grammar can't take the whole tool down.
+*/
+function getGrammarBundle() {
+	if (_grammarBundle) return _grammarBundle;
+	_grammarBundle = { ready: (async () => {
+		const out = /* @__PURE__ */ new Map();
+		try {
+			await Parser.init();
+		} catch (err) {
+			consola.warn(`[code_search] tree-sitter Parser.init failed; structural ranking disabled: ${err.message}`);
+			return out;
+		}
+		const root = resolveGrammarRoot();
+		if (!root) {
+			consola.warn("[code_search] tree-sitter-wasms package not resolvable; structural ranking disabled");
+			return out;
+		}
+		for (const [key, filename] of Object.entries(GRAMMAR_FILES)) {
+			const wasmPath = path$1.join(root, filename);
+			try {
+				const lang = await Parser.Language.load(wasmPath);
+				out.set(key, lang);
+			} catch (err) {
+				consola.warn(`[code_search] failed to load tree-sitter grammar '${key}' from ${filename}: ${err.message}`);
+			}
+		}
+		return out;
+	})() };
+	return _grammarBundle;
+}
+getGrammarBundle().ready.catch(() => {});
+function getLanguageKeyForPath(filePath) {
+	return EXTENSION_TO_LANG[path$1.extname(filePath).toLowerCase()] ?? null;
+}
+const _treeCache = /* @__PURE__ */ new Map();
+function cacheGet(absPath, mtimeMs) {
+	const cur = _treeCache.get(absPath);
+	if (!cur) return void 0;
+	if (cur.mtimeMs !== mtimeMs) {
+		if (cur.tree) try {
+			cur.tree.delete();
+		} catch {}
+		_treeCache.delete(absPath);
+		return;
+	}
+	_treeCache.delete(absPath);
+	_treeCache.set(absPath, cur);
+	return cur;
+}
+function cachePut(absPath, entry) {
+	while (_treeCache.size >= STRUCTURAL_CACHE_MAX) {
+		const firstKey = _treeCache.keys().next().value;
+		if (firstKey === void 0) break;
+		const evicted = _treeCache.get(firstKey);
+		if (evicted?.tree) try {
+			evicted.tree.delete();
+		} catch {}
+		_treeCache.delete(firstKey);
+	}
+	_treeCache.set(absPath, entry);
+}
+/**
+* Compute the absolute byte offset where line `lineNumber1` starts
+* in `source`. Lines are counted by LF; CRLF files have the same
+* line starts as LF files (the \r is part of the previous line's
+* content, not the line break). `lineNumber1` is 1-indexed to match
+* ripgrep's output. Returns -1 if the line is past EOF.
+*/
+function lineStartByte(source, lineNumber1) {
+	if (lineNumber1 <= 1) return 0;
+	let line = 1;
+	for (let i = 0; i < source.length; i++) if (source.charCodeAt(i) === 10) {
+		line += 1;
+		if (line === lineNumber1) return i + 1;
+	}
+	return -1;
+}
+/**
+* Walk up from a matched identifier node looking for the closest
+* definition-shape ancestor (per the language's allowed types). When
+* we find one, verify the matched identifier is at the definition's
+* "name" slot — NOT inside a parameter type, a body, or a parent's
+* signature. Returns true iff this is a real definition site for
+* the identifier the rg submatch landed on.
+*
+* The walk has a small depth bound (6) — definition names sit very
+* close to their definition node in every supported grammar; deeper
+* walks risk false positives (e.g., matching `name` inside the body
+* of an enclosing function and concluding "yes, definition").
+*/
+function isDefiningSite(matchedNode, langKey) {
+	const defTypes = DEFINITION_NODE_TYPES[langKey];
+	if (!defTypes) return false;
+	let cur = matchedNode.parent;
+	let depth = 0;
+	while (cur && depth < 6) {
+		if (defTypes.has(cur.type)) {
+			const nameField = cur.childForFieldName("name");
+			if (nameField && containsByteRange(nameField, matchedNode)) return true;
+			const declarator = cur.childForFieldName("declarator");
+			if (declarator && containsByteRange(declarator, matchedNode)) {
+				const first = firstIdentifierLeaf(declarator);
+				if (first && first.startIndex === matchedNode.startIndex) return true;
+			}
+			const typeField = cur.childForFieldName("type");
+			if (typeField && containsByteRange(typeField, matchedNode)) {
+				const first = firstIdentifierLeaf(typeField);
+				if (first && first.startIndex === matchedNode.startIndex) return true;
+			}
+		}
+		cur = cur.parent;
+		depth += 1;
+	}
+	return false;
+}
+function containsByteRange(outer, inner) {
+	return outer.startIndex <= inner.startIndex && outer.endIndex >= inner.endIndex;
+}
+function firstIdentifierLeaf(node) {
+	if (IDENTIFIER_NODE_TYPES.has(node.type)) return node;
+	for (const child of node.namedChildren) {
+		const r = firstIdentifierLeaf(child);
+		if (r) return r;
+	}
+	return null;
+}
+/**
+* Run the structural-confirmation pass over the top-N already-ranked
+* BM25F hits. Wall-clock-bounded — checked between files, not mid-
+* parse (web-tree-sitter@0.22 doesn't expose a usable cancel hook).
+*
+* Per-file failure modes (file too big, language unsupported, parse
+* error, I/O error) are silent: the file's hits keep the regex
+* `symbol_context` heuristic. Only the wall-clock budget fires the
+* user-visible `fallback` message.
+*/
+async function runStructuralPass(opts) {
+	const result = {
+		confirmedHitIndexes: /* @__PURE__ */ new Set(),
+		fallback: null
+	};
+	if (opts.hitsRanked.length === 0) return result;
+	if (opts.signal.aborted) return result;
+	const grammars = await getGrammarBundle().ready;
+	if (grammars.size === 0) return result;
+	const cap = Math.min(opts.hitsRanked.length, opts.topN);
+	const byFile = /* @__PURE__ */ new Map();
+	for (let i = 0; i < cap; i++) {
+		const entry = opts.hitsRanked[i];
+		const list = byFile.get(entry.hit.file) ?? [];
+		list.push(entry);
+		byFile.set(entry.hit.file, list);
+	}
+	const t0 = Date.now();
+	let filesParsed = 0;
+	let parsersUsed = /* @__PURE__ */ new Map();
+	try {
+		for (const [relFile, entries] of byFile) {
+			if (opts.signal.aborted) break;
+			if (Date.now() - t0 >= opts.budgetMs) {
+				result.fallback = `structural budget exceeded after parsing ${filesParsed}/${cap} hits; retry with structural: "topN" or narrow your query`;
+				break;
+			}
+			const langKey = getLanguageKeyForPath(relFile);
+			if (!langKey) continue;
+			const lang = grammars.get(langKey);
+			if (!lang) continue;
+			const absPath = path$1.join(opts.workspaceRoot, relFile);
+			let mtimeMs;
+			let size;
+			try {
+				const st = statSync(absPath);
+				mtimeMs = st.mtimeMs;
+				size = st.size;
+			} catch (err) {
+				consola.debug(`[code_search] structural skip ${relFile} (stat failed: ${err.message})`);
+				continue;
+			}
+			if (size > STRUCTURAL_MAX_FILE_BYTES) {
+				consola.debug(`[code_search] structural skip ${relFile} (${size} bytes > cap)`);
+				continue;
+			}
+			let cached = cacheGet(absPath, mtimeMs);
+			if (!cached) {
+				let source;
+				try {
+					source = readFileSync(absPath, "utf8");
+				} catch (err) {
+					consola.debug(`[code_search] structural skip ${relFile} (read failed: ${err.message})`);
+					cachePut(absPath, {
+						mtimeMs,
+						tree: null,
+						source: null
+					});
+					continue;
+				}
+				let parser = parsersUsed.get(langKey);
+				if (!parser) {
+					parser = new Parser();
+					parser.setLanguage(lang);
+					parsersUsed.set(langKey, parser);
+				}
+				let tree = null;
+				try {
+					tree = parser.parse(source);
+				} catch (err) {
+					consola.debug(`[code_search] tree-sitter parse failed for ${relFile}: ${err.message}`);
+				}
+				cached = {
+					mtimeMs,
+					tree,
+					source: tree ? source : null
+				};
+				cachePut(absPath, cached);
+				filesParsed += 1;
+			}
+			if (!cached.tree || !cached.source) continue;
+			for (const entry of entries) {
+				const lineStart = lineStartByte(cached.source, entry.hit.line);
+				if (lineStart < 0) continue;
+				const matchByteStart = lineStart + entry.hit.match_start;
+				const matchByteEnd = lineStart + entry.hit.match_end;
+				let node;
+				try {
+					node = cached.tree.rootNode.descendantForIndex(matchByteStart, matchByteEnd);
+				} catch {
+					node = null;
+				}
+				if (!node) continue;
+				if (!IDENTIFIER_NODE_TYPES.has(node.type)) {
+					let cur = node;
+					let depth = 0;
+					while (cur && !IDENTIFIER_NODE_TYPES.has(cur.type) && depth < 3) {
+						const leaf = firstIdentifierLeaf(cur);
+						if (leaf && leaf.startIndex === matchByteStart) {
+							cur = leaf;
+							break;
+						}
+						cur = cur.parent;
+						depth += 1;
+					}
+					node = cur;
+				}
+				if (!node || !IDENTIFIER_NODE_TYPES.has(node.type)) continue;
+				if (isDefiningSite(node, langKey)) result.confirmedHitIndexes.add(entry.index);
+			}
+		}
+	} finally {
+		for (const parser of parsersUsed.values()) try {
+			parser.delete();
+		} catch {}
+		parsersUsed = /* @__PURE__ */ new Map();
+	}
+	return result;
+}
+function extractFields(hit, astConfirmed) {
+	const ctx = [...hit.context_before, ...hit.context_after].join("\n");
+	let symbolContext;
+	if (astConfirmed) {
+		const ident = hit.matched_line.slice(hit.match_start, hit.match_end);
+		symbolContext = ident.length > 0 ? ident : hit.matched_line;
+	} else if (SYMBOL_REGEX.test(hit.matched_line.trimStart())) symbolContext = hit.matched_line;
+	else symbolContext = "";
+	return {
+		match_line: hit.matched_line,
+		context: ctx,
+		file_path: hit.file.replace(/[/\\]/g, " "),
+		symbol_context: symbolContext
+	};
+}
+/**
+* BM25F score for the given hit set against the tokenized query.
+*
+*   BM25F(q, f) = Σ_t  IDF(t) · w_t,f / (w_t,f + k1)
+*
+*   w_t,f = Σ_field  b_field · tf_t,field,f /
+*                    ((1 − l_field) + l_field · len_field,f/avglen_field)
+*
+*   IDF(t) = log( (M − df(t) + 0.5) / (df(t) + 0.5) )
+*
+* Corpus stats are derived from the rg hit set itself — we have no
+* persistent index. M = number of files in the hit set; df(t) = how
+* many of those files contain token `t` in any field; avglen_f =
+* mean tokenized length of field `f` across those files. This is
+* the "compute corpus stats per-call" pattern, which works because
+* M ≤ a few hundred files in practice (sub-second).
+*/
+function bm25fScore(hits, queryTokens, astConfirmedHits) {
+	if (hits.length === 0 || queryTokens.length === 0) return hits.map((h) => ({
+		hit: h,
+		score: 0,
+		field_contributions: {
+			match_line: 0,
+			symbol_context: 0,
+			file_path: 0,
+			context: 0
+		}
+	}));
+	const fileTokenCache = /* @__PURE__ */ new Map();
+	const perHitTokens = [];
+	for (let i = 0; i < hits.length; i++) {
+		const hit = hits[i];
+		const fields = extractFields(hit, astConfirmedHits?.has(i) ?? false);
+		fileTokenCache.set(hit.file, fields);
+		perHitTokens.push({
+			match_line: tokenize(fields.match_line),
+			context: tokenize(fields.context),
+			file_path: tokenize(fields.file_path),
+			symbol_context: tokenize(fields.symbol_context)
+		});
+	}
+	const filesSeen = /* @__PURE__ */ new Set();
+	for (const hit of hits) filesSeen.add(hit.file);
+	const M = filesSeen.size;
+	const df = /* @__PURE__ */ new Map();
+	const fileTokensByField = {
+		match_line: /* @__PURE__ */ new Map(),
+		context: /* @__PURE__ */ new Map(),
+		file_path: /* @__PURE__ */ new Map(),
+		symbol_context: /* @__PURE__ */ new Map()
+	};
+	for (let i = 0; i < hits.length; i++) {
+		const file = hits[i].file;
+		const t = perHitTokens[i];
+		for (const fname of Object.keys(t)) {
+			let bucket = fileTokensByField[fname].get(file);
+			if (!bucket) {
+				bucket = /* @__PURE__ */ new Set();
+				fileTokensByField[fname].set(file, bucket);
+			}
+			for (const tok of t[fname]) bucket.add(tok);
+		}
+	}
+	for (const qt of queryTokens) {
+		const files = /* @__PURE__ */ new Set();
+		for (const fname of Object.keys(fileTokensByField)) for (const [file, tokSet] of fileTokensByField[fname]) if (tokSet.has(qt)) files.add(file);
+		df.set(qt, files.size);
+	}
+	const avglen = {
+		match_line: 0,
+		context: 0,
+		file_path: 0,
+		symbol_context: 0
+	};
+	for (const fname of Object.keys(avglen)) {
+		const lens = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (let i = 0; i < hits.length; i++) {
+			if (seen.has(hits[i].file)) continue;
+			seen.add(hits[i].file);
+			lens.push(perHitTokens[i][fname].length);
+		}
+		avglen[fname] = lens.length > 0 ? lens.reduce((a, b) => a + b, 0) / lens.length : 1;
+		if (avglen[fname] === 0) avglen[fname] = 1;
+	}
+	const idf = /* @__PURE__ */ new Map();
+	for (const qt of queryTokens) {
+		const d = df.get(qt) ?? 0;
+		idf.set(qt, Math.log((M - d + .5) / (d + .5) + 1));
+	}
+	const out = [];
+	for (let i = 0; i < hits.length; i++) {
+		const tokens = perHitTokens[i];
+		const contributions = {
+			match_line: 0,
+			symbol_context: 0,
+			file_path: 0,
+			context: 0
+		};
+		for (const qt of queryTokens) {
+			let w = 0;
+			const perField = {
+				match_line: 0,
+				symbol_context: 0,
+				file_path: 0,
+				context: 0
+			};
+			for (const fname of Object.keys(FIELD_BOOSTS)) {
+				const tf = tokens[fname].filter((t) => t === qt).length;
+				if (tf === 0) continue;
+				const len = tokens[fname].length || 1;
+				const l = FIELD_LEN_NORMS[fname];
+				const norm = 1 - l + l * (len / (avglen[fname] || 1));
+				const fieldContrib = FIELD_BOOSTS[fname] * (tf / norm);
+				w += fieldContrib;
+				perField[fname] = fieldContrib;
+			}
+			if (w === 0) continue;
+			const termScore = (idf.get(qt) ?? 0) * (w / (w + BM25F_K1));
+			for (const fname of Object.keys(perField)) {
+				const share = perField[fname] / w;
+				contributions[fname] += termScore * share;
+			}
+		}
+		const total = Object.values(contributions).reduce((a, b) => a + b, 0);
+		out.push({
+			hit: hits[i],
+			score: total,
+			field_contributions: contributions
+		});
+	}
+	return out;
+}
+function shoulderPrune(scored) {
+	if (scored.length === 0) return {
+		kept: [],
+		prunedBelowShoulder: 0
+	};
+	scored.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		if (a.hit.file !== b.hit.file) return a.hit.file < b.hit.file ? -1 : 1;
+		return a.hit.line - b.hit.line;
+	});
+	const topScore = scored[0].score;
+	if (topScore <= 0) return {
+		kept: scored,
+		prunedBelowShoulder: 0
+	};
+	const threshold = topScore * SHOULDER_THRESHOLD;
+	let cut = scored.length;
+	for (let i = 0; i < scored.length; i++) if (scored[i].score < threshold) {
+		cut = i;
+		break;
+	}
+	return {
+		kept: scored.slice(0, cut),
+		prunedBelowShoulder: scored.length - cut
+	};
+}
+function renderSnippet(hit) {
+	let snippet = [
+		...hit.context_before,
+		hit.matched_line,
+		...hit.context_after
+	].join("\n");
+	if (Buffer.byteLength(snippet, "utf8") > MAX_SNIPPET_BYTES) {
+		const buf = Buffer.from(snippet, "utf8");
+		const halfCap = Math.floor((MAX_SNIPPET_BYTES - 16) / 2);
+		snippet = buf.slice(0, halfCap).toString("utf8") + "\n... [truncated] ...\n" + buf.slice(buf.length - halfCap).toString("utf8");
+	}
+	return snippet;
+}
+async function searchCode(rawInput, externalSignal) {
+	const t0 = Date.now();
+	const inputErr = validateInputs(rawInput);
+	if (inputErr) throw new Error(inputErr);
+	const ws = validateWorkspace(rawInput.workspace);
+	if (!ws.ok || !ws.canonical) throw new Error(ws.error ?? "workspace validation failed");
+	const mode = rawInput.mode ?? "ranked";
+	const structuralMode = rawInput.structural ?? "full";
+	const limit = rawInput.limit ?? DEFAULT_LIMIT;
+	const contextLines = Math.min(rawInput.context_lines ?? DEFAULT_CONTEXT_LINES, MAX_CONTEXT_LINES);
+	const expansion = mode === "regex" ? null : expandIdentifierVariants(rawInput.query);
+	const expansionPattern = expansion ? buildExpansionPattern(expansion) : void 0;
+	const ac = new AbortController();
+	const onExternal = () => ac.abort("external");
+	if (externalSignal) if (externalSignal.aborted) ac.abort("external");
+	else externalSignal.addEventListener("abort", onExternal, { once: true });
+	const wallTimer = setTimeout(() => ac.abort("timeout"), WALL_TIME_MS);
+	wallTimer.unref();
+	let parseResult;
+	let rgResolution;
+	try {
+		rgResolution = resolveRipgrep();
+	} catch (err) {
+		clearTimeout(wallTimer);
+		if (externalSignal) externalSignal.removeEventListener("abort", onExternal);
+		throw err;
+	}
+	const args = buildRgArgs({
+		mode,
+		fileGlob: rawInput.file_glob,
+		contextLines,
+		query: rawInput.query,
+		expansionPattern
+	});
+	let child;
+	try {
+		child = spawn(rgResolution.rgPath, args, {
+			cwd: ws.canonical,
+			shell: false,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch (err) {
+		clearTimeout(wallTimer);
+		if (externalSignal) externalSignal.removeEventListener("abort", onExternal);
+		throw new Error(`failed to spawn ripgrep: ${err.message}`);
+	}
+	const STDERR_TEXT_CAP = 64 * 1024;
+	let stderrBytes = 0;
+	let stderrText = "";
+	if (child.stderr) {
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (chunk) => {
+			stderrBytes += chunk.length;
+			if (stderrText.length < STDERR_TEXT_CAP) stderrText = (stderrText + chunk).slice(0, STDERR_TEXT_CAP);
+			if (stderrBytes > 1024 * 1024) ac.abort("stderr_cap");
+		});
+	}
+	let exitCode = null;
+	const exitPromise = new Promise((resolve) => {
+		child.on("close", (code) => {
+			exitCode = code;
+			resolve();
+		});
+	});
+	try {
+		parseResult = await parseRgJsonStream(child, {
+			limit,
+			contextLines,
+			signal: ac.signal
+		});
+	} finally {
+		clearTimeout(wallTimer);
+		if (externalSignal) externalSignal.removeEventListener("abort", onExternal);
+		if (!child.killed) killChild(child);
+	}
+	if (ac.signal.aborted && parseResult.hits.length === 0) {
+		const reason = String(ac.signal.reason ?? "aborted");
+		throw new Error(`code_search aborted (${reason})`);
+	}
+	if (!ac.signal.aborted) await exitPromise;
+	if (exitCode !== null && exitCode !== 0 && exitCode !== 1 && !ac.signal.aborted && parseResult.hits.length === 0) {
+		const trimmed = stderrText.trim();
+		const detail = trimmed.length > 0 ? trimmed.replace(/^rg:\s*/i, "").slice(0, 600) : `ripgrep exited with code ${exitCode}`;
+		throw new Error(`code_search: ${detail}`);
+	}
+	let kept;
+	let prunedBelowShoulder;
+	let notice = null;
+	if (mode === "ranked") {
+		const queryTokens = tokenize(rawInput.query);
+		const pass1 = bm25fScore(parseResult.hits, queryTokens);
+		pass1.sort((a, b) => b.score - a.score);
+		const topN = structuralMode === "topN" ? STRUCTURAL_TOPN_FAST : STRUCTURAL_TOPN_FULL;
+		const indexByHit = /* @__PURE__ */ new Map();
+		for (let i = 0; i < parseResult.hits.length; i++) indexByHit.set(parseResult.hits[i], i);
+		const structural = await runStructuralPass({
+			hitsRanked: pass1.slice(0, Math.min(topN, pass1.length)).map((sh) => ({
+				hit: sh.hit,
+				index: indexByHit.get(sh.hit) ?? -1
+			})).filter((e) => e.index >= 0),
+			workspaceRoot: ws.canonical,
+			topN,
+			budgetMs: STRUCTURAL_BUDGET_MS,
+			signal: ac.signal
+		});
+		notice = structural.fallback;
+		const pruned = shoulderPrune(bm25fScore(parseResult.hits, queryTokens, structural.confirmedHitIndexes));
+		kept = pruned.kept.slice(0, limit);
+		prunedBelowShoulder = pruned.prunedBelowShoulder;
+	} else kept = parseResult.hits.map((h) => ({
+		hit: h,
+		score: 0,
+		field_contributions: {}
+	}));
+	const results = kept.map((sh) => {
+		let file = sh.hit.file;
+		if (file.startsWith("./") || file.startsWith(".\\")) file = file.slice(2);
+		file = file.replace(/\\/g, "/");
+		const baseHit = {
+			file,
+			line: sh.hit.line,
+			snippet: renderSnippet(sh.hit),
+			match_byte_range: [sh.hit.match_start, sh.hit.match_end]
+		};
+		if (mode === "ranked") {
+			baseHit.score = round4(sh.score);
+			baseHit.field_contributions = {
+				match_line: round4(sh.field_contributions.match_line ?? 0),
+				symbol_context: round4(sh.field_contributions.symbol_context ?? 0),
+				file_path: round4(sh.field_contributions.file_path ?? 0),
+				context: round4(sh.field_contributions.context ?? 0)
+			};
+		} else baseHit.field_contributions = null;
+		return baseHit;
+	});
+	const elapsed_ms = Date.now() - t0;
+	const debugLog = process.env.GH_ROUTER_DEBUG_CODE_SEARCH === "1";
+	consola.info(`[code_search] mode=${mode} structural=${structuralMode} expansion=${expansion ? expansion.length : 0} results=${results.length} truncated=${parseResult.truncated} scanned_files=${parseResult.scannedFiles} elapsed_ms=${elapsed_ms} abort=${parseResult.cancelled} rg=${rgResolution.source} notice=${notice ? "yes" : "no"}` + (debugLog ? ` query="${rawInput.query}" workspace="${ws.canonical}"` : ""));
+	return {
+		results,
+		truncated: parseResult.truncated,
+		pruned_below_shoulder: mode === "ranked" ? prunedBelowShoulder : void 0,
+		scanned_files: parseResult.scannedFiles,
+		elapsed_ms,
+		ranking: mode === "ranked" ? {
+			algorithm: "BM25F",
+			citation: "Robertson, Zaragoza, Taylor 2004",
+			k1: BM25F_K1
+		} : { algorithm: "ripgrep_document_order" },
+		notice
+	};
+}
+function round4(x) {
+	return Math.round(x * 1e4) / 1e4;
+}
+
 //#endregion
 //#region src/services/copilot/web-search.ts
 const RpcSchema = z.object({
@@ -2263,7 +3515,7 @@ function buildPeerAwarenessSnippet(opts) {
 	return [
 		"## Peer review and advisor",
 		"",
-		`Cross-lab peer critics under \`mcp__gh-router-peers__*\` — ${criticList.join(", ")} — plus the \`peer-review-coordinator\` fan-out subagent, and Claude Code's built-in \`advisor\` tool, are available at your discretion for second opinions and adversarial review. Subagents you spawn inherit them.${codexCliClause}`
+		`Cross-lab peer critics under \`mcp__gh-router-peers__*\` — ${criticList.join(", ")} — plus the \`peer-review-coordinator\` fan-out subagent, and Claude Code's built-in \`advisor\` tool, are available at your discretion for second opinions and adversarial review. Subagents you spawn inherit them.${codexCliClause} Also \`mcp__gh-router-peers__code_search\` for accurate ranked code discovery (BM25F + tree-sitter) — prefer it over \`Grep\` when finding definitions or call sites.`
 	].join("\n");
 }
 /** Convenience: every persona that should be registered for the given mode. */
@@ -2328,6 +3580,94 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([{
 			};
 		}
 	}
+}, {
+	toolNameHttp: "code_search",
+	description: "Fast structured code search over a local workspace. Returns ranked, deduplicated hits with snippets. Ranks with BM25F across matched-line / file-path / surrounding-context / symbol-context fields, then refines `symbol-context` with tree-sitter AST analysis on the top hits so identifier definitions outrank incidental string matches. Prefer this over Grep/Bash+grep for ranked discovery (\"where is X defined\", \"which files reference Y\", \"find code that does Z\") — ranked mode surfaces the few right answers instead of every match. Use Grep for exact-pattern enumeration when you need every hit unranked, and Glob for file-name patterns (no content match). `workspace` is any absolute path the proxy process can read — typically the project root or a sub-tree you're working in.",
+	inputSchema: {
+		type: "object",
+		required: ["query", "workspace"],
+		additionalProperties: false,
+		properties: {
+			query: {
+				type: "string",
+				description: "Search text. In 'ranked' (default) and 'literal' modes, interpreted as a literal string. In 'regex' mode, interpreted as a PCRE2 regex. In 'ranked' and 'literal' modes, single-identifier queries are auto-expanded across camelCase / snake_case / kebab-case / SCREAMING_SNAKE skeletons so `getUserName` also matches `get_user_name`."
+			},
+			workspace: {
+				type: "string",
+				description: "Absolute path to the project root (or sub-tree) to search."
+			},
+			mode: {
+				type: "string",
+				enum: [
+					"ranked",
+					"literal",
+					"regex"
+				],
+				description: "Ranking mode. 'ranked' (default): BM25F + tree-sitter structural boost; results ordered by score with shoulder pruning (drops results below 50% of the top score). 'literal': fixed-string search, ripgrep document order. 'regex': PCRE2 search, ripgrep document order."
+			},
+			file_glob: {
+				type: "string",
+				description: "Optional ripgrep glob filter (e.g. 'src/**/*.ts')."
+			},
+			limit: {
+				type: "number",
+				description: "Max hits to return (default 20)."
+			},
+			structural: {
+				type: "string",
+				enum: ["full", "topN"],
+				description: "Structural-ranking depth (ranked mode only). 'full' (default) runs tree-sitter on the top 50 BM25F hits — best signal, fine for typical repos. 'topN' restricts to the top 10 for tighter latency on very large workspaces. Both modes share a 200ms wall-clock budget; on budget exhaustion the response includes `notice` and remaining hits fall back to the regex symbol heuristic."
+			}
+		}
+	},
+	async handler(args, signal) {
+		try {
+			const result = await searchCode({
+				query: typeof args.query === "string" ? args.query : "",
+				workspace: typeof args.workspace === "string" ? args.workspace : "",
+				mode: args.mode === "literal" || args.mode === "regex" || args.mode === "ranked" ? args.mode : void 0,
+				file_glob: typeof args.file_glob === "string" ? args.file_glob : void 0,
+				limit: typeof args.limit === "number" ? args.limit : void 0,
+				structural: args.structural === "full" || args.structural === "topN" ? args.structural : void 0
+			}, signal);
+			const SIZE_CAP_BYTES = 256 * 1024;
+			const trimmedHits = [];
+			let totalBytes = 0;
+			let sizeCapped = false;
+			for (const hit of result.results) {
+				const next = {
+					file: hit.file,
+					line: hit.line,
+					snippet: hit.snippet
+				};
+				const nextBytes = Buffer.byteLength(JSON.stringify(next), "utf8");
+				if (trimmedHits.length > 0 && totalBytes + nextBytes > SIZE_CAP_BYTES) {
+					sizeCapped = true;
+					break;
+				}
+				trimmedHits.push(next);
+				totalBytes += nextBytes;
+			}
+			const minimal = {
+				results: trimmedHits,
+				truncated: result.truncated || sizeCapped
+			};
+			if (sizeCapped) minimal.notice = `response size limit reached at ${trimmedHits.length} hits (~${Math.round(totalBytes / 1024)}KB); narrow your query or lower 'limit' to get all relevant matches`;
+			else if (typeof result.notice === "string") minimal.notice = result.notice;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(minimal)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `code_search failed: ${err instanceof Error ? err.message : String(err)}`
+				}],
+				isError: true
+			};
+		}
+	}
 }]);
 
 //#endregion
@@ -2835,8 +4175,8 @@ const ENDPOINT_ALIASES = {
 * - the model has no `supported_endpoints` field (backward-compat)
 * - the endpoint is listed in `supported_endpoints`
 */
-function modelSupportsEndpoint(modelId, path$1) {
-	const endpoint = ENDPOINT_ALIASES[path$1] ?? path$1;
+function modelSupportsEndpoint(modelId, path$2) {
+	const endpoint = ENDPOINT_ALIASES[path$2] ?? path$2;
 	const model = state.models?.data.find((m) => m.id === modelId);
 	if (!model) return true;
 	const supported = model.supported_endpoints;
@@ -2847,17 +4187,17 @@ function modelSupportsEndpoint(modelId, path$1) {
 * Log an error when a model is used on an endpoint it doesn't support.
 * Returns `true` if a mismatch was detected (for testing).
 */
-function logEndpointMismatch(modelId, path$1) {
-	if (modelSupportsEndpoint(modelId, path$1)) return false;
+function logEndpointMismatch(modelId, path$2) {
+	if (modelSupportsEndpoint(modelId, path$2)) return false;
 	const supported = (state.models?.data.find((m) => m.id === modelId))?.supported_endpoints ?? [];
-	consola.error(`Model "${modelId}" does not support ${path$1}. Supported endpoints: ${supported.join(", ")}`);
+	consola.error(`Model "${modelId}" does not support ${path$2}. Supported endpoints: ${supported.join(", ")}`);
 	return true;
 }
 /**
 * Return model IDs that support the given endpoint.
 */
-function listModelsForEndpoint(path$1) {
-	const endpoint = ENDPOINT_ALIASES[path$1] ?? path$1;
+function listModelsForEndpoint(path$2) {
+	const endpoint = ENDPOINT_ALIASES[path$2] ?? path$2;
 	return (state.models?.data ?? []).filter((m) => {
 		const supported = m.supported_endpoints;
 		if (!supported || supported.length === 0) return true;
@@ -2914,7 +4254,7 @@ function initProxyFromEnv() {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version = "0.3.27";
+var version = "0.3.28";
 
 //#endregion
 //#region src/lib/approval.ts