@frontman-ai/astro 0.4.1 → 0.4.2

package/dist/index.js

@@ -1,6 +1,6 @@
 import * as Fs from 'fs';
 import { existsSync, readFileSync } from 'fs';
-import * as Nodepath from 'path';
+import * as Nodepath4 from 'path';
 import { dirname, join } from 'path';
 import * as Nodebuffer from 'buffer';
 import * as Nodechild_process from 'child_process';
@@ -72,7 +72,7 @@ function forEach(opt, f) {
     return f(valFromOption(opt));
   }
 }
-function getOrThrow(x, message3) {
+function getOrThrow(x, message4) {
   if (x !== void 0) {
     return valFromOption(x);
   } else {
@@ -462,22 +462,22 @@ function create(str) {
 // ../../node_modules/sury/src/Sury.res.mjs
 var immutableEmpty = {};
 var immutableEmpty$1 = [];
-function capitalize(string3) {
-  return string3.slice(0, 1).toUpperCase() + string3.slice(1);
+function capitalize(string4) {
+  return string4.slice(0, 1).toUpperCase() + string4.slice(1);
 }
 var copy = ((d2) => ({ ...d2 }));
-function fromString(string3) {
+function fromString(string4) {
   let _idx = 0;
   while (true) {
     let idx = _idx;
-    let match = string3[idx];
+    let match = string4[idx];
     if (match === void 0) {
-      return `"` + string3 + `"`;
+      return `"` + string4 + `"`;
     }
     switch (match) {
       case '"':
       case "\n":
-        return JSON.stringify(string3);
+        return JSON.stringify(string4);
       default:
         _idx = idx + 1 | 0;
         continue;
@@ -545,14 +545,14 @@ function stringify(unknown2) {
     return "null";
   }
   if (Array.isArray(unknown2)) {
-    let string3 = "[";
+    let string4 = "[";
     for (let i = 0, i_finish = unknown2.length; i < i_finish; ++i) {
       if (i !== 0) {
-        string3 = string3 + ", ";
+        string4 = string4 + ", ";
       }
-      string3 = string3 + stringify(unknown2[i]);
+      string4 = string4 + stringify(unknown2[i]);
     }
-    return string3 + "]";
+    return string4 + "]";
   }
   if (unknown2.constructor !== Object) {
     return Object.prototype.toString.call(unknown2);
@@ -569,9 +569,9 @@ function stringify(unknown2) {
 function toExpression(schema3) {
   let tag = schema3.type;
   let $$const = schema3.const;
-  let name14 = schema3.name;
-  if (name14 !== void 0) {
-    return name14;
+  let name15 = schema3.name;
+  if (name15 !== void 0) {
+    return name15;
   }
   if ($$const !== void 0) {
     return stringify($$const);
@@ -732,8 +732,8 @@ var shakenTraps = {
       return target[prop];
     }
     let l$1 = valFromOption(l);
-    let message3 = `Schema S.` + l$1 + ` is not enabled. To start using it, add S.enable` + capitalize(l$1) + `() at the project root.`;
-    throw new Error(`[Sury] ` + message3);
+    let message4 = `Schema S.` + l$1 + ` is not enabled. To start using it, add S.enable` + capitalize(l$1) + `() at the project root.`;
+    throw new Error(`[Sury] ` + message4);
   }
 };
 function shaken(apiName) {
@@ -1691,10 +1691,10 @@ function isPriority(tagFlag, byKey) {
   }
 }
 function isWiderUnionSchema(schemaAnyOf, inputAnyOf) {
-  return inputAnyOf.every((inputSchema13, idx) => {
+  return inputAnyOf.every((inputSchema14, idx) => {
     let schema3 = schemaAnyOf[idx];
-    if (schema3 !== void 0 && !(flags[inputSchema13.type] & 9152) && inputSchema13.type === schema3.type) {
-      return inputSchema13.const === schema3.const;
+    if (schema3 !== void 0 && !(flags[inputSchema14.type] & 9152) && inputSchema14.type === schema3.type) {
+      return inputSchema14.const === schema3.const;
     } else {
       return false;
     }
@@ -2740,8 +2740,8 @@ function argsToString(args) {
 function stripAnsi(str) {
   return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
 }
-function addLog(state, level, message3, attributes, consoleMethod) {
-  let cleanMessage = stripAnsi(message3).trim();
+function addLog(state, level, message4, attributes, consoleMethod) {
+  let cleanMessage = stripAnsi(message4).trim();
   if (cleanMessage === "") {
     return;
   }
@@ -2818,11 +2818,11 @@ var interceptConsole = (function(state) {
     originalDebug(...args);
   };
 });
-function handleStdoutWrite(state, message3) {
+function handleStdoutWrite(state, message4) {
   try {
-    let matchesPattern2 = state.config.stdoutPatterns.some((pattern2) => message3.includes(pattern2));
+    let matchesPattern2 = state.config.stdoutPatterns.some((pattern2) => message4.includes(pattern2));
     if (matchesPattern2) {
-      return addLog(state, "build", message3, void 0, void 0);
+      return addLog(state, "build", message4, void 0, void 0);
     } else {
       return;
     }
@@ -2834,8 +2834,8 @@ function interceptStdout(_state) {
   (function(_state2) {
     const originalWrite = process.stdout.write.bind(process.stdout);
     process.stdout.write = (chunk, ...args) => {
-      const message3 = typeof chunk === "string" ? chunk : chunk.toString();
-      handleStdoutWrite(_state2, message3);
+      const message4 = typeof chunk === "string" ? chunk : chunk.toString();
+      handleStdoutWrite(_state2, message4);
       return originalWrite(chunk, ...args);
     };
   })(_state);
@@ -3018,10 +3018,10 @@ function endsWithSep(path) {
   }
 }
 function resolve(sourceRoot, inputPath) {
-  let normalizedRoot = Nodepath.normalize(sourceRoot);
-  let rootWithSep = endsWithSep(normalizedRoot) ? normalizedRoot : normalizedRoot + Nodepath.sep;
-  if (Nodepath.isAbsolute(inputPath)) {
-    let normalizedPath = Nodepath.normalize(inputPath);
+  let normalizedRoot = Nodepath4.normalize(sourceRoot);
+  let rootWithSep = endsWithSep(normalizedRoot) ? normalizedRoot : normalizedRoot + Nodepath4.sep;
+  if (Nodepath4.isAbsolute(inputPath)) {
+    let normalizedPath = Nodepath4.normalize(inputPath);
     if (normalizedPath === normalizedRoot || normalizedPath.startsWith(rootWithSep)) {
       return {
         TAG: "Ok",
@@ -3036,7 +3036,7 @@ function resolve(sourceRoot, inputPath) {
       };
     }
   }
-  let fullPath = Nodepath.normalize(Nodepath.join(sourceRoot, inputPath));
+  let fullPath = Nodepath4.normalize(Nodepath4.join(sourceRoot, inputPath));
   if (fullPath === normalizedRoot || fullPath.startsWith(rootWithSep)) {
     return {
       TAG: "Ok",
@@ -3055,7 +3055,7 @@ function toString(safePath) {
   return safePath.path;
 }
 function dirname2(safePath) {
-  return Nodepath.dirname(safePath.path);
+  return Nodepath4.dirname(safePath.path);
 }
 
 // ../frontman-core/src/FrontmanCore__PathContext.res.mjs
@@ -3067,7 +3067,7 @@ function endsWithSep2(path) {
   }
 }
 function toRelativePath(sourceRoot, absolutePath) {
-  let normalizedRoot = endsWithSep2(sourceRoot) ? sourceRoot : sourceRoot + Nodepath.sep;
+  let normalizedRoot = endsWithSep2(sourceRoot) ? sourceRoot : sourceRoot + Nodepath4.sep;
   if (absolutePath.startsWith(normalizedRoot)) {
     return absolutePath.slice(normalizedRoot.length, absolutePath.length);
   } else if (absolutePath.startsWith(sourceRoot)) {
@@ -3080,11 +3080,11 @@ function resolveSearchPath(sourceRoot, inputPath) {
   if (inputPath === void 0) {
     return sourceRoot;
   }
-  if (!Nodepath.isAbsolute(inputPath)) {
-    return Nodepath.join(sourceRoot, inputPath);
+  if (!Nodepath4.isAbsolute(inputPath)) {
+    return Nodepath4.join(sourceRoot, inputPath);
   }
-  let normalizedPath = Nodepath.normalize(inputPath);
-  let normalizedRoot = Nodepath.normalize(sourceRoot);
+  let normalizedPath = Nodepath4.normalize(inputPath);
+  let normalizedRoot = Nodepath4.normalize(sourceRoot);
   if (normalizedPath.startsWith(normalizedRoot)) {
     return normalizedPath;
   } else {
@@ -3828,11 +3828,11 @@ function getMostSignificantDynamicType(segments) {
   });
 }
 async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
-  let fullPath = Nodepath.join(projectRoot, baseDir, currentPath);
+  let fullPath = Nodepath4.join(projectRoot, baseDir, currentPath);
   try {
     let entries = await Fs.promises.readdir(fullPath);
     return (await Promise.all(entries.map(async (entry) => {
-      let entryPath = Nodepath.join(fullPath, entry);
+      let entryPath = Nodepath4.join(fullPath, entry);
       let stats = await Fs.promises.lstat(entryPath);
       if (stats.isSymbolicLink()) {
         return [];
@@ -3841,13 +3841,13 @@ async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
         if (entry.startsWith("_") || entry === "api" || entry === "components") {
           return [];
         } else {
-          return await findPages(baseDir, Nodepath.join(currentPath, entry), projectRoot, sourceRoot);
+          return await findPages(baseDir, Nodepath4.join(currentPath, entry), projectRoot, sourceRoot);
         }
       }
       if (!(entry.endsWith(".astro") || entry.endsWith(".md") || entry.endsWith(".mdx") || entry.endsWith(".html"))) {
         return [];
       }
-      let filePath = Nodepath.join(currentPath, entry);
+      let filePath = Nodepath4.join(currentPath, entry);
       let routePath = fileToRoute(filePath);
       let filePathNoExt = filePath.replace(/\.(astro|md|mdx|html)$/, "");
       let segments = filePathNoExt.replaceAll("\\", "/").split("/");
@@ -4070,7 +4070,8 @@ var ToolNames = {
   grep: "grep",
   fileExists: "file_exists",
   loadAgentInstructions: "load_agent_instructions",
-  lighthouse: "lighthouse"};
+  lighthouse: "lighthouse",
+  listTree: "list_tree"};
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__Grep.res.mjs
 var name6 = ToolNames.grep;
@@ -4365,8 +4366,421 @@ LIMITATIONS:
 - Results limited to max_results (default 20)
 - Binary files are automatically skipped
 - Hidden files (starting with '.') are skipped by default`;
-var name7 = ToolNames.readFile;
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_JSON.js
+function bool3(json3) {
+  if (typeof json3 === "boolean") {
+    return json3;
+  }
+}
+function $$null2(json3) {
+  if (json3 === null) {
+    return null;
+  }
+}
+function string3(json3) {
+  if (typeof json3 === "string") {
+    return json3;
+  }
+}
+function float3(json3) {
+  if (typeof json3 === "number") {
+    return json3;
+  }
+}
+function object2(json3) {
+  if (typeof json3 === "object" && json3 !== null && !Array.isArray(json3)) {
+    return json3;
+  }
+}
+function array3(json3) {
+  if (Array.isArray(json3)) {
+    return json3;
+  }
+}
+var Decode = {
+  bool: bool3,
+  $$null: $$null2,
+  string: string3,
+  float: float3,
+  object: object2,
+  array: array3
+};
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_string.js
+function compare(s1, s2) {
+  if (s1 === s2) {
+    return 0;
+  } else if (s1 < s2) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+async function pathExists(path) {
+  try {
+    await Fs.promises.access(path);
+    return true;
+  } catch (exn) {
+    return false;
+  }
+}
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__ListTree.res.mjs
+var name7 = ToolNames.listTree;
 var inputSchema6 = schema2((s2) => ({
+  path: s2.m(option2(string2)),
+  depth: s2.m(option2(int2))
+}));
+var workspaceSchema = schema2((s2) => ({
+  name: s2.m(string2),
+  path: s2.m(string2)
+}));
+var outputSchema6 = schema2((s2) => ({
+  tree: s2.m(string2),
+  workspaces: s2.m(array2(workspaceSchema)),
+  monorepoType: s2.m(option2(string2))
+}));
+var packageJsonNameSchema = schema2((s2) => ({
+  name: s2.m(option2(string2))
+}));
+var packageJsonWorkspacesObjSchema = schema2((s2) => ({
+  packages: s2.m(option2(array2(string2)))
+}));
+var noiseDirs = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "_build",
+  "deps",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".svelte-kit",
+  ".output",
+  ".nuxt",
+  ".vercel",
+  "__pycache__",
+  "target"
+];
+function makeTrieNode(name15) {
+  return {
+    name: name15,
+    children: {
+      contents: {}
+    },
+    isFile: {
+      contents: false
+    }
+  };
+}
+function buildTrie(files) {
+  let root_children = {
+    contents: {}
+  };
+  let root_isFile = {
+    contents: false
+  };
+  let root = {
+    name: ".",
+    children: root_children,
+    isFile: root_isFile
+  };
+  files.forEach((filePath) => {
+    let parts = filePath.split("/").filter((p2) => p2 !== "");
+    let current = {
+      contents: root
+    };
+    parts.forEach((part, idx) => {
+      let isLast = idx === (parts.length - 1 | 0);
+      let existing = current.contents.children.contents[part];
+      if (existing !== void 0) {
+        if (isLast) {
+          existing.isFile.contents = true;
+        }
+        current.contents = existing;
+        return;
+      }
+      let node = makeTrieNode(part);
+      if (isLast) {
+        node.isFile.contents = true;
+      }
+      current.contents.children.contents[part] = node;
+      current.contents = node;
+    });
+  });
+  return root;
+}
+function getSortedChildren(node) {
+  let entries = Object.entries(node.children.contents).map((param) => {
+    let child = param[1];
+    let hasChildren = Object.keys(child.children.contents).length !== 0;
+    let isDir = hasChildren || !child.isFile.contents;
+    return {
+      entryName: param[0],
+      node: child,
+      isDir
+    };
+  }).filter((e) => !noiseDirs.includes(e.entryName));
+  return entries.toSorted((a, b) => {
+    let match = a.isDir;
+    let match$1 = b.isDir;
+    if (match) {
+      if (!match$1) {
+        return -1;
+      }
+    } else if (match$1) {
+      return 1;
+    }
+    let n = compare(a.entryName, b.entryName);
+    if (n < 0) {
+      return -1;
+    } else if (n > 0) {
+      return 1;
+    } else {
+      return 0;
+    }
+  });
+}
+function renderTree(root, maxDepth, workspacePaths) {
+  let lines = [];
+  let walk = (node, prefix, currentDepth, parentPath) => {
+    if (currentDepth > maxDepth) {
+      return;
+    }
+    let children = getSortedChildren(node);
+    let totalCount = children.length;
+    let truncated = totalCount > 15;
+    let visibleChildren = truncated ? children.slice(0, 10) : children;
+    let visibleCount = visibleChildren.length;
+    visibleChildren.forEach((entry, idx) => {
+      let isLastVisible = idx === (visibleCount - 1 | 0) && !truncated;
+      let connector = isLastVisible ? `\u2514\u2500\u2500 ` : `\u251C\u2500\u2500 `;
+      let childPrefix = isLastVisible ? prefix + "    " : prefix + `\u2502   `;
+      let suffix = entry.isDir ? "/" : "";
+      let entryRelPath = parentPath !== void 0 ? parentPath + "/" + entry.entryName : entry.entryName;
+      let workspaceAnnotation;
+      if (entry.isDir) {
+        let wsName = workspacePaths[entryRelPath];
+        workspaceAnnotation = wsName !== void 0 ? ` [workspace: ` + wsName + `]` : "";
+      } else {
+        workspaceAnnotation = "";
+      }
+      lines.push(prefix + connector + entry.entryName + suffix + workspaceAnnotation);
+      if (entry.isDir) {
+        return walk(entry.node, childPrefix, currentDepth + 1 | 0, entryRelPath);
+      }
+    });
+    if (!truncated) {
+      return;
+    }
+    let remaining = totalCount - 10 | 0;
+    lines.push(prefix + (`\u2514\u2500\u2500 ... and ` + remaining.toString() + ` more entries`));
+  };
+  lines.push(".");
+  walk(root, "", 1, void 0);
+  return lines.join("\n");
+}
+function buildWorkspacePathLookup(workspaces) {
+  let lookup = {};
+  workspaces.forEach((ws) => {
+    lookup[ws.path] = ws.name;
+  });
+  return lookup;
+}
+async function readJsonFile(path) {
+  try {
+    let content = await Fs.promises.readFile(path, "utf8");
+    return {
+      TAG: "Ok",
+      _0: JSON.parse(content)
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to read/parse ` + path + `: ` + msg
+    };
+  }
+}
+async function readPackageName(dirPath) {
+  let pkgPath = Nodepath4.join(dirPath, "package.json");
+  let json3 = await readJsonFile(pkgPath);
+  if (json3.TAG !== "Ok") {
+    return;
+  }
+  try {
+    return parseOrThrow2(json3._0, packageJsonNameSchema).name;
+  } catch (exn) {
+    return;
+  }
+}
+function extractWorkspaceGlobs(json3) {
+  let obj = Decode.object(json3);
+  if (obj === void 0) {
+    return;
+  }
+  let wsJson = obj["workspaces"];
+  if (wsJson === void 0) {
+    return;
+  }
+  try {
+    return parseOrThrow2(wsJson, array2(string2));
+  } catch (exn) {
+    try {
+      return parseOrThrow2(wsJson, packageJsonWorkspacesObjSchema).packages;
+    } catch (exn$1) {
+      return;
+    }
+  }
+}
+async function resolveWorkspaceGlobs(rootPath, globs) {
+  let results = [];
+  await Promise.all(globs.map(async (glob) => {
+    if (glob.endsWith("/*")) {
+      let parentDir = glob.slice(0, glob.length - 2 | 0);
+      let fullParent = Nodepath4.join(rootPath, parentDir);
+      try {
+        let entries = await Fs.promises.readdir(fullParent);
+        await Promise.all(entries.map(async (entry) => {
+          let entryPath = Nodepath4.join(fullParent, entry);
+          let stats = await Fs.promises.stat(entryPath);
+          if (stats.isDirectory()) {
+            results.push(parentDir + "/" + entry);
+            return;
+          }
+        }));
+        return;
+      } catch (raw_exn) {
+        let exn = internalToException(raw_exn);
+        let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+        console.warn(`ListTree: failed to resolve workspace glob "` + glob + `": ` + msg);
+        return;
+      }
+    } else {
+      let fullPath = Nodepath4.join(rootPath, glob);
+      if (await pathExists(fullPath)) {
+        results.push(glob);
+        return;
+      } else {
+        return;
+      }
+    }
+  }));
+  return results;
+}
+async function detectMonorepo(rootPath) {
+  let pkgJsonResult = await readJsonFile(Nodepath4.join(rootPath, "package.json"));
+  let workspaceGlobs;
+  workspaceGlobs = pkgJsonResult.TAG === "Ok" ? extractWorkspaceGlobs(pkgJsonResult._0) : void 0;
+  let hasTurbo = await pathExists(Nodepath4.join(rootPath, "turbo.json"));
+  let hasNx = await pathExists(Nodepath4.join(rootPath, "nx.json"));
+  let hasPnpmWorkspace = await pathExists(Nodepath4.join(rootPath, "pnpm-workspace.yaml"));
+  let monorepoType = hasTurbo ? "turborepo" : hasNx ? "nx" : hasPnpmWorkspace ? "pnpm-workspaces" : workspaceGlobs !== void 0 ? "npm-workspaces" : void 0;
+  let workspaces;
+  if (workspaceGlobs !== void 0) {
+    let resolvedPaths = await resolveWorkspaceGlobs(rootPath, workspaceGlobs);
+    workspaces = await Promise.all(resolvedPaths.map(async (wsPath) => {
+      let fullPath = Nodepath4.join(rootPath, wsPath);
+      let n = await readPackageName(fullPath);
+      let name15 = n !== void 0 ? n : wsPath;
+      return {
+        name: name15,
+        path: wsPath
+      };
+    }));
+  } else {
+    workspaces = [];
+  }
+  return {
+    monorepoType,
+    workspaces
+  };
+}
+async function getTrackedFiles(cwd) {
+  let result = await spawnResult("git", ["ls-files"], cwd);
+  if (result.TAG === "Ok") {
+    let lines = result._0.stdout.trim().split("\n").filter((line) => line !== "");
+    return {
+      TAG: "Ok",
+      _0: lines
+    };
+  }
+  let match = result._0;
+  let match$1 = match.code;
+  if (match$1 === 128) {
+    return {
+      TAG: "Error",
+      _0: `Not a git repository: ` + match.stderr
+    };
+  }
+  return {
+    TAG: "Error",
+    _0: `git ls-files failed: ` + match.stderr
+  };
+}
+async function execute6(ctx2, input) {
+  let path = getOr(input.path, ".");
+  let maxDepth = getOr(input.depth, 3);
+  let err = resolve2(ctx2.sourceRoot, path);
+  if (err.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: formatError(err._0)
+    };
+  }
+  try {
+    let fullPath = err._0.resolvedPath;
+    let filesResult = await getTrackedFiles(fullPath);
+    let files;
+    if (filesResult.TAG === "Ok") {
+      files = filesResult._0;
+    } else {
+      console.warn(`ListTree: ` + filesResult._0 + `, falling back to readdir`);
+      files = await Fs.promises.readdir(fullPath);
+    }
+    let trie = buildTrie(files);
+    let monoInfo = await detectMonorepo(fullPath);
+    let workspacePaths = buildWorkspacePathLookup(monoInfo.workspaces);
+    let tree = renderTree(trie, maxDepth, workspacePaths);
+    return {
+      TAG: "Ok",
+      _0: {
+        tree,
+        workspaces: monoInfo.workspaces,
+        monorepoType: monoInfo.monorepoType
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to list tree for ` + path + `: ` + msg
+    };
+  }
+}
+var description6 = `Returns a text tree view of the project directory structure with monorepo workspace detection.
+
+WHEN TO USE THIS TOOL:
+- Getting oriented in an unfamiliar codebase
+- Understanding monorepo workspace layout and boundaries
+- Exploring a specific subdirectory's structure in depth
+- Prefer this over chaining multiple list_files calls for structure discovery
+
+PARAMETERS:
+- path (optional): Subdirectory to root the tree at. Defaults to "." (project root).
+- depth (optional): Maximum directory depth to display. Defaults to 3.
+
+OUTPUT:
+Returns a text tree with directories and files. Directories end with /.
+Workspace roots are annotated with [workspace: name].
+Respects .gitignore. Skips node_modules, .git, dist, build, etc.`;
+var name8 = ToolNames.readFile;
+var inputSchema7 = schema2((s2) => ({
   path: s2.m(string2),
   offset: s2.m(option2(int2)),
   limit: s2.m(option2(int2))
@@ -4376,13 +4790,13 @@ var pathContextSchema2 = schema2((s2) => ({
   resolvedPath: s2.m(string2),
   relativePath: s2.m(string2)
 }));
-var outputSchema6 = schema2((s2) => ({
+var outputSchema7 = schema2((s2) => ({
   content: s2.m(string2),
   totalLines: s2.m(int2),
   hasMore: s2.m(bool2),
   _context: s2.m(option2(pathContextSchema2))
 }));
-async function execute6(ctx2, input) {
+async function execute7(ctx2, input) {
   let offset = getOr(input.offset, 0);
   let limit = getOr(input.limit, 500);
   let err = resolve2(ctx2.sourceRoot, input.path);
@@ -4423,7 +4837,7 @@ async function execute6(ctx2, input) {
     };
   }
 }
-var description6 = `Reads a file from the filesystem.
+var description7 = `Reads a file from the filesystem.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
@@ -4446,8 +4860,8 @@ function map3(opt, f) {
 }
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__ListFiles.res.mjs
-var name8 = ToolNames.listFiles;
-var inputSchema7 = schema2((s2) => ({
+var name9 = ToolNames.listFiles;
+var inputSchema8 = schema2((s2) => ({
   path: s2.m(option2(string2))
 }));
 var fileEntrySchema = schema2((s2) => ({
@@ -4456,7 +4870,7 @@ var fileEntrySchema = schema2((s2) => ({
   isFile: s2.m(bool2),
   isDirectory: s2.m(bool2)
 }));
-var outputSchema7 = array2(fileEntrySchema);
+var outputSchema8 = array2(fileEntrySchema);
 async function getIgnoredEntries(cwd, entries) {
   if (entries.length === 0) {
     return {
@@ -4511,7 +4925,7 @@ async function getIgnoredEntries(cwd, entries) {
     };
   }
 }
-async function execute7(ctx2, input) {
+async function execute8(ctx2, input) {
   let path = getOr(input.path, ".");
   let err = resolve2(ctx2.sourceRoot, path);
   if (err.TAG !== "Ok") {
@@ -4523,19 +4937,19 @@ async function execute7(ctx2, input) {
   try {
     let fullPath = err._0.resolvedPath;
     let entries = await Fs.promises.readdir(fullPath);
-    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name14) => !ignored.includes(name14)));
+    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name15) => !ignored.includes(name15)));
     if (filteredEntriesResult.TAG !== "Ok") {
       return {
         TAG: "Error",
         _0: filteredEntriesResult._0
       };
     }
-    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name14) => {
-      let entryPath = Nodepath.join(fullPath, name14);
+    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name15) => {
+      let entryPath = Nodepath4.join(fullPath, name15);
       let stats = await Fs.promises.stat(entryPath);
       return {
-        name: name14,
-        path: Nodepath.join(path, name14),
+        name: name15,
+        path: Nodepath4.join(path, name15),
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory()
       };
@@ -4553,14 +4967,23 @@ async function execute7(ctx2, input) {
     };
   }
 }
-var description7 = `Lists files and directories in a given path.
+var description8 = `Lists files and directories in a single directory.
 
-Parameters:
+WHEN TO USE THIS TOOL:
+- Browsing one directory's immediate contents in detail (names, types)
+- Checking what files exist in a specific directory before reading or editing
+- Verifying file organization after making changes
+- Use list_tree instead when you need a multi-level project overview or monorepo layout
+- Use search_files instead when you need to find files by name pattern across the project
+
+PARAMETERS:
 - path (optional): Path to directory - either relative to source root or absolute (must be under source root). Defaults to "." (root directory).
 
-Returns array of entries with name, path, and type information.`;
-var name9 = ToolNames.writeFile;
-var inputSchema8 = schema2((s2) => ({
+OUTPUT:
+Returns array of entries with name, path, and type (file or directory) information.
+Respects .gitignore \u2014 ignored files are excluded from results.`;
+var name10 = ToolNames.writeFile;
+var inputSchema9 = schema2((s2) => ({
   path: s2.m(string2),
   content: s2.m(option2(string2)),
   image_ref: s2.m(option2(string2)),
@@ -4571,7 +4994,7 @@ var pathContextSchema3 = schema2((s2) => ({
   resolvedPath: s2.m(string2),
   relativePath: s2.m(string2)
 }));
-var outputSchema8 = schema2((s2) => ({
+var outputSchema9 = schema2((s2) => ({
   _context: s2.m(option2(pathContextSchema3))
 }));
 function writeContent(resolvedPath, content, encoding) {
@@ -4581,7 +5004,7 @@ function writeContent(resolvedPath, content, encoding) {
   let buffer = Nodebuffer.Buffer.from(content, "base64");
   return Fs.promises.writeFile(resolvedPath, buffer);
 }
-async function execute8(ctx2, input) {
+async function execute9(ctx2, input) {
   let match = input.content;
   let match$1 = input.image_ref;
   if (match === void 0) {
@@ -4635,7 +5058,7 @@ async function execute8(ctx2, input) {
     };
   }
 }
-var description8 = `Writes content to a file.
+var description9 = `Writes content to a file.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
@@ -4646,11 +5069,13 @@ Parameters:
 Provide either content OR image_ref, not both.
 Creates parent directories if they don't exist. Overwrites existing files.
 The _context field provides path resolution details for debugging.`;
-var name10 = ToolNames.fileExists;
-var inputSchema9 = schema2((s2) => ({
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__FileExists.res.mjs
+var name11 = ToolNames.fileExists;
+var inputSchema10 = schema2((s2) => ({
   path: s2.m(string2)
 }));
-async function execute9(ctx2, input) {
+async function execute10(ctx2, input) {
   let msg = resolve(ctx2.sourceRoot, input.path);
   if (msg.TAG !== "Ok") {
     return {
@@ -4658,26 +5083,19 @@ async function execute9(ctx2, input) {
       _0: msg._0
     };
   }
-  try {
-    await Fs.promises.access(toString(msg._0));
-    return {
-      TAG: "Ok",
-      _0: true
-    };
-  } catch (exn) {
-    return {
-      TAG: "Ok",
-      _0: false
-    };
-  }
+  let exists = await pathExists(toString(msg._0));
+  return {
+    TAG: "Ok",
+    _0: exists
+  };
 }
-var description9 = `Checks if a file or directory exists.
+var description10 = `Checks if a file or directory exists.
 
 Parameters:
 - path (required): Path to check - either relative to source root or absolute (must be under source root)
 
 Returns true if the path exists, false otherwise.`;
-var outputSchema9 = bool2;
+var outputSchema10 = bool2;
 
 // ../bindings/src/Lighthouse.res.mjs
 var run = ((url2, flags2) => import('module').then(({ createRequire }) => {
@@ -4718,18 +5136,43 @@ async function killSafely(chrome) {
   }
 }
 
+// ../frontman-core/src/FrontmanCore__ExnUtils.res.mjs
+function message3(exn) {
+  return getOr(flatMap(fromException(exn), message2), "Unknown error");
+}
+
 // ../frontman-core/src/tools/FrontmanCore__Tool__Lighthouse.res.mjs
-var name11 = ToolNames.lighthouse;
-var inputSchema10 = schema2((s2) => ({
+var name12 = ToolNames.lighthouse;
+var presetSchema = union2([
+  literal2("desktop"),
+  literal2("mobile")
+]);
+function presetToString(preset) {
+  if (preset === "desktop") {
+    return "desktop";
+  } else {
+    return "mobile";
+  }
+}
+var inputSchema11 = schema2((s2) => ({
   url: s2.m(string2),
-  preset: s2.m(option2(string2))
+  preset: s2.m(option2(presetSchema))
+}));
+var elementDetailSchema = schema2((s2) => ({
+  selector: s2.m(option2(string2)),
+  snippet: s2.m(option2(string2)),
+  nodeLabel: s2.m(option2(string2)),
+  explanation: s2.m(option2(string2)),
+  url: s2.m(option2(string2)),
+  sourceLocation: s2.m(option2(string2))
 }));
 var auditIssueSchema = schema2((s2) => ({
   id: s2.m(string2),
   title: s2.m(string2),
   description: s2.m(string2),
   score: s2.m(float2),
-  displayValue: s2.m(option2(string2))
+  displayValue: s2.m(option2(string2)),
+  elements: s2.m(array2(elementDetailSchema))
 }));
 var categoryResultSchema = schema2((s2) => ({
   id: s2.m(string2),
@@ -4737,7 +5180,7 @@ var categoryResultSchema = schema2((s2) => ({
   score: s2.m(int2),
   topIssues: s2.m(array2(auditIssueSchema))
 }));
-var outputSchema10 = schema2((s2) => ({
+var outputSchema11 = schema2((s2) => ({
   url: s2.m(string2),
   fetchTime: s2.m(string2),
   categories: s2.m(array2(categoryResultSchema)),
@@ -4750,30 +5193,126 @@ var categoryIds = [
   "best-practices",
   "seo"
 ];
+function getStr(dict3, key) {
+  return flatMap(dict3[key], Decode.string);
+}
+function extractNodeDetail(itemDict) {
+  let n = flatMap(itemDict["node"], Decode.object);
+  let nodeDict;
+  if (n !== void 0) {
+    nodeDict = n;
+  } else {
+    let match = getStr(itemDict, "type");
+    nodeDict = match === "node" ? itemDict : void 0;
+  }
+  if (nodeDict === void 0) {
+    return;
+  }
+  let selector = getStr(nodeDict, "selector");
+  let snippet = getStr(nodeDict, "snippet");
+  let nodeLabel = getStr(nodeDict, "nodeLabel");
+  let explanation = getStr(nodeDict, "explanation");
+  if (selector === void 0 && snippet === void 0) {
+    return;
+  }
+  return {
+    selector,
+    snippet,
+    nodeLabel,
+    explanation,
+    url: void 0,
+    sourceLocation: void 0
+  };
+}
+function extractSourceLocation(itemDict) {
+  let sourceDict = flatMap(itemDict["source"], Decode.object);
+  if (sourceDict === void 0) {
+    return;
+  }
+  let url2 = getStr(sourceDict, "url");
+  if (url2 === void 0) {
+    return;
+  }
+  let line = map(flatMap(sourceDict["line"], Decode.float), (prim) => prim | 0);
+  let col = map(flatMap(sourceDict["column"], Decode.float), (prim) => prim | 0);
+  if (line !== void 0) {
+    if (col !== void 0) {
+      return url2 + `:` + line.toString() + `:` + col.toString();
+    } else {
+      return url2 + `:` + line.toString();
+    }
+  } else {
+    return url2;
+  }
+}
+function extractResourceDetail(itemDict) {
+  let url2 = getStr(itemDict, "url");
+  let sourceLocation = extractSourceLocation(itemDict);
+  if (url2 === void 0 && sourceLocation === void 0) {
+    return;
+  }
+  return {
+    selector: void 0,
+    snippet: void 0,
+    nodeLabel: void 0,
+    explanation: void 0,
+    url: url2,
+    sourceLocation
+  };
+}
+function extractElements(details) {
+  let detailsDict = flatMap(details, Decode.object);
+  if (detailsDict === void 0) {
+    return [];
+  }
+  let arr = flatMap(detailsDict["items"], Decode.array);
+  let items = arr !== void 0 ? arr : [];
+  return filterMap(items, (item) => {
+    let itemDict = Decode.object(item);
+    if (itemDict === void 0) {
+      return;
+    }
+    let result = extractNodeDetail(itemDict);
+    if (result !== void 0) {
+      return result;
+    } else {
+      return extractResourceDetail(itemDict);
+    }
+  }).slice(0, 3);
+}
 function getTopIssues(category, audits, maxIssues) {
   return filterMap(category.auditRefs, (ref) => audits[ref.id]).filter((audit) => {
-    let score = audit.score;
-    if (!(score == null) && (audit.scoreDisplayMode === "binary" || audit.scoreDisplayMode === "numeric" || audit.scoreDisplayMode === "metricSavings")) {
-      return score < 1;
-    } else {
+    let match = audit.scoreDisplayMode;
+    let match$1 = audit.score;
+    switch (match) {
+      case "numeric":
+      case "binary":
+      case "metricSavings":
+        break;
+      default:
+        return false;
+    }
+    if (match$1 == null) {
       return false;
+    } else {
+      return match$1 < 1;
     }
   }).toSorted((a, b) => {
-    let scoreA = getOr(fromNullable(a.score), 0);
-    let scoreB = getOr(fromNullable(b.score), 0);
+    let scoreA = getOrThrow(fromNullable(a.score));
+    let scoreB = getOrThrow(fromNullable(b.score));
     return scoreA - scoreB;
   }).slice(0, maxIssues).map((audit) => ({
     id: audit.id,
     title: audit.title,
     description: audit.description,
-    score: getOr(fromNullable(audit.score), 0),
-    displayValue: audit.displayValue
+    score: getOrThrow(fromNullable(audit.score)),
+    displayValue: audit.displayValue,
+    elements: extractElements(audit.details)
   }));
 }
 function processLhr(lhr) {
   let categories = filterMap(categoryIds, (id) => lhr.categories[id]).map((category) => {
-    let s2 = category.score;
-    let score = !(s2 == null) ? Math.round(s2 * 100) | 0 : 0;
+    let score = Math.round(getOrThrow(fromNullable(category.score)) * 100) | 0;
     let topIssues = getTopIssues(category, lhr.audits, 3);
     return {
       id: category.id,
@@ -4795,13 +5334,16 @@ function processLhr(lhr) {
 }
 async function runLighthouse(chrome, url2, preset) {
   let port2 = chrome.port;
+  let formFactor = presetToString(preset);
+  let tmp;
+  tmp = preset === "desktop";
   let flags_port = port2;
   let flags_output = "json";
   let flags_logLevel = "error";
   let flags_onlyCategories = categoryIds;
-  let flags_formFactor = preset;
+  let flags_formFactor = formFactor;
   let flags_screenEmulation = {
-    disabled: preset === "desktop"
+    disabled: tmp
   };
   let flags_throttlingMethod = "simulate";
   let flags2 = {
@@ -4813,42 +5355,28 @@ async function runLighthouse(chrome, url2, preset) {
     screenEmulation: flags_screenEmulation,
     throttlingMethod: flags_throttlingMethod
   };
+  let result;
   try {
     let runnerResult = await run(url2, flags2);
-    await killSafely(chrome);
-    if (runnerResult == null) {
-      return {
-        TAG: "Error",
-        _0: "Lighthouse returned no results. The URL may be unreachable."
-      };
-    } else {
-      return {
-        TAG: "Ok",
-        _0: processLhr(runnerResult.lhr)
-      };
-    }
+    result = runnerResult == null ? {
+      TAG: "Error",
+      _0: "Lighthouse returned no results. The URL may be unreachable."
+    } : {
+      TAG: "Ok",
+      _0: processLhr(runnerResult.lhr)
+    };
   } catch (raw_exn) {
     let exn = internalToException(raw_exn);
-    await killSafely(chrome);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
-    return {
+    result = {
       TAG: "Error",
-      _0: `Lighthouse audit failed: ` + msg
+      _0: `Lighthouse audit failed: ` + message3(exn)
     };
   }
+  await killSafely(chrome);
+  return result;
 }
-async function execute10(_ctx, input) {
+async function execute11(_ctx, input) {
   let preset = getOr(input.preset, "desktop");
-  switch (preset) {
-    case "desktop":
-    case "mobile":
-      break;
-    default:
-      return {
-        TAG: "Error",
-        _0: `Invalid preset "` + preset + `". Must be "desktop" or "mobile".`
-      };
-  }
   try {
     let chrome = await launch({
       chromeFlags: [
@@ -4861,14 +5389,13 @@ async function execute10(_ctx, input) {
     return await runLighthouse(chrome, input.url, preset);
   } catch (raw_exn) {
     let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
     return {
       TAG: "Error",
-      _0: `Failed to launch Chrome: ` + msg + `. Make sure Chrome is installed on the system.`
+      _0: `Failed to launch Chrome: ` + message3(exn) + `. Make sure Chrome is installed on the system.`
     };
   }
 }
-var description10 = `Runs a Lighthouse audit on a URL to analyze performance, accessibility, best practices, and SEO.
+var description11 = `Runs a Lighthouse audit on a URL to analyze performance, accessibility, best practices, and SEO.
 
 WHEN TO USE THIS TOOL:
 - After making changes that might affect page load performance
@@ -4882,21 +5409,27 @@ PARAMETERS:
   IMPORTANT: Check the current_page context for device_emulation - if a mobile device is being emulated (e.g., iPhone, Pixel), use preset: "mobile" to match the user's testing context.
 
 OUTPUT:
-Returns scores (0-100) for each category plus the top 3 issues to fix in each category.
-Higher scores are better. Issues include actionable descriptions.
+Returns scores (0-100) for each category plus the top 3 worst issues per category.
+Higher scores are better. Each issue includes:
+- A description of the problem
+- Specific offending elements with CSS selectors, HTML snippets, and source locations when available
+Use the selectors and snippets to locate the exact elements that need fixing.
+
+IMPORTANT - ITERATIVE FIXING:
+Only the 3 worst-scoring issues per category are returned. Fixing these may reveal additional issues that were previously ranked lower. After making fixes, re-run the lighthouse audit to check for newly surfaced issues and verify improvements. Repeat until scores are satisfactory.
 
 LIMITATIONS:
 - Requires Chrome to be installed on the system
 - Takes 15-30 seconds to complete
 - Results can vary between runs (\xB15 points is normal)
 - URL must be accessible from the machine running the audit`;
-var name12 = ToolNames.searchFiles;
-var inputSchema11 = schema2((s2) => ({
+var name13 = ToolNames.searchFiles;
+var inputSchema12 = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
   max_results: s2.m(option2(int2))
 }));
-var outputSchema11 = schema2((s2) => ({
+var outputSchema12 = schema2((s2) => ({
   files: s2.m(array2(string2)),
   totalResults: s2.m(int2),
   truncated: s2.m(bool2)
@@ -4946,7 +5479,7 @@ function matchesPattern(fileName2, patternLower) {
 function filterAndPaginate(lines, pattern2, maxResults) {
   let patternLower = pattern2.toLowerCase();
   let matchedFiles = lines.filter((filePath) => {
-    let fileName2 = Nodepath.basename(filePath);
+    let fileName2 = Nodepath4.basename(filePath);
     return matchesPattern(fileName2, patternLower);
   });
   let truncated = matchedFiles.length > maxResults;
@@ -5010,7 +5543,7 @@ async function executeGitLsFiles(pattern2, searchPath, maxResults) {
     _0: `Git ls-files failed: ` + match.stderr
   };
 }
-async function execute11(ctx2, input) {
+async function execute12(ctx2, input) {
   let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
   let maxResults = getOr(input.max_results, 20);
   let rgPath = getRipgrepPath2();
@@ -5024,7 +5557,7 @@ async function execute11(ctx2, input) {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
 }
-var description11 = `Fast file name search tool that finds files matching a pattern.
+var description12 = `Fast file name search tool that finds files matching a pattern.
 
 WHEN TO USE THIS TOOL:
 - Use when you need to find files by name pattern
@@ -5052,15 +5585,15 @@ LIMITATIONS:
 - Hidden files (starting with '.') are included
 - Respects .gitignore when using git ls-files fallback
 - Only finds files, not directories`;
-var name13 = ToolNames.loadAgentInstructions;
-var inputSchema12 = schema2((s2) => ({
+var name14 = ToolNames.loadAgentInstructions;
+var inputSchema13 = schema2((s2) => ({
   startPath: s2.m(option2(string2))
 }));
 var instructionFileSchema = schema2((s2) => ({
   content: s2.m(string2),
   fullPath: s2.m(string2)
 }));
-var outputSchema12 = array2(instructionFileSchema);
+var outputSchema13 = array2(instructionFileSchema);
 var agentsVariants = [
   "Agents.md",
   ".claude/Agents.md",
@@ -5077,7 +5610,7 @@ async function findFileCaseInsensitive(dir, targetFileName) {
     let targetLower = targetFileName.toLowerCase();
     let found = files.find((file) => file.toLowerCase() === targetLower);
     if (found !== void 0) {
-      return Nodepath.join(dir, found);
+      return Nodepath4.join(dir, found);
     } else {
       return;
     }
@@ -5086,8 +5619,8 @@ async function findFileCaseInsensitive(dir, targetFileName) {
   }
 }
 async function loadIfExists(path) {
-  let dir = Nodepath.dirname(path);
-  let fileName2 = Nodepath.basename(path);
+  let dir = Nodepath4.dirname(path);
+  let fileName2 = Nodepath4.basename(path);
   let actualPath = await findFileCaseInsensitive(dir, fileName2);
   if (actualPath === void 0) {
     return;
@@ -5106,7 +5639,7 @@ async function loadVariants(dir, variants) {
   let results = [];
   for (let i = 0, i_finish = variants.length; i < i_finish; ++i) {
     let variant = variants[i];
-    let path = Nodepath.join(dir, variant);
+    let path = Nodepath4.join(dir, variant);
     let file = await loadIfExists(path);
     if (file !== void 0) {
       results.push(file);
@@ -5123,7 +5656,7 @@ async function findAtDirectory(dir) {
   }
 }
 async function walkUpDirectories(current, acc) {
-  let parent = Nodepath.dirname(current);
+  let parent = Nodepath4.dirname(current);
   if (parent === current) {
     return acc;
   }
@@ -5131,7 +5664,7 @@ async function walkUpDirectories(current, acc) {
   let newAcc = acc.concat(filesAtLevel);
   return await walkUpDirectories(parent, newAcc);
 }
-async function execute12(ctx2, input) {
+async function execute13(ctx2, input) {
   let inputPath = getOr(input.startPath, ".");
   let msg = resolve(ctx2.sourceRoot, inputPath);
   if (msg.TAG !== "Ok") {
@@ -5156,7 +5689,7 @@ async function execute12(ctx2, input) {
     };
   }
 }
-var description12 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
+var description13 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
 
 Parameters:
 - startPath (optional): Starting directory for discovery - must be under source root. Defaults to "." (source root).
@@ -5173,22 +5706,6 @@ Discovery:
 function coreTools() {
   return {
     tools: [
-      {
-        name: name7,
-        description: description6,
-        inputSchema: inputSchema6,
-        outputSchema: outputSchema6,
-        execute: execute6,
-        visibleToAgent: true
-      },
-      {
-        name: name9,
-        description: description8,
-        inputSchema: inputSchema8,
-        outputSchema: outputSchema8,
-        execute: execute8,
-        visibleToAgent: true
-      },
       {
         name: name8,
         description: description7,
@@ -5206,11 +5723,27 @@ function coreTools() {
         visibleToAgent: true
       },
       {
-        name: name13,
-        description: description12,
-        inputSchema: inputSchema12,
-        outputSchema: outputSchema12,
-        execute: execute12,
+        name: name9,
+        description: description8,
+        inputSchema: inputSchema8,
+        outputSchema: outputSchema8,
+        execute: execute8,
+        visibleToAgent: true
+      },
+      {
+        name: name11,
+        description: description10,
+        inputSchema: inputSchema10,
+        outputSchema: outputSchema10,
+        execute: execute10,
+        visibleToAgent: true
+      },
+      {
+        name: name14,
+        description: description13,
+        inputSchema: inputSchema13,
+        outputSchema: outputSchema13,
+        execute: execute13,
         visibleToAgent: false
       },
       {
@@ -5221,6 +5754,14 @@ function coreTools() {
         execute: execute5,
         visibleToAgent: true
       },
+      {
+        name: name13,
+        description: description12,
+        inputSchema: inputSchema12,
+        outputSchema: outputSchema12,
+        execute: execute12,
+        visibleToAgent: true
+      },
       {
         name: name12,
         description: description11,
@@ -5229,14 +5770,6 @@ function coreTools() {
         execute: execute11,
         visibleToAgent: true
       },
-      {
-        name: name11,
-        description: description10,
-        inputSchema: inputSchema10,
-        outputSchema: outputSchema10,
-        execute: execute10,
-        visibleToAgent: true
-      },
       {
         name: name3,
         description: description2,
@@ -5244,6 +5777,14 @@ function coreTools() {
         outputSchema: outputSchema2,
         execute: execute2,
         visibleToAgent: true
+      },
+      {
+        name: name7,
+        description: description6,
+        inputSchema: inputSchema6,
+        outputSchema: outputSchema6,
+        execute: execute6,
+        visibleToAgent: true
       }
     ]
   };
@@ -5264,8 +5805,8 @@ function replaceByName(registry, replacement) {
     })
   };
 }
-function getToolByName(registry, name14) {
-  return registry.tools.find((m) => m.name === name14);
+function getToolByName(registry, name15) {
+  return registry.tools.find((m) => m.name === name15);
 }
 function serializeTool(m) {
   return {
@@ -7127,12 +7668,12 @@ var toolCallRequestSchema = schema2((s2) => ({
 var protocolVersion = "1.0";
 
 // ../frontman-core/src/FrontmanCore__Server.res.mjs
-async function executeTool(registry, ctx2, name14, $$arguments) {
-  let toolModule = getToolByName(registry, name14);
+async function executeTool(registry, ctx2, name15, $$arguments) {
+  let toolModule = getToolByName(registry, name15);
   if (toolModule === void 0) {
     return {
       TAG: "ToolNotFound",
-      _0: name14
+      _0: name15
     };
   }
   let toolCtx_projectRoot = ctx2.projectRoot;