@posthog/agent 2.3.363 → 2.3.370

package/dist/agent.js

@@ -63,11 +63,11 @@ var require_tree_sitter = __commonJS({
               throw toThrow;
             };
             var scriptDirectory = "";
-            function locateFile(path14) {
+            function locateFile(path15) {
               if (Module["locateFile"]) {
-                return Module["locateFile"](path14, scriptDirectory);
+                return Module["locateFile"](path15, scriptDirectory);
               }
-              return scriptDirectory + path14;
+              return scriptDirectory + path15;
             }
             var readAsync, readBinary;
             if (ENVIRONMENT_IS_NODE) {
@@ -81,10 +81,10 @@ var require_tree_sitter = __commonJS({
               };
               readAsync = (filename, binary2 = true) => {
                 filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-                return new Promise((resolve4, reject) => {
+                return new Promise((resolve6, reject) => {
                   fs.readFile(filename, binary2 ? void 0 : "utf8", (err2, data) => {
                     if (err2) reject(err2);
-                    else resolve4(binary2 ? data.buffer : data);
+                    else resolve6(binary2 ? data.buffer : data);
                   });
                 });
               };
@@ -125,13 +125,13 @@ var require_tree_sitter = __commonJS({
                 }
                 readAsync = (url) => {
                   if (isFileURI(url)) {
-                    return new Promise((reject, resolve4) => {
+                    return new Promise((reject, resolve6) => {
                       var xhr = new XMLHttpRequest();
                       xhr.open("GET", url, true);
                       xhr.responseType = "arraybuffer";
                       xhr.onload = () => {
                         if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                          resolve4(xhr.response);
+                          resolve6(xhr.response);
                         }
                         reject(xhr.status);
                       };
@@ -1091,8 +1091,8 @@ var require_tree_sitter = __commonJS({
                 }
                 var libFile = locateFile(libName2);
                 if (flags2.loadAsync) {
-                  return new Promise(function(resolve4, reject) {
-                    asyncLoad(libFile, resolve4, reject);
+                  return new Promise(function(resolve6, reject) {
+                    asyncLoad(libFile, resolve6, reject);
                   });
                 }
                 if (!readBinary) {
@@ -3696,15 +3696,15 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path14, isFile, isDirectory) {
-      log(`checking %s`, path14);
+    function check(path15, isFile2, isDirectory) {
+      log(`checking %s`, path15);
       try {
-        const stat = fs_1.statSync(path14);
-        if (stat.isFile() && isFile) {
+        const stat2 = fs_1.statSync(path15);
+        if (stat2.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat.isDirectory() && isDirectory) {
+        if (stat2.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -3719,8 +3719,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path14, type = exports2.READABLE) {
-      return check(path14, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    function exists2(path15, type = exports2.READABLE) {
+      return check(path15, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
     }
     exports2.exists = exists2;
     exports2.FILE = 1;
@@ -3846,17 +3846,17 @@ var Pushable = class {
   resolvers = [];
   done = false;
   push(item) {
-    const resolve4 = this.resolvers.shift();
-    if (resolve4) {
-      resolve4({ value: item, done: false });
+    const resolve6 = this.resolvers.shift();
+    if (resolve6) {
+      resolve6({ value: item, done: false });
     } else {
       this.queue.push(item);
     }
   }
   end() {
     this.done = true;
-    for (const resolve4 of this.resolvers) {
-      resolve4({ value: void 0, done: true });
+    for (const resolve6 of this.resolvers) {
+      resolve6({ value: void 0, done: true });
     }
     this.resolvers = [];
   }
@@ -3873,8 +3873,8 @@ var Pushable = class {
             done: true
           });
         }
-        return new Promise((resolve4) => {
-          this.resolvers.push(resolve4);
+        return new Promise((resolve6) => {
+          this.resolvers.push(resolve6);
         });
       }
     };
@@ -3988,20 +3988,20 @@ function nodeReadableToWebReadable(nodeStream) {
 function nodeWritableToWebWritable(nodeStream) {
   return new WritableStream({
     write(chunk) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve6, reject) => {
         const ok = nodeStream.write(Buffer.from(chunk), (err2) => {
           if (err2) reject(err2);
         });
         if (ok) {
-          resolve4();
+          resolve6();
         } else {
-          nodeStream.once("drain", resolve4);
+          nodeStream.once("drain", resolve6);
         }
       });
     },
     close() {
-      return new Promise((resolve4) => {
-        nodeStream.end(resolve4);
+      return new Promise((resolve6) => {
+        nodeStream.end(resolve6);
       });
     },
     abort(reason) {
@@ -4016,7 +4016,7 @@ function nodeWritableToWebWritable(nodeStream) {
 import { randomUUID } from "crypto";
 import * as fs8 from "fs";
 import * as os4 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -4030,7 +4030,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.363",
+  version: "2.3.370",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -4220,15 +4220,17 @@ function isMethod(method, expected) {
 }
 
 // src/enrichment/file-enricher.ts
-import * as path3 from "path";
+import * as path4 from "path";
 
 // ../enricher/dist/index.js
 var import_web_tree_sitter = __toESM(require_tree_sitter(), 1);
-import { existsSync } from "fs";
+import { statSync } from "fs";
 import * as path from "path";
+import { existsSync } from "fs";
+import * as path2 from "path";
 import { fileURLToPath } from "url";
 import * as fs2 from "fs/promises";
-import * as path2 from "path";
+import * as path3 from "path";
 function getCapture(captures, name2) {
   const found = captures.find((c) => c.name === name2);
   return found ? found.node : null;
@@ -4343,6 +4345,22 @@ function walkNodes(root, type, callback) {
   };
   visit(root);
 }
+var JSX_NODE_TYPES = /* @__PURE__ */ new Set([
+  "jsx_element",
+  "jsx_fragment",
+  "jsx_self_closing_element",
+  "jsx_opening_element",
+  "jsx_closing_element",
+  "jsx_attribute"
+]);
+function isInsideJsx(node) {
+  let cur = node.parent;
+  while (cur) {
+    if (JSX_NODE_TYPES.has(cur.type)) return true;
+    cur = cur.parent;
+  }
+  return false;
+}
 var JS_CAPTURE_METHODS = /* @__PURE__ */ new Set(["capture"]);
 var JS_FLAG_METHODS = /* @__PURE__ */ new Set([
   "getFeatureFlag",
@@ -4528,6 +4546,33 @@ var JS_QUERIES = {
         object: (_) @client
         property: (property_identifier) @method)
       arguments: (arguments . (_) @first_arg)) @call
+  `,
+  imports: `
+    (import_statement
+      (import_clause
+        (identifier) @default_name)
+      source: (string (string_fragment) @source)) @stmt
+
+    (import_statement
+      (import_clause
+        (named_imports
+          (import_specifier
+            name: (identifier) @imported_name) @spec))
+      source: (string (string_fragment) @source)) @stmt
+
+    (import_statement
+      (import_clause
+        (named_imports
+          (import_specifier
+            name: (identifier) @imported_name
+            alias: (identifier) @local_name) @spec))
+      source: (string (string_fragment) @source)) @stmt
+
+    (import_statement
+      (import_clause
+        (namespace_import
+          (identifier) @namespace_name))
+      source: (string (string_fragment) @source)) @stmt
   `
 };
 var PY_QUERIES = {
@@ -4604,6 +4649,31 @@ var PY_QUERIES = {
         object: (_) @client
         attribute: (identifier) @method)
       arguments: (argument_list . (_) @first_arg)) @call
+  `,
+  imports: `
+    (import_from_statement
+      module_name: (dotted_name) @source
+      name: (dotted_name) @imported_name) @stmt
+
+    (import_from_statement
+      module_name: (dotted_name) @source
+      name: (aliased_import
+        name: (dotted_name) @imported_name
+        alias: (identifier) @local_name)) @stmt
+
+    (import_from_statement
+      module_name: (relative_import
+        (import_prefix) @relative_prefix
+        (dotted_name)? @relative_name)
+      name: (dotted_name) @imported_name) @stmt
+
+    (import_from_statement
+      module_name: (relative_import
+        (import_prefix) @relative_prefix
+        (dotted_name)? @relative_name)
+      name: (aliased_import
+        name: (dotted_name) @imported_name
+        alias: (identifier) @local_name)) @stmt
   `
 };
 var GO_QUERIES = {
@@ -4995,7 +5065,7 @@ function buildConstantMap(pm, lang, tree) {
 }
 var POSTHOG_CLASS_NAMES2 = /* @__PURE__ */ new Set(["PostHog", "Posthog"]);
 var GO_CONSTRUCTOR_NAMES2 = /* @__PURE__ */ new Set(["New", "NewWithConfig"]);
-async function findPostHogCalls(pm, source, languageId) {
+async function findPostHogCalls(pm, source, languageId, context) {
   const ready = await pm.ensureReady(languageId);
   if (!ready) {
     return [];
@@ -5024,6 +5094,7 @@ async function findPostHogCalls(pm, source, languageId) {
       const clientNode = getCapture(match.captures, "client");
       const methodNode = getCapture(match.captures, "method");
       const keyNode = getCapture(match.captures, "key");
+      const callNode = getCapture(match.captures, "call");
       if (!clientNode || !methodNode || !keyNode) {
         continue;
       }
@@ -5049,7 +5120,8 @@ async function findPostHogCalls(pm, source, languageId) {
         key: cleanStringValue(keyNode.text),
         line: keyNode.startPosition.row,
         keyStartCol: keyNode.startPosition.column,
-        keyEndCol: keyNode.endPosition.column
+        keyEndCol: keyNode.endPosition.column,
+        inJsx: callNode ? isInsideJsx(callNode) : void 0
       });
     }
   }
@@ -5104,6 +5176,7 @@ async function findPostHogCalls(pm, source, languageId) {
       const methodNode = getCapture(match.captures, "method");
       const propNameNode = getCapture(match.captures, "prop_name");
       const keyNode = getCapture(match.captures, "key");
+      const callNode = getCapture(match.captures, "call");
       if (!clientNode || !methodNode || !propNameNode || !keyNode) {
         continue;
       }
@@ -5126,7 +5199,8 @@ async function findPostHogCalls(pm, source, languageId) {
         key: cleanStringValue(keyNode.text),
         line: keyNode.startPosition.row,
         keyStartCol: keyNode.startPosition.column,
-        keyEndCol: keyNode.endPosition.column
+        keyEndCol: keyNode.endPosition.column,
+        inJsx: callNode ? isInsideJsx(callNode) : void 0
       });
     }
   }
@@ -5223,6 +5297,7 @@ async function findPostHogCalls(pm, source, languageId) {
       for (const match of matches) {
         const funcNode = getCapture(match.captures, "func_name");
         const keyNode = getCapture(match.captures, "key");
+        const callNode = getCapture(match.captures, "call");
         if (!funcNode || !keyNode) {
           continue;
         }
@@ -5233,7 +5308,8 @@ async function findPostHogCalls(pm, source, languageId) {
             key: cleanStringValue(keyNode.text),
             line: keyNode.startPosition.row,
             keyStartCol: keyNode.startPosition.column,
-            keyEndCol: keyNode.endPosition.column
+            keyEndCol: keyNode.endPosition.column,
+            inJsx: callNode ? isInsideJsx(callNode) : void 0
           });
         }
       }
@@ -5247,6 +5323,7 @@ async function findPostHogCalls(pm, source, languageId) {
       for (const match of matches) {
         const funcNode = getCapture(match.captures, "func_name");
         const keyNode = getCapture(match.captures, "key");
+        const callNode = getCapture(match.captures, "call");
         if (!funcNode || !keyNode) {
           continue;
         }
@@ -5256,7 +5333,8 @@ async function findPostHogCalls(pm, source, languageId) {
             key: cleanStringValue(keyNode.text),
             line: keyNode.startPosition.row,
             keyStartCol: keyNode.startPosition.column,
-            keyEndCol: keyNode.endPosition.column
+            keyEndCol: keyNode.endPosition.column,
+            inJsx: callNode ? isInsideJsx(callNode) : void 0
           });
         }
       }
@@ -5271,6 +5349,7 @@ async function findPostHogCalls(pm, source, languageId) {
         const clientNode = getCapture(match.captures, "client");
         const methodNode = getCapture(match.captures, "method");
         const argNode = getCapture(match.captures, "arg_id");
+        const callNode = getCapture(match.captures, "call");
         if (!clientNode || !methodNode || !argNode) {
           continue;
         }
@@ -5300,7 +5379,8 @@ async function findPostHogCalls(pm, source, languageId) {
           key: resolved,
           line,
           keyStartCol: argNode.startPosition.column,
-          keyEndCol: argNode.endPosition.column
+          keyEndCol: argNode.endPosition.column,
+          inJsx: callNode ? isInsideJsx(callNode) : void 0
         });
       }
     }
@@ -5313,6 +5393,7 @@ async function findPostHogCalls(pm, source, languageId) {
       const clientNode = getCapture(match.captures, "client");
       const methodNode = getCapture(match.captures, "method");
       const firstArgNode = getCapture(match.captures, "first_arg");
+      const callNode = getCapture(match.captures, "call");
       if (!clientNode || !methodNode || !firstArgNode) {
         continue;
       }
@@ -5337,13 +5418,167 @@ async function findPostHogCalls(pm, source, languageId) {
         line,
         keyStartCol: firstArgNode.startPosition.column,
         keyEndCol: firstArgNode.endPosition.column,
-        dynamic: true
+        dynamic: true,
+        inJsx: callNode ? isInsideJsx(callNode) : void 0
       });
       matchedLines.add(line);
     }
   }
+  if (context?.wrappersByLocalName?.size) {
+    synthesizeBareWrapperCalls(
+      pm,
+      lang,
+      tree,
+      languageId,
+      context.wrappersByLocalName,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
+  if (context?.namespaceWrappers?.size) {
+    synthesizeNamespaceWrapperCalls(
+      pm,
+      lang,
+      tree,
+      languageId,
+      context.namespaceWrappers,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
   return calls;
 }
+var WRAPPER_BARE_CALL_QUERIES = {
+  javascript: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  javascriptreact: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  typescript: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  typescriptreact: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  python: `(call function: (identifier) @func_name arguments: (argument_list) @args) @call`
+};
+var WRAPPER_NAMESPACE_CALL_QUERIES = {
+  javascript: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  javascriptreact: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  typescript: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  typescriptreact: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  python: `(call function: (attribute object: (identifier) @ns attribute: (identifier) @method) arguments: (argument_list) @args) @call`
+};
+function synthesizeBareWrapperCalls(pm, lang, tree, languageId, wrappers, constantMap, calls, matchedLines) {
+  const queryStr = WRAPPER_BARE_CALL_QUERIES[languageId];
+  if (!queryStr) return;
+  const query2 = pm.getQuery(lang, queryStr);
+  if (!query2) return;
+  for (const match of query2.matches(tree.rootNode)) {
+    const funcNode = getCapture(match.captures, "func_name");
+    const argsNode = getCapture(match.captures, "args");
+    const callNode = getCapture(match.captures, "call");
+    if (!funcNode || !argsNode) continue;
+    const wrapper = wrappers.get(funcNode.text);
+    if (!wrapper) continue;
+    pushWrapperCall(
+      wrapper,
+      funcNode,
+      argsNode,
+      callNode,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
+}
+function synthesizeNamespaceWrapperCalls(pm, lang, tree, languageId, namespaceWrappers, constantMap, calls, matchedLines) {
+  const queryStr = WRAPPER_NAMESPACE_CALL_QUERIES[languageId];
+  if (!queryStr) return;
+  const query2 = pm.getQuery(lang, queryStr);
+  if (!query2) return;
+  for (const match of query2.matches(tree.rootNode)) {
+    const nsNode = getCapture(match.captures, "ns");
+    const methodNode = getCapture(match.captures, "method");
+    const argsNode = getCapture(match.captures, "args");
+    const callNode = getCapture(match.captures, "call");
+    if (!nsNode || !methodNode || !argsNode) continue;
+    const nsWrappers = namespaceWrappers.get(nsNode.text);
+    if (!nsWrappers) continue;
+    const wrapper = nsWrappers.get(methodNode.text);
+    if (!wrapper) continue;
+    pushWrapperCall(
+      wrapper,
+      methodNode,
+      argsNode,
+      callNode,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
+}
+function pushWrapperCall(wrapper, callerNode, argsNode, callNode, constantMap, calls, matchedLines) {
+  let line = callerNode.startPosition.row;
+  let keyStartCol = callerNode.startPosition.column;
+  let keyEndCol = callerNode.endPosition.column;
+  let key = "";
+  let dynamic = false;
+  if (wrapper.classification.kind === "fixed-key") {
+    key = wrapper.classification.key;
+  } else {
+    const positional = argsNode.namedChildren.filter(
+      (c) => c.type !== "comment" && c.type !== "keyword_argument"
+    );
+    const arg = positional[wrapper.classification.paramIndex];
+    if (!arg) return;
+    line = arg.startPosition.row;
+    keyStartCol = arg.startPosition.column;
+    keyEndCol = arg.endPosition.column;
+    if (arg.type === "string") {
+      const fragment = arg.namedChildren.find(
+        (c) => c.type === "string_fragment" || c.type === "string_content"
+      );
+      if (fragment) {
+        key = fragment.text;
+      } else {
+        dynamic = true;
+      }
+    } else if (arg.type === "template_string") {
+      const fragments = arg.namedChildren.filter(
+        (c) => c.type === "string_fragment"
+      );
+      const hasInterp = arg.namedChildren.some(
+        (c) => c.type === "template_substitution"
+      );
+      if (!hasInterp && fragments.length === 1) {
+        key = fragments[0].text;
+      } else {
+        dynamic = true;
+      }
+    } else if (arg.type === "interpreted_string_literal") {
+      key = arg.text.slice(1, -1);
+    } else if (arg.type === "identifier") {
+      const resolved = constantMap.get(arg.text);
+      if (resolved) {
+        key = resolved;
+      } else {
+        dynamic = true;
+      }
+    } else {
+      dynamic = true;
+    }
+  }
+  if (matchedLines.has(line) && dynamic) {
+    return;
+  }
+  calls.push({
+    method: wrapper.posthogMethod,
+    key,
+    line,
+    keyStartCol,
+    keyEndCol,
+    dynamic: dynamic ? true : void 0,
+    viaWrapper: wrapper.name,
+    inJsx: callNode ? isInsideJsx(callNode) : void 0
+  });
+  matchedLines.add(line);
+}
 async function findInitCalls(pm, source, languageId) {
   const ready = await pm.ensureReady(languageId);
   if (!ready) {
@@ -5756,6 +5991,7 @@ async function findFunctions(pm, source, languageId) {
     }
     const params = singleParamNode ? [singleParamNode.text] : paramsNode ? extractParams(paramsNode.text) : [];
     const bodyLine = bodyNode.startPosition.row;
+    const bodyEndLine = bodyNode.endPosition.row;
     const nextLineIdx = bodyLine + 1;
     const lines = text2.split("\n");
     const nextLine = nextLineIdx < lines.length ? lines[nextLineIdx] : "";
@@ -5765,6 +6001,7 @@ async function findFunctions(pm, source, languageId) {
       params,
       isComponent: /^[A-Z]/.test(name2),
       bodyLine,
+      bodyEndLine,
       bodyIndent
     });
   }
@@ -5822,6 +6059,157 @@ async function findFlagAssignments(pm, source, languageId) {
   }
   return assignments;
 }
+var JS_EXTENSION_PROBES = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+];
+var PY_EXTENSION_PROBES = [".py"];
+function isRelativeSpecifier(spec) {
+  return spec.startsWith("./") || spec.startsWith("../") || spec === ".";
+}
+function resolveJsPath(callerAbsPath, specifier) {
+  if (!isRelativeSpecifier(specifier)) return null;
+  const dir = path.dirname(callerAbsPath);
+  const base = path.resolve(dir, specifier);
+  if (JS_EXTENSION_PROBES.includes(path.extname(specifier))) {
+    return isFile(base) ? base : null;
+  }
+  if (isFile(base)) return base;
+  for (const ext of JS_EXTENSION_PROBES) {
+    const candidate = base + ext;
+    if (isFile(candidate)) return candidate;
+  }
+  for (const ext of JS_EXTENSION_PROBES) {
+    const candidate = path.join(base, `index${ext}`);
+    if (isFile(candidate)) return candidate;
+  }
+  return null;
+}
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolvePythonModule(callerAbsPath, relativePrefix, moduleName) {
+  if (!relativePrefix) return null;
+  const dots = relativePrefix.length;
+  const levelsUp = dots - 1;
+  let baseDir = path.dirname(callerAbsPath);
+  for (let i2 = 0; i2 < levelsUp; i2++) {
+    baseDir = path.dirname(baseDir);
+  }
+  if (!moduleName) {
+    const init2 = path.join(baseDir, "__init__.py");
+    return isFile(init2) ? init2 : null;
+  }
+  const parts2 = moduleName.split(".");
+  const joined = path.join(baseDir, ...parts2);
+  for (const ext of PY_EXTENSION_PROBES) {
+    const candidate = joined + ext;
+    if (isFile(candidate)) return candidate;
+  }
+  const pkgInit = path.join(joined, "__init__.py");
+  if (isFile(pkgInit)) return pkgInit;
+  return null;
+}
+async function findImports(pm, source, languageId, callerAbsPath) {
+  const ready = await pm.ensureReady(languageId);
+  if (!ready) return [];
+  const { lang, family } = ready;
+  if (!family.queries.imports) return [];
+  const tree = pm.parse(source, lang);
+  if (!tree) return [];
+  const query2 = pm.getQuery(lang, family.queries.imports);
+  if (!query2) return [];
+  const edges = [];
+  const isPython = languageId === "python";
+  for (const match of query2.matches(tree.rootNode)) {
+    if (isPython) {
+      pushPythonEdge(match.captures, callerAbsPath, edges);
+    } else {
+      pushJsEdge(match.captures, callerAbsPath, edges);
+    }
+  }
+  return dedupe(edges);
+}
+function pushJsEdge(captures, callerAbsPath, out2) {
+  const sourceNode = getCapture(captures, "source");
+  if (!sourceNode) return;
+  const specifier = sourceNode.text;
+  if (!isRelativeSpecifier(specifier)) return;
+  const resolvedAbsPath = resolveJsPath(callerAbsPath, specifier);
+  const defaultNode = getCapture(captures, "default_name");
+  if (defaultNode) {
+    out2.push({
+      localName: defaultNode.text,
+      importedName: "default",
+      isDefault: true,
+      resolvedAbsPath
+    });
+    return;
+  }
+  const namespaceNode = getCapture(captures, "namespace_name");
+  if (namespaceNode) {
+    out2.push({
+      localName: namespaceNode.text,
+      importedName: "*",
+      isNamespace: true,
+      resolvedAbsPath
+    });
+    return;
+  }
+  const importedNode = getCapture(captures, "imported_name");
+  if (importedNode) {
+    const localNode = getCapture(captures, "local_name");
+    out2.push({
+      localName: (localNode ?? importedNode).text,
+      importedName: importedNode.text,
+      resolvedAbsPath
+    });
+  }
+}
+function pushPythonEdge(captures, callerAbsPath, out2) {
+  const importedNode = getCapture(captures, "imported_name");
+  if (!importedNode) return;
+  const relativePrefix = getCapture(captures, "relative_prefix");
+  const relativeName = getCapture(captures, "relative_name");
+  const sourceNode = getCapture(captures, "source");
+  let resolvedAbsPath = null;
+  if (relativePrefix) {
+    resolvedAbsPath = resolvePythonModule(
+      callerAbsPath,
+      relativePrefix.text,
+      relativeName ? relativeName.text : null
+    );
+  } else if (sourceNode) {
+    resolvedAbsPath = resolvePythonModule(callerAbsPath, ".", sourceNode.text);
+  }
+  const localNode = getCapture(captures, "local_name");
+  out2.push({
+    localName: (localNode ?? importedNode).text,
+    importedName: importedNode.text,
+    resolvedAbsPath
+  });
+}
+function dedupe(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const e of edges) {
+    const key = `${e.localName}|${e.importedName}|${e.resolvedAbsPath ?? ""}|${e.isDefault ? "d" : ""}|${e.isNamespace ? "n" : ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out2.push(e);
+  }
+  return out2;
+}
 var noop = {
   warn() {
   }
@@ -5837,17 +6225,18 @@ var DEFAULT_CONFIG = {
 };
 function resolveGrammarsDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  const dir = path.dirname(thisFile);
+  const dir = path2.dirname(thisFile);
   const candidates = [
-    path.join(dir, "..", "grammars"),
-    path.join(dir, "grammars"),
-    path.join(dir, "..", "..", "grammars")
+    path2.join(dir, "..", "grammars"),
+    path2.join(dir, "grammars"),
+    path2.join(dir, "..", "..", "grammars")
   ];
   return candidates.find((p) => existsSync(p)) ?? candidates[0];
 }
 var ParserManager = class {
   parser = null;
   languages = /* @__PURE__ */ new Map();
+  languageKeys = /* @__PURE__ */ new WeakMap();
   queryCache = /* @__PURE__ */ new Map();
   maxCacheSize = 256;
   initPromise = null;
@@ -5866,7 +6255,7 @@ var ParserManager = class {
   async doInit() {
     try {
       await import_web_tree_sitter.default.init({
-        locateFile: (scriptName) => path.join(this.wasmDir, scriptName)
+        locateFile: (scriptName) => path2.join(this.wasmDir, scriptName)
       });
       this.parser = new import_web_tree_sitter.default();
     } catch (err2) {
@@ -5893,9 +6282,10 @@ var ParserManager = class {
     let lang = this.languages.get(family.wasm);
     if (!lang) {
       try {
-        const wasmPath = path.join(this.wasmDir, family.wasm);
+        const wasmPath = path2.join(this.wasmDir, family.wasm);
         lang = await import_web_tree_sitter.default.Language.load(wasmPath);
         this.languages.set(family.wasm, lang);
+        this.languageKeys.set(lang, family.wasm);
       } catch (err2) {
         warn(`Failed to load grammar ${family.wasm}`, err2);
         return null;
@@ -5914,7 +6304,8 @@ var ParserManager = class {
     if (!queryStr.trim()) {
       return null;
     }
-    const cacheKey = `${lang.toString()}:${queryStr}`;
+    const langKey = this.languageKeys.get(lang) ?? lang.toString();
+    const cacheKey = `${langKey}:${queryStr}`;
     let query2 = this.queryCache.get(cacheKey);
     if (query2) {
       this.queryCache.delete(cacheKey);
@@ -5941,6 +6332,7 @@ var ParserManager = class {
     this.parser = null;
     this.initPromise = null;
     this.languages.clear();
+    this.languageKeys = /* @__PURE__ */ new WeakMap();
     this.queryCache.clear();
   }
 };
@@ -6755,6 +7147,260 @@ function isTruthinessCheckForVar(conditionNode, varName) {
   }
   return false;
 }
+var CONTROL_FLOW_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "else"
+]);
+function getKeyArgLocator(method, family, languageId) {
+  if (languageId === "python") {
+    if (family.captureMethods.has(method)) {
+      return { positionalIndex: 1, kwargName: "event" };
+    }
+    if (family.flagMethods.has(method)) {
+      return { positionalIndex: 0, kwargName: "key" };
+    }
+    return null;
+  }
+  if (family.allMethods.has(method)) {
+    return { positionalIndex: 0 };
+  }
+  return null;
+}
+function extractRawParams(paramsNode, singleParamNode, languageId) {
+  if (singleParamNode) {
+    return [singleParamNode.text];
+  }
+  if (!paramsNode) {
+    return [];
+  }
+  const names = [];
+  for (const child of paramsNode.namedChildren) {
+    const n = extractParamName(child, languageId);
+    if (n) {
+      names.push(n);
+    } else {
+      names.push("");
+    }
+  }
+  return names;
+}
+function extractParamName(node, languageId) {
+  switch (node.type) {
+    case "identifier":
+      return node.text;
+    case "required_parameter":
+    case "optional_parameter": {
+      const pat = node.childForFieldName("pattern");
+      if (pat) return extractParamName(pat, languageId);
+      const name2 = node.childForFieldName("name");
+      if (name2) return extractParamName(name2, languageId);
+      const id = node.namedChildren.find((c) => c.type === "identifier");
+      return id?.text ?? null;
+    }
+    case "assignment_pattern": {
+      const left = node.childForFieldName("left");
+      return left ? extractParamName(left, languageId) : null;
+    }
+    case "typed_parameter":
+    case "default_parameter":
+    case "typed_default_parameter": {
+      const name2 = node.childForFieldName("name");
+      if (name2) return extractParamName(name2, languageId);
+      const id = node.namedChildren.find((c) => c.type === "identifier");
+      return id?.text ?? null;
+    }
+    case "parameter": {
+      const id = node.namedChildren.find(
+        (c) => c.type === "identifier" || c.type === "field_identifier"
+      );
+      return id?.text ?? null;
+    }
+    default: {
+      const id = node.namedChildren.find((c) => c.type === "identifier");
+      return id?.text ?? null;
+    }
+  }
+}
+function findPostHogCallInBody(body2, allClients, family, languageId, detectNested) {
+  let found = null;
+  const visit = (node) => {
+    if (found) return;
+    const call = matchPostHogCall(
+      node,
+      allClients,
+      family,
+      languageId,
+      detectNested
+    );
+    if (call) {
+      found = call;
+      return;
+    }
+    for (const child of node.namedChildren) {
+      if (found) return;
+      visit(child);
+    }
+  };
+  visit(body2);
+  return found;
+}
+function matchPostHogCall(node, allClients, family, languageId, detectNested) {
+  if (node.type !== "call_expression" && node.type !== "call") return null;
+  const funcNode = node.childForFieldName("function");
+  if (!funcNode) return null;
+  let method = null;
+  if (funcNode.type === "member_expression" || funcNode.type === "attribute") {
+    const objNode = funcNode.childForFieldName("object") || funcNode.childForFieldName("operand");
+    const propNode = funcNode.childForFieldName("property") || funcNode.childForFieldName("attribute");
+    if (!objNode || !propNode) return null;
+    const clientName = extractClientName(objNode, detectNested);
+    if (!clientName || !allClients.has(clientName)) return null;
+    method = propNode.text;
+  } else if (funcNode.type === "selector_expression") {
+    const opNode = funcNode.childForFieldName("operand");
+    const fieldNode = funcNode.childForFieldName("field");
+    if (!opNode || !fieldNode) return null;
+    const clientName = extractClientName(opNode, detectNested);
+    if (!clientName || !allClients.has(clientName)) return null;
+    method = fieldNode.text;
+  } else {
+    return null;
+  }
+  if (!method || !family.allMethods.has(method)) return null;
+  const locator = getKeyArgLocator(method, family, languageId);
+  if (!locator) return null;
+  const argsNode = node.childForFieldName("arguments") || node.namedChildren.find(
+    (c) => c.type === "arguments" || c.type === "argument_list"
+  ) || null;
+  if (!argsNode) return null;
+  const { keyNode, kwargName } = pickKeyArg(argsNode, locator);
+  return {
+    method,
+    keyArgNode: keyNode,
+    kwargName
+  };
+}
+function pickKeyArg(argsNode, locator) {
+  const positional = [];
+  let kwargHit = null;
+  let kwargName = null;
+  for (const child of argsNode.namedChildren) {
+    if (child.type === "keyword_argument") {
+      const nameNode = child.childForFieldName("name");
+      const valueNode = child.childForFieldName("value");
+      if (nameNode && valueNode && locator.kwargName && nameNode.text === locator.kwargName) {
+        kwargHit = valueNode;
+        kwargName = nameNode.text;
+      }
+      continue;
+    }
+    positional.push(child);
+  }
+  if (kwargHit) {
+    return { keyNode: kwargHit, kwargName };
+  }
+  const positionalHit = positional[locator.positionalIndex] ?? null;
+  return { keyNode: positionalHit, kwargName: null };
+}
+function classifyKeyArg(keyArgNode, params) {
+  if (!keyArgNode) return null;
+  if (keyArgNode.type === "string" || keyArgNode.type === "interpreted_string_literal") {
+    const key = extractStringFromNode(keyArgNode);
+    return key !== null ? { kind: "fixed-key", key } : null;
+  }
+  if (keyArgNode.type === "template_string") {
+    const hasInterpolation = keyArgNode.namedChildren.some(
+      (c) => c.type === "template_substitution"
+    );
+    if (hasInterpolation) return null;
+    const key = extractStringFromNode(keyArgNode);
+    return key !== null ? { kind: "fixed-key", key } : null;
+  }
+  if (keyArgNode.type === "identifier") {
+    const idx = params.indexOf(keyArgNode.text);
+    if (idx >= 0) return { kind: "pass-through", paramIndex: idx };
+    return null;
+  }
+  return null;
+}
+function getExportStatus(nameNode, languageId) {
+  const defNode = nameNode.parent;
+  if (!defNode) return { isDefaultExport: false, isNamedExport: false };
+  if (languageId === "python") {
+    let cur2 = defNode.parent;
+    while (cur2) {
+      if (cur2.type === "module") {
+        return { isDefaultExport: false, isNamedExport: true };
+      }
+      if (cur2.type === "function_definition" || cur2.type === "class_definition") {
+        return { isDefaultExport: false, isNamedExport: false };
+      }
+      cur2 = cur2.parent;
+    }
+    return { isDefaultExport: false, isNamedExport: false };
+  }
+  let cur = defNode.parent;
+  while (cur) {
+    if (cur.type === "export_statement") {
+      const hasDefault = cur.children.some((c) => c.type === "default");
+      return { isDefaultExport: hasDefault, isNamedExport: !hasDefault };
+    }
+    if (cur.type === "program" || cur.type === "module") break;
+    cur = cur.parent;
+  }
+  return { isDefaultExport: false, isNamedExport: false };
+}
+async function findWrappers(pm, source, languageId) {
+  const ready = await pm.ensureReady(languageId);
+  if (!ready) return [];
+  const { lang, family } = ready;
+  const tree = pm.parse(source, lang);
+  if (!tree) return [];
+  const functionQuery = pm.getQuery(lang, family.queries.functions);
+  if (!functionQuery) return [];
+  const allClients = getEffectiveClients(pm.config);
+  const { clientAliases } = findAliases(pm, lang, tree, family);
+  for (const a of clientAliases) allClients.add(a);
+  const wrappers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of functionQuery.matches(tree.rootNode)) {
+    const nameNode = getCapture(match.captures, "func_name");
+    const paramsNode = getCapture(match.captures, "func_params");
+    const singleParamNode = getCapture(match.captures, "func_single_param");
+    const bodyNode = getCapture(match.captures, "func_body");
+    if (!nameNode || !bodyNode) continue;
+    const name2 = nameNode.text;
+    if (CONTROL_FLOW_KEYWORDS.has(name2)) continue;
+    if (seen.has(name2)) continue;
+    const params = extractRawParams(paramsNode, singleParamNode, languageId);
+    const call = findPostHogCallInBody(
+      bodyNode,
+      allClients,
+      family,
+      languageId,
+      pm.config.detectNestedClients
+    );
+    if (!call) continue;
+    const classification = classifyKeyArg(call.keyArgNode, params);
+    if (!classification) continue;
+    const methodKind = family.captureMethods.has(call.method) ? "capture" : "flag";
+    const posthogMethod = call.method === "Enqueue" ? "capture" : call.method;
+    const exportStatus = getExportStatus(nameNode, languageId);
+    seen.add(name2);
+    wrappers.push({
+      name: name2,
+      methodKind,
+      posthogMethod,
+      classification,
+      ...exportStatus
+    });
+  }
+  return wrappers;
+}
 var PostHogDetector = class {
   pm = new ParserManager();
   updateConfig(config) {
@@ -6766,8 +7412,8 @@ var PostHogDetector = class {
   get supportedLanguages() {
     return this.pm.supportedLanguages;
   }
-  async findPostHogCalls(source, languageId) {
-    return findPostHogCalls(this.pm, source, languageId);
+  async findPostHogCalls(source, languageId, context) {
+    return findPostHogCalls(this.pm, source, languageId, context);
   }
   async findInitCalls(source, languageId) {
     return findInitCalls(this.pm, source, languageId);
@@ -6781,6 +7427,12 @@ var PostHogDetector = class {
   async findFlagAssignments(source, languageId) {
     return findFlagAssignments(this.pm, source, languageId);
   }
+  async findWrappers(source, languageId) {
+    return findWrappers(this.pm, source, languageId);
+  }
+  async findImports(source, languageId, callerAbsPath) {
+    return findImports(this.pm, source, languageId, callerAbsPath);
+  }
   dispose() {
     this.pm.dispose();
   }
@@ -6885,18 +7537,32 @@ function commentPrefix(languageId) {
 }
 function formatFlagComment(flag) {
   const parts2 = [`Flag: "${flag.flagKey}"`];
-  if (flag.flag) {
-    parts2.push(flag.flagType);
-    if (flag.rollout !== null) {
-      parts2.push(`${flag.rollout}% rolled out`);
-    }
-    if (flag.experiment) {
-      const status = flag.experiment.end_date ? "complete" : "running";
-      parts2.push(`Experiment: "${flag.experiment.name}" (${status})`);
-    }
-    if (flag.staleness) {
-      parts2.push(`STALE (${flag.staleness})`);
-    }
+  if (!flag.flag) {
+    parts2.push("not in PostHog");
+    return parts2.join(" \u2014 ");
+  }
+  parts2.push(flag.flagType);
+  parts2.push(flag.flag.active ? "active" : "inactive");
+  if (flag.rollout !== null) {
+    parts2.push(`${flag.rollout}% rolled out`);
+  }
+  if (flag.evaluationStats) {
+    const evals = flag.evaluationStats.evaluations.toLocaleString();
+    const users = flag.evaluationStats.uniqueUsers.toLocaleString();
+    const days = flag.evaluationStats.windowDays;
+    parts2.push(`${evals} evals / ${users} users (${days}d)`);
+  } else if (flag.evaluationStatsError) {
+    parts2.push("eval stats unavailable");
+  }
+  if (flag.experiment) {
+    const status = flag.experiment.end_date ? "complete" : "running";
+    parts2.push(`Experiment: "${flag.experiment.name}" (${status})`);
+  }
+  if (flag.staleness) {
+    parts2.push(`STALE (${flag.staleness})`);
+  }
+  if (flag.url) {
+    parts2.push(flag.url);
   }
   return parts2.join(" \u2014 ");
 }
@@ -6917,21 +7583,25 @@ function formatEventComment(event) {
   return parts2.join(" \u2014 ");
 }
 function buildCommentBody(item, enrichedFlags, enrichedEvents) {
+  let body2 = null;
   if (item.type === "flag") {
     const flag = enrichedFlags.get(item.name);
-    if (flag) return formatFlagComment(flag);
-    return null;
-  }
-  if (item.type === "event") {
+    body2 = flag ? formatFlagComment(flag) : null;
+  } else if (item.type === "event") {
     const event = enrichedEvents.get(item.name);
-    if (event) return formatEventComment(event);
-    if (item.detail) return `Event: ${item.detail}`;
-    return null;
+    if (event) {
+      body2 = formatEventComment(event);
+    } else if (item.detail) {
+      body2 = `Event: ${item.detail}`;
+    }
+  } else if (item.type === "init") {
+    body2 = `Init: token "${item.name}"`;
   }
-  if (item.type === "init") {
-    return `Init: token "${item.name}"`;
+  if (!body2) return null;
+  if (item.viaWrapper) {
+    body2 = `${body2} (via ${item.viaWrapper})`;
   }
-  return null;
+  return body2;
 }
 function formatComments(source, languageId, items, enrichedFlags, enrichedEvents) {
   const prefix = commentPrefix(languageId);
@@ -6942,7 +7612,7 @@ function formatComments(source, languageId, items, enrichedFlags, enrichedEvents
     const targetLine = item.line + offset;
     const body2 = buildCommentBody(item, enrichedFlags, enrichedEvents);
     if (!body2) continue;
-    const comment = `${prefix} [PostHog] ${body2}`;
+    const comment = item.inJsx ? `{/* [PostHog] ${body2} */}` : `${prefix} [PostHog] ${body2}`;
     const indent = lines[targetLine]?.match(/^(\s*)/)?.[1] ?? "";
     lines.splice(targetLine, 0, `${indent}${comment}`);
     offset++;
@@ -6956,15 +7626,32 @@ function formatInlineComments(source, languageId, items, enrichedFlags, enriched
   for (const item of items) {
     const body2 = buildCommentBody(item, enrichedFlags, enrichedEvents);
     if (!body2) continue;
-    const arr = byLine.get(item.line) ?? [];
-    arr.push(body2);
-    byLine.set(item.line, arr);
+    const entry = byLine.get(item.line) ?? { jsxBodies: [], nonJsxBodies: [] };
+    (item.inJsx ? entry.jsxBodies : entry.nonJsxBodies).push(body2);
+    byLine.set(item.line, entry);
   }
-  for (const [lineIdx, bodies] of byLine) {
+  const leadingInserts = [];
+  for (const [lineIdx, { jsxBodies, nonJsxBodies }] of byLine) {
     if (lineIdx < 0 || lineIdx >= lines.length) continue;
-    const suffix = ` ${prefix} [PostHog] ${bodies.join(" | ")}`;
+    if (jsxBodies.length > 0 && nonJsxBodies.length > 0) {
+      const joined2 = [...nonJsxBodies, ...jsxBodies].join(" | ");
+      const indent = lines[lineIdx]?.match(/^(\s*)/)?.[1] ?? "";
+      leadingInserts.push({
+        atLine: lineIdx,
+        text: `${indent}{/* [PostHog] ${joined2} */}`
+      });
+      continue;
+    }
+    const isJsx = jsxBodies.length > 0;
+    const bodies = isJsx ? jsxBodies : nonJsxBodies;
+    const joined = bodies.join(" | ");
+    const suffix = isJsx ? ` {/* [PostHog] ${joined} */}` : ` ${prefix} [PostHog] ${joined}`;
     lines[lineIdx] = `${lines[lineIdx]}${suffix}`;
   }
+  leadingInserts.sort((a, b) => b.atLine - a.atLine);
+  for (const { atLine, text: text2 } of leadingInserts) {
+    lines.splice(atLine, 0, text2);
+  }
   return lines.join("\n");
 }
 var EnrichedResult = class {
@@ -6987,6 +7674,7 @@ var EnrichedResult = class {
       let entry = flagMap.get(check.flagKey);
       if (!entry) {
         const flag = this.context.flags?.get(check.flagKey);
+        const url = this.context.flagUrls?.get(check.flagKey) ?? null;
         entry = {
           flagKey: check.flagKey,
           occurrences: [],
@@ -7002,7 +7690,10 @@ var EnrichedResult = class {
           variants: flag ? extractVariants(flag) : [],
           experiment: experiments.find(
             (e) => e.feature_flag_key === check.flagKey
-          )
+          ),
+          url,
+          evaluationStats: this.context.flagEvaluationStats?.get(check.flagKey),
+          evaluationStatsError: this.context.flagEvaluationStatsError ?? false
         };
         flagMap.set(check.flagKey, entry);
       }
@@ -7060,6 +7751,10 @@ var EnrichedResult = class {
           enriched.flagType = flag.flagType;
           enriched.staleness = flag.staleness;
           enriched.rollout = flag.rollout;
+          enriched.active = flag.flag?.active;
+          enriched.url = flag.url;
+          enriched.evaluations = flag.evaluationStats?.evaluations;
+          enriched.evaluationUsers = flag.evaluationStats?.uniqueUsers;
           if (flag.experiment) {
             enriched.experimentName = flag.experiment.name;
             enriched.experimentStatus = flag.experiment.end_date ? "complete" : "running";
@@ -7126,8 +7821,8 @@ var PostHogApi = class {
   get signal() {
     return AbortSignal.timeout(this.config.timeoutMs ?? 1e4);
   }
-  async get(path32) {
-    const res = await fetch(`${this.baseUrl}${path32}`, {
+  async get(path42) {
+    const res = await fetch(`${this.baseUrl}${path42}`, {
       headers: {
         Authorization: `Bearer ${this.config.apiKey}`,
         "Content-Type": "application/json"
@@ -7136,13 +7831,13 @@ var PostHogApi = class {
     });
     if (!res.ok) {
       throw new Error(
-        `PostHog API error: ${res.status} ${res.statusText} on GET ${path32}`
+        `PostHog API error: ${res.status} ${res.statusText} on GET ${path42}`
       );
     }
     return res.json();
   }
-  async post(path32, body2) {
-    const res = await fetch(`${this.baseUrl}${path32}`, {
+  async post(path42, body2) {
+    const res = await fetch(`${this.baseUrl}${path42}`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.config.apiKey}`,
@@ -7153,7 +7848,7 @@ var PostHogApi = class {
     });
     if (!res.ok) {
       throw new Error(
-        `PostHog API error: ${res.status} ${res.statusText} on POST ${path32}`
+        `PostHog API error: ${res.status} ${res.statusText} on POST ${path42}`
       );
     }
     return res.json();
@@ -7171,11 +7866,11 @@ var PostHogApi = class {
     return data.results;
   }
   async getEventDefinitions(names) {
-    let path32 = "/event_definitions/?limit=500";
+    let path42 = "/event_definitions/?limit=500";
     if (names && names.length > 0) {
-      path32 += `&search=${encodeURIComponent(names.join(","))}`;
+      path42 += `&search=${encodeURIComponent(names.join(","))}`;
     }
-    const data = await this.get(path32);
+    const data = await this.get(path42);
     return data.results;
   }
   async getEventStats(eventNames, daysBack = 30) {
@@ -7211,6 +7906,35 @@ var PostHogApi = class {
     }
     return stats;
   }
+  async getFlagEvaluationStats(flagKeys, daysBack = 7) {
+    if (flagKeys.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const days = Math.max(1, Math.min(365, Math.floor(daysBack)));
+    const query2 = `
+      SELECT
+        properties.$feature_flag AS flag_key,
+        count() AS evaluations,
+        count(DISTINCT person_id) AS unique_users
+      FROM events
+      WHERE event = '$feature_flag_called'
+        AND properties.$feature_flag IN {flagKeys}
+        AND timestamp >= now() - INTERVAL ${days} DAY
+      GROUP BY flag_key
+    `;
+    const data = await this.post("/query/", {
+      query: {
+        kind: "HogQLQuery",
+        query: query2,
+        values: { flagKeys }
+      }
+    });
+    const stats = /* @__PURE__ */ new Map();
+    for (const [flagKey, evaluations, uniqueUsers] of data.results) {
+      stats.set(flagKey, { evaluations, uniqueUsers, windowDays: days });
+    }
+    return stats;
+  }
 };
 var CAPTURE_METHODS = /* @__PURE__ */ new Set(["capture", "Enqueue"]);
 var ParseResult = class {
@@ -7234,14 +7958,18 @@ var ParseResult = class {
     return this.calls.filter((c) => CAPTURE_METHODS.has(c.method)).map((c) => ({
       name: c.key,
       line: c.line,
-      dynamic: c.dynamic ?? false
+      dynamic: c.dynamic ?? false,
+      viaWrapper: c.viaWrapper,
+      inJsx: c.inJsx
     }));
   }
   get flagChecks() {
     return this.calls.filter((c) => !CAPTURE_METHODS.has(c.method)).map((c) => ({
       method: c.method,
       flagKey: c.key,
-      line: c.line
+      line: c.line,
+      viaWrapper: c.viaWrapper,
+      inJsx: c.inJsx
     }));
   }
   get flagKeys() {
@@ -7269,7 +7997,9 @@ var ParseResult = class {
         line: call.line,
         name: call.key,
         method: call.method,
-        detail: call.dynamic ? "dynamic event name" : void 0
+        detail: call.dynamic ? "dynamic event name" : void 0,
+        viaWrapper: call.viaWrapper,
+        inJsx: call.inJsx
       });
     }
     return items.sort((a, b) => a.line - b.line);
@@ -7282,14 +8012,22 @@ var ParseResult = class {
       flagKeys.length > 0 ? api.getFeatureFlags() : Promise.resolve([]),
       flagKeys.length > 0 ? api.getExperiments() : Promise.resolve([]),
       eventNames.length > 0 ? api.getEventDefinitions(eventNames) : Promise.resolve([]),
-      eventNames.length > 0 ? api.getEventStats(eventNames) : Promise.resolve(/* @__PURE__ */ new Map())
+      eventNames.length > 0 ? api.getEventStats(eventNames) : Promise.resolve(/* @__PURE__ */ new Map()),
+      flagKeys.length > 0 ? api.getFlagEvaluationStats(flagKeys, 7) : Promise.resolve(/* @__PURE__ */ new Map())
     ]);
-    const [flagsResult, experimentsResult, eventDefsResult, eventStatsResult] = settled;
+    const [
+      flagsResult,
+      experimentsResult,
+      eventDefsResult,
+      eventStatsResult,
+      flagEvalStatsResult
+    ] = settled;
     const labels = [
       "getFeatureFlags",
       "getExperiments",
       "getEventDefinitions",
-      "getEventStats"
+      "getEventStats",
+      "getFlagEvaluationStats"
     ];
     settled.forEach((r, i2) => {
       if (r.status === "rejected") {
@@ -7300,6 +8038,8 @@ var ParseResult = class {
     const allExperiments = experimentsResult.status === "fulfilled" ? experimentsResult.value : [];
     const allEventDefs = eventDefsResult.status === "fulfilled" ? eventDefsResult.value : [];
     const eventStats = eventStatsResult.status === "fulfilled" ? eventStatsResult.value : /* @__PURE__ */ new Map();
+    const flagEvaluationStats = flagEvalStatsResult.status === "fulfilled" ? flagEvalStatsResult.value : /* @__PURE__ */ new Map();
+    const flagEvaluationStatsError = flagEvalStatsResult.status === "rejected";
     const flagKeySet = new Set(flagKeys);
     const flags2 = new Map(
       allFlags.filter((f) => flagKeySet.has(f.key)).map((f) => [f.key, f])
@@ -7310,18 +8050,34 @@ var ParseResult = class {
     const eventDefinitions = new Map(
       allEventDefs.filter((d) => eventNames.includes(d.name)).map((d) => [d.name, d])
     );
+    const host = config.host.replace(/\/$/, "");
+    const flagUrls = /* @__PURE__ */ new Map();
+    for (const [key, flag] of flags2) {
+      flagUrls.set(
+        key,
+        `${host}/project/${config.projectId}/feature_flags/${flag.id}`
+      );
+    }
     return new EnrichedResult(this, {
       flags: flags2,
       experiments,
       eventDefinitions,
-      eventStats
+      eventStats,
+      flagEvaluationStats,
+      flagEvaluationStatsError,
+      flagUrls
     });
   }
 };
+var MAX_WRAPPER_SOURCE_BYTES = 1e6;
+var WRAPPER_CACHE_MAX = 1024;
+var POSTHOG_LITERAL_REGEX = /posthog/i;
 var PostHogEnricher = class {
   detector = new PostHogDetector();
+  wrapperCache = /* @__PURE__ */ new Map();
   updateConfig(config) {
     this.detector.updateConfig(config);
+    this.wrapperCache.clear();
   }
   isSupported(langId) {
     return this.detector.isSupported(langId);
@@ -7329,9 +8085,9 @@ var PostHogEnricher = class {
   get supportedLanguages() {
     return this.detector.supportedLanguages;
   }
-  async parse(source, languageId) {
+  async parse(source, languageId, context) {
     const results = await Promise.allSettled([
-      this.detector.findPostHogCalls(source, languageId),
+      this.detector.findPostHogCalls(source, languageId, context),
       this.detector.findInitCalls(source, languageId),
       this.detector.findFlagAssignments(source, languageId),
       this.detector.findVariantBranches(source, languageId),
@@ -7362,7 +8118,7 @@ var PostHogEnricher = class {
     );
   }
   async parseFile(filePath) {
-    const ext = path2.extname(filePath).toLowerCase();
+    const ext = path3.extname(filePath).toLowerCase();
     const languageId = EXT_TO_LANG_ID[ext];
     if (!languageId) {
       throw new Error(`Unsupported file extension: ${ext}`);
@@ -7370,8 +8126,70 @@ var PostHogEnricher = class {
     const source = await fs2.readFile(filePath, "utf-8");
     return this.parse(source, languageId);
   }
+  /**
+   * Parse a file for wrapper definitions (functions that directly call PostHog SDK methods).
+   * Results are cached per absolute path + mtime so subsequent calls within the same session
+   * are cheap. Returns [] for unsupported extensions, unreadable files, or files larger than
+   * `MAX_WRAPPER_SOURCE_BYTES`.
+   */
+  async getWrappersForFile(absPath) {
+    const ext = path3.extname(absPath).toLowerCase();
+    const languageId = EXT_TO_LANG_ID[ext];
+    if (!languageId || !this.isSupported(languageId)) {
+      return this.setWrapperCache(absPath, 0, []);
+    }
+    let mtimeMs = 0;
+    try {
+      const stat2 = await fs2.stat(absPath);
+      mtimeMs = stat2.mtimeMs;
+      if (stat2.size > MAX_WRAPPER_SOURCE_BYTES) {
+        return this.setWrapperCache(absPath, mtimeMs, []);
+      }
+    } catch {
+      return this.setWrapperCache(absPath, 0, []);
+    }
+    const cached = this.wrapperCache.get(absPath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      this.touchCache(absPath);
+      return cached.wrappers;
+    }
+    let source;
+    try {
+      source = await fs2.readFile(absPath, "utf-8");
+    } catch {
+      return this.setWrapperCache(absPath, mtimeMs, []);
+    }
+    if (!POSTHOG_LITERAL_REGEX.test(source)) {
+      return this.setWrapperCache(absPath, mtimeMs, []);
+    }
+    const wrappers = await this.detector.findWrappers(source, languageId);
+    return this.setWrapperCache(absPath, mtimeMs, wrappers);
+  }
+  async findImportsInSource(source, languageId, callerAbsPath) {
+    return this.detector.findImports(source, languageId, callerAbsPath);
+  }
+  clearWrapperCache() {
+    this.wrapperCache.clear();
+  }
   dispose() {
     this.detector.dispose();
+    this.wrapperCache.clear();
+  }
+  setWrapperCache(absPath, mtimeMs, wrappers) {
+    if (this.wrapperCache.size >= WRAPPER_CACHE_MAX) {
+      const oldest = this.wrapperCache.keys().next().value;
+      if (oldest !== void 0) {
+        this.wrapperCache.delete(oldest);
+      }
+    }
+    this.wrapperCache.set(absPath, { mtimeMs, wrappers });
+    return wrappers;
+  }
+  touchCache(absPath) {
+    const entry = this.wrapperCache.get(absPath);
+    if (!entry) return;
+    this.wrapperCache.delete(absPath);
+    this.wrapperCache.set(absPath, entry);
   }
 };
 
@@ -7385,14 +8203,25 @@ function createEnrichment(apiConfig, logger) {
   };
 }
 var MAX_ENRICHMENT_BYTES = 1e6;
+var MAX_RELATIVE_IMPORTS = 64;
+var RELATIVE_IMPORT_REGEX = /(?:^|\n)\s*(?:import\b[^\n]*['"]\.{1,2}\/|from\s+\.)/;
+var POSTHOG_LITERAL_REGEX2 = /posthog/i;
 async function enrichFileForAgent(deps, filePath, content) {
   if (!content || content.length > MAX_ENRICHMENT_BYTES) return null;
-  if (!/posthog/i.test(content)) return null;
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   const langId = EXT_TO_LANG_ID[ext];
   if (!langId || !deps.enricher.isSupported(langId)) return null;
+  const hasPostHogLiteral = POSTHOG_LITERAL_REGEX2.test(content);
+  const hasRelativeImport = RELATIVE_IMPORT_REGEX.test(content);
+  let parseContext;
+  if (hasRelativeImport) {
+    const absPath = path4.resolve(filePath);
+    const ctx = await buildWrapperContext(deps, content, langId, absPath);
+    if (ctx) parseContext = ctx;
+  }
+  if (!hasPostHogLiteral && !parseContext) return null;
   try {
-    const parsed = await deps.enricher.parse(content, langId);
+    const parsed = await deps.enricher.parse(content, langId, parseContext);
     if (parsed.calls.length === 0 && parsed.initCalls.length === 0) {
       return null;
     }
@@ -7414,7 +8243,8 @@ async function enrichFileForAgent(deps, filePath, content) {
     }
     deps.logger?.debug("File enriched", {
       filePath,
-      calls: parsed.calls.length
+      calls: parsed.calls.length,
+      viaWrappers: parsed.calls.filter((c) => c.viaWrapper).length
     });
     return annotated;
   } catch (err2) {
@@ -7423,11 +8253,62 @@ async function enrichFileForAgent(deps, filePath, content) {
     return null;
   }
 }
+async function buildWrapperContext(deps, content, langId, absPath) {
+  let edges;
+  try {
+    edges = await deps.enricher.findImportsInSource(content, langId, absPath);
+  } catch (err2) {
+    deps.logger?.debug("Import resolution failed", {
+      absPath,
+      err: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return null;
+  }
+  if (!edges.length) return null;
+  const bounded = edges.slice(0, MAX_RELATIVE_IMPORTS);
+  const wrappersByLocalName = /* @__PURE__ */ new Map();
+  const namespaceWrappers = /* @__PURE__ */ new Map();
+  const resolutions = await Promise.all(
+    bounded.map(async (edge) => {
+      if (!edge.resolvedAbsPath) return null;
+      const wrappers = await deps.enricher.getWrappersForFile(
+        edge.resolvedAbsPath
+      );
+      if (!wrappers.length) return null;
+      return { edge, wrappers };
+    })
+  );
+  for (const entry of resolutions) {
+    if (!entry) continue;
+    const { edge, wrappers } = entry;
+    if (edge.isNamespace) {
+      const nsMap = /* @__PURE__ */ new Map();
+      for (const w of wrappers) {
+        if (w.isNamedExport || w.isDefaultExport) {
+          nsMap.set(w.name, w);
+        }
+      }
+      if (nsMap.size) namespaceWrappers.set(edge.localName, nsMap);
+      continue;
+    }
+    if (edge.isDefault) {
+      const target2 = wrappers.find((w) => w.isDefaultExport);
+      if (target2) wrappersByLocalName.set(edge.localName, target2);
+      continue;
+    }
+    const target = wrappers.find(
+      (w) => w.name === edge.importedName && w.isNamedExport
+    );
+    if (target) wrappersByLocalName.set(edge.localName, target);
+  }
+  if (!wrappersByLocalName.size && !namespaceWrappers.size) return null;
+  return { wrappersByLocalName, namespaceWrappers };
+}
 
 // src/utils/common.ts
 async function withTimeout(operation, timeoutMs) {
   const timeoutPromise = new Promise(
-    (resolve4) => setTimeout(() => resolve4({ result: "timeout" }), timeoutMs)
+    (resolve6) => setTimeout(() => resolve6({ result: "timeout" }), timeoutMs)
   );
   const operationPromise = operation.then((value) => ({
     result: "success",
@@ -7627,7 +8508,7 @@ var BaseAcpAgent = class {
 };
 
 // src/adapters/claude/conversion/acp-to-sdk.ts
-import * as path4 from "path";
+import * as path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function sdkText(value) {
   return { type: "text", text: value };
@@ -7635,7 +8516,7 @@ function sdkText(value) {
 function formatUriAsLink(uri) {
   try {
     if (uri.startsWith("zed://")) {
-      const name2 = path4.basename(uri) || uri;
+      const name2 = path5.basename(uri) || uri;
       return `[@${name2}](${uri})`;
     }
     return uri;
@@ -7646,7 +8527,7 @@ function formatUriAsLink(uri) {
 function formatFileAttachment(uri) {
   try {
     const filePath = fileURLToPath2(uri);
-    const name2 = path4.basename(filePath) || filePath;
+    const name2 = path5.basename(filePath) || filePath;
     return [
       "Attached file available in the workspace:",
       `- name: ${name2}`,
@@ -7758,8 +8639,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path14, oldText, newText) {
-    this.items.push({ type: "diff", path: path14, oldText, newText });
+  diff(path15, oldText, newText) {
+    this.items.push({ type: "diff", path: path15, oldText, newText });
     return this;
   }
   build() {
@@ -7936,7 +8817,7 @@ var createPreToolUseHook = (settingsManager, logger) => async (input, _toolUseID
 
 // src/adapters/claude/conversion/tool-use-to-acp.ts
 import fs3 from "fs";
-import path5 from "path";
+import path6 from "path";
 
 // src/adapters/claude/mcp/tool-metadata.ts
 var mcpToolMetadataCache = /* @__PURE__ */ new Map();
@@ -7946,7 +8827,7 @@ function buildToolKey(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
 }
 function delay(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function fetchMcpToolMetadata(q, logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" })) {
   let retries = 0;
@@ -8022,10 +8903,10 @@ function stripSystemReminders(value) {
 }
 function toDisplayPath(filePath, cwd) {
   if (!cwd) return filePath;
-  const resolvedCwd = path5.resolve(cwd);
-  const resolvedFile = path5.resolve(filePath);
-  if (resolvedFile.startsWith(resolvedCwd + path5.sep) || resolvedFile === resolvedCwd) {
-    return path5.relative(resolvedCwd, resolvedFile);
+  const resolvedCwd = path6.resolve(cwd);
+  const resolvedFile = path6.resolve(filePath);
+  if (resolvedFile.startsWith(resolvedCwd + path6.sep) || resolvedFile === resolvedCwd) {
+    return path6.relative(resolvedCwd, resolvedFile);
   }
   return filePath;
 }
@@ -9165,18 +10046,18 @@ async function handleUserAssistantMessage(message, context) {
 
 // src/adapters/claude/plan/utils.ts
 import * as os from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path6.join(os.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || path7.join(os.homedir(), ".claude");
 }
 function getClaudePlansDir() {
-  return path6.join(getClaudeConfigDir(), "plans");
+  return path7.join(getClaudeConfigDir(), "plans");
 }
 function isClaudePlanFilePath(filePath) {
   if (!filePath) return false;
-  const resolved = path6.resolve(filePath);
-  const plansDir = path6.resolve(getClaudePlansDir());
-  return resolved === plansDir || resolved.startsWith(plansDir + path6.sep);
+  const resolved = path7.resolve(filePath);
+  const plansDir = path7.resolve(getClaudePlansDir());
+  return resolved === plansDir || resolved.startsWith(plansDir + path7.sep);
 }
 function isPlanReady(plan) {
   if (!plan) return false;
@@ -9972,7 +10853,7 @@ function resolveModelPreference(preference, options) {
 import { spawn } from "child_process";
 import * as fs4 from "fs";
 import * as os2 from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/adapters/claude/session/instructions.ts
 var BRANCH_NAMING = `
@@ -10164,8 +11045,8 @@ function buildSpawnWrapper(sessionId, onProcessSpawned, onProcessExited, logger)
   };
 }
 function ensureLocalSettings(cwd) {
-  const claudeDir = path7.join(cwd, ".claude");
-  const localSettingsPath = path7.join(claudeDir, "settings.local.json");
+  const claudeDir = path8.join(cwd, ".claude");
+  const localSettingsPath = path8.join(claudeDir, "settings.local.json");
   try {
     if (!fs4.existsSync(localSettingsPath)) {
       fs4.mkdirSync(claudeDir, { recursive: true });
@@ -10244,8 +11125,8 @@ function buildSessionOptions(params) {
   return options;
 }
 function clearStatsigCache() {
-  const statsigPath = path7.join(
-    process.env.CLAUDE_CONFIG_DIR || path7.join(os2.homedir(), ".claude"),
+  const statsigPath = path8.join(
+    process.env.CLAUDE_CONFIG_DIR || path8.join(os2.homedir(), ".claude"),
     "statsig"
   );
   fs4.rm(statsigPath, { recursive: true, force: true }, () => {
@@ -10255,7 +11136,7 @@ function clearStatsigCache() {
 // src/adapters/claude/session/settings.ts
 import * as fs7 from "fs";
 import * as os3 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 import { minimatch } from "minimatch";
 
 // src/utils/async-mutex.ts
@@ -10267,8 +11148,8 @@ var AsyncMutex = class {
       this.locked = true;
       return;
     }
-    return new Promise((resolve4) => {
-      this.queue.push(resolve4);
+    return new Promise((resolve6) => {
+      this.queue.push(resolve6);
     });
   }
   release() {
@@ -10289,7 +11170,7 @@ var AsyncMutex = class {
 
 // ../git/dist/queries.js
 import * as fs6 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -10328,8 +11209,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path14) {
-  return path14 instanceof String && cache.has(path14);
+function isPathSpec(path15) {
+  return path15 instanceof String && cache.has(path15);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -10418,8 +11299,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path14) {
-  return (0, import_file_exists.exists)(path14, import_file_exists.FOLDER);
+function folderExists(path15) {
+  return (0, import_file_exists.exists)(path15, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -10823,8 +11704,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path14) {
-      return /^\.(git)?$/.test(path14.trim());
+    parser(path15) {
+      return /^\.(git)?$/.test(path15.trim());
     }
   };
 }
@@ -11258,11 +12139,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path14, line, preview] = input.split(NULL);
-    paths.add(path14);
-    (results[path14] = results[path14] || []).push({
+    const [path15, line, preview] = input.split(NULL);
+    paths.add(path15);
+    (results[path15] = results[path15] || []).push({
       line: asNumber(line),
-      path: path14,
+      path: path15,
       preview
     });
   });
@@ -12027,14 +12908,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path14, text2) {
+function parseInit(bare, path15, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path14, false, result[1]);
+    return new InitSummary(bare, path15, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path14, true, result[1]);
+    return new InitSummary(bare, path15, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -12045,7 +12926,7 @@ function parseInit(bare, path14, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path14, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path15, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -12054,9 +12935,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path14, existing, gitDir) {
+      constructor(bare, path15, existing, gitDir) {
         this.bare = bare;
-        this.path = path14;
+        this.path = path15;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -12068,7 +12949,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path14, customArgs) {
+function initTask(bare = false, path15, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -12077,7 +12958,7 @@ function initTask(bare = false, path14, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path14, text2);
+      return parseInit(commands.includes("--bare"), path15, text2);
     }
   };
 }
@@ -12893,12 +13774,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path14, index, working_dir) {
-        this.path = path14;
+      constructor(path15, index, working_dir) {
+        this.path = path15;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path14) || [null, path14, path14];
+          const detail = fromPathRegex.exec(path15) || [null, path15, path15];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -12929,14 +13810,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path14) {
+  function data(index, workingDir, path15) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path14);
+      handler(result, path15);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path14, index, workingDir));
+      result.files.push(new FileStatusSummary(path15, index, workingDir));
     }
   }
 }
@@ -13249,9 +14130,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path14, write) {
+      hashObject(path15, write) {
         return this._runTask(
-          hashObjectTask(path14, write === true),
+          hashObjectTask(path15, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -13604,8 +14485,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path14 = input.trim().replace(/^["']|["']$/g, "");
-  return path14 && normalize(path14);
+  const path15 = input.trim().replace(/^["']|["']$/g, "");
+  return path15 && normalize(path15);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -13919,8 +14800,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path14) {
-  return subModuleTask(["add", repo, path14]);
+function addSubModuleTask(repo, path15) {
+  return subModuleTask(["add", repo, path15]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -14250,8 +15131,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path14, then) {
-      return this._runTask(addSubModuleTask2(repo, path14), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path15, then) {
+      return this._runTask(addSubModuleTask2(repo, path15), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(
@@ -14853,24 +15734,24 @@ function createGitClient(baseDir, options) {
 // ../git/dist/lock-detector.js
 import { execFile } from "child_process";
 import fs5 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 async function getIndexLockPath(repoPath) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "index.lock"], { cwd: repoPath });
-    return path8.resolve(repoPath, stdout.trim());
+    return path9.resolve(repoPath, stdout.trim());
   } catch {
-    return path8.join(repoPath, ".git", "index.lock");
+    return path9.join(repoPath, ".git", "index.lock");
   }
 }
 async function getLockInfo(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
   try {
-    const stat = await fs5.stat(lockPath);
+    const stat2 = await fs5.stat(lockPath);
     return {
       path: lockPath,
-      ageMs: Date.now() - stat.mtimeMs
+      ageMs: Date.now() - stat2.mtimeMs
     };
   } catch {
     return null;
@@ -14905,10 +15786,10 @@ var AsyncReaderWriterLock = class {
       this.readers++;
       return;
     }
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       this.readQueue.push(() => {
         this.readers++;
-        resolve4();
+        resolve6();
       });
     });
   }
@@ -14922,11 +15803,11 @@ var AsyncReaderWriterLock = class {
       return;
     }
     this.writerWaiting = true;
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       this.writeQueue.push(() => {
         this.writerWaiting = this.writeQueue.length > 0;
         this.writer = true;
-        resolve4();
+        resolve6();
       });
     });
   }
@@ -15127,13 +16008,13 @@ function parseRule(rule) {
 function normalizePath(filePath, cwd) {
   let resolved = filePath;
   if (resolved.startsWith("~/")) {
-    resolved = path10.join(os3.homedir(), resolved.slice(2));
+    resolved = path11.join(os3.homedir(), resolved.slice(2));
   } else if (resolved.startsWith("./")) {
-    resolved = path10.join(cwd, resolved.slice(2));
-  } else if (!path10.isAbsolute(resolved)) {
-    resolved = path10.join(cwd, resolved);
+    resolved = path11.join(cwd, resolved.slice(2));
+  } else if (!path11.isAbsolute(resolved)) {
+    resolved = path11.join(cwd, resolved);
   }
-  return path10.normalize(resolved).replace(/\\/g, "/");
+  return path11.normalize(resolved).replace(/\\/g, "/");
 }
 function matchesGlob(pattern, filePath, cwd) {
   const normalizedPattern = normalizePath(pattern, cwd);
@@ -15254,11 +16135,11 @@ var SettingsManager = class {
     return this.initPromise;
   }
   getUserSettingsPath() {
-    const configDir = process.env.CLAUDE_CONFIG_DIR || path10.join(os3.homedir(), ".claude");
-    return path10.join(configDir, "settings.json");
+    const configDir = process.env.CLAUDE_CONFIG_DIR || path11.join(os3.homedir(), ".claude");
+    return path11.join(configDir, "settings.json");
   }
   getProjectSettingsPath() {
-    return path10.join(this.cwd, ".claude", "settings.json");
+    return path11.join(this.cwd, ".claude", "settings.json");
   }
   /**
    * Local settings are anchored to the primary worktree so every worktree of
@@ -15266,7 +16147,7 @@ var SettingsManager = class {
    * avoids re-prompting for the same permission in every worktree.
    */
   getLocalSettingsPath() {
-    return path10.join(this.repoRoot, ".claude", "settings.local.json");
+    return path11.join(this.repoRoot, ".claude", "settings.local.json");
   }
   async loadAllSettings() {
     this.repoRoot = await resolveMainRepoPath(this.cwd);
@@ -15384,7 +16265,7 @@ var SettingsManager = class {
       }
       permissions.allow = Array.from(current2);
       const next = { ...existing, permissions };
-      await fs7.promises.mkdir(path10.dirname(filePath), { recursive: true });
+      await fs7.promises.mkdir(path11.dirname(filePath), { recursive: true });
       await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.localSettings = next;
@@ -15488,7 +16369,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     };
   }
   async newSession(params) {
-    if (fs8.existsSync(path11.resolve(os4.homedir(), ".claude.json.backup")) && !fs8.existsSync(path11.resolve(os4.homedir(), ".claude.json"))) {
+    if (fs8.existsSync(path12.resolve(os4.homedir(), ".claude.json.backup")) && !fs8.existsSync(path12.resolve(os4.homedir(), ".claude.json"))) {
       throw RequestError2.authRequired();
     }
     const response = await this.createSession(params, {
@@ -15594,8 +16475,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (this.session.promptRunning) {
       this.session.input.push(userMessage);
       const order = this.session.nextPendingOrder++;
-      const cancelled = await new Promise((resolve4) => {
-        this.session.pendingMessages.set(promptUuid, { resolve: resolve4, order });
+      const cancelled = await new Promise((resolve6) => {
+        this.session.pendingMessages.set(promptUuid, { resolve: resolve6, order });
       });
       if (cancelled) {
         return { stopReason: "cancelled" };
@@ -16466,7 +17347,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
    */
   deferBackgroundFetches(q) {
     Promise.all([
-      new Promise((resolve4) => setTimeout(resolve4, 10)).then(
+      new Promise((resolve6) => setTimeout(resolve6, 10)).then(
         () => this.sendAvailableCommandsUpdate()
       ),
       fetchMcpToolMetadata(q, this.logger).then(() => {
@@ -16674,7 +17555,7 @@ function resetUsage(state) {
 // src/adapters/codex/settings.ts
 import * as fs9 from "fs";
 import * as os5 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 var CodexSettingsManager = class {
   cwd;
   settings = { mcpServerNames: [] };
@@ -16685,7 +17566,7 @@ var CodexSettingsManager = class {
   async initialize() {
   }
   getConfigPath() {
-    return path12.join(os5.homedir(), ".codex", "config.toml");
+    return path13.join(os5.homedir(), ".codex", "config.toml");
   }
   loadSettings() {
     const configPath = this.getConfigPath();
@@ -16748,7 +17629,7 @@ function parseCodexToml(content, cwd) {
 // src/adapters/codex/spawn.ts
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { delimiter, dirname as dirname4 } from "path";
+import { delimiter, dirname as dirname5 } from "path";
 function buildConfigArgs(options) {
   const args2 = [];
   args2.push("-c", `features.remote_models=false`);
@@ -16799,7 +17680,7 @@ function spawnCodexProcess(options) {
   }
   const { command, args: args2 } = findCodexBinary(options);
   if (options.binaryPath && existsSync4(options.binaryPath)) {
-    const binDir = dirname4(options.binaryPath);
+    const binDir = dirname5(options.binaryPath);
     env.PATH = `${binDir}${delimiter}${env.PATH ?? ""}`;
   }
   logger.info("Spawning codex-acp process", {
@@ -17638,7 +18519,7 @@ var PostHogAPIClient = class {
 // src/session-log-writer.ts
 import fs10 from "fs";
 import fsp from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -17674,7 +18555,7 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path13.join(
+      const sessionDir = path14.join(
         this.localCachePath,
         "sessions",
         context.runId
@@ -17932,7 +18813,7 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path13.join(
+    const logPath = path14.join(
       this.localCachePath,
       "sessions",
       session.context.runId,
@@ -17951,13 +18832,13 @@ var SessionLogWriter = class _SessionLogWriter {
     }
   }
   static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path13.join(localCachePath, "sessions");
+    const sessionsDir = path14.join(localCachePath, "sessions");
     let deleted = 0;
     try {
       const entries = await fsp.readdir(sessionsDir);
       const now = Date.now();
       for (const entry of entries) {
-        const entryPath = path13.join(sessionsDir, entry);
+        const entryPath = path14.join(sessionsDir, entry);
         try {
           const stats = await fsp.stat(entryPath);
           if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {