march-cli 0.1.35 → 0.1.36

package/src/agent/code-search/retrieval/model2vec.mjs

@@ -0,0 +1,96 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { readSafetensors } from "./safetensors.mjs";
+import { normalizedVector } from "./vector.mjs";
+import { WordPieceTokenizer } from "./wordpiece.mjs";
+
+export const POTION_CODE_MODEL_ID = "minishlab/potion-code-16M";
+const HF_RESOLVE_BASE = "https://huggingface.co";
+const MODEL_FILES = ["config.json", "tokenizer.json", "model.safetensors"];
+
+export class Model2VecVectorizer {
+  constructor({ modelDir, modelId = POTION_CODE_MODEL_ID, allowDownload = true } = {}) {
+    if (!modelDir) throw new Error("Model2VecVectorizer requires modelDir");
+    this.modelDir = modelDir;
+    this.modelId = modelId;
+    this.allowDownload = allowDownload;
+    this.id = `model2vec:${modelId}`;
+    this.dimensions = 256;
+    this.modelPromise = null;
+  }
+
+  async encode(texts) {
+    const model = await this.load();
+    return texts.map((text) => model.encode(text));
+  }
+
+  async load() {
+    this.modelPromise ??= this.loadModel();
+    return this.modelPromise;
+  }
+
+  async loadModel() {
+    await ensureModelFiles({ modelDir: this.modelDir, modelId: this.modelId, allowDownload: this.allowDownload });
+    const config = JSON.parse(await readFile(join(this.modelDir, "config.json"), "utf8"));
+    const tokenizerJson = JSON.parse(await readFile(join(this.modelDir, "tokenizer.json"), "utf8"));
+    const tensors = await readSafetensors(join(this.modelDir, "model.safetensors"));
+    const embeddings = tensors.getTensor(tensors.names.includes("embeddings") ? "embeddings" : "embedding.weight");
+    const weights = tensors.names.includes("weights") ? tensors.getTensor("weights") : null;
+    const mapping = tensors.names.includes("mapping") ? tensors.getTensor("mapping") : null;
+    const model = new LoadedModel2Vec({ config, tokenizerJson, embeddings, weights, mapping });
+    this.dimensions = model.dimensions;
+    return model;
+  }
+}
+
+export async function ensureModelFiles({ modelDir, modelId = POTION_CODE_MODEL_ID, allowDownload = true }) {
+  const missing = MODEL_FILES.filter((name) => !existsSync(join(modelDir, name)));
+  if (missing.length === 0) return;
+  if (!allowDownload) throw new Error(`Missing Model2Vec files in ${modelDir}: ${missing.join(", ")}`);
+  await mkdir(modelDir, { recursive: true });
+  for (const name of missing) await downloadModelFile({ modelDir, modelId, name });
+}
+
+class LoadedModel2Vec {
+  constructor({ config, tokenizerJson, embeddings, weights, mapping }) {
+    this.normalize = config?.normalize !== false;
+    this.tokenizer = new WordPieceTokenizer(tokenizerJson);
+    this.embeddings = embeddings.values;
+    this.vocabularySize = embeddings.shape[0];
+    this.dimensions = embeddings.shape[1];
+    this.weights = weights?.values ?? null;
+    this.mapping = mapping?.values ?? null;
+  }
+
+  encode(text) {
+    const ids = this.tokenizer.encode(text);
+    const values = new Float32Array(this.dimensions);
+    let count = 0;
+    for (const id of ids) {
+      const mapped = this.mapping ? this.mapping[id] : id;
+      if (mapped == null || mapped < 0 || mapped >= this.vocabularySize) continue;
+      const weight = this.weights?.[id] ?? 1;
+      const offset = mapped * this.dimensions;
+      for (let dim = 0; dim < this.dimensions; dim += 1) values[dim] += this.embeddings[offset + dim] * weight;
+      count += 1;
+    }
+    if (count > 0) for (let dim = 0; dim < this.dimensions; dim += 1) values[dim] /= count;
+    const vector = normalizedVector(values);
+    if (this.normalize && vector.norm > 0) {
+      for (let dim = 0; dim < values.length; dim += 1) values[dim] /= vector.norm;
+      return normalizedVector(values);
+    }
+    return vector;
+  }
+}
+
+async function downloadModelFile({ modelDir, modelId, name }) {
+  const url = `${HF_RESOLVE_BASE}/${modelId}/resolve/main/${name}`;
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) throw new Error(`Failed to download ${modelId}/${name}: HTTP ${response.status}`);
+  const target = join(modelDir, name);
+  const tmpPath = join(dirname(target), `${basename(target)}.${process.pid}.tmp`);
+  await writeFile(tmpPath, new Uint8Array(await response.arrayBuffer()));
+  await rename(tmpPath, target);
+}

