opencode-codebase-index 0.11.0 → 0.12.0

package/dist/index.cjs

@@ -333,7 +333,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path18, checkUnignored, mode) {
+      test(path19, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -342,7 +342,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path18);
+          const matched = rule[mode].test(path19);
           if (!matched) {
             return;
           }
@@ -363,17 +363,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path18, originalPath, doThrow) => {
-      if (!isString(path18)) {
+    var checkPath = (path19, originalPath, doThrow) => {
+      if (!isString(path19)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path18) {
+      if (!path19) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path18)) {
+      if (checkPath.isNotRelative(path19)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -382,7 +382,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path18) => REGEX_TEST_INVALID_PATH.test(path18);
+    var isNotRelative = (path19) => REGEX_TEST_INVALID_PATH.test(path19);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -412,19 +412,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path18 = originalPath && checkPath.convert(originalPath);
+        const path19 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path18,
+          path19,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path18, cache, checkUnignored, slices);
+        return this._t(path19, cache, checkUnignored, slices);
       }
-      checkIgnore(path18) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path18)) {
-          return this.test(path18);
+      checkIgnore(path19) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path19)) {
+          return this.test(path19);
         }
-        const slices = path18.split(SLASH2).filter(Boolean);
+        const slices = path19.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -437,18 +437,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path18, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path19, false, MODE_CHECK_IGNORE);
       }
-      _t(path18, cache, checkUnignored, slices) {
-        if (path18 in cache) {
-          return cache[path18];
+      _t(path19, cache, checkUnignored, slices) {
+        if (path19 in cache) {
+          return cache[path19];
         }
         if (!slices) {
-          slices = path18.split(SLASH2).filter(Boolean);
+          slices = path19.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path18] = this._rules.test(path18, checkUnignored, MODE_IGNORE);
+          return cache[path19] = this._rules.test(path19, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -456,29 +456,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path18] = parent.ignored ? parent : this._rules.test(path18, checkUnignored, MODE_IGNORE);
+        return cache[path19] = parent.ignored ? parent : this._rules.test(path19, checkUnignored, MODE_IGNORE);
       }
-      ignores(path18) {
-        return this._test(path18, this._ignoreCache, false).ignored;
+      ignores(path19) {
+        return this._test(path19, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path18) => !this.ignores(path18);
+        return (path19) => !this.ignores(path19);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path18) {
-        return this._test(path18, this._testCache, true);
+      test(path19) {
+        return this._test(path19, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path18) => checkPath(path18 && checkPath.convert(path18), path18, RETURN_FALSE);
+    var isPathValid = (path19) => checkPath(path19 && checkPath.convert(path19), path19, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path18) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path18) || isNotRelative(path18);
+      checkPath.isNotRelative = (path19) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path19) || isNotRelative(path19);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -662,7 +662,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var os6 = __toESM(require("os"), 1);
-var path17 = __toESM(require("path"), 1);
+var path18 = __toESM(require("path"), 1);
 var import_url2 = require("url");
 
 // src/config/constants.ts
@@ -809,6 +809,7 @@ function getDefaultSearchConfig() {
     rerankTopN: 20,
     contextLines: 0,
     routingHints: true,
+    routingGraphHandoffHints: false,
     routingHintRole: "system"
   };
 }
@@ -931,6 +932,7 @@ function parseConfig(raw) {
     rerankTopN: typeof rawSearch.rerankTopN === "number" ? Math.min(200, Math.max(0, Math.floor(rawSearch.rerankTopN))) : defaultSearch.rerankTopN,
     contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines,
     routingHints: typeof rawSearch.routingHints === "boolean" ? rawSearch.routingHints : defaultSearch.routingHints,
+    routingGraphHandoffHints: typeof rawSearch.routingGraphHandoffHints === "boolean" ? rawSearch.routingGraphHandoffHints : defaultSearch.routingGraphHandoffHints,
     routingHintRole: rawSearch.routingHintRole === "developer" || rawSearch.routingHintRole === "system" ? rawSearch.routingHintRole : defaultSearch.routingHintRole
   };
   const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
@@ -1557,7 +1559,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path18) => statMethod(path18, { bigint: true });
+      this._stat = (path19) => statMethod(path19, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -1582,8 +1584,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path18, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
+          const { path: path19, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path19));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -1623,20 +1625,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path18, depth) {
+  async _exploreDir(path19, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path18, this._rdOptions);
+      files = await (0, import_promises.readdir)(path19, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path18 };
+    return { files, depth, path: path19 };
   }
-  async _formatEntry(dirent, path18) {
+  async _formatEntry(dirent, path19) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path18, basename5));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path19, basename5));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -2036,16 +2038,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path19, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path18);
-    emitRaw(rawEvent, evPath, { watchedPath: path18 });
-    if (evPath && path18 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path18, evPath), KEY_LISTENERS, sp.join(path18, evPath));
+    listener(path19);
+    emitRaw(rawEvent, evPath, { watchedPath: path19 });
+    if (evPath && path19 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path19, evPath), KEY_LISTENERS, sp.join(path19, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path18, {
+    return (0, import_node_fs.watch)(path19, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -2061,12 +2063,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path18, fullPath, options, handlers) => {
+var setFsWatchListener = (path19, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path19, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -2077,7 +2079,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path18,
+      path19,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -2092,7 +2094,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path18, "r");
+          const fd = await (0, import_promises2.open)(path19, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -2123,7 +2125,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path19, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -2145,7 +2147,7 @@ var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path18, curr));
+          foreach(cont.listeners, (listener2) => listener2(path19, curr));
         }
       })
     };
@@ -2175,13 +2177,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path18, listener) {
+  _watchWithNodeFs(path19, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path18);
-    const basename5 = sp.basename(path18);
+    const directory = sp.dirname(path19);
+    const basename5 = sp.basename(path19);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sp.resolve(path18);
+    const absolutePath = sp.resolve(path19);
     const options = {
       persistent: opts.persistent
     };
@@ -2191,12 +2193,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path18, absolutePath, options, {
+      closer = setFsWatchFileListener(path19, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path18, absolutePath, options, {
+      closer = setFsWatchListener(path19, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -2218,7 +2220,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path18, newStats) => {
+    const listener = async (path19, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -2232,11 +2234,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path18);
+            this.fsw._closeFile(path19);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path18, closer2);
+              this.fsw._addPathCloser(path19, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -2268,7 +2270,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path18, item) {
+  async _handleSymlink(entry, directory, path19, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -2278,7 +2280,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path18);
+        linkPath = await (0, import_promises2.realpath)(path19);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -2288,12 +2290,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path18, entry.stats);
+          this.fsw._emit(EV.CHANGE, path19, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path18, entry.stats);
+        this.fsw._emit(EV.ADD, path19, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -2323,9 +2325,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path18 = sp.join(directory, item);
+      let path19 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path19, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -2334,11 +2336,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path18 = sp.join(dir, sp.relative(dir, path18));
-        this._addToNodeFs(path18, initialAdd, wh, depth + 1);
+        path19 = sp.join(dir, sp.relative(dir, path19));
+        this._addToNodeFs(path19, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -2347,7 +2349,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve12(void 0);
+        resolve13(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -2404,13 +2406,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path19, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path18) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path19) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path18);
+    const wh = this.fsw._getWatchHelpers(path19);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -2426,8 +2428,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path18);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
+        const absPath = sp.resolve(path19);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path19) : path19;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -2437,29 +2439,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path19) : path19;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path18, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path19, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path18), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path19), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path18, closer);
+        this.fsw._addPathCloser(path19, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path18;
+        return path19;
       }
     }
   }
