agemon 6.0.0 → 6.3.1

package/dist/{chunk-5LATHJYU.js → chunk-ZZBF3GOV.js}

@@ -512,8 +512,6 @@ async function containsHomeDirectory(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 ESSENTIALS_SKILLS_REPOSITORY_URL = "https://github.com/vercel-labs/agent-skills.git";
-var ESSENTIALS_SKILLS_COMMIT = "063bee94c3f4df8453406c830b0a7df0f2860278";
 var AGNIX_VERSION = "0.58.0";
 var AGNIX_RELEASE_ARCHIVE_SHA256 = {
   "agnix-x86_64-unknown-linux-gnu.tar.gz": "68cbf435c87e89319133cd4fd4b8b0c8b0763b17862f231bf495ccb9d8ee074b",
@@ -563,17 +561,137 @@ function fingerprintContent(contents) {
   return sha256Hex(contents);
 }
 
-// src/core/state-root.ts
+// src/plugins/skills/skill-tree.ts
 import { constants as constants3 } from "fs";
-import { mkdir as mkdir2, open as open4, readFile as readFile2, realpath as realpath3, stat } from "fs/promises";
+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 join2 } from "path";
+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 lstat3, open as open3, readFile, rm as rm2 } from "fs/promises";
+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;
@@ -613,18 +731,18 @@ function processExists(pid) {
 var linuxProcessProbe = {
   bootId: () => readTrimmedOrNull("/proc/sys/kernel/random/boot_id"),
   async startTime(pid) {
-    const stat3 = await readTrimmedOrNull(`/proc/${pid}/stat`);
-    return stat3 === null ? null : parseProcessStartTime(stat3);
+    const stat2 = await readTrimmedOrNull(`/proc/${pid}/stat`);
+    return stat2 === null ? null : parseProcessStartTime(stat2);
   },
   exists: processExists
 };
 function readBootSessionUuidWithSysctl() {
-  return new Promise((resolve4, reject) => {
+  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) : resolve4(stdout)
+      (error, stdout) => error ? reject(error) : resolve3(stdout)
     );
   });
 }