package/src/agent/code-search/retrieval/safetensors.mjs

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+
+const HEADER_BYTES = 8;
+const DTYPE_READERS = {
+  F32: { size: 4, read: (view, offset) => view.getFloat32(offset, true) },
+  F64: { size: 8, read: (view, offset) => view.getFloat64(offset, true) },
+  I32: { size: 4, read: (view, offset) => view.getInt32(offset, true) },
+  I64: { size: 8, read: (view, offset) => Number(view.getBigInt64(offset, true)) },
+  U32: { size: 4, read: (view, offset) => view.getUint32(offset, true) },
+  U64: { size: 8, read: (view, offset) => Number(view.getBigUint64(offset, true)) },
+};
+
+export async function readSafetensors(filePath) {
+  const buffer = await readFile(filePath);
+  return parseSafetensors(buffer);
+}
+
+export function parseSafetensors(buffer) {
+  const data = toArrayBuffer(buffer);
+  const headerLength = Number(new DataView(data, 0, HEADER_BYTES).getBigUint64(0, true));
+  const headerStart = HEADER_BYTES;
+  const headerEnd = headerStart + headerLength;
+  const headerJson = new TextDecoder().decode(new Uint8Array(data, headerStart, headerLength));
+  const header = JSON.parse(headerJson);
+  return {
+    names: Object.keys(header).filter((name) => name !== "__metadata__"),
+    getTensor(name) {
+      const descriptor = header[name];
+      if (!descriptor) throw new Error(`Missing safetensors tensor: ${name}`);
+      return readTensor(data, headerEnd, descriptor);
+    },
+  };
+}
+
+function readTensor(data, dataStart, descriptor) {
+  const reader = DTYPE_READERS[descriptor.dtype];
+  if (!reader) throw new Error(`Unsupported safetensors dtype: ${descriptor.dtype}`);
+  const [start, end] = descriptor.data_offsets;
+  const byteOffset = dataStart + start;
+  const length = (end - start) / reader.size;
+  const view = new DataView(data, byteOffset, end - start);
+  const values = new Float32Array(length);
+  for (let index = 0; index < length; index += 1) values[index] = reader.read(view, index * reader.size);
+  return { values, shape: descriptor.shape, dtype: descriptor.dtype };
+}
+
+function toArrayBuffer(buffer) {
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}

package/src/agent/code-search/retrieval/vector.mjs