@@ -2491,35 +2493,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative8 = sp2.relative(matcher.path, string);
-        if (!relative8) {
+        const relative9 = sp2.relative(matcher.path, string);
+        if (!relative9) {
           return false;
         }
-        return !relative8.startsWith("..") && !sp2.isAbsolute(relative8);
+        return !relative9.startsWith("..") && !sp2.isAbsolute(relative9);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath(path18) {
-  if (typeof path18 !== "string")
+function normalizePath(path19) {
+  if (typeof path19 !== "string")
     throw new Error("string expected");
-  path18 = sp2.normalize(path18);
-  path18 = path18.replace(/\\/g, "/");
+  path19 = sp2.normalize(path19);
+  path19 = path19.replace(/\\/g, "/");
   let prepend = false;
-  if (path18.startsWith("//"))
+  if (path19.startsWith("//"))
     prepend = true;
-  path18 = path18.replace(DOUBLE_SLASH_RE, "/");
+  path19 = path19.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path18 = "/" + path18;
-  return path18;
+    path19 = "/" + path19;
+  return path19;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path18 = normalizePath(testString);
+  const path19 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path18, stats)) {
+    if (pattern(path19, stats)) {
       return true;
     }
   }
@@ -2557,19 +2559,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
-var normalizeIgnored = (cwd = "") => (path18) => {
-  if (typeof path18 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
+var normalizePathToUnix = (path19) => toUnix(sp2.normalize(toUnix(path19)));
+var normalizeIgnored = (cwd = "") => (path19) => {
+  if (typeof path19 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path19) ? path19 : sp2.join(cwd, path19));
   } else {
-    return path18;
+    return path19;
   }
 };
-var getAbsolutePath = (path18, cwd) => {
-  if (sp2.isAbsolute(path18)) {
-    return path18;
+var getAbsolutePath = (path19, cwd) => {
+  if (sp2.isAbsolute(path19)) {
+    return path19;
   }
-  return sp2.join(cwd, path18);
+  return sp2.join(cwd, path19);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -2634,10 +2636,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path18, follow, fsw) {
+  constructor(path19, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path18;
-    this.path = path18 = path18.replace(REPLACER_RE, "");
+    const watchPath = path19;
+    this.path = path19 = path19.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -2777,20 +2779,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path18) => {
-        const absPath = getAbsolutePath(path18, cwd);
+      paths = paths.map((path19) => {
+        const absPath = getAbsolutePath(path19, cwd);
         return absPath;
       });
     }
-    paths.forEach((path18) => {
-      this._removeIgnoredPath(path18);
+    paths.forEach((path19) => {
+      this._removeIgnoredPath(path19);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path18) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path19) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path19, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -2812,17 +2814,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path18) => {
-      if (!sp2.isAbsolute(path18) && !this._closers.has(path18)) {
+    paths.forEach((path19) => {
+      if (!sp2.isAbsolute(path19) && !this._closers.has(path19)) {
         if (cwd)
-          path18 = sp2.join(cwd, path18);
-        path18 = sp2.resolve(path18);
+          path19 = sp2.join(cwd, path19);
+        path19 = sp2.resolve(path19);
       }
-      this._closePath(path18);
-      this._addIgnoredPath(path18);
-      if (this._watched.has(path18)) {
+      this._closePath(path19);
+      this._addIgnoredPath(path19);
+      if (this._watched.has(path19)) {
         this._addIgnoredPath({
-          path: path18,
+          path: path19,
           recursive: true
         });
       }
@@ -2886,38 +2888,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path18, stats) {
+  async _emit(event, path19, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path18 = sp2.normalize(path18);
+      path19 = sp2.normalize(path19);
     if (opts.cwd)
-      path18 = sp2.relative(opts.cwd, path18);
-    const args = [path18];
+      path19 = sp2.relative(opts.cwd, path19);
+    const args = [path19];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path18))) {
+    if (awf && (pw = this._pendingWrites.get(path19))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path18, [event, ...args]);
+        this._pendingUnlinks.set(path19, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path19) => {
+          this._pendingUnlinks.forEach((entry, path20) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path19);
+            this._pendingUnlinks.delete(path20);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path19)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path18);
+        this._pendingUnlinks.delete(path19);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2935,16 +2937,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path19, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path19, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path18) : path18;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path19) : path19;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -2975,23 +2977,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path18, timeout) {
+  _throttle(actionType, path19, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path18);
+    const actionPath = action.get(path19);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path18);
+      const item = action.get(path19);
       const count = item ? item.count : 0;
-      action.delete(path18);
+      action.delete(path19);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2999,7 +3001,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path18, thr);
+    action.set(path19, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -3013,44 +3015,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path18, threshold, event, awfEmit) {
+  _awaitWriteFinish(path19, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path18;
-    if (this.options.cwd && !sp2.isAbsolute(path18)) {
-      fullPath = sp2.join(this.options.cwd, path18);
+    let fullPath = path19;
+    if (this.options.cwd && !sp2.isAbsolute(path19)) {
+      fullPath = sp2.join(this.options.cwd, path19);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path18)) {
+        if (err || !writes.has(path19)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path18).lastChange = now2;
+          writes.get(path19).lastChange = now2;
         }
-        const pw = writes.get(path18);
+        const pw = writes.get(path19);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path18);
+          writes.delete(path19);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path18)) {
-      writes.set(path18, {
+    if (!writes.has(path19)) {
+      writes.set(path19, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path18);
+          writes.delete(path19);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -3061,8 +3063,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path18, stats) {
-    if (this.options.atomic && DOT_RE.test(path18))
+  _isIgnored(path19, stats) {
+    if (this.options.atomic && DOT_RE.test(path19))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -3072,17 +3074,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path18, stats);
+    return this._userIgnored(path19, stats);
   }
-  _isntIgnored(path18, stat4) {
-    return !this._isIgnored(path18, stat4);
+  _isntIgnored(path19, stat4) {
+    return !this._isIgnored(path19, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path18) {
-    return new WatchHelper(path18, this.options.followSymlinks, this);
+  _getWatchHelpers(path19) {
+    return new WatchHelper(path19, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -3114,63 +3116,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path18 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path18);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path18, 100))
+    const path19 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path19);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path19) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path19, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path18);
+    const wp = this._getWatchedDir(path19);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path18, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path19, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path18;
+    let relPath = path19;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path18);
+      relPath = sp2.relative(this.options.cwd, path19);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path18);
+    this._watched.delete(path19);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path18))
-      this._emit(eventName, path18);
-    this._closePath(path18);
+    if (wasTracked && !this._isIgnored(path19))
+      this._emit(eventName, path19);
+    this._closePath(path19);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path18) {
-    this._closeFile(path18);
-    const dir = sp2.dirname(path18);
-    this._getWatchedDir(dir).remove(sp2.basename(path18));
+  _closePath(path19) {
+    this._closeFile(path19);
+    const dir = sp2.dirname(path19);
+    this._getWatchedDir(dir).remove(sp2.basename(path19));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path18) {
-    const closers = this._closers.get(path18);
+  _closeFile(path19) {
+    const closers = this._closers.get(path19);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path18);
+    this._closers.delete(path19);
   }
-  _addPathCloser(path18, closer) {
+  _addPathCloser(path19, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path18);
+    let list = this._closers.get(path19);
     if (!list) {
       list = [];
-      this._closers.set(path18, list);
+      this._closers.set(path19, list);
     }
     list.push(closer);
   }
@@ -3500,7 +3502,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path18, type]) => ({ path: path18, type })
+      ([path19, type]) => ({ path: path19, type })
     );
     this.pendingChanges.clear();
     try {
@@ -3633,12 +3635,14 @@ function createWatcherWithIndexer(getIndexer, projectRoot, config) {
 }
 
 // src/tools/index.ts
-var import_plugin = require("@opencode-ai/plugin");
+var import_plugin2 = require("@opencode-ai/plugin");
 
 // src/indexer/index.ts
 var import_fs7 = require("fs");
-var path12 = __toESM(require("path"), 1);
+var path13 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
+var import_child_process2 = require("child_process");
+var import_util2 = require("util");
 
 // node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -3662,7 +3666,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve12, reject) => {
+  const wrappedPromise = new Promise((resolve13, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -3676,7 +3680,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve12, reject);
+    promise.then(resolve13, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -3684,7 +3688,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve12(fallback());
+          resolve13(fallback());
         } catch (error) {
           reject(error);
         }
@@ -3694,7 +3698,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve12();
+        resolve13();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -4096,7 +4100,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -4136,7 +4140,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve12(result);
+          resolve13(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -4324,13 +4328,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve12();
+        resolve13();
       };
       this.on(event, listener);
     });
