@bompus/house-rules 0.0.0-stage → 0.13.0

package/rules/references/release-batching.md

@@ -0,0 +1,66 @@
+## Release batching
+
+When preparing or publishing a release, follow the repository's versioning,
+changelog, release-channel, authorization and verification requirements.
+Where those requirements allow it, batch compatible changes instead of
+publishing a release for every landed change. Landing and publishing are
+separate actions; authorization for one does not authorize the other.
+
+Record completed changes in the repository's pending-release record using its
+existing convention or automation. Keep unfinished work in the task plan.
+Before publishing, review approved backlog work and open pull requests with
+their owners. Include compatible changes that are ready or intended for the
+next release. Record the included changes, unfinished items and release cutoff
+or readiness condition in the task plan. Backlog items do not authorize
+implementation or landing. Do not hold a ready batch for unrelated, unapproved
+or indefinite work.
+
+Before any release or public announcement, audit every public-facing
+material against the intended revision or artifact and current verified state:
+the README and package READMEs, comparisons, performance metrics, graphics and
+visuals (banners, charts, diagrams, screenshots and demo recordings, with their
+alt text), relevant documentation, registry and marketplace listing text,
+announcement plans and drafts, release notes and the release announcement.
+
+Check each for old version numbers, figures and behavior. Regenerate or replace
+a visual that shows them; where that is not possible, remove it or label the
+version it shows. Record which materials were checked and the evidence for
+claims in the task plan. Correct, add, remove or update content to resolve
+outdated instructions, omissions, contradictions and unsupported claims.
+
+Distinguish released, deployed and planned behavior; give performance claims
+measurement conditions and evidence, and label unverified results. Preserve
+historical results with their tested versions instead of presenting them as
+current measurements.
+
+Run the audit on every version bump, before the first publish step: the tag,
+the registry or package publish, the GitHub release or any announcement. Land
+each correction first. Landing the corrections is part of the audit; one made
+after publishing means the audit did not finish. This applies to every public
+repository, including ones created later.
+
+Audit the pending changelog entries at the same point on every version bump,
+public or private, and land the corrected changelog first. Check each entry
+against the code that will ship: names, commands, counts and figures are
+verified, not copied, and no transient number stays. Keep entries plain and no
+longer than their reader needs. Merge entries that describe iterations of one
+concern into one entry that states the final behavior; how a change evolved
+stays in git. Keep whole any entry a user must act on (a breaking change, an
+upgrade or a repair step); never merge it away. An urgent release does not narrow
+this audit.
+
+Recheck affected claims when the candidate or supporting evidence changes.
+Before publishing, resolve unsupported or contradictory claims by correcting,
+qualifying or removing them; record any remaining accuracy blocker. Do not
+publish material with an unresolved accuracy blocker. Use existing evidence;
+this audit does not authorize new benchmarks, probes, source changes outside
+the task, or publication. Follow the owning repository's requirements for any
+needed correction or measurement. An urgent release may narrow the audit to
+its published materials and affected claims, but must still verify them.
+
+An urgent security, regression or compatibility fix can ship without waiting
+for unfinished backlog work. Every release's notes must cover all unreleased
+changes included in its artifact, including an urgent release. Choose the
+version for the combined changes according to the repository's scheme.
+Publishing still requires its normal authorization and checks; this modifier
+adds no permission to tag, publish or change release automation.

package/rules/references/squash-landing.md