@@ -0,0 +1,107 @@
+import { tokenize } from "../tokenize.mjs";
+
+const DEFAULT_DIMENSIONS = 256;
+const SEMANTIC_MIN_SCORE = 0.05;
+
+export class LocalVectorIndex {
+  constructor(chunks, vectors, { vectorizer = defaultVectorizer } = {}) {
+    this.chunks = chunks;
+    this.dimensions = vectorizer.dimensions;
+    this.vectorizer = vectorizer;
+    this.vectors = vectors;
+  }
+
+  static async create(chunks, { vectorizer = defaultVectorizer } = {}) {
+    const vectors = await vectorizer.encode(chunks.map(chunkVectorText));
+    return new LocalVectorIndex(chunks, vectors, { vectorizer });
+  }
+
+  async search(query, { limit = 50 } = {}) {
+    const [queryVector] = await this.vectorizer.encode([query]);
+    return this.searchVector(queryVector, { limit });
+  }
+
+  searchVector(queryVector, { limit = 50 } = {}) {
+    if (queryVector.norm === 0) return [];
+    const scored = [];
+    for (let index = 0; index < this.vectors.length; index += 1) {
+      const score = cosineSimilarity(queryVector, this.vectors[index]);
+      if (score >= SEMANTIC_MIN_SCORE) scored.push({ chunk: this.chunks[index], score });
+    }
+    scored.sort((a, b) => b.score - a.score || a.chunk.file_path.localeCompare(b.chunk.file_path));
+    return scored.slice(0, limit);
+  }
+}
+
+export class HashingVectorizer {
+  constructor({ dimensions = DEFAULT_DIMENSIONS } = {}) {
+    this.id = `hashing-${dimensions}`;
+    this.dimensions = dimensions;
+  }
+
+  async encode(texts) {
+    return texts.map((text) => vectorizeText(text, this.dimensions));
+  }
+}
+
+export const defaultVectorizer = new HashingVectorizer();
+
+function chunkVectorText(chunk) {
+  return [
+    chunk.file_path,
+    chunk.symbols.join(" "),
+    chunk.identifiers.join(" "),
+    chunk.content,
+  ].join("\n");
+}
+
+function vectorizeText(text, dimensions) {
+  const values = new Float32Array(dimensions);
+  const tokens = tokenize(text);
+  for (const token of tokens) {
+    addFeature(values, token, 1);
+    for (const gram of charTrigrams(token)) addFeature(values, gram, 0.35);
+  }
+  return normalizedVector(values);
+}
+
+export function normalizedVector(values) {
+  return { values, norm: vectorNorm(values) };
+}
+
+function addFeature(values, feature, weight) {
+  const hash = hashString(feature);
+  const index = hash % values.length;
+  const sign = hash & 1 ? 1 : -1;
+  values[index] += sign * weight;
+}
+
+function charTrigrams(token) {
+  const padded = `^${token}$`;
+  if (padded.length <= 3) return [padded];
+  const grams = [];
+  for (let index = 0; index <= padded.length - 3; index += 1) grams.push(padded.slice(index, index + 3));
+  return grams;
+}
+
+function cosineSimilarity(left, right) {
+  if (left.norm === 0 || right.norm === 0) return 0;
+  let dot = 0;
+  for (let index = 0; index < left.values.length; index += 1) dot += left.values[index] * right.values[index];
+  return dot / (left.norm * right.norm);
+}
+
+function vectorNorm(values) {
+  let sum = 0;
+  for (const value of values) sum += value * value;
+  return Math.sqrt(sum);
+}
+
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}

package/src/agent/code-search/retrieval/wordpiece.mjs

@@ -0,0 +1,82 @@
+const MAX_INPUT_CHARS_PER_WORD = 100;
+
+export class WordPieceTokenizer {
+  constructor(tokenizerJson) {
+    const model = tokenizerJson?.model ?? {};
+    this.vocab = model.vocab ?? {};
+    this.unkToken = model.unk_token ?? "[UNK]";
+    this.unkId = this.vocab[this.unkToken] ?? 1;
+    this.prefix = model.continuing_subword_prefix ?? "##";
+    this.lowercase = tokenizerJson?.normalizer?.lowercase !== false;
+    this.maxInputCharsPerWord = model.max_input_chars_per_word ?? MAX_INPUT_CHARS_PER_WORD;
+  }
+
+  encode(text, { maxLength = 512 } = {}) {
+    const ids = [];
+    for (const token of preTokenize(normalizeText(text, { lowercase: this.lowercase }))) {
+      for (const id of this.wordPiece(token)) {
+        if (id !== this.unkId) ids.push(id);
+        if (ids.length >= maxLength) return ids;
+      }
+    }
+    return ids;
+  }
+
+  wordPiece(token) {
+    if (!token) return [];
+    if (token.length > this.maxInputCharsPerWord) return [this.unkId];
+    const ids = [];
+    let start = 0;
+    while (start < token.length) {
+      let end = token.length;
+      let current = null;
+      while (start < end) {
+        const piece = start === 0 ? token.slice(start, end) : `${this.prefix}${token.slice(start, end)}`;
+        if (Object.hasOwn(this.vocab, piece)) {
+          current = piece;
+          break;
+        }
+        end -= 1;
+      }
+      if (current === null) return [this.unkId];
+      ids.push(this.vocab[current]);
+      start = end;
+    }
+    return ids;
+  }
+}
+
+function normalizeText(text, { lowercase }) {
+  let normalized = String(text ?? "").replace(/[\t\n\r]+/g, " ");
+  normalized = normalized.replace(/[\u0000-\u001f\u007f]/g, " ");
+  return lowercase ? normalized.toLowerCase() : normalized;
+}
+
+function preTokenize(text) {
+  const tokens = [];
+  let current = "";
+  for (const char of text) {
+    if (/\s/u.test(char)) {
+      pushCurrent();
+    } else if (isPunctuation(char)) {
+      pushCurrent();
+      tokens.push(char);
+    } else {
+      current += char;
+    }
+  }
+  pushCurrent();
+  return tokens;
+
+  function pushCurrent() {
+    if (current) tokens.push(current);
+    current = "";
+  }
+}
+
+function isPunctuation(char) {
+  const code = char.codePointAt(0);
+  if ((code >= 33 && code <= 47) || (code >= 58 && code <= 64)) return true;
+  if ((code >= 91 && code <= 96) || (code >= 123 && code <= 126)) return true;
+  return /\p{P}/u.test(char);
+}

