@bompus/house-rules 0.0.0-stage → 0.13.0

package/skills/hr-read-reddit/scripts/reddit.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env bun
+// Read Reddit threads and subreddit searches through Reddit's public Atom (RSS)
+// feeds: no key, full post and comment bodies, links kept inline.
+import { parseArgs as parseCli } from "node:util";
+
+const ORIGIN = "https://www.reddit.com";
+// Reddit blocks generic agents; its API rules ask for a descriptive user agent.
+const HEADERS = { "user-agent": "linux:agent-read-reddit:v1 (read-only research)" };
+const HOSTS = /^(?:www\.|old\.|new\.|np\.|m\.)?reddit\.com$/;
+
+export type Entry = {
+  id: string;
+  kind: "post" | "comment" | "other";
+  author: string;
+  published: string;
+  title: string;
+  url: string;
+  text: string;
+};
+export type Options = {
+  command: string | undefined;
+  args: string[];
+  json: boolean;
+  pages: number;
+  since: number | null;
+  sort: string;
+};
+
+/** `{ sub, id }` for a thread URL on reddit.com (any subdomain) or redd.it; null otherwise. */
+export function parseThreadUrl(input: string): { sub: string | null; id: string } | null {
+  let url: URL;
+  try {
+    url = new URL(input);
+  } catch {
+    return null;
+  }
+  if (url.hostname === "redd.it") {
+    const id = /^\/([a-z0-9]+)$/i.exec(url.pathname)?.[1];
+    return id ? { sub: null, id } : null;
+  }
+  if (!HOSTS.test(url.hostname)) {
+    return null;
+  }
+  const match = /^\/r\/([^/]+)\/comments\/([a-z0-9]+)/i.exec(url.pathname);
+  return match ? { sub: match[1]!, id: match[2]! } : null;
+}
+
+const ENTITIES: Record<string, string> = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+};
+export function decodeEntities(s: string): string {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e: string) => {
+    if (e[0] === "#") {
+      return String.fromCodePoint(
+        e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : Number(e.slice(1)),
+      );
+    }
+    return ENTITIES[e.toLowerCase()] ?? m;
+  });
+}
+
+/** Entry HTML as plain text; a link becomes `text (url)`, or the bare URL when the text says nothing. */
+export function htmlToText(html: string): string {
+  const text = html
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/<a\s[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_, href: string, label: string) => {
+      const url = decodeEntities(href).replace(/^\//, `${ORIGIN}/`);
+      const words = decodeEntities(label.replace(/<[^>]+>/g, "")).trim();
+      return !words || /^\[(link|comments)\]$/.test(words) || words === url
+        ? url
+        : `${words} (${url})`;
+    })
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<\/(p|div|li|h\d|pre|blockquote|tr)>/gi, "\n")
+    .replace(/<li[^>]*>/gi, "- ")
+    .replace(/<[^>]+>/g, "");
+  return decodeEntities(text)
+    .replace(/[ \t]+/g, " ")
+    .replace(/ *\n */g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+/** Atom feed entries: `{ id, kind, author, published, title, url, text }`; kind is post (t3) or comment (t1). */
+export function parseFeed(xml: string): Entry[] {
+  const tag = (s: string, name: string) =>
+    new RegExp(`<${name}[^>]*>([\\s\\S]*?)</${name}>`).exec(s)?.[1] ?? "";
+  return [...xml.matchAll(/<entry>([\s\S]*?)<\/entry>/g)].map(([, e = ""]) => {
+    const id = tag(e, "id");
+    return {
+      id,
+      kind: id.startsWith("t3_") ? "post" : id.startsWith("t1_") ? "comment" : ("other" as const),
+      author: tag(tag(e, "author"), "name").replace(/^\/u\//, ""),
+      published: tag(e, "published") || tag(e, "updated"),
+      title: decodeEntities(tag(e, "title")),
+      url: decodeEntities(/<link href="([^"]*)"/.exec(e)?.[1] ?? ""),
+      text: htmlToText(decodeEntities(tag(e, "content"))),
+    };
+  });
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+let waitUntil = 0;
+
+/** GET a feed, spacing requests by Reddit's rate-limit headers and retrying a 429 twice. */
+async function getFeed(url: string): Promise<Entry[]> {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const wait = waitUntil - Date.now();
+    if (wait > 0) {
+      console.error(`rate limit: waiting ${Math.ceil(wait / 1000)} s`);
+      await sleep(wait);
+    }
+    const res = await fetch(url, { headers: HEADERS });
+    const reset = Number(res.headers.get("x-ratelimit-reset")) || 60;
+    const remaining = Number(res.headers.get("x-ratelimit-remaining") ?? 1);
+    if (res.status === 429 || remaining < 1) {
+      waitUntil = Date.now() + (reset + 1) * 1000;
+    }
+    if (res.status === 429) {
+      continue;
+    }
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} for ${url}`);
+    }
+    return parseFeed(await res.text());
+  }
+  throw new Error(`HTTP 429 three times for ${url}`);
+}
+
+const SORTS = ["new", "relevance", "top"];
+
+export function parseArgs(argv: string[]): Options | { error: string } {
+  let parsed;
+  try {
+    parsed = parseCli({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        json: { type: "boolean" },
+        pages: { type: "string" },
+        since: { type: "string" },
+        sort: { type: "string" },
+      },
+    });
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+  const { values, positionals } = parsed;
+  const [command, ...args] = positionals;
+  const pages = Number(values.pages ?? 1);
+  const since = values.since === undefined ? null : Date.parse(values.since);
+  const sort = values.sort ?? "new";
+  if (!Number.isInteger(pages) || pages < 1) {
+    return { error: `bad --pages value ${values.pages}` };
+  }
+  if (Number.isNaN(since)) {
+    return { error: `bad --since value ${values.since}` };
+  }
+  if (!SORTS.includes(sort)) {
+    return { error: `bad --sort value ${sort}` };
+  }
+  const opts: Options = { command, args, json: values.json === true, pages, since, sort };
+  if (command === "thread" && args.length > 0) {
+    return opts;
+  }
+  if (command === "search" && args.length === 2) {
+    return opts;
+  }
+  return { error: command ? `bad arguments for ${command}` : "missing command" };
+}
+
+function print(entry: Entry, json: boolean): void {
+  if (json) {
+    console.log(JSON.stringify(entry));
+    return;
+  }
+  const head = entry.kind === "post" ? `### ${entry.title}\n${entry.url}\n` : "#### comment ";
+  console.log(`${head}u/${entry.author} · ${entry.published}\n\n${entry.text}\n`);
+}
+
+async function main(argv: string[]): Promise<number> {
+  const opts = parseArgs(argv);
+  if ("error" in opts) {
+    console.error(opts.error);
+    console.error("usage: reddit.ts thread <url>... [--json]");
+    console.error(
+      "       reddit.ts search <subreddit|all> <query> [--pages N] [--since ISO-date] [--sort new|relevance|top] [--json]",
+    );
+    return 2;
+  }
+  if (opts.command === "thread") {
+    let failed = 0;
+    for (const input of opts.args) {
+      const ref = parseThreadUrl(input);
+      if (!ref) {
+        console.log(`## ${input}\nnot a Reddit thread URL\n`);
+        failed++;
+        continue;
+      }
+      const path = ref.sub ? `/r/${ref.sub}/comments/${ref.id}` : `/comments/${ref.id}`;
+      try {
+        if (!opts.json) {
+          console.log(`## ${input}`);
+        }
+        for (const entry of await getFeed(`${ORIGIN}${path}/.rss?limit=500`)) {
+          print(entry, opts.json);
+        }
+      } catch (error) {
+        console.log(`fetch failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        failed++;
+      }
+    }
+    return failed ? 1 : 0;
+  }
+  const [sub, query = ""] = opts.args;
+  const base =
+    sub === "all" ? `${ORIGIN}/search.rss?` : `${ORIGIN}/r/${sub}/search.rss?restrict_sr=on&`;
+  let after = "";
+  for (let page = 0; page < opts.pages; page++) {
+    const url = `${base}q=${encodeURIComponent(query)}&sort=${opts.sort}&limit=100${after && `&after=${after}`}`;
+    let entries: Entry[];
+    try {
+      entries = await getFeed(url);
+    } catch (error) {
+      console.log(`fetch failed: ${error instanceof Error ? error.message : String(error)}\n`);
+      return 1;
+    }
+    let old = false;
+    for (const entry of entries) {
+      if (opts.since && Date.parse(entry.published) < opts.since) {
+        old = opts.sort === "new";
+        continue;
+      }
+      print(entry, opts.json);
+    }
+    console.error(`page ${page + 1}: ${entries.length} results`);
+    if (entries.length < 100 || old) {
+      break;
+    }
+    after = entries.at(-1)!.id;
+  }
+  return 0;
+}
+
+if (import.meta.main) {
+  process.exitCode = await main(process.argv.slice(2));
+}

package/skills/hr-read-x-links/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: hr-read-x-links
+description: Read X/Twitter post links (x.com, twitter.com and mirrors) in full, including quoted posts, long-form articles, expanded links and attached images. Use whenever a task needs the content of an X post; generic web fetch returns truncated text and no images.
+---
+
+# Read X links
+
+Generic web fetch usually sees X behind a login wall: text cut at "Show more", `t.co`
+links, no images, and quoted articles reduced to a bare link. Read posts through
+the bundled script instead. It calls the public [fxtwitter](https://github.com/FxEmbed/FxEmbed)
+API and needs no key. It sends the post's handle and ID to that third-party
+service and downloads attached images from the URLs it returns.
+
+```bash
+bun scripts/x-post.ts --media-dir <scratch-dir>/media <url> [<url>...]
+```
+
+Run it from this skill's directory. It prints, for each post and any quoted
+post: author, date, full text with expanded links, the article body when the
+post is an X article, and the local path of every downloaded image. Put
+`--media-dir` in your task's scratch directory, on disk rather than in a
+RAM-backed `/tmp`.
+
+Then:
+
+1. Open every downloaded image with the host's image-reading tool. Prompts,
+   tables and charts are often posted only as screenshots.
+2. Follow expanded links (GitHub repos, blog posts) with web fetch when the post
+   only points at the substance.
+3. Report what stayed unread: videos (the script prints the video URL and a
+   thumbnail), earlier posts in a thread (a reply shows its parent's ID; fetch
+   that URL to walk up), and any post the script reported as failed. Say so
+   rather than rating content you did not see.
+4. When the post promotes a tool, method or result, keep what the post claims
+   apart from what its source shows. Check each claim against the repository,
+   docs or paper it links, report what the tool actually does, and name each
+   claim with no evidence behind it, such as a benchmark with no method or a
+   screenshot with no source.
+
+A deleted, protected or age-restricted post fails with the API's message; ask
+the user for a screenshot. If the API itself is down, fall back to web fetch
+and state that text and images may be incomplete.

package/skills/hr-read-x-links/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "HR: Read X links"

package/skills/hr-read-x-links/scripts/x-post.ts

@@ -0,0 +1,264 @@
+#!/usr/bin/env bun
+// Read X/Twitter posts through the public fxtwitter API: full text, expanded
+// links, quoted posts, long-form articles, and downloadable images.
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs as parseCli } from "node:util";
+
+const API = "https://api.fxtwitter.com";
+// pbs.twimg.com answers 403 without a browser-like user agent.
+const HEADERS = { "user-agent": "Mozilla/5.0" };
+const HOSTS = /^(?:www\.|mobile\.)?(?:x|twitter|fixupx|fxtwitter|vxtwitter|fixvx)\.com$/;
+
+// The parts of fxtwitter's response this script reads.
+type Facet = { type?: string; original?: string; replacement?: string; indices: [number, number] };
+type ArticleMedia = { media_id?: string; media_info?: { original_img_url?: string } };
+type Block = { type?: string; text?: string; entityRanges?: { key?: number | string }[] };
+type Entity = { type?: string; data?: { mediaItems?: { mediaId?: string }[] } };
+export type Article = {
+  title?: string;
+  content?: { blocks?: Block[]; entityMap?: { key: number | string; value: Entity }[] };
+  cover_media?: ArticleMedia;
+  media_entities?: ArticleMedia[];
+};
+export type Tweet = {
+  id: string;
+  url?: string;
+  text?: string;
+  created_at?: string;
+  raw_text?: { text?: string; facets?: Facet[] };
+  author?: { screen_name?: string; name?: string };
+  replying_to?: string;
+  replying_to_status?: string;
+  media?: {
+    photos?: { url: string }[];
+    videos?: { url: string; thumbnail_url?: string; duration?: number }[];
+  };
+  article?: Article;
+  quote?: Tweet;
+};
+
+/** `{ user, id }` for a post URL on x.com or a known mirror; null otherwise. */
+export function parseStatusUrl(input: string): { user: string; id: string } | null {
+  let url: URL;
+  try {
+    url = new URL(input);
+  } catch {
+    return null;
+  }
+  if (!HOSTS.test(url.hostname)) {
+    return null;
+  }
+  const match = /^\/([^/]+)\/status(?:es)?\/(\d+)/.exec(url.pathname);
+  return match ? { user: match[1]!, id: match[2]! } : null;
+}
+
+/** Post text with t.co links replaced by their targets. */
+export function expandedText(tweet: Tweet): string {
+  const text = tweet.raw_text?.text ?? tweet.text ?? "";
+  const facets = (tweet.raw_text?.facets ?? [])
+    .filter((f) => f.type === "url" && f.original && f.replacement)
+    .sort((a, b) => b.indices[0] - a.indices[0]);
+  let out = text;
+  for (const f of facets) {
+    out = out.slice(0, f.indices[0]) + f.replacement + out.slice(f.indices[1]);
+  }
+  return out;
+}
+
+export type Photo = { url: string; id: string | null };
+
+/**
+ * Article body as Markdown-ish text. An image block becomes `[image N]`, where N
+ * is that image's position in `mediaOf(tweet).photos` (and its downloaded file).
+ */
+export function articleText(article: Article | undefined, photos: Photo[] = []): string {
+  const blocks = article?.content?.blocks ?? [];
+  const entities = new Map(
+    (article?.content?.entityMap ?? []).map((e) => [String(e.key), e.value]),
+  );
+  const lines: string[] = [];
+  let ordered = 0;
+  for (const block of blocks) {
+    const text = (block.text ?? "").trim();
+    if (block.type !== "ordered-list-item") {
+      ordered = 0;
+    }
+    if (block.type === "atomic") {
+      const entity = entities.get(String(block.entityRanges?.[0]?.key));
+      const mediaId = entity?.type === "MEDIA" ? entity.data?.mediaItems?.[0]?.mediaId : null;
+      if (mediaId) {
+        const n = photos.findIndex((p) => p.id === mediaId);
+        lines.push(n >= 0 ? `[image ${n + 1}]` : "[image]");
+      }
+      continue;
+    }
+    if (!text) {
+      continue;
+    }
+    if (block.type === "header-one") {
+      lines.push(`# ${text}`);
+    } else if (block.type === "header-two") {
+      lines.push(`## ${text}`);
+    } else if (block.type === "unordered-list-item") {
+      lines.push(`- ${text}`);
+    } else if (block.type === "ordered-list-item") {
+      lines.push(`${++ordered}. ${text}`);
+    } else if (block.type === "blockquote") {
+      lines.push(`> ${text}`);
+    } else {
+      lines.push(text);
+    }
+  }
+  return lines.join("\n");
+}
+
+/** Every image and video a post carries, including article images. */
+export function mediaOf(tweet: Tweet): {
+  photos: Photo[];
+  videos: { url: string; thumbnail?: string; duration?: number }[];
+} {
+  const photos: Photo[] = (tweet.media?.photos ?? []).map((p) => ({ url: p.url, id: null }));
+  const article = tweet.article;
+  for (const m of [article?.cover_media, ...(article?.media_entities ?? [])]) {
+    if (m?.media_info?.original_img_url) {
+      photos.push({ url: m.media_info.original_img_url, id: m.media_id ?? null });
+    }
+  }
+  const videos = (tweet.media?.videos ?? []).map((v) => ({
+    url: v.url,
+    thumbnail: v.thumbnail_url,
+    duration: v.duration,
+  }));
+  return { photos, videos };
+}
+
+async function fetchPost(user: string, id: string): Promise<Tweet> {
+  const res = await fetch(`${API}/${user}/status/${id}`, { headers: HEADERS });
+  const body = (await res.json().catch(() => null)) as { tweet?: Tweet; message?: string } | null;
+  if (!res.ok || !body?.tweet) {
+    throw new Error(`${user}/status/${id}: HTTP ${res.status} ${body?.message ?? ""}`.trim());
+  }
+  return body.tweet;
+}
+
+async function download(url: string, path: string): Promise<string> {
+  const res = await fetch(url, { headers: HEADERS });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}`);
+  }
+  writeFileSync(path, Buffer.from(await res.arrayBuffer()));
+  return path;
+}
+
+async function render(tweet: Tweet, mediaDir: string | null, label: string): Promise<string> {
+  const out: string[] = [];
+  const a = tweet.author ?? {};
+  out.push(`### ${label}: @${a.screen_name} (${a.name ?? ""}) · ${tweet.created_at}`);
+  out.push(tweet.url ?? "");
+  if (tweet.replying_to) {
+    out.push(
+      `Reply to @${tweet.replying_to} (${tweet.replying_to_status}); earlier thread posts are not included.`,
+    );
+  }
+  out.push("", expandedText(tweet));
+  const { photos, videos } = mediaOf(tweet);
+  if (tweet.article) {
+    out.push("", `#### Article: ${tweet.article.title}`, "", articleText(tweet.article, photos));
+  }
+  for (const [i, { url }] of photos.entries()) {
+    if (!mediaDir) {
+      out.push(`image ${i + 1}: ${url}`);
+      continue;
+    }
+    const ext = /\.(\w+)(?:\?|$)/.exec(url)?.[1] ?? "jpg";
+    const path = join(mediaDir, `${tweet.id}-${i + 1}.${ext}`);
+    out.push(
+      `image ${i + 1}: ${await download(url, path).catch((e: unknown) => `${url} (download failed: ${e instanceof Error ? e.message : String(e)})`)}`,
+    );
+  }
+  for (const [i, v] of videos.entries()) {
+    out.push(
+      `video ${i + 1} (${v.duration ?? "?"}s, not readable as text): ${v.url} thumbnail: ${v.thumbnail}`,
+    );
+  }
+  return out.join("\n");
+}
+
+export function parseArgs(argv: string[]): {
+  mediaDir: string | null;
+  urls: string[];
+  error?: string;
+} {
+  let parsed;
+  try {
+    parsed = parseCli({
+      args: argv,
+      allowPositionals: true,
+      options: { "media-dir": { type: "string" } },
+    });
+  } catch (error) {
+    return {
+      mediaDir: null,
+      urls: [],
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+  const mediaDir = parsed.values["media-dir"] ?? null;
+  // A forgotten directory would otherwise take the first URL as its value.
+  if (mediaDir !== null && /^https?:/i.test(mediaDir)) {
+    return { mediaDir: null, urls: [], error: "--media-dir needs a directory value" };
+  }
+  return { mediaDir, urls: parsed.positionals };
+}
+
+async function main(argv: string[]): Promise<number> {
+  const { mediaDir, urls, error } = parseArgs(argv);
+  if (error || urls.length === 0) {
+    if (error) {
+      console.error(error);
+    }
+    console.error("usage: x-post.ts [--media-dir DIR] <x.com status URL>...");
+    return 2;
+  }
+  if (mediaDir) {
+    mkdirSync(mediaDir, { recursive: true });
+  }
+  let failed = 0;
+  for (const input of urls) {
+    const ref = parseStatusUrl(input);
+    if (!ref) {
+      console.log(`## ${input}\nnot an X post URL\n`);
+      failed++;
+      continue;
+    }
+    try {
+      const tweet = await fetchPost(ref.user, ref.id);
+      const parts = [await render(tweet, mediaDir, "Post")];
+      // The embedded quote omits its article and full media; fetch it directly.
+      if (tweet.quote) {
+        const embedded = tweet.quote;
+        let quote = embedded;
+        try {
+          quote = await fetchPost(embedded.author?.screen_name ?? "i", embedded.id);
+        } catch (error) {
+          parts.push(
+            `Quoted post fetch failed (${error instanceof Error ? error.message : String(error)}); showing the embedded copy, which can lack its article and full media.`,
+          );
+        }
+        parts.push(await render(quote, mediaDir, "Quoted post"));
+      }
+      console.log(`## ${input}\n${parts.join("\n\n")}\n`);
+    } catch (error) {
+      console.log(
+        `## ${input}\nfetch failed: ${error instanceof Error ? error.message : String(error)}\n`,
+      );
+      failed++;
+    }
+  }
+  return failed ? 1 : 0;
+}
+
+if (import.meta.main) {
+  process.exitCode = await main(process.argv.slice(2));
+}

package/skills/hr-research-shared-links/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: hr-research-shared-links
+description: "Research a shared link or repo in depth, compare it with the user's setup and rate each idea. Use when a session opens with a link or asks for thoughts or what to borrow. Not for factual lookups, and not for implementing or fixing things the link describes."
+---
+
+# Research shared links
+
+A shared link asks "is this worth anything to us?", not "what does it say?".
+The failure to avoid is a first answer built from the page that was shared,
+so the user has to ask again to "look closer", "compare it to ours" or "find
+the hidden gems". Do that work the first time.
+
+## Before reading
+
+1. If the link looks unrelated to the session's work or carries stray
+   characters, say what you think it is and confirm before a long analysis.
+2. For several links, give each its own verdict and add one synthesis.
+3. Tell the user in one line what you will do: read the primary source, compare
+   with their setup, rate each idea.
+
+## Read the source, not the pointer
+
+1. Use the reader for the site when one is available (X posts, Reddit threads);
+   generic fetch truncates them.
+2. Follow an article, post or video to what it is about: the repository, paper,
+   docs or data. The shared page is a claim; the source is the evidence.
+3. For a repository, read past the README: agent guidance files, skills, docs,
+   tests and the code behind any headline feature. These hold the transferable
+   ideas. Search its open issues and security disclosures for the shared claim
+   and for each idea you may recommend, check every hit against the current
+   code, and read the latest release notes. Record the terms you searched. The
+   README says what the maintainer wants to be true; the tracker shows what
+   users and reviewers found, and a fix may already have landed.
+4. Say what you did not read: videos, images, earlier posts in a thread,
+   private or login-gated pages, source behind a README claim. Do not rate what
+   you did not see.
+5. Check headline claims against the project's own data. Recompute a cost or
+   speed figure, compare the README with the results file, and name each claim
+   that has no evidence behind it.
+6. A license does not stop you borrowing an idea. If it bars an AI from reading
+   the material, flag that and offer another reader.
+
+## Compare with what the user has
+
+1. Search their rules, skills, docs and settings for the same idea before judging
+   it. "We lack this" needs a search showing the gap; "we have this" needs the
+   path.
+2. Search the earlier sessions and decisions you can reach for standing
+   constraints and options already rejected. Name any records you could not
+   reach, and do not read their absence as "never decided". Do not recommend
+   what was ruled out without saying so and saying what changed.
+3. State exactly what the comparison ran against: which fork or version of ours,
+   which release of theirs, the competitor's real name.
+
+## Rate each idea
+
+Give each idea one row: source path, the technique in one to three lines, what it
+would change here and what that is worth (faster, cheaper, safer, clearer),
+the evidence on both sides (their file and line, our search), and a verdict.
+
+- **Adopt**: clear gain, fits a stated need, small to carry.
+- **Consider**: real idea, unproven here or costly. Say what would settle it.
+- **Skip**: already covered, ruled out, or tied to the vendor's model or product.
+
+Separate the idea that transfers from the vendor and model details around it.
+Weigh build against buy against borrow: a maintained tool that is good enough
+beats building, and an idea is often worth taking without the tool. List the
+ideas you dropped and why, so the recommended set and the table agree.
+
+## Route what is worth keeping
+
+1. Name the layer that owns each kept idea: shared portable rules, host or
+   machine setup, one project, or a portfolio-level record. Use the user's own
+   ownership map when they have one.
+2. A deferred idea gets the condition that reopens it and a proposed home in
+   the owning repository; offer to save it there rather than leaving it only in
+   this reply.
+3. If an idea means adopting something vendored, offer to record where it came
+   from so upstream changes are noticed. If evaluating it exposed an upstream
+   bug, offer to file it.
+4. Wording adopted into rules describes behavior and carries no "borrowed from"
+   history. Provenance belongs in the research record.
+
+## Answer
+
+1. Lead with a table, one row per link or repository: what it is, its status in
+   the user's setup (have, partly, missing, ruled out) with the evidence, and the
+   verdict.
+2. Then the ranked ideas, then what is not worth borrowing and why.
+3. Explain jargon in plain words or a small diagram. Before changing anything
+   from this research, show the exact before and after wording or real sample
+   output.
+4. End with offers under the user's offer rules. Candidates: write a research
+   note; test it against what they use on quality, speed or cost (give the
+   expected wall-clock time and check host load first); get independent opinions
+   from other models or a review panel, with a brief that includes your findings
+   and the candidates you rejected, choosing the reviewers yourself; build or
+   adopt one idea, saying which steps that option includes (file changes,
+   installing the tool, a pull request, landing) and which it leaves for a later
+   offer; stop here.
+
+"Tell me more" and "thoughts?" authorize research and nothing else. Changing
+files, installing the tool or opening a pull request needs the user's selection.

package/skills/hr-split-to-prs/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron Queen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.