@@ -0,0 +1,50 @@
+## Squash landing
+
+Prefer squash merges for pull requests unless the repository requires another
+strategy or the user picks one. With the GitHub CLI that is
+`gh pr merge <n> --squash`; a bare `gh pr merge` can create a merge commit.
+Do not pass `--delete-branch` when other worktrees may hold the head branch;
+delete the remote branch with `git push origin --delete <branch>` instead.
+
+When you integrate a task branch locally instead of through a pull request,
+land it as standard commits, never as a "Merge branch" commit: `git merge
+--squash` then commit with a message in the repository's commit convention,
+or a fast-forward when the base has not moved. After a pull request merges,
+do not also squash the branch locally.
+
+When a review bot reviews pull requests, merge only after its check finishes
+and each finding is fixed or answered with a reason, threads resolved. Read
+the review body too: findings outside the diff arrive there, not as threads.
+
+Let an enabled automatic review start; do not comment to request one. When none
+starts, check the integration's status instead of tagging the bot again. A bot's
+config file in the repository does not show that it is enabled, and an existing
+check on the head must report completion before you merge (for CodeRabbit, a
+successful status whose description starts with "Review completed").
+
+During integration, never switch, reset or remove the session's own checkout: no
+`checkout` or `switch` to another ref, no `reset` or branch force-move, and no
+`worktree remove` on it. Updating the default branch it has checked out
+(`merge --squash`, or `merge --ff-only` to the fetched remote head after a remote merge)
+under the fast-forward conditions in § Landing is expected; report other paths
+to their owners.
+
+After the merge, do not leave the session's own checkout on a landed branch.
+Fetch first, then:
+
+- When the content is fully in the base (a merged pull request whose remote
+  head is deleted, or an empty content diff after a squash) and the tree is
+  clean, move the checkout onto the fetched base: `git switch <base>` once the
+  local base is current, never merge, reset or stash. When another worktree
+  has the base checked out, detach at the fetched base (`git switch --detach
+<remote>/<base>`) and create or switch to a branch before any further
+  commits.
+- When an app manages the checkout, leave it for the app to retire. Report it;
+  it is not a blocker.
+- When the tree is dirty or ownership is in doubt, stop: record the
+  merged commit, the checkout path and the owner wherever you track the task.
+
+After each landing, update the task list and any active handoff with the
+commit, the verification result and the remaining work, then retire the task
+worktree and branch under § Cleanup. Stop earlier only when the user asks or
+integration is blocked, and report the exact blocker.

package/rules/references/thread-visuals.md

@@ -0,0 +1,45 @@
+## Visuals in issues, discussions and comments
+
+Use an image, chart or diagram only to show a spatial interface state, compare
+before and after, show a trend across multiple measurements, or explain a flow
+with branches. Otherwise use text, a table or a short code block. Most comments
+are text. The exception is a qualified measured result. It lies outside its declared
+variation criterion and the outputs are identical. An
+issue, discussion or pull request that reports one opens with a headline chart
+of it, so a reader sees the benefit before reading the body. A result with
+one row that moved by less than 10% stays text and a table.
+Draw it with the `hr-writing-pr` skill's `scripts/benefit-chart.py` when that skill
+is installed, or with any charting tool. A comment that only adds data to an
+existing thread stays text and a table.
+
+Keep the exact numbers, steps or states in text beside the visual, and give the
+image alt text, so a reader who cannot see it loses nothing. Many readers of an
+issue or pull request are agents that cannot parse an image. Every value, label
+and caveat in the visual also appears as body text, such as a table, a list or a
+described state. The alt text says what the image shows, not only that it is a
+chart. Label a mockup as an
+illustration. Preview a chart or diagram design you have not used before with the
+user before posting it.
+
+The destination is usually public. Before posting, check the capture for private
+paths, private project or repository names, local usernames, tokens and other
+credentials, and follow any capture rule the repository or your host rules
+state, such as a required theme.
+
+Attach the file through the project host's supported route. On GitHub,
+`gh issue create`, `gh issue edit`, `gh issue comment` and `gh pr comment`
+accept `--attach '<file>#<alt text>'` in recent `gh` versions (check
+`gh <command> --help`). In a browser form (the route for an issue form), use
+the form's upload field when it renders. When it does not, add the file through
+a text field's attach control and replace the default alt text `Image` that the
+upload inserts. Do not commit the image to the repository or use a
+third-party image host.
+
+Where the CLI has no attach route (`gh discussion` has
+no `--attach` flag) or refuses the upload, such as for lack of write access to
+the repository, use a browser signed in to the user's GitHub account: the page's
+upload field takes the file where `--attach` does not. Hand the user the exact
+text and the file only when the host has no such browser or the upload fails
+there, and do not post another way.
+
+Posting to an external project still needs the user's direction.

package/setup.mjs

