@ushiradineth/veil 0.1.5 → 0.1.6

package/dist/bin.js

@@ -456,15 +456,15 @@ var init_parseUtil = __esm({
           message: issueData.message
         };
       }
-      let errorMessage = "";
+      let errorMessage2 = "";
       const maps = errorMaps.filter((m) => !!m).slice().reverse();
       for (const map of maps) {
-        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+        errorMessage2 = map(fullIssue, { data, defaultError: errorMessage2 }).message;
       }
       return {
         ...issueData,
         path: fullPath,
-        message: errorMessage
+        message: errorMessage2
       };
     };
     EMPTY_PATH = [];
@@ -6774,13 +6774,13 @@ var init_registries = __esm({
         this._idmap = /* @__PURE__ */ new Map();
       }
       add(schema, ..._meta) {
-        const meta = _meta[0];
-        this._map.set(schema, meta);
-        if (meta && typeof meta === "object" && "id" in meta) {
-          if (this._idmap.has(meta.id)) {
-            throw new Error(`ID ${meta.id} already exists in the registry`);
+        const meta2 = _meta[0];
+        this._map.set(schema, meta2);
+        if (meta2 && typeof meta2 === "object" && "id" in meta2) {
+          if (this._idmap.has(meta2.id)) {
+            throw new Error(`ID ${meta2.id} already exists in the registry`);
           }
-          this._idmap.set(meta.id, schema);
+          this._idmap.set(meta2.id, schema);
         }
         return this;
       }
@@ -6790,9 +6790,9 @@ var init_registries = __esm({
         return this;
       }
       remove(schema) {
-        const meta = this._map.get(schema);
-        if (meta && typeof meta === "object" && "id" in meta) {
-          this._idmap.delete(meta.id);
+        const meta2 = this._map.get(schema);
+        if (meta2 && typeof meta2 === "object" && "id" in meta2) {
+          this._idmap.delete(meta2.id);
         }
         this._map.delete(schema);
         return this;
@@ -7869,9 +7869,9 @@ var init_to_json_schema = __esm({
             }
           }
         }
-        const meta = this.metadataRegistry.get(schema);
-        if (meta)
-          Object.assign(result.schema, meta);
+        const meta2 = this.metadataRegistry.get(schema);
+        if (meta2)
+          Object.assign(result.schema, meta2);
         if (this.io === "input" && isTransforming(schema)) {
           delete result.schema.examples;
           delete result.schema.default;
@@ -8114,8 +8114,8 @@ var init_schemas2 = __esm({
       };
       inst.clone = (_def, params) => clone(inst, _def, params);
       inst.brand = () => inst;
-      inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
+      inst.register = ((reg, meta2) => {
+        reg.add(inst, meta2);
         return inst;
       });
     });
@@ -8651,8 +8651,8 @@ var init_schemas3 = __esm({
       };
       inst.clone = (def2, params) => clone(inst, def2, params);
       inst.brand = () => inst;
-      inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
+      inst.register = ((reg, meta2) => {
+        reg.add(inst, meta2);
         return inst;
       });
       inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
@@ -10696,19 +10696,19 @@ var init_Refs = __esm({
 });
 
 // node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
+function addErrorMessage(res, key, errorMessage2, refs) {
   if (!refs?.errorMessages)
     return;
-  if (errorMessage) {
+  if (errorMessage2) {
     res.errorMessage = {
       ...res.errorMessage,
-      [key]: errorMessage
+      [key]: errorMessage2
     };
   }
 }
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+function setResponseValueAndErrors(res, key, value, errorMessage2, refs) {
   res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
+  addErrorMessage(res, key, errorMessage2, refs);
 }
 var init_errorMessages = __esm({
   "node_modules/zod-to-json-schema/dist/esm/errorMessages.js"() {
@@ -12330,8 +12330,8 @@ var init_protocol = __esm({
                       if (queuedMessage.type === "response") {
                         resolver(message);
                       } else {
-                        const errorMessage = message;
-                        const error2 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                        const errorMessage2 = message;
+                        const error2 = new McpError(errorMessage2.error.code, errorMessage2.error.message, errorMessage2.error.data);
                         resolver(error2);
                       }
                     } else {
@@ -15410,8 +15410,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize2) {
-      if (normalize2 !== false)
+    function getFullPath(resolver, id = "", normalize3) {
+      if (normalize3 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -16751,7 +16751,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize2(uri, options) {
+    function normalize3(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         serialize(parse3(uri, options), options);
@@ -16767,49 +16767,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative3, options, skipNormalization) {
+    function resolveComponent(base, relative4, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative3 = parse3(serialize(relative3, options), options);
+        relative4 = parse3(serialize(relative4, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative3.scheme) {
-        target.scheme = relative3.scheme;
-        target.userinfo = relative3.userinfo;
-        target.host = relative3.host;
-        target.port = relative3.port;
-        target.path = removeDotSegments(relative3.path || "");
-        target.query = relative3.query;
+      if (!options.tolerant && relative4.scheme) {
+        target.scheme = relative4.scheme;
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
-          target.userinfo = relative3.userinfo;
-          target.host = relative3.host;
-          target.port = relative3.port;
-          target.path = removeDotSegments(relative3.path || "");
-          target.query = relative3.query;
+        if (relative4.userinfo !== void 0 || relative4.host !== void 0 || relative4.port !== void 0) {
+          target.userinfo = relative4.userinfo;
+          target.host = relative4.host;
+          target.port = relative4.port;
+          target.path = removeDotSegments(relative4.path || "");
+          target.query = relative4.query;
         } else {
-          if (!relative3.path) {
+          if (!relative4.path) {
             target.path = base.path;
-            if (relative3.query !== void 0) {
-              target.query = relative3.query;
+            if (relative4.query !== void 0) {
+              target.query = relative4.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative3.path[0] === "/") {
-              target.path = removeDotSegments(relative3.path);
+            if (relative4.path[0] === "/") {
+              target.path = removeDotSegments(relative4.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative3.path;
+                target.path = "/" + relative4.path;
               } else if (!base.path) {
-                target.path = relative3.path;
+                target.path = relative4.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative3.query;
+            target.query = relative4.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -16817,7 +16817,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative3.fragment;
+      target.fragment = relative4.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -16987,7 +16987,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize2,
+      normalize: normalize3,
       resolve: resolve2,
       resolveComponent,
       equal,
@@ -17152,19 +17152,19 @@ var require_core = __commonJS({
         this.addKeyword("$async");
       }
       _addDefaultMetaSchema() {
-        const { $data, meta, schemaId } = this.opts;
+        const { $data, meta: meta2, schemaId } = this.opts;
         let _dataRefSchema = $dataRefSchema;
         if (schemaId === "id") {
           _dataRefSchema = { ...$dataRefSchema };
           _dataRefSchema.id = _dataRefSchema.$id;
           delete _dataRefSchema.$id;
         }
-        if (meta && $data)
+        if (meta2 && $data)
           this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
       }
       defaultMeta() {
-        const { meta, schemaId } = this.opts;
-        return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0;
+        const { meta: meta2, schemaId } = this.opts;
+        return this.opts.defaultMeta = typeof meta2 == "object" ? meta2[schemaId] || meta2 : void 0;
       }
       validate(schemaKeyRef, data) {
         let v;
@@ -17184,12 +17184,12 @@ var require_core = __commonJS({
         const sch = this._addSchema(schema, _meta);
         return sch.validate || this._compileSchemaEnv(sch);
       }
-      compileAsync(schema, meta) {
+      compileAsync(schema, meta2) {
         if (typeof this.opts.loadSchema != "function") {
           throw new Error("options.loadSchema should be a function");
         }
         const { loadSchema } = this.opts;
-        return runCompileAsync.call(this, schema, meta);
+        return runCompileAsync.call(this, schema, meta2);
         async function runCompileAsync(_schema, _meta) {
           await loadMetaSchema.call(this, _schema.$schema);
           const sch = this._addSchema(_schema, _meta);
@@ -17221,7 +17221,7 @@ var require_core = __commonJS({
           if (!this.refs[ref])
             await loadMetaSchema.call(this, _schema.$schema);
           if (!this.refs[ref])
-            this.addSchema(_schema, ref, meta);
+            this.addSchema(_schema, ref, meta2);
         }
         async function _loadSchema(ref) {
           const p = this._loading[ref];
@@ -17326,8 +17326,8 @@ var require_core = __commonJS({
             return this;
           }
           case "object": {
-            const cacheKey = schemaKeyRef;
-            this._cache.delete(cacheKey);
+            const cacheKey2 = schemaKeyRef;
+            this._cache.delete(cacheKey2);
             let id = schemaKeyRef[this.opts.schemaId];
             if (id) {
               id = (0, resolve_1.normalizeId)(id);
@@ -17438,7 +17438,7 @@ var require_core = __commonJS({
           }
         }
       }
-      _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+      _addSchema(schema, meta2, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
         let id;
         const { schemaId } = this.opts;
         if (typeof schema == "object") {
@@ -17454,7 +17454,7 @@ var require_core = __commonJS({
           return sch;
         baseId = (0, resolve_1.normalizeId)(id || baseId);
         const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
-        sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
+        sch = new compile_1.SchemaEnv({ schema, schemaId, meta: meta2, baseId, localRefs });
         this._cache.set(sch.schema, sch);
         if (addSchema && !baseId.startsWith("#")) {
           if (baseId)
@@ -20401,23 +20401,23 @@ var init_server2 = __esm({
           const wrappedHandler = async (request, extra) => {
             const validatedRequest = safeParse2(CallToolRequestSchema, request);
             if (!validatedRequest.success) {
-              const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-              throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+              const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage2}`);
             }
             const { params } = validatedRequest.data;
             const result = await Promise.resolve(handler(request, extra));
             if (params.task) {
               const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
               if (!taskValidationResult.success) {
-                const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-                throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+                const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+                throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
               }
               return taskValidationResult.data;
             }
             const validationResult = safeParse2(CallToolResultSchema, result);
             if (!validationResult.success) {
-              const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-              throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+              const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage2}`);
             }
             return validationResult.data;
           };
@@ -20704,8 +20704,8 @@ function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
 }
 function getCompleter(schema) {
-  const meta = schema[COMPLETABLE_SYMBOL];
-  return meta?.complete;
+  const meta2 = schema[COMPLETABLE_SYMBOL];
+  return meta2?.complete;
 }
 var COMPLETABLE_SYMBOL, McpZodTypeKind;
 var init_completable = __esm({
@@ -21015,12 +21015,12 @@ var init_mcp = __esm({
        * @param errorMessage - The error message.
        * @returns The tool error result.
        */
-      createToolError(errorMessage) {
+      createToolError(errorMessage2) {
         return {
           content: [
             {
               type: "text",
-              text: errorMessage
+              text: errorMessage2
             }
           ],
           isError: true
@@ -21038,8 +21038,8 @@ var init_mcp = __esm({
         const parseResult = await safeParseAsync2(schemaToParse, args);
         if (!parseResult.success) {
           const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
-          const errorMessage = getParseErrorMessage(error2);
-          throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+          const errorMessage2 = getParseErrorMessage(error2);
+          throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage2}`);
         }
         return parseResult.data;
       }
@@ -21063,8 +21063,8 @@ var init_mcp = __esm({
         const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
         if (!parseResult.success) {
           const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
-          const errorMessage = getParseErrorMessage(error2);
-          throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+          const errorMessage2 = getParseErrorMessage(error2);
+          throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage2}`);
         }
       }
       /**
@@ -21276,8 +21276,8 @@ var init_mcp = __esm({
             const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
             if (!parseResult.success) {
               const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
-              const errorMessage = getParseErrorMessage(error2);
-              throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
+              const errorMessage2 = getParseErrorMessage(error2);
+              throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage2}`);
             }
             const args = parseResult.data;
             const cb = prompt.callback;
@@ -21716,13 +21716,126 @@ var init_stdio2 = __esm({
   }
 });
 
+// src/cache.ts
+function getLru(cache, key) {
+  const value = cache.get(key);
+  if (value === void 0) return void 0;
+  cache.delete(key);
+  cache.set(key, value);
+  return value;
+}
+function setLru(cache, key, value, maxSize) {
+  if (cache.has(key)) cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > maxSize) {
+    const first = cache.keys().next().value;
+    if (first === void 0) break;
+    cache.delete(first);
+  }
+}
+var TopKHeap;
+var init_cache = __esm({
+  "src/cache.ts"() {
+    "use strict";
+    TopKHeap = class {
+      heap = [];
+      k;
+      constructor(k) {
+        this.k = k;
+      }
+      parent(i) {
+        return Math.floor((i - 1) / 2);
+      }
+      left(i) {
+        return 2 * i + 1;
+      }
+      right(i) {
+        return 2 * i + 2;
+      }
+      swap(i, j) {
+        const temp = this.heap[i];
+        this.heap[i] = this.heap[j];
+        this.heap[j] = temp;
+      }
+      heapifyUp(i) {
+        while (i > 0) {
+          const p = this.parent(i);
+          if (this.heap[i].score >= this.heap[p].score) break;
+          this.swap(i, p);
+          i = p;
+        }
+      }
+      heapifyDown(i) {
+        while (true) {
+          let smallest = i;
+          const l = this.left(i);
+          const r = this.right(i);
+          if (l < this.heap.length && this.heap[l].score < this.heap[smallest].score) {
+            smallest = l;
+          }
+          if (r < this.heap.length && this.heap[r].score < this.heap[smallest].score) {
+            smallest = r;
+          }
+          if (smallest === i) break;
+          this.swap(i, smallest);
+          i = smallest;
+        }
+      }
+      insert(item, score) {
+        if (this.k <= 0) return;
+        if (this.heap.length < this.k) {
+          this.heap.push({ item, score });
+          this.heapifyUp(this.heap.length - 1);
+        } else if (score > this.heap[0].score) {
+          this.heap[0] = { item, score };
+          this.heapifyDown(0);
+        }
+      }
+      toSortedArray() {
+        const sorted = [...this.heap].sort((a, b) => b.score - a.score);
+        return sorted.map((entry) => entry.item);
+      }
+    };
+  }
+});
+
+// src/state-root.ts
+import { isAbsolute, join, normalize, relative } from "node:path";
+function resolveStateRoot(workspace, override) {
+  const raw = (override ?? process.env.VEIL_STATE_ROOT ?? DEFAULT_STATE_ROOT).trim();
+  if (!raw) return join(workspace, DEFAULT_STATE_ROOT);
+  if (isAbsolute(raw)) return normalize(raw);
+  return normalize(join(workspace, raw));
+}
+function resolveIndexDir(workspace, override) {
+  return join(resolveStateRoot(workspace, override), "index");
+}
+function relativeStateRoot(workspace, override) {
+  const stateRoot = resolveStateRoot(workspace, override);
+  const rel = relative(workspace, stateRoot);
+  if (!rel || rel === ".") return "";
+  if (rel.startsWith("..") || isAbsolute(rel)) return null;
+  return rel.replace(/\\/g, "/");
+}
+function diagnosticsStatePath(workspace, override) {
+  return join(resolveIndexDir(workspace, override), "diagnostics-state.json");
+}
+var DEFAULT_STATE_ROOT;
+var init_state_root = __esm({
+  "src/state-root.ts"() {
+    "use strict";
+    DEFAULT_STATE_ROOT = ".veil";
+  }
+});
+
 // src/diagnostics.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join as join2 } from "node:path";
 var PerformanceDiagnostics, diagnostics, Profiler, profiler;
 var init_diagnostics = __esm({
   "src/diagnostics.ts"() {
     "use strict";
+    init_state_root();
     PerformanceDiagnostics = class {
       queryCacheHits = 0;
       queryCacheMisses = 0;
@@ -21749,7 +21862,7 @@ var init_diagnostics = __esm({
       exitFn;
       constructor(options) {
         this.persistIntervalMs = options?.persistIntervalMs ?? Number(process.env.VEIL_DIAGNOSTICS_PERSIST_MS ?? "1000");
-        this.statePath = options?.statePath ?? (process.env.VEIL_DIAGNOSTICS_PATH ?? join(process.cwd(), ".agents", "index", "diagnostics-state.json"));
+        this.statePath = options?.statePath ?? (process.env.VEIL_DIAGNOSTICS_PATH ?? join2(resolveIndexDir(process.cwd()), "diagnostics-state.json"));
         this.registerHook = options?.registerHook ?? ((event, handler) => {
           process.on(event, handler);
         });
@@ -21757,6 +21870,12 @@ var init_diagnostics = __esm({
           process.exit(code);
         });
       }
+      configureStatePath(statePath) {
+        if (statePath.trim() && statePath !== this.statePath) {
+          this.statePath = statePath;
+          this.loaded = false;
+        }
+      }
       installExitHooks() {
         if (this.hooksInstalled) return;
         this.hooksInstalled = true;
@@ -22050,17 +22169,138 @@ var init_diagnostics = __esm({
   }
 });
 
+// src/indexer/build.ts
+function mergeIncrementalRecords(prevFiles, prevSymbols, prevChunks, changedSet, recomputed) {
+  const keptFiles = prevFiles.filter((f) => !changedSet.has(f.path));
+  const keptSymbols = prevSymbols.filter((s) => !changedSet.has(s.path));
+  const keptChunks = prevChunks.filter((c) => !changedSet.has(c.path));
+  return {
+    files: [...keptFiles, ...recomputed.files],
+    symbols: [...keptSymbols, ...recomputed.symbols],
+    chunks: [...keptChunks, ...recomputed.chunks]
+  };
+}
+function sortIndexedRecords(records) {
+  records.files.sort((a, b) => a.path.localeCompare(b.path));
+  records.symbols.sort((a, b) => a.path === b.path ? a.line - b.line : a.path.localeCompare(b.path));
+  records.chunks.sort((a, b) => a.id.localeCompare(b.id));
+}
+var init_build = __esm({
+  "src/indexer/build.ts"() {
+    "use strict";
+  }
+});
+
+// src/query.ts
+function normalizeText(input) {
+  return input.toLowerCase();
+}
+function toConfidence(score) {
+  if (score >= 8) return "high";
+  if (score >= 4) return "medium";
+  return "low";
+}
+function scoreFile(path, parsed) {
+  const pathLower = normalizeText(path);
+  let score = pathLower.includes(parsed.normalized) ? 8 : 2;
+  const reasons = [];
+  if (pathLower.includes(parsed.normalized)) {
+    reasons.push({ label: "exact-path-match", detail: "Path contains the full normalized query" });
+  }
+  for (const token of parsed.tokens) {
+    if (pathLower.includes(token)) {
+      score += 1.5;
+      reasons.push({ label: "token-path-match", detail: `Path contains token '${token}'` });
+    }
+  }
+  return { score, reasons };
+}
+function scoreSymbol(symbol, parsed) {
+  const nameLower = normalizeText(symbol.name);
+  const pathLower = normalizeText(symbol.path);
+  let score = nameLower.includes(parsed.normalized) ? 9 : 3;
+  const reasons = [];
+  if (nameLower.includes(parsed.normalized)) {
+    reasons.push({ label: "exact-symbol-match", detail: "Symbol name contains the full query" });
+  }
+  for (const token of parsed.tokens) {
+    if (nameLower.includes(token)) {
+      score += 2;
+      reasons.push({ label: "token-symbol-match", detail: `Symbol name contains token '${token}'` });
+    }
+    if (pathLower.includes(token)) {
+      score += 0.8;
+      reasons.push({ label: "token-path-context", detail: `Symbol path contains token '${token}'` });
+    }
+  }
+  return { score, reasons };
+}
+function scoreChunk(chunk, parsed) {
+  const hay = normalizeText(`${chunk.path}
+${chunk.content}`);
+  const pathLower = normalizeText(chunk.path);
+  let score = hay.includes(parsed.normalized) ? 7 : 2;
+  const reasons = [];
+  if (hay.includes(parsed.normalized)) {
+    reasons.push({ label: "exact-content-match", detail: "Chunk content contains the full query" });
+  }
+  for (const token of parsed.tokens) {
+    if (hay.includes(token)) {
+      score += 1.3;
+      reasons.push({ label: "token-content-match", detail: `Chunk content contains token '${token}'` });
+    }
+    if (pathLower.includes(token)) {
+      score += 1;
+      reasons.push({ label: "token-path-match", detail: `Chunk path contains token '${token}'` });
+    }
+  }
+  return { score, reasons };
+}
+function ensureLookupReasons(reasons, label, detail) {
+  if (reasons.length > 0) return reasons;
+  return [{ label, detail }];
+}
+function rankLookupResults(items, scorer, fallbackReason) {
+  return items.map((item) => {
+    const scored = scorer(item);
+    const reasons = ensureLookupReasons(scored.reasons, fallbackReason.label, fallbackReason.detail);
+    return { item, score: scored.score, confidence: toConfidence(scored.score), reasons };
+  }).sort((a, b) => b.score - a.score);
+}
+var init_query = __esm({
+  "src/query.ts"() {
+    "use strict";
+  }
+});
+
 // src/indexer.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { join as join2, relative } from "node:path";
+import { join as join3, relative as relative2 } from "node:path";
 import { spawnSync } from "node:child_process";
-function getIndexDir(workspace) {
-  return join2(workspace, ".agents", "index");
+function cacheKey(workspace, stateRoot) {
+  return `${workspace}::${resolveIndexDir(workspace, stateRoot)}`;
+}
+function setIndexCache(key, entry) {
+  INDEX_CACHE.set(key, entry);
+  if (INDEX_CACHE.size > MAX_INDEX_CACHE_SIZE) {
+    const first = INDEX_CACHE.keys().next().value;
+    if (first) INDEX_CACHE.delete(first);
+  }
+}
+function setStatusCache(key, value) {
+  STATUS_CACHE.set(key, { value, ts: Date.now() });
+  if (STATUS_CACHE.size > MAX_STATUS_CACHE_SIZE) {
+    const first = STATUS_CACHE.keys().next().value;
+    if (first) STATUS_CACHE.delete(first);
+  }
+}
+function getIndexDir(workspace, stateRoot) {
+  return resolveIndexDir(workspace, stateRoot);
 }
-function getIndexPath(workspace, file) {
-  return join2(getIndexDir(workspace), file);
+function getIndexPath(workspace, file, stateRoot) {
+  return join3(getIndexDir(workspace, stateRoot), file);
 }
 function hashText(content) {
   return createHash("sha1").update(content).digest("hex");
@@ -22123,18 +22363,19 @@ function hasDirtyWorkspace(workspace) {
   if (raw === null) return false;
   return raw.length > 0;
 }
-async function listFilesFallback(workspace) {
+async function listFilesFallback(workspace, stateRoot) {
   const out = [];
+  const stateRootRel = relativeStateRoot(workspace, stateRoot);
   async function walk(abs) {
     const items = await readdir(abs, { withFileTypes: true });
     for (const item of items) {
       if (item.name === ".git" || item.name === "node_modules") continue;
-      if (item.name === ".agents") continue;
-      const nextAbs = join2(abs, item.name);
+      if (stateRootRel && item.name === stateRootRel.split("/")[0]) continue;
+      const nextAbs = join3(abs, item.name);
       if (item.isDirectory()) {
         await walk(nextAbs);
       } else if (item.isFile()) {
-        out.push(relative(workspace, nextAbs));
+        out.push(relative2(workspace, nextAbs));
       }
     }
   }
@@ -22168,16 +22409,16 @@ async function mtimeMs(path) {
     return null;
   }
 }
-function normalizeText(input) {
+function normalizeText2(input) {
   return input.toLowerCase();
 }
 function tokenize(input) {
-  const normalized = normalizeText(input);
+  const normalized = normalizeText2(input);
   const tokens = normalized.split(/[^a-z0-9_./-]+/).map((token) => token.trim()).filter((token) => token.length >= 3 && token.length <= 64).filter((token) => !STOP_TOKENS.has(token));
   return [...new Set(tokens)];
 }
 function normalizeQuery(input) {
-  return normalizeText(input).replace(/\s+/g, " ").trim();
+  return normalizeText2(input).replace(/\s+/g, " ").trim();
 }
 function resolveIntent(normalized, tokens, requested = "auto") {
   if (requested !== "auto") return requested;
@@ -22187,8 +22428,8 @@ function resolveIntent(normalized, tokens, requested = "auto") {
   if (tokens.some((token) => SYMBOL_HINT_TOKENS.has(token))) return "symbols";
   return "code";
 }
-function cacheParsedQuery(cacheKey, parsed) {
-  QUERY_PARSE_CACHE.set(cacheKey, parsed);
+function cacheParsedQuery(cacheKey2, parsed) {
+  QUERY_PARSE_CACHE.set(cacheKey2, parsed);
   if (QUERY_PARSE_CACHE.size > MAX_QUERY_PARSE_CACHE) {
     const first = QUERY_PARSE_CACHE.keys().next().value;
     if (first) QUERY_PARSE_CACHE.delete(first);
@@ -22196,8 +22437,8 @@ function cacheParsedQuery(cacheKey, parsed) {
   return parsed;
 }
 function parseQuery(input, intent = "auto") {
-  const cacheKey = `${intent}\0${input}`;
-  const cached2 = QUERY_PARSE_CACHE.get(cacheKey);
+  const cacheKey2 = `${intent}\0${input}`;
+  const cached2 = QUERY_PARSE_CACHE.get(cacheKey2);
   if (cached2) return cached2;
   const normalized = normalizeQuery(input);
   let tokens = tokenize(normalized);
@@ -22211,7 +22452,7 @@ function parseQuery(input, intent = "auto") {
     pathTokens,
     intent: resolveIntent(normalized, tokens, intent)
   };
-  return cacheParsedQuery(cacheKey, parsed);
+  return cacheParsedQuery(cacheKey2, parsed);
 }
 function codePathBias(pathLower) {
   let score = 0;
@@ -22286,7 +22527,7 @@ function buildCacheEntry(files, symbols, chunks, mtimes) {
   const normalizePath = (path) => {
     let cached2 = pathNormCache.get(path);
     if (cached2 === void 0) {
-      cached2 = normalizeText(path);
+      cached2 = normalizeText2(path);
       pathNormCache.set(path, cached2);
     }
     return cached2;
@@ -22311,13 +22552,13 @@ function buildCacheEntry(files, symbols, chunks, mtimes) {
     return cached2;
   };
   const chunksPathLower = chunks.map((c) => normalizePath(c.path));
-  const chunksTopLevelLower = chunks.map((c) => normalizeText(getTopLevel(c.path)));
-  const chunksBasenameLower = chunks.map((c) => normalizeText(getBasename(c.path)));
-  const chunksSearch = chunks.map((c) => normalizeText(`${c.path}
+  const chunksTopLevelLower = chunks.map((c) => normalizeText2(getTopLevel(c.path)));
+  const chunksBasenameLower = chunks.map((c) => normalizeText2(getBasename(c.path)));
+  const chunksSearch = chunks.map((c) => normalizeText2(`${c.path}
 ${c.content}`));
   const chunksCodeBias = chunksPathLower.map((pathLower) => codePathBias(pathLower));
   const chunksDocsBias = chunksPathLower.map((pathLower, i) => docsPathBias(pathLower, chunksBasenameLower[i] ?? ""));
-  const symbolsLower = symbols.map((s) => normalizeText(s.name));
+  const symbolsLower = symbols.map((s) => normalizeText2(s.name));
   return {
     filesMtimeMs: mtimes.files,
     symbolsMtimeMs: mtimes.symbols,
@@ -22401,8 +22642,8 @@ function makeChunks(path, content) {
   }
   return chunks;
 }
-async function readExistingIndex(workspace, name) {
-  const p = getIndexPath(workspace, name);
+async function readExistingIndex(workspace, name, stateRoot) {
+  const p = getIndexPath(workspace, name, stateRoot);
   if (!existsSync2(p)) return [];
   try {
     const raw = await readFile(p, "utf-8");
@@ -22411,24 +22652,25 @@ async function readExistingIndex(workspace, name) {
     return [];
   }
 }
-async function loadCachedIndex(workspace) {
-  const filesPath = getIndexPath(workspace, "files.ndjson");
-  const symbolsPath = getIndexPath(workspace, "symbols.ndjson");
-  const chunksPath = getIndexPath(workspace, "chunks.ndjson");
+async function loadCachedIndex(workspace, stateRoot) {
+  const filesPath = getIndexPath(workspace, "files.ndjson", stateRoot);
+  const symbolsPath = getIndexPath(workspace, "symbols.ndjson", stateRoot);
+  const chunksPath = getIndexPath(workspace, "chunks.ndjson", stateRoot);
   const [filesMtime, symbolsMtime, chunksMtime] = await Promise.all([
     mtimeMs(filesPath),
     mtimeMs(symbolsPath),
     mtimeMs(chunksPath)
   ]);
-  const cached2 = INDEX_CACHE.get(workspace);
+  const key = cacheKey(workspace, stateRoot);
+  const cached2 = INDEX_CACHE.get(key);
   if (cached2 && cached2.filesMtimeMs === filesMtime && cached2.symbolsMtimeMs === symbolsMtime && cached2.chunksMtimeMs === chunksMtime) {
     diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
     return cached2;
   }
   const [files, symbols, chunks] = await Promise.all([
-    readExistingIndex(workspace, "files.ndjson"),
-    readExistingIndex(workspace, "symbols.ndjson"),
-    readExistingIndex(workspace, "chunks.ndjson")
+    readExistingIndex(workspace, "files.ndjson", stateRoot),
+    readExistingIndex(workspace, "symbols.ndjson", stateRoot),
+    readExistingIndex(workspace, "chunks.ndjson", stateRoot)
   ]);
   const entry = buildCacheEntry(files, symbols, chunks, {
     files: filesMtime,
@@ -22436,11 +22678,11 @@ async function loadCachedIndex(workspace) {
     chunks: chunksMtime
   });
   if (cached2) diagnostics.recordCacheInvalidation();
-  INDEX_CACHE.set(workspace, entry);
+  setIndexCache(key, entry);
   diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
   return entry;
 }
-async function writeHumanDocs(workspace, files) {
+async function writeHumanDocs(workspace, files, stateRoot) {
   const byTop = /* @__PURE__ */ new Map();
   for (const file of files) {
     byTop.set(file.top_level, (byTop.get(file.top_level) ?? 0) + 1);
@@ -22450,7 +22692,7 @@ async function writeHumanDocs(workspace, files) {
     dirsLines.push(`- ${dir}: ${count}`);
   }
   dirsLines.push("");
-  await writeFile(getIndexPath(workspace, "dirs.md"), dirsLines.join("\n"), "utf-8");
+  await writeFile(getIndexPath(workspace, "dirs.md", stateRoot), dirsLines.join("\n"), "utf-8");
   const entryCandidates = /* @__PURE__ */ new Set([
     "README.md",
     "AGENTS.md",
@@ -22464,15 +22706,16 @@ async function writeHumanDocs(workspace, files) {
   const entryLines = ["# Entrypoints", "", "High-signal files for navigation:", ""];
   for (const path of entries) entryLines.push(`- ${path}`);
   entryLines.push("");
-  await writeFile(getIndexPath(workspace, "entrypoints.md"), entryLines.join("\n"), "utf-8");
+  await writeFile(getIndexPath(workspace, "entrypoints.md", stateRoot), entryLines.join("\n"), "utf-8");
 }
-async function getStatus(workspace) {
-  const cached2 = STATUS_CACHE.get(workspace);
+async function getStatus(workspace, options = {}) {
+  const key = cacheKey(workspace, options.state_root);
+  const cached2 = STATUS_CACHE.get(key);
   if (cached2 && Date.now() - cached2.ts < STATUS_CACHE_TTL_MS) {
     diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
     return cached2.value;
   }
-  const manifestPath = getIndexPath(workspace, "manifest.json");
+  const manifestPath = getIndexPath(workspace, "manifest.json", options.state_root);
   const currentHead = runGit(workspace, ["rev-parse", "HEAD"]);
   if (!existsSync2(manifestPath)) {
     const status2 = {
@@ -22484,7 +22727,7 @@ async function getStatus(workspace) {
     };
     if (hasDirtyWorkspace(workspace)) status2.reasons.push("workspace-dirty");
     status2.stale = status2.reasons.length > 0;
-    STATUS_CACHE.set(workspace, { value: status2, ts: Date.now() });
+    setStatusCache(key, status2);
     diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
     return status2;
   }
@@ -22501,7 +22744,7 @@ async function getStatus(workspace) {
       current_git_head: currentHead
     };
     if (hasDirtyWorkspace(workspace)) malformedStatus.reasons.push("workspace-dirty");
-    STATUS_CACHE.set(workspace, { value: malformedStatus, ts: Date.now() });
+    setStatusCache(key, malformedStatus);
     diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
     return malformedStatus;
   }
@@ -22520,7 +22763,7 @@ async function getStatus(workspace) {
     manifest,
     current_git_head: currentHead
   };
-  STATUS_CACHE.set(workspace, { value: status, ts: Date.now() });
+  setStatusCache(key, status);
   diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
   return status;
 }
@@ -22528,10 +22771,11 @@ function shouldRefreshDiscover(status) {
   if (!status.stale) return false;
   return status.reasons.some((reason) => reason !== "workspace-dirty");
 }
-async function processFile(workspace, rel) {
-  if (rel.startsWith(".agents/index/")) return { file: null, symbols: [], chunks: [] };
+async function processFile(workspace, rel, stateRoot) {
+  const stateRootRel = relativeStateRoot(workspace, stateRoot);
+  if (stateRootRel && (rel === stateRootRel || rel.startsWith(`${stateRootRel}/`))) return { file: null, symbols: [], chunks: [] };
   if (rel.startsWith(".git/")) return { file: null, symbols: [], chunks: [] };
-  const abs = join2(workspace, rel);
+  const abs = join3(workspace, rel);
   let st;
   try {
     st = await stat(abs);
@@ -22561,13 +22805,13 @@ async function processFile(workspace, rel) {
     chunks: makeChunks(rel, content)
   };
 }
-async function computeForPaths(workspace, paths) {
+async function computeForPaths(workspace, paths, stateRoot) {
   const files = [];
   const symbols = [];
   const chunks = [];
   for (let i = 0; i < paths.length; i += BATCH_SIZE) {
     const batch = paths.slice(i, i + BATCH_SIZE);
-    const results = await Promise.all(batch.map((rel) => processFile(workspace, rel)));
+    const results = await Promise.all(batch.map((rel) => processFile(workspace, rel, stateRoot)));
     for (const result of results) {
       if (result.file) {
         files.push(result.file);
@@ -22578,24 +22822,24 @@ async function computeForPaths(workspace, paths) {
   }
   return { files, symbols, chunks };
 }
-async function buildIndex(workspace, mode = "full") {
+async function buildIndex(workspace, mode = "full", options = {}) {
   const buildStart = nowMs();
-  const indexDir = getIndexDir(workspace);
+  const indexDir = getIndexDir(workspace, options.state_root);
   await mkdir(indexDir, { recursive: true });
-  const tracked = listTrackedFiles(workspace) ?? await listFilesFallback(workspace);
+  const tracked = listTrackedFiles(workspace) ?? await listFilesFallback(workspace, options.state_root);
   const gitHead = runGit(workspace, ["rev-parse", "HEAD"]);
   let files = [];
   let symbols = [];
   let chunks = [];
   if (mode === "full") {
-    const computed = await computeForPaths(workspace, tracked);
+    const computed = await computeForPaths(workspace, tracked, options.state_root);
     files = computed.files;
     symbols = computed.symbols;
     chunks = computed.chunks;
   } else {
-    const prevStatus = await getStatus(workspace);
+    const prevStatus = await getStatus(workspace, options);
     if (!prevStatus.exists || !prevStatus.manifest?.git_head) {
-      const computed = await computeForPaths(workspace, tracked);
+      const computed = await computeForPaths(workspace, tracked, options.state_root);
       files = computed.files;
       symbols = computed.symbols;
       chunks = computed.chunks;
@@ -22605,33 +22849,29 @@ async function buildIndex(workspace, mode = "full") {
       for (const prevFile of await readExistingIndex(workspace, "files.ndjson")) {
         if (!trackedSet.has(prevFile.path)) changedSet.add(prevFile.path);
       }
-      const prevFiles = await readExistingIndex(workspace, "files.ndjson");
-      const prevSymbols = await readExistingIndex(workspace, "symbols.ndjson");
-      const prevChunks = await readExistingIndex(workspace, "chunks.ndjson");
-      const keptFiles = prevFiles.filter((f) => !changedSet.has(f.path));
-      const keptSymbols = prevSymbols.filter((s) => !changedSet.has(s.path));
-      const keptChunks = prevChunks.filter((c) => !changedSet.has(c.path));
+      const prevFiles = await readExistingIndex(workspace, "files.ndjson", options.state_root);
+      const prevSymbols = await readExistingIndex(workspace, "symbols.ndjson", options.state_root);
+      const prevChunks = await readExistingIndex(workspace, "chunks.ndjson", options.state_root);
       const changedPaths = [...changedSet];
-      const recomputed = await computeForPaths(workspace, changedPaths);
-      files = [...keptFiles, ...recomputed.files];
-      symbols = [...keptSymbols, ...recomputed.symbols];
-      chunks = [...keptChunks, ...recomputed.chunks];
-    }
-  }
-  files.sort((a, b) => a.path.localeCompare(b.path));
-  symbols.sort((a, b) => a.path === b.path ? a.line - b.line : a.path.localeCompare(b.path));
-  chunks.sort((a, b) => a.id.localeCompare(b.id));
-  await writeFile(getIndexPath(workspace, "files.ndjson"), toNdjson(files), "utf-8");
-  await writeFile(getIndexPath(workspace, "symbols.ndjson"), toNdjson(symbols), "utf-8");
-  await writeFile(getIndexPath(workspace, "chunks.ndjson"), toNdjson(chunks), "utf-8");
-  await writeHumanDocs(workspace, files);
+      const recomputed = await computeForPaths(workspace, changedPaths, options.state_root);
+      const merged = mergeIncrementalRecords(prevFiles, prevSymbols, prevChunks, changedSet, recomputed);
+      files = merged.files;
+      symbols = merged.symbols;
+      chunks = merged.chunks;
+    }
+  }
+  sortIndexedRecords({ files, symbols, chunks });
+  await writeFile(getIndexPath(workspace, "files.ndjson", options.state_root), toNdjson(files), "utf-8");
+  await writeFile(getIndexPath(workspace, "symbols.ndjson", options.state_root), toNdjson(symbols), "utf-8");
+  await writeFile(getIndexPath(workspace, "chunks.ndjson", options.state_root), toNdjson(chunks), "utf-8");
+  await writeHumanDocs(workspace, files, options.state_root);
   const [filesMtime, symbolsMtime, chunksMtime] = await Promise.all([
-    mtimeMs(getIndexPath(workspace, "files.ndjson")),
-    mtimeMs(getIndexPath(workspace, "symbols.ndjson")),
-    mtimeMs(getIndexPath(workspace, "chunks.ndjson"))
+    mtimeMs(getIndexPath(workspace, "files.ndjson", options.state_root)),
+    mtimeMs(getIndexPath(workspace, "symbols.ndjson", options.state_root)),
+    mtimeMs(getIndexPath(workspace, "chunks.ndjson", options.state_root))
   ]);
-  INDEX_CACHE.set(
-    workspace,
+  setIndexCache(
+    cacheKey(workspace, options.state_root),
     buildCacheEntry(files, symbols, chunks, {
       files: filesMtime,
       symbols: symbolsMtime,
@@ -22648,9 +22888,9 @@ async function buildIndex(workspace, mode = "full") {
     symbol_count: symbols.length,
     chunk_count: chunks.length
   };
-  await writeFile(getIndexPath(workspace, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  await writeFile(getIndexPath(workspace, "manifest.json", options.state_root), `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
-  STATUS_CACHE.delete(workspace);
+  STATUS_CACHE.delete(cacheKey(workspace, options.state_root));
   diagnostics.recordIndexBuild();
   diagnostics.recordBuildLatency(nowMs() - buildStart);
   diagnostics.recordCacheInvalidation();
@@ -22659,7 +22899,7 @@ async function buildIndex(workspace, mode = "full") {
 }
 function queryFilesFromCache(cache, parsed, limit) {
   const key = `${parsed.intent}\0${parsed.normalized}\0${limit}`;
-  const cached2 = cache.queryFilesCache.get(key);
+  const cached2 = getLru(cache.queryFilesCache, key);
   if (cached2) {
     diagnostics.recordCacheHit();
     return cached2;
@@ -22673,18 +22913,18 @@ function queryFilesFromCache(cache, parsed, limit) {
     for (const token of parsed.tokens) {
       if (pathLower.includes(token)) score += token.includes("/") ? 3 : 1.5;
     }
-    const topDir = normalizeText(topLevel(pathLower));
+    const topDir = normalizeText2(topLevel(pathLower));
     if (parsed.intent === "code" && CODE_TOP_LEVEL_HINTS.has(topDir)) score += 0.6;
     if (parsed.intent === "docs" && (pathLower.endsWith(".md") || pathLower.includes("/docs/"))) score += 1.5;
     if (score > 0.5) heap.insert(i, score);
   }
   const result = heap.toSortedArray().map((index) => cache.files[index]);
-  cache.queryFilesCache.set(key, result);
+  setLru(cache.queryFilesCache, key, result, MAX_QUERY_CACHE_SIZE);
   return result;
 }
 function querySymbolsFromCache(cache, parsed, limit) {
   const key = `${parsed.intent}\0${parsed.normalized}\0${limit}`;
-  const cached2 = cache.querySymbolsCache.get(key);
+  const cached2 = getLru(cache.querySymbolsCache, key);
   if (cached2) {
     diagnostics.recordCacheHit();
     return cached2;
@@ -22703,7 +22943,7 @@ function querySymbolsFromCache(cache, parsed, limit) {
     const symbol = cache.symbols[i];
     if (!symbol) continue;
     const nameLower = cache.symbolsLower[i] ?? "";
-    const pathLower = normalizeText(symbol.path);
+    const pathLower = normalizeText2(symbol.path);
     let score = nameLower.includes(parsed.normalized) ? 7 : 0;
     for (const token of parsed.tokens) {
       if (nameLower.includes(token)) score += 2;
@@ -22714,7 +22954,7 @@ function querySymbolsFromCache(cache, parsed, limit) {
     if (score >= 1.5) heap.insert(i, score);
   }
   const result = heap.toSortedArray().map((index) => cache.symbols[index]);
-  cache.querySymbolsCache.set(key, result);
+  setLru(cache.querySymbolsCache, key, result, MAX_QUERY_CACHE_SIZE);
   return result;
 }
 function queryChunksFromCache(cache, parsed, limit, options) {
@@ -22726,15 +22966,15 @@ function queryChunksFromCache(cache, parsed, limit, options) {
     options.path_prefix ?? "",
     options.language ?? ""
   ].join("\0");
-  const cached2 = cache.queryChunksCache.get(key);
+  const cached2 = getLru(cache.queryChunksCache, key);
   if (cached2) {
     diagnostics.recordCacheHit();
     return cached2;
   }
   diagnostics.recordCacheMiss();
   if (!parsed.normalized) return [];
-  const languageFilter = options.language ? normalizeText(options.language) : "";
-  const pathPrefix = options.path_prefix ? normalizeText(options.path_prefix) : "";
+  const languageFilter = options.language ? normalizeText2(options.language) : "";
+  const pathPrefix = options.path_prefix ? normalizeText2(options.path_prefix) : "";
   const shouldPreferCode = options.prefer_code ?? parsed.intent !== "docs";
   const tokenScoreByIndex = /* @__PURE__ */ new Map();
   for (const token of parsed.tokens) {
@@ -22774,21 +23014,21 @@ function queryChunksFromCache(cache, parsed, limit, options) {
     if (score >= 2) heap.insert(i, score);
   }
   const result = heap.toSortedArray().map((index) => cache.chunks[index]);
-  cache.queryChunksCache.set(key, result);
+  setLru(cache.queryChunksCache, key, result, MAX_QUERY_CACHE_SIZE);
   return result;
 }
-async function queryFiles(workspace, q, limit = 20) {
+async function queryFiles(workspace, q, limit = 20, options = {}) {
   const start = nowMs();
-  const cache = await loadCachedIndex(workspace);
+  const cache = await loadCachedIndex(workspace, options.state_root);
   const parsed = parseQuery(q);
   const out = queryFilesFromCache(cache, parsed, limit);
   diagnostics.recordQuery(nowMs() - start);
   diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
   return out;
 }
-async function querySymbols(workspace, q, limit = 20) {
+async function querySymbols(workspace, q, limit = 20, options = {}) {
   const start = nowMs();
-  const cache = await loadCachedIndex(workspace);
+  const cache = await loadCachedIndex(workspace, options.state_root);
   const parsed = parseQuery(q);
   const out = querySymbolsFromCache(cache, parsed, limit);
   diagnostics.recordQuery(nowMs() - start);
@@ -22797,7 +23037,7 @@ async function querySymbols(workspace, q, limit = 20) {
 }
 async function queryChunks(workspace, q, limit = 10, options = {}) {
   const start = nowMs();
-  const cache = await loadCachedIndex(workspace);
+  const cache = await loadCachedIndex(workspace, options.state_root);
   const parsed = parseQuery(q, options.intent);
   const out = queryChunksFromCache(cache, parsed, limit, options);
   diagnostics.recordQuery(nowMs() - start);
@@ -22806,7 +23046,7 @@ async function queryChunks(workspace, q, limit = 10, options = {}) {
 }
 async function discoverIndex(workspace, query, options = {}) {
   const start = nowMs();
-  const cache = await loadCachedIndex(workspace);
+  const cache = await loadCachedIndex(workspace, options.state_root);
   const parsed = parseQuery(query, options.intent);
   const filesLimit = options.files_limit ?? 20;
   const symbolsLimit = options.symbols_limit ?? (parsed.intent === "symbols" ? 40 : 20);
@@ -22824,81 +23064,9 @@ async function discoverIndex(workspace, query, options = {}) {
   diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
   return { intent: parsed.intent, files, symbols, chunks };
 }
-function toConfidence(score) {
-  if (score >= 8) return "high";
-  if (score >= 4) return "medium";
-  return "low";
-}
-function scoreFile(path, parsed) {
-  const pathLower = normalizeText(path);
-  let score = pathLower.includes(parsed.normalized) ? 8 : 2;
-  const reasons = [];
-  if (pathLower.includes(parsed.normalized)) {
-    reasons.push({ label: "exact-path-match", detail: "Path contains the full normalized query" });
-  }
-  for (const token of parsed.tokens) {
-    if (pathLower.includes(token)) {
-      score += 1.5;
-      reasons.push({ label: "token-path-match", detail: `Path contains token '${token}'` });
-    }
-  }
-  return { score, reasons };
-}
-function scoreSymbol(symbol, parsed) {
-  const nameLower = normalizeText(symbol.name);
-  const pathLower = normalizeText(symbol.path);
-  let score = nameLower.includes(parsed.normalized) ? 9 : 3;
-  const reasons = [];
-  if (nameLower.includes(parsed.normalized)) {
-    reasons.push({ label: "exact-symbol-match", detail: "Symbol name contains the full query" });
-  }
-  for (const token of parsed.tokens) {
-    if (nameLower.includes(token)) {
-      score += 2;
-      reasons.push({ label: "token-symbol-match", detail: `Symbol name contains token '${token}'` });
-    }
-    if (pathLower.includes(token)) {
-      score += 0.8;
-      reasons.push({ label: "token-path-context", detail: `Symbol path contains token '${token}'` });
-    }
-  }
-  return { score, reasons };
-}
-function scoreChunk(chunk, parsed) {
-  const hay = normalizeText(`${chunk.path}
-${chunk.content}`);
-  const pathLower = normalizeText(chunk.path);
-  let score = hay.includes(parsed.normalized) ? 7 : 2;
-  const reasons = [];
-  if (hay.includes(parsed.normalized)) {
-    reasons.push({ label: "exact-content-match", detail: "Chunk content contains the full query" });
-  }
-  for (const token of parsed.tokens) {
-    if (hay.includes(token)) {
-      score += 1.3;
-      reasons.push({ label: "token-content-match", detail: `Chunk content contains token '${token}'` });
-    }
-    if (pathLower.includes(token)) {
-      score += 1;
-      reasons.push({ label: "token-path-match", detail: `Chunk path contains token '${token}'` });
-    }
-  }
-  return { score, reasons };
-}
-function ensureLookupReasons(reasons, label, detail) {
-  if (reasons.length > 0) return reasons;
-  return [{ label, detail }];
-}
-function rankLookupResults(items, scorer, fallbackReason) {
-  return items.map((item) => {
-    const scored = scorer(item);
-    const reasons = ensureLookupReasons(scored.reasons, fallbackReason.label, fallbackReason.detail);
-    return { item, score: scored.score, confidence: toConfidence(scored.score), reasons };
-  }).sort((a, b) => b.score - a.score);
-}
 async function lookupIndex(workspace, query, options = {}) {
   const start = nowMs();
-  const cache = await loadCachedIndex(workspace);
+  const cache = await loadCachedIndex(workspace, options.state_root);
   const parsed = parseQuery(query, options.intent);
   const filesLimit = options.files_limit ?? 8;
   const symbolsLimit = options.symbols_limit ?? (parsed.intent === "symbols" ? 20 : 12);
@@ -22973,78 +23141,27 @@ async function lookupIndex(workspace, query, options = {}) {
   diagnostics.updateCacheSizes(INDEX_CACHE.size, STATUS_CACHE.size);
   return response;
 }
-var SCHEMA_VERSION, DEFAULT_STALE_HOURS, MAX_FILE_SIZE, CHUNK_SIZE_LINES, CHUNK_OVERLAP_LINES, BATCH_SIZE, TopKHeap, INDEX_CACHE, STATUS_CACHE, STATUS_CACHE_TTL_MS, STOP_TOKENS, DOC_HINT_TOKENS, SYMBOL_HINT_TOKENS, CODE_TOP_LEVEL_HINTS, MAX_QUERY_PARSE_CACHE, QUERY_PARSE_CACHE;
+var SCHEMA_VERSION, DEFAULT_STALE_HOURS, MAX_FILE_SIZE, CHUNK_SIZE_LINES, CHUNK_OVERLAP_LINES, BATCH_SIZE, INDEX_CACHE, STATUS_CACHE, STATUS_CACHE_TTL_MS, MAX_INDEX_CACHE_SIZE, MAX_STATUS_CACHE_SIZE, MAX_QUERY_CACHE_SIZE, STOP_TOKENS, DOC_HINT_TOKENS, SYMBOL_HINT_TOKENS, CODE_TOP_LEVEL_HINTS, MAX_QUERY_PARSE_CACHE, QUERY_PARSE_CACHE;
 var init_indexer = __esm({
   "src/indexer.ts"() {
     "use strict";
+    init_cache();
     init_diagnostics();
+    init_build();
+    init_query();
+    init_state_root();
     SCHEMA_VERSION = "1";
     DEFAULT_STALE_HOURS = 24;
     MAX_FILE_SIZE = 512 * 1024;
     CHUNK_SIZE_LINES = 120;
     CHUNK_OVERLAP_LINES = 20;
     BATCH_SIZE = 20;
-    TopKHeap = class {
-      heap = [];
-      k;
-      constructor(k) {
-        this.k = k;
-      }
-      parent(i) {
-        return Math.floor((i - 1) / 2);
-      }
-      left(i) {
-        return 2 * i + 1;
-      }
-      right(i) {
-        return 2 * i + 2;
-      }
-      swap(i, j) {
-        const temp = this.heap[i];
-        this.heap[i] = this.heap[j];
-        this.heap[j] = temp;
-      }
-      heapifyUp(i) {
-        while (i > 0) {
-          const p = this.parent(i);
-          if (this.heap[i].score >= this.heap[p].score) break;
-          this.swap(i, p);
-          i = p;
-        }
-      }
-      heapifyDown(i) {
-        while (true) {
-          let smallest = i;
-          const l = this.left(i);
-          const r = this.right(i);
-          if (l < this.heap.length && this.heap[l].score < this.heap[smallest].score) {
-            smallest = l;
-          }
-          if (r < this.heap.length && this.heap[r].score < this.heap[smallest].score) {
-            smallest = r;
-          }
-          if (smallest === i) break;
-          this.swap(i, smallest);
-          i = smallest;
-        }
-      }
-      insert(item, score) {
-        if (this.heap.length < this.k) {
-          this.heap.push({ item, score });
-          this.heapifyUp(this.heap.length - 1);
-        } else if (score > this.heap[0].score) {
-          this.heap[0] = { item, score };
-          this.heapifyDown(0);
-        }
-      }
-      toSortedArray() {
-        const sorted = [...this.heap].sort((a, b) => b.score - a.score);
-        return sorted.map((entry) => entry.item);
-      }
-    };
     INDEX_CACHE = /* @__PURE__ */ new Map();
     STATUS_CACHE = /* @__PURE__ */ new Map();
     STATUS_CACHE_TTL_MS = 1500;
+    MAX_INDEX_CACHE_SIZE = 32;
+    MAX_STATUS_CACHE_SIZE = 64;
+    MAX_QUERY_CACHE_SIZE = 100;
     STOP_TOKENS = /* @__PURE__ */ new Set([
       "the",
       "and",
@@ -25735,10 +25852,10 @@ var require_helpers = __commonJS({
         return !arr.includes(node, i + 1);
       });
       nodes.sort(function(a, b) {
-        var relative3 = compareDocumentPosition(a, b);
-        if (relative3 & DocumentPosition.PRECEDING) {
+        var relative4 = compareDocumentPosition(a, b);
+        if (relative4 & DocumentPosition.PRECEDING) {
           return -1;
-        } else if (relative3 & DocumentPosition.FOLLOWING) {
+        } else if (relative4 & DocumentPosition.FOLLOWING) {
           return 1;
         }
         return 0;
@@ -30100,6 +30217,34 @@ var require_dist3 = __commonJS({
   }
 });
 
+// src/errors.ts
+function errorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function isAbortLike(aborted2, message) {
+  const lower = message.toLowerCase();
+  return aborted2 || message.includes("AbortError") || lower.includes("aborted") || lower.includes("timeout");
+}
+var init_errors4 = __esm({
+  "src/errors.ts"() {
+    "use strict";
+  }
+});
+
+// src/validation.ts
+function clampInt(value, min, max, fallback) {
+  const candidate = Number.isFinite(value) ? Math.trunc(value) : fallback;
+  return Math.min(max, Math.max(min, candidate));
+}
+function trimQuery(value) {
+  return (value ?? "").trim();
+}
+var init_validation = __esm({
+  "src/validation.ts"() {
+    "use strict";
+  }
+});
+
 // src/fetch-url.ts
 function nowMs2(bunLike = typeof Bun === "undefined" ? void 0 : Bun) {
   if (bunLike && typeof bunLike.nanoseconds === "function") {
@@ -30183,8 +30328,8 @@ async function fetchUrl(options) {
   const started = nowMs2();
   const parsed = parseUrl(options.url.trim());
   const format = options.format ?? "markdown";
-  const timeoutMs = Math.min(2e4, Math.max(300, options.timeout_ms ?? 8e3));
-  const maxBytes = Math.min(2e6, Math.max(100, options.max_bytes ?? 2e5));
+  const timeoutMs = clampInt(options.timeout_ms, 100, 2e4, 8e3);
+  const maxBytes = clampInt(options.max_bytes, 100, 2e6, 2e5);
   if (!parsed) {
     return {
       meta: { ok: false, duration_ms: Number((nowMs2() - started).toFixed(4)), truncated: false },
@@ -30262,8 +30407,8 @@ async function fetchUrl(options) {
       error: null
     };
   } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    const timeoutLike = abort.signal.aborted || message.includes("AbortError") || message.toLowerCase().includes("timeout");
+    const message = errorMessage(error2);
+    const timeoutLike = isAbortLike(abort.signal.aborted, message);
     return {
       meta: { ok: false, duration_ms: Number((nowMs2() - started).toFixed(4)), truncated: false },
       data: null,
@@ -30281,6 +30426,8 @@ var init_fetch_url = __esm({
   "src/fetch-url.ts"() {
     "use strict";
     import_node_html_markdown = __toESM(require_dist3(), 1);
+    init_errors4();
+    init_validation();
     NHM = new import_node_html_markdown.NodeHtmlMarkdown({
       maxConsecutiveNewlines: 3
     });
@@ -30289,8 +30436,8 @@ var init_fetch_url = __esm({
 
 // src/git.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { realpathSync } from "node:fs";
-import { isAbsolute, normalize, relative as relative2, resolve } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, realpathSync } from "node:fs";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join4, normalize as normalize2, relative as relative3, resolve } from "node:path";
 function nowMs3(bunRef) {
   if (process.env.VEIL_FORCE_DATE_NOW === "1") {
     return Date.now();
@@ -30302,21 +30449,42 @@ function nowMs3(bunRef) {
   return Date.now();
 }
 function runCommand(command, args, cwd, timeoutMs) {
-  const out = spawnSync2(command, args, {
-    cwd,
-    encoding: "utf-8",
-    stdio: "pipe",
-    timeout: timeoutMs
-  });
-  return {
-    ok: out.status === 0 && !out.error,
-    stdout: out.stdout ?? "",
-    stderr: out.stderr ?? "",
-    code: out.status,
-    timedOut: out.signal === "SIGTERM" && out.status === null,
-    error: out.error?.message,
-    errorCode: out.error?.code
-  };
+  const started = nowMs3();
+  try {
+    const out = spawnSync2(command, args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: timeoutMs
+    });
+    const elapsed = nowMs3() - started;
+    const timedOut = out.signal === "SIGTERM" && out.status === null || elapsed > timeoutMs;
+    return {
+      ok: out.status === 0 && !out.error && !timedOut,
+      stdout: out.stdout ?? "",
+      stderr: out.stderr ?? "",
+      code: out.status,
+      timedOut,
+      error: out.error?.message,
+      errorCode: out.error?.code
+    };
+  } catch (error2) {
+    const value = error2;
+    return {
+      ok: false,
+      stdout: "",
+      stderr: "",
+      code: null,
+      timedOut: false,
+      error: value.message ?? String(error2),
+      errorCode: value.code
+    };
+  }
+}
+function isMissingBinary(result) {
+  if (result.errorCode === "ENOENT") return true;
+  if (!result.error) return false;
+  return result.error.includes("ENOENT") || result.error.includes("Executable not found in $PATH") || result.error.includes("No such file or directory");
 }
 function responseMeta(workspace, tool, started, truncated, warnings) {
   return {
@@ -30359,21 +30527,69 @@ function truncateText(raw, maxBytes) {
 }
 function validatePathArg(workspace, path) {
   if (!path) return { ok: true };
-  if (path.startsWith("-") || isAbsolute(path)) {
+  if (path.indexOf("\0") >= 0) {
+    return { ok: false, error: { code: "invalid-path", message: "Path contains null bytes" } };
+  }
+  if (path.startsWith("-")) {
+    return { ok: false, error: { code: "invalid-path", message: "Path cannot start with hyphen" } };
+  }
+  if (isAbsolute2(path)) {
     return { ok: false, error: { code: "invalid-path", message: "Path must be a relative path inside workspace" } };
   }
-  const normalized = normalize(path);
+  const normalized = normalize2(path);
   const abs = resolve(workspace, normalized);
-  const rel = relative2(workspace, abs);
-  if (rel.startsWith("..") || isAbsolute(rel)) {
+  const rel = relative3(workspace, abs);
+  if (rel.startsWith("..") || isAbsolute2(rel)) {
     return { ok: false, error: { code: "invalid-path", message: "Path escapes workspace" } };
   }
+  try {
+    const workspaceReal = realpathSync(workspace);
+    let absReal = abs;
+    try {
+      absReal = realpathSync(abs);
+    } catch {
+      const parentDir = dirname2(abs);
+      try {
+        const parentReal = realpathSync(parentDir);
+        absReal = resolve(parentReal, basename(abs));
+      } catch {
+        absReal = abs;
+      }
+    }
+    const relReal = relative3(workspaceReal, absReal);
+    if (relReal.startsWith("..") || isAbsolute2(relReal)) {
+      return { ok: false, error: { code: "invalid-path", message: "Path escapes workspace via symlink" } };
+    }
+  } catch (error2) {
+    const workspaceResolved = resolve(workspace);
+    const absResolved = resolve(workspace, normalized);
+    const relResolved = relative3(workspaceResolved, absResolved);
+    if (relResolved.startsWith("..") || isAbsolute2(relResolved)) {
+      return { ok: false, error: { code: "invalid-path", message: "Path escapes workspace" } };
+    }
+  }
   return { ok: true, value: normalized };
 }
 function validateRevision(rev) {
   if (!rev) return { ok: true };
-  if (rev.length > 200 || rev.startsWith("-") || /\s/.test(rev)) {
-    return { ok: false, error: { code: "invalid-revision", message: "Revision contains unsafe characters" } };
+  if (rev.length > 200) {
+    return { ok: false, error: { code: "invalid-revision", message: "Revision string too long (max 200 characters)" } };
+  }
+  if (rev.startsWith("-")) {
+    return { ok: false, error: { code: "invalid-revision", message: "Revision cannot start with hyphen" } };
+  }
+  const hasControlChar = Array.from(rev).some((ch) => {
+    const code = ch.charCodeAt(0);
+    return code === 0 || code >= 1 && code <= 31;
+  });
+  if (hasControlChar) {
+    return { ok: false, error: { code: "invalid-revision", message: "Revision contains null bytes or control characters" } };
+  }
+  if (/\s/.test(rev)) {
+    return { ok: false, error: { code: "invalid-revision", message: "Revision contains whitespace" } };
+  }
+  if (/[;|&$`(){}[\]<>!\\'"]/.test(rev)) {
+    return { ok: false, error: { code: "invalid-revision", message: "Revision contains shell metacharacters" } };
   }
   const safeRefPattern = /^[A-Za-z0-9._/\-~^]+(\.{2,3}[A-Za-z0-9._/\-~^]+)?$/;
   if (!safeRefPattern.test(rev)) {
@@ -30383,7 +30599,7 @@ function validateRevision(rev) {
 }
 function ensureGitRepo(workspace, options) {
   const probe = runCommand(options.command ?? "git", ["-C", workspace, "rev-parse", "--is-inside-work-tree"], workspace, options.timeoutMs);
-  if (probe.errorCode === "ENOENT" || probe.error && probe.error.includes("ENOENT")) {
+  if (isMissingBinary(probe)) {
     return { ok: false, error: { code: "git-unavailable", message: "git is not available in PATH" }, gitAvailable: false };
   }
   if (!probe.ok) {
@@ -30402,8 +30618,8 @@ function ensureGitRepo(workspace, options) {
     workspaceReal = resolve(workspace);
     topReal = resolve(topReal);
   }
-  const fromTop = relative2(topReal, workspaceReal);
-  if (fromTop.startsWith("..") || isAbsolute(fromTop)) {
+  const fromTop = relative3(topReal, workspaceReal);
+  if (fromTop.startsWith("..") || isAbsolute2(fromTop)) {
     return { ok: false, error: { code: "not-a-repo", message: "Workspace is outside git repository root" }, gitAvailable: true };
   }
   return { ok: true };
@@ -30640,23 +30856,124 @@ function ghLookup(workspace, options) {
   const timeoutMs = Math.min(2e4, Math.max(500, options.timeout_ms ?? 12e3));
   const command = options.command ?? "gh";
   const probe = runCommand(command, ["--version"], workspace, timeoutMs);
-  if (probe.errorCode === "ENOENT" || probe.error && probe.error.includes("ENOENT")) {
+  if (isMissingBinary(probe)) {
     recordDiagnostics("gh_lookup", started, false, false);
-    return fail(workspace, "gh_lookup", started, { code: "gh-unavailable", message: "gh is not available in PATH" }, true);
+    return Promise.resolve(fail(workspace, "gh_lookup", started, { code: "gh-unavailable", message: "gh is not available in PATH" }, true));
   }
   if (!probe.ok) {
     recordDiagnostics("gh_lookup", started, false, probe.timedOut);
-    return fail(workspace, "gh_lookup", started, {
+    return Promise.resolve(fail(workspace, "gh_lookup", started, {
       code: probe.timedOut ? "timeout" : "gh-unavailable",
       message: "gh command is unavailable"
-    });
+    }));
   }
   const auth = runCommand(command, ["auth", "status"], workspace, timeoutMs);
   if (!auth.ok) {
     recordDiagnostics("gh_lookup", started, false, auth.timedOut);
-    return fail(workspace, "gh_lookup", started, {
+    return Promise.resolve(fail(workspace, "gh_lookup", started, {
       code: auth.timedOut ? "timeout" : "gh-unauthenticated",
       message: "gh is unauthenticated or cannot access GitHub"
+    }));
+  }
+  const parseRepoRef = (repoRef2) => {
+    const trimmed = repoRef2.trim();
+    if (!trimmed) return null;
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+      try {
+        const url = new URL(trimmed);
+        const parts2 = url.pathname.replace(/^\/+/, "").replace(/\.git$/, "").split("/").filter(Boolean);
+        if (parts2.length < 2) return null;
+        const owner2 = parts2[0] ?? "";
+        const name2 = parts2[1] ?? "";
+        if (!owner2 || !name2) return null;
+        return { repo: `${owner2}/${name2}`, owner: owner2, name: name2, url: `https://github.com/${owner2}/${name2}.git` };
+      } catch {
+        return null;
+      }
+    }
+    const normalizedRepo = trimmed.replace(/\.git$/, "");
+    const parts = normalizedRepo.split("/").filter(Boolean);
+    if (parts.length !== 2) return null;
+    const owner = parts[0] ?? "";
+    const name = parts[1] ?? "";
+    if (!owner || !name) return null;
+    return { repo: `${owner}/${name}`, owner, name, url: `https://github.com/${owner}/${name}.git` };
+  };
+  const repoRef = parseRepoRef(options.repo);
+  if (!repoRef) {
+    recordDiagnostics("gh_lookup", started, false, false);
+    return Promise.resolve(
+      fail(workspace, "gh_lookup", started, {
+        code: "command-failed",
+        message: "repo must be 'owner/repo' or a GitHub URL"
+      })
+    );
+  }
+  if (options.kind === "repo_context") {
+    const gitProbe = runCommand("git", ["--version"], workspace, timeoutMs);
+    if (isMissingBinary(gitProbe)) {
+      recordDiagnostics("gh_lookup", started, false, false);
+      return Promise.resolve(fail(workspace, "gh_lookup", started, { code: "git-unavailable", message: "git is not available in PATH" }, false));
+    }
+    if (!gitProbe.ok) {
+      recordDiagnostics("gh_lookup", started, false, gitProbe.timedOut);
+      return Promise.resolve(
+        fail(workspace, "gh_lookup", started, {
+          code: gitProbe.timedOut ? "timeout" : "command-failed",
+          message: "git command is unavailable"
+        }, false)
+      );
+    }
+    const tempRoot = options.temp_root && options.temp_root.trim() ? options.temp_root.trim() : "/tmp";
+    const target = join4(tempRoot, basename(repoRef.name));
+    mkdirSync2(tempRoot, { recursive: true });
+    const gitDir = join4(target, ".git");
+    let syncOut;
+    if (!existsSync3(gitDir)) {
+      syncOut = runCommand("git", ["clone", "--depth", "1", repoRef.url, target], workspace, timeoutMs);
+    } else {
+      const remote = runCommand("git", ["-C", target, "remote", "set-url", "origin", repoRef.url], workspace, timeoutMs);
+      const fetch2 = runCommand("git", ["-C", target, "fetch", "--depth", "1", "origin"], workspace, timeoutMs);
+      const headRef = runCommand("git", ["-C", target, "symbolic-ref", "refs/remotes/origin/HEAD"], workspace, timeoutMs);
+      const branchRef = headRef.ok ? headRef.stdout.trim().replace(/^refs\/remotes\//, "") : "origin/main";
+      const reset = runCommand("git", ["-C", target, "reset", "--hard", branchRef], workspace, timeoutMs);
+      syncOut = !remote.ok || !fetch2.ok || !reset.ok ? { ok: false, stdout: `${remote.stdout}
+${fetch2.stdout}
+${reset.stdout}`, stderr: `${remote.stderr}
+${fetch2.stderr}
+${reset.stderr}`, code: 1, timedOut: remote.timedOut || fetch2.timedOut || reset.timedOut } : reset;
+    }
+    if (!syncOut.ok) {
+      recordDiagnostics("gh_lookup", started, false, syncOut.timedOut);
+      return Promise.resolve(
+        fail(workspace, "gh_lookup", started, {
+          code: syncOut.timedOut ? "timeout" : "command-failed",
+          message: `failed to sync repo ${repoRef.repo}: ${(syncOut.stderr || syncOut.error || "unknown").trim()}`
+        })
+      );
+    }
+    return buildIndex(target, "changed", { state_root: options.state_root }).then(async (manifest) => {
+      const status = await getStatus(target, { state_root: options.state_root });
+      const stateRootResolved = resolveStateRoot(target, options.state_root);
+      const data2 = {
+        repo: repoRef.repo,
+        kind: "repo_context",
+        query: options.query ?? "",
+        limit: 0,
+        text: `repo indexed at ${target}`,
+        repo_url: repoRef.url,
+        cloned_workspace: target,
+        state_root: stateRootResolved,
+        status_exists: status.exists
+      };
+      recordDiagnostics("gh_lookup", started, true, false);
+      return finish(workspace, "gh_lookup", started, data2, { truncated: false });
+    }).catch((error2) => {
+      recordDiagnostics("gh_lookup", started, false, false);
+      return fail(workspace, "gh_lookup", started, {
+        code: "command-failed",
+        message: `failed to index cloned repo: ${String(error2)}`
+      });
     });
   }
   const limit = Math.min(50, Math.max(1, options.limit ?? 10));
@@ -30665,41 +30982,44 @@ function ghLookup(workspace, options) {
   let args;
   if (options.kind === "issues") {
     subcommand = "issue";
-    args = ["search", query || "is:open", "--repo", options.repo, "--limit", String(limit)];
+    args = ["search", query || "is:open", "--repo", repoRef.repo, "--limit", String(limit)];
   } else if (options.kind === "prs") {
     subcommand = "pr";
-    args = ["list", "--repo", options.repo, "--limit", String(limit)];
+    args = ["list", "--repo", repoRef.repo, "--limit", String(limit)];
     if (query) {
       args.push("--search", query);
     }
   } else {
     subcommand = "run";
-    args = ["list", "--repo", options.repo, "--limit", String(limit)];
+    args = ["list", "--repo", repoRef.repo, "--limit", String(limit)];
   }
   const out = runCommand(command, [subcommand, ...args], workspace, timeoutMs);
   if (!out.ok) {
     recordDiagnostics("gh_lookup", started, false, out.timedOut);
-    return fail(workspace, "gh_lookup", started, {
+    return Promise.resolve(fail(workspace, "gh_lookup", started, {
       code: out.timedOut ? "timeout" : "command-failed",
       message: `gh lookup failed: ${(out.stderr || out.error || "unknown").trim()}`
-    });
+    }));
   }
   const truncation = truncateText(out.stdout, DEFAULT_MAX_BYTES);
   const data = {
-    repo: options.repo,
+    repo: repoRef.repo,
     kind: options.kind,
     query,
     limit,
-    text: truncation.text
+    text: truncation.text,
+    repo_url: repoRef.url
   };
   recordDiagnostics("gh_lookup", started, true, false);
-  return finish(workspace, "gh_lookup", started, data, truncation);
+  return Promise.resolve(finish(workspace, "gh_lookup", started, data, truncation));
 }
 var DEFAULT_MAX_BYTES, MAX_BYTES_CAP;
 var init_git = __esm({
   "src/git.ts"() {
     "use strict";
     init_diagnostics();
+    init_indexer();
+    init_state_root();
     DEFAULT_MAX_BYTES = 64e3;
     MAX_BYTES_CAP = 5e5;
   }
@@ -31386,8 +31706,8 @@ async function runProvider(def, fetchImpl, query, limit, signal) {
       warning: results.length > 0 ? null : "no-parseable-results"
     };
   } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    const timeoutLike = signal.aborted || message === "timeout" || message.includes("AbortError") || message.toLowerCase().includes("aborted");
+    const message = errorMessage(error2);
+    const timeoutLike = isAbortLike(signal.aborted || message === "timeout", message);
     return {
       provider: def.provider,
       ok: false,
@@ -31477,9 +31797,9 @@ function traceForPending(provider, durationMs, warning) {
 }
 async function webSearch(workspace, options) {
   const started = nowMs4();
-  const query = options.query.trim();
-  const limit = Math.min(25, Math.max(1, options.limit ?? 8));
-  const timeoutMs = Math.min(15e3, Math.max(300, options.timeout_ms ?? 5e3));
+  const query = trimQuery(options.query);
+  const limit = clampInt(options.limit, 1, 25, 8);
+  const timeoutMs = clampInt(options.timeout_ms, 100, 2e4, 5e3);
   const debug = options.debug ?? false;
   if (!query) {
     return {
@@ -31604,6 +31924,8 @@ var PROVIDER_ORDER, PROVIDER_BASE_SCORE, TRACKING_PARAMS, PROVIDERS;
 var init_web_search = __esm({
   "src/web-search.ts"() {
     "use strict";
+    init_errors4();
+    init_validation();
     PROVIDER_ORDER = ["google", "duckduckgo", "wikipedia", "github", "reddit", "deepwiki"];
     PROVIDER_BASE_SCORE = {
       google: 10,
@@ -31801,34 +32123,39 @@ var init_server3 = __esm({
     init_fetch_url();
     init_git();
     init_format();
+    init_state_root();
     init_web_search();
     server = new McpServer({
       name: "veil",
-      version: "0.1.0"
+      version: "0.1.6"
     });
     server.tool(
       "status",
       "Return current index status and staleness reasons",
       {
-        workspace: external_exports.string().optional()
+        workspace: external_exports.string().optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace }) => {
+      async ({ workspace, state_root }) => {
         const ws = workspace ?? process.cwd();
-        const status = await getStatus(ws);
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
+        const status = await getStatus(ws, { state_root });
         return asText(status);
       }
     );
     server.tool(
       "refresh",
-      "Build or refresh the index in .agents/index",
+      "Build or refresh the index in .veil/index",
       {
         workspace: external_exports.string().optional(),
-        mode: external_exports.enum(["full", "changed"]).optional()
+        mode: external_exports.enum(["full", "changed"]).optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace, mode }) => {
+      async ({ workspace, mode, state_root }) => {
         const ws = workspace ?? process.cwd();
         const selectedMode = mode ?? "changed";
-        const manifest = await buildIndex(ws, selectedMode);
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
+        const manifest = await buildIndex(ws, selectedMode, { state_root });
         return asText({ ok: true, mode: selectedMode, manifest });
       }
     );
@@ -31838,11 +32165,13 @@ var init_server3 = __esm({
       {
         workspace: external_exports.string().optional(),
         query: external_exports.string(),
-        limit: external_exports.number().int().positive().max(200).optional()
+        limit: external_exports.number().int().positive().max(200).optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace, query, limit }) => {
+      async ({ workspace, query, limit, state_root }) => {
         const ws = workspace ?? process.cwd();
-        const items = await queryFiles(ws, query, limit ?? 20);
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
+        const items = await queryFiles(ws, query, limit ?? 20, { state_root });
         return asText({ items });
       }
     );
@@ -31852,11 +32181,13 @@ var init_server3 = __esm({
       {
         workspace: external_exports.string().optional(),
         query: external_exports.string(),
-        limit: external_exports.number().int().positive().max(200).optional()
+        limit: external_exports.number().int().positive().max(200).optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace, query, limit }) => {
+      async ({ workspace, query, limit, state_root }) => {
         const ws = workspace ?? process.cwd();
-        const items = await querySymbols(ws, query, limit ?? 20);
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
+        const items = await querySymbols(ws, query, limit ?? 20, { state_root });
         return asText({ items });
       }
     );
@@ -31870,15 +32201,18 @@ var init_server3 = __esm({
         prefer_code: external_exports.boolean().optional(),
         path_prefix: external_exports.string().optional(),
         language: external_exports.string().optional(),
-        intent: external_exports.enum(["auto", "code", "docs", "symbols"]).optional()
+        intent: external_exports.enum(["auto", "code", "docs", "symbols"]).optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace, query, limit, prefer_code, path_prefix, language, intent }) => {
+      async ({ workspace, query, limit, prefer_code, path_prefix, language, intent, state_root }) => {
         const ws = workspace ?? process.cwd();
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
         const items = await queryChunks(ws, query, limit ?? 10, {
           prefer_code,
           path_prefix,
           language,
-          intent
+          intent,
+          state_root
         });
         return asText({ items });
       }
@@ -31895,10 +32229,12 @@ var init_server3 = __esm({
         prefer_code: external_exports.boolean().optional(),
         path_prefix: external_exports.string().optional(),
         language: external_exports.string().optional(),
-        intent: external_exports.enum(["auto", "code", "docs", "symbols"]).optional()
+        intent: external_exports.enum(["auto", "code", "docs", "symbols"]).optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace, query, files_limit, symbols_limit, search_limit, prefer_code, path_prefix, language, intent }) => {
+      async ({ workspace, query, files_limit, symbols_limit, search_limit, prefer_code, path_prefix, language, intent, state_root }) => {
         const ws = workspace ?? process.cwd();
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
         const result = await lookupIndex(ws, query, {
           files_limit,
           symbols_limit,
@@ -31906,7 +32242,8 @@ var init_server3 = __esm({
           prefer_code,
           path_prefix,
           language,
-          intent
+          intent,
+          state_root
         });
         return asText(result);
       }
@@ -31924,7 +32261,8 @@ var init_server3 = __esm({
         prefer_code: external_exports.boolean().optional(),
         path_prefix: external_exports.string().optional(),
         language: external_exports.string().optional(),
-        intent: external_exports.enum(["auto", "code", "docs", "symbols"]).optional()
+        intent: external_exports.enum(["auto", "code", "docs", "symbols"]).optional(),
+        state_root: external_exports.string().optional()
       },
       async ({
         workspace,
@@ -31936,13 +32274,15 @@ var init_server3 = __esm({
         prefer_code,
         path_prefix,
         language,
-        intent
+        intent,
+        state_root
       }) => {
         const ws = workspace ?? process.cwd();
-        let status = await getStatus(ws);
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
+        let status = await getStatus(ws, { state_root });
         if (shouldRefreshDiscover(status) && (refresh_if_stale ?? true)) {
-          await buildIndex(ws, "changed");
-          status = await getStatus(ws);
+          await buildIndex(ws, "changed", { state_root });
+          status = await getStatus(ws, { state_root });
         }
         const discovered = await discoverIndex(ws, query, {
           files_limit,
@@ -31951,7 +32291,8 @@ var init_server3 = __esm({
           prefer_code,
           path_prefix,
           language,
-          intent
+          intent,
+          state_root
         });
         return asText({ status, intent: discovered.intent, files: discovered.files, symbols: discovered.symbols, chunks: discovered.chunks });
       }
@@ -32052,14 +32393,17 @@ var init_server3 = __esm({
       {
         workspace: external_exports.string().optional(),
         repo: external_exports.string(),
-        kind: external_exports.enum(["issues", "prs", "checks"]),
+        kind: external_exports.enum(["repo_context", "issues", "prs", "checks"]),
         query: external_exports.string().optional(),
         limit: external_exports.number().int().positive().max(50).optional(),
-        timeout_ms: external_exports.number().int().positive().max(2e4).optional()
+        timeout_ms: external_exports.number().int().positive().max(2e4).optional(),
+        temp_root: external_exports.string().optional(),
+        state_root: external_exports.string().optional()
       },
-      async ({ workspace, repo, kind, query, limit, timeout_ms }) => {
+      async ({ workspace, repo, kind, query, limit, timeout_ms, temp_root, state_root }) => {
         const ws = workspace ?? process.cwd();
-        return asText(ghLookup(ws, { repo, kind, query, limit, timeout_ms }));
+        diagnostics.configureStatePath(diagnosticsStatePath(ws, state_root));
+        return asText(await ghLookup(ws, { repo, kind, query, limit, timeout_ms, temp_root, state_root }));
       }
     );
     server.tool(
@@ -32101,6 +32445,11 @@ function writeOutput(data) {
 async function main() {
   const cmd = process.argv[2] ?? "status";
   const workspace = resolveWorkspace();
+  const stateRoot = getArg("--state-root");
+  if (stateRoot) {
+    process.env.VEIL_STATE_ROOT = stateRoot;
+  }
+  diagnostics.configureStatePath(diagnosticsStatePath(workspace, stateRoot));
   const enableProfiling = hasFlag("--profile");
   if (enableProfiling) {
     profiler.enable();
@@ -32113,12 +32462,12 @@ async function main() {
   }
   if (cmd === "refresh") {
     const mode = getArg("--mode", "changed") ?? "changed";
-    const manifest = await buildIndex(workspace, mode);
+    const manifest = await buildIndex(workspace, mode, { state_root: stateRoot });
     writeOutput({ ok: true, mode, manifest });
     return;
   }
   if (cmd === "status") {
-    const status = await getStatus(workspace);
+    const status = await getStatus(workspace, { state_root: stateRoot });
     writeOutput(status);
     return;
   }
@@ -32126,19 +32475,19 @@ async function main() {
     const query = getArg("--query", "") ?? "";
     const intent = getArg("--intent", "auto") ?? "auto";
     const refreshIfStale = (getArg("--refresh-if-stale", "1") ?? "1") !== "0";
-    let status = await getStatus(workspace);
+    let status = await getStatus(workspace, { state_root: stateRoot });
     if (shouldRefreshDiscover(status) && refreshIfStale) {
-      await buildIndex(workspace, "changed");
-      status = await getStatus(workspace);
+      await buildIndex(workspace, "changed", { state_root: stateRoot });
+      status = await getStatus(workspace, { state_root: stateRoot });
     }
-    const discovered = await discoverIndex(workspace, query, { prefer_code: true, intent });
+    const discovered = await discoverIndex(workspace, query, { prefer_code: true, intent, state_root: stateRoot });
     writeOutput({ status, intent: discovered.intent, files: discovered.files, symbols: discovered.symbols, chunks: discovered.chunks });
     return;
   }
   if (cmd === "lookup") {
     const query = getArg("--query", "") ?? "";
     const intent = getArg("--intent", "auto") ?? "auto";
-    const result = await lookupIndex(workspace, query, { intent, prefer_code: true });
+    const result = await lookupIndex(workspace, query, { intent, prefer_code: true, state_root: stateRoot });
     writeOutput(result);
     return;
   }
@@ -32226,15 +32575,17 @@ async function main() {
   }
   if (cmd === "gh-lookup") {
     const repo = getArg("--repo", "") ?? "";
-    const kind = getArg("--kind", "issues") ?? "issues";
+    const kind = getArg("--kind", "repo_context") ?? "repo_context";
     const limit = Number(getArg("--limit", "10") ?? "10");
     const timeout_ms = Number(getArg("--timeout-ms", "12000") ?? "12000");
-    const result = ghLookup(workspace, {
+    const result = await ghLookup(workspace, {
       repo,
       kind,
       query: getArg("--query"),
       limit: Number.isFinite(limit) ? limit : 10,
-      timeout_ms: Number.isFinite(timeout_ms) ? timeout_ms : 12e3
+      timeout_ms: Number.isFinite(timeout_ms) ? timeout_ms : 12e3,
+      state_root: stateRoot,
+      temp_root: getArg("--temp-root")
     });
     writeOutput(result);
     return;
@@ -32243,7 +32594,7 @@ async function main() {
     console.error("\n" + profiler.report());
   }
   process.stderr.write(
-    "Usage: bun run src/cli.ts <build|refresh|status|discover|lookup|web-search|fetch-url|diagnostics|git-status|git-log|git-diff|git-show|gh-lookup> [--workspace <path>] [--mode full|changed] [--query <text>] [--profile]\nOutput format: TOON\nweb-search providers: google, duckduckgo, wikipedia, github, reddit, deepwiki\nweb-search debug: --debug 1\nfetch-url: --url <https://...> [--format markdown|text|html] [--timeout-ms 8000] [--max-bytes 200000]\n"
+    "Usage: bun run src/cli.ts <build|refresh|status|discover|lookup|web-search|fetch-url|diagnostics|git-status|git-log|git-diff|git-show|gh-lookup> [--workspace <path>] [--state-root <.veil|relative|/abs/path>] [--mode full|changed] [--query <text>] [--profile]\nOutput format: TOON\nweb-search providers: google, duckduckgo, wikipedia, github, reddit, deepwiki\nweb-search debug: --debug 1\nfetch-url: --url <https://...> [--format markdown|text|html] [--timeout-ms 8000] [--max-bytes 200000]\n"
   );
   process.exitCode = 1;
 }
@@ -32255,6 +32606,7 @@ var init_cli = __esm({
     init_fetch_url();
     init_format();
     init_git();
+    init_state_root();
     init_web_search();
     main().catch((error2) => {
       process.stderr.write(`${String(error2)}
@@ -32306,7 +32658,9 @@ var __internalBin = {
   usage,
   route
 };
-if (import.meta.main) {
+var meta = import.meta;
+var isMain = typeof meta.main === "boolean" ? meta.main : true;
+if (isMain) {
   main2().catch((error2) => {
     process.stderr.write(`${String(error2)}
 `);