@lousy-agents/mcp 5.13.5 → 5.14.0

package/dist/mcp-server.js

@@ -3333,7 +3333,7 @@ class Ajv {
     constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
-        this.formats = {};
+        this.formats = Object.create(null);
         this._compilations = new Set();
         this._loading = {};
         this._cache = new Map();
@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-832(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+8050(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -26562,7 +26562,7 @@ function isPathWithinRoot(rootPath, candidatePath) {
 }
 /**
  * Ensures existing path segments under targetDir are not symbolic links.
- */ async function assertPathHasNoSymbolicLinks(targetDir, absolutePath) {
+ */ async function file_system_utils_assertPathHasNoSymbolicLinks(targetDir, absolutePath) {
     const rootPath = await (0,promises_.realpath)(targetDir);
     if (!isPathWithinRoot(rootPath, absolutePath)) {
         throw new Error(`Resolved path is outside target directory: ${absolutePath}`);
@@ -26592,7 +26592,7 @@ function isPathWithinRoot(rootPath, candidatePath) {
  * Resolves a relative path under targetDir and validates it does not pass through symlinks.
  */ async function file_system_utils_resolveSafePath(targetDir, relativePath) {
     const resolvedPath = await resolvePathWithinRoot(targetDir, relativePath);
-    await assertPathHasNoSymbolicLinks(targetDir, resolvedPath);
+    await file_system_utils_assertPathHasNoSymbolicLinks(targetDir, resolvedPath);
     return resolvedPath;
 }
 /**
@@ -26778,14 +26778,14 @@ const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
 const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
 const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
 const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
-const sep = "/";
+const pathe_M_eThtNZ_sep = "/";
 const normalize = function(path) {
   if (path.length === 0) {
     return ".";
   }
   path = normalizeWindowsPath(path);
   const isUNCPath = path.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path);
+  const isPathAbsolute = pathe_M_eThtNZ_isAbsolute(path);
   const trailingSeparator = path[path.length - 1] === "/";
   path = normalizeString(path, !isPathAbsolute);
   if (path.length === 0) {
@@ -26806,7 +26806,7 @@ const normalize = function(path) {
     }
     return `//${path}`;
   }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+  return isPathAbsolute && !pathe_M_eThtNZ_isAbsolute(path) ? `/${path}` : path;
 };
 const pathe_M_eThtNZ_join = function(...segments) {
   let path = "";
@@ -26845,10 +26845,10 @@ const pathe_M_eThtNZ_resolve = function(...arguments_) {
       continue;
     }
     resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
+    resolvedAbsolute = pathe_M_eThtNZ_isAbsolute(path);
   }
   resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+  if (resolvedAbsolute && !pathe_M_eThtNZ_isAbsolute(resolvedPath)) {
     return `/${resolvedPath}`;
   }
   return resolvedPath.length > 0 ? resolvedPath : ".";
@@ -26912,7 +26912,7 @@ function normalizeString(path, allowAboveRoot) {
   }
   return res;
 }
-const isAbsolute = function(p) {
+const pathe_M_eThtNZ_isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 const toNamespacedPath = function(p) {
@@ -26923,7 +26923,7 @@ const pathe_M_eThtNZ_extname = function(p) {
   const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
   return match && match[1] || "";
 };
-const relative = function(from, to) {
+const pathe_M_eThtNZ_relative = function(from, to) {
   const _from = pathe_M_eThtNZ_resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
   const _to = pathe_M_eThtNZ_resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
   if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
@@ -26944,7 +26944,7 @@ const pathe_M_eThtNZ_dirname = function(p) {
   if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
     segments[0] += "/";
   }
-  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+  return segments.join("/") || (pathe_M_eThtNZ_isAbsolute(p) ? "/" : ".");
 };
 const pathe_M_eThtNZ_format = function(p) {
   const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
@@ -26989,15 +26989,15 @@ const pathe_M_eThtNZ_path = (/* unused pure expression or super */ null && ({
   dirname: pathe_M_eThtNZ_dirname,
   extname: pathe_M_eThtNZ_extname,
   format: pathe_M_eThtNZ_format,
-  isAbsolute: isAbsolute,
+  isAbsolute: pathe_M_eThtNZ_isAbsolute,
   join: pathe_M_eThtNZ_join,
   matchesGlob: matchesGlob,
   normalize: normalize,
   normalizeString: normalizeString,
   parse: pathe_M_eThtNZ_parse,
-  relative: relative,
+  relative: pathe_M_eThtNZ_relative,
   resolve: pathe_M_eThtNZ_resolve,
-  sep: sep,
+  sep: pathe_M_eThtNZ_sep,
   toNamespacedPath: toNamespacedPath
 }));
 
@@ -28502,371 +28502,317 @@ var jsonc = __webpack_require__(5975);
 
 
 
-
 const defaultFindOptions = {
-  startingFrom: ".",
-  rootPattern: /^node_modules$/,
-  reverse: false,
-  test: (filePath) => {
-    try {
-      if ((0,external_node_fs_.statSync)(filePath).isFile()) {
-        return true;
-      }
-    } catch {
-    }
-  }
+	startingFrom: ".",
+	rootPattern: /^node_modules$/,
+	reverse: false,
+	test: (filePath) => {
+		try {
+			if ((0,external_node_fs_.statSync)(filePath).isFile()) return true;
+		} catch {}
+	}
 };
 async function findFile(filename, _options = {}) {
-  const filenames = Array.isArray(filename) ? filename : [filename];
-  const options = { ...defaultFindOptions, ..._options };
-  const basePath = pathe_M_eThtNZ_resolve(options.startingFrom);
-  const leadingSlash = basePath[0] === "/";
-  const segments = basePath.split("/").filter(Boolean);
-  if (filenames.includes(segments.at(-1)) && await options.test(basePath)) {
-    return basePath;
-  }
-  if (leadingSlash) {
-    segments[0] = "/" + segments[0];
-  }
-  let root = segments.findIndex((r) => r.match(options.rootPattern));
-  if (root === -1) {
-    root = 0;
-  }
-  if (options.reverse) {
-    for (let index = root + 1; index <= segments.length; index++) {
-      for (const filename2 of filenames) {
-        const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  } else {
-    for (let index = segments.length; index > root; index--) {
-      for (const filename2 of filenames) {
-        const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  }
-  throw new Error(
-    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
-  );
+	const filenames = Array.isArray(filename) ? filename : [filename];
+	const options = {
+		...defaultFindOptions,
+		..._options
+	};
+	const basePath = pathe_M_eThtNZ_resolve(options.startingFrom);
+	const leadingSlash = basePath[0] === "/";
+	const segments = basePath.split("/").filter(Boolean);
+	if (filenames.includes(segments.at(-1)) && await options.test(basePath)) return basePath;
+	if (leadingSlash) segments[0] = "/" + segments[0];
+	let root = segments.findIndex((r) => r.match(options.rootPattern));
+	if (root === -1) root = 0;
+	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename of filenames) {
+		const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename);
+		if (await options.test(filePath)) return filePath;
+	}
+	else for (let index = segments.length; index > root; index--) for (const filename of filenames) {
+		const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename);
+		if (await options.test(filePath)) return filePath;
+	}
+	throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
 }
 function findNearestFile(filename, options = {}) {
-  return findFile(filename, options);
+	return findFile(filename, options);
 }
 function findFarthestFile(filename, options = {}) {
-  return findFile(filename, { ...options, reverse: true });
+	return findFile(filename, {
+		...options,
+		reverse: true
+	});
 }
-
 function _resolvePath(id, opts = {}) {
-  if (id instanceof URL || id.startsWith("file://")) {
-    return normalize((0,external_node_url_.fileURLToPath)(id));
-  }
-  if (isAbsolute(id)) {
-    return normalize(id);
-  }
-  return resolveModulePath(id, {
-    ...opts,
-    from: opts.from || opts.parent || opts.url
-  });
+	if (id instanceof URL || id.startsWith("file://")) return normalize((0,external_node_url_.fileURLToPath)(id));
+	if (pathe_M_eThtNZ_isAbsolute(id)) return normalize(id);
+	return resolveModulePath(id, {
+		...opts,
+		from: opts.from || opts.parent || opts.url
+	});
 }
-
 const FileCache$1 = /* @__PURE__ */ (/* unused pure expression or super */ null && (new Map()));
 function defineTSConfig(tsconfig) {
-  return tsconfig;
+	return tsconfig;
 }
 async function readTSConfig(id, options = {}) {
-  const resolvedPath = await resolveTSConfig(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache$1;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const text = await promises.readFile(resolvedPath, "utf8");
-  const parsed = parseJSONC(text);
-  cache.set(resolvedPath, parsed);
-  return parsed;
+	const resolvedPath = await resolveTSConfig(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache$1;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const parsed = parseJSONC(await promises.readFile(resolvedPath, "utf8"));
+	cache.set(resolvedPath, parsed);
+	return parsed;
 }
 async function writeTSConfig(path, tsconfig) {
-  await promises.writeFile(path, stringifyJSONC(tsconfig));
+	await promises.writeFile(path, stringifyJSONC(tsconfig));
 }
 async function resolveTSConfig(id = process.cwd(), options = {}) {
-  return findNearestFile("tsconfig.json", {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile("tsconfig.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
-
 const lockFiles = [
-  "yarn.lock",
-  "package-lock.json",
-  "pnpm-lock.yaml",
-  "npm-shrinkwrap.json",
-  "bun.lockb",
-  "bun.lock",
-  "deno.lock"
+	"yarn.lock",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"npm-shrinkwrap.json",
+	"bun.lockb",
+	"bun.lock",
+	"deno.lock"
+];
+const packageFiles = [
+	"package.json",
+	"package.json5",
+	"package.yaml"
 ];
-const packageFiles = ["package.json", "package.json5", "package.yaml"];
 const workspaceFiles = [
-  "pnpm-workspace.yaml",
-  "lerna.json",
-  "turbo.json",
-  "rush.json",
-  "deno.json",
-  "deno.jsonc"
+	"pnpm-workspace.yaml",
+	"lerna.json",
+	"turbo.json",
+	"rush.json",
+	"deno.json",
+	"deno.jsonc"
 ];
 const FileCache = /* @__PURE__ */ new Map();
 function definePackageJSON(pkg) {
-  return pkg;
+	return pkg;
 }
 async function findPackage(id = process.cwd(), options = {}) {
-  return findNearestFile(packageFiles, {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile(packageFiles, {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
 async function readPackage(id, options = {}) {
-  const resolvedPath = await findPackage(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const blob = await promises.readFile(resolvedPath, "utf8");
-  let parsed;
-  if (resolvedPath.endsWith(".json5")) {
-    parsed = parseJSON5(blob);
-  } else if (resolvedPath.endsWith(".yaml")) {
-    parsed = parseYAML(blob);
-  } else {
-    try {
-      parsed = parseJSON(blob);
-    } catch {
-      parsed = parseJSONC(blob);
-    }
-  }
-  cache.set(resolvedPath, parsed);
-  return parsed;
+	const resolvedPath = await findPackage(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	if (resolvedPath.endsWith(".json5")) parsed = parseJSON5(blob);
+	else if (resolvedPath.endsWith(".yaml")) parsed = parseYAML(blob);
+	else try {
+		parsed = parseJSON(blob);
+	} catch {
+		parsed = parseJSONC(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
 }
 async function writePackage(path, pkg) {
-  let content;
-  if (path.endsWith(".json5")) {
-    content = stringifyJSON5(pkg);
-  } else if (path.endsWith(".yaml")) {
-    content = stringifyYAML(pkg);
-  } else {
-    content = stringifyJSON(pkg);
-  }
-  await promises.writeFile(path, content);
+	let content;
+	if (path.endsWith(".json5")) content = stringifyJSON5(pkg);
+	else if (path.endsWith(".yaml")) content = stringifyYAML(pkg);
+	else content = stringifyJSON(pkg);
+	await promises.writeFile(path, content);
 }
 async function readPackageJSON(id, options = {}) {
-  const resolvedPath = await resolvePackageJSON(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const blob = await external_node_fs_.promises.readFile(resolvedPath, "utf8");
-  let parsed;
-  try {
-    parsed = json_n(blob);
-  } catch {
-    parsed = (0,jsonc.parseJSONC)(blob);
-  }
-  cache.set(resolvedPath, parsed);
-  return parsed;
+	const resolvedPath = await resolvePackageJSON(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await external_node_fs_.promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	try {
+		parsed = json_n(blob);
+	} catch {
+		parsed = (0,jsonc.parseJSONC)(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
 }
 async function writePackageJSON(path, pkg) {
-  await promises.writeFile(path, stringifyJSON(pkg));
+	await promises.writeFile(path, stringifyJSON(pkg));
 }
 async function resolvePackageJSON(id = process.cwd(), options = {}) {
-  return findNearestFile("package.json", {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile("package.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
 async function resolveLockfile(id = process.cwd(), options = {}) {
-  return findNearestFile(lockFiles, {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile(lockFiles, {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
 const workspaceTests = {
-  workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
-  gitConfig: (opts) => findFile(".git/config", opts).then((r) => pathe_M_eThtNZ_resolve(r, "../..")),
-  lockFile: (opts) => findFile(lockFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
-  packageJson: (opts) => findFile(packageFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r))
+	workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
+	gitConfig: (opts) => findFile(".git/config", opts).then((r) => pathe_M_eThtNZ_resolve(r, "../..")),
+	lockFile: (opts) => findFile(lockFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
+	packageJson: (opts) => findFile(packageFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r))
 };
 async function findWorkspaceDir(id = process.cwd(), options = {}) {
-  const startingFrom = _resolvePath(id, options);
-  const tests = options.tests || ["workspaceFile", "gitConfig", "lockFile", "packageJson"];
-  for (const testName of tests) {
-    const test = workspaceTests[testName];
-    if (options[testName] === false || !test) {
-      continue;
-    }
-    const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
-    const detected = await test({
-      ...options,
-      startingFrom,
-      reverse: direction === "furthest"
-    }).catch(() => {
-    });
-    if (detected) {
-      return detected;
-    }
-  }
-  throw new Error(`Cannot detect workspace root from ${id}`);
+	const startingFrom = _resolvePath(id, options);
+	const tests = options.tests || [
+		"workspaceFile",
+		"gitConfig",
+		"lockFile",
+		"packageJson"
+	];
+	for (const testName of tests) {
+		const test = workspaceTests[testName];
+		if (options[testName] === false || !test) continue;
+		const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
+		const detected = await test({
+			...options,
+			startingFrom,
+			reverse: direction === "furthest"
+		}).catch(() => {});
+		if (detected) return detected;
+	}
+	throw new Error(`Cannot detect workspace root from ${id}`);
 }
 async function updatePackage(id, callback, options = {}) {
-  const resolvedPath = await findPackage(id, options);
-  const pkg = await readPackage(id, options);
-  const proxy = new Proxy(pkg, {
-    get(target, prop) {
-      if (typeof prop === "string" && objectKeys.has(prop) && !Object.hasOwn(target, prop)) {
-        target[prop] = {};
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-  const updated = await callback(proxy) || pkg;
-  await writePackage(resolvedPath, updated);
+	const resolvedPath = await findPackage(id, options);
+	const pkg = await readPackage(id, options);
+	await writePackage(resolvedPath, await callback(new Proxy(pkg, { get(target, prop) {
+		if (typeof prop === "string" && objectKeys.has(prop) && !Object.hasOwn(target, prop)) target[prop] = {};
+		return Reflect.get(target, prop);
+	} })) || pkg);
 }
 function sortPackage(pkg) {
-  const sorted = {};
-  const originalKeys = Object.keys(pkg);
-  const knownKeysPresent = defaultFieldOrder.filter(
-    (key) => Object.hasOwn(pkg, key)
-  );
-  for (const key of originalKeys) {
-    const currentIndex = knownKeysPresent.indexOf(key);
-    if (currentIndex === -1) {
-      sorted[key] = pkg[key];
-      continue;
-    }
-    for (let i = 0; i <= currentIndex; i++) {
-      const knownKey = knownKeysPresent[i];
-      if (!Object.hasOwn(sorted, knownKey)) {
-        sorted[knownKey] = pkg[knownKey];
-      }
-    }
-  }
-  for (const key of [...dependencyKeys, "scripts"]) {
-    const value = sorted[key];
-    if (dist_isObject(value)) {
-      sorted[key] = sortObject(value);
-    }
-  }
-  return sorted;
+	const sorted = {};
+	const originalKeys = Object.keys(pkg);
+	const knownKeysPresent = defaultFieldOrder.filter((key) => Object.hasOwn(pkg, key));
+	for (const key of originalKeys) {
+		const currentIndex = knownKeysPresent.indexOf(key);
+		if (currentIndex === -1) {
+			sorted[key] = pkg[key];
+			continue;
+		}
+		for (let i = 0; i <= currentIndex; i++) {
+			const knownKey = knownKeysPresent[i];
+			if (!Object.hasOwn(sorted, knownKey)) sorted[knownKey] = pkg[knownKey];
+		}
+	}
+	for (const key of [...dependencyKeys, "scripts"]) {
+		const value = sorted[key];
+		if (dist_isObject(value)) sorted[key] = sortObject(value);
+	}
+	return sorted;
 }
 function normalizePackage(pkg) {
-  const normalized = sortPackage(pkg);
-  for (const key of dependencyKeys) {
-    if (!Object.hasOwn(normalized, key)) {
-      continue;
-    }
-    const value = normalized[key];
-    if (!dist_isObject(value)) {
-      delete normalized[key];
-    }
-  }
-  return normalized;
+	const normalized = sortPackage(pkg);
+	for (const key of dependencyKeys) {
+		if (!Object.hasOwn(normalized, key)) continue;
+		const value = normalized[key];
+		if (!dist_isObject(value)) delete normalized[key];
+	}
+	return normalized;
 }
 function dist_isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sortObject(obj) {
-  return Object.fromEntries(
-    Object.entries(obj).sort(([a], [b]) => a.localeCompare(b))
-  );
+	return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
 }
 const dependencyKeys = (/* unused pure expression or super */ null && ([
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "peerDependencies"
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
 ]));
-const objectKeys = /* @__PURE__ */ (/* unused pure expression or super */ null && (new Set([
-  "typesVersions",
-  "scripts",
-  "resolutions",
-  "overrides",
-  "dependencies",
-  "devDependencies",
-  "dependenciesMeta",
-  "peerDependencies",
-  "peerDependenciesMeta",
-  "optionalDependencies",
-  "engines",
-  "publishConfig"
-])));
+const objectKeys = new Set([
+	"typesVersions",
+	"scripts",
+	"resolutions",
+	"overrides",
+	"dependencies",
+	"devDependencies",
+	"dependenciesMeta",
+	"peerDependencies",
+	"peerDependenciesMeta",
+	"optionalDependencies",
+	"engines",
+	"publishConfig"
+]);
 const defaultFieldOrder = (/* unused pure expression or super */ null && ([
-  "$schema",
-  "name",
-  "version",
-  "private",
-  "description",
-  "keywords",
-  "homepage",
-  "bugs",
-  "repository",
-  "funding",
-  "license",
-  "author",
-  "sideEffects",
-  "type",
-  "imports",
-  "exports",
-  "main",
-  "module",
-  "browser",
-  "types",
-  "typesVersions",
-  "typings",
-  "bin",
-  "man",
-  "files",
-  "workspaces",
-  "scripts",
-  "resolutions",
-  "overrides",
-  "dependencies",
-  "devDependencies",
-  "dependenciesMeta",
-  "peerDependencies",
-  "peerDependenciesMeta",
-  "optionalDependencies",
-  "bundledDependencies",
-  "bundleDependencies",
-  "packageManager",
-  "engines",
-  "publishConfig"
+	"$schema",
+	"name",
+	"version",
+	"private",
+	"description",
+	"keywords",
+	"homepage",
+	"bugs",
+	"repository",
+	"funding",
+	"license",
+	"author",
+	"sideEffects",
+	"type",
+	"imports",
+	"exports",
+	"main",
+	"module",
+	"browser",
+	"types",
+	"typesVersions",
+	"typings",
+	"bin",
+	"man",
+	"files",
+	"workspaces",
+	"scripts",
+	"resolutions",
+	"overrides",
+	"dependencies",
+	"devDependencies",
+	"dependenciesMeta",
+	"peerDependencies",
+	"peerDependenciesMeta",
+	"optionalDependencies",
+	"bundledDependencies",
+	"bundleDependencies",
+	"packageManager",
+	"engines",
+	"publishConfig"
 ]));
-
 function defineGitConfig(config) {
-  return config;
+	return config;
 }
 async function resolveGitConfig(dir, opts) {
-  return findNearestFile(".git/config", { ...opts, startingFrom: dir });
+	return findNearestFile(".git/config", {
+		...opts,
+		startingFrom: dir
+	});
 }
 async function readGitConfig(dir, opts) {
-  const path = await resolveGitConfig(dir, opts);
-  const ini = await readFile(path, "utf8");
-  return parseGitConfig(ini);
+	return parseGitConfig(await readFile(await resolveGitConfig(dir, opts), "utf8"));
 }
 async function writeGitConfig(path, config) {
-  await writeFile(path, stringifyGitConfig(config));
+	await writeFile(path, stringifyGitConfig(config));
 }
 function parseGitConfig(ini) {
-  return parseINI(ini.replaceAll(/^\[(\w+) "(.+)"\]$/gm, "[$1.$2]"));
+	return parseINI(ini.replaceAll(/^\[(\w+) "(.+)"\]$/gm, "[$1.$2]"));
 }
 function stringifyGitConfig(config) {
-  return stringifyINI(config).replaceAll(/^\[(\w+)\.(\w+)\]$/gm, '[$1 "$2"]');
+	return stringifyINI(config).replaceAll(/^\[(\w+)\.(\w+)\]$/gm, "[$1 \"$2\"]");
 }
 
 
-
 ;// CONCATENATED MODULE: ../../node_modules/c12/dist/index.mjs
 
 
@@ -29237,7 +29183,7 @@ async function watchConfig(options) {
 		options.rcFile && resolve(l.cwd, typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc`),
 		options.packageJson && resolve(l.cwd, "package.json")
 	]).filter(Boolean))];
-	const watch = await __webpack_require__.e(/* import() */ 27).then(__webpack_require__.bind(__webpack_require__, 9774)).then((r) => r.watch || r.default || r);
+	const watch = await __webpack_require__.e(/* import() */ 475).then(__webpack_require__.bind(__webpack_require__, 4710)).then((r) => r.watch || r.default || r);
 	const { diff } = await __webpack_require__.e(/* import() */ 164).then(__webpack_require__.bind(__webpack_require__, 263));
 	const _fswatcher = watch(watchingFiles, {
 		ignoreInitial: true,
@@ -29990,6 +29936,240 @@ function defaultExec(command, args, options) {
     return new OctokitRulesetGateway(octokit);
 }
 
+// EXTERNAL MODULE: external "node:crypto"
+var external_node_crypto_ = __webpack_require__(7598);
+;// CONCATENATED MODULE: ../core/src/gateways/init-hooks-config-gateway.ts
+
+
+
+
+
+const CLAUDE_SETTINGS_PATH = (0,external_node_path_.join)(".claude", "settings.json");
+/**
+ * PreToolUse hooks for Edit and Write tools only.
+ * File paths are NOT passed as shell arguments — Claude Code pipes the hook
+ * JSON (including tool_input.file_path) to the command via stdin.
+ */ const PRE_TOOL_USE_HOOKS = [
+    {
+        matcher: "Edit",
+        hooks: [
+            {
+                type: "command",
+                command: "lousy-agents context"
+            }
+        ]
+    },
+    {
+        matcher: "Write",
+        hooks: [
+            {
+                type: "command",
+                command: "lousy-agents context"
+            }
+        ]
+    }
+];
+const SESSION_START_HOOKS = [
+    {
+        hooks: [
+            {
+                type: "command",
+                command: "lousy-agents context"
+            }
+        ]
+    }
+];
+const STOP_HOOKS = [
+    {
+        hooks: [
+            {
+                type: "command",
+                command: "lousy-agents capture"
+            }
+        ]
+    }
+];
+const SUBAGENT_STOP_HOOKS = [
+    {
+        hooks: [
+            {
+                type: "command",
+                command: "lousy-agents capture"
+            }
+        ]
+    }
+];
+const DANGEROUS_KEYS = new Set([
+    "__proto__",
+    "constructor",
+    "prototype"
+]);
+function hasPrototypePollutionKey(obj, depth = 0) {
+    if (depth > 20) return false;
+    if (obj === null || typeof obj !== "object") return false;
+    for (const key of Object.keys(obj)){
+        if (DANGEROUS_KEYS.has(key)) return true;
+        if (hasPrototypePollutionKey(obj[key], depth + 1)) return true;
+    }
+    return false;
+}
+function safeJoin(rootDir, relativePath) {
+    const resolved = resolve(rootDir, relativePath);
+    const root = resolve(rootDir);
+    if (resolved !== root) {
+        const rel = relative(root, resolved);
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+            throw new Error(`Resolved path is outside target directory: ${relativePath}`);
+        }
+    }
+    return resolved;
+}
+function getExistingMatchers(hooks, event) {
+    const entries = hooks[event];
+    if (!Array.isArray(entries)) return new Set();
+    return new Set(entries.filter((e)=>e !== null && typeof e === "object").map((e)=>e.matcher).filter((m)=>typeof m === "string"));
+}
+class InitHooksConfigGateway {
+    async initHooks(rootDir, config) {
+        const written = [];
+        const skipped = [];
+        const realRootDir = await realpath(rootDir);
+        const settingsPath = safeJoin(realRootDir, CLAUDE_SETTINGS_PATH);
+        const claudeDir = join(realRootDir, ".claude");
+        // Reject symlinks on .claude/settings.json and all ancestor segments
+        await assertPathHasNoSymbolicLinks(realRootDir, settingsPath);
+        let existing = {};
+        try {
+            const raw = await readFileNoFollow(settingsPath, 1_048_576);
+            const parsed = JSON.parse(raw);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                if (hasPrototypePollutionKey(parsed)) {
+                    throw new Error("Settings file contains dangerous prototype keys");
+                }
+                existing = parsed;
+            }
+        } catch (error) {
+            if (error instanceof Error && "code" in error) {
+                const code = error.code;
+                if (code === "ENOENT" || code === "ENOTDIR") {
+                    existing = {};
+                } else {
+                    throw error;
+                }
+            } else if (error instanceof SyntaxError || error instanceof Error && error.message === "Settings file contains dangerous prototype keys") {
+                throw error;
+            } else if (error instanceof Error) {
+                throw error;
+            }
+        }
+        const rawHooks = existing.hooks;
+        const existingHooks = rawHooks !== null && typeof rawHooks === "object" && !Array.isArray(rawHooks) ? rawHooks : {};
+        const existingPreToolUseMatchers = getExistingMatchers(existingHooks, "PreToolUse");
+        const alreadyHasEditHook = existingPreToolUseMatchers.has("Edit") && !config.force;
+        const alreadyHasWriteHook = existingPreToolUseMatchers.has("Write") && !config.force;
+        const alreadyHasStop = Array.isArray(existingHooks.Stop) && !config.force;
+        const alreadyHasSubagentStop = Array.isArray(existingHooks.SubagentStop) && !config.force;
+        const alreadyHasSessionStart = config.addSessionStart && Array.isArray(existingHooks.SessionStart) && !config.force;
+        const allAlreadyPresent = alreadyHasEditHook && alreadyHasWriteHook && alreadyHasStop && alreadyHasSubagentStop && (!config.addSessionStart || alreadyHasSessionStart);
+        if (allAlreadyPresent) {
+            skipped.push(settingsPath);
+            return {
+                written,
+                skipped
+            };
+        }
+        const updatedHooks = {
+            ...existingHooks
+        };
+        const missingPreToolUseHooks = PRE_TOOL_USE_HOOKS.filter((h)=>!(h.matcher === "Edit" && alreadyHasEditHook) && !(h.matcher === "Write" && alreadyHasWriteHook));
+        if (missingPreToolUseHooks.length > 0) {
+            // In --force mode, remove any existing Edit/Write matchers before
+            // appending the new ones so we never produce duplicate entries.
+            const existing_ = Array.isArray(existingHooks.PreToolUse) ? config.force ? existingHooks.PreToolUse.filter((e)=>{
+                if (e === null || typeof e !== "object" || Array.isArray(e)) {
+                    return true;
+                }
+                const m = e.matcher;
+                return m !== "Edit" && m !== "Write";
+            }) : existingHooks.PreToolUse : [];
+            updatedHooks.PreToolUse = [
+                ...existing_,
+                ...missingPreToolUseHooks
+            ];
+        }
+        // Stop/SubagentStop: written if not already configured with a valid
+        // array. Use --force to replace them.
+        if (!alreadyHasStop) {
+            updatedHooks.Stop = STOP_HOOKS;
+        }
+        if (!alreadyHasSubagentStop) {
+            updatedHooks.SubagentStop = SUBAGENT_STOP_HOOKS;
+        }
+        if (config.addSessionStart && !alreadyHasSessionStart) {
+            updatedHooks.SessionStart = SESSION_START_HOOKS;
+        }
+        const updatedSettings = {
+            ...existing,
+            hooks: updatedHooks
+        };
+        const content = `${JSON.stringify(updatedSettings, null, 2)}\n`;
+        await mkdir(claudeDir, {
+            recursive: true
+        });
+        // Re-check after mkdir: a race between the initial check and directory
+        // creation could allow an attacker to replace .claude/ with a symlink.
+        // By the time mkdir returns, the directory exists; if .claude (or any
+        // ancestor) is now a symlink the walk will reach it and throw.
+        await assertPathHasNoSymbolicLinks(realRootDir, settingsPath);
+        // Use a random suffix so the temp path is unpredictable, combined with
+        // O_EXCL so the open fails rather than truncating a pre-existing file.
+        // Together these defeat hardlink pre-creation attacks: an attacker cannot
+        // predict the path to hardlink, and even if they did O_EXCL would reject it.
+        const tmpPath = `${settingsPath}.${randomBytes(8).toString("hex")}.tmp`;
+        // O_NOFOLLOW prevents following a symlink that races between open and write.
+        // O_EXCL guarantees the file is newly created (no truncate of an existing target).
+        const hasNoFollow = typeof constants.O_NOFOLLOW === "number" && constants.O_NOFOLLOW !== 0;
+        const openFlags = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (hasNoFollow ? constants.O_NOFOLLOW : 0);
+        let tmpFileHandle;
+        try {
+            tmpFileHandle = await open(tmpPath, openFlags);
+        } catch (error) {
+            if (error instanceof Error && "code" in error) {
+                if (error.code === "ELOOP") {
+                    throw new Error(`Symlinks are not allowed for temp path: ${JSON.stringify(tmpPath)}`);
+                }
+                if (error.code === "EEXIST") {
+                    // With 8 random bytes (2^64 possibilities) this is astronomically
+                    // rare; if it happens it likely indicates a targeted attack.
+                    throw new Error(`Temp file already exists (possible collision or attack): ${JSON.stringify(tmpPath)}`);
+                }
+            }
+            throw error;
+        }
+        try {
+            await tmpFileHandle.writeFile(content, "utf8");
+        } finally{
+            await tmpFileHandle.close();
+        }
+        try {
+            await rename(tmpPath, settingsPath);
+        } catch (error) {
+            // Best-effort cleanup: remove the random temp file so it does not
+            // accumulate on repeated failures (e.g. settingsPath unwritable).
+            await unlink(tmpPath).catch(()=>{});
+            throw error;
+        }
+        written.push(settingsPath);
+        return {
+            written,
+            skipped
+        };
+    }
+}
+function createInitHooksConfigGateway() {
+    return new InitHooksConfigGateway();
+}
+
 ;// CONCATENATED MODULE: ../core/src/gateways/instruction-analysis-gateway.ts
 /**
  * Gateway for analyzing repository instructions for feedback loop coverage
@@ -30094,6 +30274,258 @@ function defaultExec(command, args, options) {
     return new FileSystemInstructionAnalysisGateway();
 }
 
+// EXTERNAL MODULE: ../../node_modules/yaml/dist/index.js
+var yaml_dist = __webpack_require__(3519);
+;// CONCATENATED MODULE: ../core/src/lib/frontmatter.ts
+/**
+ * Shared YAML frontmatter parser for markdown files.
+ * Extracts YAML data between leading `---` delimiters.
+ */ 
+/**
+ * Parses YAML frontmatter and returns a tagged result:
+ * - `{ ok: true, data }` on success
+ * - `{ ok: false, reason: 'missing' }` when no frontmatter delimiters found
+ * - `{ ok: false, reason: 'invalid', detail }` when YAML is malformed (with error detail)
+ */ function frontmatter_parseFrontmatterWithError(content) {
+    const lines = content.split("\n");
+    if (lines[0]?.trim() !== "---") {
+        return {
+            ok: false,
+            reason: "missing"
+        };
+    }
+    let endIndex = -1;
+    for(let i = 1; i < lines.length; i++){
+        if (lines[i]?.trim() === "---") {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        return {
+            ok: false,
+            reason: "missing"
+        };
+    }
+    const yamlContent = lines.slice(1, endIndex).join("\n");
+    let data;
+    try {
+        const parsed = parseYaml(yamlContent, {
+            maxAliasCount: 0
+        });
+        data = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch (error) {
+        const detail = error instanceof Error ? error.message : "Unknown YAML parse error";
+        return {
+            ok: false,
+            reason: "invalid",
+            detail
+        };
+    }
+    const fieldLines = new Map();
+    for(let i = 1; i < endIndex; i++){
+        const match = lines[i]?.match(/^([^\s:][^:]*?):(?:\s|$)/);
+        if (match?.[1]) {
+            fieldLines.set(match[1], i + 1);
+        }
+    }
+    return {
+        ok: true,
+        data: {
+            data: data ?? {},
+            fieldLines,
+            frontmatterStartLine: 1
+        }
+    };
+}
+/**
+ * Parses YAML frontmatter from markdown content.
+ *
+ * Returns `null` when the content has no opening `---`, no closing `---`,
+ * or contains invalid YAML.
+ */ function frontmatter_parseFrontmatter(content) {
+    const result = frontmatter_parseFrontmatterWithError(content);
+    return result.ok ? result.data : null;
+}
+
+;// CONCATENATED MODULE: ../core/src/use-cases/lesson-schema.ts
+
+const SAFE_SLUG = /^[a-z0-9-]+$/;
+const MAX_TITLE_LENGTH = 200;
+const MAX_PATTERN_LENGTH = 200;
+const MAX_PATTERNS = 50;
+const MAX_TRIGGER_VALUES = 100;
+const MAX_TRIGGER_VALUE_LENGTH = 200;
+const lesson_schema_LessonFrontmatterSchema = schemas_object({
+    slug: schemas_string().regex(SAFE_SLUG, "slug must match ^[a-z0-9-]+$"),
+    title: schemas_string().min(1).max(MAX_TITLE_LENGTH),
+    type: schemas_enum([
+        "invariant",
+        "pattern"
+    ]),
+    created: schemas_string().regex(/^\d{4}-\d{2}-\d{2}$/, "created must be YYYY-MM-DD"),
+    revised: schemas_string().regex(/^\d{4}-\d{2}-\d{2}$/, "revised must be YYYY-MM-DD"),
+    provenance: schemas_array(schemas_object({
+        pr: schemas_number().int(),
+        // biome-ignore lint/style/useNamingConvention: YAML frontmatter key uses snake_case
+        finding_id: schemas_string(),
+        facet: schemas_string()
+    }).strict()),
+    triggers: schemas_object({
+        paths: schemas_array(schemas_string().min(1).max(MAX_TRIGGER_VALUE_LENGTH)).max(MAX_TRIGGER_VALUES),
+        tags: schemas_array(schemas_string().min(1).max(MAX_TRIGGER_VALUE_LENGTH)).max(MAX_TRIGGER_VALUES),
+        patterns: schemas_array(schemas_string().min(1).max(MAX_PATTERN_LENGTH)).max(MAX_PATTERNS)
+    }).strict()
+}).strict().refine((data)=>data.revised >= data.created, {
+    message: "revised must be on or after created (lexicographic ISO date compare)",
+    path: [
+        "revised"
+    ]
+});
+
+;// CONCATENATED MODULE: ../core/src/gateways/lesson-file-gateway.ts
+/**
+ * Gateway for reading lesson files from .lousy-agents/lessons/.
+ */ 
+
+
+
+
+const MAX_LESSON_FILE_BYTES = 1_048_576; // 1 MB
+const MAX_LESSON_FILES = 500;
+const MAX_AGGREGATE_BYTES = (/* unused pure expression or super */ null && (20 * 1024 * 1024)); // 20 MB
+const LESSONS_RELATIVE_PATH = (0,external_node_path_.join)(".lousy-agents", "lessons");
+/**
+ * Extracts the markdown body from lesson file content (text after second `---`).
+ */ function extractBody(content) {
+    const lines = content.split("\n");
+    if (lines[0]?.trim() !== "---") {
+        return content;
+    }
+    let endIndex = -1;
+    for(let i = 1; i < lines.length; i++){
+        if (lines[i]?.trim() === "---") {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        return "";
+    }
+    const bodyLines = lines.slice(endIndex + 1);
+    if (bodyLines[0] === "") {
+        return bodyLines.slice(1).join("\n");
+    }
+    return bodyLines.join("\n");
+}
+class LessonFileGateway {
+    async readLessons(rootDir) {
+        const realRootDir = await realpath(rootDir);
+        const lessonsDir = join(realRootDir, LESSONS_RELATIVE_PATH);
+        await assertPathHasNoSymbolicLinks(realRootDir, lessonsDir);
+        let dirStat;
+        try {
+            dirStat = await lstat(lessonsDir);
+        } catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                return {
+                    lessons: [],
+                    errors: []
+                };
+            }
+            throw error;
+        }
+        if (!dirStat.isDirectory()) {
+            throw new Error(`Lessons path exists but is not a directory: ${lessonsDir}`);
+        }
+        let entries;
+        try {
+            entries = await readdir(lessonsDir, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            const wrapped = new Error(`Cannot read lessons directory ${lessonsDir}: ${reason}`);
+            // Preserve the OS error code so callers can distinguish EACCES
+            // (permission denied) from other failures without parsing the message.
+            if (error instanceof Error && "code" in error) {
+                wrapped.code = error.code;
+            }
+            throw wrapped;
+        }
+        const mdFiles = entries.filter((e)=>e.isFile() && e.name.endsWith(".md")).map((e)=>join(lessonsDir, e.name)).sort();
+        if (mdFiles.length > MAX_LESSON_FILES) {
+            throw new Error(`Lesson file count exceeds limit: ${mdFiles.length} files found (max ${MAX_LESSON_FILES})`);
+        }
+        const lessons = [];
+        const errors = [];
+        let aggregateBytes = 0;
+        for (const filePath of mdFiles){
+            let content;
+            try {
+                content = await readFileNoFollow(filePath, MAX_LESSON_FILE_BYTES);
+            } catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                errors.push({
+                    filePath,
+                    reason
+                });
+                continue;
+            }
+            const byteLength = Buffer.byteLength(content, "utf-8");
+            aggregateBytes += byteLength;
+            if (aggregateBytes > MAX_AGGREGATE_BYTES) {
+                throw new Error(`Aggregate lesson bytes exceed limit: ${aggregateBytes} bytes > ${MAX_AGGREGATE_BYTES} bytes`);
+            }
+            const parseResult = parseFrontmatterWithError(content);
+            if (!parseResult.ok) {
+                const reason = parseResult.reason === "invalid" ? `Invalid YAML frontmatter: ${parseResult.detail}` : "Missing YAML frontmatter";
+                errors.push({
+                    filePath,
+                    reason
+                });
+                continue;
+            }
+            const schemaResult = LessonFrontmatterSchema.safeParse(parseResult.data.data);
+            if (!schemaResult.success) {
+                const reason = schemaResult.error.issues.map((i)=>`${i.path.join(".")}: ${i.message}`).join("; ");
+                errors.push({
+                    filePath,
+                    reason
+                });
+                continue;
+            }
+            const fm = schemaResult.data;
+            const body = extractBody(content);
+            const lesson = {
+                slug: fm.slug,
+                title: fm.title,
+                type: fm.type,
+                created: fm.created,
+                revised: fm.revised,
+                provenance: fm.provenance,
+                triggers: {
+                    paths: fm.triggers.paths,
+                    tags: fm.triggers.tags,
+                    patterns: fm.triggers.patterns
+                },
+                body
+            };
+            lessons.push({
+                lesson,
+                filePath
+            });
+        }
+        return {
+            lessons,
+            errors
+        };
+    }
+}
+function createLessonFileGateway() {
+    return new LessonFileGateway();
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/consola/dist/core.mjs
 const LogLevels = {
   silent: Number.NEGATIVE_INFINITY,
@@ -31902,58 +32334,6 @@ const PackageJsonSchema = schemas_object({
     return new FileSystemSkillFileGateway();
 }
 
-// EXTERNAL MODULE: ../../node_modules/yaml/dist/index.js
-var yaml_dist = __webpack_require__(3519);
-;// CONCATENATED MODULE: ../core/src/lib/frontmatter.ts
-/**
- * Shared YAML frontmatter parser for markdown files.
- * Extracts YAML data between leading `---` delimiters.
- */ 
-/**
- * Parses YAML frontmatter from markdown content.
- *
- * Returns `null` when the content has no opening `---`, no closing `---`,
- * or contains invalid YAML.
- */ function frontmatter_parseFrontmatter(content) {
-    const lines = content.split("\n");
-    if (lines[0]?.trim() !== "---") {
-        return null;
-    }
-    let endIndex = -1;
-    for(let i = 1; i < lines.length; i++){
-        if (lines[i]?.trim() === "---") {
-            endIndex = i;
-            break;
-        }
-    }
-    if (endIndex === -1) {
-        return null;
-    }
-    const yamlContent = lines.slice(1, endIndex).join("\n");
-    let data;
-    try {
-        const parsed = parseYaml(yamlContent, {
-            maxAliasCount: 0
-        });
-        data = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-    } catch  {
-        return null;
-    }
-    const fieldLines = new Map();
-    for(let i = 1; i < endIndex; i++){
-        // Match YAML top-level field names: non-whitespace start, any chars except colon, then colon followed by whitespace or end-of-line
-        const match = lines[i]?.match(/^([^\s:][^:]*?):(?:\s|$)/);
-        if (match?.[1]) {
-            fieldLines.set(match[1], i + 1);
-        }
-    }
-    return {
-        data: data ?? {},
-        fieldLines,
-        frontmatterStartLine: 1
-    };
-}
-
 ;// CONCATENATED MODULE: ../core/src/gateways/skill-lint-gateway.ts
 /**
  * Gateway for skill lint file system operations.
@@ -32483,6 +32863,8 @@ function createWorkflowGateway(cwd) {
 
 
 
+
+
 ;// CONCATENATED MODULE: ./src/tools/types.ts
 /**
  * Shared types and utilities for MCP tool handlers.
@@ -48922,7 +49304,7 @@ function default_ok() {}
 
 function unreachable() {}
 
-;// CONCATENATED MODULE: ../../node_modules/unified/node_modules/is-plain-obj/index.js
+;// CONCATENATED MODULE: ../../node_modules/is-plain-obj/index.js
 function is_plain_obj_isPlainObject(value) {
 	if (typeof value !== 'object' || value === null) {
 		return false;
@@ -51684,7 +52066,7 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
 
 /** Maximum number of raw heading pattern entries accepted before deduplication. */ const MAX_RAW_HEADING_PATTERNS = 1000;
 /** Maximum number of heading patterns accepted in a single execute() call. */ const MAX_HEADING_PATTERNS = 50;
-/** Maximum character length for a single heading pattern. */ const MAX_PATTERN_LENGTH = 200;
+/** Maximum character length for a single heading pattern. */ const analyze_instruction_quality_MAX_PATTERN_LENGTH = 200;
 /**
  * Lowercase-keyed lookup built once from HEADING_PATTERN_DESCRIPTIONS.
  * Enables description lookup regardless of the casing callers supply for patterns.
@@ -51696,7 +52078,7 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
  * Input for the analyze instruction quality use case.
  */ const AnalyzeInstructionQualityInputSchema = schemas_object({
     targetDir: schemas_string().min(1, "Target directory is required"),
-    headingPatterns: schemas_array(schemas_string().max(MAX_PATTERN_LENGTH * 2)).max(MAX_RAW_HEADING_PATTERNS).optional(),
+    headingPatterns: schemas_array(schemas_string().max(analyze_instruction_quality_MAX_PATTERN_LENGTH * 2)).max(MAX_RAW_HEADING_PATTERNS).optional(),
     proximityWindow: schemas_number().int().positive().optional()
 });
 /**
@@ -51796,8 +52178,8 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
             if (trimmed.length === 0) {
                 throw new Error("headingPatterns must not contain empty or whitespace-only entries");
             }
-            if (trimmed.length > MAX_PATTERN_LENGTH) {
-                throw new Error(`headingPatterns entries must not exceed ${MAX_PATTERN_LENGTH} characters`);
+            if (trimmed.length > analyze_instruction_quality_MAX_PATTERN_LENGTH) {
+                throw new Error(`headingPatterns entries must not exceed ${analyze_instruction_quality_MAX_PATTERN_LENGTH} characters`);
             }
             const lower = trimmed.toLowerCase();
             if (!seenLower.has(lower)) {
@@ -63814,4 +64196,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(832);
+var __webpack_exports__ = __webpack_require__(8050);