agemon 0.1.0 → 6.3.0

package/dist/chunk-ZZBF3GOV.js

@@ -0,0 +1,3451 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/untrusted-text.ts
+var TERMINAL_UNSAFE_CHARACTER_RANGES = "\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f\\u061c\\u200b-\\u200f\\u2028\\u2029\\u202a-\\u202e\\u2060\\u2066-\\u2069\\ufeff";
+var TERMINAL_UNSAFE_CHARACTERS = new RegExp(
+  `[${TERMINAL_UNSAFE_CHARACTER_RANGES}]`,
+  "gu"
+);
+var IDENTIFIER_UNSAFE_CHARACTERS = new RegExp(
+  `[\\t\\n${TERMINAL_UNSAFE_CHARACTER_RANGES}]`,
+  "u"
+);
+function printable(value) {
+  return value.replace(TERMINAL_UNSAFE_CHARACTERS, "?");
+}
+function isSafeIdentifier(value) {
+  return !IDENTIFIER_UNSAFE_CHARACTERS.test(value);
+}
+function quoteForShlex(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/core/repo-paths.ts
+import { constants as constants2 } from "fs";
+import { lstat as lstat2, mkdir, open as open2, realpath } from "fs/promises";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+
+// src/core/files.ts
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import {
+  access,
+  lstat,
+  open,
+  rename,
+  rm
+} from "fs/promises";
+var OWNER_ONLY_MODE = 384;
+var DEFAULT_NEW_FILE_MODE = 438;
+var PERMISSION_BITS = 511;
+var READ_CHUNK_BYTES = 64 * 1024;
+var PRESERVED_ORIGINAL_SUFFIX = ".agemon-original";
+var BYTES_PER_MEBIBYTE = 1024 * 1024;
+var MAX_READ_FILE_BYTES = 8 * BYTES_PER_MEBIBYTE;
+var MAX_READ_FILE_LABEL = `${MAX_READ_FILE_BYTES / BYTES_PER_MEBIBYTE} MiB`;
+function isMissingFileError(error) {
+  return error.code === "ENOENT";
+}
+var RefusedFileError = class extends Error {
+};
+var NotARegularFileError = class extends RefusedFileError {
+  constructor(action, filePath) {
+    super(
+      `Refusing to ${action} ${filePath}: it is not a regular file (agemon does not ${action} through symlinks or special files).`
+    );
+    this.name = "NotARegularFileError";
+  }
+};
+var FileTooLargeError = class extends RefusedFileError {
+  constructor(filePath) {
+    super(
+      `Refusing to read ${filePath}: it is larger than ${MAX_READ_FILE_LABEL}.`
+    );
+    this.name = "FileTooLargeError";
+  }
+};
+var RefusedPathError = class extends RefusedFileError {
+  constructor(message) {
+    super(message);
+    this.name = "RefusedPathError";
+  }
+};
+async function readAtMostCap(handle, filePath) {
+  const chunks = [];
+  let totalBytes = 0;
+  for (; ; ) {
+    const { bytesRead, buffer } = await handle.read({
+      buffer: Buffer.alloc(READ_CHUNK_BYTES)
+    });
+    if (bytesRead === 0) {
+      return Buffer.concat(chunks, totalBytes).toString("utf8");
+    }
+    totalBytes += bytesRead;
+    if (totalBytes > MAX_READ_FILE_BYTES) {
+      throw new FileTooLargeError(filePath);
+    }
+    chunks.push(buffer.subarray(0, bytesRead));
+  }
+}
+async function readRegularFileIfExists(filePath) {
+  let handle;
+  try {
+    handle = await open(
+      filePath,
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return null;
+    }
+    if (error.code === "ELOOP") {
+      throw new NotARegularFileError("read", filePath);
+    }
+    throw error;
+  }
+  try {
+    if (!(await handle.stat()).isFile()) {
+      throw new NotARegularFileError("read", filePath);
+    }
+    return await readAtMostCap(handle, filePath);
+  } finally {
+    await handle.close();
+  }
+}
+async function sha256OfRegularFile(filePath, maxBytes) {
+  let handle;
+  try {
+    handle = await open(
+      filePath,
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+  } catch (error) {
+    if (error.code === "ELOOP") {
+      throw new NotARegularFileError("read", filePath);
+    }
+    throw error;
+  }
+  try {
+    if (!(await handle.stat()).isFile()) {
+      throw new NotARegularFileError("read", filePath);
+    }
+    const hash = createHash("sha256");
+    let totalBytes = 0;
+    const buffer = Buffer.alloc(READ_CHUNK_BYTES);
+    for (; ; ) {
+      const { bytesRead } = await handle.read({ buffer });
+      if (bytesRead === 0) {
+        return hash.digest("hex");
+      }
+      totalBytes += bytesRead;
+      if (totalBytes > maxBytes) {
+        throw new Error(
+          `Refusing to hash ${filePath}: it is larger than expected.`
+        );
+      }
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+  } finally {
+    await handle.close();
+  }
+}
+async function modeOfReplaceableFile(filePath) {
+  let existing;
+  try {
+    existing = await lstat(filePath);
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return null;
+    }
+    throw error;
+  }
+  if (!existing.isFile()) {
+    throw new NotARegularFileError("write", filePath);
+  }
+  try {
+    await access(filePath, constants.W_OK);
+  } catch {
+    throw new Error(
+      `Refusing to write ${filePath}: it is read-only for this user.`
+    );
+  }
+  return existing.mode & PERMISSION_BITS;
+}
+async function writeFileAtomic(filePath, contents, options = {}) {
+  const existingMode = await modeOfReplaceableFile(filePath);
+  const tempPath = `${filePath}.tmp-${process.pid}-${randomUUID()}`;
+  const handle = await open(
+    tempPath,
+    "wx",
+    existingMode === null ? options.newFileMode ?? DEFAULT_NEW_FILE_MODE : OWNER_ONLY_MODE
+  );
+  try {
+    try {
+      if (existingMode !== null) {
+        await handle.chmod(existingMode);
+      }
+      await handle.writeFile(contents, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, { force: true });
+    throw error;
+  }
+}
+async function writeNewFile(filePath, contents) {
+  const handle = await open(filePath, "wx", OWNER_ONLY_MODE);
+  try {
+    await handle.writeFile(contents, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function writeNewFileWithFallback(preferredPath, fallbackPath, contents) {
+  try {
+    await writeNewFile(preferredPath, contents);
+    return preferredPath;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  await writeNewFile(fallbackPath, contents);
+  return fallbackPath;
+}
+async function saveVerifiedCopyBeside(targetPath, contents) {
+  const preferredPath = `${targetPath}${PRESERVED_ORIGINAL_SUFFIX}`;
+  const savedPath = await writeNewFileWithFallback(
+    preferredPath,
+    `${preferredPath}.${Date.now()}`,
+    contents
+  );
+  if (await readRegularFileIfExists(savedPath) !== contents) {
+    throw new Error(`Could not verify the copy saved at ${savedPath}`);
+  }
+  return savedPath;
+}
+
+// src/core/repo-paths.ts
+var AGEMON_STATE_DIRECTORY = ".agemon";
+var GIT_DIRECTORY = ".git";
+var IGNORABLE_CODE_POINTS = new RegExp("\\p{Default_Ignorable_Code_Point}", "gu");
+var MAX_PATH_COMPONENT_BYTES = 255;
+var GITDIR_FILE_PREFIX = "gitdir:";
+var GITDIR_FILE_PROBE_BYTES = 4096;
+function isMissingPathError(error) {
+  return error.code === "ENOENT";
+}
+function refuseRepoPath(relativePath, reason) {
+  throw new RefusedPathError(
+    `Refusing to use '${printable(relativePath)}': ${reason}. agemon only touches files inside the repository.`
+  );
+}
+async function resolveRealDirectory(repoRoot, components, options, createdComponents = []) {
+  let current = repoRoot;
+  for (const [index, component] of components.entries()) {
+    current = join(current, component);
+    let stats;
+    try {
+      stats = await lstat2(current);
+    } catch (error) {
+      if (!isMissingPathError(error)) {
+        throw error;
+      }
+      if (!options.create) {
+        return null;
+      }
+      await mkdir(current);
+      createdComponents.push(components.slice(0, index + 1).join("/"));
+      continue;
+    }
+    if (!stats.isDirectory()) {
+      throw new RefusedPathError(
+        `Refusing to use ${printable(current)}: it is a symlink or not a directory. agemon only uses real directories here \u2014 replace it with a real directory.`
+      );
+    }
+  }
+  return current;
+}
+function foldForCaseInsensitiveFilesystems(component) {
+  return component.replace(IGNORABLE_CODE_POINTS, "").toLowerCase();
+}
+async function resolveInsideRepo(repoRoot, relativePath) {
+  if (relativePath.length === 0 || relativePath.includes("\0")) {
+    refuseRepoPath(relativePath, "it is empty or contains a NUL byte");
+  }
+  if (isAbsolute(relativePath)) {
+    refuseRepoPath(relativePath, "it is an absolute path");
+  }
+  if (!isSafeIdentifier(relativePath)) {
+    refuseRepoPath(relativePath, "it contains control characters");
+  }
+  const repoRelativePath = relative(repoRoot, resolve(repoRoot, relativePath));
+  if (repoRelativePath === "" || repoRelativePath === ".." || repoRelativePath.startsWith(`..${sep}`)) {
+    refuseRepoPath(relativePath, "it resolves outside the repository");
+  }
+  const components = repoRelativePath.split(sep);
+  if (components.some(
+    (component) => Buffer.byteLength(component) > MAX_PATH_COMPONENT_BYTES
+  )) {
+    refuseRepoPath(relativePath, "a path component is longer than 255 bytes");
+  }
+  const foldedComponents = components.map(foldForCaseInsensitiveFilesystems);
+  if (foldedComponents.includes(GIT_DIRECTORY)) {
+    refuseRepoPath(relativePath, "it is inside a .git directory");
+  }
+  if (foldedComponents[0] === AGEMON_STATE_DIRECTORY) {
+    refuseRepoPath(relativePath, "it is inside agemon's own .agemon/ state");
+  }
+  await resolveRealDirectory(repoRoot, components.slice(0, -1), {
+    create: false
+  });
+  return join(repoRoot, repoRelativePath);
+}
+async function resolveStateDirectory(repoRoot, segments, options) {
+  return resolveRealDirectory(
+    repoRoot,
+    [AGEMON_STATE_DIRECTORY, ...segments],
+    options
+  );
+}
+async function resolveRepoDirectory(repoRoot, relativeDirectory, options = { create: false }) {
+  return resolveRealDirectory(repoRoot, relativeDirectory.split("/"), options);
+}
+async function ensureRepoDirectory(repoRoot, relativeDirectory) {
+  const createdDirectories = [];
+  await resolveRealDirectory(
+    repoRoot,
+    relativeDirectory.split("/"),
+    { create: true },
+    createdDirectories
+  );
+  return createdDirectories;
+}
+async function readRegularFilePrefix(path, maxBytes) {
+  const handle = await open2(
+    path,
+    constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
+  );
+  try {
+    if (!(await handle.stat()).isFile()) {
+      return null;
+    }
+    const buffer = Buffer.alloc(maxBytes);
+    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+async function classifyGitEntry(directory) {
+  const gitPath = join(directory, GIT_DIRECTORY);
+  try {
+    const stats = await lstat2(gitPath);
+    const entry = (kind) => ({
+      kind,
+      ownerUid: stats.uid
+    });
+    if (stats.isDirectory()) {
+      return entry("repository");
+    }
+    if (!stats.isFile()) {
+      return entry("unacceptable");
+    }
+    const prefix = await readRegularFilePrefix(
+      gitPath,
+      GITDIR_FILE_PROBE_BYTES
+    );
+    return entry(
+      prefix?.startsWith(GITDIR_FILE_PREFIX) ? "repository" : "unacceptable"
+    );
+  } catch (error) {
+    return {
+      kind: isMissingPathError(error) ? "none" : "unreadable",
+      ownerUid: null
+    };
+  }
+}
+async function hasGitEntry(directory) {
+  return (await classifyGitEntry(directory)).kind !== "none";
+}
+async function isOwnedBy(directory, gitEntry, uid) {
+  if (uid === void 0) {
+    return true;
+  }
+  return gitEntry.ownerUid === uid && (await lstat2(directory)).uid === uid;
+}
+async function realpathOrResolved(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function isSameOrInside(path, ancestor) {
+  const pathFromAncestor = relative(ancestor, path);
+  return pathFromAncestor === "" || pathFromAncestor !== ".." && !pathFromAncestor.startsWith(`..${sep}`) && !isAbsolute(pathFromAncestor);
+}
+async function resolveRepositoryRoot(cwd, homeDirectory = homedir(), currentUid = process.getuid?.()) {
+  const start = await realpath(cwd);
+  const home = await realpathOrResolved(homeDirectory);
+  const useStart = (notice) => ({
+    root: start,
+    notice
+  });
+  const notUsing = (directory, reason) => useStart(
+    `Not using ${printable(directory)} as the repository root (${reason}).`
+  );
+  for (let directory = start; ; directory = dirname(directory)) {
+    const gitEntry = await classifyGitEntry(directory);
+    if (gitEntry.kind === "unreadable") {
+      return useStart(null);
+    }
+    if (gitEntry.kind !== "none" && directory === start) {
+      return useStart(null);
+    }
+    if (gitEntry.kind === "unacceptable") {
+      return notUsing(directory, "its .git is not a directory or gitdir file");
+    }
+    if (gitEntry.kind === "repository") {
+      if (isSameOrInside(home, directory)) {
+        return useStart(
+          `Not using ${printable(directory)} as the repository root (it contains your home directory); run 'git init' here or run agemon from the repository root.`
+        );
+      }
+      if (!await isOwnedBy(directory, gitEntry, currentUid)) {
+        return notUsing(directory, "it is owned by another user");
+      }
+      return {
+        root: directory,
+        notice: `Using repository root ${printable(directory)} (not the current directory).`
+      };
+    }
+    if (dirname(directory) === directory) {
+      return useStart(null);
+    }
+  }
+}
+
+// src/platform/home.ts
+import { realpath as realpath2 } from "fs/promises";
+import { userInfo } from "os";
+import { isAbsolute as isAbsolute2 } from "path";
+function isUsableAbsolutePath(value) {
+  return isAbsolute2(value) && value === value.trim() && isSafeIdentifier(value);
+}
+function accountHomeDirectory() {
+  try {
+    return userInfo().homedir;
+  } catch {
+    return null;
+  }
+}
+function resolveHomeDirectory() {
+  for (const candidate of [process.env.HOME, accountHomeDirectory()]) {
+    if (candidate && isUsableAbsolutePath(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    "HOME is not an absolute path without control characters or surrounding spaces, and your account has no usable home directory. Set HOME to your home directory and run agemon again."
+  );
+}
+async function realpathOrNull(path) {
+  try {
+    return await realpath2(path);
+  } catch {
+    return null;
+  }
+}
+async function homeDirectoryRealpaths() {
+  const realpaths = [];
+  for (const candidate of [process.env.HOME, accountHomeDirectory()]) {
+    const real = candidate && isAbsolute2(candidate) ? await realpathOrNull(candidate) : null;
+    if (real !== null) {
+      realpaths.push(real);
+    }
+  }
+  return realpaths;
+}
+async function isHomeDirectory(realDirectory) {
+  return (await homeDirectoryRealpaths()).includes(realDirectory);
+}
+async function containsHomeDirectory(realDirectory) {
+  return (await homeDirectoryRealpaths()).some(
+    (home) => isSameOrInside(home, realDirectory)
+  );
+}
+
+// src/plugins/pins.ts
+var CODE_REVIEW_GRAPH_VERSION = "2.3.9";
+var CODE_REVIEW_GRAPH_PACKAGE_SPEC = `code-review-graph==${CODE_REVIEW_GRAPH_VERSION}`;
+var AGNIX_VERSION = "0.58.0";
+var AGNIX_RELEASE_ARCHIVE_SHA256 = {
+  "agnix-x86_64-unknown-linux-gnu.tar.gz": "68cbf435c87e89319133cd4fd4b8b0c8b0763b17862f231bf495ccb9d8ee074b",
+  "agnix-x86_64-unknown-linux-musl.tar.gz": "692d8e90017629e69d9256842ab010a6396affb1c482952f5988ade05fdbccd3",
+  "agnix-aarch64-unknown-linux-gnu.tar.gz": "66b1ad951232b7f112e36b2fd8d7dae01ed3a89f84eee2152f5a2baf4dd8b0a7",
+  "agnix-aarch64-apple-darwin.tar.gz": "a0585c5ad000d8c6861f545ff55d0a7b09460653cd29e56c15675bb9e6e62fe7"
+};
+var AGNIX_NPM_TARBALL = {
+  url: `https://registry.npmjs.org/agnix/-/agnix-${AGNIX_VERSION}.tgz`,
+  integrity: "sha512-DpGdAmG66EmwNSlX+JXiEUbCL+dxbOiDAjzniHgafFbfDfQKYGHyEEVBT1JcKAMPVapM3U2jCU1U+4UCOnT/TA=="
+};
+var AGNIX_PACKAGE_FILE_SHA256 = {
+  "package.json": "c214b20e9ba469c9fb318937a5aa2efbddff057797fd77eda49eefcdb869dd8b",
+  "bin/agnix": "34a7b789cea9872deb3c81fde838c003a3b4366f3924d06e9deb3cccc60228af"
+};
+var AGNIX_BINARY_SHA256 = [
+  "d220619c26e4b6f8448bad36816608dfeca0ae2b7c3153ea1d772d485eec6bc9",
+  "b4a3c1c630e36dbc3227da82a14b5b055e3add70f5d8384675fbab8e4ae317e6",
+  "fca697c810e5ea6598c48377171ad57fdae8b8b82ac9f33c6e6d1c7338ec2987",
+  "d9dc2071417d9f5c288e87031f861eba8689586f8f6df9c30a2a21348ceba598"
+];
+
+// src/core/fingerprint.ts
+import { createHash as createHash2 } from "crypto";
+function canonicalizeJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => canonicalizeJsonValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const sortedEntries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    return Object.fromEntries(
+      sortedEntries.map(([key, entryValue]) => [
+        key,
+        canonicalizeJsonValue(entryValue)
+      ])
+    );
+  }
+  return value;
+}
+function sha256Hex(contents) {
+  return createHash2("sha256").update(contents).digest("hex");
+}
+function fingerprintJson(value) {
+  return sha256Hex(JSON.stringify(canonicalizeJsonValue(value)));
+}
+function fingerprintContent(contents) {
+  return sha256Hex(contents);
+}
+
+// src/plugins/skills/skill-tree.ts
+import { constants as constants3 } from "fs";
+import { lstat as lstat3, open as open3, opendir } from "fs/promises";
+import { join as join2 } from "path";
+var MAX_SKILL_ENTRIES = 200;
+var MAX_SKILL_DEPTH = 8;
+var MAX_SKILL_BYTES = 8 * 1024 * 1024;
+var FINDER_METADATA_FILE = ".DS_Store";
+var SKILLS_CLI_COPY_EXCLUSIONS = {
+  anyName: ["metadata.json"],
+  directoryNames: [".git", "__pycache__", "__pypackages__"]
+};
+var SkillTreeRefusal = class extends Error {
+};
+var keepEveryEntry = () => false;
+function isLeftOutBySkillsCli(name, stats) {
+  return SKILLS_CLI_COPY_EXCLUSIONS.anyName.includes(name) || stats.isDirectory() && SKILLS_CLI_COPY_EXCLUSIONS.directoryNames.includes(
+    name
+  );
+}
+function isFinderMetadataFile(name, stats) {
+  return name === FINDER_METADATA_FILE && stats.isFile();
+}
+async function readRegularFileWithoutFollowing(path, maxBytes) {
+  const handle = await open3(
+    path,
+    constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
+  );
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile()) {
+      return null;
+    }
+    if (stats.size > maxBytes) {
+      throw new SkillTreeRefusal("it is larger than 8 MiB");
+    }
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+async function sortedNamesUpToCap(directory) {
+  const names = [];
+  for await (const entry of await opendir(directory)) {
+    names.push(entry.name);
+    if (names.length > MAX_SKILL_ENTRIES) {
+      throw new SkillTreeRefusal(
+        `it has more than ${MAX_SKILL_ENTRIES} entries`
+      );
+    }
+  }
+  return names.sort();
+}
+async function readSkillTree(directory, skipEntry = keepEveryEntry) {
+  const entries = [];
+  let totalBytes = 0;
+  const walk = async (relativeDirectory, depth) => {
+    if (depth > MAX_SKILL_DEPTH) {
+      throw new SkillTreeRefusal(
+        `it is nested deeper than ${MAX_SKILL_DEPTH} levels`
+      );
+    }
+    for (const name of await sortedNamesUpToCap(
+      join2(directory, relativeDirectory)
+    )) {
+      const relativePath = relativeDirectory === "" ? name : `${relativeDirectory}/${name}`;
+      const absolutePath = join2(directory, relativePath);
+      const stats = await lstat3(absolutePath);
+      if (skipEntry(name, stats)) {
+        continue;
+      }
+      if (entries.length >= MAX_SKILL_ENTRIES) {
+        throw new SkillTreeRefusal(
+          `it has more than ${MAX_SKILL_ENTRIES} entries`
+        );
+      }
+      if (stats.isDirectory()) {
+        entries.push({ relativePath, contents: null, mode: stats.mode });
+        await walk(relativePath, depth + 1);
+        continue;
+      }
+      const contents = stats.isFile() ? await readRegularFileWithoutFollowing(
+        absolutePath,
+        MAX_SKILL_BYTES - totalBytes
+      ) : null;
+      if (contents === null) {
+        throw new SkillTreeRefusal(
+          `${printable(relativePath)} is a symlink or not a regular file`
+        );
+      }
+      totalBytes += contents.length;
+      if (totalBytes > MAX_SKILL_BYTES) {
+        throw new SkillTreeRefusal("it is larger than 8 MiB");
+      }
+      entries.push({ relativePath, contents, mode: stats.mode });
+    }
+  };
+  await walk("", 1);
+  return entries;
+}
+function fingerprintSkillTree(entries) {
+  return fingerprintJson(
+    entries.map((entry) => [
+      entry.relativePath,
+      entry.contents === null ? null : sha256Hex(entry.contents)
+    ])
+  );
+}
+async function fingerprintSkillSource(directory) {
+  return fingerprintSkillTree(
+    await readSkillTree(directory, isLeftOutBySkillsCli)
+  );
+}
+function readInstalledSkill(directory) {
+  return readSkillTree(directory, isFinderMetadataFile);
+}
+async function fingerprintInstalledSkill(directory) {
+  return fingerprintSkillTree(await readInstalledSkill(directory));
+}
+
+// src/core/state-root.ts
+import { constants as constants4 } from "fs";
+import { mkdir as mkdir2, open as open5, readFile as readFile2, realpath as realpath3, stat } from "fs/promises";
+import { homedir as homedir2, userInfo as userInfo2 } from "os";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join3 } from "path";
+
+// src/core/file-lock.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { execFile } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { lstat as lstat4, open as open4, readFile, rm as rm2 } from "fs/promises";
+import { setTimeout as sleep } from "timers/promises";
+var LOCK_FILE_MODE = 384;
+var DEFAULT_POLL_MS = 200;
+var UNREADABLE_LOCK_GRACE_MS = 3e4;
+var STALE_BREAKER_AGE_MS = 6e4;
+var BREAKER_SUFFIX = ".break";
+var START_TIME_INDEX_AFTER_NAME = 19;
+var SMALLEST_TRUSTED_PID = 2;
+var SYSCTL_PATH = "/usr/sbin/sysctl";
+var SYSCTL_TIMEOUT_MS = 5e3;
+var SYSCTL_OUTPUT_LIMIT_BYTES = 1024;
+var BOOT_SESSION_UUID_PATTERN = /^[0-9A-F]{8}(?:-[0-9A-F]{4}){3}-[0-9A-F]{12}$/iu;
+var locksHeldByThisCallChain = new AsyncLocalStorage();
+function parseProcessStartTime(statContents) {
+  const endOfName = statContents.lastIndexOf(")");
+  if (endOfName < 0) {
+    return null;
+  }
+  const fieldsAfterName = statContents.slice(endOfName + 1).trim().split(/\s+/u);
+  return fieldsAfterName[START_TIME_INDEX_AFTER_NAME] ?? null;
+}
+async function readTrimmedOrNull(path) {
+  try {
+    return (await readFile(path, "utf8")).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var linuxProcessProbe = {
+  bootId: () => readTrimmedOrNull("/proc/sys/kernel/random/boot_id"),
+  async startTime(pid) {
+    const stat2 = await readTrimmedOrNull(`/proc/${pid}/stat`);
+    return stat2 === null ? null : parseProcessStartTime(stat2);
+  },
+  exists: processExists
+};
+function readBootSessionUuidWithSysctl() {
+  return new Promise((resolve3, reject) => {
+    execFile(
+      SYSCTL_PATH,
+      ["-n", "kern.bootsessionuuid"],
+      { timeout: SYSCTL_TIMEOUT_MS, maxBuffer: SYSCTL_OUTPUT_LIMIT_BYTES },
+      (error, stdout) => error ? reject(error) : resolve3(stdout)
+    );
+  });
+}
+function createDarwinProcessProbe(readBootSessionUuid = readBootSessionUuidWithSysctl) {
+  let bootId;
+  return {
+    bootId() {
+      bootId ??= readBootSessionUuid().then(
+        (output) => BOOT_SESSION_UUID_PATTERN.test(output.trim()) ? output.trim() : null,
+        () => null
+      );
+      return bootId;
+    },
+    startTime: async () => null,
+    exists: processExists
+  };
+}
+var hostProcessProbe = process.platform === "darwin" ? createDarwinProcessProbe() : linuxProcessProbe;
+function parseLockOwner(contents) {
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const owner = parsed;
+  const isNullableString = (value) => value === null || typeof value === "string";
+  const hasTrustedPid = Number.isSafeInteger(owner.pid) && owner.pid >= SMALLEST_TRUSTED_PID;
+  if (typeof owner.token !== "string" || !hasTrustedPid || !isNullableString(owner.bootId) || !isNullableString(owner.startTime) || typeof owner.acquiredAt !== "string") {
+    return null;
+  }
+  return owner;
+}
+async function isOwnerAlive(owner, probe) {
+  const currentBootId = await probe.bootId();
+  if (currentBootId !== null && owner.bootId !== null) {
+    if (owner.bootId !== currentBootId) {
+      return false;
+    }
+    if (owner.startTime !== null) {
+      return await probe.startTime(owner.pid) === owner.startTime;
+    }
+  }
+  return probe.exists(owner.pid);
+}
+async function isOlderThan(path, ageMs) {
+  try {
+    return Date.now() - (await lstat4(path)).mtimeMs > ageMs;
+  } catch {
+    return false;
+  }
+}
+async function isStaleLock(lockPath, contents, probe) {
+  const owner = parseLockOwner(contents);
+  if (owner === null) {
+    return isOlderThan(lockPath, UNREADABLE_LOCK_GRACE_MS);
+  }
+  return !await isOwnerAlive(owner, probe);
+}
+async function createLockFile(lockPath, contents) {
+  let handle;
+  try {
+    handle = await open4(lockPath, "wx", LOCK_FILE_MODE);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+  try {
+    await handle.writeFile(contents, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  return true;
+}
+async function breakStaleLock(lockPath, staleContents, probe) {
+  const breakerPath = `${lockPath}${BREAKER_SUFFIX}`;
+  if (!await createLockFile(breakerPath, String(process.pid))) {
+    if (await isOlderThan(breakerPath, STALE_BREAKER_AGE_MS)) {
+      await rm2(breakerPath, { force: true });
+    }
+    return false;
+  }
+  try {
+    if (await readRegularFileIfExists(lockPath) !== staleContents || !await isStaleLock(lockPath, staleContents, probe)) {
+      return false;
+    }
+    await rm2(lockPath, { force: true });
+    return true;
+  } finally {
+    await rm2(breakerPath, { force: true });
+  }
+}
+function describeHolder(contents) {
+  const owner = contents === null ? null : parseLockOwner(contents);
+  return owner === null ? "another agemon run" : `another agemon run (pid ${owner.pid}, since ${printable(owner.acquiredAt)})`;
+}
+async function acquireLock(lockPath, ownerContents, options, probe) {
+  const deadline = Date.now() + options.waitMs;
+  for (; ; ) {
+    if (await createLockFile(lockPath, ownerContents)) {
+      return;
+    }
+    const existing = await readRegularFileIfExists(lockPath);
+    if (existing === null) {
+      continue;
+    }
+    if (await isStaleLock(lockPath, existing, probe) && await breakStaleLock(lockPath, existing, probe)) {
+      continue;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `${describeHolder(existing)} holds ${printable(lockPath)}. Wait for it to finish; delete that file only if no agemon is running (an unreadable lock counts as stale after 30 s).`
+      );
+    }
+    await sleep(options.pollMs ?? DEFAULT_POLL_MS);
+  }
+}
+async function releaseLock(lockPath, ownerContents) {
+  if (await readRegularFileIfExists(lockPath) === ownerContents) {
+    await rm2(lockPath, { force: true });
+  }
+}
+async function withFileLock(lockPath, work, options) {
+  const heldLocks = locksHeldByThisCallChain.getStore() ?? /* @__PURE__ */ new Set();
+  if (heldLocks.has(lockPath)) {
+    throw new Error(
+      `agemon tried to take ${printable(lockPath)} while already holding it.`
+    );
+  }
+  const probe = options.probe ?? hostProcessProbe;
+  const owner = {
+    token: randomUUID2(),
+    pid: process.pid,
+    bootId: await probe.bootId(),
+    startTime: await probe.startTime(process.pid),
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const ownerContents = JSON.stringify(owner);
+  await acquireLock(lockPath, ownerContents, options, probe);
+  const held = {
+    async assertStillHeld() {
+      if (await readRegularFileIfExists(lockPath) !== ownerContents) {
+        throw new Error(
+          `agemon's lock ${printable(lockPath)} was removed or replaced by another run; nothing more was changed. Run agemon again.`
+        );
+      }
+    }
+  };
+  try {
+    return await locksHeldByThisCallChain.run(
+      /* @__PURE__ */ new Set([...heldLocks, lockPath]),
+      () => work(held)
+    );
+  } finally {
+    await releaseLock(lockPath, ownerContents);
+  }
+}
+
+// src/core/state-root.ts
+var PRIVATE_DIRECTORY_MODE = 448;
+var PERMISSION_BITS2 = 511;
+var GROUP_AND_OTHER_BITS = 63;
+var GROUP_WRITE = 16;
+var OTHER_WRITE = 2;
+var STICKY_BIT = 512;
+var ROOT_UID = 0;
+var REPOSITORY_STATE_KEY_LENGTH = 16;
+var RUN_LOCK_WAIT_MS = 0;
+function currentAccounts() {
+  const user = userInfo2();
+  return {
+    uid: user.uid,
+    username: user.username,
+    groupFile: "/etc/group",
+    passwdFile: "/etc/passwd"
+  };
+}
+function resolveStateRoot(hostPlatform = process.platform) {
+  const xdgStateHome = process.env.XDG_STATE_HOME;
+  if (xdgStateHome && isAbsolute3(xdgStateHome)) {
+    return xdgStateHome;
+  }
+  const homeDirectory = homedir2();
+  if (!isAbsolute3(homeDirectory)) {
+    throw new Error(
+      "Cannot locate agemon's state directory: set HOME (or XDG_STATE_HOME) to an absolute path."
+    );
+  }
+  return hostPlatform === "darwin" ? join3(homeDirectory, "Library", "Application Support") : join3(homeDirectory, ".local", "state");
+}
+async function readColonSeparatedRows(path) {
+  return (await readFile2(path, "utf8")).split("\n").filter((line) => line.length > 0).map((line) => line.split(":"));
+}
+async function isUserPrivateGroup(gid, accounts) {
+  let groups;
+  let users;
+  try {
+    groups = await readColonSeparatedRows(accounts.groupFile);
+    users = await readColonSeparatedRows(accounts.passwdFile);
+  } catch {
+    return false;
+  }
+  const groupsWithGid = groups.filter((fields) => fields[2] === String(gid));
+  const isPrivateGroupRow = (fields) => fields[0] === accounts.username && (fields[3] ?? "").trim() === "";
+  if (groupsWithGid.length === 0 || !groupsWithGid.every(isPrivateGroupRow)) {
+    return false;
+  }
+  return !users.some(
+    (fields) => fields[3] === String(gid) && fields[0] !== accounts.username
+  );
+}
+function refuseDirectory(directory, reason) {
+  throw new Error(
+    `Refusing to use ${printable(directory)}: ${reason}. Fix it (for example 'chmod g-w,o-w ${printable(directory)}', or point XDG_STATE_HOME at a directory you own), then run agemon again. Groups served only by LDAP or NSS are not recognised as private.`
+  );
+}
+async function assertNotWritableByOthers(directory, mode, gid, accounts) {
+  if (mode & OTHER_WRITE) {
+    refuseDirectory(directory, "other users can write to it");
+  }
+  if (mode & GROUP_WRITE && !await isUserPrivateGroup(gid, accounts)) {
+    refuseDirectory(directory, "its group can write to it");
+  }
+}
+async function assertSafeStateRoot(stateRoot, accounts) {
+  let stats;
+  try {
+    stats = await stat(stateRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  if (!stats.isDirectory()) {
+    refuseDirectory(stateRoot, "it is not a directory");
+  }
+  if (stats.uid !== accounts.uid && stats.uid !== ROOT_UID) {
+    refuseDirectory(stateRoot, "it is owned by another user");
+  }
+  if (!(stats.mode & STICKY_BIT)) {
+    await assertNotWritableByOthers(stateRoot, stats.mode, stats.gid, accounts);
+  }
+}
+async function openAgemonDirectory(directory, mode) {
+  const flags = constants4.O_RDONLY | constants4.O_DIRECTORY | constants4.O_NOFOLLOW;
+  try {
+    return await open5(directory, flags);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ELOOP" || code === "ENOTDIR") {
+      refuseDirectory(directory, "it is not a real directory");
+    }
+    if (code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (mode === "check") {
+    return null;
+  }
+  try {
+    await mkdir2(directory, { mode: PRIVATE_DIRECTORY_MODE });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  return openAgemonDirectory(directory, "check");
+}
+async function resolveAgemonStateDirectory(mode, accounts = currentAccounts()) {
+  const stateRoot = resolveStateRoot();
+  const directory = join3(stateRoot, "agemon");
+  if (mode === "prepare") {
+    await mkdir2(stateRoot, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  }
+  await assertSafeStateRoot(stateRoot, accounts);
+  const handle = await openAgemonDirectory(directory, mode);
+  if (handle === null) {
+    return { path: directory, tightenedFromMode: null };
+  }
+  try {
+    const stats = await handle.stat();
+    if (stats.uid !== accounts.uid) {
+      refuseDirectory(directory, "it is owned by another user");
+    }
+    await assertNotWritableByOthers(directory, stats.mode, stats.gid, accounts);
+    if (mode === "check" || !(stats.mode & GROUP_AND_OTHER_BITS)) {
+      return { path: directory, tightenedFromMode: null };
+    }
+    await handle.chmod(PRIVATE_DIRECTORY_MODE);
+    return {
+      path: directory,
+      tightenedFromMode: stats.mode & PERMISSION_BITS2
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function checkAgemonStateDirectoryBeforeRun(dryRun, report) {
+  const directory = await resolveAgemonStateDirectory(
+    dryRun ? "check" : "prepare"
+  );
+  if (directory.tightenedFromMode !== null) {
+    report(
+      `Restricted ${printable(directory.path)} to its owner (mode was ${directory.tightenedFromMode.toString(8)}).`
+    );
+  }
+}
+async function preparePrivateStateDirectory(name) {
+  const directory = join3(
+    (await resolveAgemonStateDirectory("prepare")).path,
+    name
+  );
+  await mkdir2(directory, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  return directory;
+}
+function prepareToolsRoot() {
+  return preparePrivateStateDirectory("tools");
+}
+async function repositoryStateKey(repoRoot) {
+  return sha256Hex(await realpath3(repoRoot)).slice(
+    0,
+    REPOSITORY_STATE_KEY_LENGTH
+  );
+}
+async function withAgemonStateLock(lockRelativePath, work, waitMs) {
+  const lockPath = join3(
+    (await resolveAgemonStateDirectory("prepare")).path,
+    lockRelativePath
+  );
+  await mkdir2(dirname2(lockPath), {
+    recursive: true,
+    mode: PRIVATE_DIRECTORY_MODE
+  });
+  return withFileLock(lockPath, work, { waitMs });
+}
+async function withRepositoryRunLock(repoRoot, work) {
+  return withAgemonStateLock(
+    join3("runs", `${await repositoryStateKey(repoRoot)}.lock`),
+    () => work(),
+    RUN_LOCK_WAIT_MS
+  );
+}
+
+// src/plugins/skills/skills-cli.ts
+import { existsSync as existsSync2 } from "fs";
+import {
+  copyFile,
+  mkdtemp,
+  readdir,
+  readFile as readFile3,
+  rename as rename2,
+  rm as rm3
+} from "fs/promises";
+import { join as join5 } from "path";
+
+// src/core/package-assets.ts
+import { existsSync, lstatSync, readFileSync } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "agemon";
+var PACKAGE_MANIFEST = "package.json";
+var MAX_PACKAGE_MANIFEST_BYTES = 1024 * 1024;
+var cachedPackageRoot;
+function readPackageName(manifestPath) {
+  const stats = lstatSync(manifestPath);
+  if (!stats.isFile() || stats.size > MAX_PACKAGE_MANIFEST_BYTES) {
+    return null;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return typeof manifest === "object" && manifest !== null && "name" in manifest && typeof manifest.name === "string" ? manifest.name : null;
+  } catch {
+    return null;
+  }
+}
+function findNearestPackageDirectory(startDirectory) {
+  let currentDir = startDirectory;
+  for (; ; ) {
+    if (existsSync(join4(currentDir, PACKAGE_MANIFEST))) {
+      return currentDir;
+    }
+    const parentDir = dirname3(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolvePackageRootFrom(startDirectory) {
+  const packageDirectory = findNearestPackageDirectory(startDirectory);
+  if (packageDirectory === null || readPackageName(join4(packageDirectory, PACKAGE_MANIFEST)) !== PACKAGE_NAME || !existsSync(join4(packageDirectory, "assets", "skills"))) {
+    throw new Error(
+      "Unable to locate agemon's vendored assets/skills directory."
+    );
+  }
+  return packageDirectory;
+}
+function resolvePackageRoot() {
+  cachedPackageRoot ??= resolvePackageRootFrom(
+    dirname3(fileURLToPath(import.meta.url))
+  );
+  return cachedPackageRoot;
+}
+function resolveVendoredSkillPath(groupId, skillId) {
+  return join4(resolvePackageRoot(), "assets", "skills", groupId, skillId);
+}
+function resolveToolsManifestDirectory() {
+  return join4(resolvePackageRoot(), "assets", "tools");
+}
+
+// src/core/subprocess-runner.ts
+import { spawn } from "child_process";
+import { isAbsolute as isAbsolute4 } from "path";
+
+// src/inspect/redact.ts
+var DENYLISTED_FILE_PATTERNS = [
+  /(^|\/)\.env(\.[^/]*)?$/,
+  /\.pem$/i,
+  /(^|\/)id_(?:rsa|ed25519|ecdsa|dsa)/i,
+  /\.key$/i,
+  /\.p12$/i,
+  /\.pfx$/i,
+  /(^|\/)\.pypirc$/,
+  /(^|\/)\.aws\/credentials$/,
+  /(^|\/)\.docker\/config\.json$/,
+  /(^|\/)\.npmrc$/,
+  /(^|\/)\.netrc$/,
+  /(^|\/)\.git-credentials$/,
+  /\.local\.json$/,
+  /(^|\/)\.kube\/config$/,
+  /(^|\/)\.pgpass$/,
+  /\.ppk$/i,
+  /\.jks$/i,
+  /\.keystore$/i,
+  /(^|\/)credentials\.json$/,
+  /(^|\/)\.config\/gh\/hosts\.yml$/,
+  /(^|\/)\.vault-token$/,
+  /(^|\/)credentials\.tfrc\.json$/,
+  /(^|\/)application_default_credentials\.json$/,
+  /(^|\/)\.azure\/accessTokens\.json$/,
+  /\.kdbx$/i,
+  /(^|\/)\.config\/gcloud\/credentials\.db$/,
+  /(^|\/)\.gnupg\//,
+  /(^|\/)\.terraformrc$/,
+  /(^|\/)[^/]*service[-_]account[^/]*\.json$/i
+];
+var CREDENTIAL_KEY_PATTERN = /(?:^|[._-])(?:tokens?|secret|password|passwd|pwd|api[._-]?key|access[._-]?key|client[._-]?secret|auth|authorization|credentials?|private[._-]?key)(?:$|[._-])|_key$|^key$/i;
+var CAMEL_CASE_BOUNDARY = /([a-z0-9])([A-Z])/g;
+var CONCATENATED_CREDENTIAL_SUFFIX = /(?:token|secret|password|passwd|apikey)$/i;
+var PEM_DASHES = "-{4,5}";
+var PEM_LABEL = "[A-Z0-9 ]+";
+var PEM_BEGIN = `${PEM_DASHES} ?BEGIN ${PEM_LABEL}${PEM_DASHES}`;
+var PEM_END = `${PEM_DASHES} ?END ${PEM_LABEL}${PEM_DASHES}`;
+var PEM_PATTERN = new RegExp(PEM_BEGIN, "i");
+var JWT_PATTERN = /^eyJ[A-Za-z0-9_-]+=*\.eyJ[A-Za-z0-9_-]+=*\.[A-Za-z0-9_-]+=*$/;
+var URL_WITH_CREDENTIALS_PATTERN = /\b[a-z][a-z0-9+.-]{0,31}:\/\/[^/\s:@]+:[^/\s:@]+@/i;
+var MAX_REDACTED_LINE_CHARACTERS = 4096;
+var HIGH_ENTROPY_MIN_LENGTH = 32;
+var HIGH_ENTROPY_MIN_BITS_PER_CHAR = 3.5;
+var HIGH_ENTROPY_CHARSET = /^[A-Za-z0-9+/=_-]+$/;
+var MIN_PATH_SEGMENTS = 3;
+var MIXED_SEGMENT_MIN_LENGTH = 16;
+var WORD_SEPARATOR = /[-_]/;
+function isDenylistedPath(relativePath) {
+  return DENYLISTED_FILE_PATTERNS.some((pattern) => pattern.test(relativePath));
+}
+function shannonEntropyBitsPerChar(value) {
+  const characterCounts = /* @__PURE__ */ new Map();
+  for (const character of value) {
+    characterCounts.set(character, (characterCounts.get(character) ?? 0) + 1);
+  }
+  let bitsPerChar = 0;
+  for (const count of characterCounts.values()) {
+    const probability = count / value.length;
+    bitsPerChar -= probability * Math.log2(probability);
+  }
+  return bitsPerChar;
+}
+function mixesCasesAndDigits(value) {
+  return /[A-Z]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value);
+}
+function looksLikeSecretPathSegment(segment) {
+  if (shannonEntropyBitsPerChar(segment) < HIGH_ENTROPY_MIN_BITS_PER_CHAR) {
+    return false;
+  }
+  return segment.length >= MIXED_SEGMENT_MIN_LENGTH && mixesCasesAndDigits(segment) || segment.length >= HIGH_ENTROPY_MIN_LENGTH && !WORD_SEPARATOR.test(segment);
+}
+function looksLikeWordPath(value) {
+  const segments = value.split("/");
+  return value.startsWith("/") && segments.length >= MIN_PATH_SEGMENTS && !segments.some(looksLikeSecretPathSegment);
+}
+function looksHighEntropy(value) {
+  return value.length >= HIGH_ENTROPY_MIN_LENGTH && HIGH_ENTROPY_CHARSET.test(value) && shannonEntropyBitsPerChar(value) >= HIGH_ENTROPY_MIN_BITS_PER_CHAR && !looksLikeWordPath(value);
+}
+function stripKeyDecoration(rawKey) {
+  return rawKey.replace(/^[-"']+/, "").replace(/["':]+$/, "");
+}
+function namesCredentialKey(rawKey) {
+  const key = stripKeyDecoration(rawKey);
+  return CREDENTIAL_KEY_PATTERN.test(key.replace(CAMEL_CASE_BOUNDARY, "$1_$2")) || CONCATENATED_CREDENTIAL_SUFFIX.test(key);
+}
+function classifyString(value) {
+  if (PEM_PATTERN.test(value)) {
+    return "pem";
+  }
+  if (JWT_PATTERN.test(value)) {
+    return "jwt";
+  }
+  if (URL_WITH_CREDENTIALS_PATTERN.test(value)) {
+    return "url-credentials";
+  }
+  if (looksHighEntropy(value)) {
+    return "high-entropy";
+  }
+  return null;
+}
+function redactJsonValue(input) {
+  const redactedPaths = [];
+  const walk = (value, path, insideCredentialKey) => {
+    if (typeof value === "string") {
+      const reason = insideCredentialKey ? "credential-key" : classifyString(value.slice(0, MAX_REDACTED_LINE_CHARACTERS));
+      if (reason === null) {
+        return value;
+      }
+      redactedPaths.push(path);
+      return redactedMarker(reason);
+    }
+    if (Array.isArray(value)) {
+      return value.map(
+        (entry, index) => walk(entry, `${path}[${index}]`, insideCredentialKey)
+      );
+    }
+    if (value !== null && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(
+          ([key, entryValue]) => [
+            key,
+            walk(
+              entryValue,
+              path === "" ? key : `${path}.${key}`,
+              insideCredentialKey || namesCredentialKey(key)
+            )
+          ]
+        )
+      );
+    }
+    return value;
+  };
+  return { value: walk(input, "", false), redactedPaths };
+}
+var PEM_BLOCK_PATTERN = new RegExp(
+  `${PEM_BEGIN}[\\s\\S]*?(?:${PEM_END}|$)`,
+  "gi"
+);
+var PEM_TAIL_WITHOUT_BEGIN_PATTERN = new RegExp(
+  `^(?:[A-Za-z0-9+/=]+\\r?\\n)*${PEM_END}`,
+  "gim"
+);
+var TOKEN_WRAPPER_PATTERN = /^([("'`[{<]*)(.*?)([)"'`\]}>,;.]*)$/s;
+var KEY_SEPARATOR_PATTERN = /([A-Za-z0-9_.-]+)(["']?[=:])/g;
+var ASSIGNMENT_PATTERN = /^([A-Za-z0-9_.-]+=)(.+)$/s;
+var KEY_PATH_SEPARATOR = /[/:?&]/;
+var STANDALONE_SEPARATORS = /* @__PURE__ */ new Set(["=", ":"]);
+var AUTH_SCHEME_PATTERN = /^(?:bearer|basic)$/i;
+var AUTHORIZATION_TOKEN_SCHEME = /^token$/i;
+function redactedMarker(reason) {
+  return `<redacted:${reason}>`;
+}
+function announcesSecretInText(rawKey) {
+  return namesCredentialKey(rawKey) || AUTH_SCHEME_PATTERN.test(stripKeyDecoration(rawKey));
+}
+function redactKeyValue(token) {
+  for (const match of token.matchAll(KEY_SEPARATOR_PATTERN)) {
+    if (!announcesSecretInText(match[1])) {
+      continue;
+    }
+    const valueStart = (match.index ?? 0) + match[0].length;
+    const upToValue = token.slice(0, valueStart);
+    const [, valuePrefix, value, valueSuffix] = TOKEN_WRAPPER_PATTERN.exec(
+      token.slice(valueStart)
+    );
+    if (value.length === 0 || AUTH_SCHEME_PATTERN.test(value)) {
+      return { text: token, announcesSecret: true };
+    }
+    return {
+      text: `${upToValue}${valuePrefix}${redactedMarker("credential-key")}${valueSuffix}`,
+      announcesSecret: false
+    };
+  }
+  return null;
+}
+function redactAssignedValue(core) {
+  const assignment = ASSIGNMENT_PATTERN.exec(core);
+  if (assignment === null) {
+    return null;
+  }
+  const reason = classifyString(assignment[2]);
+  return reason === null ? null : `${assignment[1]}${redactedMarker(reason)}`;
+}
+function redactToken(token, previousToken, secretWasAnnounced) {
+  const [, prefix, core, suffix] = TOKEN_WRAPPER_PATTERN.exec(
+    token
+  );
+  if (AUTH_SCHEME_PATTERN.test(core)) {
+    return { text: token, announcesSecret: true };
+  }
+  if (secretWasAnnounced) {
+    if (AUTHORIZATION_TOKEN_SCHEME.test(core)) {
+      return { text: token, announcesSecret: true };
+    }
+    return {
+      text: `${prefix}${redactedMarker("credential-key")}${suffix}`,
+      announcesSecret: false
+    };
+  }
+  if (STANDALONE_SEPARATORS.has(core)) {
+    return {
+      text: token,
+      announcesSecret: announcesSecretInText(
+        previousToken.split(KEY_PATH_SEPARATOR).at(-1) ?? ""
+      )
+    };
+  }
+  const keyValue = redactKeyValue(token);
+  if (keyValue !== null) {
+    return keyValue;
+  }
+  if (core.startsWith("-") && announcesSecretInText(core)) {
+    return { text: token, announcesSecret: true };
+  }
+  const redactedAssignment = redactAssignedValue(core);
+  if (redactedAssignment !== null) {
+    return {
+      text: `${prefix}${redactedAssignment}${suffix}`,
+      announcesSecret: false
+    };
+  }
+  const reason = classifyString(core);
+  return {
+    text: reason === null ? token : `${prefix}${redactedMarker(reason)}${suffix}`,
+    announcesSecret: false
+  };
+}
+function redactSecretsInText(text) {
+  let previousToken = "";
+  let secretWasAnnounced = false;
+  return text.split("\n").map((line) => line.slice(0, MAX_REDACTED_LINE_CHARACTERS)).join("\n").replace(PEM_BLOCK_PATTERN, redactedMarker("pem")).replace(PEM_TAIL_WITHOUT_BEGIN_PATTERN, redactedMarker("pem")).split(/(\s+)/).map((token) => {
+    if (token.length === 0 || /^\s+$/.test(token)) {
+      return token;
+    }
+    const redaction = redactToken(token, previousToken, secretWasAnnounced);
+    previousToken = token;
+    secretWasAnnounced = redaction.announcesSecret;
+    return redaction.text;
+  }).join("");
+}
+
+// src/core/subprocess-runner.ts
+var MAX_RAW_OUTPUT_LINE_CHARACTERS = MAX_REDACTED_LINE_CHARACTERS;
+var MAX_SHOWN_OUTPUT_LINE_CHARACTERS = 300;
+var FAILURE_OUTPUT_LINES = 10;
+var CONTROL_SEQUENCE_INTRODUCER = `(?:${String.fromCharCode(27)}\\[|${String.fromCharCode(155)})`;
+var TERMINAL_ESCAPE_SEQUENCE = new RegExp(
+  `${CONTROL_SEQUENCE_INTRODUCER}[0-9;?]*[ -/]*[@-~]`,
+  "g"
+);
+var SPAWN_ERROR_PREFIX = "process spawn error: ";
+function sanitizeOutput(text) {
+  return printable(
+    redactSecretsInText(text.replace(TERMINAL_ESCAPE_SEQUENCE, ""))
+  );
+}
+function capShownLine(line) {
+  return line.length > MAX_SHOWN_OUTPUT_LINE_CHARACTERS ? `${line.slice(0, MAX_SHOWN_OUTPUT_LINE_CHARACTERS)}\u2026` : line;
+}
+function safeOutputTail(stream, maxLines) {
+  const rawLines = stream.split("\n");
+  if (rawLines.at(-1) === "") {
+    rawLines.pop();
+  }
+  const earlierLineCount = Math.max(rawLines.length - maxLines, 0);
+  if (rawLines.length === 0) {
+    return { earlierLineCount, lines: [] };
+  }
+  const keptRawText = rawLines.slice(earlierLineCount).map((line) => line.slice(0, MAX_RAW_OUTPUT_LINE_CHARACTERS)).join("\n");
+  return {
+    earlierLineCount,
+    lines: sanitizeOutput(keptRawText).split("\n").map(capShownLine)
+  };
+}
+function describeSubprocessFailure(result, command) {
+  const tail = safeOutputTail(result.stderr.trim(), FAILURE_OUTPUT_LINES);
+  if (tail.lines.every((line) => line.trim() === "")) {
+    return `${command} exited ${result.code}`;
+  }
+  return [
+    ...tail.earlierLineCount > 0 ? [`\u2026 ${tail.earlierLineCount} earlier lines`] : [],
+    ...tail.lines
+  ].join("\n");
+}
+function isSpawnFailure(result) {
+  return result.code === 1 && result.stderr.startsWith(SPAWN_ERROR_PREFIX);
+}
+var NPM_LAUNCH_MARKERS = [
+  "npm_command",
+  "npm_execpath",
+  "npm_config_user_agent"
+];
+var NPM_INJECTED_VARIABLES = ["init_cwd", "node"];
+var NPM_INJECTED_PATH_SUFFIXES = ["/node_modules/.bin", "/node-gyp-bin"];
+function wasLaunchedByNpm(names) {
+  return names.some((name) => NPM_LAUNCH_MARKERS.includes(name.toLowerCase()));
+}
+function isNpmInjectedVariable(name) {
+  const lowerCaseName = name.toLowerCase();
+  return lowerCaseName.startsWith("npm_") || NPM_INJECTED_VARIABLES.includes(lowerCaseName);
+}
+function keepSearchPathEntries(searchPath, launchedByNpm) {
+  return searchPath.split(":").filter(
+    (entry) => isAbsolute4(entry) && !(launchedByNpm && NPM_INJECTED_PATH_SUFFIXES.some(
+      (suffix) => entry.replace(/\/+$/, "").endsWith(suffix)
+    ))
+  ).join(":");
+}
+function agemonSubprocessEnvironment(environment = process.env) {
+  const names = Object.keys(environment);
+  const launchedByNpm = wasLaunchedByNpm(names);
+  const kept = {};
+  for (const name of names) {
+    const value = environment[name];
+    if (value === void 0 || launchedByNpm && isNpmInjectedVariable(name)) {
+      continue;
+    }
+    kept[name] = name === "PATH" ? keepSearchPathEntries(value, launchedByNpm) : value;
+  }
+  return kept;
+}
+var DEFAULT_SUBPROCESS_TIMEOUT_MS = 3e5;
+var MAX_CAPTURED_CHARACTERS_PER_STREAM = 10 * 1024 * 1024;
+var TRUNCATION_MARKER = "\n\u2026[truncated]";
+var HARD_KILL_GRACE_MS = 2e3;
+var STREAM_DRAIN_GRACE_MS = 2e3;
+var TIMEOUT_EXIT_CODE = 124;
+function sliceWithoutSplittingSurrogatePair(text, length) {
+  const lastKeptCodeUnit = text.charCodeAt(length - 1);
+  const endsWithHighSurrogate = lastKeptCodeUnit >= 55296 && lastKeptCodeUnit <= 56319;
+  return text.slice(0, endsWithHighSurrogate ? length - 1 : length);
+}
+function createBoundedCapture() {
+  let text = "";
+  let truncated = false;
+  return {
+    append(chunk) {
+      if (truncated) {
+        return;
+      }
+      const remainingCharacters = MAX_CAPTURED_CHARACTERS_PER_STREAM - text.length;
+      if (chunk.length <= remainingCharacters) {
+        text += chunk;
+        return;
+      }
+      text += `${sliceWithoutSplittingSurrogatePair(chunk, remainingCharacters)}${TRUNCATION_MARKER}`;
+      truncated = true;
+    },
+    get text() {
+      return text;
+    }
+  };
+}
+async function runSubprocess(command, args, options = {}) {
+  if (process.env.AGEMON_FAKE_SUBPROCESS === "1") {
+    const { runFakeSubprocess } = await import("./fake-subprocess-IV4ML77S.js");
+    return runFakeSubprocess(command, args, options);
+  }
+  return runRealSubprocess(command, args, options);
+}
+async function runRealSubprocess(command, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_SUBPROCESS_TIMEOUT_MS;
+  return await new Promise((resolve3) => {
+    let settled = false;
+    let timedOut = false;
+    let timeoutHandle;
+    let hardKillHandle;
+    let drainHandle;
+    const stdout = createBoundedCapture();
+    const stderr = createBoundedCapture();
+    const clearTimers = () => {
+      clearTimeout(timeoutHandle);
+      clearTimeout(hardKillHandle);
+      clearTimeout(drainHandle);
+    };
+    const finalize = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimers();
+      resolve3(result);
+    };
+    const resultForExit = (code, signal) => {
+      if (timedOut) {
+        const timeoutMessage = `Command timed out after ${timeoutMs}ms.`;
+        return {
+          code: TIMEOUT_EXIT_CODE,
+          stdout: stdout.text,
+          stderr: stderr.text ? `${stderr.text}
+${timeoutMessage}` : timeoutMessage
+        };
+      }
+      if (signal) {
+        return {
+          code: 1,
+          stdout: stdout.text,
+          stderr: `${stderr.text}Process terminated by signal: ${signal}`
+        };
+      }
+      return { code: code ?? 1, stdout: stdout.text, stderr: stderr.text };
+    };
+    const finalizeAfterDrainGrace = (code, signal) => {
+      clearTimeout(drainHandle);
+      drainHandle = setTimeout(() => {
+        childProcess.stdout.destroy();
+        childProcess.stderr.destroy();
+        finalize(resultForExit(code, signal));
+      }, STREAM_DRAIN_GRACE_MS);
+    };
+    const environment = {
+      ...agemonSubprocessEnvironment(),
+      ...options.env
+    };
+    for (const name of options.unsetEnv ?? []) {
+      delete environment[name];
+    }
+    const childProcess = spawn(command, args, {
+      cwd: options.cwd ?? process.cwd(),
+      env: environment,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        const signal = options.killSignal ?? "SIGTERM";
+        const terminated = childProcess.kill(signal);
+        if (!terminated) {
+          finalize({
+            code: TIMEOUT_EXIT_CODE,
+            stdout: stdout.text,
+            stderr: `${stderr.text}
+Command timed out after ${timeoutMs}ms and could not be signaled with ${signal}.`
+          });
+          return;
+        }
+        hardKillHandle = setTimeout(() => {
+          childProcess.kill("SIGKILL");
+          finalizeAfterDrainGrace(null, "SIGKILL");
+        }, HARD_KILL_GRACE_MS);
+      }, timeoutMs);
+    }
+    childProcess.stdout.setEncoding("utf8");
+    childProcess.stderr.setEncoding("utf8");
+    childProcess.stdout.on("data", (chunk) => stdout.append(chunk));
+    childProcess.stderr.on("data", (chunk) => stderr.append(chunk));
+    childProcess.on("error", (error) => {
+      const errorMessage = stderr.text ? `${stderr.text}
+${SPAWN_ERROR_PREFIX}${error.message}` : `${SPAWN_ERROR_PREFIX}${error.message}`;
+      finalize({ code: 1, stdout: stdout.text, stderr: errorMessage });
+    });
+    childProcess.on(
+      "exit",
+      (code, signal) => {
+        clearTimeout(timeoutHandle);
+        clearTimeout(hardKillHandle);
+        finalizeAfterDrainGrace(code, signal);
+      }
+    );
+    childProcess.on(
+      "close",
+      (code, signal) => {
+        finalize(resultForExit(code, signal));
+      }
+    );
+  });
+}
+
+// src/plugins/skills/skills-cli.ts
+var TOOLS_LOCK_HASH_LENGTH = 16;
+var TOOLS_INSTALL_TIMEOUT_MS = 18e4;
+var TOOLS_LOCK_WAIT_MS = 10 * 6e4;
+var TOOLS_MANIFEST_FILES = ["package.json", "package-lock.json"];
+var SKILLS_CLI_PATH_IN_TOOLS_DIR = join5(
+  "node_modules",
+  "skills",
+  "bin",
+  "cli.mjs"
+);
+function isLostInstallRace(error) {
+  const code = error.code;
+  return code === "EEXIST" || code === "ENOTEMPTY";
+}
+async function renameUnlessAnotherRunWon(stagingDirectory, toolsDirectory) {
+  try {
+    await rename2(stagingDirectory, toolsDirectory);
+    return true;
+  } catch (error) {
+    if (isLostInstallRace(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function promoteStagingDirectory(stagingDirectory, toolsDirectory, cliPath) {
+  if (await renameUnlessAnotherRunWon(stagingDirectory, toolsDirectory)) {
+    return;
+  }
+  if (existsSync2(cliPath)) {
+    return;
+  }
+  const brokenDirectory = `${stagingDirectory}.broken`;
+  await rename2(toolsDirectory, brokenDirectory);
+  await rm3(brokenDirectory, { recursive: true, force: true });
+  await renameUnlessAnotherRunWon(stagingDirectory, toolsDirectory);
+}
+var ABANDONED_TOOLS_DIRECTORY_PATTERN = /^[0-9a-f]{16}\.tmp-[^/]+$/;
+async function removeAbandonedToolsDirectories(toolsRoot) {
+  for (const entry of await readdir(toolsRoot)) {
+    if (ABANDONED_TOOLS_DIRECTORY_PATTERN.test(entry)) {
+      await rm3(join5(toolsRoot, entry), { recursive: true, force: true });
+    }
+  }
+}
+async function installToolsDirectory(ctx, toolsRoot, manifestDirectory, toolsDirectory, cliPath) {
+  await removeAbandonedToolsDirectories(toolsRoot);
+  const stagingDirectory = await mkdtemp(`${toolsDirectory}.tmp-`);
+  try {
+    for (const fileName of TOOLS_MANIFEST_FILES) {
+      await copyFile(
+        join5(manifestDirectory, fileName),
+        join5(stagingDirectory, fileName)
+      );
+    }
+    const installResult = await ctx.run(
+      "npm",
+      [
+        "ci",
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund",
+        "--prefix",
+        stagingDirectory
+      ],
+      { cwd: stagingDirectory, timeoutMs: TOOLS_INSTALL_TIMEOUT_MS }
+    );
+    if (installResult.code !== 0) {
+      throw new Error(
+        `Installing the pinned skills CLI into ${toolsRoot} failed: ${describeSubprocessFailure(installResult, "npm ci")}`
+      );
+    }
+    await promoteStagingDirectory(stagingDirectory, toolsDirectory, cliPath);
+  } finally {
+    await rm3(stagingDirectory, { recursive: true, force: true });
+  }
+}
+async function ensureSkillsCli(ctx) {
+  const manifestDirectory = resolveToolsManifestDirectory();
+  const lockHash = sha256Hex(
+    await readFile3(join5(manifestDirectory, "package-lock.json"))
+  ).slice(0, TOOLS_LOCK_HASH_LENGTH);
+  const toolsRoot = await prepareToolsRoot();
+  const toolsDirectory = join5(toolsRoot, lockHash);
+  const cliPath = join5(toolsDirectory, SKILLS_CLI_PATH_IN_TOOLS_DIR);
+  if (existsSync2(cliPath)) {
+    return cliPath;
+  }
+  await withAgemonStateLock(
+    "tools.lock",
+    async () => {
+      if (!existsSync2(cliPath)) {
+        await installToolsDirectory(
+          ctx,
+          toolsRoot,
+          manifestDirectory,
+          toolsDirectory,
+          cliPath
+        );
+      }
+    },
+    TOOLS_LOCK_WAIT_MS
+  );
+  return cliPath;
+}
+async function runSkillsCli(ctx, args, timeoutMs) {
+  const cliPath = await ensureSkillsCli(ctx);
+  return ctx.run(process.execPath, [cliPath, ...args], {
+    cwd: ctx.cwd,
+    timeoutMs
+  });
+}
+
+// src/core/config.ts
+import { join as join7, relative as relative2 } from "path";
+import { isDeepStrictEqual } from "util";
+
+// node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r?\n/);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r?\n/);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class _TomlError extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+  /** @internal */
+  static x(message, ctx, ptr) {
+    throw new _TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+  }
+};
+
+// node_modules/smol-toml/dist/primitive.js
+function parseString(ctx) {
+  let startPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in strings", ctx);
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state) {
+        let s = ctx.s.slice(sliceStart, ctx.p);
+        parsed = parsed ? parsed + s : s;
+      }
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let errPtr = ctx.p++ - 1;
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            TomlError.x("invalid non-hex character in unicode escape", ctx);
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          TomlError.x("invalid unicode escape", ctx, errPtr);
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p--;
+        state = 0;
+      } else if (isMultiline && (c === 32 || c === 9)) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          TomlError.x("unrecognised escape sequence", ctx);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2)
+        TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  TomlError.x("unfinished string", ctx, startPtr);
+}
+
+// node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date, fasttype, unsafeDelim) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    let c;
+    if (typeof date === "string") {
+      if (fasttype)
+        prep: {
+          if (fasttype < 3) {
+            if (+date.slice(11, 13) > 23) {
+              date = "";
+              break prep;
+            }
+            if (fasttype === 2) {
+              offset = null;
+              date += "Z";
+            } else if ((c = date.charCodeAt(date.length - 1)) !== 90 && c !== 122) {
+              offset = date.slice(date.length - 6);
+            }
+            if (unsafeDelim)
+              date = date.slice(0, 10) + "T" + date.slice(11);
+          } else if (fasttype === 4) {
+            date = +date.slice(0, 2) > 23 ? "" : `0000-01-01T${date}Z`;
+          }
+          hasDate = fasttype !== 4;
+          hasTime = fasttype !== 3;
+        }
+      else {
+        let match = date.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date = `0000-01-01T${date}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+          if (match[2] && +match[2] > 23) {
+            date = "";
+          } else {
+            offset = match[3] || null;
+            if (!offset && hasTime)
+              date += "Z";
+          }
+        } else {
+          date = "";
+        }
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z" || this.#offset === "z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// node_modules/smol-toml/dist/extract.js
+function isDigit(char, base = 10) {
+  return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
+}
+function isEndOfValue(char, delim) {
+  return char === 32 || char === 9 || char === 10 || char === 13 || // Structure end or next value delimiter
+  delim && (char === delim || char === 44) || // Comment
+  char === 35;
+}
+function extractValue(ctx, end) {
+  let errPtr = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p);
+  if (c === 91 || c === 123) {
+    ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
+    let value = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      TomlError.x("invalid value", ctx, errPtr);
+    return ctx.p++, false;
+  }
+  if (c === 43 || c === 45) {
+    return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
+    return parseDate(ctx, c, end);
+  }
+  if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
+    return parseTime(ctx, c, end);
+  }
+  return parseNumber(ctx, ctx.p, c, 0, end);
+}
+function parseNumber(ctx, startPtr, startChr, sign, endChr) {
+  let c = startChr;
+  let state = 0;
+  let hasUnderscores = false;
+  if (c === 105) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, (sign || 1) / 0;
+  }
+  if (c === 110) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
+      TomlError.x("invalid value", ctx, startPtr);
+    return ctx.p++, NaN;
+  }
+  if (c === 48) {
+    if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
+      return ctx.bi === true ? 0n : 0;
+    if (!sign) {
+      if (c === 120)
+        return parseIntegerBaseN(ctx, startPtr, 16, endChr);
+      else if (c === 98)
+        return parseIntegerBaseN(ctx, startPtr, 2, endChr);
+      else if (c === 111)
+        return parseIntegerBaseN(ctx, startPtr, 8, endChr);
+    }
+    if (c === 46)
+      state = 2;
+    else if (c === 101 || c === 69)
+      state = 4;
+    else
+      TomlError.x("illegal leading zero", ctx, startPtr);
+  } else if (!isDigit(c))
+    TomlError.x("invalid value", ctx, startPtr);
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (!state)
+      state = 1;
+    if (c === 95) {
+      if (!(state & 1))
+        TomlError.x("illegal underscore", ctx);
+      state += 11;
+      hasUnderscores = true;
+    } else if (state === 1 && c === 46)
+      state = 2;
+    else if ((state === 1 || state === 3) && (c === 101 || c === 69))
+      state = 4;
+    else if (state === 4 && (c === 43 || c === 45)) {
+      state = 6;
+    } else if (!isDigit(c))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (state > 9)
+      state -= 11;
+    else if (!(state & 1))
+      state++;
+  }
+  if (!state) {
+    let val = (startChr - 48) * (sign || 1);
+    return ctx.bi === true ? BigInt(val) : val;
+  }
+  if (!(state & 1))
+    TomlError.x("unfinished numeric value", ctx, startPtr);
+  let str = ctx.s.slice(startPtr, ctx.p);
+  if (hasUnderscores)
+    str = str.replaceAll("_", "");
+  return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
+}
+function parseIntegerBaseN(ctx, startPtr, base, endChr) {
+  let c, underscore = 1;
+  while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
+    if (c === 95) {
+      if (underscore & 1)
+        TomlError.x("illegal underscore", ctx);
+      underscore = 3;
+    } else if (!isDigit(c, base))
+      TomlError.x(`illegal character in numeric literal`, ctx);
+    else if (underscore & 1)
+      underscore--;
+  }
+  if (underscore & 1)
+    TomlError.x("unfinished numeric value", ctx);
+  let str = ctx.s.slice(startPtr + 2, ctx.p);
+  if (underscore)
+    str = str.replaceAll("_", "");
+  return parseInteger(ctx, str, base, startPtr);
+}
+function parseInteger(ctx, str, base, startPtr) {
+  if (ctx.bi !== true)
+    int: {
+      let val = parseInt(str, base);
+      if (!Number.isSafeInteger(val)) {
+        if (ctx.bi)
+          break int;
+        TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
+      }
+      return val;
+    }
+  return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
+}
+function parseDate(ctx, c, endChr) {
+  let startPtr = ctx.p++, unsafeSeparator;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
+    return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
+  }
+  ctx.p += 5;
+  if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
+    TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
+  if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
+    let t2 = ctx.s.slice(startPtr, ctx.p);
+    return readDate(ctx, t2, 3, false, startPtr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
+    TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
+  if (ctx.s.charCodeAt(ctx.p += 3) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  if (c = ctx.s.charCodeAt(ctx.p)) {
+    if (c === 90 || c === 122) {
+      let t2 = ctx.s.slice(startPtr, ++ctx.p);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, "[+00:00]");
+    }
+    if (c === 43 || c === 45) {
+      let t2 = ctx.s.slice(startPtr, ctx.p += 6);
+      return readDate(ctx, t2, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
+    }
+  }
+  let t = ctx.s.slice(startPtr, ctx.p);
+  return readDate(ctx, t, 2, unsafeSeparator, startPtr);
+}
+function parseTime(ctx, c, endChr) {
+  let start = ctx.p;
+  if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
+    return parseNumber(ctx, --ctx.p, c, 0, endChr);
+  }
+  if (ctx.s.charCodeAt(ctx.p += 4) === 58)
+    ctx.p += 3;
+  if (ctx.s.charCodeAt(ctx.p) === 46)
+    while (isDigit(ctx.s.charCodeAt(++ctx.p)))
+      ;
+  let t = ctx.s.slice(start, ctx.p);
+  return readDate(ctx, t, 4, false, start);
+}
+function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
+  if (ctx.ld) {
+    let date = new TomlDate(str, type, unsafeDelim);
+    if (!date.isValid())
+      TomlError.x("invalid date", ctx, errPtr);
+    return date;
+  }
+  try {
+    if (temporalSuffix)
+      str += temporalSuffix;
+    switch (type) {
+      case 1:
+        return Temporal.ZonedDateTime.from(str);
+      case 2:
+        return Temporal.PlainDateTime.from(str);
+      case 3:
+        return Temporal.PlainDate.from(str);
+      case 4:
+        return Temporal.PlainTime.from(str);
+    }
+  } catch (e) {
+    TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
+  }
+}
+
+// node_modules/smol-toml/dist/util.js
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      TomlError.x("control characters are not allowed in comments", ctx);
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (ctx.p < ctx.s.length) {
+    while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+
+// node_modules/smol-toml/dist/struct.js
+function parseKey(ctx, end = 61) {
+  let startPtr;
+  let state = 0;
+  let parsed = [];
+  let sliceStart;
+  let c = ctx.s.charCodeAt(startPtr = ctx.p);
+  do {
+    if (c === end) {
+      if (!state)
+        TomlError.x("unexpected end of key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      return ctx.p++, parsed;
+    } else if (c === 46) {
+      if (!state)
+        TomlError.x("illegal empty bare key", ctx);
+      if (state === 1)
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+      state = 0;
+    } else if (!state && (c === 34 || c === 39)) {
+      if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
+        TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
+      parsed.push(parseString(ctx));
+      state = 2;
+      ctx.p--;
+    } else if (c === 32 || c === 9) {
+      if (state === 1) {
+        parsed.push(ctx.s.slice(sliceStart, ctx.p));
+        state = 2;
+      }
+    } else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
+      TomlError.x("illegal character in key", ctx);
+    } else if (!state) {
+      state = 1;
+      sliceStart = ctx.p;
+    }
+  } while (c = ctx.s.charCodeAt(++ctx.p));
+  TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
+}
+function parseInlineTable(ctx) {
+  let startPtr = ctx.p++;
+  let res = /* @__PURE__ */ Object.create(null);
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let errPtr = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+      }
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor")) {
+        t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
+        break;
+      }
+      if (!hasOwn && unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      TomlError.x("trying to redefine an already defined value", ctx, errPtr);
+    }
+    skipVoid(ctx, true, true);
+    let value = extractValue(
+      ctx,
+      125
+      /* } */
+    );
+    if (t && typeof (t[k] = value) === "object")
+      seen.add(value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished table", ctx, startPtr);
+}
+function parseArray(ctx) {
+  let startPtr = ctx.p++;
+  let res = [];
+  let c;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(
+      ctx,
+      93
+      /* ] */
+    ));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44)
+      TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
+  }
+  TomlError.x("unfinished array", ctx, startPtr);
+}
+
+// node_modules/smol-toml/dist/parse.js
+function peekTable(ctx, key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      let unsafe = k === "__proto__";
+      if (ctx.uk && (unsafe || k === "constructor"))
+        return false;
+      if (unsafe) {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: /* @__PURE__ */ Object.create(null)
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = /* @__PURE__ */ Object.create(null));
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: /* @__PURE__ */ Object.create(null) };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function validateTablePeek(ctx, peek, ptr) {
+  if (peek === null || ctx.uk === 2)
+    TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
+}
+function parse(toml, options = {}) {
+  let ctx = {
+    s: toml,
+    p: 0,
+    d: options.maxDepth ?? 1e3,
+    bi: options.integersAsBigInt ?? false,
+    ld: options.useLegacyDate ?? true,
+    uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
+  };
+  let res = /* @__PURE__ */ Object.create(null);
+  let meta = /* @__PURE__ */ Object.create(null);
+  let tmp;
+  let skipping = false;
+  let tbl = res;
+  let m = meta;
+  if (toml.charCodeAt(0) === 65279)
+    ctx.p++;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      skipping = false;
+      let k = parseKey(
+        ctx,
+        93
+        /* ] */
+      );
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p) !== 93) {
+          TomlError.x("expected end of table array declaration", ctx);
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        ctx,
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        validateTablePeek(ctx, p, tmp);
+        skipping = true;
+      } else {
+        m = p[2];
+        tbl = p[1];
+      }
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        ctx,
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p && !skipping)
+        validateTablePeek(ctx, p, tmp);
+      skipVoid(ctx, true, true);
+      let v = extractValue(ctx, void 0);
+      if (p && !skipping)
+        p[1][p[0]] = v;
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
+      TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// node_modules/smol-toml/dist/stringify.js
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+var HAS_WELLFORMED = !!"".isWellFormed;
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (typeof obj.getUTCDate === "function" && obj instanceof Date)
+      return "date";
+    if (globalThis.Temporal) {
+      if (obj.until) {
+        if (obj instanceof Temporal.ZonedDateTime)
+          return "temporal/tz+uc";
+        if (obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainDate)
+          return "temporal/uc";
+        if (obj instanceof Temporal.PlainTime || obj instanceof Temporal.Instant)
+          return "temporal";
+        if (obj instanceof Temporal.PlainYearMonth)
+          return "temporal/x";
+      } else if (obj.toPlainDate && obj instanceof Temporal.PlainMonthDay || obj.negated && obj instanceof Temporal.Duration) {
+        return "temporal/x";
+      }
+    }
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0; i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatWellFormedStringUnchecked(s) {
+  return JSON.stringify(s).replaceAll("\x7F", "\\u007f");
+}
+function formatString(s) {
+  return formatWellFormedStringUnchecked(HAS_WELLFORMED ? s.toWellFormed() : s);
+}
+function formatKey(s) {
+  if (BARE_KEY.test(s))
+    return s;
+  if (HAS_WELLFORMED && !s.isWellFormed())
+    throw new RangeError("key contains illegal lone surrogates");
+  return formatWellFormedStringUnchecked(s);
+}
+function stringifyValue(val, type, depth, numberAsFloat, strictTemporal) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  switch (type) {
+    // @ts-expect-error -- intentional fallthrough case
+    case "number":
+      if (isNaN(val))
+        return "nan";
+      if (val === Infinity)
+        return "inf";
+      if (val === -Infinity)
+        return "-inf";
+      if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+        return val.toFixed(1);
+    case "bigint":
+    case "boolean":
+    case "temporal":
+      return val.toString();
+    case "string":
+      return formatString(val);
+    case "date":
+      if (isNaN(val.getTime()))
+        throw new TypeError("cannot serialize invalid date");
+      return val.toISOString();
+    case "object":
+      return stringifyInlineTable(val, depth, numberAsFloat, strictTemporal);
+    case "array":
+      return stringifyArray(val, depth, numberAsFloat, strictTemporal);
+    // @ts-expect-error -- intentional fallthrough case
+    case "temporal/tz+uc":
+      if (strictTemporal) {
+        let tz = val.timeZoneId;
+        let tzc = tz.charCodeAt(0);
+        if (
+          // Classic offset
+          tzc !== 43 && tzc !== 45 && // Fast pre-check pass; see below for the actually accepted values
+          (tzc !== 85 && tzc !== 71 && tzc !== 90 && tzc !== 69 || // UTC and its aliases; Temporal implementations don't all canonicalise unfortunately
+          tz !== "UTC" && tz !== "UCT" && tz !== "Universal" && tz !== "Zulu" && // GMT is a TZ but it's for all intents and purposes equivalent to UTC. Safe to downgrade.
+          !tz.startsWith("GMT") && tz !== "Greenwich" && // Etc/* are all safe to downgrade to offset (either UTC, GMT, or offset)
+          !tz.startsWith("Etc/"))
+        ) {
+          throw new TypeError("Temporal objects with an IANA timezone are not allowed in Temporal strict mode");
+        }
+      }
+    case "temporal/uc":
+      if (strictTemporal && val.calendarId !== "iso8601")
+        throw new TypeError("Temporal objects with a non-default calendar are not allowed in Temporal strict mode");
+      return val.toString({
+        calendarName: "never",
+        timeZoneName: "never"
+      });
+    case "temporal/x":
+      throw new TypeError("Unsupported " + val[Symbol.toStringTag]);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat, strictTemporal) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += formatKey(k) + " = " + stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat, strictTemporal);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat, strictTemporal) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0; i < array.length; i++) {
+    if (i)
+      res += ", ";
+    if (array[i] === null || array[i] === void 0) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat, strictTemporal);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat, strictTemporal) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0; i < array.length; i++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat, strictTemporal);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat, strictTemporal) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = formatKey(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat, strictTemporal);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat, strictTemporal);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat, strictTemporal);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false, strictTemporal = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat, strictTemporal);
+  if (str[str.length - 1] !== "\n")
+    return str + "\n";
+  return str;
+}
+
+// src/core/backups.ts
+import { dirname as dirname4, isAbsolute as isAbsolute5, join as join6, resolve as resolve2 } from "path";
+var BACKUP_SEGMENTS = ["backups"];
+var V1_BACKUP_SEGMENTS = ["backups", "master-prompt"];
+var BACKUP_DIRECTORY = join6(AGEMON_STATE_DIRECTORY, ...BACKUP_SEGMENTS);
+var V1_BACKUP_DIRECTORY = join6(AGEMON_STATE_DIRECTORY, ...V1_BACKUP_SEGMENTS);
+var RESOURCE_ID_HASH_LENGTH = 12;
+function sanitizeForFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/gu, "_");
+}
+function resolveImmutableBackupPath(cwd, resourceId) {
+  const resourceIdHash = sha256Hex(resourceId).slice(
+    0,
+    RESOURCE_ID_HASH_LENGTH
+  );
+  return join6(
+    cwd,
+    BACKUP_DIRECTORY,
+    `${sanitizeForFileName(resourceId)}-${resourceIdHash}.bak`
+  );
+}
+function resolveLegacyBackupPath(cwd, resourceId) {
+  return join6(cwd, BACKUP_DIRECTORY, `${sanitizeForFileName(resourceId)}.bak`);
+}
+function resolveV1RuleFileBackupPath(cwd, target) {
+  return join6(cwd, V1_BACKUP_DIRECTORY, `${sanitizeForFileName(target)}.bak`);
+}
+function backupDirectorySegments(cwd, backupPath) {
+  const directory = dirname4(backupPath);
+  if (directory === join6(cwd, BACKUP_DIRECTORY)) {
+    return BACKUP_SEGMENTS;
+  }
+  if (directory === join6(cwd, V1_BACKUP_DIRECTORY)) {
+    return V1_BACKUP_SEGMENTS;
+  }
+  return null;
+}
+async function writeBackup(cwd, backupPath, contents) {
+  await resolveStateDirectory(cwd, BACKUP_SEGMENTS, { create: true });
+  await writeFileAtomic(backupPath, contents);
+  return { path: backupPath, checksum: sha256Hex(contents) };
+}
+async function writeImmutableBackup(cwd, resourceId, contents) {
+  const backupPath = resolveImmutableBackupPath(cwd, resourceId);
+  const existingBackup = await readBackupFile(cwd, backupPath);
+  if (existingBackup !== null) {
+    return { path: backupPath, checksum: sha256Hex(existingBackup) };
+  }
+  return writeBackup(cwd, backupPath, contents);
+}
+var BackupPathOccupiedError = class extends Error {
+  constructor(backupPath) {
+    super(`${backupPath} already holds a different file`);
+    this.backupPath = backupPath;
+  }
+  backupPath;
+};
+async function writeBackupOnce(cwd, resourceId, contents) {
+  const backupPath = resolveImmutableBackupPath(cwd, resourceId);
+  let existingBackup;
+  try {
+    existingBackup = await readBackupFile(cwd, backupPath);
+  } catch (error) {
+    if (error instanceof NotARegularFileError || error instanceof FileTooLargeError) {
+      throw new BackupPathOccupiedError(backupPath);
+    }
+    throw error;
+  }
+  if (existingBackup === null) {
+    return writeBackup(cwd, backupPath, contents);
+  }
+  if (existingBackup !== contents) {
+    throw new BackupPathOccupiedError(backupPath);
+  }
+  return { path: backupPath, checksum: sha256Hex(contents) };
+}
+async function replaceStaleBackup(cwd, resourceId, contents) {
+  const backupPath = resolveImmutableBackupPath(cwd, resourceId);
+  if (await readBackupFile(cwd, backupPath) === contents) {
+    return { path: backupPath, checksum: sha256Hex(contents) };
+  }
+  return writeBackup(cwd, backupPath, contents);
+}
+function immutableBackupCandidates(cwd, resourceId, recordedPath) {
+  const ownBackupPaths = [
+    resolveImmutableBackupPath(cwd, resourceId),
+    resolveLegacyBackupPath(cwd, resourceId)
+  ];
+  const recordedOwnPath = recordedPath !== null && isAbsolute5(recordedPath) ? ownBackupPaths.find((ownPath) => ownPath === resolve2(recordedPath)) : void 0;
+  return recordedOwnPath === void 0 ? ownBackupPaths : [
+    recordedOwnPath,
+    ...ownBackupPaths.filter((ownPath) => ownPath !== recordedOwnPath)
+  ];
+}
+async function readBackupFile(cwd, backupPath) {
+  const segments = backupDirectorySegments(cwd, backupPath);
+  if (segments === null) {
+    throw new RefusedPathError(
+      `Refusing to use ${printable(backupPath)}: it is not in agemon's backup directory.`
+    );
+  }
+  const backupDirectory = await resolveStateDirectory(cwd, segments, {
+    create: false
+  });
+  return backupDirectory === null ? null : readRegularFileIfExists(backupPath);
+}
+async function readFirstExistingBackup(cwd, candidatePaths) {
+  for (const candidatePath of candidatePaths) {
+    try {
+      const contents = await readBackupFile(cwd, candidatePath);
+      if (contents !== null) {
+        return { path: candidatePath, contents };
+      }
+    } catch (error) {
+      if (!(error instanceof NotARegularFileError) && !(error instanceof FileTooLargeError)) {
+        throw error;
+      }
+    }
+  }
+  return null;
+}
+
+// src/core/config.ts
+var CONFIG_FILE_NAME = "agemon.toml";
+var CONFIG_BACKUP_RESOURCE_PREFIX = "config:agemon.toml";
+var CONFIG_BACKUP_CONTENT_HASH_LENGTH = 16;
+var MAX_CUSTOM_GROUP_ID_CHARACTERS = 40;
+var CUSTOM_GROUP_ID_PATTERN = new RegExp(
+  `^[a-z0-9][a-z0-9-]{0,${MAX_CUSTOM_GROUP_ID_CHARACTERS - 1}}$`,
+  "u"
+);
+var RESERVED_GROUP_IDS = ["all", "none"];
+var MAX_CUSTOM_GROUP_LABEL_CHARACTERS = 80;
+var SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+var LOCAL_SOURCE_PATTERN = /^\.\/(?:[A-Za-z0-9._-]+\/)*([A-Za-z0-9._-]+)$/u;
+var AGENT_DIRECTORIES = [".agents", ".claude"];
+var GITHUB_SOURCE_PATTERN = /^github:([A-Za-z0-9][A-Za-z0-9_.-]{0,99})\/([A-Za-z0-9][A-Za-z0-9_.-]{0,99})$/u;
+var COMMIT_REF_PATTERN = /^[0-9a-f]{40}$/u;
+var MAX_CUSTOM_GROUPS = 20;
+var MAX_SKILLS_PER_CUSTOM_GROUP = 50;
+var MAX_REMOTE_REPOSITORIES = 10;
+var CONFLICT_DECISIONS = ["keep", "replace", "skip"];
+var SKILL_GROUPS_WHEN_ABSENT = "interactive prompt per group, or essentials-only when non-interactive";
+var AGEMON_TOML_TABLES = {
+  topLevel: {
+    heading: "Top-level keys",
+    keys: [
+      {
+        name: "capabilities",
+        type: "array of capability ids",
+        whenAbsent: null,
+        summary: "The capabilities agemon reconciles in this repository. An empty list or an unknown id is an error."
+      },
+      {
+        name: "skill_groups",
+        type: "string: comma-separated group ids, or all or none",
+        whenAbsent: SKILL_GROUPS_WHEN_ABSENT,
+        summary: "The skill groups to install, as with --skill-groups; the flag wins when both are given."
+      },
+      {
+        name: "custom_skill_groups",
+        type: "table of group id to custom group table",
+        whenAbsent: "no project-defined groups",
+        summary: `Project-defined skill groups. A group id is lower-case letters, digits and '-' (at most ${MAX_CUSTOM_GROUP_ID_CHARACTERS} characters), not all or none, and not a built-in group id.`
+      },
+      {
+        name: "conflict_decisions",
+        type: "table of resource id to decision",
+        whenAbsent: "every conflict needs a decision in the run",
+        summary: "What to do with a rule file that holds your own rules where agemon would write a pointer."
+      },
+      {
+        name: "known_capabilities",
+        type: "array of capability ids",
+        whenAbsent: "the capabilities agemon had before this key existed",
+        summary: "The capabilities the agemon that wrote the file knew about, so a capability added in a later release is offered once."
+      }
+    ]
+  },
+  customSkillGroup: {
+    heading: "Custom skill group tables",
+    keys: [
+      {
+        name: "label",
+        type: `string, one line, at most ${MAX_CUSTOM_GROUP_LABEL_CHARACTERS} characters`,
+        whenAbsent: null,
+        summary: "The name shown when agemon asks which groups to install."
+      },
+      {
+        name: "skills",
+        type: `array of 1 to ${MAX_SKILLS_PER_CUSTOM_GROUP} skill entries`,
+        whenAbsent: null,
+        summary: "The skills in the group, each a local or a GitHub source."
+      }
+    ]
+  },
+  customSkill: {
+    heading: "Custom skill entries",
+    keys: [
+      {
+        name: "source",
+        type: 'string: "./<path>" or "github:<owner>/<repository>"',
+        whenAbsent: null,
+        summary: "A directory in this repository (the skill's name is the directory name), or a GitHub repository."
+      },
+      {
+        name: "ref",
+        type: "string: a full 40-character commit sha",
+        whenAbsent: null,
+        summary: "The commit to fetch; branches, tags and short shas are refused. Only for GitHub sources.",
+        githubSourceOnly: true
+      },
+      {
+        name: "skill",
+        type: "string: a skill name",
+        whenAbsent: null,
+        summary: "The skill to take from skills/<skill>/ in the repository. Only for GitHub sources.",
+        githubSourceOnly: true
+      }
+    ]
+  }
+};
+var keyNames = (keys) => keys.map((key) => key.name);
+var TOP_LEVEL_KEYS = keyNames(AGEMON_TOML_TABLES.topLevel.keys);
+var CUSTOM_GROUP_KEYS = keyNames(AGEMON_TOML_TABLES.customSkillGroup.keys);
+var GITHUB_SKILL_KEYS = keyNames(AGEMON_TOML_TABLES.customSkill.keys);
+var LOCAL_SKILL_KEYS = keyNames(
+  AGEMON_TOML_TABLES.customSkill.keys.filter((key) => !key.githubSourceOnly)
+);
+function resolveConfigPath(cwd) {
+  return join7(cwd, CONFIG_FILE_NAME);
+}
+function fail(detail) {
+  throw new Error(`${CONFIG_FILE_NAME} is invalid: ${printable(detail)}`);
+}
+function validateCapabilities(value) {
+  if (!Array.isArray(value)) {
+    fail("'capabilities' must be an array of capability ids");
+  }
+  if (value.length === 0) {
+    fail("'capabilities' must list at least one capability id");
+  }
+  return value.map((entry) => {
+    if (typeof entry !== "string" || entry.trim().length === 0) {
+      fail("'capabilities' entries must be non-empty strings");
+    }
+    return entry;
+  });
+}
+function validateKnownCapabilities(value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    fail("'known_capabilities' must be an array of non-empty strings");
+  }
+  return value;
+}
+function validateKnownKeys(record) {
+  const unknownKey = Object.keys(record).find(
+    (key) => !TOP_LEVEL_KEYS.includes(key)
+  );
+  if (unknownKey !== void 0) {
+    fail(
+      `unknown key '${unknownKey}'. Valid keys: ${TOP_LEVEL_KEYS.join(", ")}.`
+    );
+  }
+}
+function validateSkillGroups(value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    fail("'skill_groups' must be a string when present");
+  }
+  return value;
+}
+function asTable(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail(`'${field}' must be a table`);
+  }
+  return value;
+}
+function assertOnlyKeys(table, allowedKeys, field) {
+  const unknownKey = Object.keys(table).find(
+    (key) => !allowedKeys.includes(key)
+  );
+  if (unknownKey !== void 0) {
+    fail(
+      `'${field}' has unknown key '${unknownKey}'. Valid keys: ${allowedKeys.join(", ")}.`
+    );
+  }
+}
+function isPlainSkillName(value) {
+  return SKILL_NAME_PATTERN.test(value);
+}
+function validateSkillName(value, field) {
+  if (typeof value !== "string" || !isPlainSkillName(value)) {
+    fail(
+      `'${field}' must be a skill name of lower-case letters, digits, '.', '_' or '-' (at most 64 characters, not starting with '-' or '.')`
+    );
+  }
+  return value;
+}
+function validateLocalSource(path, field) {
+  const match = LOCAL_SOURCE_PATTERN.exec(path);
+  const components = path.split("/").slice(1);
+  if (match === null || components.some((component) => component === "." || component === "..")) {
+    fail(
+      `'${field}' must be a repository-relative path like "./tools/skills/<name>" without '.' or '..' components`
+    );
+  }
+  if (AGENT_DIRECTORIES.includes(components[0].toLowerCase())) {
+    fail(
+      `'${field}' must not point into ${AGENT_DIRECTORIES.join(" or ")}, where installed skills live`
+    );
+  }
+  return {
+    kind: "local",
+    path,
+    skillName: validateSkillName(match[1], `${field} (last path component)`)
+  };
+}
+function validateCustomSkill(value, field) {
+  const skill = asTable(value, field);
+  if (typeof skill.source !== "string") {
+    fail(`'${field}.source' must be a string`);
+  }
+  if (!skill.source.startsWith("github:")) {
+    assertOnlyKeys(skill, LOCAL_SKILL_KEYS, field);
+    return validateLocalSource(skill.source, `${field}.source`);
+  }
+  assertOnlyKeys(skill, GITHUB_SKILL_KEYS, field);
+  const match = GITHUB_SOURCE_PATTERN.exec(skill.source);
+  if (match === null) {
+    fail(`'${field}.source' must be "github:<owner>/<repository>"`);
+  }
+  if (typeof skill.ref !== "string" || !COMMIT_REF_PATTERN.test(skill.ref)) {
+    fail(
+      `'${field}.ref' must be a full 40-character commit sha; branches, tags and short shas are refused`
+    );
+  }
+  return {
+    kind: "github",
+    owner: match[1],
+    repository: match[2],
+    ref: skill.ref,
+    skillName: validateSkillName(skill.skill, `${field}.skill`)
+  };
+}
+function validateCustomSkillGroup(id, value) {
+  const field = `custom_skill_groups.${id}`;
+  if (!CUSTOM_GROUP_ID_PATTERN.test(id) || RESERVED_GROUP_IDS.includes(id)) {
+    fail(
+      `'${field}': a group id is lower-case letters, digits and '-' (at most ${MAX_CUSTOM_GROUP_ID_CHARACTERS} characters), and not ${RESERVED_GROUP_IDS.join(" or ")}`
+    );
+  }
+  const group = asTable(value, field);
+  assertOnlyKeys(group, CUSTOM_GROUP_KEYS, field);
+  if (typeof group.label !== "string" || group.label.trim().length === 0 || group.label.length > MAX_CUSTOM_GROUP_LABEL_CHARACTERS || !isSafeIdentifier(group.label)) {
+    fail(
+      `'${field}.label' must be a non-empty single-line string of at most ${MAX_CUSTOM_GROUP_LABEL_CHARACTERS} characters, without invisible or control characters`
+    );
+  }
+  if (!Array.isArray(group.skills) || group.skills.length === 0 || group.skills.length > MAX_SKILLS_PER_CUSTOM_GROUP) {
+    fail(
+      `'${field}.skills' must list between 1 and ${MAX_SKILLS_PER_CUSTOM_GROUP} skills`
+    );
+  }
+  return {
+    id,
+    label: group.label,
+    skills: group.skills.map(
+      (skill, index) => validateCustomSkill(skill, `${field}.skills[${index}]`)
+    )
+  };
+}
+function validateCustomSkillGroups(value) {
+  if (value === void 0) {
+    return [];
+  }
+  const groups = Object.entries(asTable(value, "custom_skill_groups")).map(
+    ([id, group]) => validateCustomSkillGroup(id, group)
+  );
+  if (groups.length > MAX_CUSTOM_GROUPS) {
+    fail(
+      `'custom_skill_groups' may define at most ${MAX_CUSTOM_GROUPS} groups`
+    );
+  }
+  const skillNames = groups.flatMap(
+    (group) => group.skills.map((skill) => skill.skillName)
+  );
+  const duplicateName = skillNames.find(
+    (name, index) => skillNames.indexOf(name) !== index
+  );
+  if (duplicateName !== void 0) {
+    fail(
+      `skill '${duplicateName}' appears more than once in 'custom_skill_groups'`
+    );
+  }
+  const remoteRepositories = new Set(
+    groups.flatMap(
+      (group) => group.skills.flatMap(
+        (skill) => skill.kind === "github" ? [`${skill.owner}/${skill.repository}`] : []
+      )
+    )
+  );
+  if (remoteRepositories.size > MAX_REMOTE_REPOSITORIES) {
+    fail(
+      `'custom_skill_groups' may use at most ${MAX_REMOTE_REPOSITORIES} GitHub repositories`
+    );
+  }
+  return groups;
+}
+var quotedDecisions = CONFLICT_DECISIONS.map(
+  (decision) => JSON.stringify(decision)
+);
+var CONFLICT_DECISION_CHOICES = `${quotedDecisions.slice(0, -1).join(", ")}, or ${quotedDecisions.at(-1)}`;
+function isConflictDecision(value) {
+  return CONFLICT_DECISIONS.some((decision) => decision === value);
+}
+function validateConflictDecisions(value) {
+  const decisions = /* @__PURE__ */ new Map();
+  if (value === void 0) {
+    return decisions;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail("'conflict_decisions' must be a table of resource id to decision");
+  }
+  for (const [resourceId, decision] of Object.entries(
+    value
+  )) {
+    if (!isConflictDecision(decision)) {
+      fail(
+        `'conflict_decisions.${resourceId}' must be ${CONFLICT_DECISION_CHOICES}, got ${JSON.stringify(decision)}`
+      );
+    }
+    decisions.set(resourceId, decision);
+  }
+  return decisions;
+}
+async function loadConfig(cwd) {
+  let rawContents;
+  try {
+    rawContents = await readRegularFileIfExists(resolveConfigPath(cwd));
+  } catch (error) {
+    if (error instanceof RefusedFileError) {
+      fail(error.message);
+    }
+    throw new Error(`Unable to read ${CONFIG_FILE_NAME}: ${String(error)}`);
+  }
+  if (rawContents === null) {
+    return null;
+  }
+  return validateConfigText(rawContents);
+}
+function parseConfigRecord(text) {
+  try {
+    return parse(text);
+  } catch (error) {
+    const detail = error instanceof TomlError ? error.message : String(error);
+    fail(`not valid TOML \u2014 ${detail}`);
+  }
+}
+function validateConfigText(text) {
+  const record = parseConfigRecord(text);
+  validateKnownKeys(record);
+  return {
+    capabilities: validateCapabilities(record.capabilities),
+    skillGroups: validateSkillGroups(record.skill_groups),
+    customSkillGroups: validateCustomSkillGroups(record.custom_skill_groups),
+    conflictDecisions: validateConflictDecisions(record.conflict_decisions),
+    knownCapabilities: validateKnownCapabilities(record.known_capabilities),
+    sourceText: text
+  };
+}
+function serializeConfigRecord(record) {
+  return `${stringify(record)}
+`;
+}
+function configBackupResourceId(addedCapabilityIds, originalText) {
+  const contentHash = sha256Hex(originalText).slice(
+    0,
+    CONFIG_BACKUP_CONTENT_HASH_LENGTH
+  );
+  return `${CONFIG_BACKUP_RESOURCE_PREFIX}:${addedCapabilityIds.join(",")}:${contentHash}`;
+}
+async function rewriteConfigCapabilities(cwd, config, update) {
+  const configPath = resolveConfigPath(cwd);
+  const currentText = await readRegularFileIfExists(configPath);
+  if (currentText !== config.sourceText) {
+    return { kind: "not-written", reason: "it changed during this run" };
+  }
+  const currentRecord = parseConfigRecord(currentText);
+  const nextRecord = {
+    ...currentRecord,
+    capabilities: update.capabilities,
+    known_capabilities: [
+      .../* @__PURE__ */ new Set([
+        ...config.knownCapabilities ?? [],
+        ...update.knownCapabilities
+      ])
+    ]
+  };
+  const nextText = serializeConfigRecord(nextRecord);
+  if (!isDeepStrictEqual(
+    structuredClone(parseConfigRecord(nextText)),
+    structuredClone(nextRecord)
+  )) {
+    return {
+      kind: "not-written",
+      reason: "rewriting it would change values agemon did not mean to change"
+    };
+  }
+  validateConfigText(nextText);
+  const losesCommentsOrLayout = serializeConfigRecord(currentRecord) !== currentText;
+  let backup = null;
+  if (losesCommentsOrLayout) {
+    const addedIds = update.capabilities.filter(
+      (id) => !config.capabilities.includes(id)
+    );
+    try {
+      backup = await writeBackupOnce(
+        cwd,
+        configBackupResourceId(addedIds, currentText),
+        currentText
+      );
+    } catch (error) {
+      if (!(error instanceof BackupPathOccupiedError)) {
+        throw error;
+      }
+      return {
+        kind: "not-written",
+        reason: `agemon's backup path ${relative2(cwd, error.backupPath)} holds something else; move it aside and run agemon again`
+      };
+    }
+  }
+  await writeFileAtomic(configPath, nextText);
+  return {
+    kind: "written",
+    backupPath: backup === null ? null : relative2(cwd, backup.path)
+  };
+}
+async function writeConfig(cwd, config) {
+  const configPath = resolveConfigPath(cwd);
+  const payload = {
+    capabilities: config.capabilities
+  };
+  if (config.skillGroups !== null) {
+    payload.skill_groups = config.skillGroups;
+  }
+  payload.conflict_decisions = Object.fromEntries(config.conflictDecisions);
+  payload.known_capabilities = config.knownCapabilities;
+  await writeFileAtomic(configPath, `${stringify(payload)}
+`);
+  return configPath;
+}
+
+// src/plugins/skills/skills-cli-targets.ts
+import { lstat as lstat5, rm as rm4, unlink } from "fs/promises";
+import { join as join8 } from "path";
+var CANONICAL_SKILLS_DIRECTORY = ".agents/skills";
+var CLAUDE_SKILLS_DIRECTORY = ".claude/skills";
+var SKILLS_LOCK_FILE = "skills-lock.json";
+async function lstatIfPresent(path) {
+  try {
+    return await lstat5(path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function refuse(relativePath, reason) {
+  throw new RefusedPathError(
+    `Refusing to run the skills CLI: ${printable(relativePath)} ${reason}. agemon only lets it write inside the repository \u2014 replace it with a real directory or file.`
+  );
+}
+function assertPlainSkillName(skillName) {
+  if (!isPlainSkillName(skillName)) {
+    throw new RefusedPathError(
+      `Refusing to run the skills CLI: the skill name '${printable(skillName)}' is not a plain skill name. The ledger in .agemon/state.json may have been edited; check it before running agemon again.`
+    );
+  }
+}
+async function prepareSkillsCliTargets(repoRoot, skillNames) {
+  skillNames.forEach(assertPlainSkillName);
+  const canonicalDirectory = await resolveRepoDirectory(
+    repoRoot,
+    CANONICAL_SKILLS_DIRECTORY,
+    { create: false }
+  );
+  if (canonicalDirectory !== null) {
+    for (const skillName of skillNames) {
+      const stats = await lstatIfPresent(join8(canonicalDirectory, skillName));
+      if (stats?.isSymbolicLink()) {
+        refuse(`${CANONICAL_SKILLS_DIRECTORY}/${skillName}`, "is a symlink");
+      }
+    }
+  }
+  const lockStats = await lstatIfPresent(join8(repoRoot, SKILLS_LOCK_FILE));
+  if (lockStats !== null && !lockStats.isFile()) {
+    refuse(SKILLS_LOCK_FILE, "is a symlink or not a regular file");
+  }
+  return ensureRepoDirectory(repoRoot, CLAUDE_SKILLS_DIRECTORY);
+}
+async function removeInstalledSkillCopy(repoRoot, skillName) {
+  assertPlainSkillName(skillName);
+  const skillsDirectory = await resolveRepoDirectory(
+    repoRoot,
+    CLAUDE_SKILLS_DIRECTORY
+  );
+  if (skillsDirectory === null) {
+    return;
+  }
+  const copyPath = join8(skillsDirectory, skillName);
+  const stats = await lstatIfPresent(copyPath);
+  if (stats?.isSymbolicLink()) {
+    await unlink(copyPath);
+  } else if (stats !== null) {
+    await rm4(copyPath, { recursive: true, force: true });
+  }
+}
+
+export {
+  __commonJS,
+  __toESM,
+  MAX_READ_FILE_BYTES,
+  MAX_READ_FILE_LABEL,
+  RefusedFileError,
+  FileTooLargeError,
+  RefusedPathError,
+  readRegularFileIfExists,
+  sha256OfRegularFile,
+  writeFileAtomic,
+  writeNewFileWithFallback,
+  saveVerifiedCopyBeside,
+  printable,
+  isSafeIdentifier,
+  quoteForShlex,
+  AGEMON_STATE_DIRECTORY,
+  isMissingPathError,
+  resolveInsideRepo,
+  resolveStateDirectory,
+  resolveRepoDirectory,
+  ensureRepoDirectory,
+  readRegularFilePrefix,
+  hasGitEntry,
+  isSameOrInside,
+  resolveRepositoryRoot,
+  isDenylistedPath,
+  redactJsonValue,
+  redactSecretsInText,
+  isUsableAbsolutePath,
+  resolveHomeDirectory,
+  isHomeDirectory,
+  containsHomeDirectory,
+  CODE_REVIEW_GRAPH_VERSION,
+  CODE_REVIEW_GRAPH_PACKAGE_SPEC,
+  AGNIX_VERSION,
+  AGNIX_RELEASE_ARCHIVE_SHA256,
+  AGNIX_NPM_TARBALL,
+  AGNIX_PACKAGE_FILE_SHA256,
+  AGNIX_BINARY_SHA256,
+  sha256Hex,
+  fingerprintJson,
+  fingerprintContent,
+  SkillTreeRefusal,
+  isLeftOutBySkillsCli,
+  readSkillTree,
+  fingerprintSkillTree,
+  fingerprintSkillSource,
+  readInstalledSkill,
+  fingerprintInstalledSkill,
+  resolveVendoredSkillPath,
+  resolveToolsManifestDirectory,
+  withFileLock,
+  resolveStateRoot,
+  resolveAgemonStateDirectory,
+  checkAgemonStateDirectoryBeforeRun,
+  preparePrivateStateDirectory,
+  prepareToolsRoot,
+  repositoryStateKey,
+  withAgemonStateLock,
+  withRepositoryRunLock,
+  SKILLS_CLI_PATH_IN_TOOLS_DIR,
+  runSkillsCli,
+  resolveImmutableBackupPath,
+  resolveV1RuleFileBackupPath,
+  writeImmutableBackup,
+  replaceStaleBackup,
+  immutableBackupCandidates,
+  readFirstExistingBackup,
+  SKILL_GROUPS_WHEN_ABSENT,
+  resolveConfigPath,
+  isPlainSkillName,
+  loadConfig,
+  rewriteConfigCapabilities,
+  writeConfig,
+  CANONICAL_SKILLS_DIRECTORY,
+  CLAUDE_SKILLS_DIRECTORY,
+  SKILLS_LOCK_FILE,
+  prepareSkillsCliTargets,
+  removeInstalledSkillCopy,
+  MAX_RAW_OUTPUT_LINE_CHARACTERS,
+  sanitizeOutput,
+  capShownLine,
+  safeOutputTail,
+  describeSubprocessFailure,
+  isSpawnFailure,
+  agemonSubprocessEnvironment,
+  TRUNCATION_MARKER,
+  runSubprocess,
+  runRealSubprocess
+};
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/date.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/util.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/
+//# sourceMappingURL=chunk-ZZBF3GOV.js.map