@@ -4616,7 +4620,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve12, reject) => {
+    await new Promise((resolve13, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -4624,7 +4628,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve12();
+        resolve13();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -5852,6 +5856,15 @@ function createMockNativeBinding() {
       close() {
         throw error;
       }
+      getTransitiveReachability() {
+        throw error;
+      }
+      detectCommunities() {
+        throw error;
+      }
+      computeCentrality() {
+        throw error;
+      }
     }
   };
 }
@@ -6402,6 +6415,14 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.getSymbolsByNameCi(name);
   }
+  getSymbolsForBranch(branch) {
+    this.throwIfClosed();
+    return this.inner.getSymbolsForBranch(branch);
+  }
+  getSymbolsForFiles(filePaths, branch) {
+    this.throwIfClosed();
+    return this.inner.getSymbolsForFiles(filePaths, branch);
+  }
   deleteSymbolsByFile(filePath) {
     this.throwIfClosed();
     return this.inner.deleteSymbolsByFile(filePath);
@@ -6479,8 +6500,125 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.gcOrphanCallEdges();
   }
+  getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth) {
+    this.throwIfClosed();
+    return this.inner.getTransitiveReachability(
+      rootSymbolIds,
+      branch,
+      direction,
+      maxDepth ?? null
+    );
+  }
+  detectCommunities(branch, symbolIds) {
+    this.throwIfClosed();
+    return this.inner.detectCommunities(branch, symbolIds ?? null);
+  }
+  computeCentrality(branch) {
+    this.throwIfClosed();
+    return this.inner.computeCentrality(branch);
+  }
 };
 
+// src/tools/changed-files.ts
+var path12 = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+var import_util = require("util");
+var execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+async function getChangedFiles(opts) {
+  const { pr, branch, projectRoot, baseBranch = "main" } = opts;
+  if (pr !== void 0) {
+    return getChangedFilesForPr(pr, projectRoot, baseBranch);
+  }
+  return getChangedFilesForBranch(branch, projectRoot, baseBranch);
+}
+async function getChangedFilesForPr(pr, projectRoot, baseBranch) {
+  let headRefName;
+  let actualBaseBranch = baseBranch;
+  try {
+    const { stdout } = await execFileAsync(
+      "gh",
+      ["pr", "view", String(pr), "--json", "headRefName,baseRefName,files"],
+      { cwd: projectRoot, timeout: 3e4 }
+    );
+    const data = JSON.parse(stdout);
+    headRefName = data.headRefName;
+    actualBaseBranch = data.baseRefName || baseBranch;
+    if (data.files && data.files.length > 0) {
+      return {
+        files: normalizeFiles(
+          data.files.map((f) => f.path),
+          projectRoot
+        ),
+        baseBranch: actualBaseBranch,
+        source: "gh",
+        headRefName
+      };
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to retrieve PR #${pr} via gh CLI: ${getErrorMessage(error)}`
+    );
+  }
+  if (headRefName === void 0) {
+    throw new Error(
+      `PR #${pr} returned no usable branch or file information.`
+    );
+  }
+  const result = await getChangedFilesForBranch(headRefName, projectRoot, actualBaseBranch);
+  return { ...result, headRefName };
+}
+async function getChangedFilesForBranch(branch, projectRoot, baseBranch) {
+  const targetBranch = branch || await getCurrentBranch2(projectRoot);
+  const mergeBase = await getMergeBase(projectRoot, baseBranch, targetBranch);
+  const { stdout } = await execFileAsync(
+    "git",
+    ["diff", "--name-only", `${mergeBase}...${targetBranch}`],
+    { cwd: projectRoot, timeout: 3e4 }
+  );
+  return {
+    files: normalizeFiles(stdout.split("\n"), projectRoot),
+    baseBranch,
+    source: "git",
+    headRefName: targetBranch
+  };
+}
+async function getCurrentBranch2(projectRoot) {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["branch", "--show-current"],
+    { cwd: projectRoot, timeout: 3e4 }
+  );
+  return stdout.trim() || "HEAD";
+}
+async function getMergeBase(projectRoot, baseBranch, branch) {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["merge-base", baseBranch, branch],
+    { cwd: projectRoot, timeout: 3e4 }
+  );
+  return stdout.trim();
+}
+function normalizeFiles(rawFiles, projectRoot) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const raw of rawFiles) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    const absolute = path12.resolve(projectRoot, trimmed);
+    const relative9 = path12.relative(projectRoot, absolute);
+    const cleaned = relative9.startsWith("./") ? relative9.slice(2) : relative9;
+    if (!seen.has(cleaned)) {
+      seen.add(cleaned);
+      result.push(cleaned);
+    }
+  }
+  return result;
+}
+
 // src/indexer/index.ts
 var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab"]);
 var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
@@ -6488,6 +6626,7 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function",
   "arrow_function",
+  "export_statement",
   "method_definition",
   "class_declaration",
   "interface_declaration",
