@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-AW74INUW.js

@@ -0,0 +1,1456 @@
+import {
+  HANDOFF_REL
+} from "./chunk-5VCOWTTP.js";
+import {
+  fileExists,
+  readJson,
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/manifest/types.ts
+var MANIFEST_FILENAME = "agent-kit.json";
+var MANIFEST_RELATIVE_PATH = `.cursor/${MANIFEST_FILENAME}`;
+var MANIFEST_SCHEMA_VERSION = 1;
+var DEFAULT_PROTECTED_PATHS = [
+  HANDOFF_REL,
+  ".cursor/plans/**",
+  ".cursor/memory/**",
+  ".cursor/context/config.json",
+  ".cursor/context/current/**",
+  ".cursor/context/backups/**"
+];
+var LEGACY_CONTEXT_PROTECTED_GLOB = ".cursor/context/**";
+var DOMAIN_PACK_IDS = [
+  "cybersec",
+  "devops",
+  "engineering-architecture",
+  "clean-code",
+  "project-management",
+  "context-management",
+  "quality"
+];
+
+// src/manifest/index.ts
+import path from "path";
+
+// src/manifest/parse.ts
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var KEBAB_ID = /^[a-z][a-z0-9-]*$/;
+var ManifestValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "ManifestValidationError";
+  }
+  issues;
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertStringArray(label, value, issues) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    issues.push(`${label} must be an array`);
+    return void 0;
+  }
+  const out = [];
+  for (let i = 0; i < value.length; i++) {
+    const item = value[i];
+    if (typeof item !== "string" || item.length === 0) {
+      issues.push(`${label}[${i}] must be a non-empty string`);
+      continue;
+    }
+    out.push(item);
+  }
+  return out;
+}
+function assertKebabIdArray(label, value, issues) {
+  const arr = assertStringArray(label, value, issues);
+  if (!arr) return arr;
+  for (let i = 0; i < arr.length; i++) {
+    if (!KEBAB_ID.test(arr[i] ?? "")) {
+      issues.push(`${label}[${i}] must match ${KEBAB_ID}`);
+    }
+  }
+  return arr;
+}
+function parseOverrides(value, issues) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    issues.push("overrides must be an array");
+    return void 0;
+  }
+  const out = [];
+  for (let i = 0; i < value.length; i++) {
+    const item = value[i];
+    if (!isPlainObject(item)) {
+      issues.push(`overrides[${i}] must be an object`);
+      continue;
+    }
+    if (typeof item.path !== "string" || item.path.length === 0) {
+      issues.push(`overrides[${i}].path must be a non-empty string`);
+      continue;
+    }
+    const entry = { path: item.path };
+    if (item.replaces !== void 0) {
+      if (typeof item.replaces !== "string" || item.replaces.length === 0) {
+        issues.push(`overrides[${i}].replaces must be a non-empty string`);
+      } else {
+        entry.replaces = item.replaces;
+      }
+    }
+    if (item.note !== void 0) {
+      if (typeof item.note !== "string") {
+        issues.push(`overrides[${i}].note must be a string`);
+      } else {
+        entry.note = item.note;
+      }
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function parseAgentKitManifest(raw, warnings = []) {
+  const issues = [];
+  if (!isPlainObject(raw)) {
+    throw new ManifestValidationError("Manifest must be a JSON object", ["root must be object"]);
+  }
+  const { $schema: _schema, ...rest } = raw;
+  void _schema;
+  if (rest.schemaVersion !== MANIFEST_SCHEMA_VERSION) {
+    issues.push(`schemaVersion must be ${MANIFEST_SCHEMA_VERSION}`);
+  }
+  if (typeof rest.version !== "string" || !SEMVER.test(rest.version)) {
+    issues.push("version must be a semver string");
+  }
+  if (rest.profile !== void 0 && (typeof rest.profile !== "string" || rest.profile.length === 0)) {
+    issues.push("profile must be a non-empty string");
+  }
+  const packs = assertKebabIdArray("packs", rest.packs, issues);
+  const skills = assertKebabIdArray("skills", rest.skills, issues);
+  const protectedPaths = assertStringArray("protected", rest.protected, issues);
+  const overrides = parseOverrides(rest.overrides, issues);
+  let registry;
+  if (rest.registry !== void 0) {
+    if (!isPlainObject(rest.registry)) {
+      issues.push("registry must be an object");
+    } else {
+      registry = {};
+      if (rest.registry.url !== void 0) {
+        if (typeof rest.registry.url !== "string") {
+          issues.push("registry.url must be a string");
+        } else {
+          registry.url = rest.registry.url;
+        }
+      }
+      if (rest.registry.ref !== void 0) {
+        if (typeof rest.registry.ref !== "string" || rest.registry.ref.length === 0) {
+          issues.push("registry.ref must be a non-empty string");
+        } else {
+          registry.ref = rest.registry.ref;
+        }
+      }
+    }
+  }
+  let personalization;
+  if (rest.personalization !== void 0) {
+    if (!isPlainObject(rest.personalization)) {
+      issues.push("personalization must be an object");
+    } else if (typeof rest.personalization.contractVersion !== "number" || typeof rest.personalization.generatorVersion !== "string" || rest.personalization.origin !== "repository-profile" || typeof rest.personalization.resultPath !== "string") {
+      issues.push("personalization must contain a valid origin and version contract");
+    } else {
+      personalization = {
+        contractVersion: rest.personalization.contractVersion,
+        generatorVersion: rest.personalization.generatorVersion,
+        origin: "repository-profile",
+        resultPath: rest.personalization.resultPath
+      };
+    }
+  }
+  if (rest.installedAt !== void 0 && typeof rest.installedAt !== "string") {
+    issues.push("installedAt must be a string");
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    "schemaVersion",
+    "version",
+    "profile",
+    "packs",
+    "skills",
+    "protected",
+    "overrides",
+    "registry",
+    "personalization",
+    "installedAt"
+  ]);
+  const unknownFields = {};
+  for (const key of Object.keys(rest)) {
+    if (!allowed.has(key)) {
+      warnings.push(`unknown field: ${key}`);
+      unknownFields[key] = rest[key];
+    }
+  }
+  if (issues.length > 0) {
+    throw new ManifestValidationError(`Invalid agent-kit.json (${issues.length} issue(s))`, issues);
+  }
+  const manifest = {
+    schemaVersion: 1,
+    version: rest.version
+  };
+  if (typeof rest.profile === "string") manifest.profile = rest.profile;
+  if (packs) manifest.packs = packs;
+  if (skills) manifest.skills = skills;
+  if (protectedPaths) manifest.protected = protectedPaths;
+  if (overrides) manifest.overrides = overrides;
+  if (registry) manifest.registry = registry;
+  if (personalization) manifest.personalization = personalization;
+  if (typeof rest.installedAt === "string") manifest.installedAt = rest.installedAt;
+  if (Object.keys(unknownFields).length > 0) manifest.unknownFields = unknownFields;
+  return manifest;
+}
+
+// src/manifest/index.ts
+async function loadAgentKitManifest(cwd, options = {}) {
+  const target = path.join(cwd, MANIFEST_RELATIVE_PATH);
+  const raw = await readJson(target);
+  if (raw === null) return null;
+  const warnings = [];
+  const manifest = parseAgentKitManifest(raw, warnings);
+  for (const warning of warnings) {
+    options.onWarning?.(
+      `${MANIFEST_RELATIVE_PATH}: ${warning} (kept, but not understood by this CLI; newer CLI?)`
+    );
+  }
+  return manifest;
+}
+
+// src/lifecycle/glob.ts
+function normalizeRelPath(input) {
+  return input.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
+}
+function matchSegments(patternParts, pathParts) {
+  let pi = 0;
+  let si = 0;
+  while (pi < patternParts.length && si < pathParts.length) {
+    const p = patternParts[pi] ?? "";
+    if (p === "**") {
+      if (pi === patternParts.length - 1) return true;
+      for (let skip = si; skip <= pathParts.length; skip++) {
+        if (matchSegments(patternParts.slice(pi + 1), pathParts.slice(skip))) return true;
+      }
+      return false;
+    }
+    const segment = pathParts[si] ?? "";
+    if (p.includes("*") || p.includes("?")) {
+      const re = new RegExp(
+        `^${p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`
+      );
+      if (!re.test(segment)) return false;
+    } else if (p !== segment) {
+      return false;
+    }
+    pi += 1;
+    si += 1;
+  }
+  while (pi < patternParts.length && patternParts[pi] === "**") pi += 1;
+  return pi === patternParts.length && si === pathParts.length;
+}
+function matchesAnyGlob(relPath, globs) {
+  const normalized = normalizeRelPath(relPath);
+  const pathParts = normalized.split("/").filter(Boolean);
+  for (const glob of globs) {
+    const pattern = normalizeRelPath(glob);
+    if (matchSegments(pattern.split("/").filter(Boolean), pathParts)) return true;
+  }
+  return false;
+}
+
+// src/lifecycle/protected.ts
+var CONTEXT_SESSION_GLOBS = [
+  ".cursor/context/config.json",
+  ".cursor/context/current/**",
+  ".cursor/context/backups/**"
+];
+function normalizeProtectedGlobs(globs) {
+  const out = [];
+  let sawLegacyContext = false;
+  for (const raw of globs) {
+    const g = normalizeRelPath(raw);
+    if (g === LEGACY_CONTEXT_PROTECTED_GLOB) {
+      sawLegacyContext = true;
+      continue;
+    }
+    out.push(g);
+  }
+  if (sawLegacyContext) {
+    out.push(...CONTEXT_SESSION_GLOBS);
+  }
+  return [...new Set(out)];
+}
+function resolveProtectedGlobs(manifest) {
+  const fromManifest = manifest?.protected ?? [];
+  const overrides = (manifest?.overrides ?? []).map((o) => o.path);
+  const merged = [...DEFAULT_PROTECTED_PATHS, ...fromManifest, ...overrides];
+  return normalizeProtectedGlobs(merged);
+}
+function isProtectedPath(relPath, globs) {
+  return matchesAnyGlob(relPath, globs);
+}
+
+// src/registry/client.ts
+import path2 from "path";
+
+// src/registry/paths.ts
+var REGISTRY_INDEX_REL = "registry/registry.json";
+
+// src/registry/client.ts
+async function loadRegistry(rootDir) {
+  const indexPath = path2.join(rootDir, REGISTRY_INDEX_REL);
+  const index = await readJson(indexPath);
+  if (!index) throw new Error(`Registry not found at ${indexPath}`);
+  return index;
+}
+function allSkills(index) {
+  return [...index.skills.core, ...index.skills.community];
+}
+function allPacks(index) {
+  return index.packs ?? [];
+}
+async function findSkill(rootDir, skillId) {
+  const index = await loadRegistry(rootDir);
+  const skill = allSkills(index).find((item) => item.id === skillId);
+  if (!skill) throw new Error(`Skill '${skillId}' not found in registry.`);
+  return skill;
+}
+async function findPack(rootDir, packId) {
+  const index = await loadRegistry(rootDir);
+  const pack = allPacks(index).find((item) => item.id === packId);
+  if (!pack) throw new Error(`Pack '${packId}' not found in registry.`);
+  return pack;
+}
+
+// src/lifecycle/overlay.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import path4 from "path";
+
+// src/lifecycle/overlay-known-hashes.ts
+var KNOWN_SHIPPED_OVERLAY_HASHES = /* @__PURE__ */ new Set([
+  "004d98f557942677264d053dcd8335f2bbcf19c5591123ec16a7a2697cb88932",
+  "05ee6ecde4215e33ace0ee152ffbf2cd885d2bd4b032900f0f0bb001d350ef0f",
+  "082bdbc584be3f3d8aa6e9d7b9f4e076450f3ff48f9147a1deb557e31475036b",
+  "09850afc201eccb3e700cb934400d49c9cbe7510d4a546ee84ee519771a8200e",
+  "0b5fe4729c3c68654434837630d775b847c082418f25b0b2c581700fe84b797a",
+  "1106b279558b6a20f87951102f172a680976f3e6530855d5dad083e1f89b9ba3",
+  "12bed56b332406477cf546d9e8360d3cab129bd82a638bea356726d00a6847a3",
+  "13f6a0711a2fcadcc7f1b751772448517ce4871cdef6a0269fc26dad51ebe26d",
+  "15566765ec95dad3bc3160f20ac910e01a13471df536e6d990f4b263700784a9",
+  "1681e6cf7b80a67cd999b94b8b6e16eb8caed0e11b32905848ba733da956e902",
+  "17818e47e06349ee35c1d8e1cc16e8bcbbbcc89c664014e9096e1f08c8567807",
+  "1974a5af0e4ba2bb0fc7e1872ef9ab70e323323ab216958c31731bcdd82c8241",
+  "1b384771cc6228215e31e6a9ab0943b13a5cdc463354a2641f1c0d85b4357e84",
+  "1b5f8c4197393dc9110d020f3b619b8502862adeb6522a6b9be4b49dd8794612",
+  "1c5c1af87951367ad04bb6fa5b1d6ebaaefbc0ee95989b624cabf406a1869907",
+  "1ded5c7b7eefc355fc1d17feb65ec472e35ed96076e47ce95f7bff5c1b84746c",
+  "1e58e0d4f2e8459b95a40d1b1e72c5c85a87230cbde945840a84073fe3a20422",
+  "2280e3ca96129ab2de8a85a301df7c2b15ffaa6204b734ed3b1f303e0055c41d",
+  "285668d08f1b15d96286d27e29cc4a67e126e097fb8a940bdde33ccf25bd2bcd",
+  "2acdb148b07f3a4872b896da419af796fd3fefaace7ac79cdee0aab447004a83",
+  "2cd7fc018a384b0188737259ecf593ce25b4b75cc38b3e410063ac91745894b9",
+  "2f6cedfa61cb62126efd6b845bbf4d8d7913e39223d5f799ac09ef64c0489824",
+  "3204a7449f3031916a8d57b37144e5d8ded6c94aa5659493fa5cc2c7321f4eab",
+  "33982aea21a074d21a638850475ce1fefa7d043ec035de3855889cc68d60cf35",
+  "38675aec695e9d4e7f16e8fbe3facc3280f47fb875bf9ac50bd6837b92b7a7fa",
+  "3ee94e2441218025c085856679d17b4a4fe7a6e3d0274423abe20a422a5ab05d",
+  "3f3354825ff06ff9f9ae1e29b71784fef4250020c23c1b490940cf06b2be0f28",
+  "46a1dd4a07a2190ab9fb09abc05a3962277209f8e0c28033bb41450301474c86",
+  "48a0d55e21132a305946b195db7f6b75da78d44a1d32166fb0c69bef4a5ffbe2",
+  "4b62a46c74e5fa6a80283f21e8e6711958fbcd577051dc73ff4050643a031475",
+  "4ba6e319ac79455a7d2713674f64fabbc9cd401b5d26b1c0edbd19c27a52297e",
+  "4bf23acbc9bd4e0f8468e61f4970e182600b72d9025d29e81ddbd83cb7b1710a",
+  "4c5167d0ebde685f266dce32c516a7c43876e0520647b93f07f2e2147e6a7b2f",
+  "4dc4efcd1b43c643d3889fb349df8d4964d0867c3a67eb67e2ec168fbb70fc75",
+  "4f133554d01cedc62280006f4cf6453e25a5cb41ef6dde4a43f9508cb36ef75d",
+  "4fe1e2bce8bd55a6decdd62c887a423cf85148b692f313aad4c777d0e50596b3",
+  "4ff844cf789cef4b1e809a55ca006316cd964bcdb2557d91c916a08e30ad15f6",
+  "533b41599c25698e5746166096a68fd4080efb5e16287b2a1ed5f73295cda446",
+  "54dda8addb74bc187ee23c31f8b7d17ad19e745a45169d29ffea094860eb18f2",
+  "570c3f91fd31a4cc1e56e997c85feab5c6756f45fc73dc741afe573912111231",
+  "5cb36f5dab846b2551afd05eab92c14122853c147d7f02136d1c04e01e3c9def",
+  "5d302d207521c53b9fa814ee0eba1376a5b2bfd2983c0373657c9fdf9884541b",
+  "5f5c125f7edf280029f214589ce3e088fc74bad717e30178405a3b537673c42f",
+  "621bc6cecf7c710a97e93463ca9b8872a1fcab1325c358cc8be65b418eebb339",
+  "693c732658e31d6403cf59e85985518f24ab92bf7fcdc3c225e9a79e54597a43",
+  "69715048da3963947aa8a39e7ac30ec01632fec862bfcb9559c46764b4833be0",
+  "6994595e3a62edb6c518006a6bece6848c7077977c041439cf7c822b89304a14",
+  "6a42e76fc038ca69ddad18541b8df161770c58980fefaf9e5e80d87407074bec",
+  "6a9af9e8a95dbb279347166c43dcee245ca673f9687841086b49911c54944c26",
+  "99fdd85310e658a1c1b0e8f92257493409c28c3d693f24deeaa665861788e1e4",
+  // public registry SoT n8n-workflows/SKILL.md (em dash description)
+  "6b66ed7747ea2d19cb457f5af656e3c07f9f563f7f32b3951fa4ae5f27f0ac46",
+  "6dede0588274f5b44d833bcc696ec4776eb978ed24a20efdcc9c38caf3df1576",
+  "71991a10972b8b956cae93c88517e31741c95e351814082df65e44f813590210",
+  "75ae3018a70ed838428c0e63e8b6901ac05bf1f1cf1845faa6f73c3940d22e4a",
+  "75e591bfde61ca1ca3ca1303cc9bc487197af2f713c68f346a46e94ca9432fd5",
+  "76ae85bbc336c6f435d9653e8f254ae49774b4ebaecf7335697115933eb8797c",
+  "76c4361e70a73276771e841e2c939253b4124d690a0fd25aff2a3ac636d8f4b0",
+  // mission-kit-comms/SKILL.md
+  "79878f0f6f59d1a0b65d94011c0cafe7b6f8e03e89f568aa638b8ba7a2c34076",
+  "8108b202c829627c3c2df33575016ebe942df42acf4f1cc393900be3b82b402c",
+  "819b7bd3ba9e8bf12dcd4f81a76c98e48261b34c397f339b36d36eb364d9c3f4",
+  "8619500b0c7024390d43e3aaefa2a2d731728d7c664aaf90e0acdd067f3397ce",
+  "875b0a8805280b2a2df43f2c42f9063fe0623a34fa19c3aa5d2ec48211f3ebae",
+  "8a11c80b0fbf6c4aabf60eec05b8cca7dccf5bca472787a8afa3028fd8fbedfa",
+  "8b25659727063013e8bf6d7925f815b2630c2919b21e6fdac354362bf122bfab",
+  "8c7edbacc74b1431fbecb04c9857c0e7a9cb1578fc6ca6367be888dbcec3c98f",
+  "8d8d60e929ebf717eed3c1a29ee0de7c71ae917d125eb1b220a77220597281ed",
+  "8ffc181bb152c68a3353309bfdc87c42bdb925b98675cdba959c0cdb90b2adea",
+  "91ce0c933e3c8ee81927b8224f944ec5ce5445098a2ad154773092e3541dbf69",
+  "9309af07a0a99a56143386b3ddd2a35fae29378fba3f6b4c9297a5d1c02a9724",
+  "9439da963acbe5dd88a3aa4d6ba4fb297db666ce8f2c9d3917dbc6d6e517f9aa",
+  "989e7e1bdfb29dedf850405f28648810d008885196efe7ae38c6e7554c7ce45d",
+  "98d96e25f67aa9c234cb0c422f0d701c22a04bfe184fb4eb68295003d429552b",
+  "99031145609af46e7e0f315006bf633f47002eccece8eb7af8b5efd762313ade",
+  "9a3cea681399b42ef930a0720802378fe1b06ee73370df9ede9d0309c3c60ab2",
+  "9ccf52fe53c6fa4d731650ab4928ce50e201fa34f3e174fee70e3d29867fef2a",
+  "9d905aca0123f3018c81c579217104f1749d8da802f3837b2407fbad8f2d803f",
+  "9e324c52c1a9d1ceee738bccf47da92910aca9f7a5a21cc41738d9573c414830",
+  "9eb457654167df562481637b25ecd91f0ff3c9282ba79409089d644d3b09b926",
+  "a013a6a476160183d6457ff6c1c51ec228bdca359b11eb15cd9b7fc177a705db",
+  "a08d04f8efa121ad498f96873778c22630c9172c07c216839e348cd0bb7c2292",
+  "a7cd7058bcb6fbd962c37317fa16893bc86a270d0164af5a0e6f3f026aa408ad",
+  "a833a7131cdfc003b45a48cb26c6ce33dc218c1814156047db5211a79192e0a0",
+  "ac2f1f7d9e68f9c98fc4fe5ca348b1a90cf484141bbd116db871d63bdcc3c7c3",
+  "b5c7a10df90d209be07159b7ff9bfa24e869538a0b6026bb5ce79e1cdd5b2528",
+  "bd9fd1efacbd132c5dafc12cd0cf2b651a2b1fab7b2d7a9ba4a3e44128097f48",
+  "be964ff33a40280e13ce6071fb3e30ce87c374527efbb74c25c9d4534084a634",
+  "c245035b539e41e822fab8c74fcde3b18c45f4b9f26f1c8583fc9e7254249698",
+  "c794accc6668d74a739c982c1b63985a8be4be08afe3766214ab1e08d25ea95c",
+  "c96d522be440fbb638dbe953cebf1bb31185c431ac2e14446369cfb7d155a951",
+  "cf2bd11891b934484171fa705f470de284e3874402e1e487750735dbc7692857",
+  "d0e3bf82efbe32c09761689802ffea7838046dbdd4803b88ead5ec3dfc7efb7e",
+  "d4659e4bb6fd6022559fc632b17db6a39007c04bc0ded59017a0dacc013632ed",
+  "d484243167e13c34f9df7ff378baf2967f7cbfcd88170d4d32e745efbcae7480",
+  "d67ac8fa1edec6e50c82aeca064335e799e408d0e4bbc95e1407cf7463a61de3",
+  "d7ad53f06a41bcb2f2b998fd4a4c99209a0cf287cf0d0d4acbcc36c73dd46e4a",
+  "d96aa15dde45147aa40db64684688a4b5c9ad660dcd16c55156b31933a42c37e",
+  "d9ecd90f80ebc25db73ebed27c32596b9cfce518b3026a3a4d5787321ba6324a",
+  "dd01d051dbab257e16609b02c983bad6a576ed8473781b4f1df9ef2eb5f85795",
+  "dd9ff2ff8aa7bcb2cdfc59092ad73227631c1c3619b495131f7faee65224cb17",
+  "de6efabde6a1d69357926b88b5a4ed3eec19e11b82597cb999f5365f952305b8",
+  "debc0758b3e39294df85ccb7eab3455e93a2b8c608602d309a7b0ebdb6618805",
+  "e03b5764b908f9ed5c592108fbc11d5962d9256fd129a63ab4a39c8efaa2ef3e",
+  "e102e77f9f520f938d26861978249e4d85a8c8755d48c8e79b21fef9423325ee",
+  "e2d89f780c6ae5393dc05818f9e3e9a8bf6629eac05702eea8f9a25b578e3ff1",
+  "e2f1e9108fd450817ab42570db656b1e43b20b5ba703b14027ce540e1b8fe502",
+  "e37c62695b5c70451ef1a0c90b31b73a9c442ebc55fb3fc3f79c294b993b99ea",
+  "e3c32aec17e8f728cbd13162a123a9debffb8bbcec527a00b1c2df30a1a20080",
+  "e511e04064ffb8c429b659d2ae2e0f223e8cc51039ae816753095a5f7a160595",
+  "e5682d4696e874d09f12a1d65891fee5971201a29c654c08f5d3b90fb9a6a0b7",
+  "e57437bf790fda1d43b895e2b5b0a7d2d57635c319ac0e2439ba2222a825bcde",
+  "e8bb214c3e551c44f379db13c5962ef20698b505b0227d283d3ae632e1bc3626",
+  "ea36e74c9d592980cba5c08d04ee70fc59a6cd01e87a50bbfae4f668557df4b4",
+  "ebd41f8df764a14b3460016fafcfdde98c4c3a59a3c17f773451ef061fc42f95",
+  "ef181a4e2bd9f82f45628637b8d66925ffa20801558808f1b03ea72b7cb82a72",
+  "f061432a2606049717c0cbf098ef07b1da4df2b136c4cb9cdaa7ea44c876bcd6",
+  "f061d36a1180293519fbb560bbf659c621bd90885e995fca6eaf2eda9e418a50",
+  "f28731a82f4b394a5765fdefe2d1b667810831f6dcea400ca62bc66e1d65371c",
+  "f43a5484e39aca4e6af86e7f8d2941773cdc1c960838ad88ae3540c49a1097df",
+  "f46c108457e4fe12953dca75b409e06fca9cb264baffabe0c0d04c89af471e56",
+  "f6bc17efa746680a44bbc49be67ac3f924d9c306c6d937f9959c57a1d3c5b9af",
+  "f981764422d468567b5aff31148dc659aeee22cb13dc0ecd873d737deaf07372",
+  "fa306a0cdb0f40c817e32164cd03b946564a02b4b7f7c3f4f0b9513096584d28",
+  "fa5cf460eb314437081f7cea30dc8041c0bd6fc3f560a74bc2d7be1bf07384b0",
+  "fc39ec6d8a22498697f968ffc0fe5f717bed97afd68f922c76a80ed1f10d6579",
+  "a8756742197c3a2e1a6d64f4bde2a88db48abb66a0f449d625cd2e1c7b8d0cb4",
+  "6a5f8795a4a26b419f167e249576b798781c95308dc1ea50958351de713231d4",
+  "4009c5e2faf9775d5708cdff0b5f9da80fd3ce390cc42aed0bb94272f6b05b1b",
+  "a8e070fae187908ef7b2cf2a41605e3079329403b1802b5fc67e83294c96a070",
+  "81186b528105f2873818ea91f51d20c95a68c0c4b3d128aa8896dd38a1bb3159",
+  "b2c7db73a0e18bd475651001722aa34b39276af9f73f0921102b680eb42bea0e",
+  "d03445b726cb6afe2ff37a936de97605cc60e441896e06385abfc15a127e2f45",
+  "f5ef970adaf4cfa7af551e35cb41b4052576109f5444a280b1e26562338b39e8",
+  "fe3f8e2339a7f183545f2aad6b7f02d3687277ca67597fa7620bfee269392bcd",
+  "b2489e381ea7daaef7299e5aede437a8baaa39baaddaac849efbf0a6ccb84a2b",
+  "0ae7d076904fd342de3ba38745f38fed8ca5c1f02d7b099d27deeb0a9be79740",
+  "15ca459811f0f050f4eeff77d4567b45c0790beb77904ecf37e145d65a858c77",
+  "1dc329c0c0695a4395bb7c30db0fb7b6fb06bcf5fdc1d6a475656ac6a525aa5f",
+  "35bb0008ef52af147a45fba667f7dceb841d537ad5e185317672577afbcbc189",
+  "42b701d224f4e690dc027d66fcc1214bab31a0ae0c50ef982124f57d4dae4982",
+  "65272f85a32f8fe95ed19d0823fa9d1d6dee5bc18a0244f7b553ea5162ba9b36",
+  "73cd50bac290b84df6245d3647e686dee8ec3b0434736d08fdba6e30d342ef0a",
+  "61b635ea8a08171062bd329a4615d7426eb787eb796271aa882f55f39db56810",
+  "86afbea8f64de68a79ad5e374f3132bdbe2582b94321fb3d438314838e36c776",
+  "65cc1c0293b145e48ed73ad0ca9ab33cbba5ed834a5bfb31f195ed30c2f143df",
+  "f04fcfe31354d1b09aeb256a17e4aab91c98ea48a5cff25e4a0281af3cfb289f",
+  "34e559ad9036d93d9cbc96d394bc2bbeb10ce50ead00d58a914158ae19daa76c",
+  "359a142aeadd769a9b89ac909ae5129940e7e6b0892b70256098c584d97631ce",
+  "8eab94f7a78149db1bbbc0fd45f21dc2d874209d534bcff39077fd6e1d2c42fb",
+  "9be406f92f7dca71f3af814b14fb26b011f9f12c37c789f7ddc3d647b1a7ab60",
+  "bb67ddcdd9ab58ed89287421f5e4b6ebfb3941e6a789287ddec9b9c25b56b1ed",
+  "7343ecd797f484eea1a3ebc11e87c75d90f617bd627bfc367a1eca5a1628bdf1",
+  "8a723b4808f14413fc173a6ce33370067ffc78d0c2e05a21c4406d7fa3e66457",
+  "65554e304a70b77e07fe40facf0ef305d6216399bfbb811db2491ce2f31d86d7",
+  "f8cc89a52fb1ec17f7f26ecd5cb18f79a5e9c7b7ffe7a6899465aa4090433b98",
+  "543e6596e7ce9f3ce4de642f1ea7e5d437d553fa28c0d56eb0f244ec8526ce17",
+  "71c6d1cce604c4a275db7c9a5c48f1753604bf35e083be054511ebc91f4977e6",
+  "8d0fd61bcbb9e035dea3a8b9f298a48c226bb28785923cb07e1154cf084934ad",
+  "1d489cea7648a73b4fee12dbadc592700024272d0f1562378e1b1e8ed2bbeffe",
+  "246216002ee4c98ee4daf1402c531fc2788bb2dc1656d5517844da0ab674c086",
+  "9dea9e262e096c9cde32dfd1d1c2d832114018f8768679320b5dba9d442ebaa8",
+  "ec78c2d6cae7b1120a88bc8a2e4796e1525b894c4c44e653770ef2807ba0080c",
+  "221ebfef9a7b94f4d10ab21d13be073426405bb7d8550e89bc04935a43494284",
+  "78dc088900961ef37419d050ac7f5b499f8dbcc1ec663ef923dbac892e236d32",
+  "379f565e3321bb89c51d04ad9b2f939d8e0a4758b0b6950ad98b19c5963d091f",
+  "b65c495e70ced29711e0b213a9eb5333b5446e7f5393ad2a461b373dfb60f53c",
+  // .cursor/commands/run-plan-all.md PO adjustment-class hard drift
+  "b0058c7516917079514696e5a4e25250b3f5542145557d4bb94761c48e1f5ffe",
+  // .cursor/commands/run-plan-all.md start/resume 3-way Ask
+  "19562f3079fe27380b947742107dd693f5cf606188f468203f0a481b2668e9c7",
+  "3bdad79bd9e25ca127b85a8e5f659db6334cf11903e2ad163d053a94d5efe4f2",
+  "48a6c5e9a9a07ed7ee11ef31b6895be3176f727ac9a7665959d87a97de89da0b",
+  "4aaff4b1d51c3627e353458aa4d733736666dc2c3f8b7711b9677131eed7cefb",
+  "6bc92f215031c0f9702b39cf7cee2076928a0516c4a756c603c730bd0878eca3",
+  "8a6b53d5702431af97a9dfcbc97c47b9bf562561c40e2b09f7271a19998a8d06",
+  "949d8c97a7c2cdad133ab9e28b9c2955157fee988125f4e94f0659d10a24ea0d",
+  "96a77a9d75de9985d967f030626d779677db18f54a5966f5df1d770557c87190",
+  "cdef696f85a7e594289ec604918aad8122c4d03cfd3991dc28a114e853190186",
+  "e10ec219a3bfa6cea556f9cf0c1905ae35a578fc329c9476808faf9084b62d01",
+  // Hooks and scripts joined the overlay after v5.7.0; bodies shipped at released
+  // tags are listed so an unedited older consumer copy still refreshes instead of
+  // being preserved as customized.
+  "196f18aac06c4dc82f937bc147d00f44177aea1a3c0bdeb661d5d81cfd84523e",
+  // .cursor/scripts/plan-external-review.sh as shipped in v5.3.0–v5.4.0
+  "ca7698db9747f8b2333d7f9f0ed2de72b0f029ee8b1d6dcf3e54e52cff6dbf3c",
+  // .cursor/scripts/plan-external-review.sh as shipped in v5.5.0
+  "fd621d8a5fe64f9dde94c62dd7a3402602e1d92d9c5b80fde60660532a1a06d3",
+  // .cursor/scripts/plan-external-review.sh as shipped in v5.6.0
+  "901471bdf9dedb5d87659dade4102b56794f480617ab534d3f86d18a291be443",
+  // .cursor/scripts/plan-external-review.sh as shipped in v5.7.0
+  // .cursor/scripts/comms-draft.mjs is not an L0 artifact today (never written to a
+  // consumer); listed so a copy at any released tag refreshes if it joins the overlay.
+  "9f44b146b88d6bad2f27ddf03b7241223e63d5785f4bfc5fe3fba2e5208286f3",
+  // .cursor/scripts/comms-draft.mjs as shipped in v5.3.0
+  "f9377bc3547b6202267745905337e7b4562fb8cb5949198401b89fa5ff99c628",
+  // .cursor/scripts/comms-draft.mjs as shipped in v5.4.0–v5.7.0
+  "434d3c01e60a3ce5247b990486d251b9ddba66f3cdf0cf6da84b8b3a030b41e4",
+  "b5f6bbbb9ae839989dccf1758ebf2d08c826295be820c1c41e0b7914dd34481d",
+  "c18004ccafe021fcef38b0a567e2701aeaa6d7d890f43684b7317b5e6428a31b",
+  "e093af1f2c8f3bdf6dfa6ab92586ab84b1df180a8b77718b884a0f6f91bd53c4",
+  "3a88df22375f90a3a6743f50d9a01129e0373f4ca8dff03fb744c1de3c149409",
+  "481a9994ccecaa611173f9ef91a1dbe7458d89758c6a6b5e7c3bbbbf460888ce",
+  "691d91fd1e9032b6f9315f29348d4473201917da257258afd74eb954298d8d71",
+  "ab0808b7dbc333e523b87b126bb655353cde2574db30d849cc9c9037843bef8c",
+  "85514e26af694bbe38e7ddf625710a32719ddf6afc173843c9cdfbffdad8e466",
+  "35b6c0cde7538fb1837d54ba841668e82ac7b9e3ef274adcea3d7f34ba4bfb64",
+  "4230e45f2ccd89cf8e25c56d21dfbfbe134613c686ea361243f94c49cf6802af",
+  "b4fbb2c15a1330ba36351a90490696fd558a347d25ac14af768017d6155335c0",
+  "c37ee51662b6eca65224d737911a4bb209a3742694b37a4d00ed29abc4e0b253",
+  "f46a0e36c1ee887ad7e62fa00a8facefe90605827de7bf2e6f90655d6660ed0e",
+  "40edd2d21be802af95501cf3492665ee48423439cfc64c14f17ed1e7eb8bdfdf",
+  "08c15346f42360bd7a4b4e803ca88e5f1727d9db106e7dc4d96523ee7aba129a",
+  "0cc36b633ca1a18fa472ed8040a5b927b4c918318dbd17f6163b706cd7a8acbe",
+  "0fdc92828174abba815db3799a274aca70cccacca573d949e412d4622928ec50",
+  "33fc7d6bc49cea32bd737e46aaf63ad2bedbc72a52615fc2b881e6ddbb34587a",
+  "45c475337798bdbf5bd3a42c1f085278d1563a9e76c1295961b1ce66a89b4820",
+  "484df32ebf132fb121ab1e31b0e64345058c9c82b2a39498cc06d1794c270f23",
+  "60aa86ca3f2873908e57c2830675eec393c114cd711b3b162d02be355792b697",
+  "85c307d01e36dc62d4a341c1932b0a7fae3663f28ec0e32ad5cda30f35ffca86",
+  "9133d73c070243947b3bf9ffec78d21d66a5cb7488c11a4bf731b3c9c3529b3c",
+  "c082e903d9569b297c93a41ea561718a5258dfefd6a0f0457402f565caa1bbd0",
+  "c10bcbc952e58e8f89818c5119cde7b54bab5b74c5b194b5d26b2b125ec1036a",
+  "ed68d0fe3dca46c159402a1ae62148d2482352718be792ff65fd38efae706bef",
+  "8356eda7f3597c3d3726b32f87f6f4da87999be93760e738748138acc2a3d73e",
+  "90a8e3a67e41c33b93da824290148e4af84d3d49848727fa88b34d8df9bad29a",
+  "ec51cebd225fc861072b62e4ee0292fd4ba01ba0817770e7a379ad41d7bd850a",
+  "3edb378d29c89081c9ad6439b077aa928a21aed864aed5ef02e819b75ac33d7a",
+  "634f1d9ac6f632074054c5b029567303d783f1fc01e62be588668d20044fadcc",
+  "bc5c76a5b63fad600c94786300284987f54d237e3f7d38bb8b520906a9685ba2",
+  "efcbbf40f1e616e2e7ae513765463806b192bd5e6b8acd3be832bf590c14a542",
+  "2ef2688b31b86a4bbf358f3662495a65314b2edf2b7b2215d71e5be9cff90d22",
+  "a9cad5b77ae12cfa907a4e460d39be75c8f864a27e7f85394bef67120a6fba45",
+  "c35c76052f76cb45a970fcb825d5ddc49f7e371441f0953735ffb9d072da2680",
+  "611279d799db865e5329ed8723d73ebd2d839c273b52aef12803b4b11a75a75a",
+  "28840c700bdf8968b6f02c6bbb9cf965643f30f0911b2622a9c01dfae233d8fb",
+  "947f39141a3f830cd29145a74058d48c2feb8fbcd958ea7f90522e46fb0c25c5",
+  "c8535a73997daf1800394626d0e4845c923544040bae85a724ca427f56ba9812",
+  "9486e4ae754782114b1ec7d22baf661a8f33413d01fcf3a0759f97f1eedd84c1",
+  "8453f7d9d818b101d0d7b0cf5d0985e57174285f4cb7899517d5af52bc6490d5",
+  "9a877468512ffa14e77940757b3532c20f6fda7878419c9986f6d9e03ca31081",
+  "db310ca8f9841b5937f475ab042d768f84bc00a29282fbcce159fc9bf7646921",
+  "052217cbd533ef7214bb55f9e7a7d8cb979f0a4b32e42f8b98b57ebd86935d25",
+  "0aab08e34dd433fd38fa3f4d6729d1a7a2f626387fdb2b9bc8a48bd0f84be2f3",
+  "4bdbc2837b195c529d83302bd3c830d7d669879757ac3f92ec1d1ac703b21522",
+  "744c0d44e26b8a8fb7272b07eff884da583a8b73a50f7a1e4a9be55ecb40b39e",
+  "7b791a2ec4ff31bb6f19d60bc19152fb1ee5139b56254b9a3ba783a7f1bf9016",
+  "7e5a4a5f88ee48f17fe40e66772da4816480b1fba5fff5a58026d05753614393",
+  "c0b51e50d6117ce597c096386a1928f803e3abf1a65f6948ff7b00583651db5e",
+  "d1c8ea35ae9bdb5dad47c3ab80d73d5a327a0379216bead38eda18c0f2836fe9",
+  "e299dd585ed6c37292758d2821663aa46a80d6c7964f67b3d1d3279cf746e764",
+  "51a5608322e14694fafad15cbb710663800dc315d4deb12516c1591ac94e3ed7",
+  "78d553f98cc172dd6f0f3b2e01056813a32a894f6bdca64e665265df84a8eb0b",
+  "90c466fbe5bf7e6f3936b8a46407fbd5d0d542582c39b697ecbb5ada1be482ce",
+  "d2f539aa6340b1e41f6f47d179a2c17666415b82e7bf02be9416061855b5534c",
+  "05034e22b01b830b1fe12df4834e6c57eb0b152539e469d8d4e393b2b61dd76d",
+  "3268c3549d9634aefe29e399961a3be0ebb6e205d454609411ea877da4552d51",
+  "5c583058ae2d35e9a650a7a0d2ee304be8e71e361b51ea6903b2cd6ac14fd6a1",
+  "7c3cb1f7f449b6a459532d1dc315d574b7148f0d373f3e3271a52ad0151e0eb4",
+  "1163b51a64118363c90db5f0b8f7280fcea335631768f83e64fdf1948b41df89",
+  "a1590ecae718e7c43f356ddfc76c983f499725970a1953bf6d4d2d4ebf8fa1dc",
+  "2b69c26c0dacd5596906178138f85b2b14076552e1995817ea64bf99f48e0ed2",
+  "6e3e62f4d47d66cc55f659cf37b7c1ff4f9b43581b9470e740d60768217c1a23",
+  "60a3ef8eddf0f262fce40a32b715ee4c2e68d52e18f74d790e68a0f54c8657f1",
+  "dfd40e3c2c62a2810030e21a78f71f2646eab19b3658e326ecb5cd8def258aad",
+  "ee5572cfba7b96285c433ea2f6e469a205c783fba216af6cf4aafefdbf33ff89",
+  "85cd5f00c51efcc263b45fe91d1e10278a866d9266392e0ed480cd8ef5da6cc1",
+  "8ea5a65412bf4b95fdbb57fcce7c1a046848f161cf8235a3d9b7e752068775a8",
+  "974b143673aa6bd202205264d82f30898777e5694d4269449f564fd536f402d7",
+  "2317949f51d8a9d31b700c3af60b6fd3bccff1a8520af7707d7909f42bc5cff2",
+  "18426bc3bc8fdf0ab7577d92e31310faf3b83001f8e6e6fe5ef1a1043230e178",
+  "24cc918e7ffa54df7f6007989fe62b83af1035c9bf6071cac8c4f848e28b04ca",
+  "76757eae42daccc0d82c9630eab31041c6d6ea8fe4b4a47843574a6057dd2a4b",
+  "88db17beb9ce2b95b2ce2c1df753b96933024a464cc847770d3f05cd7de2872c",
+  "71fff34e9392692d58f3dc92ed65d070f0b476446e0a183a8fbad66d46f3a785",
+  "73e3ca429cb522b0877f0d6d46bedbaf270f94bc63bb87f4e0fc7c512bf36e9c",
+  "9a61f7432cf66be53d42b5d6f3c67ea71dd5efa1cc18d77d996f08ffea873373",
+  "fd2a8867de62f83c89ae11295cae5b5699360b5205f9726c2c47c064318bd7a4",
+  "364126473e089ed09a71e3f9eed80b1d602b35b4baa669b0a4f4be0519a787f8",
+  "cb14c0162e66ac565679089a566a725b26989db3536b7dba89bff77cb6010969",
+  "ebf490086ea45a7b342b3ec7408c9a82b22031daaefddf4425b6e6e931f6d6c8",
+  "3077e013297c7dd1e32eb2fa86e1ffa1de7d8740058652782bb8d391782eed71",
+  "7e0fa1bb73c8b6f1358cae19477304d85edfb7d4d9a7faf37c00e0578ed79edf",
+  "c5f4ddb5dcf5f40919bedce89870af99422c6f3c9d540ca1f7554a66eaa2f2a8",
+  "62b744c1cc00f54601579b164d198838395e6ed8e4bcff67fdf55e0e1d9a7d9e",
+  "b1d129c5648014b97e7e1a8577b21b17d35d0bf84494f8be7cc142d51eb1da49",
+  "d05dfe1f6405f9d04c0f0113dbd34decf59b75840fb1d916b4c51c8961211b5f",
+  "4377b06a6ee0e44ce4a8125a0eba8e4c512a249533221570ac426308ba282c50",
+  "9cb8284762a05b4b67f8eb4a06d981bf574b30b02c30d23639a92ddfdeb838fc",
+  "bc71bb9c93cb9a4aaba901537681cdb81a5f2a9fd1e6f740eb54bca25b7b878e",
+  "f502f374f1d25cb20448aeebe678caa17a3c9cd0c683aaf8073878dda72e5375",
+  "5fb839c42331b9298302c374334c358a73ec58bb5bb5a6942847f9e49c154b3c",
+  "1782bf44268490c9e5465aa890447f01b1bc88e426dd8968186c5c9a7493086e",
+  "4ab0925a44544c1a43e5abc007a0e5ec2bd60353ec67ce82f8a68f2623dccac0",
+  "0970a3732ee6a869b5f96494d8e3a69850989745a8841dd64b96aa5f9d6e54d4",
+  "86cf6c8c0aa44c47736ebc741c2cd7d88c2566d4612859e873eb330613c2d0f4",
+  "38f1aafe4d1c6e3ec450c252acc4a02d963bd95eb8412481a466e07739aad08f",
+  "a56905278b2d5c31b253f08b8d352401a261556b0c1a9ddc3a825c95bd1c24d9",
+  "cdd8f7d7311ebc5c741011f8243c8bf4d569e5dfdeb1bc42cc63150fc691c0b1",
+  "a34699ec6ee5319095c1f942b2dda529267024731c1226af527b5e965fcb263a",
+  "d4fd6b07139c50f1279603b4043c7d3416fb28e5f4905d57246945fcb4155e46",
+  "41d37520284fea44e97215c11840919c7397bdee02d99995efc6fdd345aeb490",
+  "e4e9348c9733f2dbc4a51e5104724df223ce1c28bcc1c9c0d8f3fdb8d0636a18",
+  "faf23127658c7be0c654ddb4f1e59cbda3b6332098f4609ffb595f1ff3779093",
+  "4fc6a944e4dbb60f73d2806f92f0e9ee9a289768b774d57488f3ff2ea8a648ee",
+  "50e4c09c91871cf93eeb39a175271ab881da332d867c9e021912188c6daaff36",
+  "6b03e518bed270d22ccab3e31eac9a38b65aadb5ab2a9b94a5728bc98866d170",
+  "6e6ac653f78181274643c0195fd45e54b84a30f1d8c04ed162cb0c8413f6fd14",
+  "9d457611a5446552e339d6538cb72cb486bfece828b9c84901632a7f91af6f2d",
+  "beb9c3973c476f03270474b947843ebfa75e42f146ffefa36d5a8a9c421c3d48",
+  "b95d8a09adfdb8e4682fb465679eb08d8a0df12a98569314d1b9160a458c5fd2",
+  "8097f5120fe05288255fb2c6958bac3fe0dc656d5a47edc1b6034d708a1a66ad",
+  "4a576f4c99aa6f3cc3e5a5f3b2683092f906d2630a477b4ed25012bd78375cbc",
+  "0b938de3209ef379552b2bb318b87db37b624fcd70c54ce4ad4a236ce78fda7c",
+  "254385f5e8b81984432049bcc0b242f30ef19ebeb390b0ff0b5ee40cb685ab0f",
+  "36f3ada91168a220adddffc5ce854ce6b247b2b31d93a24ebad503f5f23b084e",
+  "78febafce5d57f070c48186073dff66bd760b93cf4cd062eab6011d28d2fdb35",
+  "e48c3f064baf8200c415b4eef0c8f7392ba028183c90f5c9cf27c11a64320506",
+  "16c82c42a411ae43a20058e3f7b0275ee28c4dcc29dbf60200df3f22e9a822f6",
+  "96ae34198c7272f870b948c70bcd0c5b08c3c107b8725114e49f81643f2cee2d",
+  "85fbe0b7c94becea111ca74d8d78af02946ca6ed92d37dc2acdb6a79cbe382e3",
+  "7bd09f38fa6eb0f10784a92a93126625e394ae7b3049663e1eef8fd813b36084",
+  "1edcd3a11466e0e0096a6f10c8c659ac854bff1da932f954eaf88155bee2664a",
+  "7a2b2fd9d04867fe1d81d703be6101e331072dc88f741c079a1db3ceb5b909e2",
+  "c01a56bde96881b970b1d8adfa591439e32d2d9757cd04b2c0aff9397d3b43ee",
+  "d285be59fa627135074bd0458071ff04ff7a5a645de021b9f2bdf6ca1e6ccac5",
+  "e76d2d2a02da56896e19d271b4242d89bb5be3688a474d5cedd02645625a1691",
+  "5f1a47074e04cb0ccb6c1afb124f8151b6744553719249e9a71709ca72c1dcc0",
+  "d665d93a388b2bc7847a34dcbf59da872249153f5790c93e474fda78567f69b2",
+  "daf55d66744175670f34c009b740c5d01ceeee226c0deeb57c076715c6f91698",
+  "40d896ae39cbb7aa4c514405bb4b30a02ef7f8d72496707052f9b356d3b592e7",
+  "ae489d7e19436f99c8a32040ca60fcf5ab885d7106003d163cde9b902a91754b",
+  "f2595c418fe8544bb031e8917dbcc1eedfbd8547cee64ab7c08c6af132868d45",
+  "3813489721d4ee4d5f0a7fa478e4fa29380b02771604f6547341bc95aa6d4464",
+  "401141ae7b12c8dbba15393b30f63c5a6da344a54efe74346041935aa3503f73",
+  "631423417bc9400db86f6d09d5e7eb72e71e1682bf300bac38fbf3c9343f13da",
+  "8e85854d78e7f05651994dc5a428e6025b535a2da80df198dedb8ed11cb9a88a",
+  "116ae95ddcf5e02553da516314b800a167244402582694134b3cbba68892fe51",
+  "43461708227d807baa4aec3df043ee0e1a715aa7e771a13d710e01029a0d933d",
+  "780b713d6ac68ba978497095e528e351e9963589937d22dbda5d21c8660cb1a4",
+  "41d3eac7f116ec22535d830149979fe0a8dbf44625dd841bc9785cbd7c5ddc95",
+  "80e11549ad3700d1e7345447aff1b3858e532e9347594ee4f028566c8c7b8a6a",
+  "1ffbfa48a76d39f78db66f4ea250c451ae335c31d7e45d0fdc4d99bc714bae33",
+  "19a5aa359e740fa18d7cc19f0b11243bc53d8d016545bce35837deac7fe2ef7e",
+  "f1c7beac6a619520d744fd984bc16b322f3d545b9d8490801aee628dabd94aff",
+  "14d919d01637aa6b5acc92804dbb4ab56cecc88281aedd5cb7b5dcf8f7da958e",
+  "a8decf7b78e2b2c833b0808c3e108322cfb895fadaec159467973a681028d92a"
+]);
+
+// src/lifecycle/paths.ts
+import { lstat, realpath } from "fs/promises";
+import path3 from "path";
+function resolveContained(root, rel) {
+  const rootAbs = path3.resolve(root);
+  const candidate = path3.resolve(rootAbs, rel);
+  if (escapesRoot(rootAbs, candidate)) {
+    throw new Error(`Path escapes registry/project root: ${rel}`);
+  }
+  return candidate;
+}
+function escapesRoot(rootAbs, candidate) {
+  const relToRoot = path3.relative(rootAbs, candidate);
+  return relToRoot === ".." || relToRoot.startsWith(`..${path3.sep}`) || path3.isAbsolute(relToRoot);
+}
+async function assertRealContained(root, abs) {
+  const stat2 = await lstat(abs);
+  if (stat2.isSymbolicLink()) {
+    throw new Error(`Refusing to follow symlink: ${abs}`);
+  }
+  const [rootReal, absReal] = await Promise.all([realpath(root), realpath(abs)]);
+  if (escapesRoot(rootReal, absReal)) {
+    throw new Error(`Path resolves outside root via symlink: ${abs}`);
+  }
+}
+async function assertRealParentContained(root, abs) {
+  let dir = path3.dirname(abs);
+  for (; ; ) {
+    try {
+      await lstat(dir);
+      break;
+    } catch {
+      const parent = path3.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  const [rootReal, dirReal] = await Promise.all([realpath(root), realpath(dir)]);
+  if (escapesRoot(rootReal, dirReal)) {
+    throw new Error(`Parent directory resolves outside root via symlink: ${abs}`);
+  }
+}
+async function isRealWriteTargetContained(root, abs) {
+  try {
+    let exists = true;
+    try {
+      await lstat(abs);
+    } catch {
+      exists = false;
+    }
+    if (exists) await assertRealContained(root, abs);
+    else await assertRealParentContained(root, abs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toPosixRel(root, absPath) {
+  return path3.relative(root, absPath).split(path3.sep).join("/");
+}
+
+// src/lifecycle/overlay.ts
+var MANAGED_HASHES_REL = ".cursor/agent-kit.managed-hashes.json";
+var CONSUMER_OVERLAY_PREFIXES = [
+  ".cursor/agents/",
+  ".cursor/skills/",
+  ".cursor/commands/",
+  ".claude/commands/",
+  ".cursor/hooks/",
+  ".cursor/scripts/"
+];
+function isConsumerOverlayPath(relPath) {
+  const norm = relPath.split(path4.sep).join("/");
+  return CONSUMER_OVERLAY_PREFIXES.some((p) => norm.startsWith(p));
+}
+function contentHash(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function loadManagedHashLedger(projectRoot) {
+  const abs = resolveContained(projectRoot, MANAGED_HASHES_REL);
+  try {
+    const raw = await readFile(abs, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.hashes && typeof parsed.hashes === "object") {
+      return { schemaVersion: 1, hashes: { ...parsed.hashes } };
+    }
+  } catch {
+  }
+  return { schemaVersion: 1, hashes: {} };
+}
+async function saveManagedHashLedger(projectRoot, ledger) {
+  const abs = resolveContained(projectRoot, MANAGED_HASHES_REL);
+  await mkdir(path4.dirname(abs), { recursive: true });
+  const payload = {
+    schemaVersion: 1,
+    hashes: { ...ledger.hashes }
+  };
+  await writeFile(abs, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+function shouldPreserveCustomizedOverlay(localContent, recordedHash, knownShippedHashes = KNOWN_SHIPPED_OVERLAY_HASHES) {
+  const localHash = contentHash(localContent);
+  if (!recordedHash) {
+    return !knownShippedHashes.has(localHash);
+  }
+  return localHash !== recordedHash;
+}
+async function seedManagedHashLedger(projectRoot) {
+  const ledger = await loadManagedHashLedger(projectRoot);
+  for (const prefix of CONSUMER_OVERLAY_PREFIXES) {
+    const prefixPath = resolveContained(projectRoot, prefix);
+    let entries;
+    try {
+      entries = await readdir(prefixPath, { withFileTypes: true, recursive: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const parentPath = String(entry.parentPath);
+      const name = String(entry.name);
+      const rel = path4.relative(projectRoot, path4.join(parentPath, name));
+      const norm = rel.split(path4.sep).join("/");
+      if (ledger.hashes[norm]) continue;
+      try {
+        const content = await readFile(path4.join(parentPath, name), "utf8");
+        ledger.hashes[norm] = contentHash(content);
+      } catch {
+      }
+    }
+  }
+  await saveManagedHashLedger(projectRoot, ledger);
+  return ledger;
+}
+
+// src/lifecycle/apply.ts
+import { copyFile, lstat as lstat2, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import path5 from "path";
+function emptyStats() {
+  return {
+    written: [],
+    removed: [],
+    collisions: [],
+    skippedProtected: [],
+    missing: [],
+    unchanged: [],
+    preservedCustomized: [],
+    skippedSymlink: []
+  };
+}
+function mergeStats(into, from) {
+  into.written.push(...from.written);
+  into.removed.push(...from.removed);
+  into.collisions.push(...from.collisions);
+  into.skippedProtected.push(...from.skippedProtected);
+  into.missing.push(...from.missing);
+  into.unchanged.push(...from.unchanged);
+  into.preservedCustomized.push(...from.preservedCustomized);
+  into.skippedSymlink.push(...from.skippedSymlink);
+  return into;
+}
+async function copyRegistryFile(registryRoot, projectRoot, sourceRel, targetRel, protectedGlobs, options = {}) {
+  const targetNorm = targetRel.split(path5.sep).join("/");
+  if (isProtectedPath(targetNorm, protectedGlobs)) {
+    return "skipped-protected";
+  }
+  const sourceAbs = resolveContained(registryRoot, sourceRel);
+  const targetAbs = resolveContained(projectRoot, targetRel);
+  for (const [root, abs] of [
+    [registryRoot, sourceAbs],
+    [projectRoot, targetAbs]
+  ]) {
+    const contained = await pathExists(abs) ? await isRealContained(root, abs) : await isRealParentContained(root, abs);
+    if (!contained) return "skipped-symlink";
+  }
+  try {
+    await readFile2(sourceAbs);
+  } catch {
+    return "missing-source";
+  }
+  let existing = null;
+  try {
+    existing = await readFile2(targetAbs, "utf8");
+  } catch {
+    existing = null;
+  }
+  const next = await readFile2(sourceAbs, "utf8");
+  if (existing === next) {
+    if (isConsumerOverlayPath(targetNorm)) {
+      await touchOverlayHash(projectRoot, targetNorm, next, options);
+    }
+    return "unchanged";
+  }
+  if (existing !== null && isConsumerOverlayPath(targetNorm)) {
+    const ledger = options.managedHashes ?? await loadManagedHashLedger(projectRoot);
+    const recorded = ledger.hashes[targetNorm];
+    if (shouldPreserveCustomizedOverlay(existing, recorded)) {
+      if (!recorded) {
+        const managedHash = contentHash(next);
+        ledger.hashes[targetNorm] = managedHash;
+        if (options.managedHashes) {
+          options.managedHashes.hashes[targetNorm] = managedHash;
+        }
+        if (options.persistManagedHashes !== false) {
+          await saveManagedHashLedger(projectRoot, ledger);
+        }
+      }
+      return "preserved-customized";
+    }
+    await mkdir2(path5.dirname(targetAbs), { recursive: true });
+    await copyFile(sourceAbs, targetAbs);
+    ledger.hashes[targetNorm] = contentHash(next);
+    if (options.managedHashes) {
+      options.managedHashes.hashes[targetNorm] = ledger.hashes[targetNorm];
+    }
+    if (options.persistManagedHashes !== false) {
+      await saveManagedHashLedger(projectRoot, ledger);
+    }
+    return "written";
+  }
+  await mkdir2(path5.dirname(targetAbs), { recursive: true });
+  await copyFile(sourceAbs, targetAbs);
+  if (isConsumerOverlayPath(targetNorm)) {
+    await touchOverlayHash(projectRoot, targetNorm, next, options);
+  }
+  return "written";
+}
+async function isRealContained(root, abs) {
+  try {
+    await assertRealContained(root, abs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isRealParentContained(root, abs) {
+  try {
+    await assertRealParentContained(root, abs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathExists(abs) {
+  try {
+    await lstat2(abs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function touchOverlayHash(projectRoot, targetNorm, content, options) {
+  const ledger = options.managedHashes ?? await loadManagedHashLedger(projectRoot);
+  const hash = contentHash(content);
+  if (ledger.hashes[targetNorm] === hash) return;
+  ledger.hashes[targetNorm] = hash;
+  if (options.managedHashes) {
+    options.managedHashes.hashes[targetNorm] = hash;
+  }
+  if (options.persistManagedHashes !== false) {
+    await saveManagedHashLedger(projectRoot, ledger);
+  }
+}
+function recordOutcome(stats, targetRel, outcome) {
+  const rel = targetRel.split(path5.sep).join("/");
+  switch (outcome) {
+    case "written":
+      stats.written.push(rel);
+      break;
+    case "skipped-protected":
+      stats.skippedProtected.push(rel);
+      break;
+    case "missing-source":
+      stats.missing.push(rel);
+      break;
+    case "unchanged":
+      stats.unchanged.push(rel);
+      break;
+    case "preserved-customized":
+      stats.preservedCustomized.push(rel);
+      break;
+    case "skipped-symlink":
+      stats.skippedSymlink.push(rel);
+      break;
+  }
+}
+async function saveManifest(projectRoot, manifest) {
+  const target = path5.join(projectRoot, MANIFEST_RELATIVE_PATH);
+  const { unknownFields, ...known } = manifest;
+  const payload = {
+    ...known,
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    // Preserve installedAt on no-op updates (ADR factory-pseudo-consumer
+    // decision 4); a version change earns a fresh install timestamp.
+    installedAt: manifest.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  for (const [key, value] of Object.entries(unknownFields ?? {})) {
+    if (!(key in payload)) payload[key] = value;
+  }
+  await writeJson(target, payload);
+  return toPosixRel(projectRoot, target);
+}
+function buildManifest(input) {
+  const manifest = {
+    schemaVersion: 1,
+    version: input.version,
+    protected: normalizeProtectedGlobs(input.protected ?? [...DEFAULT_PROTECTED_PATHS])
+  };
+  if (input.profile) manifest.profile = input.profile;
+  if (input.packs?.length) manifest.packs = [...new Set(input.packs)].sort();
+  if (input.skills?.length) manifest.skills = [...new Set(input.skills)].sort();
+  if (input.personalization) manifest.personalization = input.personalization;
+  if (input.registryUrl || input.registryRef) {
+    manifest.registry = {};
+    if (input.registryUrl) manifest.registry.url = input.registryUrl;
+    if (input.registryRef) manifest.registry.ref = input.registryRef;
+  }
+  return manifest;
+}
+function upsertIdList(list, id) {
+  return [.../* @__PURE__ */ new Set([...list ?? [], id])].sort();
+}
+
+// src/registry/install.ts
+import { readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import path6 from "path";
+function skillTargetDir(skillPath, skillId) {
+  const category = skillPath.includes("/core/") ? "core" : "community";
+  return path6.posix.join(".cursor", "skills", category, skillId);
+}
+async function skillFileTargets(registryRoot, skillPath, skillId) {
+  const targetDir = skillTargetDir(skillPath, skillId);
+  const pair = (rel) => ({
+    sourceRel: path6.posix.join(skillPath, rel),
+    targetRel: path6.posix.join(targetDir, rel)
+  });
+  let companions = [];
+  try {
+    const dirAbs = resolveContained(registryRoot, skillPath);
+    const entries = await readdir2(dirAbs, { withFileTypes: true, recursive: true });
+    companions = entries.filter((entry) => entry.isFile()).map((entry) => {
+      const parent = path6.relative(dirAbs, entry.parentPath ?? dirAbs);
+      return path6.join(parent, entry.name).split(path6.sep).join("/");
+    }).filter((rel) => rel !== "SKILL.md" && !rel.split("/").some((seg) => seg.startsWith("."))).sort();
+  } catch {
+    companions = [];
+  }
+  return [pair("SKILL.md"), ...companions.map(pair)];
+}
+function targetForMember(member) {
+  switch (member.kind) {
+    case "skill":
+      return {
+        sourceRel: path6.posix.join(member.source, "SKILL.md"),
+        targetRel: path6.posix.join(skillTargetDir(member.source, member.id), "SKILL.md")
+      };
+    case "rule":
+      return {
+        sourceRel: member.source,
+        targetRel: path6.posix.join(".cursor", "rules", path6.posix.basename(member.source))
+      };
+    case "agent":
+      return {
+        sourceRel: member.source,
+        targetRel: path6.posix.join(".cursor", "agents", path6.posix.basename(member.source))
+      };
+    case "command":
+      return {
+        sourceRel: member.source,
+        targetRel: path6.posix.join(".cursor", "commands", path6.posix.basename(member.source))
+      };
+    case "hook": {
+      const targetRel = member.source.startsWith(".cursor/") ? member.source : path6.posix.join(".cursor", "hooks", path6.posix.basename(member.source));
+      return { sourceRel: member.source, targetRel };
+    }
+    case "template": {
+      const base = path6.posix.basename(member.source);
+      if (member.source.includes("/context-management/") || member.source.includes("/engineering-architecture/")) {
+        return {
+          sourceRel: member.source,
+          targetRel: path6.posix.join(".cursor", "context", "templates", base)
+        };
+      }
+      return {
+        sourceRel: member.source,
+        targetRel: path6.posix.join("templates", base)
+      };
+    }
+    default: {
+      const _exhaustive = member.kind;
+      throw new Error(`Unsupported pack member kind: ${_exhaustive}`);
+    }
+  }
+}
+async function installSkill(registryRoot, projectRoot, skill, options = {}) {
+  const stats = emptyStats();
+  const managedHashes = options.managedHashes ?? await loadManagedHashLedger(projectRoot);
+  for (const { sourceRel, targetRel } of await skillFileTargets(
+    registryRoot,
+    skill.path,
+    skill.id
+  )) {
+    const outcome = await copyRegistryFile(
+      registryRoot,
+      projectRoot,
+      sourceRel,
+      targetRel,
+      options.protectedGlobs ?? [],
+      { managedHashes, persistManagedHashes: false }
+    );
+    recordOutcome(stats, targetRel, outcome);
+  }
+  if (!options.managedHashes) await saveManagedHashLedger(projectRoot, managedHashes);
+  return stats;
+}
+async function installSkillsByIds(registryRoot, projectRoot, skillIds, options = {}) {
+  const index = await readJson(path6.join(registryRoot, REGISTRY_INDEX_REL));
+  const stats = emptyStats();
+  if (!index) return stats;
+  const pool = allSkills(index);
+  const managedHashes = options.managedHashes ?? await loadManagedHashLedger(projectRoot);
+  const skillOpts = { ...options, managedHashes };
+  try {
+    for (const id of skillIds) {
+      const skill = pool.find((s) => s.id === id);
+      if (!skill) {
+        stats.missing.push(id);
+        continue;
+      }
+      mergeStats(stats, await installSkill(registryRoot, projectRoot, skill, skillOpts));
+    }
+  } finally {
+    if (!options.managedHashes) await saveManagedHashLedger(projectRoot, managedHashes);
+  }
+  return stats;
+}
+async function loadPackManifest(registryRoot, packId) {
+  const summary = await findPack(registryRoot, packId);
+  const manifestPath = resolveContained(registryRoot, path6.join(summary.path, "pack.json"));
+  const manifest = await readJson(manifestPath);
+  if (!manifest) throw new Error(`Pack manifest not found at ${manifestPath}`);
+  return manifest;
+}
+async function installPack(registryRoot, projectRoot, packId, options = {}) {
+  await loadRegistry(registryRoot);
+  const packManifest = await loadPackManifest(registryRoot, packId);
+  const stats = emptyStats();
+  const protectedGlobs = options.protectedGlobs ?? [];
+  const managedHashes = options.managedHashes ?? await loadManagedHashLedger(projectRoot);
+  const copyOpts = { managedHashes, persistManagedHashes: false };
+  for (const member of packManifest.members) {
+    for (const { sourceRel, targetRel } of await packMemberFileTargets(registryRoot, member)) {
+      const outcome = await copyRegistryFile(
+        registryRoot,
+        projectRoot,
+        sourceRel,
+        targetRel,
+        protectedGlobs,
+        copyOpts
+      );
+      recordOutcome(stats, targetRel, outcome);
+    }
+  }
+  if (!options.managedHashes) await saveManagedHashLedger(projectRoot, managedHashes);
+  return stats;
+}
+async function packMemberFileTargets(registryRoot, member) {
+  return member.kind === "skill" ? skillFileTargets(registryRoot, member.source, member.id) : [targetForMember(member)];
+}
+
+// src/registry/resolve.ts
+import { execFile } from "child_process";
+import { createHash as createHash2, randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile as readFile4, rename, rm, stat, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import path7 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var LOCK_TIMEOUT_MS = 6e4;
+var LOCK_RETRY_MS = 200;
+var LOCK_STALE_MS = 5 * 6e4;
+var LOCK_REFRESH_MS = 1e4;
+function lockOwnerPath(lockDir) {
+  return path7.join(lockDir, "owner.json");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readLockOwner(lockDir) {
+  try {
+    const raw = await readFile4(lockOwnerPath(lockDir), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid === "number" && typeof parsed.uuid === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+async function writeLockOwner(lockDir, owner) {
+  const finalPath = lockOwnerPath(lockDir);
+  const tmpPath = path7.join(lockDir, `owner.${owner.uuid}.${randomUUID()}.tmp`);
+  await writeFile2(tmpPath, JSON.stringify(owner), "utf8");
+  await rename(tmpPath, finalPath);
+}
+async function refreshLockOwner(lockDir, uuid) {
+  const owner = await readLockOwner(lockDir);
+  if (owner && owner.uuid !== uuid) return;
+  await writeLockOwner(lockDir, { pid: process.pid, uuid, updatedAt: Date.now() });
+}
+async function releaseCacheLock(lockDir, uuid) {
+  const claimPath = path7.join(lockDir, `releasing.${uuid}`);
+  try {
+    await rename(lockOwnerPath(lockDir), claimPath);
+  } catch {
+    return;
+  }
+  let claimed = null;
+  try {
+    const raw = await readFile4(claimPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid === "number" && typeof parsed.uuid === "string") {
+      claimed = parsed;
+    }
+  } catch {
+  }
+  if (!claimed || claimed.uuid !== uuid) {
+    try {
+      await rename(claimPath, lockOwnerPath(lockDir));
+    } catch {
+    }
+    return;
+  }
+  try {
+    await rm(lockDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+async function tryReclaimStaleLock(lockDir) {
+  let owner;
+  let lockStat;
+  try {
+    lockStat = await stat(lockDir);
+    owner = await readLockOwner(lockDir);
+  } catch {
+    return false;
+  }
+  const now = Date.now();
+  if (owner) {
+    const ownerFresh = now - owner.updatedAt < LOCK_STALE_MS;
+    if (isProcessAlive(owner.pid) && ownerFresh) {
+      return false;
+    }
+  }
+  if (now - lockStat.mtimeMs > LOCK_STALE_MS) {
+    try {
+      await rm(lockDir, { recursive: true, force: true });
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function acquireCacheLock(cacheDir) {
+  const lockDir = `${cacheDir}.lock`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  const uuid = randomUUID();
+  const owner = { pid: process.pid, uuid, updatedAt: Date.now() };
+  await mkdir3(path7.dirname(lockDir), { recursive: true });
+  let lastErrorCode;
+  while (Date.now() < deadline) {
+    try {
+      await mkdir3(lockDir, { recursive: false });
+      await writeLockOwner(lockDir, owner);
+      let refreshing = false;
+      const refreshInterval = setInterval(() => {
+        if (refreshing) return;
+        refreshing = true;
+        refreshLockOwner(lockDir, uuid).catch(() => {
+        }).finally(() => {
+          refreshing = false;
+        });
+      }, LOCK_REFRESH_MS);
+      return async () => {
+        clearInterval(refreshInterval);
+        await releaseCacheLock(lockDir, uuid);
+      };
+    } catch (err) {
+      const code = err.code;
+      lastErrorCode = code;
+      if (code === "EEXIST") {
+        if (await tryReclaimStaleLock(lockDir)) {
+          continue;
+        }
+        await new Promise((r) => setTimeout(r, LOCK_RETRY_MS + Math.random() * 100));
+        continue;
+      }
+      if (code === "ENOENT") {
+        await mkdir3(path7.dirname(lockDir), { recursive: true });
+        await new Promise((r) => setTimeout(r, LOCK_RETRY_MS + Math.random() * 100));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(
+    lastErrorCode === "ENOENT" ? `Timed out acquiring cache lock on ${cacheDir}: the lock parent directory kept vanishing (concurrent cache clear?).` : `Timed out waiting for cache lock on ${cacheDir}. Another install may be stuck.`
+  );
+}
+var DEFAULT_REGISTRY_URL = "https://github.com/agent-kit-startup/agent-kit";
+var DEFAULT_REGISTRY_REF = "main";
+var SAFE_URL = /^https:\/\/[^\s]+$/;
+var SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+function assertSafeRegistrySource(url, ref) {
+  if (!SAFE_URL.test(url)) {
+    throw new Error(
+      `Refusing registry url "${url}": only https:// URLs are allowed. Use --registry <local-path> for local checkouts.`
+    );
+  }
+  if (!SAFE_REF.test(ref)) {
+    throw new Error(`Refusing registry ref "${ref}": invalid characters or leading "-".`);
+  }
+}
+function gitEnv() {
+  return { ...process.env, GIT_ALLOW_PROTOCOL: "https" };
+}
+function cacheKey(url, ref) {
+  return createHash2("sha256").update(`${url}@${ref}`).digest("hex").slice(0, 16);
+}
+async function hasRegistryIndex(root) {
+  return fileExists(path7.join(root, REGISTRY_INDEX_REL));
+}
+async function cloneRegistry(url, ref, dest) {
+  const { mkdir: mkdir4, rm: rm2 } = await import("fs/promises");
+  await mkdir4(path7.dirname(dest), { recursive: true });
+  const clearPartial = () => rm2(dest, { recursive: true, force: true });
+  await clearPartial();
+  try {
+    await execFileAsync("git", ["clone", "--depth", "1", "--branch", ref, "--", url, dest], {
+      env: gitEnv()
+    });
+  } catch (firstErr) {
+    try {
+      await clearPartial();
+      await execFileAsync("git", ["clone", "--depth", "1", "--", url, dest], { env: gitEnv() });
+      await execFileAsync("git", ["checkout", ref, "--"], { cwd: dest, env: gitEnv() });
+    } catch (secondErr) {
+      const msg = secondErr instanceof Error ? secondErr.message : String(secondErr);
+      if (/403|Authentication|could not read Username/i.test(msg)) {
+        throw new Error(
+          `Registry clone failed (auth/access): ${url}@${ref}. Check git credentials or use --registry <local-path> for a local checkout.`
+        );
+      }
+      if (/Could not resolve host|Network is unreachable|Connection refused/i.test(msg)) {
+        throw new Error(
+          `Registry clone failed (network): ${url}@${ref}. Check network/proxy settings or use --registry <local-path>.`
+        );
+      }
+      throw new Error(
+        `Registry clone failed: ${url}@${ref}. ${msg}. Use --registry <local-path> if you have a local checkout.`
+      );
+    }
+  }
+}
+async function refreshCache(cacheDir, ref) {
+  try {
+    await execFileAsync("git", ["fetch", "--depth", "1", "origin", ref], {
+      cwd: cacheDir,
+      env: gitEnv()
+    });
+    await execFileAsync("git", ["reset", "--hard", "FETCH_HEAD"], {
+      cwd: cacheDir,
+      env: gitEnv()
+    });
+  } catch {
+  }
+}
+async function resolveRegistryRoot(options) {
+  if (options.registryPath) {
+    const root = path7.resolve(options.registryPath);
+    if (!await hasRegistryIndex(root)) {
+      throw new Error(`No ${REGISTRY_INDEX_REL} under --registry ${root}`);
+    }
+    return { root, source: "flag" };
+  }
+  const envPath = process.env.AGENT_KIT_REGISTRY;
+  if (envPath) {
+    const root = path7.resolve(envPath);
+    if (!await hasRegistryIndex(root)) {
+      throw new Error(`No ${REGISTRY_INDEX_REL} under AGENT_KIT_REGISTRY=${root}`);
+    }
+    return { root, source: "env", url: options.registryUrl, ref: options.registryRef };
+  }
+  if (await hasRegistryIndex(options.cwd)) {
+    return {
+      root: path7.resolve(options.cwd),
+      source: "cwd",
+      url: options.registryUrl,
+      ref: options.registryRef
+    };
+  }
+  const url = options.registryUrl ?? DEFAULT_REGISTRY_URL;
+  const ref = options.registryRef ?? DEFAULT_REGISTRY_REF;
+  assertSafeRegistrySource(url, ref);
+  const dest = path7.join(homedir(), ".cache", "agent-kit", "registry", cacheKey(url, ref));
+  const unlock = await acquireCacheLock(dest);
+  let ownershipTransferred = false;
+  try {
+    if (await hasRegistryIndex(dest)) {
+      await refreshCache(dest, ref);
+    } else {
+      await cloneRegistry(url, ref, dest);
+      if (!await hasRegistryIndex(dest)) {
+        throw new Error(`Cloned ${url}@${ref} but ${REGISTRY_INDEX_REL} is missing`);
+      }
+    }
+    ownershipTransferred = true;
+    return { root: dest, source: "remote-cache", url, ref, unlock };
+  } finally {
+    if (!ownershipTransferred) {
+      await unlock();
+    }
+  }
+}
+
+export {
+  MANIFEST_RELATIVE_PATH,
+  DOMAIN_PACK_IDS,
+  loadAgentKitManifest,
+  DEFAULT_REGISTRY_URL,
+  DEFAULT_REGISTRY_REF,
+  assertSafeRegistrySource,
+  resolveRegistryRoot,
+  resolveContained,
+  assertRealContained,
+  assertRealParentContained,
+  isRealWriteTargetContained,
+  normalizeRelPath,
+  resolveProtectedGlobs,
+  isProtectedPath,
+  loadRegistry,
+  allSkills,
+  allPacks,
+  findSkill,
+  findPack,
+  contentHash,
+  loadManagedHashLedger,
+  saveManagedHashLedger,
+  shouldPreserveCustomizedOverlay,
+  seedManagedHashLedger,
+  emptyStats,
+  mergeStats,
+  copyRegistryFile,
+  recordOutcome,
+  saveManifest,
+  buildManifest,
+  upsertIdList,
+  skillTargetDir,
+  skillFileTargets,
+  installSkill,
+  installSkillsByIds,
+  loadPackManifest,
+  installPack,
+  packMemberFileTargets
+};