package/src/agent/code-search/scanner.mjs

@@ -0,0 +1,84 @@
+import { execFile } from "node:child_process";
+import { lstat, readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { resolveRipgrepCommand } from "../../memory/markdown/ripgrep.mjs";
+import { isSearchableTextPath, languageForPath } from "./languages.mjs";
+
+const DEFAULT_MAX_FILES = 2_000;
+const DEFAULT_MAX_FILE_BYTES = 512 * 1024;
+const SKIP_DIRS = new Set([".git", "node_modules", "dist", "build", "coverage", ".next", ".turbo", ".cache"]);
+
+export async function scanCodeFiles({ root, path = ".", maxFiles = DEFAULT_MAX_FILES, maxFileBytes = DEFAULT_MAX_FILE_BYTES } = {}) {
+  const rootPath = resolve(root);
+  const base = resolve(rootPath, path);
+  const baseRel = relative(rootPath, base);
+  if (baseRel.startsWith("..") || isAbsolute(baseRel)) throw new Error(`Search path escapes workspace: ${path}`);
+  let baseInfo;
+  try { baseInfo = await stat(base); } catch { return []; }
+  const candidates = baseInfo.isFile()
+    ? [relative(rootPath, base).replace(/\\/g, "/")]
+    : await listCandidateFiles(rootPath, base);
+  const files = [];
+  for (const relPath of [...candidates].sort()) {
+    if (files.length >= maxFiles) break;
+    if (!isSearchableTextPath(relPath)) continue;
+    const absPath = resolve(root, relPath);
+    let info;
+    try { info = await stat(absPath); } catch { continue; }
+    if (!info.isFile() || info.size > maxFileBytes) continue;
+    const content = await readUtf8Text(absPath);
+    if (content === null) continue;
+    files.push({
+      absPath,
+      relPath: relPath.replace(/\\/g, "/"),
+      language: languageForPath(relPath),
+      content,
+      size: info.size,
+      mtimeMs: info.mtimeMs,
+    });
+  }
+  return files;
+}
+
+async function listCandidateFiles(root, base) {
+  const fromRipgrep = await listRipgrepFiles(root, base);
+  if (fromRipgrep) return fromRipgrep;
+  return listFilesRecursively(root, base);
+}
+
+function listRipgrepFiles(root, base) {
+  return new Promise((resolveResult) => {
+    const command = resolveRipgrepCommand();
+    const args = ["--files", "--hidden", "--glob", "!.git/**", "--glob", "!node_modules/**"];
+    execFile(command, args, { cwd: base, maxBuffer: 50 * 1024 * 1024 }, (error, stdout) => {
+      if (error) return resolveResult(null);
+      const baseRel = relative(root, base).replace(/\\/g, "/");
+      const prefix = baseRel ? `${baseRel}/` : "";
+      resolveResult(stdout.split(/\r?\n/).filter(Boolean).map((file) => `${prefix}${file.replace(/\\/g, "/")}`));
+    });
+  });
+}
+
+async function listFilesRecursively(root, dir) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return []; }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) continue;
+    const absPath = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...await listFilesRecursively(root, absPath));
+    else if (entry.isFile()) files.push(relative(root, absPath).replace(/\\/g, "/"));
+  }
+  return files;
+}
+
+async function readUtf8Text(path) {
+  try {
+    if ((await lstat(path)).isSymbolicLink()) return null;
+    const buffer = await readFile(path);
+    if (buffer.includes(0)) return null;
+    return buffer.toString("utf8");
+  } catch {
+    return null;
+  }
+}