@@ -6526,7 +6665,7 @@ function float32ArrayToBuffer(arr) {
 function bufferToFloat32Array(buf) {
   return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
 }
-function getErrorMessage(error) {
+function getErrorMessage2(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -6539,7 +6678,7 @@ function getErrorMessage(error) {
   return String(error);
 }
 function isRateLimitError(error) {
-  const message = getErrorMessage(error);
+  const message = getErrorMessage2(error);
   return message.includes("429") || message.toLowerCase().includes("rate limit") || message.toLowerCase().includes("too many requests");
 }
 function getSafeEmbeddingChunkTokenLimit(provider) {
@@ -6557,7 +6696,7 @@ function getDynamicBatchOptions(provider) {
   return {};
 }
 function isSqliteCorruptionError(error) {
-  const message = getErrorMessage(error).toLowerCase();
+  const message = getErrorMessage2(error).toLowerCase();
   return message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database schema is corrupt") || message.includes("sqlite_corrupt");
 }
 var STARTUP_WARNING_METADATA_KEY = "index.startupWarning";
@@ -6719,9 +6858,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path12.resolve(filePath);
-  const normalizedRoot = path12.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path12.sep}`);
+  const normalizedFilePath = path13.resolve(filePath);
+  const normalizedRoot = path13.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path13.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -7774,9 +7913,9 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path12.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path12.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path12.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path13.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
@@ -7808,14 +7947,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    (0, import_fs7.mkdirSync)(path12.dirname(targetPath), { recursive: true });
+    (0, import_fs7.mkdirSync)(path13.dirname(targetPath), { recursive: true });
     (0, import_fs7.writeFileSync)(tempPath, data);
     (0, import_fs7.renameSync)(tempPath, targetPath);
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path12.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path13.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path12.resolve(this.projectRoot, kbRoot));
+      roots.add(path13.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -7824,22 +7963,29 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    return `${projectHash}:${branchName}`;
+  }
+  getBranchCatalogKeyFor(branchName) {
+    if (this.config.scope !== "global") {
+      return branchName;
+    }
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -7933,7 +8079,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path12.resolve(this.projectRoot);
+    const projectRootPath = path13.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -7956,7 +8102,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -8040,7 +8186,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -8074,7 +8220,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path12.resolve(this.projectRoot);
+    const projectRootPath = path13.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -8327,7 +8473,7 @@ var Indexer = class {
       this.logger.search("warn", "External reranker failed; using deterministic order", {
         provider: reranker.provider,
         model: reranker.model,
-        error: getErrorMessage(error)
+        error: getErrorMessage2(error)
       });
       return candidates;
     }
@@ -8434,13 +8580,13 @@ var Indexer = class {
     }
     await import_fs7.promises.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path12.join(this.indexPath, "vectors");
+    const storePath = path13.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path12.join(this.indexPath, "vectors.usearch");
+    const indexFilePath = path13.join(this.indexPath, "vectors.usearch");
     if ((0, import_fs7.existsSync)(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path12.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
@@ -8450,7 +8596,7 @@ var Indexer = class {
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path12.join(this.indexPath, "codebase.db");
+    const dbPath = path13.join(this.indexPath, "codebase.db");
     let dbIsNew = !(0, import_fs7.existsSync)(dbPath);
     try {
       this.database = new Database(dbPath);
@@ -8531,7 +8677,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -8546,7 +8692,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path12.join(this.indexPath, "vectors");
+    const storeBasePath = path13.join(this.indexPath, "vectors");
     const storeIndexPath = `${storeBasePath}.usearch`;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const backupIndexPath = `${storeIndexPath}.bak`;
@@ -8631,9 +8777,9 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path12.join(this.indexPath, "codebase.db");
+    const dbPath = path13.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
-    const errorMessage = getErrorMessage(error);
+    const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
       this.logger.error("Detected corrupted shared global index database", {
         stage,
@@ -8654,15 +8800,15 @@ var Indexer = class {
     this.indexCompatibility = null;
     this.fileHashCache.clear();
     const resetPaths = [
-      path12.join(this.indexPath, "codebase.db"),
-      path12.join(this.indexPath, "codebase.db-shm"),
-      path12.join(this.indexPath, "codebase.db-wal"),
-      path12.join(this.indexPath, "vectors.usearch"),
-      path12.join(this.indexPath, "inverted-index.json"),
-      path12.join(this.indexPath, "file-hashes.json"),
-      path12.join(this.indexPath, "failed-batches.json"),
-      path12.join(this.indexPath, "indexing.lock"),
-      path12.join(this.indexPath, "vectors")
+      path13.join(this.indexPath, "codebase.db"),
+      path13.join(this.indexPath, "codebase.db-shm"),
+      path13.join(this.indexPath, "codebase.db-wal"),
+      path13.join(this.indexPath, "vectors.usearch"),
+      path13.join(this.indexPath, "inverted-index.json"),
+      path13.join(this.indexPath, "file-hashes.json"),
+      path13.join(this.indexPath, "failed-batches.json"),
+      path13.join(this.indexPath, "indexing.lock"),
+      path13.join(this.indexPath, "vectors")
     ];
     await Promise.all(resetPaths.map(async (targetPath) => {
       try {
@@ -8927,7 +9073,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path12.relative(this.projectRoot, parsed.path);
+        const relativePath = path13.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -9211,7 +9357,7 @@ var Indexer = class {
     for (const requestBatch of requestBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve12) => setTimeout(resolve12, rateLimitBackoffMs));
+          await new Promise((resolve13) => setTimeout(resolve13, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -9226,7 +9372,7 @@ var Indexer = class {
               factor: 2,
               shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError),
               onFailedAttempt: (error) => {
-                const message = getErrorMessage(error);
+                const message = getErrorMessage2(error);
                 if (isRateLimitError(error)) {
                   rateLimitBackoffMs = Math.min(providerRateLimits.maxRetryMs, (rateLimitBackoffMs || providerRateLimits.minRetryMs) * 2);
                   this.logger.embedding("warn", `Rate limited, backing off`, {
@@ -9333,7 +9479,7 @@ var Indexer = class {
           });
         } catch (error) {
           const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id));
-          const failureMessage = getErrorMessage(error);
+          const failureMessage = getErrorMessage2(error);
           const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
           for (const chunk of failedChunks) {
             if (!failedChunkIds.has(chunk.id)) {
@@ -9772,8 +9918,8 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPath = path12.join(this.projectRoot, ".opencode", "index");
-    if (path12.resolve(this.indexPath) !== path12.resolve(localProjectIndexPath)) {
+    const localProjectIndexPath = path13.join(this.projectRoot, ".opencode", "index");
+    if (path13.resolve(this.indexPath) !== path13.resolve(localProjectIndexPath)) {
       throw new Error(
         "Project-scoped force rebuild is unsafe while using an inherited worktree index. Create a local project config boundary before clearing the index."
       );
@@ -9861,7 +10007,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -10012,7 +10158,7 @@ var Indexer = class {
         succeeded += successfulResults.length;
         stillFailing.push(...failedChunksForBatch.values());
       } catch (error) {
-        const failureMessage = getErrorMessage(error);
+        const failureMessage = getErrorMessage2(error);
         const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
         const unaccountedChunks = batch.chunks.filter(
           (chunk) => !failedChunksForBatch.has(chunk.id) && !completedChunkIds.has(chunk.id)
@@ -10218,13 +10364,194 @@ var Indexer = class {
     const { database } = await this.ensureInitialized();
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path18 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path18.length > 0 && (shortest.length === 0 || path18.length < shortest.length)) {
-        shortest = path18;
+      const path19 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path19.length > 0 && (shortest.length === 0 || path19.length < shortest.length)) {
+        shortest = path19;
       }
     }
     return shortest;
   }
+  async getSymbolsForBranch(branch) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.getSymbolsForBranch(resolvedBranch);
+  }
+  async getSymbolsForFiles(filePaths, branch) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.getSymbolsForFiles(filePaths, resolvedBranch);
+  }
+  async getTransitiveReachability(rootSymbolIds, direction, maxDepth) {
+    const { database } = await this.ensureInitialized();
+    const branch = this.getBranchCatalogKey();
+    return database.getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth);
+  }
+  async detectCommunities(branch, symbolIds) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.detectCommunities(resolvedBranch, symbolIds);
+  }
+  async computeCentrality(branch) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.computeCentrality(resolvedBranch);
+  }
+  async getPrImpact(opts) {
+    const { database } = await this.ensureInitialized();
+    const execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
+    const changedFilesResult = await getChangedFiles({
+      pr: opts.pr,
+      branch: opts.branch,
+      projectRoot: this.projectRoot,
+      baseBranch: this.baseBranch
+    });
+    const changedFiles = changedFilesResult.files;
+    const headRefName = changedFilesResult.headRefName;
+    if (opts.pr !== void 0 && headRefName === void 0) {
+      throw new Error(
+        `Could not resolve head branch for PR #${opts.pr}. Run index_codebase on the PR branch first.`
+      );
+    }
+    const resolvedBranch = opts.pr !== void 0 ? headRefName : opts.branch || this.currentBranch;
+    const branchKey = this.getBranchCatalogKeyFor(resolvedBranch || "default");
+    const branchSymbols = database.getSymbolsForBranch(branchKey);
+    if (branchSymbols.length === 0) {
+      throw new Error(
+        "Run index_codebase first to build the call graph and symbol index for this branch."
+      );
+    }
+    const absoluteChangedFiles = changedFiles.map((f) => path13.resolve(this.projectRoot, f));
+    const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
+    const directIds = directSymbols.map((s) => s.id);
+    const direction = opts.direction ?? "both";
+    const maxDepth = opts.maxDepth ?? 5;
+    const transitiveCallers = database.getTransitiveReachability(
+      directIds,
+      branchKey,
+      direction,
+      maxDepth
+    );
+    const affectedIdsSet = new Set(directIds);
+    for (const caller of transitiveCallers) {
+      affectedIdsSet.add(caller.symbolId);
+    }
+    const allAffectedIds = Array.from(affectedIdsSet);
+    const communitiesData = database.detectCommunities(branchKey, allAffectedIds);
+    const communityMap = /* @__PURE__ */ new Map();
+    for (const c of communitiesData) {
+      if (!communityMap.has(c.communityLabel)) {
+        communityMap.set(c.communityLabel, {
+          label: c.communityLabel,
+          symbolCount: 0,
+          directSymbols: /* @__PURE__ */ new Set()
+        });
+      }
+      const entry = communityMap.get(c.communityLabel);
+      entry.symbolCount++;
+      if (directIds.includes(c.symbolId)) {
+        entry.directSymbols.add(c.symbolId);
+      }
+    }
+    const communities = Array.from(communityMap.values()).map((c) => ({
+      label: c.label,
+      symbolCount: c.symbolCount,
+      directSymbols: Array.from(c.directSymbols)
+    }));
+    const centralityData = database.computeCentrality(branchKey);
+    const hubThreshold = opts.hubThreshold ?? 10;
+    const hubNodes = centralityData.filter((c) => directIds.includes(c.symbolId) && c.callerCount >= hubThreshold).map((c) => ({
+      id: c.symbolId,
+      name: c.symbolName,
+      callerCount: c.callerCount,
+      filePath: c.filePath
+    }));
+    const totalAffected = allAffectedIds.length;
+    let riskLevel;
+    let riskReason;
+    if (totalAffected < 5 && hubNodes.length === 0) {
+      riskLevel = "LOW";
+      riskReason = `Small impact: ${totalAffected} affected symbols, no hub nodes touched.`;
+    } else if (totalAffected > 20 || hubNodes.length > 1) {
+      riskLevel = "HIGH";
+      riskReason = `Large impact: ${totalAffected} affected symbols${hubNodes.length > 0 ? `, ${hubNodes.length} hub nodes touched` : ""}.`;
+    } else {
+      riskLevel = "MEDIUM";
+      riskReason = `Moderate impact: ${totalAffected} affected symbols${hubNodes.length === 1 ? ", 1 hub node touched" : ""}.`;
+    }
+    let conflictingPRs;
+    if (opts.checkConflicts) {
+      conflictingPRs = [];
+      try {
+        const { stdout } = await execFileAsync2(
+          "gh",
+          ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "10000"],
+          { cwd: this.projectRoot, timeout: 3e4 }
+        );
+        const openPRs = JSON.parse(stdout);
+        const currentCommunityLabels = new Set(communities.map((c) => c.label));
+        const allCommunitiesData = database.detectCommunities(branchKey);
+        const symbolToCommunity = /* @__PURE__ */ new Map();
+        const structuralKey = (filePath, name) => `${filePath.toLowerCase()}:${name.toLowerCase()}`;
+        for (const c of allCommunitiesData) {
+          symbolToCommunity.set(structuralKey(c.filePath, c.symbolName), c.communityLabel);
+        }
+        for (const openPr of openPRs) {
+          if (openPr.number === opts.pr) continue;
+          try {
+            const otherChanged = await getChangedFiles({
+              pr: openPr.number,
+              projectRoot: this.projectRoot,
+              baseBranch: this.baseBranch
+            });
+            const otherAbsolute = otherChanged.files.map((f) => path13.resolve(this.projectRoot, f));
+            const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
+            const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
+            const otherLabels = /* @__PURE__ */ new Set();
+            for (const sym of otherSymbols) {
+              const label = symbolToCommunity.get(structuralKey(sym.filePath, sym.name));
+              if (label) {
+                otherLabels.add(label);
+              }
+            }
+            const overlapping = Array.from(otherLabels).filter(
+              (l) => currentCommunityLabels.has(l)
+            );
+            if (overlapping.length > 0) {
+              conflictingPRs.push({
+                pr: openPr.number,
+                branch: openPr.headRefName,
+                overlappingCommunities: overlapping
+              });
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      changedFiles,
+      directSymbols: directSymbols.map((s) => ({
+        id: s.id,
+        name: s.name,
+        kind: s.kind,
+        filePath: s.filePath
+      })),
+      transitiveCallers: transitiveCallers.map((c) => ({
+        id: c.symbolId,
+        name: c.symbolName,
+        filePath: c.filePath,
+        depth: c.depth
+      })),
+      totalAffected,
+      communities,
+      hubNodes,
+      riskLevel,
+      riskReason,
+      direction,
+      conflictingPRs
+    };
+  }
   async close() {
     await this.database?.close();
     this.database = null;
@@ -10452,54 +10779,139 @@ ${truncateContent(r.content)}
   return formatted.join("\n\n");
 }
 
+// src/tools/pr-impact.ts
+var import_plugin = require("@opencode-ai/plugin");
+
+// src/tools/format-pr-impact.ts
+function formatPrImpact(result) {
+  const lines = [];
+  lines.push(`\u2192 Files changed: ${result.changedFiles.length}`);
+  for (const file of result.changedFiles) {
+    lines.push(`  - ${file}`);
+  }
+  const directCount = result.directSymbols.length;
+  const transitiveCount = result.transitiveCallers.length;
+  const directionLabel = result.direction === "callees" ? "callees" : result.direction === "both" ? "reachable (callers + callees)" : "callers";
+  lines.push(
+    `\u2192 Symbols affected: ${result.totalAffected} (${directCount} direct, ${transitiveCount} transitive ${directionLabel})`
+  );
+  if (directCount > 0) {
+    lines.push(
+      `  Direct: ${result.directSymbols.map((s) => `${s.name} (${s.kind})`).join(", ")}`
+    );
+  }
+  if (transitiveCount > 0) {
+    lines.push(
+      `  Transitive ${directionLabel}: ${result.transitiveCallers.map((s) => s.name).join(", ")}`
+    );
+  }
+  if (result.communities.length > 0) {
+    lines.push(
+      `\u2192 Communities touched: ${result.communities.map((c) => c.label).join(", ")}`
+    );
+    for (const community of result.communities) {
+      lines.push(
+        `  - ${community.label}: ${community.symbolCount} symbols`
+      );
+    }
+  } else {
+    lines.push("\u2192 Communities touched: none");
+  }
+  lines.push(`\u2192 Risk: ${result.riskLevel} \u2014 ${result.riskReason}`);
+  if (result.hubNodes.length > 0) {
+    lines.push("  Hub nodes in change scope:");
+    for (const hub of result.hubNodes) {
+      lines.push(`    - ${hub.name} (${hub.callerCount} callers) at ${hub.filePath}`);
+    }
+  }
+  if (result.conflictingPRs && result.conflictingPRs.length > 0) {
+    const conflictList = result.conflictingPRs.map(
+      (c) => `PR #${c.pr} (also touches ${c.overlappingCommunities.join(", ")} community)`
+    );
+    lines.push(`\u2192 Potential conflicts with: ${conflictList.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/pr-impact.ts
+var z = import_plugin.tool.schema;
+var pr_impact = (0, import_plugin.tool)({
+  description: "Analyze the impact of a pull request or branch by examining changed files, affected symbols, transitive callers, communities touched, hub nodes, and risk level. Use to understand blast radius before merging.",
+  args: {
+    pr: z.number().optional().describe("Pull request number to analyze"),
+    branch: z.string().optional().describe("Branch name to analyze (defaults to current branch)"),
+    maxDepth: z.number().optional().default(5).describe("Maximum traversal depth for transitive callers (default: 5)"),
+    hubThreshold: z.number().optional().default(10).describe("Minimum caller count to flag a symbol as a hub node (default: 10)"),
+    checkConflicts: z.boolean().optional().default(false).describe("Check for conflicting open PRs touching the same communities (default: false)"),
+    direction: z.enum(["callers", "callees", "both"]).optional().default("both").describe("Call-graph traversal direction: 'callers' for upstream, 'callees' for downstream, 'both' for union (default: both)")
+  },
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
+    try {
+      const result = await indexer.getPrImpact({
+        pr: args.pr,
+        branch: args.branch,
+        maxDepth: args.maxDepth,
+        hubThreshold: args.hubThreshold,
+        checkConflicts: args.checkConflicts,
+        direction: args.direction
+      });
+      return formatPrImpact(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `Error analyzing PR impact: ${message}`;
+    }
+  }
+});
+
 // src/tools/knowledge-base-paths.ts
-var path13 = __toESM(require("path"), 1);
+var path14 = __toESM(require("path"), 1);
 function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path13.isAbsolute(trimmed) ? trimmed : path13.resolve(baseDir, trimmed);
-  return path13.normalize(absolutePath);
+  const absolutePath = path14.isAbsolute(trimmed) ? trimmed : path14.resolve(baseDir, trimmed);
+  return path14.normalize(absolutePath);
 }
 function serializeConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  if (!path13.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path13.normalize(trimmed));
+  if (!path14.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path14.normalize(trimmed));
   }
-  const relativePath = path13.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path13.normalize(relativePath || "."));
+  const relativePath = path14.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path14.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path14.normalize(relativePath || "."));
   }
-  return path13.normalize(trimmed);
+  return path14.normalize(trimmed);
 }
 function resolveKnowledgeBasePath(value, projectRoot) {
-  return path13.isAbsolute(value) ? value : path13.resolve(projectRoot, value);
+  return path14.isAbsolute(value) ? value : path14.resolve(projectRoot, value);
 }
 function normalizeKnowledgeBasePath2(value, projectRoot) {
-  return path13.normalize(resolveKnowledgeBasePath(value, projectRoot));
+  return path14.normalize(resolveKnowledgeBasePath(value, projectRoot));
 }
 function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot) {
-  const normalizedInput = path13.normalize(inputPath);
+  const normalizedInput = path14.normalize(inputPath);
   return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput);
 }
 function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
-  const normalizedInput = path13.normalize(inputPath);
+  const normalizedInput = path14.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path13.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
+    (kb) => path14.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
   );
 }
 
 // src/tools/index.ts
 var import_fs9 = require("fs");
-var path15 = __toESM(require("path"), 1);
+var path16 = __toESM(require("path"), 1);
 
 // src/tools/config-state.ts
 var import_fs8 = require("fs");
-var path14 = __toESM(require("path"), 1);
+var path15 = __toESM(require("path"), 1);
 function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -10526,8 +10938,8 @@ function loadEditableConfig(projectRoot) {
 }
 function saveConfig(projectRoot, config) {
   const configPath = getConfigPath(projectRoot);
-  const configDir = path14.dirname(configPath);
-  const configBaseDir = path14.dirname(configDir);
+  const configDir = path15.dirname(configPath);
+  const configBaseDir = path15.dirname(configDir);
   if (!(0, import_fs8.existsSync)(configDir)) {
     (0, import_fs8.mkdirSync)(configDir, { recursive: true });
   }
@@ -10545,7 +10957,7 @@ var os5 = __toESM(require("os"), 1);
 function ensureStringArray(value) {
   return Array.isArray(value) ? value : [];
 }
-var z = import_plugin.tool.schema;
+var z2 = import_plugin2.tool.schema;
 var indexerMap = /* @__PURE__ */ new Map();
 var defaultProjectRoot = "";
 function initializeTools(projectRoot, config) {
@@ -10565,12 +10977,12 @@ function shouldForceLocalizeProjectIndex(projectRoot) {
   if (currentConfig.scope !== "project") {
     return false;
   }
-  const localIndexPath = path15.join(projectRoot, ".opencode", "index");
+  const localIndexPath = path16.join(projectRoot, ".opencode", "index");
   const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
   if (!mainRepoRoot) {
     return false;
   }
-  const inheritedIndexPath = path15.join(mainRepoRoot, ".opencode", "index");
+  const inheritedIndexPath = path16.join(mainRepoRoot, ".opencode", "index");
   return !(0, import_fs9.existsSync)(localIndexPath) && (0, import_fs9.existsSync)(inheritedIndexPath);
 }
 function getIndexerForProject(directory) {
@@ -10586,14 +10998,14 @@ function getIndexerForProject(directory) {
   }
   return indexer;
 }
-var codebase_peek = (0, import_plugin.tool)({
+var codebase_peek = (0, import_plugin2.tool)({
   description: "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Use this first to find WHERE code is, then use Read tool to examine specific files. Saves tokens by not returning full code blocks. Best for: discovery, navigation, finding multiple related locations.",
   args: {
-    query: z.string().describe("Natural language description of what code you're looking for."),
-    limit: z.number().optional().default(10).describe("Maximum number of results to return"),
-    fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type")
+    query: z2.string().describe("Natural language description of what code you're looking for."),
+    limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
+    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z2.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
@@ -10606,12 +11018,12 @@ var codebase_peek = (0, import_plugin.tool)({
     return formatCodebasePeek(results);
   }
 });
-var index_codebase = (0, import_plugin.tool)({
+var index_codebase = (0, import_plugin2.tool)({
   description: "Index the codebase for semantic search. Creates vector embeddings of code chunks. Incremental - only re-indexes changed files (~50ms when nothing changed). Run before first codebase_search.",
   args: {
-    force: z.boolean().optional().default(false).describe("Force reindex even if already indexed"),
-    estimateOnly: z.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
-    verbose: z.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
+    force: z2.boolean().optional().default(false).describe("Force reindex even if already indexed"),
+    estimateOnly: z2.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
+    verbose: z2.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
   },
   async execute(args, context) {
     const projectRoot = context?.worktree || defaultProjectRoot;
@@ -10644,7 +11056,7 @@ var index_codebase = (0, import_plugin.tool)({
     return formatIndexStats(stats, args.verbose ?? false);
   }
 });
-var index_status = (0, import_plugin.tool)({
+var index_status = (0, import_plugin2.tool)({
   description: "Check the status of the codebase index. Shows whether the codebase is indexed, how many chunks are stored, and the embedding provider being used.",
   args: {},
   async execute(_args, context) {
@@ -10653,7 +11065,7 @@ var index_status = (0, import_plugin.tool)({
     return formatStatus(status);
   }
 });
-var index_health_check = (0, import_plugin.tool)({
+var index_health_check = (0, import_plugin2.tool)({
   description: "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
   args: {},
   async execute(_args, context) {
@@ -10662,7 +11074,7 @@ var index_health_check = (0, import_plugin.tool)({
     return formatHealthCheck(result);
   }
 });
-var index_metrics = (0, import_plugin.tool)({
+var index_metrics = (0, import_plugin2.tool)({
   description: "Get metrics and performance statistics for the codebase index. Shows indexing stats, search timings, cache hit rates, and API usage. Requires debug.enabled=true and debug.metrics=true in config.",
   args: {},
   async execute(_args, context) {
@@ -10677,12 +11089,12 @@ var index_metrics = (0, import_plugin.tool)({
     return logger.formatMetrics();
   }
 });
-var index_logs = (0, import_plugin.tool)({
+var index_logs = (0, import_plugin2.tool)({
   description: "Get recent debug logs from the codebase indexer. Shows timestamped log entries with level and category. Requires debug.enabled=true in config.",
   args: {
-    limit: z.number().optional().default(20).describe("Maximum number of log entries to return"),
-    category: z.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
-    level: z.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
+    limit: z2.number().optional().default(20).describe("Maximum number of log entries to return"),
+    category: z2.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
+    level: z2.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
@@ -10701,15 +11113,15 @@ var index_logs = (0, import_plugin.tool)({
     return formatLogs(logs);
   }
 });
-var find_similar = (0, import_plugin.tool)({
+var find_similar = (0, import_plugin2.tool)({
   description: "Find code similar to a given snippet. Use for duplicate detection, pattern discovery, or refactoring prep. Paste code and find semantically similar implementations elsewhere in the codebase.",
   args: {
-    code: z.string().describe("The code snippet to find similar code for"),
-    limit: z.number().optional().default(10).describe("Maximum number of results to return"),
-    fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
-    excludeFile: z.string().optional().describe("Exclude results from this file path (useful when searching for duplicates of code from a specific file)")
+    code: z2.string().describe("The code snippet to find similar code for"),
+    limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
+    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z2.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
+    excludeFile: z2.string().optional().describe("Exclude results from this file path (useful when searching for duplicates of code from a specific file)")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
@@ -10725,15 +11137,15 @@ var find_similar = (0, import_plugin.tool)({
     return formatSearchResults(results);
   }
 });
-var codebase_search = (0, import_plugin.tool)({
+var codebase_search = (0, import_plugin2.tool)({
   description: "Search codebase by MEANING, not keywords. Returns full code content. Use when you need to see actual implementation. For just finding WHERE code is (saves ~90% tokens), use codebase_peek instead. For known identifiers like 'validateToken', use grep - it's faster.",
   args: {
-    query: z.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
-    limit: z.number().optional().default(5).describe("Maximum number of results to return"),
-    fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
-    contextLines: z.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
+    query: z2.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
+    limit: z2.number().optional().default(5).describe("Maximum number of results to return"),
+    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z2.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
+    contextLines: z2.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
@@ -10749,13 +11161,13 @@ var codebase_search = (0, import_plugin.tool)({
     return formatSearchResults(results, "score");
   }
 });
-var implementation_lookup = (0, import_plugin.tool)({
+var implementation_lookup = (0, import_plugin2.tool)({
   description: "Jump to symbol definition. Find WHERE something is defined. Returns the authoritative source location(s) for a function, class, method, type, or variable. Prefers real implementation files over tests, docs, examples, and fixtures. Use when you need the definition site, not all usages.",
   args: {
-    query: z.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
-    limit: z.number().optional().default(5).describe("Maximum number of results"),
-    fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
-    directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
+    query: z2.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
+    limit: z2.number().optional().default(5).describe("Maximum number of results"),
+    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
+    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
@@ -10767,13 +11179,13 @@ var implementation_lookup = (0, import_plugin.tool)({
     return formatDefinitionLookup(results, args.query);
   }
 });
-var call_graph = (0, import_plugin.tool)({
+var call_graph = (0, import_plugin2.tool)({
   description: "Query the call graph to find callers or callees of a function/method. Use to understand code flow and dependencies between functions. Supports relationship types: Call, MethodCall, Constructor, Import, Inherits, Implements.",
   args: {
-    name: z.string().describe("Function or method name to query"),
-    direction: z.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
-    symbolId: z.string().optional().describe("Symbol ID (required for 'callees' direction, returned by previous call_graph queries)"),
-    relationshipType: z.enum(["Call", "MethodCall", "Constructor", "Import", "Inherits", "Implements"]).optional().describe("Filter by relationship type. Omit to show all.")
+    name: z2.string().describe("Function or method name to query"),
+    direction: z2.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
+    symbolId: z2.string().optional().describe("Symbol ID (required for 'callees' direction, returned by previous call_graph queries)"),
+    relationshipType: z2.enum(["Call", "MethodCall", "Constructor", "Import", "Inherits", "Implements"]).optional().describe("Filter by relationship type. Omit to show all.")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
@@ -10802,38 +11214,38 @@ var call_graph = (0, import_plugin.tool)({
     return formatted.join("\n");
   }
 });
-var call_graph_path = (0, import_plugin.tool)({
+var call_graph_path = (0, import_plugin2.tool)({
   description: "Find the shortest connection path between two symbols in the call graph. Given a source and target function/method name, returns the chain of calls connecting them.",
   args: {
-    from: z.string().describe("Source function/method name (starting point)"),
-    to: z.string().describe("Target function/method name (destination)"),
-    maxDepth: z.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
+    from: z2.string().describe("Source function/method name (starting point)"),
+    to: z2.string().describe("Target function/method name (destination)"),
+    maxDepth: z2.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject(context?.worktree);
-    const path18 = await indexer.findCallPath(args.from, args.to, args.maxDepth);
-    if (path18.length === 0) {
+    const path19 = await indexer.findCallPath(args.from, args.to, args.maxDepth);
+    if (path19.length === 0) {
       return `No path found between "${args.from}" and "${args.to}". They may be in disconnected components, or the call graph index needs updating.`;
     }
-    const formatted = path18.map((hop, i) => {
+    const formatted = path19.map((hop, i) => {
       const prefix = i === 0 ? "[start]" : `--${hop.callType}-->`;
       const location = hop.filePath ? ` (${hop.filePath}:${hop.line})` : "";
       return `${prefix} ${hop.symbolName}${location}`;
     });
-    return `Path (${path18.length} hops):
+    return `Path (${path19.length} hops):
 ${formatted.join("\n")}`;
   }
 });
-var add_knowledge_base = (0, import_plugin.tool)({
+var add_knowledge_base = (0, import_plugin2.tool)({
   description: "Add a folder as a knowledge base to the semantic search index. The folder will be indexed alongside the main project code. Supports absolute paths or relative paths (relative to the project root).",
   args: {
-    path: z.string().describe("Path to the folder to add as a knowledge base (absolute or relative to project root)")
+    path: z2.string().describe("Path to the folder to add as a knowledge base (absolute or relative to project root)")
   },
   async execute(args, context) {
     const projectRoot = context?.worktree || defaultProjectRoot;
     const inputPath = args.path.trim();
-    const normalizedPath = path15.resolve(
-      path15.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, projectRoot)
+    const normalizedPath = path16.resolve(
+      path16.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, projectRoot)
     );
     if (!(0, import_fs9.existsSync)(normalizedPath)) {
       return `Error: Directory does not exist: ${normalizedPath}`;
@@ -10862,7 +11274,7 @@ var add_knowledge_base = (0, import_plugin.tool)({
       }
     }
     for (const dotDir of sensitiveDotDirs) {
-      const sensitiveDir = path15.join(homeDir, dotDir);
+      const sensitiveDir = path16.join(homeDir, dotDir);
       if (realPath === sensitiveDir || realPath.startsWith(sensitiveDir + "/")) {
         return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath}`;
       }
@@ -10896,7 +11308,7 @@ Run /index to rebuild the index with the new knowledge base.`;
     return result;
   }
 });
-var list_knowledge_bases = (0, import_plugin.tool)({
+var list_knowledge_bases = (0, import_plugin2.tool)({
   description: "List all configured knowledge base folders that are indexed alongside the main project.",
   args: {},
   async execute(_args, context) {
@@ -10933,10 +11345,10 @@ var list_knowledge_bases = (0, import_plugin.tool)({
     return result;
   }
 });
-var remove_knowledge_base = (0, import_plugin.tool)({
+var remove_knowledge_base = (0, import_plugin2.tool)({
   description: "Remove a knowledge base folder from the semantic search index.",
   args: {
-    path: z.string().describe("Path of the knowledge base to remove (must match the configured path exactly)")
+    path: z2.string().describe("Path of the knowledge base to remove (must match the configured path exactly)")
   },
   async execute(args, context) {
     const projectRoot = context?.worktree || defaultProjectRoot;
@@ -10978,7 +11390,7 @@ Run /index to rebuild the index without the removed knowledge base.`;
 
 // src/commands/loader.ts
 var import_fs10 = require("fs");
-var path16 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -11004,7 +11416,7 @@ function loadCommandsFromDirectory(commandsDir) {
   }
   const files = (0, import_fs10.readdirSync)(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path16.join(commandsDir, file);
+    const filePath = path17.join(commandsDir, file);
     let content;
     try {
       content = (0, import_fs10.readFileSync)(filePath, "utf-8");
@@ -11013,7 +11425,7 @@ function loadCommandsFromDirectory(commandsDir) {
       throw new Error(`Failed to load command file ${filePath}: ${message}`);
     }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path16.basename(file, ".md");
+    const name = path17.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -11235,7 +11647,7 @@ function assessRoutingIntent(text) {
     reason: "no_local_discovery_signal"
   };
 }
-function buildRoutingHint(assessment, status) {
+function buildRoutingHint(assessment, status, includeGraphHandoff = false) {
   if (assessment.intent === "definition_lookup") {
     if (!status || !status.indexed || status.compatibility?.compatible === false) {
       return "For this turn, if you need a symbol definition, check `index_status` first and run `index_codebase` if the index is missing or incompatible. Then use `implementation_lookup` for the definition site. Use `grep` for exhaustive literal matches.";
@@ -11246,17 +11658,21 @@ function buildRoutingHint(assessment, status) {
     return null;
   }
   if (!status || !status.indexed || status.compatibility?.compatible === false) {
-    return "For this turn, if local code discovery by behavior is needed, check `index_status` first and run `index_codebase` if the index is missing or incompatible. Use `grep` for exact identifiers or exhaustive matches.";
+    const graphHandoff2 = includeGraphHandoff ? " Use graph tools after semantic discovery identifies relevant symbols." : "";
+    return `For this turn, if local code discovery by behavior is needed, check \`index_status\` first and run \`index_codebase\` if the index is missing or incompatible.${graphHandoff2} Use \`grep\` for exact identifiers or exhaustive matches.`;
   }
-  return "For this turn, prefer `codebase_peek` for local code discovery by behavior or likely location, then use `codebase_search` when you need implementation content. Use `grep` for exact identifiers or exhaustive matches.";
+  const graphHandoff = includeGraphHandoff ? " before graph tools such as `call_graph`, `call_graph_path`, `pr_impact`, or OMO CodeGraph" : "";
+  return `For this turn, prefer \`codebase_peek\` for local code discovery by behavior or likely location${graphHandoff}. Then use \`codebase_search\` when you need implementation content. Use \`grep\` for exact identifiers or exhaustive matches.`;
 }
 var RoutingHintController = class {
-  constructor(getStatus, maxSessions = 200) {
+  constructor(getStatus, maxSessions = 200, includeGraphHandoff = false) {
     this.getStatus = getStatus;
     this.maxSessions = maxSessions;
+    this.includeGraphHandoff = includeGraphHandoff;
   }
   getStatus;
   maxSessions;
+  includeGraphHandoff;
   sessionState = /* @__PURE__ */ new Map();
   observeUserMessage(sessionID, parts) {
     const assessment = assessRoutingIntent(extractUserText(parts));
@@ -11277,7 +11693,7 @@ var RoutingHintController = class {
       return [];
     }
     const status = await this.safeGetStatus();
-    const hint = buildRoutingHint(state.assessment, status);
+    const hint = buildRoutingHint(state.assessment, status, this.includeGraphHandoff);
     return hint ? [hint] : [];
   }
   markToolUsed(sessionID, toolName) {
@@ -11328,9 +11744,9 @@ function replaceActiveWatcher(projectRoot, nextWatcher) {
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import_meta2 !== "undefined" && import_meta2.url) {
-    currentDir = path17.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+    currentDir = path18.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
   }
-  return path17.join(currentDir, "..", "commands");
+  return path18.join(currentDir, "..", "commands");
 }
 function appendRoutingHints(output, hints, preferredRole) {
   const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
@@ -11349,8 +11765,8 @@ var plugin = async ({ directory, worktree }) => {
     const config = parseConfig(rawConfig);
     initializeTools(projectRoot, config);
     const getProjectIndexer = () => getIndexerForProject(projectRoot);
-    const routingHints = config.search.routingHints ? new RoutingHintController(() => getProjectIndexer().getStatus()) : null;
-    const isHomeDir = path17.resolve(projectRoot) === path17.resolve(os6.homedir());
+    const routingHints = config.search.routingHints ? new RoutingHintController(() => getProjectIndexer().getStatus(), 200, config.search.routingGraphHandoffHints) : null;
+    const isHomeDir = path18.resolve(projectRoot) === path18.resolve(os6.homedir());
     const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(projectRoot));
     if (isHomeDir) {
       console.warn(
@@ -11389,7 +11805,8 @@ var plugin = async ({ directory, worktree }) => {
         implementation_lookup,
         add_knowledge_base,
         list_knowledge_bases,
-        remove_knowledge_base
+        remove_knowledge_base,
+        pr_impact
       },
       async "chat.message"(input, output) {
         routingHints?.observeUserMessage(input.sessionID, output.parts);