@arp-protocol/cli 0.0.3 → 0.0.4

package/dist/chunks/check-k4qnc9ee.js

@@ -0,0 +1,2011 @@
+#!/usr/bin/env node
+import {
+  KEY_NAME,
+  NEEDS_LABEL,
+  PROGRAM_NAME,
+  WITH_LABEL,
+  needKindOf,
+  needKindOfReason
+} from "./cli-kda5hz4w.js";
+import {
+  "13579_default" as _13579_default
+} from "./cli-7c393v47.js";
+import {
+  DEFAULT_TIMEOUT_MS,
+  PULSE_ATOMS_QUERY,
+  PULSE_QUALIFIERS_QUERY,
+  PULSE_USES_QUERY,
+  createGraphqlTransport,
+  defaultFetch,
+  isRecord,
+  readRecord,
+  readString
+} from "./cli-zehr6kdx.js";
+import"./cli-g5zvr10v.js";
+
+// src/check.ts
+import { createHash } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+
+// ../../packages/protocol/src/content-path.ts
+function directoryOf(path) {
+  const parts = path.split("/");
+  return parts.length < 2 ? "" : parts[parts.length - 2] ?? "";
+}
+function skillFilesIn(listing) {
+  return listing.filter((file) => (file.path.split("/").pop() ?? "").toLowerCase() === "skill.md");
+}
+
+// ../../packages/protocol/src/declare/thing-cid.ts
+function thingDocument(thing) {
+  return JSON.stringify({
+    "@context": "https://schema.org",
+    "@type": "Thing",
+    description: thing.description,
+    image: thing.image,
+    name: thing.name,
+    url: thing.url
+  });
+}
+function base32(bytes) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+  let bits = 0;
+  let value = 0;
+  let out = "";
+  for (const byte of bytes) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      out += alphabet[value >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0)
+    out += alphabet[value << 5 - bits & 31];
+  return out;
+}
+function thingUriOfDigest(digest) {
+  const cid = new Uint8Array(4 + digest.length);
+  cid.set([1, 85, 18, 32]);
+  cid.set(digest, 4);
+  return `ipfs://b${base32(cid)}`;
+}
+
+// ../../packages/protocol/src/declare/tool-thing.ts
+class InvalidToolUrlError extends Error {
+  input;
+  constructor(input, why) {
+    super(`${JSON.stringify(input)} is not a usable tool URL: ${why}`);
+    this.name = "InvalidToolUrlError";
+    this.input = input;
+  }
+}
+var TOOL_THING_DESCRIPTION = "A tool identified by its URL, so every declaration of its use lands on one atom.";
+function normaliseToolUrl(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0)
+    throw new InvalidToolUrlError(input, "empty");
+  const withScheme = /^[a-z][a-z0-9+.-]*:/i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  let url;
+  try {
+    url = new URL(withScheme);
+  } catch {
+    throw new InvalidToolUrlError(input, "not parseable as a URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new InvalidToolUrlError(input, `scheme ${url.protocol} is not http or https`);
+  }
+  if (url.hostname.length === 0)
+    throw new InvalidToolUrlError(input, "no host");
+  const host = url.hostname.replace(/\.+$/, "").replace(/^(?:www\.)+/, "");
+  const path = url.pathname.replace(/(?:\.git|\/)+$/, "");
+  const params = [...new URLSearchParams(url.search).entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  const query = params.length === 0 ? "" : `?${new URLSearchParams(params).toString()}`;
+  const port = url.port === "" || url.port === "80" || url.port === "443" ? "" : `:${url.port}`;
+  return `https://${host}${port}${path}${query}`;
+}
+function toolThing(url) {
+  const normalised = normaliseToolUrl(url);
+  return {
+    name: normalised.slice("https://".length),
+    description: TOOL_THING_DESCRIPTION,
+    image: "",
+    url: normalised
+  };
+}
+
+// ../../packages/protocol/src/declare/usage-words.ts
+var USAGE_OUTCOMES = ["worked", "failed"];
+var HAS_OUTCOME_LABEL = "has outcome";
+var USAGE_REASONS = ["missing-key", "missing-program", "missing-file", "not-the-right-tool", "no-delivery"];
+var BECAUSE_LABEL = "because";
+
+// ../../packages/protocol/src/sources/intuition/terms.ts
+var USES = "0x5c0bde1cc696456c0268248c4656acdf9621fdb39e605bc99b0a83dc8ff6e800";
+
+// ../../packages/protocol/src/pulse-usage.ts
+var DEFAULT_LIMIT = 250;
+var rowsOf = (data) => Array.isArray(data["triples"]) ? data["triples"].filter(isRecord) : [];
+async function findToolAtoms(uris, config) {
+  const out = new Map;
+  if (uris.length === 0)
+    return out;
+  const transport = config.transport ?? createGraphqlTransport({
+    url: config.graphqlUrl,
+    fetch: config.fetch ?? defaultFetch(),
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
+  const data = await transport.request(PULSE_ATOMS_QUERY, { uris: [...uris], limit: uris.length });
+  const rows = Array.isArray(data["atoms"]) ? data["atoms"].filter(isRecord) : [];
+  for (const row of rows) {
+    const id = readString(row, "term_id");
+    const uri = readString(row, "data");
+    if (id !== null && uri !== null)
+      out.set(uri, id);
+  }
+  return out;
+}
+async function getPulseUsage(toolAtomIds, config) {
+  const transport = config.transport ?? createGraphqlTransport({
+    url: config.graphqlUrl,
+    fetch: config.fetch ?? defaultFetch(),
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
+  const limit = Math.min(config.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
+  const key = (id) => id.toLowerCase();
+  const empty = () => ({
+    declarations: [],
+    agents: 0,
+    wallets: 0,
+    byDomain: {},
+    byOutcome: {},
+    byReason: {},
+    byNeed: {},
+    byWith: {},
+    byOthers: [],
+    truncated: false
+  });
+  const out = new Map(toolAtomIds.map((id) => [key(id), empty()]));
+  if (toolAtomIds.length === 0)
+    return out;
+  const edgeRows = rowsOf(await transport.request(PULSE_USES_QUERY, { tools: [...toolAtomIds], uses: USES, limit }));
+  const edges = new Map;
+  const NESTED_CAP = 100;
+  let truncated = edgeRows.length >= limit;
+  for (const row of edgeRows) {
+    const tripleId = readString(row, "term_id");
+    const tool = readString(row, "object_id");
+    const writer = readString(row, "creator_id");
+    const subject = readRecord(row, "subject");
+    const atomId = subject === null ? null : readString(subject, "term_id");
+    if (tripleId === null || tool === null || writer === null || subject === null || atomId === null)
+      continue;
+    const edgeHolders = (Array.isArray(row["positions"]) ? row["positions"].filter(isRecord) : []).map((holder) => readString(holder, "account_id")).filter((account) => account !== null);
+    const declaration = (wallet, declaredAt) => ({
+      tripleId,
+      agent: { atomId, label: readString(subject, "label") },
+      writer: wallet,
+      holders: edgeHolders,
+      declaredAt,
+      domains: [],
+      outcomes: [],
+      lines: []
+    });
+    const declarers = new Map([[key(writer), declaration(writer, readString(row, "created_at"))]]);
+    const holders = Array.isArray(row["positions"]) ? row["positions"].filter(isRecord) : [];
+    if (holders.length >= NESTED_CAP)
+      truncated = true;
+    for (const holder of holders) {
+      const wallet = readString(holder, "account_id");
+      if (wallet !== null && !declarers.has(key(wallet)))
+        declarers.set(key(wallet), declaration(wallet, null));
+    }
+    edges.set(key(tripleId), { tool: key(tool), declarers });
+  }
+  const payers = new Set(config.payers.map(key));
+  const writers = [...new Set([...edges.values()].flatMap((edge) => [...edge.declarers.values()].map((row) => row.writer)))];
+  const qualifiers = async (subjects, predicates) => subjects.length === 0 ? [] : rowsOf(await transport.request(PULSE_QUALIFIERS_QUERY, { edges: subjects, predicates, writers, limit }));
+  const pass = (rows) => {
+    truncated = truncated || rows.length >= limit;
+    return rows;
+  };
+  const standing = (row, edge, below) => {
+    const holders = Array.isArray(row["positions"]) ? row["positions"].filter(isRecord) : [];
+    if (holders.length >= NESTED_CAP)
+      truncated = true;
+    const wallets = [readString(row, "creator_id"), ...holders.map((holder) => readString(holder, "account_id"))];
+    return new Set(wallets.filter((wallet) => wallet !== null).map(key).filter((wallet) => edge.declarers.has(wallet) && !payers.has(wallet) && (below === undefined || below.has(wallet))));
+  };
+  const parts = (row) => {
+    const object = readRecord(row, "object");
+    return {
+      termId: readString(row, "term_id"),
+      subjectId: readString(row, "subject_id"),
+      predicateId: readString(row, "predicate_id"),
+      writer: readString(row, "creator_id"),
+      value: object === null ? null : readString(object, "label")
+    };
+  };
+  const isOutcome = (value) => USAGE_OUTCOMES.some((word) => word === value);
+  const isReason = (value) => USAGE_REASONS.some((word) => word === value);
+  const contexts = new Map;
+  const outcomes = new Map;
+  const others = (edge, row, predicate) => out.get(edge.tool)?.byOthers.push({
+    tripleId: row.termId ?? "",
+    writer: row.writer ?? "",
+    predicate,
+    value: row.value ?? ""
+  });
+  const onEdge = pass(await qualifiers([...edges.keys()], [config.inContextOf, config.hasOutcome]));
+  for (const row of onEdge) {
+    const line = parts(row);
+    const edge = line.subjectId === null ? undefined : edges.get(key(line.subjectId));
+    if (edge === undefined || line.predicateId === null || line.writer === null || line.value === null || line.termId === null)
+      continue;
+    const isOutcomeLine = key(line.predicateId) === key(config.hasOutcome);
+    if (isOutcomeLine && !isOutcome(line.value))
+      continue;
+    const wallets = standing(row, edge);
+    if (wallets.size === 0) {
+      others(edge, line, isOutcomeLine ? "outcome" : "context");
+    } else if (isOutcomeLine && isOutcome(line.value)) {
+      outcomes.set(key(line.termId), { edge, domain: null, form: "sibling", outcome: line.value, wallets, reasons: new Map, named: new Map });
+    } else {
+      contexts.set(key(line.termId), { edge, domain: line.value, wallets });
+    }
+  }
+  const onContext = pass(await qualifiers([...contexts.keys()], [config.hasOutcome]));
+  for (const row of onContext) {
+    const line = parts(row);
+    const context = line.subjectId === null ? undefined : contexts.get(key(line.subjectId));
+    if (context === undefined || line.value === null || line.termId === null || !isOutcome(line.value))
+      continue;
+    const wallets = standing(row, context.edge, context.wallets);
+    if (wallets.size === 0) {
+      others(context.edge, line, "outcome");
+    } else {
+      outcomes.set(key(line.termId), { edge: context.edge, domain: context.domain, form: "nested", outcome: line.value, wallets, reasons: new Map, named: new Map });
+    }
+  }
+  const reading = (predicate) => predicate !== undefined;
+  const failures = [...outcomes.entries()].filter(([, found]) => found.outcome === "failed").map(([id]) => id);
+  const worked = [...outcomes.entries()].filter(([, found]) => found.outcome === "worked").map(([id]) => id);
+  const withId = config.with;
+  const onOutcome = pass(await qualifiers(reading(withId) ? [...failures, ...worked] : failures, [config.because, ...reading(withId) ? [withId] : []]));
+  const reasonTerms = new Map;
+  const addName = (found, wallets, name) => {
+    for (const wallet of wallets) {
+      const given = found.named.get(wallet) ?? [];
+      if (!given.includes(name))
+        given.push(name);
+      found.named.set(wallet, given);
+    }
+  };
+  for (const row of onOutcome) {
+    const line = parts(row);
+    const found = line.subjectId === null ? undefined : outcomes.get(key(line.subjectId));
+    if (found === undefined || line.value === null || line.predicateId === null)
+      continue;
+    if (withId !== undefined && key(line.predicateId) === key(withId)) {
+      if (found.outcome !== "worked" || needKindOf(line.value) === null)
+        continue;
+      const wallets2 = standing(row, found.edge, found.wallets);
+      if (wallets2.size === 0)
+        others(found.edge, line, "with");
+      addName(found, wallets2, line.value);
+      continue;
+    }
+    if (found.outcome !== "failed" || !isReason(line.value))
+      continue;
+    const wallets = standing(row, found.edge, found.wallets);
+    if (wallets.size === 0)
+      others(found.edge, line, "reason");
+    for (const wallet of wallets) {
+      const given = found.reasons.get(wallet) ?? [];
+      if (!given.includes(line.value))
+        given.push(line.value);
+      found.reasons.set(wallet, given);
+    }
+    if (line.termId !== null && wallets.size > 0 && needKindOfReason(line.value) !== null) {
+      reasonTerms.set(key(line.termId), { found, reason: line.value, wallets });
+    }
+  }
+  const needsId = config.needs;
+  if (reading(needsId)) {
+    const onReason = pass(await qualifiers([...reasonTerms.keys()], [needsId]));
+    for (const row of onReason) {
+      const line = parts(row);
+      const reason = line.subjectId === null ? undefined : reasonTerms.get(key(line.subjectId));
+      if (reason === undefined || line.value === null)
+        continue;
+      const kind = needKindOf(line.value);
+      if (kind === null || kind !== needKindOfReason(reason.reason))
+        continue;
+      const wallets = standing(row, reason.found.edge, reason.wallets);
+      if (wallets.size === 0)
+        others(reason.found.edge, line, "needs");
+      addName(reason.found, wallets, line.value);
+    }
+  }
+  for (const { edge, domain, wallets } of contexts.values()) {
+    for (const wallet of wallets)
+      edge.declarers.get(wallet)?.domains.push(domain);
+  }
+  const ordered = [...outcomes.values()].sort((a, b) => Number(b.form === "nested") - Number(a.form === "nested"));
+  for (const found of ordered) {
+    for (const wallet of found.wallets) {
+      const declaration = found.edge.declarers.get(wallet);
+      if (declaration === undefined)
+        continue;
+      const reasons = found.reasons.get(wallet) ?? [];
+      const named = found.named.get(wallet) ?? [];
+      const field = found.outcome === "failed" ? "needs" : "with";
+      if (!declaration.outcomes.includes(found.outcome))
+        declaration.outcomes.push(found.outcome);
+      const domains = found.form === "nested" ? [found.domain] : declaration.domains.length > 0 ? declaration.domains : [null];
+      for (const domain of domains) {
+        const same = declaration.lines.find((line) => line.domain === domain && line.outcome === found.outcome);
+        if (same === undefined) {
+          declaration.lines.push({ domain, outcome: found.outcome, reasons, form: found.form, ...named.length === 0 ? {} : { [field]: named } });
+        } else {
+          same.reasons = [...new Set([...same.reasons, ...reasons])];
+          if (named.length > 0)
+            same[field] = [...new Set([...same[field] ?? [], ...named])];
+        }
+      }
+    }
+  }
+  for (const { tool, declarers } of edges.values()) {
+    const rows = [...declarers.values()].filter((row, at) => at === 0 || row.domains.length > 0 || row.lines.length > 0);
+    out.get(tool)?.declarations.push(...rows);
+  }
+  for (const usage of out.values()) {
+    usage.truncated = truncated;
+    usage.agents = new Set(usage.declarations.map((declaration) => key(declaration.agent.atomId))).size;
+    usage.wallets = new Set(usage.declarations.map((declaration) => key(declaration.writer)).filter((wallet) => !payers.has(wallet))).size;
+    for (const declaration of usage.declarations) {
+      for (const domain of declaration.domains)
+        usage.byDomain[domain] = (usage.byDomain[domain] ?? 0) + 1;
+      for (const outcome of declaration.outcomes)
+        usage.byOutcome[outcome] = (usage.byOutcome[outcome] ?? 0) + 1;
+      for (const reason of new Set(declaration.lines.flatMap((line) => line.reasons))) {
+        usage.byReason[reason] = (usage.byReason[reason] ?? 0) + 1;
+      }
+      const byNeed = usage.byNeed ??= {};
+      for (const name of new Set(declaration.lines.flatMap((line) => line.needs ?? [])))
+        byNeed[name] = (byNeed[name] ?? 0) + 1;
+      const byWith = usage.byWith ??= {};
+      for (const name of new Set(declaration.lines.flatMap((line) => line.with ?? [])))
+        byWith[name] = (byWith[name] ?? 0) + 1;
+    }
+  }
+  return out;
+}
+
+// ../../packages/protocol/src/failure-lines.ts
+function skillAtom(url, sha256) {
+  const thing = toolThing(url);
+  return { uri: thingUriOfDigest(sha256(thingDocument(thing))), label: thing.name };
+}
+async function readSkillLines(atomUri, config) {
+  const words = [HAS_OUTCOME_LABEL, BECAUSE_LABEL, NEEDS_LABEL, WITH_LABEL];
+  const atoms = await findToolAtoms([atomUri, ...words], config);
+  const tool = atoms.get(atomUri);
+  const hasOutcome = atoms.get(HAS_OUTCOME_LABEL);
+  const because = atoms.get(BECAUSE_LABEL);
+  if (tool === undefined || hasOutcome === undefined || because === undefined)
+    return null;
+  const needs = atoms.get(NEEDS_LABEL);
+  const withId = atoms.get(WITH_LABEL);
+  const usage = await getPulseUsage([tool], {
+    ...config,
+    hasOutcome,
+    because,
+    ...needs === undefined ? {} : { needs },
+    ...withId === undefined ? {} : { with: withId }
+  });
+  return usage.get(tool.toLowerCase()) ?? null;
+}
+function counted(counts) {
+  return [...counts.entries()].sort(([a, x], [b, y]) => y.size - x.size || a.localeCompare(b)).map(([name, wallets]) => `${name} (${wallets.size})`).join(", ");
+}
+var plural = (n) => `${n} wallet${n === 1 ? "" : "s"}`;
+function linesSentence(usage, label, where) {
+  if (usage === null)
+    return null;
+  const parts = [];
+  for (const outcome of ["failed", "worked"]) {
+    const wallets = new Set;
+    const because = new Map;
+    const named = new Map;
+    const add = (to, name, wallet) => to.set(name, (to.get(name) ?? new Set).add(wallet));
+    for (const row of usage.declarations) {
+      const wallet = row.writer.toLowerCase();
+      for (const line of row.lines) {
+        if (line.outcome !== outcome)
+          continue;
+        wallets.add(wallet);
+        for (const reason of line.reasons)
+          add(because, reason, wallet);
+        for (const name of (outcome === "failed" ? line.needs : line.with) ?? [])
+          add(named, name, wallet);
+      }
+    }
+    if (wallets.size === 0)
+      continue;
+    const detail = [
+      ...because.size === 0 ? [] : [`because ${counted(because)}`],
+      ...named.size === 0 ? [] : [`${outcome === "failed" ? "needs" : "with"} ${counted(named)}`]
+    ];
+    parts.push([`${usage.truncated ? "at least " : ""}${plural(wallets.size)} wrote ${outcome}`, ...detail].join(" · "));
+  }
+  if (parts.length === 0)
+    return null;
+  return `ARP, lines agents wrote on ${label} (${where}): ${parts.join("; ")}.`;
+}
+
+// ../../packages/protocol/src/skill-requires.ts
+var LOGIN = /\b(auth login|log ?in|sign ?up|api[ _-]?key|access token)\b/i;
+function frontmatter(markdown) {
+  const lines = markdown.split(`
+`);
+  if (lines[0]?.trim() !== "---")
+    return { lines: [], bodyStart: 0 };
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  return end === -1 ? { lines: [], bodyStart: 0 } : { lines: lines.slice(1, end), bodyStart: end + 1 };
+}
+function unquote(value) {
+  return value.trim().replace(/^["']|["']$/g, "");
+}
+function declaredBins(lines) {
+  const at = lines.findIndex((line) => /^\s*bins\s*:/.test(line));
+  if (at === -1)
+    return [];
+  const inline = lines[at]?.split(":").slice(1).join(":").trim() ?? "";
+  if (inline.startsWith("[")) {
+    return inline.replace(/^\[|\]$/g, "").split(",").map(unquote).filter((name) => name.length > 0);
+  }
+  const out = [];
+  for (const line of lines.slice(at + 1)) {
+    const item = /^\s*-\s*(.+)$/.exec(line);
+    if (item === null)
+      break;
+    out.push(unquote(item[1] ?? ""));
+  }
+  return out.filter((name) => name.length > 0);
+}
+function bashTools(lines) {
+  const line = lines.find((candidate) => /^\s*allowed-tools\s*:/.test(candidate));
+  if (line === undefined)
+    return [];
+  return [...line.matchAll(/Bash\(\s*([A-Za-z0-9._-]+)/g)].map((match) => match[1] ?? "").filter((name) => name.length > 0);
+}
+function declaredDescription(lines) {
+  const at = lines.findIndex((line) => /^description\s*:/.test(line));
+  if (at === -1)
+    return null;
+  const inline = lines[at]?.split(":").slice(1).join(":").trim() ?? "";
+  if (inline !== "" && !/^[>|][-+]?$/.test(inline))
+    return unquote(inline) || null;
+  const block = [];
+  for (const line of lines.slice(at + 1)) {
+    if (!/^\s+\S/.test(line))
+      break;
+    block.push(line.trim());
+  }
+  return block.length === 0 ? null : block.join(" ");
+}
+var COMMON = new Set(("awk bash break bun case cat cd chmod command continue cp curl cut date diff do done echo else end env " + "esac exit export false fi find for function git grep head if kill ln local ls mkdir mv node npm npx open pip pip3 pnpm printf pwd " + "python python3 read return rm sed set sh shift sleep sort source sudo tail tar tee test then time " + "touch tr true uniq unset unzip wait wc wget which while xargs yarn zip").split(" "));
+var INSTALL = /\b(?:npm\s+(?:i|install)\s+(?:-g|--global)|pnpm\s+add\s+-g|yarn\s+global\s+add|brew\s+install|pipx\s+install|pip3?\s+install|cargo\s+install)\s+([@a-z0-9][@\w./-]*)/i;
+var PROBE = /\b(?:command\s+-v|which)\s+([a-z][\w-]*)/i;
+var COMMAND = /^[a-z][a-z0-9_-]*$/;
+function shellSegments(line) {
+  const segments = [];
+  let current = "";
+  let quote = null;
+  for (let index = 0;index < line.length; index += 1) {
+    const char = line[index] ?? "";
+    if (char === "\\" && quote !== "'") {
+      current += char + (line[index + 1] ?? "");
+      index += 1;
+      continue;
+    }
+    if (quote !== null) {
+      if (char === quote)
+        quote = null;
+      current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === "#" && (index === 0 || /\s/.test(line[index - 1] ?? "")))
+      break;
+    if (char === "|" || char === ";" || char === "&" && line[index + 1] === "&") {
+      segments.push(current);
+      current = "";
+      if (line[index + 1] === char)
+        index += 1;
+      continue;
+    }
+    current += char;
+  }
+  segments.push(current);
+  return segments;
+}
+function commandsIn(shell, explicitOnly) {
+  const found = [];
+  for (const segment of shellSegments(shell)) {
+    const line = segment.trim().replace(/^\$\s+/, "");
+    if (line === "" || line.startsWith("#"))
+      continue;
+    const named = INSTALL.exec(line)?.[1] ?? PROBE.exec(line)?.[1];
+    if (named !== undefined) {
+      found.push(named);
+      continue;
+    }
+    if (explicitOnly)
+      continue;
+    const words = line.split(/\s+/).filter((word) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word));
+    const first = words[0] === "sudo" ? words[1] : words[0];
+    if (first === undefined || !COMMAND.test(first))
+      continue;
+    found.push(first);
+  }
+  return found;
+}
+var SHELL_FENCE = /^(sh|bash|shell|zsh|console|terminal)$/i;
+function shellLinesRun(lines) {
+  const run = [];
+  let heredocEnd = null;
+  let quote = null;
+  let continued = false;
+  for (const line of lines) {
+    if (heredocEnd !== null) {
+      if (line.trim() === heredocEnd)
+        heredocEnd = null;
+      continue;
+    }
+    if (quote === null && !continued)
+      run.push(line);
+    continued = line.trimEnd().endsWith("\\");
+    heredocEnd = /<<-?\s*['"]?([A-Za-z_]+)/.exec(line)?.[1] ?? null;
+    for (const char of quote === null ? shellSegments(line).join(";") : line) {
+      if (quote === null && (char === '"' || char === "'"))
+        quote = char;
+      else if (char === quote)
+        quote = null;
+    }
+  }
+  return run;
+}
+function commandsRun(body, declared) {
+  const found = [];
+  let fence = null;
+  let fenced = [];
+  for (const line of body) {
+    const marker = /^\s*(?:```|~~~)\s*([\w-]*)/.exec(line);
+    if (marker !== null) {
+      if (fence === "shell") {
+        for (const run of shellLinesRun(fenced))
+          found.push(...commandsIn(run, false));
+      }
+      fenced = [];
+      fence = fence !== null ? null : SHELL_FENCE.test(marker[1] ?? "") ? "shell" : "other";
+      continue;
+    }
+    if (fence !== null) {
+      fenced.push(line);
+      continue;
+    }
+    for (const inline of line.matchAll(/`([^`]+)`/g))
+      found.push(...commandsIn(inline[1] ?? "", true));
+  }
+  return [...new Set(found)].filter((name) => !COMMON.has(name) && !declared.includes(name));
+}
+function requiresLine(lines) {
+  const name = lines.map((line) => /^\s*requires\s*:\s*(\S+)\s*$/.exec(line)?.[1]).find(Boolean);
+  return name === undefined ? [] : [unquote(name)];
+}
+function readRequires(markdown) {
+  const { lines, bodyStart } = frontmatter(markdown);
+  const cli = [...new Set([...declaredBins(lines), ...bashTools(lines), ...requiresLine(lines)])];
+  const description = declaredDescription(lines);
+  const body = markdown.split(`
+`);
+  const runs = commandsRun(body.slice(bodyStart), cli);
+  for (let index = bodyStart;index < body.length; index += 1) {
+    const text = body[index] ?? "";
+    if (LOGIN.test(text)) {
+      return { cli, runs, login: { line: index + 1, text: text.trim().slice(0, 160) }, description };
+    }
+  }
+  return { cli, runs, login: null, description };
+}
+
+// ../../packages/protocol/src/skill-needs.ts
+var MARKDOWN = /\.(md|mdx|markdown)$/i;
+var SCRIPT = /\.(sh|bash|zsh|py|js|mjs|cjs|ts|rb|pl|ps1|php|lua)$/i;
+var COMMENT_LINE = /^\s*(?:#|\/\/|\*|--|;|rem\s)/i;
+function isTestFile(path) {
+  return /(^|\/)(tests?|__tests__|spec|fixtures?)\/|\.(test|spec)\.[a-z]+$|(^|\/)test_[^/]+\.py$|_test\.(py|go|rb)$/i.test(path);
+}
+function isSecretName(name) {
+  return /(^|_)(API_?KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|PASS|CREDENTIALS|CREDS)$/.test(name);
+}
+var SET_IN_SKILL_MD = /(?:^|\s|`)(?:export\s+|set\s+|\$env:)?([A-Z][A-Z0-9_]{2,})=/g;
+function lineAt(text, index) {
+  let line = 1;
+  for (let at = text.indexOf(`
+`);at !== -1 && at < index; at = text.indexOf(`
+`, at + 1))
+    line += 1;
+  return line;
+}
+function keysIn(files, settings) {
+  const skillMd = files.find((file) => file.path === "SKILL.md");
+  const toSet = new Set;
+  if (skillMd !== undefined)
+    for (const match of skillMd.text.matchAll(SET_IN_SKILL_MD))
+      toSet.add(match[1] ?? "");
+  const wanted = new Set(settings.filter((name) => isSecretName(name) || toSet.has(name)));
+  const ordered = [
+    ...skillMd === undefined ? [] : [skillMd],
+    ...files.filter((file) => file.path !== "SKILL.md" && !isTestFile(file.path))
+  ];
+  const found = new Map;
+  for (const file of ordered) {
+    for (const [index, line] of file.text.split(`
+`).entries()) {
+      for (const match of line.matchAll(/\b[A-Z][A-Z0-9_]{2,}\b/g)) {
+        const name = match[0];
+        if (!wanted.has(name) || found.has(name))
+          continue;
+        found.set(name, { name, why: isSecretName(name) ? "secret" : "set in SKILL.md", file: file.path, line: index + 1 });
+      }
+    }
+  }
+  return [...found.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+var EVERYWHERE = new Set("sh bash zsh dash env cat ls echo printf mkdir rm cp mv ln grep sed awk tr cut head tail sort uniq wc find xargs test true false base64 date sleep chmod touch tee kill ps uname which open xdg-open cmd powershell pwsh taskkill taskkill.exe where where.exe".split(" "));
+var ALIASES = {
+  soffice: "LibreOffice",
+  libreoffice: "LibreOffice",
+  "google-chrome": "Chrome",
+  chromium: "Chrome",
+  "chromium-browser": "Chrome",
+  magick: "ImageMagick",
+  convert: "ImageMagick",
+  pdftoppm: "poppler",
+  pdftotext: "poppler",
+  python: "python3",
+  docker: "Docker"
+};
+var SPAWNS = [
+  /\b(?:execFileSync|execFile|spawnSync|spawn|execaSync|execa)\(\s*["'`]([a-z][\w.+-]*)["'`]/g,
+  /\b(?:execSync|exec)\(\s*["'`]([a-z][\w.+-]*)[\s"'`]/g,
+  /\bBun\.spawn(?:Sync)?\(\s*\[\s*["'`]([a-z][\w.+-]*)["'`]/g,
+  /\bnew\s+Deno\.Command\(\s*["'`]([a-z][\w.+-]*)["'`]/g,
+  /\bsubprocess\.(?:run|call|check_call|check_output|Popen)\(\s*\[\s*["']([a-z][\w.+-]*)["']/g,
+  /\bsubprocess\.(?:run|call|check_call|check_output|Popen)\(\s*["']([a-z][\w.+-]*)[\s"']/g,
+  /\bos\.(?:system|popen)\(\s*["']([a-z][\w.+-]*)[\s"']/g
+];
+var DRIVES = {
+  puppeteer: "Chrome",
+  "puppeteer-core": "Chrome",
+  "chrome-launcher": "Chrome",
+  "chrome-remote-interface": "Chrome",
+  pyppeteer: "Chrome",
+  playwright: "a Playwright browser",
+  "playwright-core": "a Playwright browser",
+  "@playwright/test": "a Playwright browser",
+  "selenium-webdriver": "a browser and its driver",
+  selenium: "a browser and its driver",
+  "fluent-ffmpeg": "ffmpeg",
+  "ffmpeg-python": "ffmpeg",
+  ffmpeg: "ffmpeg",
+  pydub: "ffmpeg",
+  moviepy: "ffmpeg",
+  "openai-whisper": "ffmpeg",
+  whisper: "ffmpeg",
+  pytesseract: "tesseract",
+  "node-tesseract-ocr": "tesseract",
+  pdf2image: "poppler",
+  "pdf-poppler": "poppler",
+  wand: "ImageMagick",
+  gm: "ImageMagick",
+  pypandoc: "pandoc",
+  "node-pandoc": "pandoc",
+  docker: "Docker",
+  dockerode: "Docker"
+};
+var IMPORTS = [
+  /\bfrom\s+["']([@\w./-]+)["']/g,
+  /\bimport\s*\(\s*["']([@\w./-]+)["']\s*\)/g,
+  /\bimport\s+["']([@\w./-]+)["']/g,
+  /\brequire\(\s*["']([@\w./-]+)["']\s*\)/g,
+  /^\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm
+];
+function packageRoot(specifier) {
+  if (specifier.startsWith("@"))
+    return specifier.split("/").slice(0, 2).join("/");
+  return specifier.split("/")[0]?.split(".")[0] ?? specifier;
+}
+var NAMED_PROGRAMS = [
+  { name: "ffmpeg", pattern: /\bffmpeg\b/i },
+  { name: "ffprobe", pattern: /\bffprobe\b/i },
+  { name: "Chrome", pattern: /\b(?:Google Chrome|Chrome|Chromium|chrome-headless-shell|google-chrome|chromium-browser)\b/ },
+  { name: "Docker", pattern: /\b[Dd]ocker\b/ },
+  { name: "git", pattern: /\bgit\b(?!\s*(?:hub|lab))/ },
+  { name: "jq", pattern: /\bjq\b/ },
+  { name: "pandoc", pattern: /\bpandoc\b/i },
+  { name: "ImageMagick", pattern: /\b(?:ImageMagick|imagemagick|magick)\b/ },
+  { name: "yt-dlp", pattern: /\byt-dlp\b/ },
+  { name: "tesseract", pattern: /\btesseract\b/i },
+  { name: "poppler", pattern: /\b(?:poppler|pdftoppm|pdftotext)\b/i },
+  { name: "LibreOffice", pattern: /\b(?:LibreOffice|libreoffice|soffice)\b/ },
+  { name: "sox", pattern: /\bsox\b/ },
+  { name: "exiftool", pattern: /\bexiftool\b/i },
+  { name: "ollama", pattern: /\b[Oo]llama\b/ },
+  { name: "gh", pattern: /\bgh\s+(?:CLI|cli)\b|\bGitHub CLI\b/ },
+  { name: "python3", pattern: /\b[Pp]ython\s?3?\b(?![-.\w])/ },
+  { name: "node", pattern: /\b(?:Node\.js|node)\b(?![-.\w])/ },
+  { name: "Java", pattern: /\b(?:Java|JDK|JRE)\b/ }
+];
+var NEEDED = /\b(?:requires?|required|requirements?|needs?|needed|prerequisites?|depends on|must (?:be )?install(?:ed)?|must have|install(?:ed)? first|has to be installed|be installed)\b/i;
+var NEEDED_GLOBAL = new RegExp(NEEDED.source, "gi");
+var NOT_NEEDED = /\b(?:no|not|never|without|doesn't|don't|isn't|aren't|zero)\b[^.;]{0,30}\b(?:requires?|required|needs?|needed|install)/i;
+var NOT_AFTER = /\b(?:requires?|needs?)\s+(?:no|nothing|neither)\b/i;
+function saysWhatItNeeds(path, isScript) {
+  if (isScript)
+    return true;
+  if (!MARKDOWN.test(path))
+    return false;
+  const base = path.slice(path.lastIndexOf("/") + 1).toLowerCase();
+  return base === "skill.md" || /^(readme|requirements?|prerequisites?|setup|install(ation)?|dependencies|getting-started)\b/.test(base);
+}
+var COMMENT_OR_STRING = /^\s*(?:#|\/\/|\*|\/\*|"""|''')|["'`][^"'`]*\b(?:requires?|needs?|install)/i;
+function namedAfterVerb(line, program) {
+  for (const verb of line.matchAll(NEEDED_GLOBAL)) {
+    const at = verb.index;
+    const after = line.slice(at + verb[0].length).slice(0, 40).split(/[.;:!?](?:\s|$)/)[0] ?? "";
+    const before = line.slice(Math.max(0, at - 30), at).split(/[.;:!?](?:\s|$)/).at(-1) ?? "";
+    if (program.test(after) || program.test(before))
+      return true;
+  }
+  return false;
+}
+function programsNeededIn(files) {
+  const out = new Map;
+  const add = (program) => {
+    if (!out.has(program.name))
+      out.set(program.name, program);
+  };
+  for (const file of files) {
+    if (isTestFile(file.path))
+      continue;
+    const lines = file.text.split(`
+`);
+    const isScript = SCRIPT.test(file.path) || lines[0]?.startsWith("#!") === true;
+    if (isScript && !/\.(sh|bash|zsh)$/i.test(file.path)) {
+      for (const pattern of SPAWNS) {
+        for (const match of file.text.matchAll(pattern)) {
+          const name = match[1] ?? "";
+          const line = lineAt(file.text, match.index);
+          if (name === "" || EVERYWHERE.has(name) || COMMENT_LINE.test(lines[line - 1] ?? ""))
+            continue;
+          add({ name: ALIASES[name] ?? name, from: "spawned", file: file.path, line });
+        }
+      }
+      for (const pattern of IMPORTS) {
+        for (const match of file.text.matchAll(pattern)) {
+          const root = packageRoot(match[1] ?? match[2] ?? "");
+          const driven = DRIVES[root];
+          const line = lineAt(file.text, match.index);
+          if (driven === undefined || COMMENT_LINE.test(lines[line - 1] ?? ""))
+            continue;
+          add({ name: driven, from: "package", file: file.path, line, via: root });
+        }
+      }
+    }
+    if (/(^|\/)package\.json$/.test(file.path)) {
+      for (const [index, line] of lines.entries()) {
+        const name = /^\s*"(@?[\w./-]+)"\s*:\s*"/.exec(line)?.[1];
+        const driven = name === undefined ? undefined : DRIVES[name];
+        if (driven !== undefined)
+          add({ name: driven, from: "package", file: file.path, line: index + 1, via: name ?? "" });
+      }
+    }
+    if (/(^|\/)requirements[\w.-]*\.txt$/i.test(file.path)) {
+      for (const [index, line] of lines.entries()) {
+        const name = /^\s*([A-Za-z0-9][\w.-]*)/.exec(line.replace(/#.*/, ""))?.[1]?.toLowerCase();
+        const driven = name === undefined ? undefined : DRIVES[name];
+        if (driven !== undefined)
+          add({ name: driven, from: "package", file: file.path, line: index + 1, via: name ?? "" });
+      }
+    }
+    if (saysWhatItNeeds(file.path, isScript)) {
+      for (const [index, line] of lines.entries()) {
+        if (NOT_NEEDED.test(line) || NOT_AFTER.test(line))
+          continue;
+        if (isScript && !COMMENT_OR_STRING.test(line))
+          continue;
+        for (const { name, pattern } of NAMED_PROGRAMS) {
+          if (namedAfterVerb(line, pattern))
+            add({ name, from: "named as needed", file: file.path, line: index + 1 });
+        }
+      }
+    }
+  }
+  return [...out.values()];
+}
+
+// ../../packages/protocol/src/skill-contents.ts
+var CONTENTS_LIMITS = {
+  files: 200,
+  fileChars: 512 * 1024,
+  items: 40,
+  lineChars: 160
+};
+var SCRIPT2 = /\.(sh|bash|zsh|py|js|mjs|cjs|ts|rb|pl|ps1|php|lua)$/i;
+var MARKDOWN2 = /\.(md|mdx|markdown)$/i;
+var FENCE = /^\s*(?:```|~~~)/;
+function cap(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > CONTENTS_LIMITS.lineChars ? `${flat.slice(0, CONTENTS_LIMITS.lineChars - 1)}…` : flat;
+}
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var BASE_SHELLS = new Set(["sh", "bash", "zsh", "dash"]);
+function interpreterOf(firstLine) {
+  const match = /^#!\s*(\S+)(?:\s+(?:-\S+\s+)*(\S+))?/.exec(firstLine);
+  if (match === null)
+    return null;
+  const binary = match[1]?.split("/").pop() ?? "";
+  const name = binary === "env" ? match[2] ?? "" : binary;
+  return /^[a-z][\w.-]*$/i.test(name) && !BASE_SHELLS.has(name) ? name : null;
+}
+var SCRIPT_PROBE = /(?:^|[;&|(!{]|\bif|\bthen|\$\()\s*(?:!\s*)?(?:command\s+-v|which|type\s+-p|hash)\s+([a-z][\w.+-]*)/g;
+var SYSTEM_INSTALL = /\b(?:brew|apt-get|apt|dnf|yum|apk|pacman|choco|winget|scoop|port)\s+(?:install|add|-S)\s+(?:-\S+\s+)*([a-z][\w.+-]*)/g;
+var COMMENT_LINE2 = /^\s*(?:#|\/\/|\*|--|;|rem\s)/i;
+var PYTHON_PROBE = /\bshutil\.which\(\s*["']([a-z][\w.+-]*)["']/g;
+function programsInScriptLine(line, shell) {
+  if (COMMENT_LINE2.test(line))
+    return [];
+  const matches = shell ? [...line.matchAll(SCRIPT_PROBE), ...line.matchAll(SYSTEM_INSTALL)] : [...line.matchAll(PYTHON_PROBE)];
+  return matches.map((match) => match[1] ?? "").filter((name) => name !== "");
+}
+var PACKAGE_INSTALL = /\b(pip3?|pipx|uv\s+pip|uv\s+add|poetry\s+add|npm|pnpm|yarn|bun|gem|cargo)\s+(?:install|add|i)\b([^\n|;&#`)]*)/gi;
+function packagesIn(line) {
+  const out = [];
+  for (const match of line.matchAll(PACKAGE_INSTALL)) {
+    const manager = (match[1] ?? "").replace(/\s+/g, " ").toLowerCase();
+    for (const raw of (match[2] ?? "").trim().split(/\s+/)) {
+      const word = raw.replace(/^["']|["']$/g, "");
+      if (word === "" || word.startsWith("-") || word.startsWith(".") || /[:\\<>{}$]/.test(word))
+        continue;
+      if (/\.(txt|toml|json|cfg|lock|whl|tgz|tar\.gz|zip)$/i.test(word))
+        continue;
+      const name = word.replace(/[=<>!~[].*$/, "");
+      if (/^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(@[\w.^~-]+)?$/i.test(name))
+        out.push({ manager, name });
+    }
+  }
+  return out;
+}
+function requirementsIn(text) {
+  return text.split(`
+`).map((line) => line.replace(/#.*/, "").trim()).filter((line) => line !== "" && !line.startsWith("-") && !/^(https?|git\+)/.test(line)).map((line) => /^[A-Za-z0-9][\w.-]*/.exec(line)?.[0] ?? "").filter((name) => name !== "");
+}
+var SHELL_VARIABLES = new Set(("HOME PATH PWD OLDPWD USER LOGNAME SHELL TERM LANG LC_ALL TMPDIR TMP TEMP HOSTNAME IFS PS1 PS2 " + "RANDOM SECONDS LINENO BASH_SOURCE BASH_VERSION FUNCNAME PIPESTATUS OPTARG OPTIND EUID UID PPID " + "REPLY EDITOR VISUAL PAGER DISPLAY XDG_CONFIG_HOME XDG_DATA_HOME XDG_CACHE_HOME CI NODE_ENV DEBUG").split(" "));
+var READS_IN_CODE = [
+  /\bprocess\.env\.([A-Z][A-Z0-9_]+)/g,
+  /\bprocess\.env\[\s*["']([A-Z][A-Z0-9_]+)["']\s*\]/g,
+  /\bBun\.env\.([A-Z][A-Z0-9_]+)/g,
+  /\bDeno\.env\.get\(\s*["']([A-Z][A-Z0-9_]+)["']/g,
+  /\bimport\.meta\.env\.([A-Z][A-Z0-9_]+)/g,
+  /\bos\.environ\[\s*["']([A-Z][A-Z0-9_]+)["']\s*\]/g,
+  /\b(?:os\.environ\.get|os\.getenv|getenv|environ\.get)\(\s*["']([A-Z][A-Z0-9_]+)["']/g,
+  /\bENV(?:\.fetch\(|\[)\s*["']([A-Z][A-Z0-9_]+)["']/g,
+  /\$env:([A-Za-z][A-Za-z0-9_]+)/g
+];
+var SHELL_READ = /\$\{?([A-Z][A-Z0-9_]{2,})\b/g;
+var SHELL_ASSIGN = /^\s*(?:export\s+|local\s+|readonly\s+|declare\s+(?:-\w+\s+)?)?([A-Z][A-Z0-9_]*)=/;
+var SHELL_LOOP = /\b(?:for|read(?:\s+-\w+)*)\s+([A-Z][A-Z0-9_]*)\b/g;
+var EXPORT_IN_PROSE = /\bexport\s+([A-Z][A-Z0-9_]{2,})=/g;
+var KEY_NAMED = /\b([A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*_(?:API_KEY|APIKEY|KEY|TOKEN|SECRET|PASSWORD))\b/g;
+function shellReads(lines) {
+  const assigned = new Set;
+  for (const line of lines) {
+    const name = SHELL_ASSIGN.exec(line)?.[1];
+    if (name !== undefined)
+      assigned.add(name);
+    for (const loop of line.matchAll(SHELL_LOOP))
+      assigned.add(loop[1] ?? "");
+  }
+  return lines.flatMap((line) => [...line.matchAll(SHELL_READ)].map((match) => match[1] ?? "")).filter((name) => !assigned.has(name));
+}
+function isShell(path, text) {
+  return /\.(sh|bash|zsh)$/i.test(path) || /^#!\s*\S*\/(?:env\s+)?(?:ba|z|da)?sh\b/.test(text);
+}
+function settingsIn(path, text, code) {
+  const found = new Set;
+  for (const pattern of READS_IN_CODE) {
+    for (const match of text.matchAll(pattern))
+      found.add((match[1] ?? "").toUpperCase());
+  }
+  if (MARKDOWN2.test(path)) {
+    for (const match of text.matchAll(EXPORT_IN_PROSE))
+      found.add(match[1] ?? "");
+    for (const match of text.matchAll(KEY_NAMED))
+      found.add(match[1] ?? "");
+  } else if (isShell(path, text)) {
+    for (const name of shellReads(code))
+      found.add(name);
+  }
+  return [...found].filter((name) => name.length > 0 && !SHELL_VARIABLES.has(name));
+}
+function codeOf(path, text, isScript) {
+  const lines = text.split(`
+`);
+  if (isScript)
+    return lines;
+  if (!MARKDOWN2.test(path))
+    return [];
+  const out = [];
+  let fenced = false;
+  for (const line of lines) {
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced)
+      out.push(line);
+    else
+      for (const inline of line.matchAll(/`([^`]+)`/g))
+        out.push(inline[1] ?? "");
+  }
+  return out;
+}
+var FETCH_AND_RUN = [
+  {
+    kind: "pipe to a shell",
+    pattern: /\b(?:curl|wget|iwr|irm|Invoke-WebRequest|Invoke-RestMethod)\b[^|\n]*\|\s*(?:sudo\s+(?:-\S+\s+)*)?(?:sh|bash|zsh|dash|python3?|node|perl|ruby|iex|Invoke-Expression)\b/i
+  },
+  {
+    kind: "runs a downloaded script",
+    pattern: /\b(?:sh|bash|zsh|source)\s+<\(\s*(?:curl|wget)\b|\b(?:sh|bash|zsh)\s+-c\s+["']?\$\(\s*(?:curl|wget)\b|\b(?:iex|Invoke-Expression)\b[^\n]*\b(?:irm|iwr|Invoke-WebRequest|Invoke-RestMethod|DownloadString)\b|\bdeno\s+run\b[^\n]*\bhttps?:\/\//i
+  },
+  {
+    kind: "installs from a URL",
+    pattern: /\b(?:pip3?|pipx|uv\s+pip|npm|pnpm|yarn|bun|gem)\s+(?:install|add|i)\b[^\n|;&]*\s(?:https?:\/\/|git\+|github:)/i
+  },
+  {
+    kind: "runs a package fetched at run time",
+    pattern: /\bnpx\s+(?:-y|--yes)\b|\b(?:pnpm|yarn)\s+dlx\s+\S|\buvx\s+[a-z]|\bpipx\s+run\s+[a-z]/i
+  }
+];
+var URL_HOST = /\bhttps?:\/\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+)/gi;
+var PLACEHOLDER_HOST = /(^|\.)(example\.(com|org|net)|localhost|local|test|invalid|example|internal)$|^(127\.\d+\.\d+\.\d+|0\.0\.0\.0)$|^(www\.)?(your|my)-?(domain|site|server|host|app|api|company|website)\./;
+var FILE_LIKE_HOST = /\.(jpe?g|png|gif|webp|svg|mp[34]|wav|mov|webm|pdf|md|json|txt|html?|js|ts|py|sh)$/;
+function domainsIn(text) {
+  const out = [];
+  for (const match of text.matchAll(URL_HOST)) {
+    const host = (match[1] ?? "").toLowerCase();
+    if (!/\.[a-z]{2,}$/.test(host) && !/^\d+\.\d+\.\d+\.\d+$/.test(host))
+      continue;
+    if (PLACEHOLDER_HOST.test(host) || FILE_LIKE_HOST.test(host))
+      continue;
+    out.push(host);
+  }
+  return out;
+}
+var INVISIBLE = /[​-‍⁠-⁤᠎‪-‮⁦-⁩]|\uDB40[\uDC00-\uDDEF]/g;
+var PICTOGRAPH = /\p{Extended_Pictographic}/u;
+function codePoint(point) {
+  return `U+${point.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function invisibleIn(line, lineIndex) {
+  const counts = new Map;
+  const spelled = [];
+  for (const match of line.matchAll(INVISIBLE)) {
+    const char = match[0];
+    const at = match.index;
+    if (lineIndex === 0 && at === 0 && char === "\uFEFF")
+      continue;
+    if (char === "‍") {
+      const before = [...line.slice(0, at)].at(-1) ?? "";
+      const after = [...line.slice(at + 1)][0] ?? "";
+      if (PICTOGRAPH.test(before) && PICTOGRAPH.test(after))
+        continue;
+    }
+    const point = char.codePointAt(0) ?? 0;
+    if (point >= 917536 && point <= 917630)
+      spelled.push(String.fromCharCode(point - 917504));
+    const name = point >= 917504 && point <= 917631 ? "Unicode tag" : codePoint(point);
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  if (counts.size === 0)
+    return null;
+  const listed = [...counts.entries()].map(([name, n]) => `${n} × ${name}`).join(", ");
+  return spelled.length === 0 ? listed : `${listed}, spelling "${cap(spelled.join(""))}"`;
+}
+var BASE64_RUN = /[A-Za-z0-9+/]{100,}={0,2}/g;
+var DATA_URI = /data:([\w.+-]+\/[\w.+-]+)?(?:;[\w=-]+)*;base64,([A-Za-z0-9+/]{100,}={0,2})/g;
+var URL_TEXT = /\bhttps?:\/\/\S+/g;
+function encodedIn(line) {
+  const out = [];
+  const withoutUris = line.replace(DATA_URI, (_whole, type, body) => {
+    out.push(`data URI${type === undefined ? "" : ` ${type}`}, ${body.length} characters of base64`);
+    return " ";
+  });
+  for (const match of withoutUris.replace(URL_TEXT, " ").matchAll(BASE64_RUN)) {
+    const run = match[0];
+    if (/[A-Z]/.test(run) && /[a-z]/.test(run) && /[0-9]/.test(run))
+      out.push(`${run.length} characters of base64`);
+  }
+  return out;
+}
+var IGNORE_INSTRUCTIONS = /\b(?:ignore|disregard|forget|override)\b[^.\n]{0,40}?\b(?:previous|prior|above|earlier|preceding|all|any|other|system|your)\b[^.\n]{0,25}?\b(?:instructions?|prompts?|rules|guidelines|directions)\b/i;
+var KEEP_FROM_PERSON = /\b(?:do not|don't|never)\s+(?:tell|inform|notify|alert|(?:mention|reveal)(?:\s+(?:this|it))?\s+to)\s+(?:the\s+)?(?:user|human|person|operator)\b|\bwithout\s+(?:telling|informing|notifying|alerting)\s+(?:the\s+)?(?:user|human|person|operator)\b/i;
+function unquoted(line) {
+  return line.replace(/"[^"]*"|\u201C[^\u201D]*\u201D|\u300C[^\u300D]*\u300D|`[^`]*`/g, " ");
+}
+var COMMENT_WORDS = 4;
+function hiddenInMarkdown(path, text) {
+  const out = [];
+  const push = (kind, line, value) => out.push({ kind, file: path, line, text: value });
+  let fenced = false;
+  let comment = null;
+  for (const [index, line] of text.split(`
+`).entries()) {
+    const invisible = invisibleIn(line, index);
+    if (invisible !== null)
+      push("hidden characters", index + 1, invisible);
+    for (const encoded of encodedIn(line))
+      push("encoded block", index + 1, encoded);
+    const visible = line.replace(INVISIBLE, "");
+    if (IGNORE_INSTRUCTIONS.test(unquoted(visible)))
+      push("says to ignore instructions", index + 1, cap(visible));
+    if (KEEP_FROM_PERSON.test(unquoted(visible)))
+      push("says not to tell the person", index + 1, cap(visible));
+    if (comment === null && FENCE.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced)
+      continue;
+    let rest = visible;
+    while (rest.length > 0) {
+      if (comment === null) {
+        const open = rest.indexOf("<!--");
+        if (open === -1)
+          break;
+        comment = { start: index + 1, text: [] };
+        rest = rest.slice(open + 4);
+      }
+      const close = rest.indexOf("-->");
+      if (close === -1) {
+        comment.text.push(rest);
+        break;
+      }
+      comment.text.push(rest.slice(0, close));
+      const inner = comment.text.join(" ").replace(/\s+/g, " ").trim();
+      if (inner.split(" ").filter((word) => /[\p{L}\p{N}]/u.test(word)).length >= COMMENT_WORDS) {
+        push("HTML comment", comment.start, cap(inner));
+      }
+      comment = null;
+      rest = rest.slice(close + 3);
+    }
+  }
+  if (comment !== null)
+    push("HTML comment", comment.start, cap(`(never closed) ${comment.text.join(" ")}`));
+  return out;
+}
+function bounded(name, items, cut) {
+  if (items.length <= CONTENTS_LIMITS.items)
+    return [...items];
+  cut.push(name);
+  return items.slice(0, CONTENTS_LIMITS.items);
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function namesFile(markdown, path) {
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  return markdown.includes(path) || new RegExp(`(^|[\\s/\`'"(])${escapeRegExp(base)}($|[\\s\`'")]|[.,:;](\\s|$))`, "m").test(markdown);
+}
+function readSkillContents(input) {
+  const sorted = [...input].sort((a, b) => compare(a.path, b.path));
+  const skipped = [];
+  const files = [];
+  for (const file of sorted) {
+    if (files.length >= CONTENTS_LIMITS.files)
+      skipped.push({ path: file.path, why: "over the file limit" });
+    else if (file.text === null)
+      skipped.push({ path: file.path, why: file.tooLarge === true ? "too large" : file.notFetched === true ? "not fetched" : "binary" });
+    else if (file.text.length > CONTENTS_LIMITS.fileChars)
+      skipped.push({ path: file.path, why: "too large" });
+    else
+      files.push({ path: file.path, text: file.text.replace(/\r\n?/g, `
+`) });
+  }
+  const skillMd = files.find((file) => file.path === "SKILL.md")?.text ?? "";
+  const programs = new Map;
+  const add = (name, from) => {
+    if (!programs.has(name))
+      programs.set(name, { name, from });
+  };
+  const requires = readRequires(skillMd);
+  for (const name of requires.cli)
+    add(name, "declared");
+  for (const name of requires.runs)
+    add(name, "runs");
+  const packages = new Map;
+  const settings = new Set;
+  const domains = new Set;
+  const fetchAndRun = [];
+  const hidden = [];
+  const scripts = skipped.filter((file) => file.why === "not fetched" && SCRIPT2.test(file.path)).map((file) => ({ path: file.path, namedInSkillMd: namesFile(skillMd, file.path) }));
+  for (const file of files) {
+    const lines = file.text.split(`
+`);
+    const isScript = SCRIPT2.test(file.path) || lines[0]?.startsWith("#!") === true;
+    const code = codeOf(file.path, file.text, isScript);
+    const shell = isShell(file.path, file.text);
+    for (const line of code) {
+      const installed = packagesIn(line);
+      for (const pkg of installed)
+        packages.set(`${pkg.manager} ${pkg.name}`, pkg);
+      if (!isScript)
+        continue;
+      for (const name of programsInScriptLine(line, shell)) {
+        if (!installed.some((pkg) => pkg.name === name))
+          add(name, "script");
+      }
+    }
+    if (isScript) {
+      scripts.push({ path: file.path, namedInSkillMd: namesFile(skillMd, file.path) });
+      const interpreter = interpreterOf(lines[0] ?? "");
+      if (interpreter !== null)
+        add(interpreter, "interpreter");
+    }
+    if (/(^|\/)requirements[\w.-]*\.txt$/i.test(file.path)) {
+      for (const name of requirementsIn(file.text))
+        packages.set(`pip ${name}`, { manager: "pip", name });
+    }
+    for (const setting of settingsIn(file.path, file.text, code))
+      settings.add(setting);
+    for (const host of domainsIn(file.text))
+      domains.add(host);
+    for (const [index, line] of lines.entries()) {
+      const run = FETCH_AND_RUN.find(({ pattern }) => pattern.test(line));
+      if (run !== undefined)
+        fetchAndRun.push({ kind: run.kind, file: file.path, line: index + 1, text: cap(line) });
+    }
+    if (MARKDOWN2.test(file.path))
+      hidden.push(...hiddenInMarkdown(file.path, file.text));
+  }
+  const packageNames = new Set([...packages.values()].map((pkg) => pkg.name));
+  for (const [name, program] of programs)
+    if (program.from !== "declared" && packageNames.has(name))
+      programs.delete(name);
+  for (const needed of programsNeededIn(files))
+    if (!programs.has(needed.name))
+      programs.set(needed.name, needed);
+  const cut = [];
+  return {
+    programs: bounded("programs", [...programs.values()].sort((a, b) => compare(a.name, b.name)), cut),
+    packages: bounded("packages", [...packages.values()].sort((a, b) => compare(`${a.manager} ${a.name}`, `${b.manager} ${b.name}`)), cut),
+    settings: bounded("settings", [...settings].sort(compare), cut),
+    keys: bounded("keys", keysIn(files, [...settings]), cut),
+    scripts: bounded("scripts", scripts.sort((a, b) => compare(a.path, b.path)), cut),
+    fetchAndRun: bounded("fetchAndRun", fetchAndRun, cut),
+    domains: bounded("domains", [...domains].sort(compare), cut),
+    hidden: bounded("hidden", hidden, cut),
+    read: {
+      files: files.length,
+      bytes: files.reduce((sum, file) => sum + new TextEncoder().encode(file.text).byteLength, 0),
+      skipped
+    },
+    cut
+  };
+}
+
+// ../../packages/protocol/src/pulse.ts
+var MAX_SKILL_FILES_READ = 200;
+var MAX_SCRIPTS_READ = 5;
+var MAX_DIRECTORY_FILES_READ = 80;
+var NOT_TEXT = /\.(png|jpe?g|gif|webp|ico|bmp|tiff?|avif|svgz|pdf|zip|gz|tgz|bz2|xz|7z|rar|jar|woff2?|ttf|otf|eot|mp[34]|m4a|wav|ogg|flac|aac|mov|webm|avi|mkv|pptx|docx|xlsx|psd|ai|sketch|fig|db|sqlite|bin|exe|dll|so|dylib|wasm|pyc|class|hdr|exr|glb|ktx2?)$/i;
+var GITHUB_READ_TIMEOUT_MS = 1e4;
+var INSTALLER_ORDER = [
+  "",
+  "skills/",
+  "skills/.curated/",
+  "skills/.experimental/",
+  "skills/.system/",
+  ".agents/skills/",
+  ".claude/skills/",
+  ".cline/skills/",
+  ".codebuddy/skills/",
+  ".codex/skills/",
+  ".commandcode/skills/",
+  ".continue/skills/",
+  ".factory/skills/",
+  ".github/skills/",
+  ".goose/skills/",
+  ".grok/skills/",
+  ".iflow/skills/",
+  ".junie/skills/",
+  ".kilo/skills/",
+  ".kilocode/skills/",
+  ".kimchi/skills/",
+  ".kiro/skills/",
+  ".minimax/skills/",
+  ".mux/skills/",
+  ".neovate/skills/",
+  ".opencode/skills/",
+  ".openhands/skills/",
+  ".pi/skills/",
+  ".posit/assistant/skills/",
+  ".qoder/skills/",
+  ".roo/skills/",
+  ".trae/skills/",
+  ".windsurf/skills/",
+  ".zcode/skills/",
+  ".zencoder/skills/"
+];
+function installerRank(path) {
+  let best = null;
+  INSTALLER_ORDER.forEach((prefix, rank) => {
+    if (best !== null || !path.startsWith(prefix))
+      return;
+    const depth = path.slice(prefix.length).split("/").length;
+    if (prefix === "" ? depth <= 2 : depth <= 4)
+      best = rank;
+  });
+  return best;
+}
+function normaliseName(name) {
+  return name.trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function frontmatterName(markdown) {
+  const lines = markdown.split(`
+`);
+  if (lines[0]?.trim() !== "---")
+    return null;
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "---")
+      return null;
+    const match = /^name\s*:\s*(.+?)\s*$/.exec(line);
+    if (match !== null)
+      return (match[1] ?? "").replace(/^["']|["']$/g, "");
+  }
+  return null;
+}
+var KEY_NAME2 = /\b[A-Z][A-Z0-9_]*(?:API_KEY|APIKEY|_TOKEN|_SECRET)\b/g;
+var PAID_WORD = /\b(pricing|paid|subscription|credits?|billing|free tier|per minute)\b/gi;
+var HOST = /https?:\/\/([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/g;
+var NOT_A_SERVICE = /(^|\.)(github\.com|githubusercontent\.com|example\.(com|org|net))$/;
+var LOOKS_LIKE_A_FILE = /\.(jpe?g|png|gif|webp|mp[34]|wav|mov|webm|pdf|md|json|txt)$/;
+var SCRIPT3 = /\.(sh|bash|py|js|mjs|cjs|ts|rb|pl)$/i;
+var RUNS_FILE = /\b(?:node|bun|deno|tsx|python3?|bash|sh)\s+((?:~|\.{1,2})?\/?[\w.@-]+(?:\/[\w.@-]+)*\.(?:mjs|cjs|js|ts|py|sh))\b/g;
+var PLACEHOLDER = /(^|\/)(path|your|my|foo|example|script|file|input|output)(\/|\.|$)/i;
+function filesItRuns(markdown, repositoryFiles) {
+  const named = [...markdown.matchAll(RUNS_FILE)].map((match) => match[1] ?? "");
+  const found = new Set;
+  for (const name of named) {
+    if (name.startsWith("/") || name.startsWith("~") || PLACEHOLDER.test(name))
+      continue;
+    const tail = name.replace(/^(\.{1,2}\/)+/, "");
+    const hit = repositoryFiles.find((file) => file.path === tail || file.path.endsWith(`/${tail}`));
+    if (hit !== undefined)
+      found.add(hit.path);
+  }
+  return [...found];
+}
+function absentFiles(markdown, repositoryFiles) {
+  const named = [...markdown.matchAll(RUNS_FILE)].map((match) => match[1] ?? "");
+  return [...new Set(named)].filter((name) => {
+    if (name.startsWith("/") || name.startsWith("~") || PLACEHOLDER.test(name))
+      return false;
+    const tail = name.replace(/^(\.{1,2}\/)+/, "");
+    return !repositoryFiles.some((file) => file.path === tail || file.path.endsWith(`/${tail}`));
+  });
+}
+function readSkillFacts(markdown, filesInDirectory, repositoryFiles = filesInDirectory) {
+  const hosts = [...markdown.matchAll(HOST)].map((match) => (match[1] ?? "").toLowerCase()).filter((host) => !NOT_A_SERVICE.test(host) && !LOOKS_LIKE_A_FILE.test(host));
+  return {
+    files: filesInDirectory.length,
+    bytes: filesInDirectory.reduce((total, file) => total + file.size, 0),
+    scripts: filesInDirectory.filter((file) => SCRIPT3.test(file.path)).length,
+    keys: [...new Set(markdown.match(KEY_NAME2) ?? [])],
+    paidWords: [...new Set((markdown.match(PAID_WORD) ?? []).map((word) => word.toLowerCase()))],
+    hosts: [...new Set(hosts)],
+    runsAbsentFiles: absentFiles(markdown, repositoryFiles),
+    keysInScriptsItRuns: [],
+    requires: readRequires(markdown),
+    contains: readSkillContents([{ path: "SKILL.md", text: markdown }])
+  };
+}
+function parentOf(path) {
+  const at = path.lastIndexOf("/");
+  return at === -1 ? "" : path.slice(0, at);
+}
+var MAX_NAME_READS = 12;
+var NAME_BATCH = 6;
+var wordsOf = (text) => text.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 1);
+function byNearness(files, wanted) {
+  const words = new Set(wordsOf(wanted));
+  const shared = (file) => wordsOf(parentOf(file.path)).filter((word) => words.has(word)).length;
+  return files.map((file) => ({ file, shared: shared(file) })).sort((a, b) => b.shared - a.shared || (a.file.path < b.file.path ? -1 : a.file.path > b.file.path ? 1 : 0));
+}
+async function locate(source, repo, skill, listing) {
+  const wanted = normaliseName(skill);
+  const candidates = listing.files.filter((file) => skillFilesIn([file]).length === 1);
+  const guessed = candidates.filter((file) => normaliseName(directoryOf(file.path)) === wanted);
+  const others = candidates.filter((file) => !guessed.includes(file));
+  const read = async (files) => (await Promise.all(files.map(async (file) => ({ file, markdown: await source.file(repo, file.path) })))).filter((entry) => entry.markdown !== null && normaliseName(frontmatterName(entry.markdown) ?? "") === wanted);
+  let named = await read(guessed);
+  if (named.length === 0) {
+    if (others.length > MAX_SKILL_FILES_READ) {
+      return { status: "incomplete", reason: "too_many_skill_files" };
+    }
+    const nearest = byNearness(others, wanted).slice(0, MAX_NAME_READS);
+    const sharing = nearest.filter((entry) => entry.shared > 0).length;
+    let readTo = 0;
+    while (readTo < nearest.length && named.length === 0) {
+      const size = readTo < sharing ? sharing - readTo : NAME_BATCH;
+      named = await read(nearest.slice(readTo, readTo + size).map((entry) => entry.file));
+      readTo += size;
+    }
+    if (named.length > 0) {
+      named = [...named, ...await read(nearest.slice(readTo, sharing).map((entry) => entry.file))];
+    } else if (nearest.length < others.length) {
+      return { status: "incomplete", reason: "too_many_skill_files" };
+    }
+  }
+  if (named.length === 0) {
+    if (listing.truncated)
+      return { status: "incomplete", reason: "truncated_listing" };
+    return { status: "absent", skillFiles: candidates.length };
+  }
+  const ranked = named.map((entry) => ({ ...entry, rank: installerRank(entry.file.path) })).sort((a, b) => (a.rank ?? Infinity) - (b.rank ?? Infinity));
+  const [first, ...rest] = ranked;
+  if (first === undefined)
+    return { status: "absent", skillFiles: candidates.length };
+  const differs = rest.filter((entry) => entry.file.sha !== first.file.sha);
+  if (first.rank === null && differs.length > 0) {
+    return { status: "ambiguous", paths: ranked.map((entry) => entry.file.path) };
+  }
+  return {
+    status: "found",
+    file: first.file,
+    markdown: first.markdown,
+    alsoAt: rest.filter((entry) => entry.file.sha === first.file.sha).map((entry) => entry.file.path),
+    differsAt: differs.map((entry) => entry.file.path)
+  };
+}
+function usualPaths(skill) {
+  return [`skills/${skill}/SKILL.md`, `${skill}/SKILL.md`, `.claude/skills/${skill}/SKILL.md`, "SKILL.md"];
+}
+async function readFileOnly(result, source) {
+  if (!/^[\w.-]+$/.test(result.skill) || /^\.+$/.test(result.skill))
+    return null;
+  const wanted = normaliseName(result.skill);
+  for (const path of usualPaths(result.skill)) {
+    const markdown = await source.file(result.source, path);
+    if (markdown === null || normaliseName(frontmatterName(markdown) ?? "") !== wanted)
+      continue;
+    const { keys, paidWords, hosts, requires, contains } = readSkillFacts(markdown, []);
+    return { ...result, status: "read_file_only", path, keys, paidWords, hosts, requires, contains };
+  }
+  return null;
+}
+var SCRIPT_READ_CAP = { files: MAX_SCRIPTS_READ, bytesEach: 256 * 1024, bytes: 512 * 1024 };
+var NOT_CODE_DIRECTORY = /(^|\/)(examples?|assets?|fonts?|images?|media|samples?|fixtures?)\//i;
+function withinReadCap(paths, listed) {
+  const sizeOf = new Map(listed.map((file) => [file.path, file.size]));
+  const kept = [];
+  let bytes = 0;
+  for (const path of paths) {
+    const size = sizeOf.get(path) ?? 0;
+    if (kept.length >= SCRIPT_READ_CAP.files || NOT_CODE_DIRECTORY.test(path))
+      continue;
+    if (size > SCRIPT_READ_CAP.bytesEach || bytes + size > SCRIPT_READ_CAP.bytes)
+      continue;
+    kept.push(path);
+    bytes += size;
+  }
+  return kept;
+}
+async function readPulse(result, source, depth) {
+  if (!/^(?!\.{1,2}\/)[\w.-]+\/(?!\.{1,2}$)[\w.-]+$/.test(result.source))
+    return { ...result, status: "not_github" };
+  const listing = await source.listing(result.source);
+  if (listing === "rate_limited")
+    return await readFileOnly(result, source) ?? { ...result, status: "rate_limited" };
+  if (listing === "unreachable")
+    return { ...result, status: "repository_unreachable" };
+  const located = await locate(source, result.source, result.skill, listing);
+  if (located.status === "absent")
+    return { ...result, status: "absent", skillFiles: located.skillFiles };
+  if (located.status === "ambiguous")
+    return { ...result, status: "ambiguous", paths: located.paths };
+  if (located.status === "incomplete")
+    return { ...result, status: "incomplete", reason: located.reason };
+  const directory = parentOf(located.file.path);
+  const prefix = directory === "" ? "" : `${directory}/`;
+  const inDirectory = listing.files.filter((file) => file.path.startsWith(prefix));
+  const scripts = withinReadCap(filesItRuns(located.markdown, listing.files), listing.files);
+  const scriptTexts = await Promise.all(scripts.map(async (file) => ({ file, text: await source.file(result.source, file) })));
+  const keysInScriptsItRuns = scriptTexts.map(({ file, text }) => ({ file, keys: [...new Set(text?.match(KEY_NAME2) ?? [])] })).filter((entry) => entry.keys.length > 0);
+  const relative = (path) => path.startsWith(prefix) ? path.slice(prefix.length) : path;
+  const fetched = new Set(scriptTexts.filter((entry) => entry.text !== null).map((entry) => entry.file));
+  const others = depth === undefined ? [] : await readDirectory(source, result.source, inDirectory, new Set([located.file.path, ...fetched]), depth.directory.by);
+  for (const file of others)
+    if (file.text !== null)
+      fetched.add(file.path);
+  const contains = readSkillContents([
+    { path: "SKILL.md", text: located.markdown },
+    ...scriptTexts.flatMap(({ file, text }) => text === null ? [] : [{ path: relative(file), text }]),
+    ...others.flatMap(({ path, text }) => text === null ? [] : [{ path: relative(path), text }]),
+    ...inDirectory.filter((file) => !fetched.has(file.path) && file.path !== located.file.path && (depth !== undefined || SCRIPT3.test(file.path))).map((file) => NOT_TEXT.test(file.path) ? { path: relative(file.path), text: null } : file.size > CONTENTS_LIMITS.fileChars ? { path: relative(file.path), text: null, notFetched: true, tooLarge: true } : { path: relative(file.path), text: null, notFetched: true })
+  ]);
+  return {
+    ...result,
+    status: "read",
+    path: located.file.path,
+    alsoAt: located.alsoAt,
+    differsAt: located.differsAt,
+    contentId: directory === "" ? listing.rootTreeId : listing.trees.get(directory) ?? located.file.sha,
+    skillMdSha: located.file.sha,
+    repository: await source.repository(result.source),
+    ...listing.readAt === undefined ? {} : { listingReadAt: listing.readAt },
+    ...readSkillFacts(located.markdown, inDirectory, listing.files),
+    keysInScriptsItRuns,
+    contains
+  };
+}
+async function readDirectory(source, repo, inDirectory, done, by) {
+  let late = false;
+  by.then(() => {
+    late = true;
+  });
+  const plan = inDirectory.filter((file) => !done.has(file.path) && !NOT_TEXT.test(file.path) && file.size <= CONTENTS_LIMITS.fileChars).slice(0, MAX_DIRECTORY_FILES_READ);
+  const out = [];
+  for (let at = 0;at < plan.length && !late; at += 8) {
+    const batch = Promise.all(plan.slice(at, at + 8).map(async (file) => ({ path: file.path, text: await source.file(repo, file.path).catch(() => null) })));
+    const settled = await Promise.race([batch, by.then(() => null)]);
+    if (settled === null)
+      break;
+    out.push(...settled);
+  }
+  return out;
+}
+function githubPulseSource(options = {}) {
+  const get = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? GITHUB_READ_TIMEOUT_MS;
+  const bounded2 = () => {
+    const limit = AbortSignal.timeout(timeoutMs);
+    return options.signal === undefined ? limit : AbortSignal.any([limit, options.signal]);
+  };
+  const headers = {
+    accept: "application/vnd.github+json",
+    "user-agent": "arp-pulse",
+    ...options.token === undefined ? {} : { authorization: `Bearer ${options.token}` }
+  };
+  const listings = new Map;
+  const repositories = new Map;
+  const fileReads = new Map;
+  const quota = { apiRequests: 0, limited: false, resetsAt: null };
+  const noteLimit = (response) => {
+    const hit = response.status === 429 || response.status === 403 && (response.headers.get("x-ratelimit-remaining") === "0" || response.headers.has("retry-after"));
+    if (!hit)
+      return false;
+    quota.limited = true;
+    const reset = Number(response.headers.get("x-ratelimit-reset"));
+    if (Number.isFinite(reset) && reset > 0)
+      quota.resetsAt = new Date(reset * 1000).toISOString();
+    return true;
+  };
+  const readListing = async (repo) => {
+    const cached = await options.cache?.get(repo).catch(() => null);
+    if (cached !== null && cached !== undefined)
+      return cached;
+    if (quota.limited)
+      return "rate_limited";
+    quota.apiRequests += 1;
+    const response = await get(`https://api.github.com/repos/${repo}/git/trees/HEAD?recursive=1`, { headers, signal: bounded2() });
+    if (noteLimit(response))
+      return "rate_limited";
+    if (!response.ok)
+      return "unreachable";
+    const body = await response.json();
+    const files = [];
+    const trees = new Map;
+    for (const entry of body.tree ?? []) {
+      if (typeof entry.path !== "string" || typeof entry.sha !== "string")
+        continue;
+      if (entry.type === "tree")
+        trees.set(entry.path, entry.sha);
+      if (entry.type === "blob") {
+        files.push({ path: entry.path, sha: entry.sha, size: typeof entry.size === "number" ? entry.size : 0 });
+      }
+    }
+    const listing = {
+      rootTreeId: typeof body.sha === "string" ? body.sha : "",
+      files,
+      trees,
+      truncated: body.truncated === true
+    };
+    await options.cache?.set(repo, listing).catch(() => {
+      return;
+    });
+    return listing;
+  };
+  const readRepository = async (repo) => {
+    if (options.withRepository === false || quota.limited)
+      return null;
+    quota.apiRequests += 1;
+    const response = await get(`https://api.github.com/repos/${repo}`, { headers, signal: bounded2() });
+    noteLimit(response);
+    if (!response.ok)
+      return null;
+    const body = await response.json();
+    return {
+      stars: typeof body.stargazers_count === "number" ? body.stargazers_count : 0,
+      pushedAt: typeof body.pushed_at === "string" ? body.pushed_at : null,
+      archived: body.archived === true
+    };
+  };
+  const once = (cache, repo, read) => {
+    const hit = cache.get(repo);
+    if (hit !== undefined)
+      return hit;
+    const started = read(repo);
+    cache.set(repo, started);
+    return started;
+  };
+  return {
+    listing: (repo) => once(listings, repo, readListing),
+    repository: (repo) => once(repositories, repo, readRepository),
+    file: (repo, path) => {
+      const key = `${repo}
+${path}`;
+      const kept = options.files?.get(key);
+      if (kept !== undefined)
+        return Promise.resolve(kept);
+      return once(fileReads, key, async () => {
+        const encoded = path.split("/").map(encodeURIComponent).join("/");
+        const response = await get(`https://raw.githubusercontent.com/${repo}/HEAD/${encoded}`, { signal: bounded2() });
+        const text = response.ok ? await response.text() : null;
+        if (response.ok || response.status === 404)
+          options.files?.set(key, text);
+        return text;
+      });
+    },
+    quota: () => ({ ...quota })
+  };
+}
+
+// ../../packages/protocol/src/before-install.ts
+var PAID_SERVICES = [
+  { name: "Anthropic", hosts: ["api.anthropic.com"], keyPrefixes: ["ANTHROPIC_"] },
+  { name: "AssemblyAI", hosts: ["api.assemblyai.com"], keyPrefixes: ["ASSEMBLYAI_"] },
+  { name: "Azure OpenAI", hosts: ["openai.azure.com"], keyPrefixes: ["AZURE_OPENAI_"] },
+  { name: "Brave Search", hosts: ["api.search.brave.com"], keyPrefixes: ["BRAVE_"] },
+  { name: "Browserbase", hosts: ["api.browserbase.com"], keyPrefixes: ["BROWSERBASE_"] },
+  { name: "Cohere", hosts: ["api.cohere.ai", "api.cohere.com"], keyPrefixes: ["COHERE_", "CO_API_"] },
+  { name: "Deepgram", hosts: ["api.deepgram.com"], keyPrefixes: ["DEEPGRAM_"] },
+  { name: "DeepSeek", hosts: ["api.deepseek.com"], keyPrefixes: ["DEEPSEEK_"] },
+  { name: "ElevenLabs", hosts: ["api.elevenlabs.io"], keyPrefixes: ["ELEVENLABS_", "ELEVEN_"] },
+  { name: "Exa", hosts: ["api.exa.ai"], keyPrefixes: ["EXA_"] },
+  { name: "fal", hosts: ["fal.run", "queue.fal.run"], keyPrefixes: ["FAL_"] },
+  { name: "Firecrawl", hosts: ["api.firecrawl.dev"], keyPrefixes: ["FIRECRAWL_"] },
+  { name: "Fireworks AI", hosts: ["api.fireworks.ai"], keyPrefixes: ["FIREWORKS_"] },
+  { name: "Google Gemini", hosts: ["generativelanguage.googleapis.com"], keyPrefixes: ["GEMINI_"] },
+  { name: "Google Vertex AI", hosts: ["aiplatform.googleapis.com"], keyPrefixes: ["VERTEX_"] },
+  { name: "Groq", hosts: ["api.groq.com"], keyPrefixes: ["GROQ_"] },
+  { name: "HeyGen", hosts: ["api.heygen.com"], keyPrefixes: ["HEYGEN_"] },
+  { name: "Mistral", hosts: ["api.mistral.ai"], keyPrefixes: ["MISTRAL_"] },
+  { name: "OpenAI", hosts: ["api.openai.com"], keyPrefixes: ["OPENAI_"] },
+  { name: "OpenRouter", hosts: ["openrouter.ai"], keyPrefixes: ["OPENROUTER_"] },
+  { name: "Perplexity", hosts: ["api.perplexity.ai"], keyPrefixes: ["PERPLEXITY_", "PPLX_"] },
+  { name: "Replicate", hosts: ["api.replicate.com"], keyPrefixes: ["REPLICATE_"] },
+  { name: "Resend", hosts: ["api.resend.com"], keyPrefixes: ["RESEND_"] },
+  { name: "Runway", hosts: ["api.dev.runwayml.com", "api.runwayml.com"], keyPrefixes: ["RUNWAY_", "RUNWAYML_"] },
+  { name: "SerpApi", hosts: ["serpapi.com"], keyPrefixes: ["SERPAPI_", "SERP_API_"] },
+  { name: "Stability AI", hosts: ["api.stability.ai"], keyPrefixes: ["STABILITY_"] },
+  { name: "Tavily", hosts: ["api.tavily.com"], keyPrefixes: ["TAVILY_"] },
+  { name: "Together AI", hosts: ["api.together.xyz", "api.together.ai"], keyPrefixes: ["TOGETHER_"] },
+  { name: "Twilio", hosts: ["api.twilio.com"], keyPrefixes: ["TWILIO_"] },
+  { name: "xAI", hosts: ["api.x.ai"], keyPrefixes: ["XAI_"] }
+];
+var STATIC_HOSTS = [
+  "fonts.googleapis.com",
+  "gstatic.com",
+  "cdn.jsdelivr.net",
+  "unpkg.com",
+  "cdnjs.cloudflare.com",
+  "esm.sh",
+  "cdn.skypack.dev",
+  "ga.jspm.io",
+  "githubusercontent.com",
+  "cdn.tailwindcss.com",
+  "code.jquery.com",
+  "use.typekit.net",
+  "fonts.bunny.net",
+  "rsms.me",
+  "cartocdn.com",
+  "tile.openstreetmap.org",
+  "server.arcgisonline.com",
+  "images.unsplash.com"
+];
+var STATIC_SHAPE = /^(?:cdn|static|fonts?|tiles?|assets|img|images|media)\d*[.-]|(?:^|[.-])cdn(?:[.-]|$)|\.cdn\./;
+var API_SHAPE = /^api\d*[.-]|[.-]api\.|^.*\.googleapis\.com$/;
+function under(host, base) {
+  return host === base || host.endsWith(`.${base}`);
+}
+var ASSET = /\.(woff2?|ttf|otf|eot|png|jpe?g|gif|webp|svgz?|ico|bmp|tiff?|avif|heic|hdr|exr|mp[34]|m4a|wav|ogg|flac|aac|mov|webm|avi|mkv|psd|ai|sketch|fig|glb|gltf|fbx|blend|ktx2?|basis|pdf|zip|gz|tgz)$|(^|\/)\.(gitkeep|keep|DS_Store)$/i;
+function beforeInstall(input) {
+  const services = new Map;
+  const service = (name) => {
+    const found = services.get(name) ?? { name, hosts: [], keys: [] };
+    services.set(name, found);
+    return found;
+  };
+  const apiHosts = [];
+  const staticHosts = [];
+  const otherHosts = [];
+  for (const host of input.domains) {
+    const known = PAID_SERVICES.find((entry) => entry.hosts.some((base) => under(host, base)));
+    if (known !== undefined) {
+      service(known.name).hosts.push(host);
+      apiHosts.push(host);
+    } else if (STATIC_HOSTS.some((base) => under(host, base)) || STATIC_SHAPE.test(host))
+      staticHosts.push(host);
+    else if (API_SHAPE.test(host))
+      apiHosts.push(host);
+    else
+      otherHosts.push(host);
+  }
+  for (const key of input.keys) {
+    if (key.why !== "secret")
+      continue;
+    const known = PAID_SERVICES.find((entry) => entry.keyPrefixes.some((prefix) => key.name.startsWith(prefix)));
+    if (known !== undefined)
+      service(known.name).keys.push(key.name);
+  }
+  const asked = new Set(input.keys.map((key) => key.name));
+  return {
+    fetchAndRun: [...input.fetchAndRun],
+    keys: [...input.keys],
+    otherSettings: input.settings.filter((name) => !asked.has(name)).length,
+    services: [...services.values()].sort((a, b) => a.name < b.name ? -1 : 1),
+    programs: [...input.programs],
+    scripts: [...input.scripts],
+    apiHosts,
+    staticHosts,
+    otherHosts,
+    hidden: [...input.hidden],
+    notRead: input.skipped.filter((file) => file.why !== "binary" && !ASSET.test(file.path)),
+    cut: [...input.cut]
+  };
+}
+var plural2 = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
+function programNames(programs, shown = 4) {
+  const names = programs.map((program) => program.name);
+  return names.length <= shown ? names.join(", ") : `${names.slice(0, shown).join(", ")} +${names.length - shown}`;
+}
+function beforeInstallSummary(view) {
+  const secrets = view.keys.filter((key) => key.why === "secret").length;
+  const toSet = view.keys.length - secrets;
+  const asks = secrets + toSet === 0 ? "no keys" : [secrets === 0 ? null : plural2(secrets, "key"), toSet === 0 ? null : plural2(toSet, "setting")].filter((part) => part !== null).join(", ");
+  return [
+    ...view.fetchAndRun.length === 0 ? [] : ["fetches and runs code"],
+    asks,
+    view.services.length === 0 ? "no paid services" : plural2(view.services.length, "paid service"),
+    view.programs.length === 0 ? "nothing to install named" : `needs ${programNames(view.programs)}`,
+    view.scripts.length === 0 ? "no scripts" : plural2(view.scripts.length, "script"),
+    ...view.hidden.length === 0 ? [] : [plural2(view.hidden.length, "hidden text", "hidden texts")],
+    ...view.notRead.length === 0 ? [] : [`${plural2(view.notRead.length, "file")} not read`]
+  ].join(" · ");
+}
+function programSourceText(program) {
+  const at = program.file === undefined ? "" : `${program.file}${program.line === undefined ? "" : `:${program.line}`}`;
+  switch (program.from) {
+    case "declared":
+      return "declared in SKILL.md";
+    case "runs":
+      return "run in SKILL.md";
+    case "interpreter":
+      return "script interpreter";
+    case "script":
+      return "a script checks for it or installs it";
+    case "spawned":
+      return `run by ${at}`;
+    case "package":
+      return `via ${program.via ?? "a package"}, ${at}`;
+    case "named as needed":
+      return `said to be needed, ${at}`;
+  }
+}
+function contentsLines(contents, perList = 6) {
+  const view = beforeInstall({ ...contents, skipped: contents.read.skipped });
+  const list = (items, cut2) => `${items.slice(0, perList).join(", ")}${items.length > perList || cut2 ? `, and ${Math.max(0, items.length - perList)}${cut2 ? "+" : ""} more` : ""}`;
+  const cut = (name) => view.cut.includes(name);
+  const at = (rows, name) => list(rows.map((row) => `${row.kind} at ${row.file}:${row.line} "${row.text}"`), cut(name));
+  const others = view.otherSettings === 0 ? "" : `; ${plural2(view.otherSettings, "other setting")} it reads`;
+  const hostParts = [
+    view.apiHosts.length === 0 ? "no API host" : list(view.apiHosts, false),
+    ...view.staticHosts.length === 0 ? [] : [`fonts, CDNs and map tiles: ${view.staticHosts.length}`],
+    ...view.otherHosts.length === 0 ? [] : [`other sites named: ${view.otherHosts.length}`]
+  ];
+  return [
+    `Before you install: ${beforeInstallSummary(view)}`,
+    ...view.fetchAndRun.length === 0 ? [] : [`Fetches and runs code: ${at(view.fetchAndRun, "fetchAndRun")}`],
+    `Asks for: ${view.keys.length === 0 ? `no keys${others}` : `${list(view.keys.map((key) => `${key.name} (${key.why === "secret" ? "" : "set in SKILL.md, "}${key.file}:${key.line})`), cut("keys"))}${others}`}`,
+    `Paid services: ${view.services.length === 0 ? "none named" : list(view.services.map((entry) => `${entry.name} (${[...entry.hosts, ...entry.keys].join(", ")})`), false)}`,
+    `Needs installed: ${view.programs.length === 0 ? "none named" : list(view.programs.map((program) => `${program.name} (${programSourceText(program)})`), cut("programs"))}`,
+    `Runs on your machine: ${view.scripts.length === 0 ? "no scripts" : `${plural2(view.scripts.length, "script")}: ${list(view.scripts.map((script) => script.namedInSkillMd ? `${script.path} (named in SKILL.md)` : script.path), cut("scripts"))}`}${view.fetchAndRun.length === 0 ? "; fetches and runs no code" : ""}`,
+    `Sends data to (hosts its files name, not shown to be contacted): ${hostParts.join("; ")}`,
+    ...view.hidden.length === 0 ? [] : [`Hidden or encoded text: ${at(view.hidden, "hidden")}`],
+    ...view.notRead.length === 0 ? [] : [`Not read: ${list(view.notRead.map((file) => `${file.path} (${file.why})`), false)}`]
+  ];
+}
+
+// ../../packages/protocol/src/skill-install.ts
+var MAX_SKILLS_READ = 3;
+var ADD = new Set(["add", "a", "install", "i"]);
+var RUNNERS = new Set(["npx", "pnpx", "bunx"]);
+async function namesUnder(install, source) {
+  const listing = await source.listing(install.repo);
+  if (listing === "rate_limited" || listing === "unreachable")
+    return listing;
+  const prefix = install.subpath === null ? "" : `${install.subpath}/`;
+  const files = skillFilesIn(listing.files).filter((file) => file.path.startsWith(prefix)).sort((a, b) => a.path.split("/").length - b.path.split("/").length || a.path.localeCompare(b.path));
+  const names = await Promise.all(files.slice(0, MAX_SKILLS_READ).map(async (file) => {
+    const markdown = await source.file(install.repo, file.path);
+    const parts = file.path.split("/");
+    return (markdown === null ? null : frontmatterName(markdown)) ?? parts.at(-2) ?? install.repo.split("/")[1] ?? "";
+  }));
+  return { names, total: files.length };
+}
+async function readSkillInstall(install, source, deadline, directoryBy = deadline) {
+  if (install.kind === "elsewhere")
+    return install;
+  const late = deadline.then(() => "late");
+  let names;
+  let total;
+  if (install.skills === "all") {
+    const found = await Promise.race([
+      namesUnder(install, source).catch(() => "unreachable"),
+      late
+    ]);
+    if (found === "late")
+      return {
+        kind: "github",
+        install,
+        readings: [],
+        notRead: 0,
+        listing: "no answer in time"
+      };
+    if (found === "rate_limited" || found === "unreachable") {
+      return { kind: "github", install, readings: [], notRead: 0, listing: found };
+    }
+    ({ names, total } = found);
+  } else {
+    names = install.skills.slice(0, MAX_SKILLS_READ);
+    total = install.skills.length;
+  }
+  const readings = await Promise.all(names.map(async (skill) => {
+    const pulse = readPulse({ source: install.repo, skill, installs: null, installsText: null, url: null }, source, { directory: { by: directoryBy } }).then((read) => ({ skill, pulse: read })).catch(() => ({ skill, pulse: null, why: "read failed" }));
+    const settled = await Promise.race([pulse, late]);
+    return settled === "late" ? { skill, pulse: null, why: "no answer in time" } : settled;
+  }));
+  return {
+    kind: "github",
+    install,
+    readings,
+    notRead: Math.max(0, total - names.length),
+    listing: null
+  };
+}
+var plural3 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function readingLines(repo, reading) {
+  const head = `${repo} · ${reading.skill}`;
+  const { pulse } = reading;
+  if (pulse === null)
+    return [
+      `${head}: not read (${reading.why === "no answer in time" ? "GitHub did not answer in time" : "the read failed"})`
+    ];
+  switch (pulse.status) {
+    case "read": {
+      const facts = [
+        `${pulse.path}`,
+        plural3(pulse.files, "file"),
+        ...pulse.repository === null ? [] : [
+          plural3(pulse.repository.stars, "star"),
+          ...pulse.repository.pushedAt === null ? [] : [`last push ${pulse.repository.pushedAt.slice(0, 10)}`],
+          ...pulse.repository.archived ? ["archived"] : []
+        ]
+      ];
+      return [
+        `${head} (${facts.join(", ")})`,
+        ...contentsLines(pulse.contains).map((line) => `  ${line}`),
+        ...pulse.differsAt.length === 0 ? [] : [`  Other files carry this name and differ: ${pulse.differsAt.join(", ")}`]
+      ];
+    }
+    case "read_file_only":
+      return [
+        `${head} (${pulse.path}; GitHub's hourly limit was reached, so SKILL.md alone was read, not its scripts)`,
+        ...contentsLines(pulse.contains).map((line) => `  ${line}`)
+      ];
+    case "absent":
+      return [
+        `${head}: no SKILL.md in the repository names it (${plural3(pulse.skillFiles, "skill file")} read)`
+      ];
+    case "ambiguous":
+      return [
+        `${head}: several files carry this name and differ, and which one installs is not knowable here: ${pulse.paths.join(", ")}`
+      ];
+    case "incomplete":
+      return [
+        `${head}: not read (${pulse.reason === "truncated_listing" ? "GitHub cut the repository's file list" : "too many skill files to search"})`
+      ];
+    case "rate_limited":
+      return [`${head}: not read (GitHub's hourly limit; GITHUB_TOKEN raises it)`];
+    case "repository_unreachable":
+      return [`${head}: not read (the repository did not answer)`];
+    case "not_github":
+      return [`${head}: not read (not a GitHub repository)`];
+  }
+}
+function skillInstallReport(read) {
+  const title = "ARP read this skill before the install (what its own files contain; facts, not a verdict):";
+  if (read.kind === "elsewhere") {
+    return `${title}
+${read.source}: not read (ARP reads GitHub sources only)`;
+  }
+  const { install } = read;
+  const lines = [title];
+  if (read.listing !== null) {
+    const why = read.listing === "rate_limited" ? "GitHub's hourly limit; GITHUB_TOKEN raises it" : read.listing === "no answer in time" ? "GitHub did not answer in time" : "the repository did not answer";
+    lines.push(`${install.repo}${install.subpath === null ? "" : `/${install.subpath}`}: not read (${why})`);
+  } else if (read.readings.length === 0) {
+    lines.push(`${install.repo}${install.subpath === null ? "" : `/${install.subpath}`}: no SKILL.md found`);
+  }
+  for (const reading of read.readings)
+    lines.push(...readingLines(install.repo, reading));
+  if (read.notRead > 0)
+    lines.push(`${plural3(read.notRead, "more skill")} in this install not read (ARP reads ${MAX_SKILLS_READ})`);
+  if (install.ref !== null)
+    lines.push(`Read at the default branch's HEAD; the command names ${install.ref}.`);
+  return lines.join(`
+`);
+}
+
+// src/check.ts
+var CHECK_BUDGET_MS = 8000;
+var WHERE = "Intuition testnet 13579";
+var IN_CONTEXT_OF = _13579_default.arp.endpointBinding.inContextOf;
+var PAYERS = [_13579_default.arp.deployer, _13579_default.arp.sponsor];
+function skillRefOf(arg) {
+  const part = /^[\w.-]+$/;
+  const fromUrl = /^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/?\?skill=([^&#]+)$/.exec(arg.trim());
+  if (fromUrl !== null) {
+    const skill = decodeURIComponent(fromUrl[3] ?? "");
+    return part.test(skill) ? { repo: `${fromUrl[1]}/${fromUrl[2]}`, skill } : null;
+  }
+  const pieces = arg.trim().split("/");
+  if (pieces.length !== 3 || !pieces.every((piece) => part.test(piece)))
+    return null;
+  return { repo: `${pieces[0]}/${pieces[1]}`, skill: pieces[2] ?? "" };
+}
+function neededNames(usage) {
+  const byName = new Map;
+  for (const row of usage?.declarations ?? []) {
+    for (const line of row.lines) {
+      if (line.outcome !== "failed")
+        continue;
+      for (const name of line.needs ?? []) {
+        byName.set(name, (byName.get(name) ?? new Set).add(row.writer.toLowerCase()));
+      }
+    }
+  }
+  return new Map([...byName].map(([name, wallets]) => [name, wallets.size]));
+}
+function thisMachine(env = process.env, platform = process.platform) {
+  const dirs = (env["PATH"] ?? "").split(delimiter).filter((dir) => dir !== "");
+  const exts = platform === "win32" ? (env["PATHEXT"] ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  return {
+    hasProgram: (name) => dirs.some((dir) => exts.some((ext) => {
+      const path = join(dir, name + ext);
+      try {
+        return existsSync(path) && statSync(path).isFile();
+      } catch {
+        return false;
+      }
+    })),
+    hasVariable: (name) => (env[name] ?? "") !== ""
+  };
+}
+function namedInFiles(read) {
+  if (read.kind !== "github")
+    return [];
+  const names = new Set;
+  for (const reading of read.readings) {
+    const pulse = reading.pulse;
+    if (pulse === null || pulse.status !== "read")
+      continue;
+    for (const program of pulse.contains.programs)
+      names.add(program.name);
+    for (const setting of pulse.contains.settings)
+      names.add(setting);
+  }
+  return [...names];
+}
+var stateOf = (name, machine) => {
+  if (KEY_NAME.test(name))
+    return machine.hasVariable(name) ? "set" : "not set";
+  if (PROGRAM_NAME.test(name))
+    return machine.hasProgram(name) ? "found on PATH" : "missing here";
+  return "not checked";
+};
+function hereLines(needed, named, machine) {
+  const fromFiles = [...new Set(named)].filter((name) => !needed.has(name)).sort((a, b) => a.localeCompare(b));
+  if (needed.size === 0 && fromFiles.length === 0)
+    return ["Here: nothing named to check."];
+  const lines = ["Here (checked on this machine, nothing sent):"];
+  const wallets = (n) => `${n} wallet${n === 1 ? "" : "s"}`;
+  for (const [name, n] of [...needed].sort(([a, x], [b, y]) => y - x || a.localeCompare(b))) {
+    lines.push(`  ${name}: ${stateOf(name, machine)} (needed when it failed, ${wallets(n)})`);
+  }
+  for (const name of fromFiles)
+    lines.push(`  ${name}: ${stateOf(name, machine)} (named in its files)`);
+  return lines;
+}
+async function checkSkill(ref, deps) {
+  const budgetMs = deps.budgetMs ?? CHECK_BUDGET_MS;
+  const token = (deps.env["GITHUB_TOKEN"] ?? deps.env["GH_TOKEN"])?.trim() || undefined;
+  const deadline = new Promise((resolve) => setTimeout(resolve, budgetMs).unref?.());
+  const source = githubPulseSource({
+    ...deps.fetch === undefined ? {} : { fetch: deps.fetch },
+    ...token === undefined ? {} : { token },
+    timeoutMs: budgetMs + 500,
+    signal: AbortSignal.timeout(budgetMs + 500)
+  });
+  const contents = readSkillInstall({ kind: "github", repo: ref.repo, ref: null, subpath: null, skills: [ref.skill] }, source, deadline);
+  const url = `https://github.com/${ref.repo}?skill=${encodeURIComponent(ref.skill)}`;
+  const { uri, label } = skillAtom(url, (text) => createHash("sha256").update(text, "utf8").digest());
+  const usage = readSkillLines(uri, {
+    graphqlUrl: deps.env["INTUITION_GRAPHQL_URL"] ?? _13579_default.chain.graphqlUrl,
+    inContextOf: IN_CONTEXT_OF,
+    payers: PAYERS,
+    timeoutMs: budgetMs,
+    ...deps.fetch === undefined ? {} : { fetch: deps.fetch }
+  }).then((read2) => ({ ok: true, read: read2 }), () => ({ ok: false }));
+  const [read, lines] = await Promise.all([contents, usage]);
+  const blocks = [skillInstallReport(read)];
+  blocks.push(lines.ok ? linesSentence(lines.read, label, WHERE) ?? `Lines: no agent wrote an outcome on ${label} (${WHERE}).` : `Lines: not read (${WHERE} did not answer).`);
+  blocks.push(hereLines(lines.ok ? neededNames(lines.read) : new Map, namedInFiles(read), deps.machine).join(`
+`));
+  return `${blocks.join(`
+
+`)}
+`;
+}
+export {
+  thisMachine,
+  skillRefOf,
+  neededNames,
+  namedInFiles,
+  hereLines,
+  checkSkill,
+  CHECK_BUDGET_MS
+};