skyl.dev 0.1.0 → 0.1.2

package/dist/bin.js

@@ -1,4 +1,2267 @@
 #!/usr/bin/env node
-import { run } from "./cli.js";
+
+// ../core/src/types.ts
+var AXES = ["core", "language", "framework", "service", "topic"];
+
+// ../core/src/errors.ts
+var SkylError = class extends Error {
+  detail;
+  constructor(message, detail) {
+    super(detail ? `${message}
+  ${detail}` : message);
+    this.name = new.target.name;
+    this.detail = detail;
+  }
+};
+var SkillFormatError = class extends SkylError {
+};
+var ResolutionError = class extends SkylError {
+};
+var SourceError = class extends SkylError {
+};
+
+// ../core/src/parse.ts
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function stripQuotes(v) {
+  const t = v.trim();
+  if (t.length >= 2 && (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function inlineList(v) {
+  const inner = v.trim().slice(1, -1).trim();
+  if (inner === "") return [];
+  return inner.split(",").map(stripQuotes).filter((s) => s !== "");
+}
+function parseFrontmatter(text) {
+  const m = FRONTMATTER.exec(text);
+  if (!m) throw new SkillFormatError("no frontmatter", "a skill starts with a --- delimited block");
+  const out2 = {};
+  const lines = m[1].split("\n");
+  let currentKey = null;
+  let currentSub = null;
+  for (const raw of lines) {
+    if (raw.trim() === "" || raw.trimStart().startsWith("#")) continue;
+    const top = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(raw);
+    if (top && !/^\s/.test(raw)) {
+      const [, key, rest] = top;
+      currentKey = key;
+      currentSub = null;
+      const value = rest.trim();
+      if (value === "") out2[key] = {};
+      else if (value.startsWith("[")) out2[key] = inlineList(value);
+      else out2[key] = stripQuotes(value);
+      continue;
+    }
+    const nested = /^\s+([A-Za-z_][\w-]*):\s*(.*)$/.exec(raw);
+    if (nested && currentKey) {
+      const [, sub, rest] = nested;
+      const bucket = out2[currentKey] ??= {};
+      if (typeof bucket !== "object" || Array.isArray(bucket)) {
+        throw new SkillFormatError(`\`${currentKey}\` has both a value and nested keys`);
+      }
+      const value = rest.trim();
+      bucket[sub] = value.startsWith("[") ? inlineList(value) : value === "" ? [] : [stripQuotes(value)];
+      currentSub = sub;
+      continue;
+    }
+    const item = /^\s*-\s+(.*)$/.exec(raw);
+    if (item && currentKey) {
+      const value = stripQuotes(item[1]);
+      const bucket = out2[currentKey];
+      if (Array.isArray(bucket)) bucket.push(value);
+      else if (currentSub && bucket && typeof bucket === "object") {
+        (bucket[currentSub] ??= []).push(value);
+      } else out2[currentKey] = [value];
+      continue;
+    }
+  }
+  return out2;
+}
+function body(text) {
+  const m = FRONTMATTER.exec(text);
+  return m ? text.slice(m[0].length) : text;
+}
+function sections(markdown) {
+  const out2 = /* @__PURE__ */ new Map();
+  const parts = markdown.split(/^## (.+)$/m);
+  for (let i = 1; i < parts.length; i += 2) {
+    out2.set(parts[i].trim(), (parts[i + 1] ?? "").trim());
+  }
+  return out2;
+}
+var RULE = /^- \*\*([A-Z0-9]+-\d+)\*\*\s+`(must|should)`/gm;
+function rules(markdown) {
+  const out2 = [];
+  for (const m of markdown.matchAll(RULE)) {
+    out2.push({ id: m[1], priority: m[2] });
+  }
+  return out2;
+}
+function requireString(fm, key) {
+  const v = fm[key];
+  if (typeof v !== "string" || v === "") {
+    throw new SkillFormatError(`frontmatter is missing \`${key}\``);
+  }
+  return v;
+}
+function list(fm, key) {
+  const v = fm[key];
+  if (v === void 0) return [];
+  if (Array.isArray(v)) return v;
+  throw new SkillFormatError(`\`${key}\` must be a list`);
+}
+function parseSkill(text) {
+  const fm = parseFrontmatter(text);
+  const md = body(text);
+  const name = requireString(fm, "name");
+  const slash = name.indexOf("/");
+  if (slash <= 0 || slash === name.length - 1) {
+    throw new SkillFormatError(`name \`${name}\` is not \`family/skill\``);
+  }
+  const axis = requireString(fm, "axis");
+  if (!AXES.includes(axis)) {
+    throw new SkillFormatError(`axis \`${axis}\` is not one of ${AXES.join(", ")}`);
+  }
+  const version = requireString(fm, "version");
+  if (!/^\d+\.\d+\.\d+$/.test(version)) {
+    throw new SkillFormatError(`version \`${version}\` is not semver`);
+  }
+  const agentSections = list(fm, "agent_sections");
+  if (agentSections.length === 0) {
+    throw new SkillFormatError("frontmatter is missing `agent_sections`", "nothing would be installed");
+  }
+  const detectRaw = fm["detect"];
+  const detect2 = detectRaw && typeof detectRaw === "object" && !Array.isArray(detectRaw) ? detectRaw : {};
+  const all = sections(md);
+  const installable = agentSections.map((s) => {
+    const heading = s.charAt(0).toUpperCase() + s.slice(1);
+    const found = all.get(heading) ?? all.get(s);
+    if (found === void 0) {
+      throw new SkillFormatError(
+        `\`agent_sections\` names \`${s}\` but the file has no \`## ${heading}\``
+      );
+    }
+    return `## ${heading}
+
+${found}`;
+  }).join("\n\n");
+  return {
+    name,
+    family: name.slice(0, slash),
+    skill: name.slice(slash + 1),
+    axis,
+    version,
+    requires: list(fm, "requires"),
+    agentSections,
+    retired: list(fm, "retired"),
+    detect: detect2,
+    authors: list(fm, "authors"),
+    rules: rules(md),
+    installable,
+    installableWords: installable.split(/\s+/).filter(Boolean).length,
+    raw: text
+  };
+}
+
+// ../core/src/match.ts
+function coordinate(value) {
+  const parts = value.split(":");
+  return parts.length >= 2 ? `${parts[0]}:${parts[1]}` : value;
+}
+function globToRegExp(glob) {
+  let out2 = "";
+  for (let i = 0; i < glob.length; i += 1) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          out2 += "(?:.*/)?";
+          i += 2;
+        } else {
+          out2 += ".*";
+          i += 1;
+        }
+      } else {
+        out2 += "[^/]*";
+      }
+    } else if (c === "?") out2 += "[^/]";
+    else if (".+^${}()|[]\\".includes(c)) out2 += `\\${c}`;
+    else out2 += c;
+  }
+  return new RegExp(`^${out2}$`);
+}
+var globCache = /* @__PURE__ */ new Map();
+function globMatch(pattern, path) {
+  let re = globCache.get(pattern);
+  if (!re) {
+    re = globToRegExp(pattern);
+    globCache.set(pattern, re);
+  }
+  const normalised = path.replace(/^\.\//, "").replace(/\\/g, "/");
+  return re.test(normalised) || re.test(`./${normalised}`.slice(2));
+}
+function strategyFor(key) {
+  if (key.endsWith("dependency") || key.endsWith("dependencies")) return "coordinate";
+  if (key === "file" || key.endsWith("_file") || key.endsWith("path")) return "glob";
+  return "exact";
+}
+function matches(key, wanted, signal) {
+  switch (strategyFor(key)) {
+    case "coordinate":
+      return coordinate(signal) === coordinate(wanted);
+    case "glob":
+      return globMatch(wanted, signal);
+    case "exact":
+      return signal === wanted || signal.includes(wanted);
+  }
+}
+
+// ../core/src/detect.ts
+function hits(detect2, signals) {
+  const found = [];
+  for (const [key, wanted] of Object.entries(detect2)) {
+    const present = signals[key];
+    if (!present || present.length === 0) continue;
+    for (const w of wanted) {
+      if (present.some((p) => matches(key, w, p))) found.push({ key, value: w });
+    }
+  }
+  return found;
+}
+function detect(skills, signals) {
+  const matched = [];
+  const families = /* @__PURE__ */ new Set();
+  for (const s of skills) {
+    if (Object.keys(s.detect).length === 0) continue;
+    const on2 = hits(s.detect, signals);
+    if (on2.length > 0) {
+      matched.push({ skill: s.name, on: on2 });
+      families.add(s.family);
+    }
+  }
+  for (const s of skills) {
+    if (s.axis !== "core" || !families.has(s.family)) continue;
+    if (matched.some((m) => m.skill === s.name)) continue;
+    matched.push({ skill: s.name, on: [{ key: "family", value: s.family }] });
+  }
+  return matched.sort((a, b) => a.skill.localeCompare(b.skill));
+}
+function unmatched(skills, matched) {
+  const taken = new Set(matched.map((m) => m.skill));
+  const families = new Set(matched.map((m) => m.skill.split("/")[0]));
+  return skills.filter((s) => !taken.has(s.name) && families.has(s.family)).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// ../core/src/resolve.ts
+function resolve(skills, requested) {
+  const byName = new Map(skills.map((s) => [s.name, s]));
+  const ordered = [];
+  const done = /* @__PURE__ */ new Set();
+  const path = [];
+  const visit = (name, from) => {
+    if (done.has(name)) return;
+    if (path.includes(name)) {
+      throw new ResolutionError(
+        "skills require each other in a cycle",
+        [...path.slice(path.indexOf(name)), name].join(" -> ")
+      );
+    }
+    const skill = byName.get(name);
+    if (!skill) {
+      throw new ResolutionError(
+        `unknown skill \`${name}\``,
+        from ? `required by \`${from}\`` : "not in the index"
+      );
+    }
+    path.push(name);
+    for (const dep of skill.requires) visit(dep, name);
+    path.pop();
+    done.add(name);
+    ordered.push(skill);
+  };
+  for (const name of requested) visit(name);
+  return ordered;
+}
+function implied(resolved, requested) {
+  const asked = new Set(requested);
+  return resolved.filter((s) => !asked.has(s.name));
+}
+
+// ../core/src/source.ts
+function directorySource(root, label = "directory") {
+  return {
+    name: `${label} (${root})`,
+    async load() {
+      const { readdir: readdir4, readFile: readFile9 } = await import("node:fs/promises");
+      const { join: join9 } = await import("node:path");
+      const out2 = [];
+      let families;
+      try {
+        families = (await readdir4(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+      } catch (cause) {
+        throw new SourceError(`cannot read ${root}`, String(cause));
+      }
+      for (const family of families) {
+        const dir = join9(root, family);
+        const entries = (await readdir4(dir, { withFileTypes: true })).filter((e) => e.isDirectory());
+        for (const entry of entries) {
+          const file = join9(dir, entry.name, "SKILL.md");
+          try {
+            out2.push(parseSkill(await readFile9(file, "utf8")));
+          } catch (cause) {
+            if (cause.code === "ENOENT") continue;
+            throw new SourceError(`cannot parse ${file}`, cause.message);
+          }
+        }
+      }
+      return out2;
+    }
+  };
+}
+function bundleSource(load, label) {
+  return {
+    name: label,
+    async load() {
+      const bundle = await load();
+      return Object.entries(bundle.skills).map(([name, raw]) => {
+        try {
+          return parseSkill(raw);
+        } catch (cause) {
+          throw new SourceError(`cannot parse \`${name}\` from ${label}`, cause.message);
+        }
+      });
+    }
+  };
+}
+function httpBundleSource(url, label = "remote") {
+  return bundleSource(async () => {
+    const res = await fetch(url, { headers: { accept: "application/json" } });
+    if (!res.ok) throw new SourceError(`${label} returned ${res.status}`, url);
+    return await res.json();
+  }, `${label} (${url})`);
+}
+async function firstAvailable(sources2) {
+  const failures = [];
+  for (const source of sources2) {
+    try {
+      const skills = await source.load();
+      if (skills.length > 0) return { skills, from: source };
+      failures.push(`${source.name}: empty`);
+    } catch (cause) {
+      failures.push(`${source.name}: ${cause.message}`);
+    }
+  }
+  throw new SourceError("no source could supply the registry", failures.join("\n  "));
+}
+
+// ../core/src/targets.ts
+var flat = (name) => name.replace("/", "-");
+var TARGETS = [
+  {
+    id: "claude",
+    dir: ".claude/skills",
+    fileFor: (name) => `${flat(name)}/SKILL.md`
+  },
+  {
+    id: "cursor",
+    dir: ".cursor/rules",
+    fileFor: (name) => `${flat(name)}.mdc`,
+    // Cursor decides when to apply a rule from its own frontmatter, so a skill that
+    // arrives without one is either always on or never on, depending on the version.
+    header: (name) => `---
+description: ${name}
+alwaysApply: false
+---
+
+`
+  },
+  { id: "windsurf", dir: ".windsurf/rules", fileFor: (name) => `${flat(name)}.md` },
+  { id: "continue", dir: ".continue/rules", fileFor: (name) => `${flat(name)}.md` },
+  { id: "agents", dir: ".agents/skills", fileFor: (name) => `${flat(name)}.md` }
+];
+var DEFAULT_TARGET = "claude";
+function targetById(id) {
+  return TARGETS.find((t) => t.id === id);
+}
+
+// ../core/src/lockfile.ts
+import { createHash } from "node:crypto";
+var LOCKFILE_NAME = "skyl.lock";
+function hashContent(text) {
+  return `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
+}
+function parseLockfile(text) {
+  const data = JSON.parse(text);
+  if (data.lockfileVersion !== 1) {
+    throw new Error(`unsupported lockfile version ${String(data.lockfileVersion)}`);
+  }
+  return data;
+}
+function formatLockfile(lock) {
+  const skills = {};
+  for (const name of Object.keys(lock.skills).sort()) skills[name] = lock.skills[name];
+  const ordered = { lockfileVersion: lock.lockfileVersion, target: lock.target, ...lock.source ? { source: lock.source } : {}, skills };
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+function entryFor(skill, installed, reason) {
+  return { version: skill.version, hash: hashContent(installed), reason };
+}
+function drift(entry, onDisk, upstream) {
+  if (!entry || onDisk === void 0) return "missing";
+  const localChanged = hashContent(onDisk) !== entry.hash;
+  const upstreamChanged = upstream !== void 0 && upstream.version !== entry.version;
+  if (localChanged && upstreamChanged) return "both";
+  if (localChanged) return "local-edit";
+  if (upstreamChanged) return "upstream-change";
+  return "unchanged";
+}
+
+// ../core/src/names.ts
+function normalise(skills, requested) {
+  const known = new Set(skills.map((s) => s.name));
+  const families = new Set(requested.filter((r) => r.includes("/")).map((r) => r.split("/")[0]));
+  return requested.map((raw) => {
+    const name = raw.trim();
+    if (name.includes("/")) {
+      if (!known.has(name)) throw new ResolutionError(`unknown skill \`${name}\``);
+      return name;
+    }
+    const inNamedFamily = skills.filter((s) => families.has(s.family) && s.skill === name);
+    if (inNamedFamily.length === 1) return inNamedFamily[0].name;
+    const anywhere = skills.filter((s) => s.skill === name);
+    if (anywhere.length === 1) return anywhere[0].name;
+    if (anywhere.length === 0) throw new ResolutionError(`unknown skill \`${name}\``);
+    throw new ResolutionError(
+      `\`${name}\` is ambiguous`,
+      `it exists in ${anywhere.map((s) => s.family).join(", ")}. Name the family.`
+    );
+  });
+}
+
+// ../core/src/diff.ts
+var MAX_CELLS = 4e6;
+function diffLines(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  if (a.length * b.length > MAX_CELLS) {
+    return [
+      ...a.map((text) => ({ kind: "-", text })),
+      ...b.map((text) => ({ kind: "+", text }))
+    ];
+  }
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head += 1;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail += 1;
+  const midA = a.slice(head, a.length - tail);
+  const midB = b.slice(head, b.length - tail);
+  const table = Array.from({ length: midA.length + 1 }, () => new Array(midB.length + 1).fill(0));
+  for (let i2 = midA.length - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = midB.length - 1; j2 >= 0; j2 -= 1) {
+      table[i2][j2] = midA[i2] === midB[j2] ? table[i2 + 1][j2 + 1] + 1 : Math.max(table[i2 + 1][j2], table[i2][j2 + 1]);
+    }
+  }
+  const ops = a.slice(0, head).map((text) => ({ kind: " ", text }));
+  let i = 0;
+  let j = 0;
+  while (i < midA.length && j < midB.length) {
+    if (midA[i] === midB[j]) {
+      ops.push({ kind: " ", text: midA[i] });
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      ops.push({ kind: "-", text: midA[i] });
+      i += 1;
+    } else {
+      ops.push({ kind: "+", text: midB[j] });
+      j += 1;
+    }
+  }
+  while (i < midA.length) {
+    ops.push({ kind: "-", text: midA[i] });
+    i += 1;
+  }
+  while (j < midB.length) {
+    ops.push({ kind: "+", text: midB[j] });
+    j += 1;
+  }
+  for (const text of a.slice(a.length - tail)) ops.push({ kind: " ", text });
+  return ops;
+}
+function hunks(ops, context2 = 3) {
+  const changed = ops.map((o) => o.kind !== " ");
+  if (!changed.some(Boolean)) return [];
+  const keep = new Array(ops.length).fill(false);
+  for (let i = 0; i < ops.length; i += 1) {
+    if (!changed[i]) continue;
+    for (let j = Math.max(0, i - context2); j <= Math.min(ops.length - 1, i + context2); j += 1) {
+      keep[j] = true;
+    }
+  }
+  const out2 = [];
+  let beforeLine = 1;
+  let afterLine = 1;
+  let current;
+  for (let i = 0; i < ops.length; i += 1) {
+    const op = ops[i];
+    if (keep[i]) {
+      current ??= { lines: [], beforeStart: beforeLine, afterStart: afterLine };
+      current.lines.push(op);
+    } else if (current) {
+      out2.push(close(current));
+      current = void 0;
+    }
+    if (op.kind !== "+") beforeLine += 1;
+    if (op.kind !== "-") afterLine += 1;
+  }
+  if (current) out2.push(close(current));
+  return out2;
+}
+function close(c) {
+  return {
+    beforeStart: c.beforeStart,
+    beforeCount: c.lines.filter((l) => l.kind !== "+").length,
+    afterStart: c.afterStart,
+    afterCount: c.lines.filter((l) => l.kind !== "-").length,
+    lines: c.lines
+  };
+}
+function stat(ops) {
+  return {
+    added: ops.filter((o) => o.kind === "+").length,
+    removed: ops.filter((o) => o.kind === "-").length
+  };
+}
+
+// ../core/src/lint.ts
+var HUMAN_SECTIONS = ["Why", "Pitfalls", "Provenance"];
+var VAGUE = [
+  "appropriately",
+  "properly",
+  "as needed",
+  "as appropriate",
+  "when appropriate",
+  "best practice",
+  "best practices",
+  "if necessary",
+  "where possible",
+  "reasonable",
+  "clean code",
+  "well-structured",
+  "avoid unnecessary"
+];
+var lineOf = (text, needle) => {
+  const at = text.indexOf(needle);
+  return at < 0 ? void 0 : text.slice(0, at).split("\n").length;
+};
+function lintSkill(text, path) {
+  const found = [];
+  let skill;
+  try {
+    skill = parseSkill(text);
+  } catch (cause) {
+    const e = cause;
+    return [{ level: "error", message: e.message.split("\n")[0], ...e.detail ? { detail: e.detail } : {} }];
+  }
+  if (path) {
+    const parts = path.split(/[\\/]/).filter(Boolean);
+    const dir = parts.slice(-3, -1).join("/");
+    if (dir !== "" && dir !== skill.name) {
+      found.push({
+        level: "error",
+        message: `name \`${skill.name}\` does not match its path`,
+        detail: `the file lives in ${dir}/, so it can never be found by name`
+      });
+    }
+  }
+  const md = body(text);
+  const all = sections(md);
+  const offset = text.slice(0, text.length - md.length).split("\n").length - 1;
+  for (const s of HUMAN_SECTIONS) {
+    if (!all.has(s)) {
+      found.push({ level: "warn", message: `no \`## ${s}\` section`, detail: "required for a shipped skill" });
+    }
+  }
+  if (skill.rules.length === 0) {
+    found.push({
+      level: "error",
+      message: "no rules found",
+      detail: "a rule is `- **PREFIX-N** `must`: instruction`"
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of skill.rules) {
+    if (seen.has(rule.id)) {
+      found.push({ level: "error", message: `duplicate rule id \`${rule.id}\``, ...lineFor(md, rule.id, offset) });
+    }
+    seen.add(rule.id);
+  }
+  for (const id of skill.retired) {
+    if (!/^[A-Z0-9]+-\d+$/.test(id)) {
+      found.push({
+        level: "error",
+        message: `retired entry \`${id}\` is not a rule id`,
+        detail: "use the bare id, so reuse of it stays detectable"
+      });
+      continue;
+    }
+    if (seen.has(id)) {
+      found.push({
+        level: "error",
+        message: `retired id \`${id}\` is in use again`,
+        detail: "ids are never reused: published evidence points at the old one",
+        ...lineFor(md, id, offset)
+      });
+    }
+  }
+  for (const block of md.split(/^- \*\*/m).slice(1)) {
+    const id = /^([A-Z0-9]+-\d+)/.exec(block)?.[1];
+    if (!id) continue;
+    const at = lineFor(md, id, offset);
+    if (!block.includes("*Why:*")) {
+      found.push({ level: "warn", message: `${id}: no \`*Why:*\``, detail: "the reader cannot recognise the bug in the wild", ...at });
+    }
+    if (!block.includes("*Not when:*")) {
+      found.push({ level: "warn", message: `${id}: no \`*Not when:*\``, detail: "a rule with no stated boundary is applied everywhere", ...at });
+    }
+    const instruction = block.split("*Why:*")[0].toLowerCase();
+    for (const word of VAGUE) {
+      if (instruction.includes(word)) {
+        found.push({ level: "warn", message: `${id}: "${word}" is not decidable`, detail: "a reader cannot hold it against a file and answer yes or no", ...at });
+        break;
+      }
+    }
+  }
+  const dash = text.indexOf("\u2014");
+  if (dash >= 0) {
+    found.push({
+      level: "warn",
+      message: "em dash in the text",
+      detail: "use a comma, a full stop, or a colon",
+      line: text.slice(0, dash).split("\n").length
+    });
+  }
+  if (Object.keys(skill.detect).length === 0) {
+    found.push({
+      level: "warn",
+      message: "no `detect` block",
+      detail: "nothing will ever propose this skill, it can only be installed by name"
+    });
+  }
+  return found;
+}
+function lineFor(md, id, offset) {
+  const line = lineOf(md, `**${id}**`);
+  return line === void 0 ? {} : { line: line + offset };
+}
+var XREF = /`([a-z0-9-]+\/[a-z0-9-]+)\s+([A-Z0-9]+-\d+)`/g;
+function lintRegistry(skills) {
+  const out2 = /* @__PURE__ */ new Map();
+  const byName = new Map(skills.map((s) => [s.name, s]));
+  const ruleIds = new Map(
+    skills.map((s) => [s.name, /* @__PURE__ */ new Set([...s.rules.map((r) => r.id), ...s.retired])])
+  );
+  for (const skill of skills) {
+    const found = [];
+    for (const dep of skill.requires) {
+      if (!byName.has(dep)) {
+        found.push({ level: "error", message: `requires \`${dep}\`, which is not in the registry` });
+      }
+    }
+    for (const m of skill.raw.matchAll(XREF)) {
+      const [, target, rule] = m;
+      if (target === skill.name) continue;
+      const ids = ruleIds.get(target);
+      if (!ids) {
+        found.push({ level: "error", message: `cites \`${target} ${rule}\`, and \`${target}\` is not in the registry` });
+      } else if (!ids.has(rule)) {
+        found.push({ level: "error", message: `cites \`${target} ${rule}\`, which does not exist` });
+      }
+    }
+    if (found.length > 0) out2.set(skill.name, found);
+  }
+  return out2;
+}
+
+// ../core/src/audit.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "is",
+  "are",
+  "was",
+  "be",
+  "been",
+  "to",
+  "of",
+  "in",
+  "on",
+  "for",
+  "with",
+  "as",
+  "at",
+  "by",
+  "from",
+  "that",
+  "this",
+  "it",
+  "its",
+  "not",
+  "no",
+  "do",
+  "does",
+  "use",
+  "using",
+  "used",
+  "when",
+  "where",
+  "which",
+  "you",
+  "your",
+  "we",
+  "our",
+  "can",
+  "will",
+  "should",
+  "must",
+  "never",
+  "always",
+  "all",
+  "any",
+  "each",
+  "per",
+  "into",
+  "out",
+  "up",
+  "has",
+  "have",
+  "they",
+  "them",
+  "their",
+  "one",
+  "two",
+  "more",
+  "than",
+  "so",
+  "only",
+  "also"
+]);
+var words = (text) => text.toLowerCase().match(/[a-z][a-z0-9_.]{2,}/g)?.filter((w) => !STOP.has(w)) ?? [];
+var IMPERATIVE = /\b(must|never|always|do not|don't|avoid|prefer|require[sd]?|should|use\b)/i;
+function distinctive(skills) {
+  const perSkill = /* @__PURE__ */ new Map();
+  const documents = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const set = new Set(words(skill.installable));
+    perSkill.set(skill.name, set);
+    for (const term of set) documents.set(term, (documents.get(term) ?? 0) + 1);
+  }
+  const limit = Math.max(1, Math.floor(skills.length / 4));
+  const out2 = /* @__PURE__ */ new Map();
+  for (const [name, set] of perSkill) {
+    out2.set(name, new Set([...set].filter((t) => (documents.get(t) ?? 0) <= limit)));
+  }
+  return out2;
+}
+var SECRET = [
+  { what: "private key", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { what: "AWS access key", re: /\bAKIA[0-9A-Z]{16}\b/ },
+  { what: "Google API key", re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+  { what: "GitHub token", re: /\bgh[pousr]_[0-9A-Za-z]{36,}\b/ },
+  { what: "Slack token", re: /\bxox[abprs]-[0-9A-Za-z-]{10,}\b/ },
+  { what: "bearer token", re: /\b(?:bearer|authorization)\s*[:=]\s*["']?[A-Za-z0-9._-]{20,}/i },
+  { what: "assignment that looks like a secret", re: /\b(?:api[_-]?key|secret|password|passwd|token|credential)s?\s*[:=]\s*["'][^"'\s]{8,}["']/i }
+];
+var EXPECTS = [
+  { what: "placement, where new code goes", re: /\b(place|placement|goes in|belongs in|live[s]? in|directory structure|module layout)\b/i },
+  { what: "build, test or lint commands", re: /\b(\.\/gradlew|npm run|pnpm |yarn |make |pytest|cargo )/ },
+  { what: "entry points or flow names", re: /\b(entry point|starts (at|in)|flow|screen|endpoint)\b/i }
+];
+function scanSecrets(text) {
+  const out2 = [];
+  text.split("\n").forEach((line, i) => {
+    for (const s of SECRET) {
+      if (s.re.test(line)) {
+        out2.push({ line: i + 1, what: s.what });
+        break;
+      }
+    }
+  });
+  return out2;
+}
+function audit(text, skills) {
+  const secrets = scanSecrets(text);
+  const vocab = distinctive(skills);
+  const found = sections(text);
+  const parts = found.size > 0 ? [...found] : [["(whole file)", text]];
+  const reports = parts.map(([heading, content]) => {
+    const terms = words(content);
+    const unique = new Set(terms);
+    const overlaps = [];
+    for (const [name, set] of vocab) {
+      const hit = [...unique].filter((t) => set.has(t));
+      if (hit.length < 4) continue;
+      const share = hit.length / Math.max(unique.size, 1);
+      if (share < 0.04) continue;
+      overlaps.push({ skill: name, share, terms: hit.slice(0, 8) });
+    }
+    overlaps.sort((a, b) => b.share - a.share);
+    return {
+      heading,
+      words: content.split(/\s+/).filter(Boolean).length,
+      overlaps: overlaps.slice(0, 3),
+      noInstruction: !IMPERATIVE.test(content)
+    };
+  });
+  return {
+    words: text.split(/\s+/).filter(Boolean).length,
+    sections: reports,
+    missing: EXPECTS.filter((e) => !e.re.test(text)).map((e) => e.what),
+    secrets
+  };
+}
+
+// src/registry.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+var HERE = dirname(fileURLToPath(import.meta.url));
+var REMOTE = "https://skyl.dev/registry.json";
+function sources(opts) {
+  const list3 = [];
+  if (opts.dir) list3.push(directorySource(resolvePath(opts.dir), "local"));
+  const bundlePath = join(HERE, "..", "bundle.json");
+  const bundled = bundleSource(
+    async () => JSON.parse(await readFile(bundlePath, "utf8")),
+    "bundled"
+  );
+  const remote = httpBundleSource(REMOTE, "skyl.dev");
+  if (opts.refresh) list3.push(remote, bundled);
+  else if (existsSync(bundlePath)) list3.push(bundled, remote);
+  else list3.push(remote);
+  return list3;
+}
+async function loadRegistry(opts) {
+  const { skills, from } = await firstAvailable(sources(opts));
+  return { skills, from: from.name };
+}
+
+// src/install.ts
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+async function readLockfile(root) {
+  try {
+    return parseLockfile(await readFile2(join2(root, LOCKFILE_NAME), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function writeLockfile(root, lock) {
+  await writeFile(join2(root, LOCKFILE_NAME), formatLockfile(lock), "utf8");
+}
+function renderFor(target, skill) {
+  const header = target.header?.(skill.name, skill.version) ?? "";
+  return `${header}${skill.installable}
+`;
+}
+function pathFor(root, target, skill) {
+  return join2(root, target.dir, target.fileFor(skill.name));
+}
+async function readInstalled(root, target, skill) {
+  try {
+    return await readFile2(pathFor(root, target, skill), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function install(root, target, ordered, requested, existing) {
+  const lock = {
+    lockfileVersion: 1,
+    target: target.id,
+    skills: { ...existing?.target === target.id ? existing.skills : {} }
+  };
+  for (const skill of ordered) {
+    const file = pathFor(root, target, skill);
+    const text = renderFor(target, skill);
+    await mkdir(dirname2(file), { recursive: true });
+    await writeFile(file, text, "utf8");
+    lock.skills[skill.name] = entryFor(
+      skill,
+      text,
+      requested.has(skill.name) ? "requested" : "required"
+    );
+  }
+  return lock;
+}
+function resolveTarget(id, lock) {
+  const wanted = id ?? lock?.target ?? DEFAULT_TARGET;
+  const target = targetById(wanted);
+  if (!target) {
+    throw new Error(`unknown target \`${wanted}\``);
+  }
+  return target;
+}
+
+// src/ui.ts
+var on = process.stdout.isTTY === true && !process.env["NO_COLOR"];
+var wrap = (code) => (s) => on ? `\x1B[${code}m${s}\x1B[0m` : s;
+var bold = wrap("1");
+var dim = wrap("2");
+var green = wrap("32");
+var yellow = wrap("33");
+var red = wrap("31");
+var cyan = wrap("36");
+function out(line = "") {
+  process.stdout.write(`${line}
+`);
+}
+function err(line) {
+  process.stderr.write(`${line}
+`);
+}
+function tokens(words2) {
+  return `~${(Math.round(words2 * 4 / 300) * 100).toLocaleString()} tokens`;
+}
+async function confirm(question, assumeYes) {
+  if (assumeYes) return true;
+  if (!process.stdin.isTTY) return false;
+  process.stdout.write(`${question} [y/N] `);
+  const answer = await new Promise((resolve2) => {
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (d) => resolve2(String(d)));
+    process.stdin.resume();
+  });
+  process.stdin.pause();
+  return /^y(es)?$/i.test(answer.trim());
+}
+
+// src/commands/add.ts
+async function add(opts) {
+  if (opts.names.length === 0) {
+    out(`${yellow("Nothing to add.")} Name a skill, or run ${bold("skyl scan")} to see what fits.`);
+    return 1;
+  }
+  const { skills } = await loadRegistry({ dir: opts.dir, refresh: opts.refresh });
+  const requested = normalise(skills, opts.names);
+  const ordered = resolve(skills, requested);
+  const extra = implied(ordered, requested);
+  const lock = await readLockfile(opts.root);
+  const target = resolveTarget(opts.target, lock);
+  const already = new Set(Object.keys(lock?.skills ?? {}));
+  out();
+  for (const skill of ordered) {
+    const state = already.has(skill.name) ? dim("reinstall") : green("install");
+    const why = extra.some((e) => e.name === skill.name) ? dim("required by another skill") : "";
+    out(`    ${bold(skill.name.padEnd(22))} ${skill.version.padEnd(8)} ${state.padEnd(18)} ${why}`);
+  }
+  const words2 = ordered.reduce((n, s) => n + s.installableWords, 0);
+  out();
+  out(`  ${ordered.length} skills, ${tokens(words2)} ${dim(`into ${target.dir}`)}`);
+  out();
+  if (!await confirm("  Write them?", opts.yes === true)) {
+    out(`  ${dim("Nothing written.")}`);
+    return 1;
+  }
+  const next = await install(opts.root, target, ordered, new Set(requested), lock);
+  await writeLockfile(opts.root, next);
+  out();
+  out(`  ${green("Done.")} ${dim("Recorded in skyl.lock.")}`);
+  out();
+  return 0;
+}
+
+// src/commands/audit.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join3, relative } from "node:path";
+var CANDIDATES = [
+  "CLAUDE.md",
+  ".claude/CLAUDE.md",
+  "AGENTS.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".github/copilot-instructions.md",
+  ".continue/rules.md",
+  ".aider.conf.yml"
+];
+async function audit2(opts) {
+  let path = opts.file;
+  if (!path) {
+    for (const c of CANDIDATES) {
+      const full = join3(opts.root, c);
+      if (await readFile3(full, "utf8").then(() => true, () => false)) {
+        path = full;
+        break;
+      }
+    }
+  } else if (!path.startsWith("/")) {
+    path = join3(opts.root, path);
+  }
+  if (!path) {
+    out(`  ${yellow("No hand-written context file found.")}`);
+    out(`  ${dim(`Looked for ${CANDIDATES.slice(0, 4).join(", ")}`)}`);
+    return 1;
+  }
+  const text = await readFile3(path, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    out(`  ${red("Cannot read")} ${path}`);
+    return 1;
+  }
+  const { skills } = await loadRegistry({ dir: opts.dir, refresh: opts.refresh });
+  const lock = await readLockfile(opts.root);
+  const installed = new Set(Object.keys(lock?.skills ?? {}));
+  const report = audit(text, skills);
+  out();
+  out(`  ${bold(relative(opts.root, path) || path)} ${dim(`${report.words} words, ${tokens(report.words)}`)}`);
+  out();
+  if (report.secrets.length > 0) {
+    out(`  ${red("Possible credentials.")} ${dim("these reach the model with every request")}`);
+    for (const s of report.secrets) out(`    ${red("!")} line ${s.line}, ${s.what}`);
+    out();
+  }
+  let flagged = 0;
+  for (const section of report.sections) {
+    const notes = [];
+    for (const o of section.overlaps) {
+      const state = installed.has(o.skill) ? "installed" : "in the registry";
+      notes.push(`${yellow("~")} shares vocabulary with ${bold(o.skill)} ${dim(`(${state}: ${o.terms.slice(0, 6).join(", ")})`)}`);
+    }
+    if (section.noInstruction && section.words > 40) {
+      notes.push(`${yellow("~")} no instruction in it ${dim("nothing to follow, and the agent can read the code itself")}`);
+    }
+    if (notes.length === 0) continue;
+    flagged += 1;
+    out(`  ${bold(section.heading)} ${dim(`${section.words} words`)}`);
+    for (const n of notes) out(`    ${n}`);
+    out();
+  }
+  if (report.missing.length > 0) {
+    out(`  ${dim("Not found in the file")}`);
+    for (const m of report.missing) out(`    ${dim("o")} ${m}`);
+    out();
+  }
+  if (flagged === 0 && report.secrets.length === 0) {
+    out(`  ${green("Nothing to flag.")} ${dim("no overlap with the registry, and every section carries an instruction")}`);
+    out();
+    return 0;
+  }
+  out(`  ${dim("Overlap is word overlap, not a judgement. Read the section before cutting it.")}`);
+  out(`  ${cyan("skyl scan")} ${dim("shows what the registry would install for this project.")}`);
+  out();
+  return 0;
+}
+
+// src/commands/context.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+
+// src/context.ts
+import { readdir as readdir2, readFile as readFile6, stat as stat2 } from "node:fs/promises";
+import { join as join6, relative as relative3, sep as sep2 } from "node:path";
+
+// src/ignore.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function toRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i += 1) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          source += "(?:.*/)?";
+          i += 2;
+        } else {
+          source += ".*";
+          i += 1;
+        }
+      } else source += "[^/]*";
+    } else if (c === "?") source += "[^/]";
+    else if ("\\^$.|+()[]{}".includes(c)) source += `\\${c}`;
+    else source += c;
+  }
+  return new RegExp(`^${source}$`);
+}
+function parseIgnore(text) {
+  const out2 = [];
+  for (const raw of text.split("\n")) {
+    let line = raw.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const negated = line.startsWith("!");
+    if (negated) line = line.slice(1);
+    const directoryOnly = line.endsWith("/");
+    if (directoryOnly) line = line.slice(0, -1);
+    const anchored = line.includes("/");
+    if (line.startsWith("/")) line = line.slice(1);
+    out2.push({ re: toRegExp(anchored ? line : `**/${line}`), negated, directoryOnly });
+  }
+  return out2;
+}
+async function loadIgnore(root, extra = []) {
+  const patterns = [];
+  for (const file of [".gitignore", ".skylignore"]) {
+    const text = await readFile4(join4(root, file), "utf8").catch(() => void 0);
+    if (text !== void 0) patterns.push(...parseIgnore(text));
+  }
+  patterns.push(...parseIgnore(extra.join("\n")));
+  return {
+    ignored(path, isDirectory) {
+      const parents = segments(path);
+      let result = false;
+      for (const p of patterns) {
+        const self = (!p.directoryOnly || isDirectory) && p.re.test(path);
+        const under = parents.some((s) => p.re.test(s));
+        if (self || under) result = !p.negated;
+      }
+      return result;
+    }
+  };
+}
+function segments(path) {
+  const parts = path.split("/");
+  return parts.slice(0, -1).map((_, i) => parts.slice(0, i + 1).join("/"));
+}
+
+// src/scan.ts
+import { readdir, readFile as readFile5 } from "node:fs/promises";
+import { join as join5, relative as relative2, sep } from "node:path";
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "build", ".git", ".gradle", ".idea", "dist", "out", ".kotlin"]);
+var MAX_DEPTH = 6;
+var BUILD_FILES = ["build.gradle.kts", "build.gradle", "settings.gradle.kts", "settings.gradle"];
+var CATALOGS = ["libs.versions.toml"];
+async function walk(root, depth = 0, acc = []) {
+  if (depth > MAX_DEPTH) return acc;
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    if (e.name.startsWith(".") && e.name !== ".claude") {
+      if (SKIP.has(e.name)) continue;
+    }
+    if (SKIP.has(e.name)) continue;
+    const full = join5(root, e.name);
+    if (e.isDirectory()) await walk(full, depth + 1, acc);
+    else acc.push(full);
+  }
+  return acc;
+}
+var DEP = /["']([a-zA-Z][\w.-]*(?:\.[\w-]+)+:[\w.-]+)(?::[^"']*)?["']/g;
+var PLUGIN_ID = /id\s*\(?\s*["']([\w.-]+)["']/g;
+var PLUGIN_ALIAS = /^\s*([\w-]+)\s*=\s*\{[^}]*id\s*=\s*["']([\w.-]+)["']/gm;
+var TOML_DEP = /^\s*[\w-]+\s*=\s*\{[^}]*module\s*=\s*["']([\w.:-]+)["']/gm;
+var TOML_GROUP = /^\s*[\w-]+\s*=\s*\{[^}]*group\s*=\s*["']([\w.-]+)["'][^}]*name\s*=\s*["']([\w.-]+)["']/gm;
+async function scanProject(root) {
+  const files = await walk(root);
+  const rel = files.map((f) => relative2(root, f).split(sep).join("/"));
+  const dependencies = /* @__PURE__ */ new Set();
+  const plugins = /* @__PURE__ */ new Set();
+  const manifestElements = /* @__PURE__ */ new Set();
+  const manifestAttributes = /* @__PURE__ */ new Set();
+  const properties = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const name = f.split(sep).pop();
+    const isBuild = BUILD_FILES.includes(name);
+    const isCatalog = CATALOGS.includes(name);
+    const isManifest = name === "AndroidManifest.xml";
+    const isProps = name === "gradle.properties";
+    if (!isBuild && !isCatalog && !isManifest && !isProps) continue;
+    let text;
+    try {
+      text = await readFile5(f, "utf8");
+    } catch {
+      continue;
+    }
+    if (isBuild || isCatalog) {
+      for (const m of text.matchAll(DEP)) dependencies.add(m[1]);
+      for (const m of text.matchAll(TOML_DEP)) dependencies.add(m[1]);
+      for (const m of text.matchAll(TOML_GROUP)) dependencies.add(`${m[1]}:${m[2]}`);
+      for (const m of text.matchAll(PLUGIN_ID)) plugins.add(m[1]);
+      for (const m of text.matchAll(PLUGIN_ALIAS)) plugins.add(m[2]);
+    }
+    if (isManifest) {
+      for (const m of text.matchAll(/<([a-zA-Z-]+)[\s>]/g)) manifestElements.add(m[1]);
+      for (const m of text.matchAll(/\s(android:[\w]+)\s*=/g)) manifestAttributes.add(m[1]);
+    }
+    if (isProps) {
+      for (const line of text.split("\n")) {
+        const eq = line.indexOf("=");
+        if (eq > 0 && !line.trimStart().startsWith("#")) properties.add(line.slice(0, eq).trim());
+      }
+    }
+  }
+  return {
+    file: rel,
+    gradle_dependency: [...dependencies],
+    gradle_plugin: [...plugins],
+    manifest_element: [...manifestElements],
+    manifest_attribute: [...manifestAttributes],
+    gradle_property: [...properties]
+  };
+}
+
+// src/context.ts
+var MAX_FILES = 40;
+var MAX_BYTES_PER_FILE = 16e3;
+var MAX_TOTAL_BYTES = 4e5;
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "build", ".git", ".gradle", ".idea", "dist", "out", "target", "vendor", ".next", ".venv"]);
+var DOC = /\.(md|mdx|adoc|rst)$/i;
+var SCHEMA = /\.(sql|graphql|gql|prisma|proto)$/i;
+var CODE = /\.(kt|kts|java|swift|ts|tsx|js|jsx|py|go|rb|rs|php|cs|dart|vue|svelte)$/i;
+var LOCKISH = /(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|Podfile\.lock|\.min\.js|\.map)$/i;
+var REASONS = [
+  { why: "documentation", weight: 100, test: (p, b) => DOC.test(b) && !/changelog|license|contributing|code_of_conduct/i.test(b) && (p.split("/").length <= 3 || /docs?\//i.test(p)) },
+  { why: "schema", weight: 90, test: (_p, b) => SCHEMA.test(b) },
+  // `AppModule.kt` starts like an entry point and is wiring, so the exclusion is explicit
+  { why: "entry point", weight: 80, test: (_p, b) => /^(Main|App|Application|index|main)[A-Za-z]*\.(kt|java|ts|tsx|js|jsx|py|go|swift|dart)$/.test(b) && !/(Module|Component|Config|Test)\./.test(b) || /Activity\.(kt|java)$/.test(b) },
+  { why: "dependency wiring", weight: 70, test: (p, b) => /(Module|Component|Injection|di)\.(kt|java|ts)$/.test(b) || /\/di\//.test(p) },
+  { why: "shared foundation", weight: 60, test: (p) => /(^|\/)(core|common|base|shared|lib)\//i.test(p) },
+  { why: "navigation or routing", weight: 55, test: (_p, b) => /(Nav|Navigation|Router|Routes|Screen)[A-Za-z]*\.(kt|java|ts|tsx)$/.test(b) },
+  { why: "data model", weight: 50, test: (p, b) => /(Entity|Dto|Model|Repository|Dao|Api|Service)\.(kt|java|ts)$/.test(b) || /\/(model|domain|entity)\//i.test(p) },
+  { why: "configuration", weight: 40, test: (_p, b) => /^(build\.gradle(\.kts)?|settings\.gradle(\.kts)?|libs\.versions\.toml|package\.json|pyproject\.toml|Cargo\.toml|go\.mod|Makefile|docker-compose\.ya?ml)$/.test(b) }
+];
+async function walk2(root, ignore) {
+  const out2 = [];
+  const step = async (dir, depth) => {
+    if (depth > 8) return;
+    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+      const full = join6(dir, entry.name);
+      const rel = relative3(root, full).split(sep2).join("/");
+      if (ignore.ignored(rel, entry.isDirectory())) continue;
+      if (entry.isDirectory()) await step(full, depth + 1);
+      else if (!LOCKISH.test(entry.name)) {
+        const info = await stat2(full).catch(() => void 0);
+        if (info) out2.push({ path: rel, bytes: info.size });
+      }
+    }
+  };
+  await step(root, 0);
+  return out2;
+}
+function renderTree(paths, limit = 500, perDirectory = 12) {
+  const byDir = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const at = p.lastIndexOf("/");
+    const dir = at < 0 ? "" : p.slice(0, at);
+    (byDir.get(dir) ?? byDir.set(dir, []).get(dir)).push(p.slice(at + 1));
+    for (let d = dir; d.includes("/"); d = d.slice(0, d.lastIndexOf("/"))) {
+      if (!byDir.has(d.slice(0, d.lastIndexOf("/")))) byDir.set(d.slice(0, d.lastIndexOf("/")), []);
+    }
+    if (dir !== "" && !byDir.has("")) byDir.set("", []);
+  }
+  const lines = [];
+  let shown = 0;
+  for (const dir of [...byDir.keys()].sort()) {
+    const depth = dir === "" ? 0 : dir.split("/").length;
+    if (dir !== "") lines.push(`${"  ".repeat(depth - 1)}${dir.split("/").pop()}/`);
+    const files = byDir.get(dir).sort();
+    for (const file of files.slice(0, perDirectory)) {
+      if (shown >= limit) break;
+      lines.push(`${"  ".repeat(depth)}${file}`);
+      shown += 1;
+    }
+    if (files.length > perDirectory) lines.push(`${"  ".repeat(depth)}... ${files.length - perDirectory} more files`);
+    if (shown >= limit) {
+      lines.push(`... ${paths.length - shown} more files`);
+      break;
+    }
+  }
+  return lines.join("\n");
+}
+async function buildContext(root, opts = {}) {
+  const ignore = await loadIgnore(root);
+  const all = await walk2(root, ignore);
+  const scored = [];
+  for (const file of all) {
+    const base = file.path.split("/").pop();
+    const reason = REASONS.find((r) => r.test(file.path, base));
+    if (!reason) continue;
+    if (!DOC.test(base) && !SCHEMA.test(base) && !CODE.test(base) && reason.why !== "configuration") continue;
+    scored.push({ path: file.path, why: reason.why, bytes: file.bytes, weight: reason.weight });
+  }
+  scored.sort((a, b) => b.weight - a.weight || b.bytes - a.bytes);
+  const limit = opts.maxFiles ?? MAX_FILES;
+  const files = [];
+  const withheld = [];
+  let total = 0;
+  for (const pick of scored) {
+    if (files.length >= limit || total >= MAX_TOTAL_BYTES) break;
+    const text = await readFile6(join6(root, pick.path), "utf8").catch(() => void 0);
+    if (text === void 0) continue;
+    const secrets = scanSecrets(text);
+    if (secrets.length > 0) {
+      withheld.push({ path: pick.path, why: `${secrets[0].what} on line ${secrets[0].line}` });
+      continue;
+    }
+    const truncated = text.length > MAX_BYTES_PER_FILE;
+    const body2 = truncated ? `${text.slice(0, MAX_BYTES_PER_FILE)}
+... truncated` : text;
+    total += body2.length;
+    files.push({ path: pick.path, why: pick.why, bytes: pick.bytes, text: body2, truncated });
+  }
+  return {
+    root,
+    tree: renderTree(all.map((f) => f.path)),
+    signals: await scanProject(root),
+    installed: opts.installed ?? [],
+    files,
+    withheld
+  };
+}
+function renderContext(bundle) {
+  const parts = [];
+  parts.push("# Project context bundle\n");
+  parts.push(`Collected by \`skyl context\` from \`${bundle.root}\`. Files were selected by rule, not by a model.
+`);
+  parts.push("## Directory tree\n");
+  parts.push("```\n" + bundle.tree + "\n```\n");
+  const signals = Object.entries(bundle.signals).filter(([, v]) => v.length > 0);
+  if (signals.length > 0) {
+    parts.push("## What the build declares\n");
+    for (const [key, values] of signals) {
+      parts.push(`**${key}**
+`);
+      parts.push(values.map((v) => `- ${v}`).join("\n") + "\n");
+    }
+  }
+  if (bundle.installed.length > 0) {
+    parts.push("## Skills already installed\n");
+    parts.push("Do not restate anything these cover.\n");
+    parts.push(bundle.installed.map((s) => `- ${s}`).join("\n") + "\n");
+  }
+  parts.push("## Files\n");
+  for (const file of bundle.files) {
+    parts.push(`### ${file.path}
+`);
+    parts.push(`_selected as ${file.why}${file.truncated ? ", truncated" : ""}_
+`);
+    parts.push("```\n" + file.text.replace(/```/g, "``\u200B`") + "\n```\n");
+  }
+  if (bundle.withheld.length > 0) {
+    parts.push("## Withheld\n");
+    parts.push("These matched the selection rules and were not included.\n");
+    parts.push(bundle.withheld.map((w) => `- ${w.path}, ${w.why}`).join("\n") + "\n");
+  }
+  return parts.join("\n");
+}
+
+// src/commands/context.ts
+async function context(opts) {
+  const lock = await readLockfile(opts.root);
+  const bundle = await buildContext(opts.root, {
+    installed: Object.keys(lock?.skills ?? {}),
+    ...opts.maxFiles === void 0 ? {} : { maxFiles: opts.maxFiles }
+  });
+  if (opts.dryRun === true) {
+    out();
+    out(`  ${bold("Would send")} ${dim(`${bundle.files.length} files`)}`);
+    out();
+    for (const file of bundle.files) {
+      out(`    ${file.path.padEnd(52)} ${dim(`${file.why}${file.truncated ? ", truncated" : ""}`)}`);
+    }
+    if (bundle.withheld.length > 0) {
+      out();
+      out(`  ${yellow("Withheld")}`);
+      for (const w of bundle.withheld) out(`    ${w.path.padEnd(52)} ${dim(w.why)}`);
+    }
+    const words2 = bundle.files.reduce((n, f) => n + f.text.split(/\s+/).length, 0);
+    out();
+    out(`  ${dim(`plus the directory tree and what the build declares, ${tokens(words2)}`)}`);
+    out();
+    return 0;
+  }
+  const text = opts.json === true ? `${JSON.stringify(bundle, null, 2)}
+` : renderContext(bundle);
+  if (opts.outFile) {
+    await writeFile2(opts.outFile, text, "utf8");
+    out(`  ${green("Written.")} ${opts.outFile} ${dim(`${bundle.files.length} files`)}`);
+    return 0;
+  }
+  process.stdout.write(text);
+  return 0;
+}
+
+// src/state.ts
+async function installedState(root, lock, target, opts) {
+  let registry;
+  let from;
+  try {
+    const reg = await loadRegistry(opts);
+    registry = new Map(reg.skills.map((s) => [s.name, s]));
+    from = reg.from;
+  } catch {
+  }
+  const items = [];
+  for (const name of Object.keys(lock.skills).sort()) {
+    const entry = lock.skills[name];
+    const skill = registry?.get(name);
+    const onDisk = skill ? await readInstalled(root, target, skill) : void 0;
+    items.push({
+      name,
+      entry,
+      skill,
+      onDisk,
+      upstream: skill ? renderFor(target, skill) : void 0,
+      state: registry === void 0 ? "unchanged" : drift(entry, onDisk, skill)
+    });
+  }
+  return { items, from };
+}
+function changedOnDisk(item) {
+  return item.upstream !== void 0 && item.onDisk !== item.upstream;
+}
+
+// src/commands/diff.ts
+function printDiff(item, full) {
+  if (item.upstream === void 0 || item.onDisk === void 0) return false;
+  const ops = diffLines(item.onDisk, item.upstream);
+  const { added, removed } = stat(ops);
+  if (added === 0 && removed === 0) return false;
+  const versions = item.skill && item.skill.version !== item.entry.version ? dim(`${item.entry.version} to ${item.skill.version}`) : dim(`${item.entry.version}, edited here`);
+  out();
+  out(`  ${bold(item.name)} ${versions}  ${green(`+${added}`)} ${red(`-${removed}`)}`);
+  out(`  ${dim("- what is in your file, + what upstream has")}`);
+  out();
+  for (const hunk of hunks(ops, full ? 999 : 3)) {
+    out(`  ${cyan(`@@ -${hunk.beforeStart},${hunk.beforeCount} +${hunk.afterStart},${hunk.afterCount} @@`)}`);
+    for (const line of hunk.lines) {
+      const text = `${line.kind} ${line.text}`;
+      out(`  ${line.kind === "+" ? green(text) : line.kind === "-" ? red(text) : dim(text)}`);
+    }
+  }
+  return true;
+}
+async function diff(opts) {
+  const lock = await readLockfile(opts.root);
+  if (!lock || Object.keys(lock.skills).length === 0) {
+    out(`${yellow("Nothing installed.")} Run ${bold("skyl scan")} to see what fits this project.`);
+    return 0;
+  }
+  const target = resolveTarget(void 0, lock);
+  const { items, from } = await installedState(opts.root, lock, target, {
+    dir: opts.dir,
+    refresh: opts.refresh ?? opts.dir === void 0
+  });
+  if (from === void 0) {
+    out(`  ${yellow("No registry reachable.")} ${dim("Nothing to compare against.")}`);
+    return 1;
+  }
+  const wanted = new Set(opts.names ?? []);
+  const subject = wanted.size === 0 ? items : items.filter((i) => wanted.has(i.name) || wanted.has(i.name.split("/")[1]));
+  if (subject.length === 0) {
+    out(`  ${yellow("Not installed here.")} ${dim([...wanted].join(", "))}`);
+    return 1;
+  }
+  let shown = 0;
+  for (const item of subject) {
+    if (item.skill === void 0) {
+      out();
+      out(`  ${bold(item.name)} ${yellow("is no longer in the registry")} ${dim("installed at " + item.entry.version)}`);
+      shown += 1;
+      continue;
+    }
+    if (item.onDisk === void 0) {
+      out();
+      out(`  ${bold(item.name)} ${yellow("file is gone")} ${dim(`skyl add ${item.name} puts it back`)}`);
+      shown += 1;
+      continue;
+    }
+    if (printDiff(item, opts.full === true)) shown += 1;
+  }
+  out();
+  if (shown === 0) {
+    out(`  ${green("Up to date.")} ${dim(`${subject.length} skills, nothing changed here or upstream`)}`);
+  } else {
+    const editable = subject.filter((i) => changedOnDisk(i) && i.state !== "local-edit").length;
+    if (editable > 0) out(`  ${cyan("skyl update")} ${dim("applies the upstream side")}`);
+  }
+  out();
+  return 0;
+}
+
+// src/commands/learn.ts
+import { spawn } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile7, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join7 } from "node:path";
+
+// src/learn.ts
+var LEARNED_NAME = "project/core";
+var MANUAL_SECTION = "Manual";
+var INSTRUCTIONS = `You are writing a project knowledge skill for an AI coding agent that will work in this
+repository. The context bundle below was selected mechanically, not by a model.
+
+Write **product knowledge**, not code quality advice. What the product is, what its terms mean, what
+its parts are called, where things live. A rule about Compose or coroutines belongs in a community
+skill and must not appear here.
+
+Include only what you can point at in the bundle:
+
+- **Glossary.** Domain terms and what they mean, with where each is defined. Usually the most
+  valuable section, and the one nothing else can supply.
+- **Features.** Modules and screens, and what each is called.
+- **Entities.** The data model and how the pieces relate.
+- **Integrations.** Third party services, and what each is used for.
+- **Flows.** Named flows and their entry points, such as "withdrawal starts at WithdrawFragment and
+  hits /api/withdraw".
+- **Placement.** Where a new screen, a new model, a new test goes.
+- **Commands.** Build, test, lint.
+
+Leave out:
+
+- Explanations of how code works. The agent reads the code faster than it reads a summary.
+- Architecture justification. One sentence for the choice, none for the argument.
+- Anything the installed skills already cover.
+- Secrets, credentials, environment structure. If you see one, say so and do not copy it.
+
+**Ask rather than assert.** Anything you cannot observe in the bundle is a question, never a claim.
+Collect the questions at the end of the file under \`## Questions\`, each as a line ending in
+\`<!-- unanswered -->\`. A business rule you inferred from a status enum is a question. This is the
+part that keeps the file from decaying: it improves each run instead of drifting.
+
+Output one markdown file and nothing else. No preamble, no explanation of what you did. Start at the
+frontmatter and use this shape:
+
+\`\`\`
+---
+name: project/core
+axis: topic
+family: project
+version: 1.0.0
+agent_sections: [rules]
+generated: <date>
+---
+
+## Rules
+
+- **PROJ-1** \`must\`: <instruction>
+  *Why:* <the failure it prevents>
+  *Not when:* <the boundary>
+
+## Glossary
+...
+## Questions
+- Can a withdrawal be cancelled after PROCESSING? <!-- unanswered -->
+\`\`\`
+`;
+function learnPrompt(bundle, keep) {
+  const parts = [INSTRUCTIONS];
+  if (keep.manual) {
+    parts.push(`
+## Text to carry over unchanged
+
+This was written by hand. Reproduce it verbatim as a \`## ${MANUAL_SECTION}\` section, and do not
+edit, summarise, or reorder it.
+
+\`\`\`
+${keep.manual}
+\`\`\`
+`);
+  }
+  if (keep.questions) {
+    parts.push(`
+## Questions still open from the last run
+
+Carry any that are still unanswered. Drop one only if the bundle now answers it.
+
+\`\`\`
+${keep.questions}
+\`\`\`
+`);
+  }
+  parts.push("\n---\n");
+  parts.push(renderContext(bundle));
+  return parts.join("\n");
+}
+function preserved(existing) {
+  if (!existing) return {};
+  const found = sections(existing);
+  const manual = found.get(MANUAL_SECTION);
+  const questions = found.get("Questions");
+  return {
+    ...manual ? { manual } : {},
+    ...questions ? { questions: questions.split("\n").filter((l) => l.includes("<!-- unanswered -->")).join("\n") } : {}
+  };
+}
+function extractMarkdown(output) {
+  const fenced = /```(?:markdown|md)?\n([\s\S]*?)```/.exec(output);
+  const text = (fenced?.[1] ?? output).trim();
+  const start = text.indexOf("---");
+  if (start < 0) return void 0;
+  return `${text.slice(start).trim()}
+`;
+}
+function reattach(generated, keep) {
+  let out2 = generated;
+  const found = sections(out2);
+  if (keep.manual && !found.has(MANUAL_SECTION)) {
+    out2 = `${out2.trimEnd()}
+
+## ${MANUAL_SECTION}
+
+${keep.manual}
+`;
+  }
+  if (keep.questions) {
+    const already = found.get("Questions") ?? "";
+    const missing = keep.questions.split("\n").filter((q) => q.trim() !== "" && !already.includes(q.trim()));
+    if (missing.length > 0) {
+      out2 = found.has("Questions") ? out2.replace(/^## Questions$/m, `## Questions
+
+${missing.join("\n")}`) : `${out2.trimEnd()}
+
+## Questions
+
+${missing.join("\n")}
+`;
+    }
+  }
+  return out2;
+}
+function caution(date, sha) {
+  return `<!--
+Generated by \`skyl learn\` on ${date}${sha ? ` from commit ${sha}` : ""}.
+Partly inferred from the repository. Correct anything wrong.
+Text under \`## ${MANUAL_SECTION}\` is written by hand and is preserved across refreshes.
+-->`;
+}
+function withCaution(markdown, date, sha) {
+  const note = caution(date, sha);
+  const end = /^---\r?\n[\s\S]*?\r?\n---\r?\n/.exec(markdown);
+  if (!end) return `${note}
+
+${markdown}`;
+  return `${markdown.slice(0, end[0].length)}
+${note}
+${markdown.slice(end[0].length)}`;
+}
+
+// src/commands/learn.ts
+var SHORTHAND = { claude: ["claude", "-p"] };
+async function learn(opts) {
+  const lock = await readLockfile(opts.root);
+  const target = resolveTarget(opts.target, lock);
+  const file = join7(opts.root, target.dir, target.fileFor(LEARNED_NAME));
+  const existing = await readFile7(file, "utf8").catch(() => void 0);
+  const keep = preserved(existing);
+  const bundle = await buildContext(opts.root, { installed: Object.keys(lock?.skills ?? {}) });
+  if (bundle.files.length === 0) {
+    err(`${yellow("Nothing to read here.")} No documentation, schema or source files were selected.`);
+    return 1;
+  }
+  const prompt = learnPrompt(bundle, keep);
+  if (opts.printPrompt === true || !opts.agent) {
+    if (opts.outFile) {
+      await writeFile3(opts.outFile, prompt, "utf8");
+      out(`  ${green("Written.")} ${opts.outFile}`);
+    } else {
+      process.stdout.write(prompt);
+    }
+    if (!opts.agent && opts.printPrompt !== true) {
+      err("");
+      err(`  ${dim("Paste this into any agent, or run")} ${cyan("skyl learn --agent claude")} ${dim("to do it here.")}`);
+    }
+    return 0;
+  }
+  const command = SHORTHAND[opts.agent] ?? opts.agent.split(" ");
+  out();
+  out(`  ${bold("Reading this project")} ${dim(`${bundle.files.length} files, ${tokens(prompt.split(/\s+/).length)}`)}`);
+  for (const w of bundle.withheld) out(`    ${yellow("withheld")} ${w.path} ${dim(w.why)}`);
+  out(`  ${dim(`through ${command.join(" ")}, which uses your own account`)}`);
+  out();
+  if (!await confirm(`  Send ${bundle.files.length} files to ${command[0]}?`, opts.yes === true)) {
+    out(`  ${dim("Nothing sent.")}`);
+    return 1;
+  }
+  const output = await pipeTo(command, prompt).catch((cause) => {
+    err(`  ${red("Could not run")} ${command.join(" ")}`);
+    err(`  ${dim(cause.message)}`);
+    return void 0;
+  });
+  if (output === void 0) return 1;
+  const generated = extractMarkdown(output);
+  if (!generated) {
+    err(`  ${red("No skill in the output.")} ${dim("Re-run with --print-prompt and paste it somewhere you can see the answer.")}`);
+    return 1;
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const sha = await gitSha(opts.root);
+  const text = withCaution(reattach(generated, keep), date, sha);
+  if (existing !== void 0) {
+    const history = join7(opts.root, ".skyl", "history", `project-core.${sha ?? date}.md`);
+    await mkdir2(dirname3(history), { recursive: true });
+    await writeFile3(history, existing, "utf8");
+  }
+  await mkdir2(dirname3(file), { recursive: true });
+  await writeFile3(file, text, "utf8");
+  const open = (text.match(/<!-- unanswered -->/g) ?? []).length;
+  out();
+  out(`  ${green(existing ? "Refreshed." : "Written.")} ${dim(file.replace(opts.root + "/", ""))}`);
+  if (keep.manual) {
+    const lines = keep.manual.split("\n").length;
+    out(`  ${dim(`## Manual carried over, ${lines} line${lines === 1 ? "" : "s"}`)}`);
+  }
+  if (open > 0) out(`  ${yellow(`${open} question${open === 1 ? "" : "s"}`)} ${dim("left for you, marked <!-- unanswered -->")}`);
+  out();
+  return 0;
+}
+function pipeTo(command, input) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command[0], command.slice(1), { stdio: ["pipe", "pipe", "inherit"] });
+    let stdout = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve2(stdout);
+      else reject(new Error(`exited with code ${String(code)}`));
+    });
+    child.stdin.end(input, "utf8");
+  });
+}
+async function gitSha(root) {
+  return new Promise((resolve2) => {
+    const child = spawn("git", ["-C", root, "rev-parse", "--short", "HEAD"], { stdio: ["ignore", "pipe", "ignore"] });
+    let out2 = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (d) => {
+      out2 += d;
+    });
+    child.on("error", () => resolve2(void 0));
+    child.on("close", (code) => resolve2(code === 0 && out2.trim() !== "" ? out2.trim() : void 0));
+  });
+}
+
+// src/commands/lint.ts
+import { readdir as readdir3, readFile as readFile8, stat as statFile } from "node:fs/promises";
+import { join as join8, relative as relative4 } from "node:path";
+async function skillFiles(path) {
+  const info = await statFile(path).catch(() => void 0);
+  if (!info) return [];
+  if (info.isFile()) return [path];
+  const out2 = [];
+  const walk3 = async (dir, depth) => {
+    if (depth > 3) return;
+    for (const entry of await readdir3(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".")) continue;
+      const full = join8(dir, entry.name);
+      if (entry.isDirectory()) await walk3(full, depth + 1);
+      else if (entry.name === "SKILL.md") out2.push(full);
+    }
+  };
+  await walk3(path, 0);
+  return out2.sort();
+}
+async function lint(opts) {
+  const targets = opts.paths.length > 0 ? opts.paths : await defaultPaths(opts.root);
+  if (targets.length === 0) {
+    err(`${yellow("Nothing to lint.")} Point at a SKILL.md or a skills directory.`);
+    return 1;
+  }
+  const files = [];
+  for (const t of targets) files.push(...await skillFiles(t));
+  if (files.length === 0) {
+    err(`${yellow("No SKILL.md found in")} ${targets.join(", ")}`);
+    return 1;
+  }
+  let errors = 0;
+  let warnings = 0;
+  const parsed = [];
+  const perFile = /* @__PURE__ */ new Map();
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const text = await readFile8(file, "utf8");
+    perFile.set(file, lintSkill(text, file));
+    try {
+      const skill = parseSkill(text);
+      parsed.push(skill);
+      fileOf.set(skill.name, file);
+    } catch {
+    }
+  }
+  for (const [name, found] of lintRegistry(parsed)) {
+    const file = fileOf.get(name);
+    if (!file) continue;
+    perFile.set(file, [...perFile.get(file) ?? [], ...found]);
+  }
+  out();
+  for (const file of files) {
+    const found = perFile.get(file) ?? [];
+    const where = relative4(opts.root, file) || file;
+    if (found.length === 0) {
+      out(`  ${green("ok")}   ${dim(where)}`);
+      continue;
+    }
+    out(`  ${found.some((f) => f.level === "error") ? red("fail") : yellow("warn")} ${bold(where)}`);
+    for (const f of found) {
+      if (f.level === "error") errors += 1;
+      else warnings += 1;
+      const at = f.line === void 0 ? "" : dim(`:${f.line}`);
+      out(`       ${f.level === "error" ? red("error") : yellow("warn ")}${at} ${f.message}`);
+      if (f.detail) out(`             ${dim(f.detail)}`);
+    }
+  }
+  out();
+  out(`  ${files.length} skill${files.length === 1 ? "" : "s"}, ${errors} error${errors === 1 ? "" : "s"}, ${warnings} warning${warnings === 1 ? "" : "s"}`);
+  if (errors === 0 && warnings > 0 && opts.strict !== true) {
+    out(`  ${dim("warnings do not fail this run,")} ${cyan("--strict")} ${dim("makes them")}`);
+  }
+  out();
+  return errors > 0 || opts.strict === true && warnings > 0 ? 1 : 0;
+}
+async function defaultPaths(root) {
+  for (const candidate of ["skills", "."]) {
+    const path = join8(root, candidate);
+    const found = await skillFiles(path);
+    if (found.length > 0) return [path];
+  }
+  return [];
+}
+
+// src/commands/list.ts
+var LABEL = {
+  unchanged: dim,
+  "local-edit": yellow,
+  "upstream-change": cyan,
+  both: yellow,
+  missing: yellow
+};
+var SAYS = {
+  unchanged: "",
+  "local-edit": "edited here",
+  "upstream-change": "update available",
+  both: "edited here, and updated upstream",
+  missing: "file is gone"
+};
+async function list2(opts) {
+  const lock = await readLockfile(opts.root);
+  if (!lock || Object.keys(lock.skills).length === 0) {
+    out(`${yellow("Nothing installed.")} Run ${bold("skyl scan")} to see what fits this project.`);
+    return 0;
+  }
+  const target = resolveTarget(void 0, lock);
+  let upstream = /* @__PURE__ */ new Map();
+  try {
+    const reg = await loadRegistry({ dir: opts.dir, refresh: opts.refresh });
+    upstream = new Map(reg.skills.map((s) => [s.name, s]));
+  } catch {
+  }
+  out();
+  out(`  ${bold("Installed")} ${dim(`for ${target.id}, in ${target.dir}`)}`);
+  out();
+  let words2 = 0;
+  for (const name of Object.keys(lock.skills).sort()) {
+    const entry = lock.skills[name];
+    const remote = upstream.get(name);
+    const onDisk = remote ? await readInstalled(opts.root, target, remote) : void 0;
+    const state = upstream.size === 0 ? "unchanged" : drift(entry, onDisk, remote);
+    const note = SAYS[state];
+    if (remote) words2 += remote.installableWords;
+    out(`    ${bold(name.padEnd(22))} ${entry.version.padEnd(8)} ${dim(entry.reason.padEnd(10))} ${LABEL[state](note)}`);
+  }
+  out();
+  if (words2 > 0) out(`  ${Object.keys(lock.skills).length} skills, ${tokens(words2)}`);
+  const stale = Object.keys(lock.skills).some((n) => {
+    const r = upstream.get(n);
+    return r && r.version !== lock.skills[n].version;
+  });
+  if (stale) out(`  ${cyan("skyl add")} ${dim("reinstalls at the current version")}`);
+  out();
+  return 0;
+}
+
+// src/commands/remove.ts
+import { rm } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+async function remove(opts) {
+  const lock = await readLockfile(opts.root);
+  if (!lock || Object.keys(lock.skills).length === 0) {
+    out(`${yellow("Nothing installed.")}`);
+    return 1;
+  }
+  if (opts.names.length === 0) {
+    out(`${yellow("Name a skill to remove.")}`);
+    return 1;
+  }
+  const target = resolveTarget(void 0, lock);
+  const { skills } = await loadRegistry({ dir: opts.dir, refresh: opts.refresh });
+  const byName = new Map(skills.map((s) => [s.name, s]));
+  const installed = new Set(Object.keys(lock.skills));
+  const asked = normalise(skills.filter((s) => installed.has(s.name)), opts.names);
+  const going = new Set(asked);
+  const orphaned = [];
+  for (const name of installed) {
+    if (going.has(name)) continue;
+    for (const dep of byName.get(name)?.requires ?? []) {
+      if (going.has(dep)) orphaned.push(`${name} requires ${dep}`);
+    }
+  }
+  if (orphaned.length > 0) {
+    out(`  ${red("Still required.")}`);
+    for (const line of orphaned) out(`    ${dim(line)}`);
+    out();
+    out(`  ${dim("Remove those first, or keep this one.")}`);
+    return 1;
+  }
+  out();
+  for (const name of asked) out(`    ${bold(name.padEnd(22))} ${red("remove")}`);
+  out();
+  if (!await confirm("  Delete them?", opts.yes === true)) {
+    out(`  ${dim("Nothing deleted.")}`);
+    return 1;
+  }
+  const skills2 = { ...lock.skills };
+  for (const name of asked) {
+    const skill = byName.get(name);
+    if (skill) {
+      const file = pathFor(opts.root, target, skill);
+      await rm(file, { force: true });
+      if (target.fileFor(name).includes("/")) await rm(dirname4(file), { recursive: true, force: true });
+    }
+    delete skills2[name];
+  }
+  await writeLockfile(opts.root, { ...lock, skills: skills2 });
+  out();
+  out(`  ${green("Removed.")} ${dim(`${asked.length} gone, ${Object.keys(skills2).length} left`)}`);
+  out();
+  return 0;
+}
+
+// src/commands/scan.ts
+async function scan(opts) {
+  const { skills } = await loadRegistry({ dir: opts.dir, refresh: opts.refresh });
+  const signals = await scanProject(opts.root);
+  const matched = detect(skills, signals);
+  if (matched.length === 0) {
+    out(`${yellow("Nothing detected.")} No skill in the registry matches this project.`);
+    out(dim("  Skyl currently covers Android. If this is an Android project, please open an issue."));
+    return 0;
+  }
+  const chosen = resolve(skills, matched.map((m) => m.skill));
+  const lock = await readLockfile(opts.root);
+  const target = resolveTarget(void 0, lock);
+  const installed = new Set(Object.keys(lock?.skills ?? {}));
+  if (opts.json) {
+    out(JSON.stringify({
+      detected: matched,
+      install: chosen.map((s) => ({ name: s.name, version: s.version, words: s.installableWords, installed: installed.has(s.name) })),
+      target: target.id
+    }, null, 2));
+    return 0;
+  }
+  const evidence = /* @__PURE__ */ new Map();
+  for (const m of matched) evidence.set(m.skill, m.on.map((o) => o.value));
+  out();
+  out(`  ${bold("Detected")} ${dim(`in ${opts.root}`)}`);
+  out();
+  for (const skill of chosen) {
+    const why = evidence.get(skill.name);
+    const mark = installed.has(skill.name) ? dim("installed") : green("new");
+    const reason = why?.length ? why[0] : skill.axis === "core" ? `every ${skill.family} project` : "required";
+    out(`    ${bold(skill.name.padEnd(22))} ${mark.padEnd(18)} ${dim(reason)}`);
+  }
+  const rest = unmatched(skills, matched).filter((s) => !chosen.some((c) => c.name === s.name));
+  if (rest.length > 0) {
+    out();
+    out(`  ${dim("Considered and not detected")}`);
+    for (const s of rest) out(`    ${dim(s.name)}`);
+  }
+  const fresh = chosen.filter((s) => !installed.has(s.name));
+  const words2 = fresh.reduce((n, s) => n + s.installableWords, 0);
+  out();
+  if (fresh.length === 0) {
+    out(`  ${green("Up to date.")} ${dim(`${chosen.length} skills installed for ${target.id}.`)}`);
+  } else {
+    out(`  ${fresh.length} to install, ${tokens(words2)} ${dim(`into ${target.dir}`)}`);
+    out();
+    out(`    ${cyan(`skyl add ${fresh.map((s) => s.name).join(" ")}`)}`);
+  }
+  out();
+  return 0;
+}
+
+// src/commands/update.ts
+var SAYS2 = {
+  apply: "update",
+  restore: "file is gone, put it back",
+  new: "newly required",
+  kept: "edited here, left alone",
+  conflict: "edited here, and changed upstream",
+  gone: "no longer in the registry"
+};
+async function update(opts) {
+  const lock = await readLockfile(opts.root);
+  if (!lock || Object.keys(lock.skills).length === 0) {
+    out(`${yellow("Nothing installed.")} Run ${bold("skyl scan")} to see what fits this project.`);
+    return 0;
+  }
+  const target = resolveTarget(void 0, lock);
+  const load = { dir: opts.dir, refresh: opts.refresh ?? opts.dir === void 0 };
+  const { items, from } = await installedState(opts.root, lock, target, load);
+  if (from === void 0) {
+    out(`  ${yellow("No registry reachable.")} ${dim("Nothing to update from.")}`);
+    return 1;
+  }
+  const { skills } = await loadRegistry(load);
+  const requested = Object.entries(lock.skills).filter(([, e]) => e.reason === "requested").map(([n]) => n);
+  const known = new Set(skills.map((s) => s.name));
+  let ordered = [];
+  try {
+    ordered = resolve(skills, requested.filter((n) => known.has(n)));
+  } catch {
+    ordered = [];
+  }
+  const held = new Set(Object.keys(lock.skills));
+  const arrivals = ordered.filter((s) => !held.has(s.name));
+  const plan = [];
+  for (const item of items) {
+    if (!item.skill) {
+      plan.push({ skill: void 0, name: item.name, action: "gone", version: item.entry.version });
+      continue;
+    }
+    if (item.onDisk === void 0) {
+      plan.push({ skill: item.skill, name: item.name, action: "restore", version: item.skill.version });
+      continue;
+    }
+    if (!changedOnDisk(item)) {
+      continue;
+    }
+    if (item.state === "local-edit") {
+      plan.push({ skill: item.skill, name: item.name, action: "kept", version: item.entry.version });
+      continue;
+    }
+    if (item.state === "both") {
+      plan.push({ skill: item.skill, name: item.name, action: opts.force === true ? "apply" : "conflict", version: item.skill.version });
+      continue;
+    }
+    plan.push({ skill: item.skill, name: item.name, action: "apply", version: item.skill.version });
+  }
+  for (const skill of arrivals) plan.push({ skill, name: skill.name, action: "new", version: skill.version });
+  const wanted = new Set(opts.names ?? []);
+  const chosen = plan.filter((p) => (p.action === "apply" || p.action === "restore" || p.action === "new") && (wanted.size === 0 || wanted.has(p.name) || wanted.has(p.name.split("/")[1])));
+  const stale = items.filter((i) => i.skill && i.skill.version !== i.entry.version && !changedOnDisk(i));
+  if (plan.length === 0 && stale.length === 0) {
+    out();
+    out(`  ${green("Up to date.")} ${dim(`${items.length} skills, from ${from}`)}`);
+    out();
+    return 0;
+  }
+  out();
+  for (const p of plan) {
+    const colour = p.action === "conflict" || p.action === "kept" || p.action === "gone" ? yellow : green;
+    out(`    ${bold(p.name.padEnd(22))} ${p.version.padEnd(8)} ${colour(SAYS2[p.action])}`);
+  }
+  out();
+  if (chosen.length === 0) {
+    if (plan.some((p) => p.action === "conflict")) {
+      out(`  ${dim("Nothing applied.")} ${cyan("skyl diff")} shows both sides, ${cyan("--force")} takes the upstream one.`);
+    } else {
+      out(`  ${dim("Nothing to apply.")}`);
+    }
+    if (stale.length > 0) await recordVersions(opts.root, lock, stale.map((i) => [i.name, i.skill.version]));
+    out();
+    return 0;
+  }
+  if (opts.showDiff === true) {
+    for (const item of items) {
+      if (chosen.some((c) => c.name === item.name)) printDiff(item, false);
+    }
+    out();
+  }
+  const words2 = chosen.reduce((n, c) => n + (c.skill?.installableWords ?? 0), 0);
+  out(`  ${chosen.length} to write, ${tokens(words2)} ${dim(`into ${target.dir}`)}`);
+  out();
+  if (!await confirm("  Apply?", opts.yes === true)) {
+    out(`  ${dim("Nothing written.")}`);
+    return 1;
+  }
+  const requestedSet = new Set(requested);
+  const next = await install(
+    opts.root,
+    target,
+    chosen.map((c) => c.skill),
+    requestedSet,
+    lock
+  );
+  for (const [name, version] of stale.map((i) => [i.name, i.skill.version])) {
+    const entry = next.skills[name];
+    if (entry) next.skills[name] = { ...entry, version };
+  }
+  await writeLockfile(opts.root, next);
+  out();
+  out(`  ${green("Done.")} ${dim("skyl.lock records what is here now.")}`);
+  out();
+  return 0;
+}
+async function recordVersions(root, lock, pairs) {
+  if (pairs.length === 0) return;
+  const skills = { ...lock.skills };
+  for (const [name, version] of pairs) {
+    const entry = skills[name];
+    if (entry) skills[name] = { ...entry, version };
+  }
+  await writeLockfile(root, { ...lock, skills });
+}
+
+// src/cli.ts
+var VERSION = "0.1.2";
+var HELP = `
+  ${bold("skyl")} ${dim("curated agent skills for what your project actually uses")}
+
+  ${dim("Install")}
+    ${bold("skyl scan")}                 read the project and propose an install
+    ${bold("skyl add")} <skill...>       install skills and what they require
+    ${bold("skyl remove")} <skill...>    take skills back out
+    ${bold("skyl list")}                 what is installed, and what has moved since
+
+  ${dim("Keep current")}
+    ${bold("skyl diff")} [skill...]      what changed here, and what changed upstream
+    ${bold("skyl update")} [skill...]    apply the upstream side, keeping local edits
+
+  ${dim("Your own files")}
+    ${bold("skyl audit")} [file]         read a hand-written CLAUDE.md and say what is in it
+    ${bold("skyl context")}              emit what a model needs to describe this project
+    ${bold("skyl learn")}                derive a project knowledge skill from this repository
+
+  ${dim("Authoring")}
+    ${bold("skyl lint")} [path...]       check skills against the spec
+
+  ${dim("Options")}
+    --target <${TARGETS.map((t) => t.id).join("|")}>
+    --dir <path>              read skills from a local checkout instead
+    --refresh                 prefer the network over the bundled copy
+    --json                    machine-readable output (scan, context)
+    --full                    whole file rather than hunks (diff)
+    --force                   take the upstream side of a conflict (update)
+    --strict                  warnings fail the run (lint)
+    --dry-run                 list what would be sent, and send nothing (context)
+    --agent <cmd>             the agent to pipe a prompt to (learn)
+    --print-prompt            print the prompt instead of running anything (learn)
+    --out <file>              write to a file instead of stdout
+    -y, --yes                 do not ask before writing
+    -C <path>                 run as if in this directory
+    -h, --help                -v, --version
+
+  ${dim("Skills are proposed, never installed without asking.")}
+`;
+function parse(argv) {
+  const positional = [];
+  const flags = {};
+  const takesValue = /* @__PURE__ */ new Set(["target", "dir", "C", "out", "agent", "max-files"]);
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const [name, inline] = arg.slice(2).split("=", 2);
+      if (inline !== void 0) flags[name] = inline;
+      else if (takesValue.has(name)) {
+        flags[name] = argv[i + 1] ?? "";
+        i += 1;
+      } else flags[name] = true;
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const short = arg.slice(1);
+      if (takesValue.has(short)) {
+        flags[short] = argv[i + 1] ?? "";
+        i += 1;
+      } else for (const c of short) flags[c] = true;
+    } else positional.push(arg);
+  }
+  return { command: positional.shift(), positional, flags };
+}
+var str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+var yes = (flags) => flags["yes"] === true || flags["y"] === true;
+async function run(argv) {
+  const { command, positional, flags } = parse(argv);
+  if (flags["version"] === true || flags["v"] === true) {
+    out(`skyl ${VERSION}`);
+    return 0;
+  }
+  if (flags["help"] === true || flags["h"] === true || command === "help") {
+    out(HELP);
+    return 0;
+  }
+  if (command === void 0) {
+    out(HELP);
+    return 1;
+  }
+  const root = str(flags["C"]) ?? process.cwd();
+  const dir = str(flags["dir"]);
+  const refresh = flags["refresh"] === true;
+  try {
+    switch (command) {
+      case "scan":
+        return await scan({ root, dir, refresh, json: flags["json"] === true });
+      case "add":
+        return await add({ root, names: positional, target: str(flags["target"]), dir, refresh, yes: yes(flags) });
+      case "list":
+        return await list2({ root, dir, refresh });
+      case "remove":
+      case "rm":
+        return await remove({ root, names: positional, dir, refresh, yes: yes(flags) });
+      case "diff":
+        return await diff({ root, names: positional, dir, refresh, full: flags["full"] === true });
+      case "update":
+      case "upgrade":
+        return await update({
+          root,
+          names: positional,
+          dir,
+          refresh,
+          yes: yes(flags),
+          force: flags["force"] === true,
+          showDiff: flags["diff"] === true
+        });
+      case "audit":
+        return await audit2({ root, file: positional[0], dir, refresh });
+      case "context":
+        return await context({
+          root,
+          dryRun: flags["dry-run"] === true,
+          json: flags["json"] === true,
+          outFile: str(flags["out"]),
+          ...str(flags["max-files"]) === void 0 ? {} : { maxFiles: Number(str(flags["max-files"])) }
+        });
+      case "learn":
+        return await learn({
+          root,
+          agent: str(flags["agent"]),
+          printPrompt: flags["print-prompt"] === true,
+          outFile: str(flags["out"]),
+          yes: yes(flags),
+          target: str(flags["target"])
+        });
+      case "lint":
+        return await lint({ root, paths: positional, strict: flags["strict"] === true });
+      default:
+        err(`${red("Unknown command")} ${bold(command)}`);
+        err(`Try ${cyan("skyl --help")}`);
+        return 1;
+    }
+  } catch (cause) {
+    if (cause instanceof SkylError) {
+      err(`${red("Error")} ${cause.message}`);
+      return 1;
+    }
+    throw cause;
+  }
+}
+
+// src/bin.ts
 process.exitCode = await run(process.argv.slice(2));
-//# sourceMappingURL=bin.js.map