@opengeni/jev 0.1.0-canary.36199476632001

package/dist/index.js

@@ -0,0 +1,3110 @@
+// src/client.ts
+var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
+var JEV_DEFAULT_MODEL = "jev-latest";
+var JEV_PRICE_PER_MILLION_INPUT_TOKENS_USD = 0.042;
+function noul(instructions, criteria) {
+  return criteria ? { type: "noul", instructions, criteria } : { type: "noul", instructions };
+}
+function jevCostUsd(inputTokens) {
+  return inputTokens * JEV_PRICE_PER_MILLION_INPUT_TOKENS_USD / 1e6;
+}
+var JevError = class extends Error {
+  /** HTTP status of the failed response, when there was one. */
+  status;
+  /** Machine-readable reason when known (for example "max_tokens_exceeded" or "state_too_large"). */
+  code;
+  constructor(message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = new.target.name;
+    this.status = options.status;
+    this.code = options.code;
+  }
+};
+var JevUnavailableError = class extends JevError {
+};
+var JevRequestError = class extends JevError {
+};
+var JEV_DEFAULT_LIMITS = {
+  stateLongestMax: 32e3,
+  stateAllMax: 64e3,
+  safety: 0.9,
+  perRequestOverhead: 300,
+  perQuestionOverhead: 12,
+  maxQuestionsPerRequest: 256
+};
+var JEV_CHARS_PER_TOKEN = 3;
+function estimateJevTokens(value, charsPerToken = JEV_CHARS_PER_TOKEN) {
+  const s = typeof value === "string" ? value : JSON.stringify(value ?? "");
+  return Math.ceil(s.length / charsPerToken);
+}
+function planChunks(stateTokens, questionTokens, limits = JEV_DEFAULT_LIMITS) {
+  const longestCap = limits.stateLongestMax * limits.safety;
+  const allCap = limits.stateAllMax * limits.safety;
+  const base = stateTokens + limits.perRequestOverhead;
+  const chunks = [];
+  let cur = [];
+  let curSum = 0;
+  for (const [id, qt] of questionTokens) {
+    const cost = qt + limits.perQuestionOverhead;
+    if (base + cost > longestCap) {
+      throw new JevRequestError(
+        `Jev state (~${stateTokens} tokens) plus question "${id}" (~${qt} tokens) exceeds ~${Math.floor(longestCap)} tokens`,
+        { code: "state_too_large" }
+      );
+    }
+    if (cur.length > 0 && (base + curSum + cost > allCap || cur.length >= limits.maxQuestionsPerRequest)) {
+      chunks.push(cur);
+      cur = [];
+      curSum = 0;
+    }
+    cur.push(id);
+    curSum += cost;
+  }
+  if (cur.length) chunks.push(cur);
+  return chunks;
+}
+var JevLimiter = class {
+  constructor(max) {
+    this.max = max;
+  }
+  active = 0;
+  queue = [];
+  async run(fn, signal) {
+    await this.acquire(signal);
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  acquire(signal) {
+    signal?.throwIfAborted();
+    if (this.active < this.max) {
+      this.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        const i = this.queue.indexOf(entry);
+        if (i >= 0) this.queue.splice(i, 1);
+        reject(signal?.reason);
+      };
+      const entry = {
+        grant: () => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve();
+        }
+      };
+      this.queue.push(entry);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /** A released slot passes straight to the next waiter, so `active` never overshoots `max`. */
+  release() {
+    const next = this.queue.shift();
+    if (next) next.grant();
+    else this.active -= 1;
+  }
+};
+var RETRYABLE_STATUS = (status) => status === 429 || status >= 500 && status <= 599;
+var AUTH_STATUS = (status) => status === 401 || status === 402 || status === 403;
+var WARM_WINDOW_MS = 4e3;
+var WARM_TIMEOUT_MS = 3e3;
+var MAX_DETAIL_CHARS = 200;
+var JevClient = class {
+  baseUrl;
+  model;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  maxRetryAfterMs;
+  retryBaseDelayMs;
+  fetchImpl;
+  limiter;
+  lastActivityAt = -Infinity;
+  constructor(options) {
+    if (!options.apiKey) throw new JevUnavailableError("Jev API key is not configured");
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? JEV_DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.model = options.model ?? JEV_DEFAULT_MODEL;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.maxRetries = Math.max(0, options.maxRetries ?? 2);
+    this.maxRetryAfterMs = Math.max(0, options.maxRetryAfterMs ?? 2e3);
+    this.retryBaseDelayMs = Math.max(0, options.retryBaseDelayMs ?? 250);
+    this.limiter = new JevLimiter(Math.max(1, options.concurrency ?? 16));
+    this.fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+  }
+  /**
+   * Ask many questions about one state. Splits the questions into several requests when they exceed the
+   * limits, runs them concurrently (bounded by `concurrency`) and merges the answers.
+   */
+  async ask(state, questions, options = {}) {
+    const { signal } = options;
+    signal?.throwIfAborted();
+    const ids = Object.keys(questions);
+    if (!ids.length) throw new JevRequestError("Jev ask() needs at least one question");
+    const stateTokens = estimateJevTokens(state);
+    const chunks = planChunks(
+      stateTokens,
+      ids.map((id) => [id, estimateJevTokens(questions[id])])
+    );
+    const label = options.tag ? `${options.tag}: ` : "";
+    const results = await Promise.all(
+      chunks.map(
+        (chunk2) => this.limiter.run(
+          () => this.post(
+            JSON.stringify({
+              state,
+              model: this.model,
+              questions: Object.fromEntries(chunk2.map((id) => [id, questions[id]]))
+            }),
+            label,
+            signal
+          ),
+          signal
+        )
+      )
+    );
+    const answers = {};
+    let inputTokens = 0;
+    let model = "";
+    results.forEach((json, i) => {
+      const got = isRecord(json.answers) ? json.answers : {};
+      for (const id of chunks[i]) {
+        const answer = normalizeAnswer(got[id]);
+        if (!answer)
+          throw new JevUnavailableError(`${label}Jev response is missing the answer "${id}"`);
+        answers[id] = answer;
+      }
+      const usage = isRecord(json.usage) ? json.usage : {};
+      inputTokens += Number(usage.input_tokens ?? 0) || 0;
+      if (typeof json.model === "string" && json.model) model = json.model;
+    });
+    return {
+      answers,
+      model,
+      usage: { inputTokens },
+      requests: results.length,
+      costUsd: jevCostUsd(inputTokens)
+    };
+  }
+  /**
+   * Open keep-alive connections before a burst of parallel requests (a cold TLS connection costs ~0.7 s).
+   * GET /healthz is free. Skipped when the client was active within the last few seconds; never throws.
+   */
+  warmUp(connections) {
+    const now = Date.now();
+    if (connections <= 0 || now - this.lastActivityAt < WARM_WINDOW_MS) return;
+    this.lastActivityAt = now;
+    for (let i = 0; i < connections; i++) {
+      const timeout = AbortSignal.timeout(WARM_TIMEOUT_MS);
+      this.fetchImpl(`${this.baseUrl}/healthz`, { method: "GET", signal: timeout }).then((res) => res.arrayBuffer()).catch(() => void 0);
+    }
+  }
+  /** One HTTP request with retries. Returns the parsed JSON body of a 2xx response. */
+  async post(body, label, signal) {
+    const url = `${this.baseUrl}/v1/systemone`;
+    const headers = { "content-type": "application/json", authorization: `Bearer ${this.apiKey}` };
+    let lastError = "unknown error";
+    let lastStatus;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      signal?.throwIfAborted();
+      const attemptSignal = withTimeout(signal, this.timeoutMs);
+      let delay = this.backoff(attempt);
+      let response = null;
+      try {
+        const res = await this.fetchImpl(url, {
+          method: "POST",
+          headers,
+          body,
+          signal: attemptSignal.signal
+        });
+        response = { res, text: await res.text() };
+      } catch (error) {
+        if (signal?.aborted) throw signal.reason;
+        lastStatus = void 0;
+        lastError = attemptSignal.timedOut() ? `timed out after ${this.timeoutMs} ms` : describeError(error);
+      } finally {
+        attemptSignal.dispose();
+        this.lastActivityAt = Date.now();
+      }
+      if (response) {
+        const { res, text } = response;
+        if (res.ok) {
+          const json = parseJson(text);
+          if (!isRecord(json))
+            throw new JevUnavailableError(`${label}Jev returned an invalid response body`);
+          return json;
+        }
+        const detail = errorDetail(text);
+        const suffix = detail.message ? `: ${detail.message}` : "";
+        if (AUTH_STATUS(res.status)) {
+          const what = res.status === 402 ? "billing or credits" : "authentication";
+          throw new JevUnavailableError(
+            `${label}Jev ${what} failed (HTTP ${res.status}${suffix})`,
+            errorOptions(res.status, detail.code)
+          );
+        }
+        if (!RETRYABLE_STATUS(res.status)) {
+          throw new JevRequestError(
+            `${label}Jev rejected the request (HTTP ${res.status}${suffix})`,
+            errorOptions(res.status, detail.code)
+          );
+        }
+        lastStatus = res.status;
+        lastError = `HTTP ${res.status}${suffix}`;
+        const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+        if (retryAfter !== null) delay = Math.min(retryAfter, this.maxRetryAfterMs);
+      }
+      if (attempt < this.maxRetries) await sleep(delay, signal);
+    }
+    throw new JevUnavailableError(
+      `${label}Jev unavailable after ${this.maxRetries + 1} attempts (${lastError})`,
+      lastStatus === void 0 ? {} : { status: lastStatus }
+    );
+  }
+  backoff(attempt) {
+    const base = Math.min(this.maxRetryAfterMs, this.retryBaseDelayMs * 2 ** attempt);
+    return Math.round(base * (1 - Math.random() * 0.25));
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(text) {
+  try {
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeAnswer(raw) {
+  if (!isRecord(raw)) return null;
+  if (raw.type === "noul") {
+    return { type: "noul", probability: typeof raw.noul === "number" ? raw.noul : Number.NaN };
+  }
+  if (raw.type === "choice") {
+    const answer = {
+      type: "choice",
+      option: String(raw.choice ?? raw.option ?? "")
+    };
+    if (isRecord(raw.probabilities))
+      answer.probabilities = raw.probabilities;
+    if (typeof raw.confidence === "number") answer.confidence = raw.confidence;
+    return answer;
+  }
+  if (raw.type === "score")
+    return { ...raw, type: "score", score: Number(raw.score) };
+  return null;
+}
+function errorOptions(status, code) {
+  return code === void 0 ? { status } : { status, code };
+}
+function errorDetail(text) {
+  const json = parseJson(text);
+  const codes = [];
+  let message = "";
+  const visit = (value) => {
+    if (typeof value === "string") {
+      if (!message) message = value;
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (!message) message = JSON.stringify(value);
+      return;
+    }
+    if (!isRecord(value)) return;
+    for (const key of ["code", "type"]) {
+      const v = value[key];
+      if (typeof v === "string" && v !== "error") codes.push(v);
+    }
+    for (const key of ["detail", "error", "message", "msg"]) if (key in value) visit(value[key]);
+  };
+  if (json === null) message = text.trim();
+  else visit(json);
+  let code = codes[0];
+  if (!code && /^[a-z][a-z0-9_]{2,60}$/.test(message)) code = message;
+  return { code, message: message.replace(/\s+/g, " ").slice(0, MAX_DETAIL_CHARS) };
+}
+function parseRetryAfter(header) {
+  if (!header) return null;
+  const secs = Number(header);
+  if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+  const at = Date.parse(header);
+  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : null;
+}
+function describeError(error) {
+  const text = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return text.slice(0, MAX_DETAIL_CHARS);
+}
+function withTimeout(parent, timeoutMs) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => controller.abort(parent?.reason);
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new JevUnavailableError(`Jev request timed out after ${timeoutMs} ms`));
+  }, timeoutMs);
+  if (parent?.aborted) controller.abort(parent.reason);
+  else parent?.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    dispose: () => {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/circuit-breaker.ts
+var JevCircuitBreaker = class {
+  failureThreshold;
+  cooldownMs;
+  authCooldownMs;
+  trialTimeoutMs;
+  consecutiveFailures = 0;
+  openUntil = null;
+  trial = null;
+  nextLeaseId = 1;
+  lastFailure = null;
+  constructor(options = {}) {
+    this.failureThreshold = Math.max(1, options.failureThreshold ?? 3);
+    this.cooldownMs = options.cooldownMs ?? 5 * 6e4;
+    this.authCooldownMs = options.authCooldownMs ?? 30 * 6e4;
+    this.trialTimeoutMs = options.trialTimeoutMs ?? 10 * 6e4;
+  }
+  /** True while calls should be refused without contacting Jev (the cooldown is running). */
+  isOpen(now = Date.now()) {
+    return this.openUntil !== null && now < this.openUntil;
+  }
+  /**
+   * Admit one call and return its lease, or null when refused. Closed: always. Open: never. Half-open:
+   * only the first caller, as the trial, until its lease is settled or it has run for trialTimeoutMs, so
+   * a trial that never ends cannot block the tool for good.
+   */
+  tryAcquire(now = Date.now()) {
+    if (this.openUntil === null) return this.issue(false);
+    if (now < this.openUntil) return null;
+    if (this.trial !== null && now - this.trial.startedAt < this.trialTimeoutMs) return null;
+    const lease = this.issue(true);
+    this.trial = { lease, startedAt: now };
+    return lease;
+  }
+  /** End an admitted call that did not contact Jev, so its outcome says nothing about Jev. */
+  release(lease) {
+    if (this.trial !== null && this.trial.lease === lease) this.trial = null;
+  }
+  /** Any call's success proves Jev works, so the lease does not change the outcome. */
+  recordSuccess(_lease) {
+    this.consecutiveFailures = 0;
+    this.openUntil = null;
+    this.trial = null;
+  }
+  /** Settle a failed call. A failure without a lease counts the same but never ends a trial. */
+  recordFailure(error, now = Date.now(), lease) {
+    if (!(error instanceof JevUnavailableError)) {
+      if (lease) this.release(lease);
+      return;
+    }
+    const halfOpen = this.openUntil !== null && now >= this.openUntil;
+    this.consecutiveFailures += 1;
+    this.lastFailure = { message: error.message, status: error.status ?? null, at: now };
+    if (halfOpen || this.consecutiveFailures >= this.failureThreshold) {
+      const auth = error.status === 401 || error.status === 402 || error.status === 403;
+      this.openUntil = now + (auth ? this.authCooldownMs : this.cooldownMs);
+      this.trial = null;
+    }
+  }
+  status(now = Date.now()) {
+    const state = this.openUntil === null ? "closed" : now < this.openUntil ? "open" : "half_open";
+    return {
+      state,
+      consecutiveFailures: this.consecutiveFailures,
+      openUntil: state === "open" ? this.openUntil : null,
+      trialInFlight: state === "half_open" && this.trial !== null && now - this.trial.startedAt < this.trialTimeoutMs,
+      lastFailure: this.lastFailure
+    };
+  }
+  issue(trial) {
+    return Object.freeze({ id: this.nextLeaseId++, trial });
+  }
+};
+
+// src/code-search/config.ts
+var DEFAULT_CODE_SEARCH_CONFIG = deepFreeze({
+  recall: {
+    maxCandidates: 240,
+    maxMatchesPerFile: 25,
+    maxFileBytes: 4e6,
+    maxLineColumns: 8e3,
+    testWeight: 0.6,
+    pathBonus: 0.5,
+    hitCountWeight: 0.1,
+    shortWordMaxLen: 5,
+    fragmentFallback: true,
+    minCandidatesBeforeWiden: 5,
+    extraExcludes: [],
+    searchHidden: true,
+    changelogWeight: 0.6,
+    ripgrepTimeoutMs: 3e4
+  },
+  wave1: {
+    filesPerRequest: 60,
+    hitLinesPerFile: 3,
+    hitLineChars: 160,
+    maxFiles: 16,
+    minFiles: 8,
+    lexicalGuard: 5
+  },
+  wave2: {
+    windowsPerFile: 5,
+    seedHitsPerFile: 24,
+    maxUp: 40,
+    maxDown: 120,
+    maxWindowLines: 150,
+    fallbackBefore: 10,
+    fallbackAfter: 30,
+    mergeGap: 2,
+    minWindowLines: 12,
+    passagesPerRequest: 4,
+    maxRequestChars: 24e3,
+    maxPassages: 80,
+    maxLineChars: 400,
+    maxProseLineChars: 1600,
+    maxWindowChars: 8e3,
+    maxProseWindowChars: 4e3
+  },
+  wave3: {
+    enabled: true,
+    maxLeadCandidates: 60,
+    maxLeadsFollowed: 6,
+    seedPassages: 12,
+    defsPerLead: 1
+  },
+  status: { enabled: true, maxEvidenceChars: 6e4, hi: 0.7, lo: 0.4 },
+  pack: {
+    charsPerToken: 3.2,
+    minPassages: 4,
+    minRelevance: 0.1,
+    fillBudget: false,
+    moreCandidates: 10,
+    leadsNotFollowed: 8,
+    minTrimLines: 15,
+    filePenalty: 0.1,
+    maxPassageChars: 3200,
+    changelogPrior: 0.5,
+    docPrior: 0.85,
+    testPrior: 1,
+    lexWeight: 0
+  },
+  jev: {
+    inlineQuestionMaxChars: 600,
+    fileCriteriaPerQuestion: false,
+    warmConnections: 12
+  },
+  // calibrated on the DEV split from the observed score distributions (relevant files mostly 0.6-0.9;
+  // minFiles and the lexical guard keep recall when few files pass)
+  thresholds: { T1: 0.6, T2: 0.5, T3: 0.5 }
+});
+function codeSearchConfig(override = {}) {
+  const base = structuredClone(DEFAULT_CODE_SEARCH_CONFIG);
+  const out = base;
+  for (const [section, values] of Object.entries(override)) {
+    const target = out[section];
+    if (!target) throw new Error(`unknown code_search config section: ${section}`);
+    if (!isPlainObject(values)) throw new Error(`code_search config ${section}: expected object`);
+    for (const [key, value] of Object.entries(values)) {
+      if (!(key in target)) throw new Error(`unknown code_search config key: ${section}.${key}`);
+      const current = target[key];
+      if (Array.isArray(current) ? !Array.isArray(value) : typeof current !== typeof value) {
+        throw new Error(
+          `code_search config ${section}.${key}: expected ${Array.isArray(current) ? "array" : typeof current}`
+        );
+      }
+      target[key] = value;
+    }
+  }
+  validateCodeSearchConfig(base);
+  return base;
+}
+function validateCodeSearchConfig(c) {
+  const probs = [];
+  for (const [k, v] of Object.entries(c.thresholds))
+    if (!(v >= 0 && v <= 1)) probs.push(`thresholds.${k} must be in [0,1]`);
+  if (c.wave1.maxFiles < 1) probs.push("wave1.maxFiles must be >= 1");
+  if (c.wave1.minFiles > c.wave1.maxFiles) probs.push("wave1.minFiles must be <= wave1.maxFiles");
+  if (c.wave1.filesPerRequest < 1 || c.wave1.filesPerRequest > 250)
+    probs.push("wave1.filesPerRequest must be 1..250");
+  if (c.wave2.passagesPerRequest < 1) probs.push("wave2.passagesPerRequest must be >= 1");
+  if (c.wave2.maxWindowLines < 10) probs.push("wave2.maxWindowLines must be >= 10");
+  if (c.wave2.maxWindowChars < 4 * c.wave2.maxLineChars)
+    probs.push("wave2.maxWindowChars must be >= 4 x wave2.maxLineChars");
+  if (c.wave2.maxProseWindowChars < 2 * c.wave2.maxProseLineChars + 200) {
+    probs.push("wave2.maxProseWindowChars must be >= 2 x wave2.maxProseLineChars + 200");
+  }
+  if (c.wave3.maxLeadCandidates > 250) probs.push("wave3.maxLeadCandidates must be <= 250");
+  if (!(c.status.lo <= c.status.hi)) probs.push("status.lo must be <= status.hi");
+  if (c.pack.charsPerToken <= 0) probs.push("pack.charsPerToken must be > 0");
+  if (c.pack.filePenalty < 0) probs.push("pack.filePenalty must be >= 0");
+  if (c.pack.maxPassageChars !== 0 && c.pack.maxPassageChars < 600)
+    probs.push("pack.maxPassageChars must be 0 or >= 600");
+  for (const k of ["changelogPrior", "docPrior", "testPrior"]) {
+    if (!(c.pack[k] > 0 && c.pack[k] <= 1)) probs.push(`pack.${k} must be in (0,1]`);
+  }
+  if (!(c.pack.lexWeight >= 0)) probs.push("pack.lexWeight must be >= 0");
+  if (!(c.recall.changelogWeight > 0 && c.recall.changelogWeight <= 1))
+    probs.push("recall.changelogWeight must be in (0,1]");
+  if (!(c.recall.ripgrepTimeoutMs > 0)) probs.push("recall.ripgrepTimeoutMs must be > 0");
+  if (probs.length) throw new Error(`invalid code_search config: ${probs.join("; ")}`);
+}
+function isPlainObject(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null) {
+    for (const v of Object.values(value)) deepFreeze(v);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+// src/code-search/judge.ts
+var PROMPTS = {
+  fileTask: "Code search triage for a software repository. A developer asked `question`. `files` lists candidate files found by keyword search; each entry is the file path followed by up to 3 matching lines as `line: text`. Judge each file independently by its path and matching lines.",
+  fileCriteria: {
+    yes: "Reading this file would likely help answer the question: it probably implements, decides, computes, configures, enforces or documents the asked behavior. A doc or design note that explains the behavior counts.",
+    no: "The file probably only mentions the same words, imports or passes values through, belongs to an unrelated feature that shares keywords, or is a test that is not about the asked behavior."
+  },
+  fileQuestion: (id, path, q) => `Would reading file \`files.${id}\` (${path}) help answer the question${q}? Apply \`criteria\`.`,
+  fileQuestionPerQ: (id, path, q) => `Would reading file \`files.${id}\` (${path}) help answer the question${q}?`,
+  passageTask: "Evidence check for a question about a software repository. Each entry in `passages` is a verbatim excerpt of one repository file with its original line numbers (`N| text`). `in` names the enclosing declaration when the excerpt starts inside one. Judge each passage on its own content only.",
+  passageQuestion: (id, path, a, b, q) => `Does \`passages.${id}\` (${path} lines ${a}-${b}) contain code or text needed to answer the question${q}?`,
+  passageCriteria: {
+    true: "The passage implements, decides, computes, configures, enforces or documents part of the asked behavior. A helper that performs one asked step counts, and so does a doc passage that states the behavior.",
+    false: "The passage only mentions, imports, calls or passes through names related to the question, is a test or type declaration that does not show the behavior, or is unrelated code that shares keywords."
+  },
+  coverageQuestion: (id, path, a, b, sub) => `Does \`passages.${id}\` (${path} lines ${a}-${b}) show the answer to this part of the question: "${sub}"?`,
+  coverageCriteria: {
+    true: "The passage itself states or implements the answer to this part.",
+    false: "The passage does not address this part, or only mentions it without showing the answer."
+  },
+  leadTask: "Follow-up selection for a question about a software repository. Evidence passages already found reference the identifiers in `leads`, whose definitions have not been read yet. Each lead shows the identifier, where it was seen, and the line it appears on.",
+  leadCriteria: {
+    yes: "The definition likely computes, decides, configures or enforces part of the asked behavior, or holds a constant, setting or rule that the answer depends on.",
+    no: "It is a generic helper (logging, formatting, errors, type plumbing, database or HTTP plumbing) or it is unrelated to the question."
+  },
+  leadQuestion: (id, name, q) => `Would reading where \`${name}\` (\`leads.${id}\`) is defined help answer the question${q}? Apply \`criteria\`.`,
+  statusTask: "Sufficiency check. `evidence` is a set of verbatim excerpts of repository files (with original line numbers) collected to answer `question`.",
+  statusQuestion: (q) => `Do the \`evidence\` passages show the answer to the question${q}?`,
+  statusSubQuestion: (sub) => `Do the \`evidence\` passages show the answer to this part of the question: "${sub}"?`,
+  statusCriteria: {
+    true: "Together the passages state or implement the answer concretely enough to cite file and line.",
+    false: "Some part of the answer is missing: the passages only mention the topic, or the deciding code is elsewhere."
+  }
+};
+function inlineQ(question, maxChars) {
+  return question.length <= maxChars ? `: "${question}"` : " in `question`";
+}
+function withSubs(ctx) {
+  return ctx.subQuestions.length ? { sub_questions: Object.fromEntries(ctx.subQuestions.map((s, i) => [`s${i + 1}`, s])) } : {};
+}
+function buildFileRequest(items, ctx, cfg) {
+  const q = inlineQ(ctx.question, cfg.jev.inlineQuestionMaxChars);
+  const perQ = cfg.jev.fileCriteriaPerQuestion;
+  const state = {
+    task: PROMPTS.fileTask,
+    question: ctx.question,
+    ...withSubs(ctx),
+    ...perQ ? {} : { criteria: PROMPTS.fileCriteria },
+    files: Object.fromEntries(items.map((f) => [f.id, f.descriptor]))
+  };
+  const questions = Object.fromEntries(
+    items.map((f) => [
+      f.id,
+      perQ ? noul(PROMPTS.fileQuestionPerQ(f.id, f.path, q), {
+        true: PROMPTS.fileCriteria.yes,
+        false: PROMPTS.fileCriteria.no
+      }) : noul(PROMPTS.fileQuestion(f.id, f.path, q))
+    ])
+  );
+  return { state, questions };
+}
+function buildPassageRequest(items, ctx, cfg) {
+  const q = inlineQ(ctx.question, cfg.jev.inlineQuestionMaxChars);
+  const state = {
+    task: PROMPTS.passageTask,
+    question: ctx.question,
+    ...withSubs(ctx),
+    passages: Object.fromEntries(
+      items.map((p) => [
+        p.id,
+        {
+          file: p.path,
+          lines: `${p.start}-${p.end}`,
+          ...p.label ? { in: p.label } : {},
+          text: p.text
+        }
+      ])
+    )
+  };
+  const questions = {};
+  for (const p of items) {
+    questions[`rel::${p.id}`] = noul(
+      PROMPTS.passageQuestion(p.id, p.path, p.start, p.end, q),
+      PROMPTS.passageCriteria
+    );
+    ctx.subQuestions.forEach((sub, j) => {
+      questions[`cov::${p.id}::${j}`] = noul(
+        PROMPTS.coverageQuestion(p.id, p.path, p.start, p.end, sub),
+        PROMPTS.coverageCriteria
+      );
+    });
+  }
+  return { state, questions };
+}
+function buildLeadRequest(items, ctx, cfg) {
+  const q = inlineQ(ctx.question, cfg.jev.inlineQuestionMaxChars);
+  const state = {
+    task: PROMPTS.leadTask,
+    question: ctx.question,
+    ...withSubs(ctx),
+    criteria: PROMPTS.leadCriteria,
+    leads: Object.fromEntries(
+      items.map((l) => [l.id, `${l.name}  (seen at ${l.seenAt})  ${l.context}`])
+    )
+  };
+  const questions = Object.fromEntries(
+    items.map((l) => [l.id, noul(PROMPTS.leadQuestion(l.id, l.name, q))])
+  );
+  return { state, questions };
+}
+function buildStatusRequest(evidence, ctx, cfg) {
+  const q = inlineQ(ctx.question, cfg.jev.inlineQuestionMaxChars);
+  const state = { task: PROMPTS.statusTask, question: ctx.question, ...withSubs(ctx), evidence };
+  const questions = {
+    overall: noul(PROMPTS.statusQuestion(q), PROMPTS.statusCriteria)
+  };
+  ctx.subQuestions.forEach((sub, j) => {
+    questions[`sub::${j}`] = noul(PROMPTS.statusSubQuestion(sub), PROMPTS.statusCriteria);
+  });
+  return { state, questions };
+}
+function chunkPassages(items, perRequest, maxChars) {
+  const out = [];
+  let cur = [];
+  let chars = 0;
+  for (const p of items) {
+    const c = p.text.length;
+    if (cur.length && (cur.length >= perRequest || chars + c > maxChars)) {
+      out.push(cur);
+      cur = [];
+      chars = 0;
+    }
+    cur.push(p);
+    chars += c;
+  }
+  if (cur.length) out.push(cur);
+  return out;
+}
+function chunkEven(xs, n) {
+  if (!xs.length) return [];
+  const groups = Math.ceil(xs.length / n);
+  const size = Math.ceil(xs.length / groups);
+  return chunk(xs, size);
+}
+function chunk(xs, n) {
+  const out = [];
+  for (let i = 0; i < xs.length; i += n) out.push(xs.slice(i, i + n));
+  return out;
+}
+var noulOf = (a) => a && a.type === "noul" && Number.isFinite(a.probability) ? a.probability : Number.NaN;
+function orLex(p, lex) {
+  return Number.isFinite(p) ? p : lex;
+}
+var JevJudge = class {
+  constructor(o) {
+    this.o = o;
+  }
+  stageStats = {};
+  jevModel = null;
+  stats() {
+    return this.stageStats;
+  }
+  model() {
+    return this.jevModel;
+  }
+  stat(stage) {
+    return this.stageStats[stage] ??= { requests: 0, inputTokens: 0, costUsd: 0, ms: 0 };
+  }
+  /** One logical request (the client may split its questions into several HTTP requests). */
+  async ask(stage, state, questions) {
+    const t0 = performance.now();
+    const r = await this.o.client.ask(state, questions, {
+      tag: stage,
+      signal: this.o.signal
+    });
+    const st = this.stat(stage);
+    st.requests += r.requests;
+    st.inputTokens += r.usage.inputTokens;
+    st.costUsd += r.costUsd;
+    this.jevModel = r.model || this.jevModel;
+    this.o.onEvent?.("jev", {
+      jevStage: stage,
+      ms: Math.round(performance.now() - t0),
+      requests: r.requests,
+      model: r.model,
+      inputTokens: r.usage.inputTokens,
+      costUsd: r.costUsd,
+      state,
+      questions,
+      answers: r.answers
+    });
+    return r.answers;
+  }
+  /** Run a stage's batches in parallel; the first failure rejects the stage. */
+  async stage(stage, batches, build, read) {
+    const t0 = performance.now();
+    try {
+      const results = await Promise.all(
+        batches.map(async (b) => {
+          const req = build(b);
+          return read(b, await this.ask(stage, req.state, req.questions));
+        })
+      );
+      return new Map(results.flat());
+    } finally {
+      this.stat(stage).ms += Math.round(performance.now() - t0);
+    }
+  }
+  async scoreFiles(items, ctx) {
+    if (!items.length) return /* @__PURE__ */ new Map();
+    return this.stage(
+      "wave1",
+      chunkEven(items, this.o.config.wave1.filesPerRequest),
+      (b) => buildFileRequest(b, ctx, this.o.config),
+      (b, a) => b.map((f) => [f.id, orLex(noulOf(a[f.id]), f.lex)])
+    );
+  }
+  async scorePassages(items, ctx, stage = "wave2") {
+    if (!items.length) return /* @__PURE__ */ new Map();
+    const w = this.o.config.wave2;
+    return this.stage(
+      stage,
+      chunkPassages(items, w.passagesPerRequest, w.maxRequestChars),
+      (b) => buildPassageRequest(b, ctx, this.o.config),
+      (b, a) => b.map((p) => [
+        p.id,
+        {
+          rel: orLex(noulOf(a[`rel::${p.id}`]), p.lex),
+          cov: ctx.subQuestions.map(
+            (_, j) => orLex(noulOf(a[`cov::${p.id}::${j}`]), p.lexCov[j] ?? 0)
+          )
+        }
+      ])
+    );
+  }
+  async scoreLeads(items, ctx) {
+    if (!items.length) return /* @__PURE__ */ new Map();
+    return this.stage(
+      "leads",
+      chunk(items, 250),
+      (b) => buildLeadRequest(b, ctx, this.o.config),
+      (b, a) => b.map((l) => [l.id, orLex(noulOf(a[l.id]), l.lex)])
+    );
+  }
+  /** null = nothing to check (empty evidence). */
+  async status(evidence, ctx) {
+    if (!evidence.trim()) return null;
+    const req = buildStatusRequest(evidence, ctx, this.o.config);
+    const t0 = performance.now();
+    try {
+      const a = await this.ask("status", req.state, req.questions);
+      return {
+        overall: noulOf(a.overall),
+        subs: ctx.subQuestions.map((_, j) => noulOf(a[`sub::${j}`]))
+      };
+    } finally {
+      this.stat("status").ms += Math.round(performance.now() - t0);
+    }
+  }
+};
+
+// src/code-search/workspace.ts
+var CODE_SEARCH_MAX_PATTERN_CHARS = 16e3;
+var CodeSearchWorkspaceError = class extends Error {
+};
+var CodeSearchRipgrepMissingError = class extends CodeSearchWorkspaceError {
+  constructor(message = "ripgrep (rg) is not installed in this workspace") {
+    super(message);
+    this.name = "CodeSearchRipgrepMissingError";
+  }
+};
+
+// src/code-search/session.ts
+var READ_CONCURRENCY = 8;
+var RIPGREP_SPLIT_CONCURRENCY = 4;
+var WorkspaceSession = class {
+  constructor(workspace, signal, ripgrepTimeoutMs) {
+    this.workspace = workspace;
+    this.signal = signal;
+    this.ripgrepTimeoutMs = ripgrepTimeoutMs;
+  }
+  calls = 0;
+  /** A ripgrep call returned output cut at the adapter's byte cap. */
+  truncated = false;
+  /** A ripgrep call hit its time limit (its output is partial). */
+  timedOut = false;
+  get partial() {
+    return this.truncated || this.timedOut;
+  }
+  /**
+   * ripgrep stdout. Exit code 2 (error) with some output keeps the output (for example unreadable files);
+   * with no output it throws unless `allowFailure`, which then yields "".
+   */
+  async ripgrep(args, options = {}) {
+    this.signal.throwIfAborted();
+    this.calls++;
+    const r = await this.workspace.ripgrep(args, {
+      signal: this.signal,
+      timeoutMs: this.ripgrepTimeoutMs
+    });
+    this.signal.throwIfAborted();
+    if (r.truncated) this.truncated = true;
+    if (r.timedOut) this.timedOut = true;
+    if (r.exitCode === 2 && !r.stdout && !r.truncated && !r.timedOut && !options.allowFailure) {
+      throw new CodeSearchWorkspaceError("ripgrep failed (exit code 2) without output");
+    }
+    return r.stdout;
+  }
+  /** File text, or null when missing or binary (NUL bytes). */
+  async readText(path, maxBytes) {
+    this.signal.throwIfAborted();
+    this.calls++;
+    const r = await this.workspace.readText(path, { signal: this.signal, maxBytes });
+    this.signal.throwIfAborted();
+    if (!r || r.binary || r.text.includes("\0")) return null;
+    return r.text;
+  }
+  async pathKinds(paths) {
+    this.signal.throwIfAborted();
+    this.calls++;
+    const r = await this.workspace.pathKinds(paths, { signal: this.signal });
+    this.signal.throwIfAborted();
+    return r;
+  }
+};
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+
+// src/code-search/text.ts
+function splitWords(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.toLowerCase());
+}
+var cap = (w) => w ? w[0].toUpperCase() + w.slice(1) : w;
+function keywordVariants(kw) {
+  const raw = kw.trim();
+  if (!raw) return [];
+  const words = splitWords(raw);
+  const out = [raw];
+  if (words.length >= 2) {
+    out.push(words[0] + words.slice(1).map(cap).join(""));
+    out.push(words.join("_"));
+    out.push(words.join("-"));
+    out.push(words.join(" "));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((v) => {
+    const k = v.toLowerCase();
+    if (seen.has(k) || k.length < 2) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function compoundFragments(kw) {
+  const words = splitWords(kw);
+  if (words.length < 3) return [];
+  const out = [];
+  for (let i = 0; i + 1 < words.length; i++) {
+    const a = words[i];
+    const b = words[i + 1];
+    if (a.length + b.length < 8) continue;
+    out.push(a + cap(b));
+  }
+  return [...new Set(out)];
+}
+function isShortPlainWord(kw, maxLen) {
+  return /^[A-Za-z]+$/.test(kw) && kw.length <= maxLen && splitWords(kw).length === 1;
+}
+function escapeRegex(s) {
+  return s.replace(/[\\.+*?()|[\]{}^$#&\-~]/g, (m) => `\\${m}`);
+}
+var STOPWORDS = new Set(
+  "a an and are as at be been but by can could did do does doing done for from had has have how i if in into is it its just me my no not of on or our should so some such than that the their them then there these they this those to too was we were what when where which while who why will with would you your also any each else ever every much more most other same very about above after again against all am before being below between both during few further here him his her hers himself itself let may might must nor now off once only own over under until up use used using want way get got make makes happen happens happening still actually really even whether instead rather something someone thing things one two three kind already mean means".split(" ")
+);
+function stem(w) {
+  let s = w.toLowerCase();
+  if (s.length > 5 && s.endsWith("ies")) s = s.slice(0, -3) + "y";
+  else if (s.length > 5 && (s.endsWith("ing") || s.endsWith("ers"))) s = s.slice(0, -3);
+  else if (s.length > 4 && (s.endsWith("ed") || s.endsWith("es") || s.endsWith("er")))
+    s = s.slice(0, -2);
+  else if (s.length > 3 && s.endsWith("s") && !s.endsWith("ss")) s = s.slice(0, -1);
+  return s;
+}
+function contentTerms(text, minLen = 3) {
+  const out = /* @__PURE__ */ new Set();
+  for (const tok of text.match(/[A-Za-z][A-Za-z0-9_]*/g) ?? []) {
+    for (const w of splitWords(tok)) {
+      if (w.length < minLen || STOPWORDS.has(w)) continue;
+      out.add(stem(w));
+    }
+  }
+  return [...out];
+}
+function overlap(terms, textTerms) {
+  if (!terms.length) return 0;
+  let n = 0;
+  for (const t of terms) if (textTerms.has(t)) n++;
+  return n / terms.length;
+}
+function isTestPath(p) {
+  return /(^|\/)(test|tests|__tests__|spec|e2e|fixtures?)\//.test(p) || /\.(test|spec)\.[a-z]+$/.test(p);
+}
+function isChangelogPath(p) {
+  return /(^|\/)(CHANGELOG|HISTORY|RELEASE[-_]?NOTES)[^/]*$/i.test(p) || /(^|\/)\.changeset\//.test(p);
+}
+function questionMentionsHistory(q) {
+  return /\b(changelog|release notes?|released|history|historical|when (?:was|did)|which version|since version|changed in)\b/i.test(
+    q
+  );
+}
+function isDocPath(p) {
+  return /\.(md|mdx|txt|rst)$/i.test(p);
+}
+function questionMentionsTests(q) {
+  return /\b(test|tests|testing|spec|specs|unit test|e2e|fixture)\b/i.test(q);
+}
+function trimAround(line, needles, maxChars) {
+  const t = line.replace(/\t/g, "  ").trim();
+  if (t.length <= maxChars) return t;
+  const lower = t.toLowerCase();
+  let at = -1;
+  for (const n of needles) {
+    const i = lower.indexOf(n.toLowerCase());
+    if (i >= 0 && (at < 0 || i < at)) at = i;
+  }
+  if (at < 0) return t.slice(0, maxChars - 3) + "...";
+  const start = Math.max(0, Math.min(at - Math.floor(maxChars / 3), t.length - maxChars));
+  const s = t.slice(start, start + maxChars - 6);
+  return (start > 0 ? "..." : "") + s + (start + maxChars - 6 < t.length ? "..." : "");
+}
+function estTokens(chars, charsPerToken) {
+  return Math.ceil(chars / charsPerToken);
+}
+function fmtK(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+}
+
+// src/code-search/leads.ts
+var LEAD_STOPLIST = new Set(
+  // JS/TS builtins, globals, utility types
+  "Promise Array Object String Number Boolean Map Set WeakMap WeakSet Symbol Error TypeError RangeError SyntaxError JSON Math Date RegExp BigInt Buffer URL URLSearchParams console require parseInt parseFloat setTimeout clearTimeout setInterval clearInterval setImmediate queueMicrotask isNaN isFinite encodeURIComponent decodeURIComponent structuredClone fetch Response Request Headers FormData Blob File AbortController AbortSignal TextEncoder TextDecoder Uint8Array Int32Array Float64Array ArrayBuffer DataView Record Partial Readonly ReadonlyArray Pick Omit Exclude Extract ReturnType Parameters Awaited NonNullable Required InstanceType Iterable AsyncIterable Generator AsyncGenerator PromiseLike Function Uppercase Lowercase keyof typeof instanceof undefined null true false this super process Bun Deno globalThis window document performance crypto expect describe test beforeEach afterEach beforeAll afterAll mock spyOn toBe toEqual toStrictEqual toMatch toContain toThrow toHaveBeenCalled toHaveBeenCalledWith toHaveLength toBeDefined toBeUndefined toBeNull toBeTruthy toBeFalsy toMatchObject toBeGreaterThan toBeLessThan resolves rejects push pop shift unshift map filter reduce forEach find findIndex some every includes join split slice splice concat indexOf lastIndexOf keys values entries from assign freeze stringify parse toString valueOf trim trimStart trimEnd replace replaceAll match matchAll exec startsWith endsWith toLowerCase toUpperCase padStart padEnd localeCompare then catch finally resolve reject allSettled race floor ceil round abs sqrt random sort reverse flat flatMap fill length size delete clear warn error info debug trace assert emit once listen close write read send next done toISOString getTime toFixed charAt charCodeAt codePointAt fromEntries isArray hasOwnProperty defineProperty getOwnPropertyNames create apply call bind select insert update values returning where from innerJoin leftJoin orderBy groupBy limit offset execute inArray isNull isNotNull desc asc sql eq ne gt gte lt lte and or not like ilike between exists object string number boolean array optional nullable nullish literal union enum infer default describe safeParse parseAsync strict passthrough extend merge partial refine superRefine transform coerce positive nonnegative int min max email uuid regex coalesce count now greatest least jsonb_build_object jsonb_set jsonb_agg array_agg format lower upper nullif current_setting set_config gen_random_uuid clock_timestamp Ok Err Some None Box Vec Arc Mutex RwLock Option Result clone unwrap expect into iter collect map_err ok_or as_ref to_string to_owned println eprintln format vec".split(/\s+/)
+);
+var CONTROL = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "return",
+  "function",
+  "typeof",
+  "await",
+  "async",
+  "new",
+  "else",
+  "case",
+  "void",
+  "delete",
+  "yield",
+  "import",
+  "export",
+  "constructor",
+  "super",
+  "this",
+  "static",
+  "private",
+  "public",
+  "protected"
+]);
+function definedNames(text) {
+  const out = /* @__PURE__ */ new Set();
+  const res = [
+    /\bfunction\*?\s+([A-Za-z_$][\w$]*)/g,
+    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g,
+    /\b(?:class|interface|type|enum|namespace|struct|trait|fn|def|func|mod)\s+([A-Za-z_$][\w$]*)/g,
+    /(?:FUNCTION|function)\s+(?:[\w"]+\.)?"?([A-Za-z_][\w]*)"?\s*\(/g,
+    /^\s*(?:(?:public|private|protected|static|async|readonly|override|get|set)\s+)*([A-Za-z_$][\w$]*)\s*(?:<[^>()]*>)?\s*\([^;]*\)\s*(?::[^={;]+)?\{\s*$/gm
+  ];
+  for (const re of res) for (const m of text.matchAll(re)) if (!CONTROL.has(m[1])) out.add(m[1]);
+  for (const m of text.matchAll(/\b(?:const|let|var)\s*\{([^}]*)\}/g)) {
+    for (const part of m[1].split(",")) {
+      const name = part.split(":").pop().split("=")[0].trim();
+      if (/^[A-Za-z_$][\w$]*$/.test(name)) out.add(name);
+    }
+  }
+  return out;
+}
+function identifiersInLine(line) {
+  const out = [];
+  for (const m of line.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:<[^<>()]*>)?\s*\(/g))
+    out.push({ name: m[1], kind: "call" });
+  const imp = /import\s+(?:type\s+)?\{([^}]*)\}/.exec(line);
+  if (imp) {
+    for (const part of imp[1].split(",")) {
+      const name = part.replace(/^\s*type\s+/, "").split(/\s+as\s+/)[0].trim();
+      if (/^[A-Za-z_$][\w$]*$/.test(name)) out.push({ name, kind: "import" });
+    }
+  }
+  for (const m of line.matchAll(/\b([A-Z][a-z0-9]+(?:[A-Z][A-Za-z0-9]*)+)\b/g))
+    out.push({ name: m[1], kind: "type" });
+  for (const m of line.matchAll(/\b([A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+)\b/g))
+    out.push({ name: m[1], kind: "constant" });
+  for (const m of line.matchAll(/\.([a-z][a-z0-9]*[A-Z][A-Za-z0-9]*)\b/g))
+    out.push({ name: m[1], kind: "member" });
+  return out;
+}
+function trimContext(line, name, max = 160) {
+  const t = line.trim().replace(/\s+/g, " ");
+  if (t.length <= max) return t;
+  const i = Math.max(0, t.indexOf(name) - 50);
+  return (i > 0 ? "..." : "") + t.slice(i, i + max - 6) + "...";
+}
+function extractLeads(seeds, searched, questionWords, max) {
+  const defined = /* @__PURE__ */ new Set();
+  for (const s of seeds) for (const n of definedNames(s.lines.join("\n"))) defined.add(n);
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of seeds) {
+    const inThis = /* @__PURE__ */ new Set();
+    const prose = /\.(md|mdx|txt|rst)$/i.test(s.path);
+    const sql = /\.sql$/i.test(s.path);
+    s.lines.forEach((line, i) => {
+      if (!prose && /^\s*(\/\/|\*|\/\*|#(?!\[)|--)/.test(line)) return;
+      const scan = prose ? (line.match(/`[^`]+`/g) ?? []).join(" ") : line;
+      if (!scan) return;
+      for (const { name, kind } of identifiersInLine(scan)) {
+        if (name.length < 4 || CONTROL.has(name) || LEAD_STOPLIST.has(name) || defined.has(name))
+          continue;
+        if (sql && /^[A-Z]+$/.test(name)) continue;
+        if (searched.has(name.toLowerCase()) || searched.has(splitWords(name).join(" "))) continue;
+        let c = byName.get(name);
+        if (!c) {
+          c = {
+            name,
+            weight: 0,
+            occurrences: 0,
+            called: false,
+            seenAt: { path: s.path, line: s.start + i },
+            context: trimContext(line, name),
+            kinds: []
+          };
+          byName.set(name, c);
+        }
+        c.occurrences++;
+        if (kind === "call") c.called = true;
+        if (!c.kinds.includes(kind)) c.kinds.push(kind);
+        if (!inThis.has(name)) {
+          c.weight += s.rel;
+          inThis.add(name);
+        }
+      }
+    });
+  }
+  const score = (c) => {
+    const words = splitWords(c.name);
+    const ov = words.filter((w) => questionWords.has(w)).length / Math.max(1, words.length);
+    return c.weight + 0.1 * Math.min(5, c.occurrences - 1) + (c.called ? 0.2 : 0) + ov;
+  };
+  return [...byName.values()].sort((a, b) => score(b) - score(a) || (a.name < b.name ? -1 : 1)).slice(0, max).map((c) => ({ ...c, weight: Math.round(score(c) * 1e3) / 1e3 }));
+}
+function definitionKinds(name) {
+  const n = escapeRegex(name);
+  return [
+    {
+      kind: "decl",
+      re: new RegExp(
+        `\\b(?:function\\*?|const|let|var|class|interface|type|enum|namespace|struct|trait|fn|def|func|mod)\\s+${n}\\b`
+      )
+    },
+    { kind: "sqlfn", re: new RegExp(`\\bfunction\\s+(?:[\\w"]+\\.)?"?${n}"?\\s*\\(`, "i") },
+    {
+      kind: "method",
+      re: new RegExp(
+        `^\\s*(?:(?:public|private|protected|static|async|readonly|override|get|set)\\s+)*${n}\\s*(?:<[^>()]*>)?\\s*\\([^;]*(?:\\{|\\(|,)\\s*$`
+      )
+    },
+    { kind: "key", re: new RegExp(`^\\s*["']?${n}["']?\\??\\s*[:=]`) }
+  ];
+}
+function definitionPattern(names) {
+  const alt = names.map(escapeRegex).join("|");
+  return "(?-u:" + [
+    `\\b(?:function\\*?|const|let|var|class|interface|type|enum|namespace|struct|trait|fn|def|func|mod)\\s+(?:${alt})\\b`,
+    `(?i:function)\\s+(?:[\\w"]+\\.)?"?(?:${alt})"?\\s*\\(`,
+    `^\\s*(?:(?:public|private|protected|static|async|readonly|override|get|set)\\s+)*(?:${alt})\\s*(?:<[^>()]*>)?\\s*\\(`,
+    `^\\s*["']?(?:${alt})["']?\\??\\s*[:=]`
+  ].join("|") + ")";
+}
+function definitionPatterns(names, maxChars = CODE_SEARCH_MAX_PATTERN_CHARS) {
+  const out = [];
+  let group = [];
+  for (const name of names) {
+    if (definitionPattern([name]).length > maxChars) continue;
+    if (group.length && definitionPattern([...group, name]).length > maxChars) {
+      out.push(definitionPattern(group));
+      group = [];
+    }
+    group.push(name);
+  }
+  if (group.length) out.push(definitionPattern(group));
+  return out;
+}
+var KIND_RANK = { decl: 3, sqlfn: 3, method: 2, key: 1 };
+function packageOf(path) {
+  const parts = path.split("/");
+  return /^(apps|packages|services|libs|crates)$/.test(parts[0] ?? "") && parts.length > 2 ? parts.slice(0, 2).join("/") : parts[0] ?? "";
+}
+function chooseDefinitions(hits, preferPaths, perName, allowTests = false, seenAt = /* @__PURE__ */ new Map()) {
+  const by = /* @__PURE__ */ new Map();
+  for (const h of hits) {
+    if (!allowTests && isTestPath(h.path)) continue;
+    const arr = by.get(h.name) ?? [];
+    arr.push(h);
+    by.set(h.name, arr);
+  }
+  const rank = (h) => (seenAt.get(h.name) === h.path ? 100 : 0) + (seenAt.has(h.name) && packageOf(seenAt.get(h.name)) === packageOf(h.path) ? 50 : 0) + KIND_RANK[h.kind] * 10 + (isTestPath(h.path) ? 0 : 4) + (preferPaths.has(h.path) ? 2 : 0) + (h.kind === "key" && /config|setting|schema|env/i.test(h.path) ? 1 : 0);
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, arr] of by) {
+    arr.sort(
+      (a, b) => rank(b) - rank(a) || (a.path < b.path ? -1 : a.path > b.path ? 1 : a.line - b.line)
+    );
+    out.set(name, arr.slice(0, perName));
+  }
+  return out;
+}
+var DEF_SCAN_EXCLUDES = ["!*.{md,mdx,txt,rst,json,jsonc,html,csv,svg,snap,xml}"];
+var TEST_EXCLUDES = [
+  "!**/test/**",
+  "!**/tests/**",
+  "!**/__tests__/**",
+  "!**/e2e/**",
+  "!**/fixtures/**",
+  "!*.test.*",
+  "!*.spec.*"
+];
+async function locateDefinitions(session, names, cfg, excludeArgs2, maxKeyOnlyDefs = 12, allowTests = false) {
+  const t0 = performance.now();
+  if (!names.length) return { hits: [], fileCounts: /* @__PURE__ */ new Map(), ms: 0 };
+  const extra = [...DEF_SCAN_EXCLUDES, ...allowTests ? [] : TEST_EXCLUDES].flatMap((g) => [
+    "-g",
+    g
+  ]);
+  const defOuts = await mapLimit(
+    definitionPatterns(names),
+    RIPGREP_SPLIT_CONCURRENCY,
+    (pattern) => session.ripgrep(
+      [
+        "--null",
+        "--line-number",
+        "--with-filename",
+        "--no-heading",
+        "--color",
+        "never",
+        "--no-require-git",
+        "--max-columns",
+        String(cfg.recall.maxLineColumns),
+        "--max-filesize",
+        String(cfg.recall.maxFileBytes),
+        ...excludeArgs2,
+        ...extra,
+        "-e",
+        pattern,
+        "--",
+        "."
+      ],
+      { allowFailure: true }
+    )
+  );
+  const kinds = new Map(names.map((n) => [n, definitionKinds(n)]));
+  const nameSet = new Set(names);
+  const files = /* @__PURE__ */ new Map();
+  const strong = [];
+  const keys = [];
+  const seenRows = /* @__PURE__ */ new Set();
+  for (const row of defOuts.flatMap((out) => out.split("\n"))) {
+    const z = row.indexOf("\0");
+    if (z <= 0) continue;
+    const colon = row.indexOf(":", z + 1);
+    if (colon < 0) continue;
+    const at = row.slice(0, colon);
+    if (seenRows.has(at)) continue;
+    seenRows.add(at);
+    const text = row.slice(colon + 1);
+    if (text.length > 400 || text.startsWith("[Omitted long line")) continue;
+    const path = row.slice(0, z).replace(/^\.\//, "");
+    const line = Number(row.slice(z + 1, colon));
+    const present = new Set((text.match(/[A-Za-z_$][\w$]*/g) ?? []).filter((t) => nameSet.has(t)));
+    for (const name of present) {
+      for (const k of kinds.get(name)) {
+        if (!k.re.test(text)) continue;
+        (k.kind === "key" ? keys : strong).push({
+          name,
+          path,
+          line,
+          kind: k.kind,
+          text: text.trim().slice(0, 200)
+        });
+        let fs = files.get(name);
+        if (!fs) files.set(name, fs = /* @__PURE__ */ new Set());
+        fs.add(path);
+        break;
+      }
+    }
+  }
+  const hasStrong = new Set(strong.map((h) => h.name));
+  const keyHits = keys.filter((h) => !hasStrong.has(h.name));
+  const keyCount = /* @__PURE__ */ new Map();
+  for (const h of keyHits) keyCount.set(h.name, (keyCount.get(h.name) ?? 0) + 1);
+  const hits = [...strong, ...keyHits.filter((h) => (keyCount.get(h.name) ?? 0) <= maxKeyOnlyDefs)];
+  hits.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.line - b.line);
+  const fileCounts = new Map(names.map((n) => [n, files.get(n)?.size ?? 0]));
+  return { hits, fileCounts, ms: Math.round(performance.now() - t0) };
+}
+
+// src/code-search/windows.ts
+function langOf(path) {
+  const ext = path.toLowerCase().split(".").pop() ?? "";
+  if ([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "mts",
+    "cts",
+    "rs",
+    "go",
+    "java",
+    "c",
+    "h",
+    "cc",
+    "cpp",
+    "hpp",
+    "cs",
+    "swift",
+    "kt",
+    "scala",
+    "css",
+    "scss",
+    "json",
+    "jsonc",
+    "proto",
+    "tf",
+    "hcl"
+  ].includes(ext)) {
+    return "brace";
+  }
+  if (["py", "yaml", "yml"].includes(ext)) return "indent";
+  if (["md", "mdx"].includes(ext)) return "markdown";
+  if (ext === "sql") return "sql";
+  return "other";
+}
+function indentOf(line) {
+  let n = 0;
+  for (const ch of line) {
+    if (ch === " ") n += 1;
+    else if (ch === "	") n += 4;
+    else break;
+  }
+  return n;
+}
+var CONTROL2 = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "return",
+  "else",
+  "do",
+  "try",
+  "with",
+  "await",
+  "new",
+  "typeof",
+  "function",
+  "throw",
+  "yield",
+  "delete",
+  "void",
+  "in",
+  "of",
+  "case",
+  "super",
+  "this",
+  "import",
+  "export"
+]);
+var TS_DECL = /^\s*(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:function\b|class\s|interface\s|type\s+[A-Za-z_$][\w$]*\s*(?:<[^>]*>)?\s*=|enum\s|const\s+[A-Za-z_$[{]|let\s+[A-Za-z_$[{]|var\s+[A-Za-z_$]|namespace\s|module\s)/;
+var EXPORT_DEFAULT = /^\s*export\s+default\b/;
+var RUST_DECL = /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(?:const\s+)?(?:fn|struct|enum|trait|impl|mod|macro_rules!)[\s<]/;
+var GO_DECL = /^\s*func\s/;
+var TEST_DECL = /^\s*(?:describe|it|test)(?:\.\w+)?\s*\(/;
+var METHOD = /^\s*(?:(?:public|private|protected|static|readonly|async|override|get|set)\s+)*\*?\s*([A-Za-z_$][\w$]*)\s*(?:<[^>()]*>)?\s*\([^;]*$/;
+var PROP_FN = /^\s*(?:(?:public|private|protected|static|readonly)\s+)*[A-Za-z_$][\w$]*\s*[:=]\s*(?:async\s*)?(?:function\b|\([^)]*\)?[^;]*=>|[A-Za-z_$][\w$]*\s*=>)/;
+var OBJ_KEY_OPEN = /^\s*["']?[A-Za-z_$][\w$-]*["']?\s*:\s*(?:[\w$.]+\()?[{[]\s*$/;
+var CALLBACK_OPEN = /^\s*(?:await\s+)?[\w$]+(?:\.[\w$]+)+\s*\(.*(?:=>|function\b).*\{\s*$/;
+var MD_HEADING = /^(#{1,6})\s/;
+var SQL_STMT = /^(?:CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|WITH|SELECT|DO|COMMENT|GRANT|REVOKE|BEGIN|SET|LOCK|TRUNCATE)\b/i;
+var PY_DECL = /^\s*(?:async\s+)?(?:def|class)\s/;
+var YAML_KEY = /^\s*(?:- )?["']?[A-Za-z_$][\w$ .-]*["']?\s*:(?:\s|$)/;
+function isDeclLine(line, lang) {
+  if (!line.trim()) return false;
+  switch (lang) {
+    case "markdown":
+      return MD_HEADING.test(line);
+    case "sql":
+      return indentOf(line) === 0 && SQL_STMT.test(line);
+    case "indent":
+      return PY_DECL.test(line) || YAML_KEY.test(line);
+    case "brace": {
+      if (TS_DECL.test(line) || EXPORT_DEFAULT.test(line) || RUST_DECL.test(line) || GO_DECL.test(line) || TEST_DECL.test(line))
+        return true;
+      if (PROP_FN.test(line) || OBJ_KEY_OPEN.test(line) || CALLBACK_OPEN.test(line)) return true;
+      const m = METHOD.exec(line);
+      if (m && !CONTROL2.has(m[1]) && /(\{|\(|,)\s*$/.test(line.trimEnd()) && !/^\s*[\w$]+\s*\(.*\)\s*;?\s*$/.test(line)) {
+        return true;
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+function stripForBrackets(line) {
+  const t = line.trim();
+  if (t.startsWith("*") || t.startsWith("/*") || t.startsWith("//")) return "";
+  return line.replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/`(?:[^`\\]|\\.)*`/g, "``").replace(/\/\*.*?\*\//g, "").replace(/\/\/.*$/, "");
+}
+var blockEndCache = /* @__PURE__ */ new WeakMap();
+function blockEnd(lines, d, lang, maxScan = 3e3) {
+  let cache = blockEndCache.get(lines);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    blockEndCache.set(lines, cache);
+  }
+  const key = d * 8 + ["brace", "indent", "markdown", "sql", "other"].indexOf(lang);
+  if (cache.has(key)) return cache.get(key);
+  const r = computeBlockEnd(lines, d, lang, maxScan);
+  cache.set(key, r);
+  return r;
+}
+function computeBlockEnd(lines, d, lang, maxScan) {
+  const n = lines.length;
+  if (d < 0 || d >= n) return null;
+  const last = Math.min(n - 1, d + maxScan);
+  if (lang === "brace") {
+    let depth = 0;
+    let maxDepth = 0;
+    for (let i = d; i <= last; i++) {
+      const s = stripForBrackets(lines[i]);
+      for (const ch of s) {
+        if (ch === "{" || ch === "(" || ch === "[") {
+          depth++;
+          if (depth > maxDepth) maxDepth = depth;
+        } else if (ch === "}" || ch === ")" || ch === "]") depth--;
+      }
+      if (maxDepth > 0 && depth <= 0) return i;
+      if (maxDepth === 0 && /;\s*$/.test(s)) return i;
+    }
+    return null;
+  }
+  if (lang === "indent") {
+    const ind = indentOf(lines[d]);
+    let lastNonEmpty = d;
+    for (let i = d + 1; i <= last; i++) {
+      const l = lines[i];
+      if (!l.trim()) continue;
+      if (indentOf(l) <= ind) return lastNonEmpty;
+      lastNonEmpty = i;
+    }
+    return last === n - 1 ? lastNonEmpty : null;
+  }
+  if (lang === "markdown") {
+    const m = MD_HEADING.exec(lines[d]);
+    if (!m) return null;
+    const level = m[1].length;
+    let inFence = false;
+    for (let i = d + 1; i <= last; i++) {
+      const l = lines[i];
+      if (/^\s*(```|~~~)/.test(l)) inFence = !inFence;
+      if (inFence) continue;
+      const h = MD_HEADING.exec(l);
+      if (h && h[1].length <= level) return i - 1;
+    }
+    return last === n - 1 ? n - 1 : null;
+  }
+  if (lang === "sql") {
+    let inDollar = false;
+    for (let i = d; i <= last; i++) {
+      const l = lines[i].replace(/--.*$/, "");
+      const toggles = (l.match(/\$[A-Za-z_]*\$/g) ?? []).length;
+      if (toggles % 2 === 1) inDollar = !inDollar;
+      if (!inDollar && /;\s*$/.test(l)) return i;
+    }
+    return null;
+  }
+  return null;
+}
+function isCommentOrDecorator(line) {
+  return /^(\/\/|\/\*\*?|\*|#\[|@[A-Za-z]|--)/.test(line.trim());
+}
+function leadingComments(lines, d, lang, maxLines = 6) {
+  if (lang === "markdown" || lang === "other") return d;
+  let s = d;
+  while (s > 0 && d - s < maxLines && isCommentOrDecorator(lines[s - 1] ?? "")) s--;
+  return s;
+}
+function nearestEnclosingLabel(lines, idx, lang, maxScan = 2e3) {
+  const ind = indentOf(lines[idx] ?? "");
+  for (let i = idx; i >= Math.max(0, idx - maxScan); i--) {
+    const l = lines[i] ?? "";
+    if (!isDeclLine(l, lang)) continue;
+    if (lang === "markdown" || lang === "sql" || i === idx || indentOf(l) < ind || ind === 0 && indentOf(l) === 0) {
+      return { line: i + 1, text: l.trim().slice(0, 140) };
+    }
+  }
+  return void 0;
+}
+function enclosingWindow(lines, hitLine, lang, cfg) {
+  const w = cfg.wave2;
+  const hi = hitLine - 1;
+  const n = lines.length;
+  const hitIndent = indentOf(lines[hi] ?? "");
+  if (lang !== "other") {
+    for (let i = hi; i >= Math.max(0, hi - w.maxUp); i--) {
+      const l = lines[i] ?? "";
+      if (!isDeclLine(l, lang)) continue;
+      if ((lang === "brace" || lang === "indent") && i !== hi && indentOf(l) > hitIndent) continue;
+      const e = blockEnd(lines, i, lang);
+      if (e === null || e < hi) continue;
+      if (i === hi && e - hi < 2) continue;
+      const start2 = leadingComments(lines, i, lang);
+      const end2 = Math.min(e, hi + w.maxDown, n - 1);
+      return padWindow(
+        {
+          start: start2 + 1,
+          end: end2 + 1,
+          hits: [hitLine],
+          label: { line: i + 1, text: l.trim().slice(0, 140) },
+          kind: "hit",
+          score: 0
+        },
+        n,
+        cfg
+      );
+    }
+  }
+  const start = Math.max(0, hi - w.fallbackBefore);
+  const end = Math.min(n - 1, hi + w.fallbackAfter);
+  const label = lang === "other" ? void 0 : nearestEnclosingLabel(lines, hi, lang);
+  return { start: start + 1, end: end + 1, hits: [hitLine], label, kind: "hit", score: 0 };
+}
+function padWindow(win, nLines, cfg) {
+  const min = cfg.wave2.minWindowLines;
+  const len = win.end - win.start + 1;
+  if (len >= min) return win;
+  const need = min - len;
+  const up = Math.floor(need / 3);
+  let start = Math.max(1, win.start - up);
+  let end = Math.min(nLines, win.end + (need - (win.start - start)));
+  if (end - start + 1 < min) start = Math.max(1, end - min + 1);
+  return { ...win, start, end };
+}
+function mergeWindows(ws, gap) {
+  const sorted = [...ws].sort((a, b) => a.start - b.start || a.end - b.end);
+  const out = [];
+  for (const w of sorted) {
+    const prev = out[out.length - 1];
+    if (prev && w.start <= prev.end + gap + 1) {
+      prev.end = Math.max(prev.end, w.end);
+      prev.hits = [.../* @__PURE__ */ new Set([...prev.hits, ...w.hits])].sort((a, b) => a - b);
+      if (w.label && (!prev.label || w.label.line < prev.label.line)) prev.label = w.label;
+      if (prev.kind !== w.kind && w.kind === "def") prev.kind = "def";
+    } else {
+      out.push({ ...w, hits: [...w.hits] });
+    }
+  }
+  return out;
+}
+function splitWindow(w, maxLines, before = 20) {
+  if (w.end - w.start + 1 <= maxLines) return [w];
+  const hits = [...w.hits].sort((a, b) => a - b);
+  if (!hits.length) return [{ ...w, end: w.start + maxLines - 1 }];
+  const out = [];
+  let i = 0;
+  while (i < hits.length) {
+    let start = Math.max(w.start, hits[i] - before);
+    if (w.start >= hits[i] - 2 * before) start = w.start;
+    const end = Math.min(w.end, start + maxLines - 1);
+    const chunkHits = [];
+    while (i < hits.length && hits[i] <= end) chunkHits.push(hits[i++]);
+    if (!chunkHits.length) {
+      i++;
+      continue;
+    }
+    out.push({
+      ...w,
+      start,
+      end,
+      hits: chunkHits,
+      label: w.label && w.label.line < start ? w.label : w.label
+    });
+  }
+  return out;
+}
+var kwRegexCache = /* @__PURE__ */ new WeakMap();
+function keywordRegex(k) {
+  if (!kwRegexCache.has(k)) {
+    let re = null;
+    try {
+      re = new RegExp(k.pattern, "i");
+    } catch {
+      re = null;
+    }
+    kwRegexCache.set(k, re);
+  }
+  return kwRegexCache.get(k);
+}
+function textHasKeyword(text, k) {
+  const re = keywordRegex(k);
+  if (re) return re.test(text);
+  const lower = text.toLowerCase();
+  return k.variants.some((v) => lower.includes(v.toLowerCase()));
+}
+function keywordsInRange(lines, start, end, keywords) {
+  const text = lines.slice(start - 1, end).join("\n");
+  return keywords.filter((k) => k.idf > 0 && textHasKeyword(text, k)).map((k) => k.index);
+}
+function scoreWindow(lines, w, keywords, hitWeight = 0.1) {
+  const kws = keywordsInRange(lines, w.start, w.end, keywords);
+  return kws.reduce((s, k) => s + keywords[k].idf, 0) + hitWeight * Math.log(1 + w.hits.length);
+}
+function buildFileWindows(lines, hitLines, keywords, lang, cfg, render) {
+  const w = cfg.wave2;
+  const ro = render ?? { maxLineChars: w.maxLineChars };
+  const maxChars = lang === "markdown" ? w.maxProseWindowChars : w.maxWindowChars;
+  if (!lines.length) return [];
+  if (!hitLines.length) {
+    const e = lang === "markdown" ? Math.min(lines.length, 80) : Math.min(lines.length, 60);
+    return splitByChars(
+      lines,
+      { start: 1, end: e, hits: [], kind: "header", score: 0 },
+      maxChars,
+      ro
+    ).slice(0, 1);
+  }
+  const inRange = hitLines.filter((h) => h.line >= 1 && h.line <= lines.length);
+  const weight = (h) => h.kws.reduce((s, k) => s + (keywords[k]?.idf ?? 0), 0);
+  const ranked = [...inRange].sort((a, b) => weight(b) - weight(a) || a.line - b.line);
+  const budgetHits = w.seedHitsPerFile;
+  const raw = [];
+  let used = 0;
+  for (const h of ranked) {
+    if (used >= budgetHits) break;
+    const inside = raw.find((r) => h.line >= r.start && h.line <= r.end);
+    if (inside) {
+      inside.hits.push(h.line);
+      continue;
+    }
+    raw.push(enclosingWindow(lines, h.line, lang, cfg));
+    used++;
+  }
+  for (const h of inRange) {
+    for (const r of raw)
+      if (h.line >= r.start && h.line <= r.end && !r.hits.includes(h.line)) r.hits.push(h.line);
+  }
+  const merged = mergeWindows(raw, w.mergeGap).flatMap((x) => splitWindow(x, w.maxWindowLines)).flatMap((x) => splitByChars(lines, x, maxChars, ro));
+  for (const x of merged) x.score = scoreWindow(lines, x, keywords, cfg.recall.hitCountWeight);
+  return merged.sort((a, b) => b.score - a.score || a.start - b.start).slice(0, w.windowsPerFile).sort((a, b) => a.start - b.start);
+}
+function definitionWindow(lines, defLine, lang, cfg, render) {
+  const w = cfg.wave2;
+  const d = defLine - 1;
+  const start = leadingComments(lines, d, lang);
+  const e = lang === "other" ? null : blockEnd(lines, d, lang);
+  let end = e === null ? Math.min(lines.length - 1, d + w.fallbackAfter) : Math.min(e, d + w.maxDown);
+  end = Math.min(end, start + w.maxWindowLines - 1, lines.length - 1);
+  const win = {
+    start: start + 1,
+    end: end + 1,
+    hits: [defLine],
+    label: { line: defLine, text: (lines[d] ?? "").trim().slice(0, 140) },
+    kind: "def",
+    score: 0
+  };
+  const maxChars = lang === "markdown" ? w.maxProseWindowChars : w.maxWindowChars;
+  return splitByChars(
+    lines,
+    win,
+    maxChars,
+    render ?? { maxLineChars: w.maxLineChars },
+    defLine - win.start
+  )[0];
+}
+function cutLine(t, maxChars, needles = []) {
+  if (t.length <= maxChars) return t;
+  let at = -1;
+  for (const re of needles) {
+    const m = re.exec(t);
+    if (m && (at < 0 || m.index < at)) at = m.index;
+  }
+  if (at < 0 || at < maxChars * 0.6)
+    return `${t.slice(0, maxChars)} ...[line cut, ${t.length} chars]`;
+  const head = Math.floor(maxChars * 0.25);
+  const before = Math.floor(maxChars * 0.3);
+  const s = Math.max(head, at - before);
+  const e = Math.min(t.length, s + (maxChars - head));
+  return `${t.slice(0, head)} ...[cut]... ${t.slice(s, e)}${e < t.length ? ` ...[line cut, ${t.length} chars]` : ""}`;
+}
+function renderLines(lines, start, end, opts) {
+  const o = typeof opts === "number" ? { maxLineChars: opts } : opts;
+  const out = [];
+  for (let i = start; i <= end && i <= lines.length; i++) {
+    out.push(`${i}| ${cutLine(lines[i - 1].replace(/\t/g, "  "), o.maxLineChars, o.needles)}`);
+  }
+  return out.join("\n");
+}
+function renderedLineLength(lines, i, o) {
+  return renderLines(lines, i, i, o).length + 1;
+}
+function splitByChars(lines, w, maxChars, o, ctxUp = 3) {
+  const len = (i) => renderedLineLength(lines, i, o);
+  let total = 0;
+  for (let i = w.start; i <= w.end; i++) total += len(i);
+  if (total <= maxChars) return [w];
+  const hits = [...w.hits].filter((h) => h >= w.start && h <= w.end).sort((a, b) => a - b);
+  const anchors = hits.length ? hits : [w.start];
+  const out = [];
+  let covered = w.start - 1;
+  for (const h of anchors) {
+    if (h <= covered) continue;
+    let s = h;
+    let used = len(h);
+    while (s - 1 >= w.start && s - 1 > covered && h - (s - 1) <= ctxUp && used + len(s - 1) <= maxChars / 4)
+      used += len(--s);
+    let e = h;
+    while (e + 1 <= w.end && used + len(e + 1) <= maxChars) used += len(++e);
+    out.push({ ...w, start: s, end: e, hits: hits.filter((x) => x >= s && x <= e) });
+    covered = e;
+  }
+  return out;
+}
+function splitLines(text) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+
+// src/code-search/pack.ts
+var r2 = (x) => Number.isFinite(x) ? x.toFixed(2) : "?";
+function diverseOrder(xs, eff, penalty, taken) {
+  const tie = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.start - b.start;
+  if (penalty <= 0) return [...xs].sort((a, b) => eff(b) - eff(a) || tie(a, b));
+  const left = [...xs];
+  const out = [];
+  while (left.length) {
+    let bi = 0;
+    let bv = -Infinity;
+    left.forEach((x2, i) => {
+      const v = eff(x2) - penalty * (taken.get(x2.path) ?? 0);
+      if (v > bv || v === bv && tie(x2, left[bi]) < 0) {
+        bv = v;
+        bi = i;
+      }
+    });
+    const x = left.splice(bi, 1)[0];
+    taken.set(x.path, (taken.get(x.path) ?? 0) + 1);
+    out.push(x);
+  }
+  return out;
+}
+function pathPrior(path, o) {
+  const p = o.cfg.pack;
+  if (isChangelogPath(path)) return o.downweightChangelogs !== false ? p.changelogPrior : 1;
+  if (isTestPath(path)) return o.downweightTests !== false ? p.testPrior : 1;
+  if (isDocPath(path)) return p.docPrior;
+  return 1;
+}
+function packScore(x, o) {
+  return (x.rel + o.cfg.pack.lexWeight * (x.lex ?? 0)) * pathPrior(x.path, o);
+}
+function priorityOrder(passages, o) {
+  const p = o.cfg.pack;
+  const effCache = /* @__PURE__ */ new Map();
+  const eff = (x) => {
+    let v = effCache.get(x);
+    if (v === void 0) effCache.set(x, v = packScore(x, o));
+    return v;
+  };
+  const byRel = [...passages].sort(
+    (a, b) => eff(b) - eff(a) || (a.path < b.path ? -1 : a.path > b.path ? 1 : a.start - b.start)
+  );
+  const out = [];
+  const taken = /* @__PURE__ */ new Map();
+  const add = (x) => {
+    if (!out.includes(x)) {
+      out.push(x);
+      taken.set(x.path, (taken.get(x.path) ?? 0) + 1);
+    }
+  };
+  o.subQuestions.forEach((_, j) => {
+    const best = [...passages].filter((x) => (x.cov[j] ?? 0) >= o.T2 && x.rel >= p.minRelevance).sort((a, b) => (b.cov[j] ?? 0) - (a.cov[j] ?? 0) || b.rel - a.rel)[0];
+    if (best) add(best);
+  });
+  for (const x of diverseOrder(
+    byRel.filter((y) => y.rel >= o.T2 && !out.includes(y)),
+    eff,
+    p.filePenalty,
+    new Map(taken)
+  ))
+    add(x);
+  for (const x of byRel) {
+    if (out.length >= p.minPassages) break;
+    if (x.rel >= p.minRelevance) add(x);
+  }
+  if (p.fillBudget)
+    for (const x of diverseOrder(
+      byRel.filter((y) => y.rel >= p.minRelevance && !out.includes(y)),
+      eff,
+      p.filePenalty,
+      new Map(taken)
+    ))
+      add(x);
+  return out;
+}
+function blockHeader(x, start, end, o) {
+  const covTags = o.subQuestions.map((_, j) => (x.cov[j] ?? 0) >= o.T2 ? `s${j + 1}` : "").filter(Boolean);
+  const parts = [`== ${x.path}:${start}-${end}  rel ${r2(x.rel)}`];
+  if (covTags.length) parts.push(`[${covTags.join(" ")}]`);
+  if (x.kind === "def" && x.lead) parts.push(`(definition of ${x.lead})`);
+  if (start !== x.start || end !== x.end) parts.push(`(trimmed from ${x.start}-${x.end})`);
+  let h = parts.join("  ");
+  if (x.label && x.label.line < start) h += `
+   in L${x.label.line}: ${x.label.text}`;
+  return h;
+}
+function renderBlock(x, start, end, o) {
+  return `${blockHeader(x, start, end, o)}
+${renderLines(x.fileLines, start, end, x.render ?? o.cfg.wave2.maxLineChars)}`;
+}
+function trimToFit(x, maxChars, o) {
+  const lineLen = (i) => renderLines(x.fileLines, i, i, x.render ?? o.cfg.wave2.maxLineChars).length + 1;
+  const hdr = blockHeader(x, x.start, x.end, o).length + 40;
+  const inside = x.hits.filter((h) => h >= x.start && h <= x.end).sort((a, b) => a - b);
+  const center = inside.length ? inside[Math.floor((inside.length - 1) / 2)] : x.start;
+  let s = center;
+  let e = center;
+  let used = hdr + lineLen(center);
+  if (used > maxChars) return null;
+  let stuckUp = false;
+  let stuckDown = false;
+  let turn = 0;
+  while (!(stuckUp && stuckDown)) {
+    const goDown = !stuckDown && (stuckUp || turn % 3 !== 2);
+    turn++;
+    if (goDown) {
+      if (e + 1 > x.end) {
+        stuckDown = true;
+        continue;
+      }
+      const c = lineLen(e + 1);
+      if (used + c > maxChars) stuckDown = true;
+      else {
+        e++;
+        used += c;
+      }
+    } else {
+      if (s - 1 < x.start) {
+        stuckUp = true;
+        continue;
+      }
+      const c = lineLen(s - 1);
+      if (used + c > maxChars) stuckUp = true;
+      else {
+        s--;
+        used += c;
+      }
+    }
+  }
+  if (e - s + 1 < o.cfg.pack.minTrimLines && e - s + 1 < x.end - x.start + 1) return null;
+  return { start: s, end: e };
+}
+function packBody(passages, o) {
+  const order = priorityOrder(passages, o);
+  let remaining = o.bodyChars;
+  const included = [];
+  for (const x of order) {
+    if (remaining < 200) break;
+    let s = x.start;
+    let e = x.end;
+    let block = renderBlock(x, s, e, o);
+    const cap2 = o.cfg.pack.maxPassageChars;
+    if (cap2 > 0 && block.length > cap2) {
+      const t = trimToFit(x, cap2, o);
+      if (t) {
+        s = t.start;
+        e = t.end;
+        block = renderBlock(x, s, e, o);
+      }
+    }
+    if (block.length + 2 > remaining) {
+      const t = trimToFit({ ...x, start: s, end: e }, remaining - 2, o);
+      if (!t) continue;
+      s = t.start;
+      e = t.end;
+      block = renderBlock(x, s, e, o);
+      if (block.length + 2 > remaining) continue;
+    }
+    remaining -= block.length + 2;
+    included.push({
+      id: x.id,
+      path: x.path,
+      start: s,
+      end: e,
+      origStart: x.start,
+      origEnd: x.end,
+      trimmed: s !== x.start || e !== x.end,
+      rel: x.rel,
+      cov: x.cov,
+      kind: x.kind,
+      lead: x.lead,
+      label: x.label,
+      block
+    });
+  }
+  const inc = new Set(included.map((p) => p.id));
+  const excluded = passages.filter((x) => !inc.has(x.id)).sort((a, b) => b.rel - a.rel);
+  const fileBest = /* @__PURE__ */ new Map();
+  for (const p of included) fileBest.set(p.path, Math.max(fileBest.get(p.path) ?? 0, p.rel));
+  const grouped = [...included].sort(
+    (a, b) => fileBest.get(b.path) - fileBest.get(a.path) || (a.path < b.path ? -1 : a.path > b.path ? 1 : a.start - b.start)
+  );
+  return {
+    included: grouped,
+    excluded,
+    body: grouped.map((p) => p.block).join("\n\n"),
+    priority: order.map((x) => x.id)
+  };
+}
+function renderFooter(f) {
+  const p = f.cfg.pack;
+  const more = f.excluded.slice(0, p.moreCandidates).map((x) => `${x.path}:${x.start}-${x.end} (${r2(x.rel)})`);
+  const moreFiles = f.otherFiles.slice(0, Math.max(0, p.moreCandidates - more.length)).map((x) => `${x.path} (${r2(x.score)})`);
+  const leads = f.leadsNotFollowed.slice(0, p.leadsNotFollowed).map((l2) => `${l2.name} (${r2(l2.score)}${l2.note ? `, ${l2.note}` : ""}) @${l2.seenAt}`);
+  const zero = f.zeroHitKeywords.map(
+    (k) => k.fragments.length ? `${k.raw} (matched fragments: ${k.fragments.join(", ")})` : k.raw
+  );
+  const build = (m2, mf2, l2) => {
+    const lines = [];
+    if (m2.length || mf2.length) {
+      lines.push("More candidates (not included; read if needed):");
+      if (m2.length) lines.push(`  ${m2.join(", ")}`);
+      if (mf2.length) lines.push(`  files: ${mf2.join(", ")}`);
+    }
+    if (l2.length) lines.push(`Leads not followed: ${l2.join(", ")}`);
+    if (zero.length) lines.push(`Keywords with zero hits: ${zero.join(", ")}`);
+    if (f.widenedNote) lines.push(f.widenedNote);
+    return lines.join("\n");
+  };
+  let m = more;
+  let mf = moreFiles;
+  let l = leads;
+  let out = build(m, mf, l);
+  while (out.length > f.maxChars && (m.length || mf.length || l.length)) {
+    if (mf.length) mf = mf.slice(0, -1);
+    else if (l.length > 2) l = l.slice(0, -1);
+    else if (m.length) m = m.slice(0, -1);
+    else l = l.slice(0, -1);
+    out = build(m, mf, l);
+  }
+  return out;
+}
+
+// src/code-search/recall.ts
+var BUILTIN_EXCLUDES = [
+  "!**/node_modules/**",
+  "!**/dist/**",
+  "!**/build/**",
+  "!**/.next/**",
+  "!**/coverage/**",
+  "!**/target/**",
+  "!**/vendor/**",
+  "!**/.git/**",
+  // a linked worktree has a `.git` FILE (gitdir pointer), which --hidden would otherwise search
+  "!**/.git",
+  "!**/.turbo/**",
+  "!*.lock",
+  "!**/package-lock.json",
+  "!**/pnpm-lock.yaml",
+  "!**/yarn.lock",
+  "!**/bun.lockb",
+  "!*.min.js",
+  "!*.min.css",
+  "!*.map",
+  "!*.snap",
+  "!**/*.gen.*",
+  "!**/*.generated.*",
+  "!**/gen/**",
+  "!**/*_pb.*",
+  "!**/*.pb.go",
+  "!*.{svg,png,jpg,jpeg,gif,ico,webp,woff,woff2,ttf,otf,eot,wasm,pdf,zip,gz,tgz,mp4,mp3,mov}"
+];
+function excludeArgs(cfg) {
+  return [
+    ...BUILTIN_EXCLUDES,
+    ...cfg.recall.extraExcludes.map((g) => g.startsWith("!") ? g : `!${g}`)
+  ].flatMap((g) => ["-g", g]);
+}
+function hiddenArgs(cfg) {
+  return cfg.recall.searchHidden ? ["--hidden"] : [];
+}
+async function listFiles(session, paths, cfg) {
+  const out = await session.ripgrep(
+    [
+      "--files",
+      "--no-require-git",
+      ...hiddenArgs(cfg),
+      "--max-filesize",
+      String(cfg.recall.maxFileBytes),
+      ...excludeArgs(cfg),
+      "--",
+      ...paths
+    ],
+    { allowFailure: true }
+  );
+  return out.split("\n").filter(Boolean).map((p) => p.replace(/^\.\//, "")).sort();
+}
+function buildPattern(kw, cfg) {
+  const variants = keywordVariants(kw);
+  if (variants.length === 1 && isShortPlainWord(variants[0], cfg.recall.shortWordMaxLen)) {
+    const lit = escapeRegex(variants[0]);
+    return { pattern: `\\b${lit}`, rgPattern: `(?-u:\\b)${lit}`, mode: "word-prefix", variants };
+  }
+  const alts = variants.map((v) => escapeRegex(v).replace(/ /g, "\\s+"));
+  return { pattern: alts.join("|"), rgPattern: alts.join("|"), mode: "phrase", variants };
+}
+function fragmentPattern(frags) {
+  return frags.flatMap((f) => keywordVariants(f)).map((v) => escapeRegex(v).replace(/ /g, "\\s+")).join("|");
+}
+function parseRgOutput(out) {
+  const matches = [];
+  let pos = 0;
+  while (pos < out.length) {
+    let nl = out.indexOf("\n", pos);
+    if (nl < 0) nl = out.length;
+    const z = out.indexOf("\0", pos);
+    if (z > pos && z < nl) {
+      const colon = out.indexOf(":", z + 1);
+      if (colon > z && colon < nl) {
+        const line = Number(out.slice(z + 1, colon));
+        const text = out.slice(colon + 1, nl).replace(/\r$/, "");
+        if (Number.isFinite(line) && !text.startsWith("[Omitted long line")) {
+          matches.push({ path: out.slice(pos, z).replace(/^\.\//, ""), line, text });
+        }
+      }
+    }
+    pos = nl + 1;
+  }
+  return matches;
+}
+var byPathLine = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.line - b.line;
+function ripgrepPatternCompiles(pattern) {
+  return jsRegex(pattern.replace(/\(\?[A-Za-z-]+:/g, "(?:")) !== null;
+}
+async function searchPattern(session, pattern, paths, cfg, opts = {}) {
+  const args = [
+    "--null",
+    "--line-number",
+    "--with-filename",
+    "--no-heading",
+    "--color",
+    "never",
+    ...opts.caseInsensitive === false ? [] : ["-i"],
+    ...opts.word ? ["-w"] : [],
+    "--no-require-git",
+    ...hiddenArgs(cfg),
+    ...opts.maxPerFile ? ["-m", String(opts.maxPerFile)] : [],
+    // very long lines (minified / generated / data) are omitted by rg and skipped by the parser
+    "--max-columns",
+    String(cfg.recall.maxLineColumns),
+    "--max-filesize",
+    String(cfg.recall.maxFileBytes),
+    ...excludeArgs(cfg),
+    "-e",
+    pattern,
+    "--",
+    ...paths
+  ];
+  const out = await session.ripgrep(args, { allowFailure: ripgrepPatternCompiles(pattern) });
+  const matches = parseRgOutput(out);
+  matches.sort(byPathLine);
+  return matches;
+}
+function splitAlternation(pattern) {
+  const out = [];
+  let depth = 0;
+  let inClass = false;
+  let start = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") i++;
+    else if (inClass) inClass = ch !== "]";
+    else if (ch === "[") inClass = true;
+    else if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "|" && depth === 0) {
+      out.push(pattern.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(pattern.slice(start));
+  return out;
+}
+function packAlternatives(alternatives, maxChars) {
+  const out = [];
+  let cur = null;
+  for (const alt of alternatives) {
+    if (cur !== null && cur.length + 1 + alt.length <= maxChars) {
+      cur += `|${alt}`;
+    } else {
+      if (cur !== null) out.push(cur);
+      cur = alt;
+    }
+  }
+  if (cur !== null) out.push(cur);
+  return out;
+}
+function mergeMatches(lists) {
+  const all = lists.flat().sort(byPathLine);
+  return all.filter(
+    (m, i) => i === 0 || m.path !== all[i - 1].path || m.line !== all[i - 1].line
+  );
+}
+async function searchAlternatives(session, alternatives, paths, cfg, maxPatternChars = CODE_SEARCH_MAX_PATTERN_CHARS) {
+  const groups = alternatives.flatMap(
+    (p) => p.length + 4 <= maxPatternChars ? [`(?:${p})`] : splitAlternation(p).map((a) => `(?:${a})`)
+  ).filter((g) => g.length <= maxPatternChars);
+  const patterns = packAlternatives(groups, maxPatternChars);
+  if (patterns.length <= 1) {
+    return patterns.length ? searchPattern(session, patterns[0], paths, cfg) : [];
+  }
+  const found = await mapLimit(
+    patterns,
+    RIPGREP_SPLIT_CONCURRENCY,
+    (p) => searchPattern(session, p, paths, cfg)
+  );
+  return mergeMatches(found);
+}
+function idfOf(df, n) {
+  return Math.log(1 + n / (1 + df));
+}
+function pathMatches(path, variants) {
+  const flatPath = path.toLowerCase().replace(/[-_ .]/g, "");
+  return variants.some((v) => {
+    const flat = v.toLowerCase().replace(/[-_ ]/g, "");
+    return flat.length >= 4 && flatPath.includes(flat);
+  });
+}
+function jsRegex(pattern) {
+  try {
+    return new RegExp(pattern, "i");
+  } catch {
+    return null;
+  }
+}
+function attribute(matches, slots) {
+  const out = slots.map(() => []);
+  for (const m of matches) {
+    const lower = m.text.toLowerCase();
+    slots.forEach((s, i) => {
+      const hit = s.re ? s.re.test(m.text) : s.literals.some((l) => lower.includes(l));
+      if (hit) out[i].push(m);
+    });
+  }
+  return out;
+}
+async function normalizePrefixes(session, prefixes) {
+  const cleaned = prefixes.map((raw) => ({ raw, rel: cleanPrefix(raw) }));
+  const lookup = [
+    ...new Set(cleaned.map((c) => c.rel).filter((r) => r !== null && r !== "."))
+  ];
+  const kinds = lookup.length ? await session.pathKinds(lookup) : {};
+  const ok = [];
+  const missing = [];
+  for (const { raw, rel } of cleaned) {
+    if (rel === ".") ok.push(".");
+    else if (rel !== null && (kinds[rel] === "file" || kinds[rel] === "directory")) ok.push(rel);
+    else missing.push(raw);
+  }
+  return { ok: [...new Set(ok)], missing };
+}
+function cleanPrefix(p) {
+  let s = p.trim().replace(/\\/g, "/");
+  if (!s || s.startsWith("/") || s.startsWith("~") || /^[A-Za-z]:\//.test(s)) return null;
+  while (s.startsWith("./")) s = s.slice(2);
+  s = s.replace(/\/+$/, "").replace(/\/{2,}/g, "/");
+  if (s === "" || s === ".") return ".";
+  if (s.startsWith("-") || s.split("/").some((seg) => seg === "..")) return null;
+  return s;
+}
+async function looksBinary(session, path, bytes = 8192) {
+  return await session.readText(path, bytes) === null;
+}
+async function recall(input) {
+  const t0 = performance.now();
+  const cfg = input.config;
+  const session = input.session;
+  const kwsRaw = [
+    ...new Set(
+      input.keywords.map((k) => k.replace(/\s+/g, " ").trim()).filter((k) => k.length >= 2)
+    )
+  ];
+  const prefixes = await normalizePrefixes(session, input.pathPrefixes);
+  let searchPaths = prefixes.ok.length ? prefixes.ok : ["."];
+  let widened = input.pathPrefixes.length > 0 && prefixes.ok.length === 0;
+  const keywordsFresh = () => kwsRaw.map((raw, index) => {
+    const { pattern, rgPattern, mode, variants } = buildPattern(raw, cfg);
+    return {
+      index,
+      raw,
+      variants,
+      mode,
+      pattern,
+      rgPattern,
+      df: 0,
+      pathDf: 0,
+      hitLines: 0,
+      idf: 0,
+      fragments: []
+    };
+  });
+  const attempt = async (paths) => {
+    const keywords2 = keywordsFresh();
+    const slots = [];
+    const fragsOf = /* @__PURE__ */ new Map();
+    for (const k of keywords2) {
+      slots.push({
+        ki: k.index,
+        fragment: false,
+        re: jsRegex(k.pattern),
+        literals: k.variants.map((v) => v.toLowerCase())
+      });
+      const frags = cfg.recall.fragmentFallback ? compoundFragments(k.raw) : [];
+      if (frags.length) {
+        const pattern = fragmentPattern(frags);
+        fragsOf.set(k.index, { frags, pattern });
+        slots.push({
+          ki: k.index,
+          fragment: true,
+          re: jsRegex(pattern),
+          literals: frags.flatMap((f) => keywordVariants(f)).map((v) => v.toLowerCase())
+        });
+      }
+    }
+    const alternatives = [
+      ...keywords2.map((k) => k.rgPattern),
+      ...[...fragsOf.values()].map((f) => f.pattern)
+    ];
+    const [files2, matches] = await Promise.all([
+      listFiles(session, paths, cfg),
+      searchAlternatives(session, alternatives, paths, cfg)
+    ]);
+    const bySlot = attribute(matches, slots);
+    const results2 = keywords2.map(() => []);
+    slots.forEach((s, i) => {
+      if (!s.fragment) results2[s.ki] = bySlot[i];
+    });
+    slots.forEach((s, i) => {
+      if (s.fragment && results2[s.ki].length === 0 && bySlot[i].length > 0) {
+        results2[s.ki] = bySlot[i];
+        keywords2[s.ki].fragments = fragsOf.get(s.ki).frags;
+      }
+    });
+    return { files: files2, keywords: keywords2, results: results2 };
+  };
+  let { files, keywords, results } = await attempt(searchPaths);
+  const countFiles = (rs) => new Set(rs.flat().map((m) => m.path)).size;
+  if (prefixes.ok.length && countFiles(results) < cfg.recall.minCandidatesBeforeWiden) {
+    searchPaths = ["."];
+    widened = true;
+    ({ files, keywords, results } = await attempt(searchPaths));
+  }
+  const n = Math.max(files.length, 1);
+  const byPath = /* @__PURE__ */ new Map();
+  const get = (path) => {
+    let c = byPath.get(path);
+    if (!c) {
+      c = {
+        path,
+        lexScore: 0,
+        kwHits: {},
+        pathKws: [],
+        hitLines: /* @__PURE__ */ new Map(),
+        isTest: isTestPath(path),
+        isDoc: isDocPath(path)
+      };
+      byPath.set(path, c);
+    }
+    return c;
+  };
+  const kwFiles = keywords.map(() => /* @__PURE__ */ new Set());
+  const maxStored = cfg.recall.maxMatchesPerFile;
+  results.forEach((matches, ki) => {
+    const kw = keywords[ki];
+    const seen = kwFiles[ki];
+    for (const m of matches) {
+      seen.add(m.path);
+      const c = get(m.path);
+      const cnt = c.kwHits[ki] = (c.kwHits[ki] ?? 0) + 1;
+      if (cnt > maxStored) continue;
+      let h = c.hitLines.get(m.line);
+      if (!h) {
+        h = { line: m.line, text: m.text, kws: [] };
+        c.hitLines.set(m.line, h);
+      }
+      if (!h.kws.includes(ki)) h.kws.push(ki);
+    }
+    kw.df = seen.size;
+    kw.hitLines = matches.length;
+  });
+  for (const kw of keywords) {
+    const variants = kw.fragments.length ? kw.fragments.flatMap((f) => keywordVariants(f)) : kw.variants;
+    for (const f of files) {
+      if (pathMatches(f, variants)) {
+        kw.pathDf++;
+        kwFiles[kw.index].add(f);
+        const c = get(f);
+        if (!c.pathKws.includes(kw.index)) c.pathKws.push(kw.index);
+      }
+    }
+  }
+  for (const kw of keywords)
+    kw.idf = kwFiles[kw.index].size > 0 ? idfOf(kwFiles[kw.index].size, n) : 0;
+  const testsOk = questionMentionsTests(input.question);
+  const historyOk = questionMentionsHistory(input.question);
+  for (const c of byPath.values()) {
+    let s = 0;
+    let lines = 0;
+    for (const [ki, cnt] of Object.entries(c.kwHits)) {
+      s += keywords[Number(ki)].idf;
+      lines += cnt;
+    }
+    for (const ki of c.pathKws) s += cfg.recall.pathBonus * keywords[ki].idf;
+    s += cfg.recall.hitCountWeight * Math.log(1 + lines);
+    if (c.isTest && !testsOk) s *= cfg.recall.testWeight;
+    if (!historyOk && isChangelogPath(c.path)) s *= cfg.recall.changelogWeight;
+    c.lexScore = s;
+  }
+  const scored = [...byPath.values()].filter((c) => c.lexScore > 0);
+  scored.sort((a, b) => b.lexScore - a.lexScore || (a.path < b.path ? -1 : 1));
+  const candidates = [];
+  let binaryDropped = 0;
+  let next = 0;
+  while (next < scored.length && candidates.length < cfg.recall.maxCandidates) {
+    const batch = scored.slice(next, next + cfg.recall.maxCandidates - candidates.length);
+    next += batch.length;
+    const pathOnly = batch.filter((c) => c.hitLines.size === 0);
+    const binary = /* @__PURE__ */ new Set();
+    const flags = await mapLimit(pathOnly, READ_CONCURRENCY, (c) => looksBinary(session, c.path));
+    pathOnly.forEach((c, i) => {
+      if (flags[i]) binary.add(c);
+    });
+    for (const c of batch) {
+      if (binary.has(c)) binaryDropped++;
+      else candidates.push(c);
+    }
+  }
+  return {
+    keywords,
+    totalFiles: files.length,
+    candidates,
+    scoredFiles: scored.length,
+    searchPaths,
+    widened,
+    missingPrefixes: prefixes.missing,
+    validPrefixes: prefixes.ok,
+    binaryDropped,
+    ms: Math.round(performance.now() - t0)
+  };
+}
+function lineWeight(h, keywords) {
+  return h.kws.reduce((s, k) => s + (keywords[k]?.idf ?? 0), 0);
+}
+function bestHitLines(c, keywords, n) {
+  return [...c.hitLines.values()].sort((a, b) => lineWeight(b, keywords) - lineWeight(a, keywords) || a.line - b.line).slice(0, n).sort((a, b) => a.line - b.line);
+}
+
+// src/code-search/search.ts
+var CODE_SEARCH_ENGINE_VERSION = "scout-0.3.1";
+var CODE_SEARCH_DEFAULT_BUDGET_TOKENS = 12e3;
+var r22 = (x) => x === null || x === void 0 || !Number.isFinite(x) ? "?" : x.toFixed(2);
+function lexicalPassageScore(text, kwPresent, keywords, qTerms, fileNorm) {
+  const total = keywords.reduce((s, k) => s + k.idf, 0) || 1;
+  const mass = kwPresent.reduce((s, k) => s + keywords[k].idf, 0) / total;
+  const qov = overlap(qTerms, new Set(contentTerms(text)));
+  return Math.max(0, Math.min(1, 0.55 * mass + 0.3 * qov + 0.15 * fileNorm));
+}
+function selectFiles(cands, scores, ids, T1, cfg) {
+  const ranked = cands.map((_, i) => i).sort(
+    (a, b) => (scores.get(ids[b]) ?? 0) - (scores.get(ids[a]) ?? 0) || cands[b].lexScore - cands[a].lexScore || a - b
+  );
+  const selected = [];
+  for (let i = 0; i < Math.min(cfg.wave1.lexicalGuard, cands.length); i++) selected.push(i);
+  ranked.forEach((i, rank) => {
+    if (selected.length >= cfg.wave1.maxFiles || selected.includes(i)) return;
+    if ((scores.get(ids[i]) ?? 0) >= T1 || rank < cfg.wave1.minFiles) selected.push(i);
+  });
+  selected.sort((a, b) => ranked.indexOf(a) - ranked.indexOf(b));
+  return { selected, ranked };
+}
+function capPassages(perFile, max) {
+  const sorted = perFile.map((ws) => [...ws].sort((a, b) => b.score - a.score));
+  const out = perFile.map(() => []);
+  let taken = 0;
+  for (let pass = 0; taken < max; pass++) {
+    let any = false;
+    for (let f = 0; f < sorted.length && taken < max; f++) {
+      const w = sorted[f][pass];
+      if (w) {
+        out[f].push(w);
+        taken++;
+        any = true;
+      }
+    }
+    if (!any) break;
+  }
+  return out;
+}
+function statusEvidence(included, maxChars) {
+  const out = [];
+  let used = 0;
+  for (const p of [...included].sort((a, b) => b.rel - a.rel)) {
+    if (used + p.block.length + 2 > maxChars) continue;
+    out.push(p.block);
+    used += p.block.length + 2;
+  }
+  return out.join("\n\n");
+}
+function statusLabel(s, cfg) {
+  if (!s || !Number.isFinite(s.overall)) return { label: "unknown", overall: null, subs: [] };
+  const { hi, lo } = cfg.status;
+  const subsOk = s.subs.every((x) => x >= hi);
+  const anySub = s.subs.some((x) => x >= hi);
+  const label = s.overall >= hi && subsOk ? "sufficient" : s.overall >= lo || anySub ? "partial" : "insufficient";
+  return { label, overall: s.overall, subs: s.subs };
+}
+function prefixNote(rec) {
+  const notes = [];
+  if (rec.missingPrefixes.length) {
+    notes.push(
+      `Note: paths not found in the workspace (ignored): ${rec.missingPrefixes.join(", ")}.`
+    );
+  }
+  if (rec.widened) {
+    notes.push(
+      !rec.validPrefixes.length ? "Note: the whole workspace was searched." : "Note: nothing matched under the given paths; the whole workspace was searched."
+    );
+  }
+  return notes.length ? notes.join(" ") : void 0;
+}
+function partialLabel(session) {
+  if (!session.partial) return "";
+  const why = session.timedOut ? "a ripgrep search hit its time limit" : "ripgrep output was cut at its size limit";
+  return `(partial search: ${why}; some matches may be missing)`;
+}
+async function runCodeSearch(input) {
+  const outer = input.signal;
+  outer?.throwIfAborted();
+  const controller = new AbortController();
+  const onOuterAbort = () => controller.abort(outer?.reason);
+  outer?.addEventListener("abort", onOuterAbort, { once: true });
+  try {
+    return await pipeline(input, controller.signal);
+  } catch (error) {
+    controller.abort(error);
+    if (outer?.aborted) throw outer.reason;
+    throw error;
+  } finally {
+    outer?.removeEventListener("abort", onOuterAbort);
+  }
+}
+async function pipeline(o, signal) {
+  const cfg = o.config ?? DEFAULT_CODE_SEARCH_CONFIG;
+  const t0 = performance.now();
+  const stageMs = {};
+  const mark = (stage, since) => {
+    stageMs[stage] = Math.round(performance.now() - since);
+  };
+  const emit = (stage, data) => {
+    try {
+      o.onStage?.(stage, data);
+    } catch {
+    }
+  };
+  const session = new WorkspaceSession(o.workspace, signal, cfg.recall.ripgrepTimeoutMs);
+  const judge = new JevJudge({ client: o.jev, config: cfg, signal, onEvent: emit });
+  const subQuestions = (o.subQuestions ?? []).map((s) => s.trim()).filter(Boolean).slice(0, 4);
+  const ctx = { question: o.question.trim(), subQuestions };
+  const budgetTokens = o.budgetTokens ?? CODE_SEARCH_DEFAULT_BUDGET_TOKENS;
+  const thr = cfg.thresholds;
+  emit("start", {
+    version: CODE_SEARCH_ENGINE_VERSION,
+    question: ctx.question,
+    subQuestions,
+    keywords: o.keywords,
+    paths: o.paths ?? [],
+    budgetTokens
+  });
+  o.jev.warmUp(cfg.jev.warmConnections);
+  let ts = performance.now();
+  const rec = await recall({
+    session,
+    question: ctx.question + " " + subQuestions.join(" "),
+    keywords: o.keywords,
+    pathPrefixes: o.paths ?? [],
+    config: cfg
+  });
+  mark("recall", ts);
+  const kws = rec.keywords;
+  emit("recall", {
+    ms: rec.ms,
+    totalFiles: rec.totalFiles,
+    scoredFiles: rec.scoredFiles,
+    searchPaths: rec.searchPaths,
+    widened: rec.widened,
+    missingPrefixes: rec.missingPrefixes,
+    binaryDropped: rec.binaryDropped,
+    partial: session.partial,
+    keywords: kws.map((k) => ({
+      raw: k.raw,
+      mode: k.mode,
+      pattern: k.pattern,
+      df: k.df,
+      pathDf: k.pathDf,
+      hitLines: k.hitLines,
+      idf: round(k.idf),
+      fragments: k.fragments
+    })),
+    candidates: rec.candidates.map((c) => ({
+      path: c.path,
+      lex: round(c.lexScore),
+      kws: Object.keys(c.kwHits).map(Number),
+      pathKws: c.pathKws,
+      lines: c.hitLines.size,
+      test: c.isTest
+    }))
+  });
+  ts = performance.now();
+  const maxLex = rec.candidates[0]?.lexScore || 1;
+  const fileIds = rec.candidates.map((_, i) => `f${String(i).padStart(3, "0")}`);
+  const fileItems = rec.candidates.map((c, i) => {
+    const hits = bestHitLines(c, kws, cfg.wave1.hitLinesPerFile);
+    const needles = Object.keys(c.kwHits).flatMap((k) => kws[Number(k)].variants);
+    const lines = hits.map(
+      (h) => `  ${h.line}: ${trimAround(h.text, needles, cfg.wave1.hitLineChars)}`
+    );
+    return {
+      id: fileIds[i],
+      path: c.path,
+      descriptor: [c.path, ...lines].join("\n"),
+      lex: c.lexScore / maxLex
+    };
+  });
+  const fileScores = await judge.scoreFiles(fileItems, ctx);
+  const { selected, ranked } = selectFiles(rec.candidates, fileScores, fileIds, thr.T1, cfg);
+  mark("wave1", ts);
+  emit("wave1", {
+    T1: thr.T1,
+    scores: rec.candidates.map((c, i) => ({
+      path: c.path,
+      p: round(fileScores.get(fileIds[i]) ?? Number.NaN),
+      lex: round(fileItems[i].lex)
+    })),
+    selected: selected.map((i) => rec.candidates[i].path)
+  });
+  ts = performance.now();
+  const fileLines = /* @__PURE__ */ new Map();
+  const loadLines = async (paths) => {
+    const missing = [...new Set(paths)].filter((p) => !fileLines.has(p));
+    const texts = await mapLimit(
+      missing,
+      READ_CONCURRENCY,
+      (p) => session.readText(p, cfg.recall.maxFileBytes)
+    );
+    missing.forEach((p, i) => {
+      const text2 = texts[i];
+      fileLines.set(p, text2 === null || text2 === void 0 ? [] : splitLines(text2));
+    });
+  };
+  const readLines = (path) => fileLines.get(path) ?? [];
+  await loadLines(selected.map((i) => rec.candidates[i].path));
+  const kwNeedles = kws.filter((k) => k.idf > 0).map((k) => keywordRegex(k)).filter((re) => re !== null);
+  const renderFor = (path, needles = kwNeedles) => ({
+    maxLineChars: isDocPath(path) ? cfg.wave2.maxProseLineChars : cfg.wave2.maxLineChars,
+    needles
+  });
+  const perFileWindows = selected.map((i) => {
+    const c = rec.candidates[i];
+    const lines = readLines(c.path);
+    const hits = [...c.hitLines.values()];
+    return buildFileWindows(lines, hits, kws, langOf(c.path), cfg, renderFor(c.path));
+  });
+  const capped = capPassages(perFileWindows, cfg.wave2.maxPassages);
+  const qTerms = contentTerms(ctx.question);
+  const subTerms = subQuestions.map((s) => contentTerms(s));
+  const evidence = [];
+  const passageItems = [];
+  let pid = 0;
+  const makePassage = (path, w, fileNorm, lead) => {
+    const lines = readLines(path);
+    const render = renderFor(path, lead ? [new RegExp(`\\b${escapeRegex(lead)}\\b`)] : kwNeedles);
+    const text2 = renderLines(lines, w.start, w.end, render);
+    const raw = lines.slice(w.start - 1, w.end).join("\n");
+    const present = keywordsInRange(lines, w.start, w.end, kws);
+    const rawTerms = new Set(contentTerms(raw));
+    const id = `p${String(pid++).padStart(3, "0")}`;
+    const lex = lexicalPassageScore(raw, present, kws, qTerms, fileNorm);
+    const lexCov = subTerms.map((t) => overlap(t, rawTerms));
+    const label2 = w.label && w.label.line < w.start ? `L${w.label.line}: ${w.label.text}` : void 0;
+    passageItems.push({ id, path, start: w.start, end: w.end, text: text2, label: label2, lex, lexCov });
+    evidence.push({
+      id,
+      path,
+      start: w.start,
+      end: w.end,
+      fileLines: lines,
+      hits: w.hits,
+      label: w.label,
+      kind: w.kind,
+      rel: lex,
+      cov: lexCov,
+      lex,
+      lead,
+      render
+    });
+  };
+  selected.forEach((ci, f) => {
+    const c = rec.candidates[ci];
+    for (const w of [...capped[f]].sort((a, b) => a.start - b.start))
+      makePassage(c.path, w, c.lexScore / maxLex);
+  });
+  const wave2Scores = await judge.scorePassages(passageItems, ctx, "wave2");
+  for (const e of evidence) {
+    const s = wave2Scores.get(e.id);
+    if (s) {
+      e.rel = s.rel;
+      e.cov = s.cov;
+    }
+  }
+  mark("wave2", ts);
+  emit("wave2", {
+    T2: thr.T2,
+    passages: evidence.map((e) => ({
+      id: e.id,
+      path: e.path,
+      start: e.start,
+      end: e.end,
+      kind: e.kind,
+      hits: e.hits.length,
+      rel: round(e.rel),
+      cov: e.cov.map(round),
+      lex: round(e.lex ?? Number.NaN)
+    }))
+  });
+  ts = performance.now();
+  let leadCands = [];
+  let leadScores = /* @__PURE__ */ new Map();
+  const chosenNames = /* @__PURE__ */ new Set();
+  if (cfg.wave3.enabled) {
+    const leadsFollowed = [];
+    const seeds = evidence.filter((e) => e.rel >= thr.T2).sort((a, b) => b.rel - a.rel).slice(0, cfg.wave3.seedPassages).map((e) => ({
+      path: e.path,
+      start: e.start,
+      lines: e.fileLines.slice(e.start - 1, e.end),
+      rel: e.rel
+    }));
+    const searched = /* @__PURE__ */ new Set();
+    for (const k of kws) {
+      for (const v of [...k.variants, ...k.fragments.flatMap((f) => keywordVariants(f))]) {
+        searched.add(v.toLowerCase());
+        searched.add(splitWords(v).join(" "));
+      }
+    }
+    const qWords = new Set(
+      [
+        ...splitWords(ctx.question + " " + subQuestions.join(" ")),
+        ...kws.flatMap((k) => splitWords(k.raw))
+      ].filter((w) => w.length >= 3 && !STOPWORDS.has(w))
+    );
+    const extracted = extractLeads(
+      seeds,
+      searched,
+      qWords,
+      Math.ceil(cfg.wave3.maxLeadCandidates * 1.5)
+    );
+    const selectedPaths = new Set(selected.map((i) => rec.candidates[i].path));
+    const allowTests = questionMentionsTests(ctx.question);
+    const defSearch = await locateDefinitions(
+      session,
+      extracted.map((l) => l.name),
+      cfg,
+      excludeArgs(cfg),
+      12,
+      allowTests
+    );
+    const seenAt = new Map(extracted.map((l) => [l.name, l.seenAt.path]));
+    const defs = chooseDefinitions(
+      defSearch.hits,
+      selectedPaths,
+      cfg.wave3.defsPerLead,
+      allowTests,
+      seenAt
+    );
+    const inEvidence = (path, line) => evidence.some((e) => e.path === path && line >= e.start && line <= e.end);
+    const leadDrops = {};
+    const nFiles = Math.max(rec.totalFiles, 1);
+    const genericity = (name) => idfOf(defSearch.fileCounts.get(name) ?? 0, nFiles) / idfOf(0, nFiles);
+    leadCands = extracted.filter((l) => {
+      const ds = defs.get(l.name) ?? [];
+      if (!ds.length) leadDrops[l.name] = "no definition found";
+      else if (ds.every((d) => inEvidence(d.path, d.line)))
+        leadDrops[l.name] = "definition already in evidence";
+      return ds.length > 0 && !ds.every((d) => inEvidence(d.path, d.line));
+    }).map((l) => ({ ...l, weight: Math.round(l.weight * genericity(l.name) * 1e3) / 1e3 })).sort((a, b) => b.weight - a.weight || (a.name < b.name ? -1 : 1)).slice(0, cfg.wave3.maxLeadCandidates);
+    const maxW = Math.max(...leadCands.map((l) => l.weight), 1e-9);
+    const leadItems = leadCands.map((l, i) => ({
+      id: `l${String(i).padStart(3, "0")}`,
+      name: l.name,
+      seenAt: `${l.seenAt.path}:${l.seenAt.line}`,
+      context: l.context,
+      lex: l.weight / maxW
+    }));
+    leadScores = await judge.scoreLeads(leadItems, ctx);
+    const chosen = leadItems.map((l) => ({ l, p: leadScores.get(l.id) ?? 0 })).filter((x) => x.p >= thr.T3).sort((a, b) => b.p - a.p || (a.l.id < b.l.id ? -1 : 1)).slice(0, cfg.wave3.maxLeadsFollowed);
+    for (const x of chosen) chosenNames.add(x.l.name);
+    await loadLines(chosen.flatMap((x) => (defs.get(x.l.name) ?? []).map((d) => d.path)));
+    const defItemsStart = passageItems.length;
+    for (const x of chosen) {
+      for (const d of defs.get(x.l.name) ?? []) {
+        const lines = readLines(d.path);
+        if (d.line > lines.length) {
+          leadsFollowed.push({
+            name: x.l.name,
+            score: x.p,
+            def: `${d.path}:${d.line} (not in the file as read)`
+          });
+          continue;
+        }
+        const w = definitionWindow(
+          lines,
+          d.line,
+          langOf(d.path),
+          cfg,
+          renderFor(d.path, [new RegExp(`\\b${escapeRegex(x.l.name)}\\b`)])
+        );
+        const overlapsExisting = evidence.some(
+          (e) => e.path === d.path && !(w.end < e.start || w.start > e.end)
+        );
+        leadsFollowed.push({
+          name: x.l.name,
+          score: x.p,
+          def: `${d.path}:${d.line}${overlapsExisting ? " (overlaps evidence)" : ""}`
+        });
+        if (overlapsExisting) continue;
+        makePassage(d.path, w, 0, x.l.name);
+      }
+    }
+    const defItems = passageItems.slice(defItemsStart);
+    if (defItems.length) {
+      const defScores = await judge.scorePassages(defItems, ctx, "lead_defs");
+      for (const e of evidence) {
+        const s = defScores.get(e.id);
+        if (s) {
+          e.rel = s.rel;
+          e.cov = s.cov;
+        }
+      }
+    }
+    emit("leads", {
+      T3: thr.T3,
+      seeds: seeds.map((s) => `${s.path}:${s.start}`),
+      candidates: leadItems.map((l) => ({
+        id: l.id,
+        name: l.name,
+        seenAt: l.seenAt,
+        lex: round(l.lex),
+        p: round(leadScores.get(l.id) ?? Number.NaN)
+      })),
+      followed: leadsFollowed,
+      defsFound: defSearch.hits.length,
+      defSearchMs: defSearch.ms,
+      extracted: extracted.length,
+      dropped: leadDrops,
+      defPassages: evidence.filter((e) => e.kind === "def").map((e) => ({
+        id: e.id,
+        path: e.path,
+        start: e.start,
+        end: e.end,
+        lead: e.lead,
+        rel: round(e.rel)
+      }))
+    });
+  }
+  mark("wave3", ts);
+  ts = performance.now();
+  const cpt = cfg.pack.charsPerToken;
+  const totalChars = Math.floor(budgetTokens * cpt);
+  const headerReserve = 420 + subQuestions.reduce((s, q) => s + q.length + 8, 0);
+  const footerReserve = Math.min(1800, Math.floor(totalChars * 0.12));
+  const body = packBody(evidence, {
+    subQuestions,
+    T2: thr.T2,
+    bodyChars: Math.max(0, totalChars - headerReserve - footerReserve),
+    cfg,
+    downweightChangelogs: !questionMentionsHistory(ctx.question + " " + subQuestions.join(" ")),
+    downweightTests: !questionMentionsTests(ctx.question)
+  });
+  const includedFiles = new Set(body.included.map((p) => p.path));
+  const windowedFiles = new Set(evidence.map((e) => e.path));
+  const otherFiles = ranked.filter((i) => !windowedFiles.has(rec.candidates[i].path)).map((i) => ({ path: rec.candidates[i].path, score: fileScores.get(fileIds[i]) ?? 0 })).filter((x) => x.score > 0);
+  const leadIdByName = new Map(leadCands.map((l, i) => [l.name, `l${String(i).padStart(3, "0")}`]));
+  const notFollowed = leadCands.filter((l) => !chosenNames.has(l.name)).map((l) => ({
+    name: l.name,
+    score: leadScores.get(leadIdByName.get(l.name)) ?? 0,
+    seenAt: `${l.seenAt.path}:${l.seenAt.line}`
+  })).sort((a, b) => b.score - a.score);
+  const zero = kws.filter((k) => k.df === 0 && k.pathDf === 0);
+  const fragmentOnly = kws.filter((k) => k.fragments.length > 0 && (k.df > 0 || k.pathDf > 0));
+  const zeroHitKeywords = [
+    ...zero.map((k) => ({ raw: k.raw, fragments: [] })),
+    ...fragmentOnly.map((k) => ({ raw: k.raw, fragments: k.fragments }))
+  ];
+  const widenedNote = prefixNote(rec);
+  const footer = renderFooter({
+    excluded: body.excluded,
+    otherFiles,
+    leadsNotFollowed: notFollowed,
+    zeroHitKeywords,
+    ...widenedNote ? { widenedNote } : {},
+    cfg,
+    maxChars: footerReserve
+  });
+  mark("pack", ts);
+  ts = performance.now();
+  let status = { label: "unknown", overall: null, subs: [] };
+  let statusCheckError;
+  let statusEvidenceChars = 0;
+  if (cfg.status.enabled && body.included.length) {
+    const ev = statusEvidence(body.included, cfg.status.maxEvidenceChars);
+    statusEvidenceChars = ev.length;
+    try {
+      status = statusLabel(await judge.status(ev, ctx), cfg);
+    } catch (error) {
+      if (signal.aborted || !(error instanceof JevUnavailableError || error instanceof JevRequestError))
+        throw error;
+      statusCheckError = error;
+      status = { label: "unknown", overall: null, subs: [], error: error.message.slice(0, 200) };
+    }
+  } else if (!body.included.length) {
+    status = { label: "insufficient", overall: null, subs: [] };
+  }
+  mark("status", ts);
+  emit("pack", {
+    T2: thr.T2,
+    budgetTokens,
+    totalChars,
+    priority: body.priority,
+    included: body.included.map((p) => ({
+      id: p.id,
+      path: p.path,
+      start: p.start,
+      end: p.end,
+      trimmed: p.trimmed,
+      rel: round(p.rel),
+      cov: p.cov.map(round),
+      chars: p.block.length
+    })),
+    excluded: body.excluded.map((e) => ({
+      id: e.id,
+      path: e.path,
+      start: e.start,
+      end: e.end,
+      rel: round(e.rel)
+    })),
+    status,
+    statusEvidenceChars
+  });
+  const jevTotals = Object.values(judge.stats()).reduce(
+    (a, s) => ({
+      requests: a.requests + s.requests,
+      inputTokens: a.inputTokens + s.inputTokens,
+      costUsd: a.costUsd + s.costUsd
+    }),
+    { requests: 0, inputTokens: 0, costUsd: 0 }
+  );
+  const wallMs = Math.round(performance.now() - t0);
+  const label = partialLabel(session);
+  const statusText = status.label === "unknown" || status.overall === null ? status.error ? "evidence rating unknown (check failed)" : "evidence rating unknown (no check)" : `evidence rating ${r22(status.overall)}` + (status.subs.length ? ` (${status.subs.map((x, j) => `s${j + 1} ${r22(x)}`).join(", ")})` : "");
+  const buildText = (packTok) => {
+    const head = [
+      `code_search${label ? " " + label : ""}: ${statusText} | ${body.included.length} passages from ${includedFiles.size} files, ~${fmtK(packTok)} tokens | ${(wallMs / 1e3).toFixed(1)}s`
+    ];
+    if (subQuestions.length) head.push(subQuestions.map((s, j) => `s${j + 1}: ${s}`).join("\n"));
+    head.push(
+      body.included.length ? "Passages are verbatim with original line numbers (N| text), grouped by file, best first; rel = relevance, [sN] = covers sub-question N. The rating covers only these passages; it cannot see other entry points, defaults, flags or exceptions the search did not return." : "No passage passed verification. Try other keywords (exact identifiers, config keys, error strings) or read the candidates below."
+    );
+    return [head.join("\n"), body.body, footer].filter(Boolean).join("\n\n") + "\n";
+  };
+  let text = buildText(0);
+  text = buildText(estTokens(text.length, cpt));
+  const stats = {
+    wallMs,
+    stageMs,
+    candidates: rec.candidates.length,
+    filesSelected: selected.length,
+    passagesVerified: evidence.length,
+    passagesIncluded: body.included.length,
+    packChars: text.length,
+    packTokensEst: estTokens(text.length, cpt),
+    workspaceCalls: session.calls,
+    ripgrepTruncated: session.partial,
+    jev: { ...jevTotals, model: judge.model() }
+  };
+  emit("summary", { wallMs, stageMs, stats, status, jevByStage: judge.stats() });
+  const result = { version: CODE_SEARCH_ENGINE_VERSION, text, status, stats };
+  if (statusCheckError) result.statusCheckError = statusCheckError;
+  return result;
+}
+function round(x) {
+  return Number.isFinite(x) ? Math.round(x * 1e3) / 1e3 : x;
+}
+
+// src/code-search/tool.ts
+var CODE_SEARCH_TOOL_NAME = "code_search";
+var CODE_SEARCH_TOOL_DESCRIPTION = "Find where something is implemented, configured or decided in the code under the working directory, in one call instead of many separate searches and file reads. Give one precise question and 6-15 keywords: likely identifiers, file-name fragments, config keys, error strings and synonyms. Optional subQuestions split distinct parts (for 'is X required?', add one for what could skip or override X); optional paths limit the search. It ranks files and passages with a fast relevance model, follows definitions one level, and returns the best passages verbatim with file paths and line numbers, plus an evidence rating for those passages. The rating cannot see what the search missed: use the passages instead of re-reading them, then check what they do not cover (other entry points, defaults, flags, exceptions) before concluding.";
+var CODE_SEARCH_LIMITS = {
+  questionMinChars: 3,
+  questionMaxChars: 2e3,
+  keywordsMax: 20,
+  keywordMaxChars: 120,
+  subQuestionsMax: 3,
+  subQuestionMaxChars: 1e3,
+  pathsMax: 8,
+  pathMaxChars: 1e3
+};
+var L = CODE_SEARCH_LIMITS;
+var codeSearchInputSchema = {
+  type: "object",
+  properties: {
+    question: {
+      type: "string",
+      minLength: L.questionMinChars,
+      maxLength: L.questionMaxChars,
+      description: "One precise question about the code, for example where a behavior is implemented or how a value is computed."
+    },
+    keywords: {
+      type: "array",
+      minItems: 1,
+      maxItems: L.keywordsMax,
+      items: { type: "string", minLength: 1, maxLength: L.keywordMaxChars },
+      description: "6-15 search keywords: likely identifiers (camelCase, snake_case, UPPER_CASE), file-name fragments, config or env keys, error strings, synonyms. Case and camel/snake/kebab variants are searched automatically."
+    },
+    subQuestions: {
+      type: "array",
+      maxItems: L.subQuestionsMax,
+      items: { type: "string", minLength: 1, maxLength: L.subQuestionMaxChars },
+      description: "Optional: the distinct parts of a multi-part question, one per entry."
+    },
+    paths: {
+      type: "array",
+      maxItems: L.pathsMax,
+      items: { type: "string", minLength: 1, maxLength: L.pathMaxChars },
+      description: "Optional: workspace-relative directories or files to limit the search to. Default: the whole workspace."
+    }
+  },
+  required: ["question", "keywords"],
+  additionalProperties: false
+};
+var CodeSearchArgumentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodeSearchArgumentError";
+  }
+};
+var KNOWN_ARGUMENTS = /* @__PURE__ */ new Set(["question", "keywords", "subQuestions", "paths"]);
+function parseCodeSearchArguments(args) {
+  const unknown = Object.keys(args).filter((k) => !KNOWN_ARGUMENTS.has(k));
+  if (unknown.length) {
+    throw new CodeSearchArgumentError(
+      `unknown argument ${unknown.map((k) => `"${k}"`).join(", ")}; allowed: question, keywords, subQuestions, paths`
+    );
+  }
+  if (typeof args.question !== "string")
+    throw new CodeSearchArgumentError("question is required and must be a string");
+  const question = args.question.trim();
+  if (question.length < L.questionMinChars)
+    throw new CodeSearchArgumentError(`question must be at least ${L.questionMinChars} characters`);
+  if (question.length > L.questionMaxChars)
+    throw new CodeSearchArgumentError(`question must be at most ${L.questionMaxChars} characters`);
+  const keywords = stringList(args.keywords, "keywords", true);
+  if (!keywords.length)
+    throw new CodeSearchArgumentError("keywords must contain at least one non-empty keyword");
+  if (keywords.length > L.keywordsMax)
+    throw new CodeSearchArgumentError(
+      `keywords accepts at most ${L.keywordsMax} entries; keep the ${L.keywordsMax} most specific`
+    );
+  const longKeyword = keywords.find((k) => k.length > L.keywordMaxChars);
+  if (longKeyword)
+    throw new CodeSearchArgumentError(
+      `each keyword must be at most ${L.keywordMaxChars} characters; use short identifiers or phrases`
+    );
+  const subQuestions = stringList(args.subQuestions, "subQuestions", false);
+  if (subQuestions.length > L.subQuestionsMax)
+    throw new CodeSearchArgumentError(`subQuestions accepts at most ${L.subQuestionsMax} entries`);
+  if (subQuestions.some((s) => s.length > L.subQuestionMaxChars)) {
+    throw new CodeSearchArgumentError(
+      `each sub-question must be at most ${L.subQuestionMaxChars} characters`
+    );
+  }
+  const paths = [...new Set(stringList(args.paths, "paths", false).map(normalizePath))];
+  if (paths.length > L.pathsMax)
+    throw new CodeSearchArgumentError(`paths accepts at most ${L.pathsMax} entries`);
+  return { question, keywords, subQuestions, paths };
+}
+function stringList(value, name, required) {
+  if (value === void 0 || value === null) {
+    if (required)
+      throw new CodeSearchArgumentError(`${name} is required and must be an array of strings`);
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+    throw new CodeSearchArgumentError(`${name} must be an array of strings`);
+  }
+  return [...new Set(value.map((v) => v.trim()).filter(Boolean))];
+}
+function normalizePath(raw) {
+  if (raw.length > L.pathMaxChars)
+    throw new CodeSearchArgumentError(`each path must be at most ${L.pathMaxChars} characters`);
+  if (raw.startsWith("/") || raw.startsWith("~") || /^[A-Za-z]:[\\/]/.test(raw)) {
+    throw new CodeSearchArgumentError(
+      `path "${raw}" is absolute; give paths relative to the working directory`
+    );
+  }
+  let p = raw;
+  while (p.startsWith("./")) p = p.slice(2);
+  p = p.replace(/\/+$/, "");
+  if (!p) p = ".";
+  if (p.split("/").some((seg) => seg === "..")) {
+    throw new CodeSearchArgumentError(
+      `path "${raw}" leaves the working directory; ".." is not allowed`
+    );
+  }
+  if (p.startsWith("-")) throw new CodeSearchArgumentError(`path "${raw}" must not start with "-"`);
+  return p;
+}
+var FALLBACK = "Search with exec_command (rg, sed) instead.";
+function renderCodeSearchError(error) {
+  const detail = (e) => (e instanceof Error ? e.message : String(e)).replace(/\s+/g, " ").trim().slice(0, 240);
+  if (error instanceof CodeSearchArgumentError)
+    return `code_search: invalid arguments: ${error.message}.`;
+  if (error instanceof JevUnavailableError)
+    return `code_search is unavailable right now (${detail(error)}). ${FALLBACK}`;
+  if (error instanceof JevRequestError)
+    return `code_search failed: the relevance model rejected the request (${detail(error)}). ${FALLBACK}`;
+  if (isRipgrepMissing(error)) {
+    return "code_search cannot run here: ripgrep (rg) is not installed in this workspace. Search with exec_command (grep, find, sed) instead.";
+  }
+  if (error instanceof CodeSearchWorkspaceError)
+    return `code_search could not search this workspace (${detail(error)}). ${FALLBACK}`;
+  if (isAbort(error)) return "code_search was cancelled.";
+  return `code_search failed unexpectedly (${detail(error)}). ${FALLBACK}`;
+}
+function isRipgrepMissing(error) {
+  if (error instanceof CodeSearchRipgrepMissingError) return true;
+  if (!(error instanceof CodeSearchWorkspaceError)) return false;
+  const m = error.message;
+  return /ripgrep|\brg\b/i.test(m) && /not (installed|found)|missing|ENOENT|no such file/i.test(m);
+}
+function isAbort(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+export {
+  CODE_SEARCH_DEFAULT_BUDGET_TOKENS,
+  CODE_SEARCH_ENGINE_VERSION,
+  CODE_SEARCH_LIMITS,
+  CODE_SEARCH_MAX_PATTERN_CHARS,
+  CODE_SEARCH_TOOL_DESCRIPTION,
+  CODE_SEARCH_TOOL_NAME,
+  CodeSearchArgumentError,
+  CodeSearchRipgrepMissingError,
+  CodeSearchWorkspaceError,
+  DEFAULT_CODE_SEARCH_CONFIG,
+  JEV_CHARS_PER_TOKEN,
+  JEV_DEFAULT_BASE_URL,
+  JEV_DEFAULT_LIMITS,
+  JEV_DEFAULT_MODEL,
+  JEV_PRICE_PER_MILLION_INPUT_TOKENS_USD,
+  JevCircuitBreaker,
+  JevClient,
+  JevError,
+  JevLimiter,
+  JevRequestError,
+  JevUnavailableError,
+  codeSearchConfig,
+  codeSearchInputSchema,
+  estimateJevTokens,
+  jevCostUsd,
+  noul,
+  parseCodeSearchArguments,
+  planChunks,
+  renderCodeSearchError,
+  runCodeSearch
+};
+//# sourceMappingURL=index.js.map