package/src/agent/code-search/tokenize.mjs

@@ -0,0 +1,16 @@
+const STOP_WORDS = new Set([
+  "a", "an", "and", "are", "as", "at", "be", "by", "for", "from", "how", "in", "is", "it", "of", "on", "or", "that", "the", "this", "to", "with",
+]);
+
+export function tokenize(text) {
+  const raw = String(text ?? "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_\-./\\:]+/g, " ")
+    .toLowerCase()
+    .match(/[a-z0-9]+/g) ?? [];
+  return raw.filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+
+export function uniqueTokens(text) {
+  return [...new Set(tokenize(text))];
+}

package/src/agent/code-search/tool.mjs

@@ -0,0 +1,75 @@
+import { join } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../tool-result.mjs";
+import { CodeSearchIndexCache } from "./cache.mjs";
+import { searchCode } from "./engine.mjs";
+import { Model2VecVectorizer, POTION_CODE_MODEL_ID } from "./retrieval/model2vec.mjs";
+
+const persistentCaches = new Map();
+
+export function createCodeSearchTool({ engine, stateRoot = null }) {
+  const cache = stateRoot ? persistentCacheFor(stateRoot) : null;
+  return defineTool({
+    name: "code_search",
+    label: "Code Search",
+    description: "Native code-aware search over the workspace. Use it to locate relevant code snippets before reading full files; use grep for exact string confirmation.",
+    parameters: Type.Object({
+      query: Type.Optional(Type.String({ description: "Natural-language or symbol query" })),
+      path: Type.Optional(Type.String({ description: "Relative or absolute workspace path to search; default current workspace" })),
+      top_k: Type.Optional(Type.Number({ description: "Maximum results to return; default 5, max 20" })),
+      mode: Type.Optional(Type.Union([
+        Type.Literal("auto"),
+        Type.Literal("symbol"),
+        Type.Literal("lexical"),
+        Type.Literal("semantic"),
+      ], { description: "Search mode. auto uses BM25 + Model2Vec retrieval with RRF fusion." })),
+      include_tests: Type.Optional(Type.Boolean({ description: "Include test/spec paths without penalty; default false" })),
+      related_to: Type.Optional(Type.Object({
+        file_path: Type.String({ description: "Workspace-relative file path containing the known code" }),
+        line: Type.Number({ description: "Line inside the known code chunk" }),
+      }, { description: "Find code related to a known file location; query can optionally refine the relation" })),
+    }),
+    execute: async (_toolCallId, params) => executeCodeSearch({ engine, cache, ...params }),
+  });
+}
+
+export async function executeCodeSearch({ engine, cache, query, path = ".", top_k, mode = "auto", include_tests = false, related_to }) {
+  try {
+    const root = engine.cwd;
+    const searchPath = path === "." ? "." : engine.resolvePath(path);
+    const result = await searchCode({ root, query, path: searchPath, top_k, mode, include_tests, related_to, cache });
+    return toolText(formatSearchOutput(result), result);
+  } catch (err) {
+    return toolText(`Error running code_search: ${err.message}`, { error: true });
+  }
+}
+
+function persistentCacheFor(stateRoot) {
+  const storagePath = join(stateRoot, "code-search", "chunks.json");
+  const modelDir = join(stateRoot, "code-search", "models", POTION_CODE_MODEL_ID.replaceAll("/", "__"));
+  const cacheKey = `${storagePath}\n${modelDir}`;
+  let cache = persistentCaches.get(cacheKey);
+  if (!cache) {
+    cache = new CodeSearchIndexCache({
+      storagePath,
+      vectorizer: new Model2VecVectorizer({ modelDir }),
+    });
+    persistentCaches.set(cacheKey, cache);
+  }
+  return cache;
+}
+
+function formatSearchOutput({ results, stats }) {
+  const header = `--- code_search (${results.length} results, ${stats.files} files, ${stats.chunks} chunks, ${stats.mode}) ---`;
+  if (results.length === 0) return `${header}\nNo matching code snippets found.`;
+  const body = results.map((result, index) => [
+    `${index + 1}. ${result.file_path}:${result.start_line}-${result.end_line} score=${result.score} kind=${result.kind}${result.symbols.length ? ` symbols=${result.symbols.join(",")}` : ""}`,
+    fenceSnippet(result.snippet),
+  ].join("\n")).join("\n\n");
+  return `${header}\n${body}`;
+}
+
+function fenceSnippet(snippet) {
+  return "```\n" + snippet.trimEnd() + "\n```";
+}

package/src/agent/runner/provider-quota-runtime.mjs

@@ -0,0 +1,38 @@
+import { createProviderQuotaService } from "../../provider/quota/index.mjs";
+import { installProviderQuotaTransportObserver, subscribeProviderQuotaTransport } from "../../provider/quota/transport-observer.mjs";
+
+export function createRunnerProviderQuotaRuntime({ authStorage, getCurrentModel, ui } = {}) {
+  installProviderQuotaTransportObserver();
+  const providerQuota = createProviderQuotaService({ authStorage });
+  let lastSnapshot = null;
+  const unsubscribeTransport = subscribeProviderQuotaTransport((event) => {
+    const model = getCurrentModel?.();
+    if (!providerQuota.supports(model?.provider) || event.providerId !== model.provider) return;
+    const snapshot = event.source === "headers"
+      ? providerQuota.observeHeaders(event.headers, model)
+      : providerQuota.observeEvent(event.payload, model);
+    if (!snapshot) return;
+    lastSnapshot = snapshot;
+    ui?.providerQuotaSnapshot?.(lastSnapshot);
+  });
+
+  return {
+    getCachedProviderQuotaSnapshot() {
+      return lastSnapshot;
+    },
+    async getProviderQuotaSnapshot({ emit = false } = {}) {
+      const model = getCurrentModel?.();
+      if (!providerQuota.supports(model?.provider)) {
+        lastSnapshot = null;
+        if (emit) ui?.providerQuotaSnapshot?.(null);
+        return null;
+      }
+      lastSnapshot = await providerQuota.refresh(model);
+      if (emit) ui?.providerQuotaSnapshot?.(lastSnapshot);
+      return lastSnapshot;
+    },
+    disposeProviderQuotaRuntime() {
+      unsubscribeTransport();
+    },
+  };
+}

package/src/agent/runner.mjs

@@ -27,6 +27,7 @@ import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
 import { registerCustomProviders } from "../provider/custom-provider.mjs";
 import { injectHostedTools } from "../provider/hosted-tools.mjs";
 import { createRunnerLifecycle } from "./lifecycle/runner-lifecycle.mjs";
+import { createRunnerProviderQuotaRuntime } from "./runner/provider-quota-runtime.mjs";
 export { MARCH_BASE_TOOL_NAMES, installModelPayloadDumper };
 export { createDefaultSessionManager, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 export { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
@@ -107,6 +108,8 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   if (serviceTier === "priority" && selectedModel && isFastProvider(selectedModel.provider)) {
     _currentFastEntry = createFastModelEntry(selectedModel).model;
   }
+  const providerQuotaRuntime = createRunnerProviderQuotaRuntime({ authStorage: resolvedAuth, ui: runtimeUi,
+    getCurrentModel: () => _currentFastEntry ?? sessionBinding.get().model });
   return {
     engine,
     get session() { return sessionBinding.get(); },
@@ -176,6 +179,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       return result;
     },
     getCurrentModel() { return _currentFastEntry ?? sessionBinding.get().model; },
+    ...providerQuotaRuntime,
     async setModel(model) {
       const activeSession = sessionBinding.get();
       const { baseId, isFast } = fromFastEntryModel(model);
@@ -249,6 +253,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
         () => shellRuntime?.dispose?.() ?? shellRuntime?.killAll?.(),
         () => lspService.dispose(),
         () => mcpClientManager?.disconnectAll?.(),
+        () => providerQuotaRuntime.disposeProviderQuotaRuntime(),
         () => detachRuntimeUi(),
       ]);
     },

package/src/agent/runtime/remote-runner-client.mjs

@@ -26,6 +26,8 @@ export function createRemoteRunnerClient(peer, { initialState = null } = {}) {
     getScopedModels: () => state?.scopedModels ?? [],
     getConfiguredProviders: () => state?.configuredProviders ?? [],
     getSessionStats: () => state?.sessionStats ?? null,
+    getCachedProviderQuotaSnapshot: () => state?.providerQuota ?? null,
+    async getProviderQuotaSnapshot(options = {}) { return applyResultWithState(await peer.call("getProviderQuotaSnapshot", options)); },
     async refreshState() { return refreshState(); },
     getLastNotificationResult: () => peer.call("getLastNotificationResult"),
     notifyTest: (options) => peer.call("notifyTest", options),

package/src/agent/runtime/runner-ipc-target.mjs

@@ -37,6 +37,13 @@ export function createRunnerIpcTarget({ createRunnerImpl, runnerOptions = {} } =
     getSessionStats() {
       return getRunner().getSessionStats();
     },
+    async getProviderQuotaSnapshot(options = {}) {
+      const result = await getRunner().getProviderQuotaSnapshot(options);
+      return { result, state: getRunnerState(runner) };
+    },
+    getCachedProviderQuotaSnapshot() {
+      return getRunner().getCachedProviderQuotaSnapshot?.() ?? null;
+    },
     getState() {
       return getRunnerState(getRunner());
     },

package/src/agent/runtime/state/runner-state.mjs

@@ -22,6 +22,7 @@ export function createRunnerStateSnapshot(runner) {
     availableThinkingLevels: runner.getAvailableThinkingLevels?.() ?? [],
     canSwitchPiSession: runner.canSwitchPiSession?.() ?? false,
     sessionStats: runner.getSessionStats?.() ?? null,
+    providerQuota: runner.getCachedProviderQuotaSnapshot?.() ?? null,
     lspStatus: runner.getLspStatus?.() ?? null,
     extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
     extensionLifecycleState: runner.getExtensionLifecycleState?.() ?? null,

package/src/agent/runtime/ui-event-bridge.mjs

@@ -51,6 +51,7 @@ export function createRuntimeUiClient(eventBus) {
     status: (text) => eventBus.emit({ type: "status", text }),
     debugLines: (lines) => eventBus.emit({ type: "debug_lines", lines }),
     recall: ({ source, hints }) => eventBus.emit({ type: "recall", source, hints }),
+    providerQuotaSnapshot: (snapshot) => eventBus.emit({ type: "provider_quota_snapshot", snapshot }),
     editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
     requestPermission: (request) => eventBus.request({ type: "permission_request", ...request }),
   };
@@ -72,6 +73,7 @@ export function dispatchRuntimeUiEvent(ui, event) {
     case "status": return ui.status?.(event.text);
     case "debug_lines": return writeDebugLines(ui, event.lines);
     case "recall": return ui.recall?.({ source: event.source, hints: event.hints });
+    case "provider_quota_snapshot": return ui.providerQuotaSnapshot?.(event.snapshot);
     case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
     case "permission_request": return ui.requestPermission?.({ toolName: event.toolName, params: event.params, category: event.category });
     default: return undefined;

package/src/agent/tools.mjs

@@ -1,4 +1,5 @@
 import { createCommandExecTool } from "./command-exec-tool.mjs";
+import { createCodeSearchTool } from "./code-search/tool.mjs";
 import { createContextStatsTool } from "./context-stats-tool.mjs";
 import { createEditFileTool } from "./file-edit-tool.mjs";
 import { createReadFileTool } from "./file-tools/read-file-tool.mjs";
@@ -15,6 +16,7 @@ import { createRuntimeRestartTool } from "./lifecycle/runtime-restart-tool.mjs";
 
 export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], lifecycle = null, permissionController = null, authStorage = null, projectMarchDir = null, stateRoot = null, getCurrentModel = null }) {
   const commandExecTool = createCommandExecTool({ cwd });
+  const codeSearchTool = createCodeSearchTool({ engine, stateRoot });
   const contextStatsTool = createContextStatsTool({ engine });
   const editFileTool = createEditFileTool({ engine, ui, lspService });
   const readFileTool = createReadFileTool({ engine });
@@ -30,6 +32,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
     screenTool,
     listWindowsTool,
     contextStatsTool,
+    codeSearchTool,
     commandExecTool,
     editFileTool,
     ...createShellTools(shellRuntime),