@@ -675,7 +793,7 @@ async function isOwnerAlive(owner, probe) {
 }
 async function isOlderThan(path, ageMs) {
   try {
-    return Date.now() - (await lstat3(path)).mtimeMs > ageMs;
+    return Date.now() - (await lstat4(path)).mtimeMs > ageMs;
   } catch {
     return false;
   }
@@ -690,7 +808,7 @@ async function isStaleLock(lockPath, contents, probe) {
 async function createLockFile(lockPath, contents) {
   let handle;
   try {
-    handle = await open3(lockPath, "wx", LOCK_FILE_MODE);
+    handle = await open4(lockPath, "wx", LOCK_FILE_MODE);
   } catch (error) {
     if (error.code === "EEXIST") {
       return false;
@@ -819,7 +937,7 @@ function resolveStateRoot(hostPlatform = process.platform) {
       "Cannot locate agemon's state directory: set HOME (or XDG_STATE_HOME) to an absolute path."
     );
   }
-  return hostPlatform === "darwin" ? join2(homeDirectory, "Library", "Application Support") : join2(homeDirectory, ".local", "state");
+  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(":"));
@@ -876,9 +994,9 @@ async function assertSafeStateRoot(stateRoot, accounts) {
   }
 }
 async function openAgemonDirectory(directory, mode) {
-  const flags = constants3.O_RDONLY | constants3.O_DIRECTORY | constants3.O_NOFOLLOW;
+  const flags = constants4.O_RDONLY | constants4.O_DIRECTORY | constants4.O_NOFOLLOW;
   try {
-    return await open4(directory, flags);
+    return await open5(directory, flags);
   } catch (error) {
     const code = error.code;
     if (code === "ELOOP" || code === "ENOTDIR") {
@@ -902,7 +1020,7 @@ async function openAgemonDirectory(directory, mode) {
 }
 async function resolveAgemonStateDirectory(mode, accounts = currentAccounts()) {
   const stateRoot = resolveStateRoot();
-  const directory = join2(stateRoot, "agemon");
+  const directory = join3(stateRoot, "agemon");
   if (mode === "prepare") {
     await mkdir2(stateRoot, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
   }
@@ -940,7 +1058,7 @@ async function checkAgemonStateDirectoryBeforeRun(dryRun, report) {
   }
 }
 async function preparePrivateStateDirectory(name) {
-  const directory = join2(
+  const directory = join3(
     (await resolveAgemonStateDirectory("prepare")).path,
     name
   );
@@ -957,7 +1075,7 @@ async function repositoryStateKey(repoRoot) {
   );
 }
 async function withAgemonStateLock(lockRelativePath, work, waitMs) {
-  const lockPath = join2(
+  const lockPath = join3(
     (await resolveAgemonStateDirectory("prepare")).path,
     lockRelativePath
   );
@@ -969,16 +1087,78 @@ async function withAgemonStateLock(lockRelativePath, work, waitMs) {
 }
 async function withRepositoryRunLock(repoRoot, work) {
   return withAgemonStateLock(
-    join2("runs", `${await repositoryStateKey(repoRoot)}.lock`),
+    join3("runs", `${await repositoryStateKey(repoRoot)}.lock`),
     () => work(),
     RUN_LOCK_WAIT_MS
   );
 }
 
-// src/plugins/skills/pinned-source.ts
-import { existsSync } from "fs";
-import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
-import { join as join3 } from "path";
+// 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";
@@ -1030,6 +1210,9 @@ 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));
 }
@@ -1045,8 +1228,21 @@ function shannonEntropyBitsPerChar(value) {
   }
   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;
+  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(/["':]+$/, "");
@@ -1318,706 +1514,132 @@ function createBoundedCapture() {
       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-2BETWZVZ.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((resolve4) => {
-    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();
-      resolve4(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/pinned-source.ts
-var SOURCE_DIRECTORY_MODE = 448;
-var GIT_STEP_TIMEOUT_MS = 12e4;
-var GIT_SYMLINK_MODE = "120000";
-var GIT_WITHOUT_HOOKS_ARGS = [
-  "-c",
-  "core.hooksPath=/dev/null",
-  "-c",
-  "core.fsmonitor=false",
-  "-c",
-  "credential.helper="
-];
-function resolvePinnedSkillsSourceDirectory(commit) {
-  return join3(resolveStateRoot(), "agemon", "skills-src", commit);
-}
-async function localGitOutput(ctx, sourceDirectory, subcommandArgs) {
-  const result = await ctx.run(
-    "git",
-    [...GIT_WITHOUT_HOOKS_ARGS, ...subcommandArgs],
-    {
-      cwd: sourceDirectory,
-      timeoutMs: GIT_STEP_TIMEOUT_MS,
-      env: isolatedGitEnvironment(sourceDirectory)
-    }
-  );
-  return result.code === 0 ? result.stdout : null;
-}
-async function isPristinePinnedCheckout(ctx, repository) {
-  const sourceDirectory = resolvePinnedSkillsSourceDirectory(repository.commit);
-  if (!existsSync(join3(sourceDirectory, ".git"))) {
-    return false;
-  }
-  try {
-    const head = await localGitOutput(ctx, sourceDirectory, [
-      "rev-parse",
-      "--verify",
-      "--end-of-options",
-      "HEAD^{commit}"
-    ]);
-    if (head?.trim() !== repository.commit) {
-      return false;
-    }
-    const status = await localGitOutput(ctx, sourceDirectory, [
-      "status",
-      "--porcelain",
-      "--ignored"
-    ]);
-    return status !== null && status.trim() === "";
-  } catch {
-    return false;
-  }
-}
-function skillPathInRepository(skillName) {
-  return `skills/${skillName}`;
-}
-function resolvePinnedSkillPath(repository, skillName) {
-  return join3(
-    resolvePinnedSkillsSourceDirectory(repository.commit),
-    skillPathInRepository(skillName)
-  );
-}
-function isolatedGitEnvironment(sourceDirectory) {
-  const gitDirectory = join3(sourceDirectory, ".git");
-  return {
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_CONFIG_GLOBAL: "/dev/null",
-    GIT_CONFIG_NOSYSTEM: "1",
-    GIT_CONFIG_COUNT: "0",
-    GIT_CONFIG_PARAMETERS: "",
-    GIT_ASKPASS: "",
-    SSH_ASKPASS: "",
-    GIT_DIR: gitDirectory,
-    GIT_WORK_TREE: sourceDirectory,
-    GIT_COMMON_DIR: gitDirectory,
-    GIT_INDEX_FILE: join3(gitDirectory, "index"),
-    GIT_OBJECT_DIRECTORY: join3(gitDirectory, "objects"),
-    GIT_ALTERNATE_OBJECT_DIRECTORIES: ""
-  };
-}
-async function runGitStep(ctx, sourceDirectory, subcommandArgs) {
-  const result = await ctx.run(
-    "git",
-    [...GIT_WITHOUT_HOOKS_ARGS, ...subcommandArgs],
-    {
-      cwd: sourceDirectory,
-      timeoutMs: GIT_STEP_TIMEOUT_MS,
-      env: isolatedGitEnvironment(sourceDirectory)
-    }
-  );
-  if (result.code !== 0) {
-    throw new Error(
-      `git ${subcommandArgs[0]} failed while fetching pinned skills: ${describeSubprocessFailure(result, "git")}`
-    );
-  }
-  return result;
-}
-function findSymlinkPaths(lsTreeOutput) {
-  return lsTreeOutput.split("\n").filter((line) => line.startsWith(`${GIT_SYMLINK_MODE} `)).map((line) => line.slice(line.indexOf("	") + 1));
-}
-async function assertSkillIsPlainFiles(ctx, sourceDirectory, skillName) {
-  const skillPath = skillPathInRepository(skillName);
-  const listing = await runGitStep(ctx, sourceDirectory, [
-    "ls-tree",
-    "-r",
-    "HEAD",
-    "--",
-    skillPath
-  ]);
-  if (listing.stdout.trim().length === 0) {
-    throw new Error(`The pinned skills commit has no ${skillPath}.`);
-  }
-  const symlinkPaths = findSymlinkPaths(listing.stdout);
-  if (symlinkPaths.length > 0) {
-    throw new Error(
-      `Refusing to install pinned skills: ${symlinkPaths.map(printable).join(", ")} is a symlink.`
-    );
-  }
-}
-async function fetchPinnedSkillsSource(ctx, repository, skillNames) {
-  const sourceDirectory = resolvePinnedSkillsSourceDirectory(repository.commit);
-  await rm3(sourceDirectory, { recursive: true, force: true });
-  await mkdir3(sourceDirectory, {
-    recursive: true,
-    mode: SOURCE_DIRECTORY_MODE
-  });
-  await runGitStep(ctx, sourceDirectory, ["init", "-q"]);
-  await runGitStep(ctx, sourceDirectory, [
-    "fetch",
-    "--depth",
-    "1",
-    repository.url,
-    repository.commit
-  ]);
-  await runGitStep(ctx, sourceDirectory, ["checkout", "-q", "FETCH_HEAD"]);
-  const head = (await runGitStep(ctx, sourceDirectory, ["rev-parse", "HEAD"])).stdout.trim();
-  if (head !== repository.commit) {
-    throw new Error(
-      `Pinned skills checkout mismatch: expected commit ${repository.commit}, got ${printable(head)}.`
-    );
-  }
-  for (const skillName of skillNames) {
-    await assertSkillIsPlainFiles(ctx, sourceDirectory, skillName);
-  }
-}
-
-// src/plugins/skills/catalog.ts
-import { join as join5 } from "path";
-
-// src/core/package-assets.ts
-import { existsSync as existsSync2, 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 (existsSync2(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 || !existsSync2(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/plugins/skills/catalog.ts
-var ESSENTIALS_REPOSITORY = {
-  url: ESSENTIALS_SKILLS_REPOSITORY_URL,
-  commit: ESSENTIALS_SKILLS_COMMIT
-};
-var GEO_AUDIT_AGENT_DESCRIPTION_SUFFIX = "Used by the geo-audit skill; do not use it for other tasks.";
-function vendoredSkill(groupId, skillId) {
-  return {
-    id: skillId,
-    get source() {
-      return resolveVendoredSkillPath(groupId, skillId);
-    },
-    skillName: skillId,
-    agent: "claude-code"
-  };
-}
-function pinnedSkill(repository, skillId) {
-  return {
-    id: skillId,
-    get source() {
-      return resolvePinnedSkillPath(repository, skillId);
-    },
-    skillName: skillId,
-    agent: "claude-code",
-    pinnedRepository: repository
-  };
-}
-function geoAuditAgent(name, briefFileName, purpose, tools) {
-  return {
-    name,
-    description: `${purpose} ${GEO_AUDIT_AGENT_DESCRIPTION_SUFFIX}`,
-    tools,
-    get briefPath() {
-      return join5(
-        resolveVendoredSkillPath("geo-seo", "geo-audit"),
-        "references",
-        briefFileName
-      );
-    }
-  };
-}
-var SKILL_GROUPS = [
-  {
-    id: "essentials",
-    label: "Essentials",
-    description: "Web design and writing guidelines from Vercel Labs.",
-    defaultSelected: true,
-    skills: [
-      pinnedSkill(ESSENTIALS_REPOSITORY, "web-design-guidelines"),
-      pinnedSkill(ESSENTIALS_REPOSITORY, "writing-guidelines")
-    ]
-  },
-  {
-    id: "design",
-    label: "Design & UI/UX",
-    description: "agemon-design: design engineering with anti-slop rules, discovery, and outcome recipes for dashboards, landings, and auth screens.",
-    defaultSelected: false,
-    skills: [
-      vendoredSkill("design", "agemon-design"),
-      vendoredSkill("design", "agemon-design-minimal"),
-      vendoredSkill("design", "agemon-design-editorial"),
-      vendoredSkill("design", "agemon-design-dashboard")
-    ]
-  },
-  {
-    id: "security",
-    label: "Security",
-    description: "Exploit-driven security review \u2014 no finding without a working proof-of-concept, CVSS-aligned severity.",
-    defaultSelected: false,
-    skills: [vendoredSkill("security", "agemon-security")]
-  },
-  {
-    id: "code-quality",
-    label: "Code Quality",
-    description: "Simplicity, DRY architecture, self-documenting naming, and surgical scope control for day-to-day edits.",
-    defaultSelected: false,
-    skills: [
-      vendoredSkill("code-quality", "agemon-clean-code"),
-      vendoredSkill("code-quality", "agemon-house-rules")
-    ]
-  },
-  {
-    id: "architecture",
-    label: "Code Architecture",
-    description: "Clean Architecture review: dependency rule, layer separation, boundary crossing, SOLID.",
-    defaultSelected: false,
-    skills: [vendoredSkill("architecture", "agemon-architecture")]
-  },
-  {
-    id: "self-review",
-    label: "Self-Review",
-    description: "Verification before claiming completion, giving and receiving code review, and root-cause-first debugging.",
-    defaultSelected: false,
-    skills: [
-      vendoredSkill("self-review", "agemon-verify-before-done"),
-      vendoredSkill("self-review", "agemon-review-intake"),
-      vendoredSkill("self-review", "agemon-review-request"),
-      vendoredSkill("self-review", "agemon-root-cause")
-    ]
-  },
-  {
-    id: "performance",
-    label: "Performance",
-    description: "Algorithmic-complexity-first discipline: N+1 detection, hot-loop hygiene, and when not to optimize.",
-    defaultSelected: false,
-    skills: [vendoredSkill("performance", "agemon-performance")]
-  },
-  {
-    id: "commit",
-    label: "Commit Hygiene",
-    description: "Staging review, commit message structure, and splitting unrelated changes into separate commits.",
-    defaultSelected: false,
-    skills: [vendoredSkill("commit", "agemon-commit")]
-  },
-  {
-    id: "teamlead",
-    label: "Team Lead",
-    description: "Team-lead workflows: structured RFC planning and PRD generation for major features or architectural changes.",
-    defaultSelected: false,
-    skills: [
-      vendoredSkill("team-lead", "agemon-plan-rfc"),
-      vendoredSkill("team-lead", "prd-generator"),
-      vendoredSkill("team-lead", "skill-headofit-audit"),
-      vendoredSkill("team-lead", "skill-incident-rca"),
-      vendoredSkill("team-lead", "skill-meeting-lifecycle"),
-      vendoredSkill("team-lead", "skill-obsidian-vault-sync"),
-      vendoredSkill("team-lead", "skill-prd-decomposer"),
-      vendoredSkill("team-lead", "skill-sec-check"),
-      vendoredSkill("team-lead", "skill-task-extractor"),
-      vendoredSkill("team-lead", "skill-techlead-reviewer"),
-      vendoredSkill("team-lead", "skill-tech-spike")
-    ]
-  },
-  {
-    id: "geo-seo",
-    label: "GEO / AI Search SEO",
-    description: "Audit and optimize websites for AI search citation (ChatGPT, Perplexity, Google AI Overviews): citability, AI crawlers, llms.txt, schema, technical SEO, reports.",
-    defaultSelected: false,
-    skills: [
-      vendoredSkill("geo-seo", "geo"),
-      vendoredSkill("geo-seo", "geo-audit"),
-      vendoredSkill("geo-seo", "geo-citability"),
-      vendoredSkill("geo-seo", "geo-crawlers"),
-      vendoredSkill("geo-seo", "geo-llmstxt"),
-      vendoredSkill("geo-seo", "geo-brand-mentions"),
-      vendoredSkill("geo-seo", "geo-platform-optimizer"),
-      vendoredSkill("geo-seo", "geo-technical"),
-      vendoredSkill("geo-seo", "geo-content"),
-      vendoredSkill("geo-seo", "geo-report"),
-      vendoredSkill("geo-seo", "geo-schema"),
-      vendoredSkill("geo-seo", "geo-report-pdf")
-    ],
-    agents: [
-      geoAuditAgent(
-        "geo-audit-ai-visibility",
-        "ai-visibility.md",
-        "Scores how quotable and visible a website is to AI search: citability, AI crawler access, llms.txt and brand presence.",
-        ["WebFetch"]
-      ),
-      geoAuditAgent(
-        "geo-audit-platform",
-        "platform-analysis.md",
-        "Scores a website's readiness for Google AI Overviews, ChatGPT, Perplexity, Gemini and Bing Copilot.",
-        ["WebFetch"]
-      ),
-      geoAuditAgent(
-        "geo-audit-technical",
-        "technical.md",
-        "Scores a website's technical health for AI crawlers: rendering, meta tags, headers, speed and security headers.",
-        ["WebFetch", "Bash"]
-      ),
-      geoAuditAgent(
-        "geo-audit-content",
-        "content.md",
-        "Scores a website's content quality and E-E-A-T signals: experience, expertise, authority and trust.",
-        ["WebFetch"]
-      ),
-      geoAuditAgent(
-        "geo-audit-schema",
-        "schema.md",
-        "Scores a website's schema.org structured data and finds missing GEO-relevant schema.",
-        ["WebFetch", "Bash"]
-      )
-    ]
-  }
-];
-var RETIRED_AGENT_NAMES = [];
-function findSkillGroup(groupId) {
-  return SKILL_GROUPS.find((group) => group.id === groupId);
-}
-var CUSTOM_GROUP_DESCRIPTION = "Defined in this repository's agemon.toml, not by agemon.";
-function localSkill(path, skillName) {
-  return {
-    id: skillName,
-    source: path,
-    skillName,
-    agent: "claude-code",
-    localSourcePath: path
-  };
-}
-function failCustomGroups(detail) {
-  throw new Error(`agemon.toml is invalid: ${printable(detail)}`);
-}
-function buildCustomSkillGroups(configs) {
-  const builtInSkillNames = new Set(
-    SKILL_GROUPS.flatMap(
-      (group) => group.skills.map((skill) => skill.skillName)
-    )
-  );
-  return configs.map((config) => {
-    if (findSkillGroup(config.id) !== void 0) {
-      failCustomGroups(
-        `custom_skill_groups.${config.id} uses the id of a built-in skill group`
-      );
-    }
-    return {
-      id: config.id,
-      label: config.label,
-      description: CUSTOM_GROUP_DESCRIPTION,
-      defaultSelected: false,
-      definedByRepository: true,
-      skills: config.skills.map((skill) => {
-        if (builtInSkillNames.has(skill.skillName)) {
-          failCustomGroups(
-            `custom_skill_groups.${config.id} names '${skill.skillName}', which is a built-in skill`
-          );
-        }
-        return skill.kind === "local" ? localSkill(skill.path, skill.skillName) : pinnedSkill(
-          {
-            url: `https://github.com/${skill.owner}/${skill.repository}`,
-            commit: skill.ref
-          },
-          skill.skillName
-        );
-      })
-    };
-  });
-}
-function assertCustomSkillGroupsAreValid(configs) {
-  buildCustomSkillGroups(configs);
-}
-
-// src/plugins/skills/skill-tree.ts
-import { constants as constants4 } from "fs";
-import { lstat as lstat4, open as open5, opendir } from "fs/promises";
-import { join as join6 } 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 open5(
-    path,
-    constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.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`
-      );
+    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 names.sort();
+  return runRealSubprocess(command, args, options);
 }
-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(
-      join6(directory, relativeDirectory)
-    )) {
-      const relativePath = relativeDirectory === "" ? name : `${relativeDirectory}/${name}`;
-      const absolutePath = join6(directory, relativePath);
-      const stats = await lstat4(absolutePath);
-      if (skipEntry(name, stats)) {
-        continue;
+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;
       }
-      if (entries.length >= MAX_SKILL_ENTRIES) {
-        throw new SkillTreeRefusal(
-          `it has more than ${MAX_SKILL_ENTRIES} entries`
-        );
+      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 (stats.isDirectory()) {
-        entries.push({ relativePath, contents: null });
-        await walk(relativePath, depth + 1);
-        continue;
+      if (signal) {
+        return {
+          code: 1,
+          stdout: stdout.text,
+          stderr: `${stderr.text}Process terminated by signal: ${signal}`
+        };
       }
-      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`
-        );
+      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);
       }
-      totalBytes += contents.length;
-      if (totalBytes > MAX_SKILL_BYTES) {
-        throw new SkillTreeRefusal("it is larger than 8 MiB");
+    );
+    childProcess.on(
+      "close",
+      (code, signal) => {
+        finalize(resultForExit(code, signal));
       }
-      entries.push({ relativePath, contents });
-    }
-  };
-  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)
-  );
-}
-async function fingerprintInstalledSkill(directory) {
-  return fingerprintSkillTree(
-    await readSkillTree(directory, isFinderMetadataFile)
-  );
+    );
+  });
 }
 
 // src/plugins/skills/skills-cli.ts
-import { existsSync as existsSync3 } from "fs";
-import {
-  copyFile,
-  mkdtemp,
-  readdir,
-  readFile as readFile3,
-  rename as rename2,
-  rm as rm4
-} from "fs/promises";
-import { join as join7 } from "path";
 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 = join7(
+var SKILLS_CLI_PATH_IN_TOOLS_DIR = join5(
   "node_modules",
   "skills",
   "bin",
@@ -2042,19 +1664,19 @@ async function promoteStagingDirectory(stagingDirectory, toolsDirectory, cliPath
   if (await renameUnlessAnotherRunWon(stagingDirectory, toolsDirectory)) {
     return;
   }
-  if (existsSync3(cliPath)) {
+  if (existsSync2(cliPath)) {
     return;
   }
   const brokenDirectory = `${stagingDirectory}.broken`;
   await rename2(toolsDirectory, brokenDirectory);
-  await rm4(brokenDirectory, { recursive: true, force: true });
+  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 rm4(join7(toolsRoot, entry), { recursive: true, force: true });
+      await rm3(join5(toolsRoot, entry), { recursive: true, force: true });
     }
   }
 }
@@ -2064,8 +1686,8 @@ async function installToolsDirectory(ctx, toolsRoot, manifestDirectory, toolsDir
   try {
     for (const fileName of TOOLS_MANIFEST_FILES) {
       await copyFile(
-        join7(manifestDirectory, fileName),
-        join7(stagingDirectory, fileName)
+        join5(manifestDirectory, fileName),
+        join5(stagingDirectory, fileName)
       );
     }
     const installResult = await ctx.run(
@@ -2087,24 +1709,24 @@ async function installToolsDirectory(ctx, toolsRoot, manifestDirectory, toolsDir
     }
     await promoteStagingDirectory(stagingDirectory, toolsDirectory, cliPath);
   } finally {
-    await rm4(stagingDirectory, { recursive: true, force: true });
+    await rm3(stagingDirectory, { recursive: true, force: true });
   }
 }
 async function ensureSkillsCli(ctx) {
   const manifestDirectory = resolveToolsManifestDirectory();
   const lockHash = sha256Hex(
-    await readFile3(join7(manifestDirectory, "package-lock.json"))
+    await readFile3(join5(manifestDirectory, "package-lock.json"))
   ).slice(0, TOOLS_LOCK_HASH_LENGTH);
   const toolsRoot = await prepareToolsRoot();
-  const toolsDirectory = join7(toolsRoot, lockHash);
-  const cliPath = join7(toolsDirectory, SKILLS_CLI_PATH_IN_TOOLS_DIR);
-  if (existsSync3(cliPath)) {
+  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 (!existsSync3(cliPath)) {
+      if (!existsSync2(cliPath)) {
         await installToolsDirectory(
           ctx,
           toolsRoot,
@@ -2127,7 +1749,7 @@ async function runSkillsCli(ctx, args, timeoutMs) {
 }
 
 // src/core/config.ts
-import { join as join9, relative as relative2 } from "path";
+import { join as join7, relative as relative2 } from "path";
 import { isDeepStrictEqual } from "util";
 
 // node_modules/smol-toml/dist/error.js
@@ -3072,11 +2694,11 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false, strictTemporal
 }
 
 // src/core/backups.ts
-import { dirname as dirname4, isAbsolute as isAbsolute5, join as join8, resolve as resolve2 } from "path";
+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 = join8(AGEMON_STATE_DIRECTORY, ...BACKUP_SEGMENTS);
-var V1_BACKUP_DIRECTORY = join8(AGEMON_STATE_DIRECTORY, ...V1_BACKUP_SEGMENTS);
+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, "_");
@@ -3086,24 +2708,24 @@ function resolveImmutableBackupPath(cwd, resourceId) {
     0,
     RESOURCE_ID_HASH_LENGTH
   );
-  return join8(
+  return join6(
     cwd,
     BACKUP_DIRECTORY,
     `${sanitizeForFileName(resourceId)}-${resourceIdHash}.bak`
   );
 }
 function resolveLegacyBackupPath(cwd, resourceId) {
-  return join8(cwd, BACKUP_DIRECTORY, `${sanitizeForFileName(resourceId)}.bak`);
+  return join6(cwd, BACKUP_DIRECTORY, `${sanitizeForFileName(resourceId)}.bak`);
 }
 function resolveV1RuleFileBackupPath(cwd, target) {
-  return join8(cwd, V1_BACKUP_DIRECTORY, `${sanitizeForFileName(target)}.bak`);
+  return join6(cwd, V1_BACKUP_DIRECTORY, `${sanitizeForFileName(target)}.bak`);
 }
 function backupDirectorySegments(cwd, backupPath) {
   const directory = dirname4(backupPath);
-  if (directory === join8(cwd, BACKUP_DIRECTORY)) {
+  if (directory === join6(cwd, BACKUP_DIRECTORY)) {
     return BACKUP_SEGMENTS;
   }
-  if (directory === join8(cwd, V1_BACKUP_DIRECTORY)) {
+  if (directory === join6(cwd, V1_BACKUP_DIRECTORY)) {
     return V1_BACKUP_SEGMENTS;
   }
   return null;
@@ -3301,7 +2923,7 @@ var LOCAL_SKILL_KEYS = keyNames(
   AGEMON_TOML_TABLES.customSkill.keys.filter((key) => !key.githubSourceOnly)
 );
 function resolveConfigPath(cwd) {
-  return join9(cwd, CONFIG_FILE_NAME);
+  return join7(cwd, CONFIG_FILE_NAME);
 }
 function fail(detail) {
   throw new Error(`${CONFIG_FILE_NAME} is invalid: ${printable(detail)}`);
@@ -3630,8 +3252,8 @@ async function writeConfig(cwd, config) {
 }
 
 // src/plugins/skills/skills-cli-targets.ts
-import { lstat as lstat5, rm as rm5, unlink } from "fs/promises";
-import { join as join10 } from "path";
+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";
@@ -3666,13 +3288,13 @@ async function prepareSkillsCliTargets(repoRoot, skillNames) {
   );
   if (canonicalDirectory !== null) {
     for (const skillName of skillNames) {
-      const stats = await lstatIfPresent(join10(canonicalDirectory, skillName));
+      const stats = await lstatIfPresent(join8(canonicalDirectory, skillName));
       if (stats?.isSymbolicLink()) {
         refuse(`${CANONICAL_SKILLS_DIRECTORY}/${skillName}`, "is a symlink");
       }
     }
   }
-  const lockStats = await lstatIfPresent(join10(repoRoot, SKILLS_LOCK_FILE));
+  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");
   }
@@ -3687,192 +3309,13 @@ async function removeInstalledSkillCopy(repoRoot, skillName) {
   if (skillsDirectory === null) {
     return;
   }
-  const copyPath = join10(skillsDirectory, skillName);
+  const copyPath = join8(skillsDirectory, skillName);
   const stats = await lstatIfPresent(copyPath);
   if (stats?.isSymbolicLink()) {
     await unlink(copyPath);
   } else if (stats !== null) {
-    await rm5(copyPath, { recursive: true, force: true });
-  }
-}
-
-// src/core/install-method.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, realpathSync } from "fs";
-import { lstat as lstat7, realpath as realpath4 } from "fs/promises";
-import { basename, dirname as dirname5, join as join11, sep as sep2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/core/npm-global.ts
-import { lstat as lstat6, stat as stat2 } from "fs/promises";
-import { isAbsolute as isAbsolute6, resolve as resolve3 } from "path";
-var NPM_ROOT_TIMEOUT_MS = 2e4;
-async function isDirectory(path) {
-  try {
-    return (await stat2(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function pathIsMissing(path) {
-  try {
-    await lstat6(path);
-    return false;
-  } catch (error) {
-    return error.code === "ENOENT";
-  }
-}
-async function resolveGlobalNpmRoot(run, options = {}) {
-  const npmRootResult = await run("npm", ["root", "--global"], {
-    timeoutMs: NPM_ROOT_TIMEOUT_MS,
-    cwd: options.cwd
-  });
-  if (npmRootResult.code !== 0) {
-    throw new Error(
-      `npm root --global failed: ${describeSubprocessFailure(npmRootResult, "npm")}`
-    );
-  }
-  const npmRoot = npmRootResult.stdout.trim();
-  if (!isAbsolute6(npmRoot)) {
-    throw new Error(
-      `npm root --global returned ${printable(npmRoot)}, which is not an absolute path.`
-    );
-  }
-  if (resolve3(npmRoot) !== npmRoot || !isSafeIdentifier(npmRoot)) {
-    throw new Error(
-      `npm root --global returned ${printable(npmRoot)}, which is not a single normalised path.`
-    );
-  }
-  if (options.mayNotExistYet && await pathIsMissing(npmRoot)) {
-    return npmRoot;
+    await rm4(copyPath, { recursive: true, force: true });
   }
-  if (!await isDirectory(npmRoot)) {
-    throw new Error(
-      `npm root --global returned ${printable(npmRoot)}, which is not a directory. npm masks UUID-like path segments as ***; use an npm prefix without one.`
-    );
-  }
-  return npmRoot;
-}
-
-// src/core/install-method.ts
-var PACKAGE_NAME2 = "agemon";
-var PACKAGE_JSON_SEARCH_DEPTH = 5;
-var INSTALL_MARKER_FILE_NAME = ".agemon-install";
-var SOURCE_CHECKOUT_ENTRIES = [".git", "src"];
-var NPX_CACHE_SEGMENT = "_npx";
-function readPackageName2(directory) {
-  try {
-    const manifest = JSON.parse(
-      readFileSync2(join11(directory, "package.json"), "utf8")
-    );
-    return manifest.name;
-  } catch {
-    return void 0;
-  }
-}
-function resolvePackageRoot2(fromDirectory = dirname5(fileURLToPath2(import.meta.url))) {
-  let directory = fromDirectory;
-  for (let depth = 0; depth < PACKAGE_JSON_SEARCH_DEPTH; depth += 1) {
-    if (readPackageName2(directory) === PACKAGE_NAME2) {
-      return realpathSync(directory);
-    }
-    directory = dirname5(directory);
-  }
-  throw new Error("Unable to locate agemon's package.json.");
-}
-function readPackageVersion(packageRoot = resolvePackageRoot2()) {
-  const manifest = JSON.parse(
-    readFileSync2(join11(packageRoot, "package.json"), "utf8")
-  );
-  return manifest.version;
-}
-function isSourceCheckout(packageRoot) {
-  return SOURCE_CHECKOUT_ENTRIES.some(
-    (entry) => existsSync4(join11(packageRoot, entry))
-  );
-}
-async function hasRegularInstallMarker(packageRoot) {
-  try {
-    return (await lstat7(join11(packageRoot, INSTALL_MARKER_FILE_NAME))).isFile();
-  } catch {
-    return false;
-  }
-}
-function isInsideNodeModules(packageRoot) {
-  return basename(dirname5(packageRoot)) === "node_modules";
-}
-async function resolveGlobalNpmPrefix(packageRoot, run) {
-  try {
-    const globalRoot = await realpath4(await resolveGlobalNpmRoot(run));
-    const globalRootHoldsThisCopy = globalRoot === dirname5(packageRoot);
-    const globalRootIsPrefixLib = basename(dirname5(globalRoot)) === "lib";
-    return globalRootHoldsThisCopy && globalRootIsPrefixLib ? dirname5(dirname5(globalRoot)) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function resolveInstallMethod(options = {}) {
-  const packageRoot = options.packageRoot ?? resolvePackageRoot2();
-  if (isSourceCheckout(packageRoot)) {
-    return { kind: "dev" };
-  }
-  if (await hasRegularInstallMarker(packageRoot)) {
-    return { kind: "install-script", installDir: packageRoot };
-  }
-  if (packageRoot.split(sep2).includes(NPX_CACHE_SEGMENT)) {
-    return { kind: "npx" };
-  }
-  if (isInsideNodeModules(packageRoot)) {
-    const prefix = await resolveGlobalNpmPrefix(
-      packageRoot,
-      options.run ?? runSubprocess
-    );
-    if (prefix !== void 0) {
-      return { kind: "npm-global", packageRoot, prefix };
-    }
-  }
-  return { kind: "unknown", packageRoot };
-}
-
-// src/core/dev-mode.ts
-var FAKE_BACKEND_ENV_VARS = [
-  "AGEMON_FAKE_SUBPROCESS",
-  "AGEMON_FAKE_SERVICES"
-];
-function isDevMode(packageRoot) {
-  return process.env.AGEMON_DEV === "1" && isSourceCheckout(packageRoot ?? resolvePackageRoot2());
-}
-function assertFakeBackendsAreDevOnly(packageRoot) {
-  const activeFakeVars = FAKE_BACKEND_ENV_VARS.filter(
-    (name) => process.env[name] === "1"
-  );
-  if (activeFakeVars.length > 0 && !isDevMode(packageRoot)) {
-    throw new Error(
-      `${activeFakeVars.join(", ")} must never be set outside the sandbox harness \u2014 refusing to start.`
-    );
-  }
-}
-
-// src/core/fake-pinned-skills.ts
-var FAKE_PINNED_SKILL_MANIFEST_FILE = "SKILL.md";
-function fakePinnedSkillManifest(skillName) {
-  return `---
-name: ${skillName}
-description: Stand-in for the pinned ${skillName} skill, written by agemon's fake git backend.
----
-
-Fake ${skillName}.
-`;
-}
-function fakePinnedSkillFingerprint(skillName) {
-  return fingerprintSkillTree([
-    {
-      relativePath: FAKE_PINNED_SKILL_MANIFEST_FILE,
-      contents: Buffer.from(fakePinnedSkillManifest(skillName))
-    }
-  ]);
-}
-function fakeSubprocessesActive() {
-  return process.env.AGEMON_FAKE_SUBPROCESS === "1" && isDevMode();
 }
 
 export {
@@ -3910,17 +3353,24 @@ export {
   containsHomeDirectory,
   CODE_REVIEW_GRAPH_VERSION,
   CODE_REVIEW_GRAPH_PACKAGE_SPEC,
-  ESSENTIALS_SKILLS_COMMIT,
   AGNIX_VERSION,
   AGNIX_RELEASE_ARCHIVE_SHA256,
   AGNIX_NPM_TARBALL,
   AGNIX_PACKAGE_FILE_SHA256,
   AGNIX_BINARY_SHA256,
-  resolveToolsManifestDirectory,
-  withFileLock,
   sha256Hex,
   fingerprintJson,
   fingerprintContent,
+  SkillTreeRefusal,
+  isLeftOutBySkillsCli,
+  readSkillTree,
+  fingerprintSkillTree,
+  fingerprintSkillSource,
+  readInstalledSkill,
+  fingerprintInstalledSkill,
+  resolveVendoredSkillPath,
+  resolveToolsManifestDirectory,
+  withFileLock,
   resolveStateRoot,
   resolveAgemonStateDirectory,
   checkAgemonStateDirectoryBeforeRun,
@@ -3929,21 +3379,6 @@ export {
   repositoryStateKey,
   withAgemonStateLock,
   withRepositoryRunLock,
-  isPristinePinnedCheckout,
-  skillPathInRepository,
-  resolvePinnedSkillPath,
-  fetchPinnedSkillsSource,
-  SKILL_GROUPS,
-  RETIRED_AGENT_NAMES,
-  findSkillGroup,
-  buildCustomSkillGroups,
-  assertCustomSkillGroupsAreValid,
-  SkillTreeRefusal,
-  isLeftOutBySkillsCli,
-  readSkillTree,
-  fingerprintSkillTree,
-  fingerprintSkillSource,
-  fingerprintInstalledSkill,
   SKILLS_CLI_PATH_IN_TOOLS_DIR,
   runSkillsCli,
   resolveImmutableBackupPath,
@@ -3963,16 +3398,6 @@ export {
   SKILLS_LOCK_FILE,
   prepareSkillsCliTargets,
   removeInstalledSkillCopy,
-  resolveGlobalNpmRoot,
-  INSTALL_MARKER_FILE_NAME,
-  readPackageVersion,
-  resolveInstallMethod,
-  isDevMode,
-  assertFakeBackendsAreDevOnly,
-  FAKE_PINNED_SKILL_MANIFEST_FILE,
-  fakePinnedSkillManifest,
-  fakePinnedSkillFingerprint,
-  fakeSubprocessesActive,
   MAX_RAW_OUTPUT_LINE_CHARACTERS,
   sanitizeOutput,
   capShownLine,
@@ -4023,4 +3448,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-5LATHJYU.js.map
+//# sourceMappingURL=chunk-ZZBF3GOV.js.map