@@ -0,0 +1,445 @@
+// Numbered selection flow. Only the existing revision-checked config writer saves.
+import { createInterface } from "node:readline";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs, stripVTControlCharacters } from "node:util";
+import { configurationPath, modifierList } from "./composition.mjs";
+import {
+  changeSelection,
+  QUESTION_MODIFIERS,
+  QUESTION_PRESETS,
+  configCommand,
+  readConfiguration,
+  selectionChanges,
+  selectionReport,
+  writeConfiguration,
+} from "./config.mjs";
+import { renderConfig } from "./config-view.mjs";
+
+const HELP = `Choose guidance with numbered prompts:
+  house-rules setup [--config PATH] [--plain]
+  house-rules setup [--config PATH] --json
+
+toggle N [N ...] or toggle NAME changes the listed choices.
+questions default|plain|coded|cards chooses how questions are asked.
+search TEXT, clear search, show selected, show all, help N
+next, back, save (on Review), refresh (after a stale revision), cancel
+
+Only an explicit save changes configuration. Output and hosts are separate.
+For scripting, use house-rules config help and config set --apply --expect.
+--json returns the existing config status report without prompting or writing.`;
+
+// Terminal output must not execute control sequences from personal metadata or paths.
+const safe = (value) => String(value).replace(/\p{Cc}/gu, " ");
+const quote = (value) =>
+  process.platform === "win32"
+    ? `'${value.replaceAll("'", "''")}'`
+    : `'${value.replaceAll("'", "'\\''")}'`;
+
+// How this copy runs and how to apply a saved selection: the npm package has a
+// `house-rules` command, a checkout from the installer is updated by running the installer again.
+const entry = fileURLToPath(new URL("./compose.mjs", import.meta.url));
+const parts = entry.split(/[\\/]/).map((part) => part.toLowerCase());
+const packaged = parts.some(
+  (part, index) =>
+    part === "node_modules" && parts[index + 1] === "@bompus" && parts[index + 2] === "house-rules",
+);
+const cliCommand = () =>
+  packaged
+    ? "house-rules"
+    : `${process.platform === "win32" ? "& " : ""}${quote(process.execPath)} ${quote(entry)}`;
+
+const installerPath = () =>
+  join(dirname(entry), process.platform === "win32" ? "install.ps1" : "install.sh");
+// The installer composes <config dir>/house-rules.json only.
+const usesInstaller = (configPath) =>
+  !packaged && existsSync(installerPath()) && basename(configPath) === "house-rules.json";
+
+function recomposeCommand(configPath) {
+  const configDir = dirname(configPath);
+  const checkout = dirname(entry);
+  const windows = process.platform === "win32";
+  const installer = installerPath();
+  if (!usesInstaller(configPath))
+    return `${cliCommand()} --config ${quote(configPath)} --out ${quote(join(configDir, "rules.md"))}`;
+  // The installer reads these variables, so a copy or config outside the defaults must name them.
+  const home = homedir();
+  const data =
+    process.env.XDG_DATA_HOME ?? (windows ? process.env.LOCALAPPDATA : join(home, ".local/share"));
+  const config = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+  const env = [
+    ["HOUSE_RULES_DIR", checkout, join(data ?? "", "house-rules")],
+    ["HOUSE_RULES_CONFIG_DIR", configDir, join(config, "house-rules")],
+  ].filter(([, actual, normal]) => resolve(actual) !== resolve(normal));
+  return windows
+    ? `${env.map(([name, value]) => `$env:${name}=${quote(value)}; `).join("")}& ${quote(installer)}`
+    : `${env.map(([name, value]) => `${name}=${quote(value)} `).join("")}sh ${quote(installer)}`;
+}
+
+export async function setupCommand(argv) {
+  let values;
+  try {
+    ({ values } = parseArgs({
+      args: argv,
+      options: {
+        config: { type: "string" },
+        plain: { type: "boolean" },
+        json: { type: "boolean" },
+        help: { type: "boolean" },
+      },
+    }));
+  } catch (error) {
+    error.exitCode = 2;
+    throw error;
+  }
+  if (values.help) return console.log(HELP);
+  if (values.json)
+    return configCommand([
+      "status",
+      "--json",
+      ...(values.config ? ["--config", values.config] : []),
+    ]);
+  let snapshot = readConfiguration(configurationPath(values.config));
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error("setup requires a terminal for input and output; no selections saved.");
+    console.log(HELP);
+    process.exitCode = 2;
+    return;
+  }
+
+  const intent = new Map();
+  let questions,
+    stage = 0,
+    query = "",
+    selectedOnly = true,
+    stale = false;
+  let saveAttempted = false;
+  const options = () => {
+    const result = {};
+    if (questions !== undefined) result.questions = questions;
+    for (const { kind, name, enabled } of intent.values()) {
+      const key = `${enabled ? "enable" : "disable"}-${kind}`;
+      (result[key] ??= []).push(name);
+    }
+    return result;
+  };
+  const draft = () => {
+    try {
+      const next = changeSelection(snapshot.config, options(), snapshot.path);
+      return { next, report: selectionReport(next, snapshot.path) };
+    } catch (error) {
+      return { error };
+    }
+  };
+  // A valid projection supplies the catalog when stored selections need repair.
+  // It is never saved; only explicit user intent is applied to the original snapshot.
+  const known = new Set(modifierList().map((m) => m.name));
+  const catalog = () => {
+    const projection = structuredClone(snapshot.config);
+    projection.modifiers = (projection.modifiers ?? []).filter((name) => known.has(name));
+    if (
+      projection.modifiers.includes("question-cards") &&
+      !projection.modifiers.includes("coded-offers")
+    )
+      projection.modifiers.push("coded-offers");
+    if (projection.modifiers.includes("model-default-questions"))
+      projection.modifiers = projection.modifiers.filter(
+        (name) => !["coded-offers", "question-cards"].includes(name),
+      );
+    return selectionReport(projection, snapshot.path);
+  };
+  let baseline = catalog(); // Malformed layers, composition or legacy names still stop setup.
+  const rows = () => {
+    const current = draft();
+    const report = current.report ?? baseline;
+    const unavailable = (snapshot.config.modifiers ?? []).filter((name) => !known.has(name));
+    const modifiers = [
+      ...report.modifiers.filter((m) => !QUESTION_MODIFIERS.includes(m.name)),
+      ...unavailable.map((name) => ({
+        name,
+        enabled: true,
+        description: "Unavailable modifier; remove to repair the selection.",
+      })),
+    ].map((row) => ({ ...row, kind: "modifier" }));
+    return [...modifiers, ...report.skills.map((row) => ({ ...row, kind: "skill" }))].map(
+      (row, index) => ({
+        ...row,
+        number: index + 1,
+        enabled: intent.get(`${row.kind}:${row.name}`)?.enabled ?? row.enabled,
+      }),
+    );
+  };
+  const print = (text = "") => {
+    const width = Math.max(24, Math.min(process.stdout.columns || 80, 120));
+    for (const line of stripVTControlCharacters(String(text)).split("\n")) {
+      let rest = safe(line);
+      while (rest.length > width) {
+        let cut = rest.lastIndexOf(" ", width);
+        if (cut < 1) cut = width;
+        console.log(rest.slice(0, cut));
+        rest = rest.slice(cut).trimStart();
+      }
+      console.log(rest);
+    }
+  };
+  const printCommand = (command) => {
+    if (/\p{Cc}/u.test(command)) {
+      print(
+        "The path contains control characters. Use config help with the original path arguments.",
+      );
+      return;
+    }
+    // Keep one logical line so terminal wrapping does not change copied shell syntax.
+    console.log(command);
+  };
+  const show = () => {
+    print(`Choose guidance / ${["Optional rules", "Skills", "Review"][stage]}`);
+    print(`Config: ${snapshot.path}`);
+    const current = draft();
+    if (current.error) print(`Selection needs repair: ${current.error.message}`);
+    if (stale)
+      print("Configuration changed. Use refresh for a new comparison, then review and save again.");
+    if (stage === 2 && current.report) {
+      print(
+        renderConfig({
+          command: "preview",
+          configPath: snapshot.path,
+          revision: snapshot.revision,
+          changes: selectionChanges(snapshot.config, current.next),
+          applied: null,
+          exists: snapshot.text !== null,
+          ...current.report,
+        }),
+      );
+      const flags = Object.entries(options()).flatMap(([key, names]) =>
+        (Array.isArray(names) ? names : [names]).flatMap((name) => [`--${key}`, quote(name)]),
+      );
+      print(
+        "Reproduce with the existing config command (POSIX shell on Unix, PowerShell on Windows):",
+      );
+      printCommand(
+        `${cliCommand()} config set --config ${quote(snapshot.path)} ${flags.join(" ")} --apply --expect ${quote(snapshot.revision)}`,
+      );
+      print("Review personal rule overrides. Setup does not interpret or edit their prose.");
+      print(
+        "Only selections will be saved. Output is not regenerated and hosts are not connected by setup.",
+      );
+      print("save / back / cancel");
+      return;
+    }
+    print("Core rules: always on. Optional rules are opt-in; skill selection follows your config.");
+    if (stage === 1) {
+      const skills = rows().filter((row) => row.kind === "skill");
+      print(
+        `${skills.filter((row) => row.enabled).length} of ${skills.length} available skills selected.`,
+      );
+    }
+    print(
+      `Question format: ${questions ?? baseline.questions}. Use questions default|plain|coded|cards.`,
+    );
+    const kind = stage === 0 ? "modifier" : "skill";
+    // With nothing selected yet, the selected-only view would be empty, so list every choice.
+    const nothingSelected = !rows().some((row) => row.kind === kind && row.enabled);
+    const visible = rows().filter(
+      (row) =>
+        row.kind === kind &&
+        (!selectedOnly || nothingSelected || row.enabled) &&
+        `${row.name} ${row.description}`.toLowerCase().includes(query.toLowerCase()),
+    );
+    for (const row of visible) {
+      print(
+        `${row.number}. [${row.enabled ? "on" : "off"}] ${row.name}${row.explicitOnly ? " (explicit only)" : ""}`,
+      );
+      print(`   ${row.description.split(/(?<=\.)\s/)[0]}`);
+    }
+    if (!visible.length)
+      print(`No matches for ${JSON.stringify(query)}. Use clear search or show all.`);
+    if (selectedOnly && nothingSelected)
+      print("Nothing is selected yet, so every choice is listed. Use toggle N to select.");
+    else if (selectedOnly)
+      print("Showing current selections. Search for relevant additions or use show all.");
+    if (baseline.unavailable.length)
+      print(`Retained unavailable exclusions: ${baseline.unavailable.join(", ")}`);
+    print("toggle N [N ...] / search TEXT / help N / next / back / cancel");
+  };
+  const input = createInterface({ input: process.stdin, terminal: false });
+  const lines = input[Symbol.asyncIterator]();
+  let interrupted = false;
+  const interrupt = () => {
+    interrupted = true;
+    process.exitCode = 130;
+    input.close();
+  };
+  process.once("SIGINT", interrupt);
+  try {
+    print(
+      snapshot.text === null
+        ? "New personal layer; no file has been created."
+        : "Existing selections loaded.",
+    );
+    print(
+      `CLI package version: ${JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8")).version}`,
+    );
+    show();
+    while (true) {
+      process.stdout.write("setup> ");
+      const line = await lines.next();
+      if (line.done || interrupted) {
+        print(
+          saveAttempted
+            ? "Cancelled; inspect config status for the last save attempt."
+            : "Cancelled; no selections saved.",
+        );
+        return;
+      }
+      const command = line.value.trim();
+      try {
+        if (command === "cancel") {
+          print(
+            saveAttempted
+              ? "Cancelled; inspect config status for the last save attempt."
+              : "Cancelled; no selections saved.",
+          );
+          return;
+        }
+        if (command === "next") {
+          if (stage === 1 && draft().error) throw draft().error;
+          stage = Math.min(2, stage + 1);
+          query = "";
+          selectedOnly = true;
+        } else if (command === "back") {
+          stage = Math.max(0, stage - 1);
+          query = "";
+          selectedOnly = true;
+        } else if (command.startsWith("search ")) {
+          query = command.slice(7);
+          selectedOnly = false;
+        } else if (command === "clear search") query = "";
+        else if (command === "show selected") selectedOnly = true;
+        else if (command === "show all") {
+          query = "";
+          selectedOnly = false;
+        } else if (command.startsWith("questions ")) {
+          const preset = command.slice(10);
+          if (!QUESTION_PRESETS.includes(preset))
+            throw new Error("Choose questions default|plain|coded|cards.");
+          questions = preset;
+        } else if (command.startsWith("toggle ") || command.startsWith("help ")) {
+          const help = command.startsWith("help ");
+          const names = command.slice(help ? 5 : 7).split(/\s+/);
+          const available = rows();
+          const chosen = names.map((name) => {
+            const matches = available.filter(
+              (row) => String(row.number) === name || row.name === name,
+            );
+            if (matches.length !== 1)
+              throw new Error(`Choose an unambiguous listed number or name: ${name}`);
+            return matches[0];
+          });
+          if (
+            !help &&
+            new Set(chosen.map((row) => `${row.kind}:${row.name}`)).size !== chosen.length
+          )
+            throw new Error("List each choice only once in a toggle command.");
+          if (
+            !help &&
+            chosen.some((row) => row.kind === "modifier" && !known.has(row.name) && !row.enabled)
+          )
+            throw new Error("An unavailable modifier can only be removed.");
+          for (const row of chosen) {
+            if (help) {
+              print(`${row.name}: ${row.description}`);
+              print(
+                `Source: ${row.origin ?? "shipped modifier"}${row.explicitOnly ? "; explicit invocation only" : ""}`,
+              );
+              if (row.kind === "skill")
+                print(
+                  "Exclusion applies to this name in every layer, including a personal override.",
+                );
+            } else {
+              const enabled = !(intent.get(`${row.kind}:${row.name}`)?.enabled ?? row.enabled);
+              intent.set(`${row.kind}:${row.name}`, { kind: row.kind, name: row.name, enabled });
+              // A rule that expects a skill would otherwise warn on every compose.
+              for (const need of enabled ? (row.requires ?? "").split(",") : []) {
+                const skill = available.find((r) => r.kind === "skill" && r.name === need.trim());
+                // A skill listed in the same command keeps the toggle the user typed.
+                if (!skill || chosen.includes(skill)) continue;
+                if (intent.get(`skill:${skill.name}`)?.enabled ?? skill.enabled) continue;
+                intent.set(`skill:${skill.name}`, {
+                  kind: "skill",
+                  name: skill.name,
+                  enabled: true,
+                });
+                print(`Also selected the ${skill.name} skill, which ${row.name} expects.`);
+              }
+            }
+          }
+        } else if (command === "refresh") {
+          if (!stale)
+            throw new Error(
+              "Refresh is available after a changed configuration; review the current draft first.",
+            );
+          snapshot = readConfiguration(snapshot.path);
+          baseline = catalog();
+          stale = false;
+          print(
+            "Fresh configuration loaded; retained selection intent is shown for review. Refresh did not write configuration.",
+          );
+        } else if (command === "save") {
+          if (stage !== 2) throw new Error("Use next to reach Review before saving.");
+          if (stale) throw new Error("Use refresh and review the new comparison before saving.");
+          const current = draft();
+          if (current.error) throw current.error;
+          if (!selectionChanges(snapshot.config, current.next).length) {
+            print("No selection changes; configuration was not written.");
+            return;
+          }
+          saveAttempted = true;
+          try {
+            writeConfiguration(snapshot, current.next, snapshot.revision);
+          } catch (error) {
+            try {
+              if (readConfiguration(snapshot.path).revision !== snapshot.revision) stale = true;
+            } catch {
+              stale = true;
+            }
+            throw error;
+          }
+          let saved;
+          try {
+            saved = readConfiguration(snapshot.path);
+            if (JSON.stringify(saved.config) !== JSON.stringify(current.next))
+              throw new Error("Saved configuration changed; inspect config status.");
+            selectionReport(saved.config, saved.path);
+          } catch (error) {
+            stale = true;
+            throw new Error(
+              `Save completed but verification failed; inspect config status or refresh: ${error.message}`,
+            );
+          }
+          print(`Selections saved: ${saved.path}`);
+          print(
+            "Output was not regenerated and hosts were not connected by setup. To apply the selections, run:",
+          );
+          printCommand(recomposeCommand(saved.path));
+          if (!usesInstaller(saved.path))
+            print(
+              "This rebuilds the rules only; add --skills-out with a new or empty directory to rebuild the skills too.",
+            );
+          return;
+        } else
+          throw new Error(
+            "Unknown command. Use toggle, questions, search, help, next, back, save or cancel.",
+          );
+      } catch (error) {
+        print(`Cannot continue: ${error.message}`);
+      }
+      show();
+    }
+  } finally {
+    process.removeListener("SIGINT", interrupt);
+    input.close();
+  }
+}

package/skills/hr-agent-guidance-audit/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.