paperthin 0.5.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "paperthin",
+  "description": "Plain-Markdown skills that turn old engineering wisdom into reflexes your agent reaches for on its own — on any agent.",
+  "skills": [
+    "./skills/single/re0",
+    "./skills/single/re0-git",
+    "./skills/single/shower",
+    "./skills/single/tasting",
+    "./skills/cross/ssotchk",
+    "./skills/cross/ssotize"
+  ]
+}

package/CLAUDE.md

@@ -0,0 +1,61 @@
+# PaperThin
+
+The guide for authoring these skills — and itself a skill artifact, so `re0` it when it drifts. The shipped catalog is [README](./README.md).
+
+## Philosophy
+
+- **Trust the artifact, not the author.** A skill exists to make work read true to someone who wasn't there. The maker's in-session mind is the worst judge of whether it does — so a skill either re-derives the work from what's true now, or imports outside eyes to test it.
+- **Single source of truth.** One fact lives in one place; everything else references it by name. Skills compose by naming each other in prose — never by copying content or reaching into another skill's files. Shared material lives in its owning skill; others point to it.
+- **Restraint.** Change only what genuinely improves — a pass that finds nothing to improve changes nothing. The enemy is slop (noise, duplication, padding), not addition.
+- **Recursive.** Every skill is general enough to use *while building the skills*, so we maintain the skills with the skills, and each pass is audited and refined by the tools it ships. Treat that loop as the point.
+
+## Layout
+
+```
+skills/<perspective>/<name>/SKILL.md
+```
+
+Group by **artifact perspective** — which is the suite's two vectors made physical:
+
+- `single/` — **depth**: refine or verify the one artifact in hand (`re0`, `re0-git`, `shower`, `tasting`).
+- `cross/` — **breadth**: reconcile one truth across many artifacts and platforms (`ssotchk`, `ssotize`).
+
+Reach for `cross/` to *establish* order (legacy refactor, knowledge-base build, fresh scaffolding); once a fact is cleanly SSOT'd, *maintain* it with `re0` rather than re-consolidating. Topic domains belong in separate plugins, so within a plugin the only durable cut is perspective. One skill = one directory with a `SKILL.md`; keep drafts and retired skills out of the README and `plugin.json`.
+
+## SKILL.md format
+
+```
+---
+name: <kebab-name>            # matches the directory and the invocation
+description: "<trigger-rich one-liner>"
+---
+
+<one line: what the skill does>
+
+## Goal
+## Workflow      — numbered steps
+## Rules         — constraints
+## Verification  — checks before finishing; report what changed
+```
+
+## Invocation
+
+Every `SKILL.md` is either user-invoked (`disable-model-invocation: true`, reachable only by the human) or model-invoked (model- or user-reachable). For the full definitions, description conventions, and why a user-invoked skill can invoke model-invoked skills but never another user-invoked one, see [docs/invocation.md](./docs/invocation.md).
+
+Default to model-invoked. Make a skill user-invoked only when the model should never reach it on its own — its trigger is a deliberate, human-decided action (commit, push, publish, deploy), or its mere presence in reach would bias the agent toward one. A user-invoked skill can't be composed, so it also stays out of `tasting`. Today only `re0-git` qualifies: it cleans a commit's message, and committing is human-decided.
+
+## Shipping
+
+Before committing:
+
+1. **SKILL.md** follows the anatomy above.
+2. **README** lists it — grouped Model-/User-invoked, each linked to its `SKILL.md`.
+3. **plugin.json** registers its path.
+4. **package.json** bumps version (new skill = minor; fix/docs = patch); `keywords` stay grouped logically.
+5. Run **`tasting`** — `shower` the artifact, `ssotchk` the repo, `re0` the docs.
+
+Commit messages: Conventional Commits, one bullet per real change — no padding, no mechanical trivia, no co-author tags. `re0-git` cleans a drifted message back to its essence, in the author's own style.
+
+## Vendoring
+
+Not a fork of [mattpocock/skills](https://github.com/mattpocock/skills) — we adopt its architecture and philosophy and ship our own non-overlapping workflows, vendoring only the small shared substrate. Reused material stays **verbatim** and is credited in [NOTICE](./NOTICE) per source (project · license · copyright), never paraphrased to drop credit.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LilMGenius
+
+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.

package/NOTICE

@@ -0,0 +1,25 @@
+This repository vendors third-party material, kept verbatim and used under the
+original licenses. Attribution is tracked per source below (not per file).
+
+======================================================================
+mattpocock/skills  —  https://github.com/mattpocock/skills  (MIT License)
+======================================================================
+Copyright (c) 2026 Matt Pocock
+
+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.

package/README.md

@@ -0,0 +1,132 @@
+<div align="center">
+
+# PaperThin
+
+<img src="https://raw.githubusercontent.com/LilMGenius/paperthin/main/assets/banner.svg" alt="PaperThin — Trust the artifact, not the author." width="820">
+
+Plain-Markdown skills that turn old engineering wisdom into reflexes your agent reaches for on its own — on any agent: Claude Code, Codex, Cursor, Antigravity, Grok-Build, Hermes, OpenClaw, Pi, etc.
+
+[Quickstart](#quickstart-15-seconds) · [Reference](#reference) · [The Problem](#the-problem) · [The Fixes](#the-fixes) · [Credits](#credits)
+
+</div>
+
+---
+
+## Quickstart (15 seconds)
+
+1. **Install** for every agent you use:
+   ```bash
+   npx skills@latest add LilMGenius/paperthin --global --agent '*'
+   ```
+2. **Run it elevated** so the skills are symlinked (they auto-update), not copied.
+3. **Use them** — model-invoked, so your agent reaches for them on its own; or call one by name, like `/re0`.
+
+**Not sure?** Paste that command into whatever agent you're using and just say "set this up for me" — it'll do the rest.
+
+## Reference
+
+### Model-invoked — your agent reaches for these on its own
+| Skill | Scope | What it does |
+|---|---|---|
+| ♻️ **[re0](./skills/single/re0/SKILL.md)** | one artifact | Rewrite a drifted artifact into a clean v0 — not another patch |
+| 🚿 **[shower](./skills/single/shower/SKILL.md)** | one artifact | Cold-read it with fresh, zero-context eyes — does it stand on its own? *(read-only)* |
+| 🔎 **[ssotchk](./skills/cross/ssotchk/SKILL.md)** | many artifacts | Find where one fact is scattered or duplicated; name the canonical source *(read-only)* |
+| 🧲 **[ssotize](./skills/cross/ssotize/SKILL.md)** | many artifacts | Consolidate it into one home and point the rest at it |
+| 🍴 **[tasting](./skills/single/tasting/SKILL.md)** | your output | After any change, auto-runs `shower` + `ssotchk` + `re0` on it |
+
+### User-invoked — you run these yourself
+| Skill | Scope | What it does |
+|---|---|---|
+| 🧾 **[re0-git](./skills/single/re0-git/SKILL.md)** | one commit | Rewrite a finished commit's message into a clean v0 so `git log` alone hands off |
+
+## The Problem
+
+**Most agent skills are slop.**
+
+Point an agent at a goal and it **adds** — more files, more options, more "helpful" boilerplate. Adding looks like progress, and nothing ever makes it go back and delete.
+
+> [!WARNING]
+> Repeat that across a project and you get the familiar AI-generated toolkit: near-duplicate skills, dead settings, a README that says the same thing three times. Plausible, busy, and quietly unmaintainable.
+
+These skills bet the other way — **every one of them removes:**
+
+- `re0` rewrites a draft into a clean v0 instead of patching it,
+- `ssotchk` / `ssotize` collapse the same fact scattered across files,
+- `shower` cuts whatever a stranger can't follow,
+- `tasting` runs all of it on your own output, automatically.
+
+> [!TIP]
+> The hard part isn't adding features — it's restraint. A pass that finds nothing to improve changes nothing. **That restraint is the product.**
+
+## The Fixes
+
+**Each is a well-worn principle, made automatic.**
+
+### #1 — Artifacts rot
+Edit a doc one piece at a time across a session and it bloats: stale deltas, duplicated noise, changelog scars. Patching on top just preserves the rot.
+
+**The fix → `re0`:** rewrite the artifact as a clean v0, as if it were the first version.
+
+> *Prior art: the Boy Scout Rule — "leave it cleaner than you found it" (Robert C. Martin, [Clean Code](https://www.informit.com/articles/article.aspx?p=1235624&seqNum=6), 2008). `re0` goes further: rewrite, don't just tidy.*
+
+<details>
+<summary><b>[PROOF]</b></summary>
+
+- **Setup** — we asked `re0` to refresh these docs once more, but they were already at v0.
+- **Result** — it found nothing to improve and left every line of prose untouched.
+- **So** — a tool that does nothing when nothing is wrong never bloats your repo: these skills remove noise, they never add it.
+</details>
+
+### #2 — You go blind to your own work
+After a long session you're the one person who *can't* read your own work straight: you know too much, so your brain quietly fills every gap and the holes turn invisible.
+
+**The fix → `shower`:** hand a stranger who never saw your session only the artifact, and ask "does this actually make sense?"
+
+> *Prior art: [egoless programming](https://en.wikipedia.org/wiki/Egoless_programming) — you can't review your own work objectively; someone else must (Gerald Weinberg, 1971). Here, that someone is a context-free sub-session.*
+
+<details>
+<summary><b>[PROOF]</b></summary>
+
+- **Setup** — we handed `shower` its own spec, to a sub-session with zero context, holding only the file.
+- **Result** — in minutes it found three bugs the author had missed:
+  - a step that hinted the answer it should hide,
+  - a path that leaked spoiler files,
+  - a scope too vague to act on.
+- **So** — a skill that catches its own bugs can catch yours.
+</details>
+
+### #3 — The same fact ends up everywhere
+A timeout value, a decision, a status — copied into a README, a doc, a ticket, and a Slack thread. The copies drift, and now no one knows which is true.
+
+**The fix → `ssotchk` + `ssotize`:** find the scatter, name the canonical source, then consolidate and point the rest at it.
+
+> *Prior art: [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) — one fact, one authoritative home (Hunt & Thomas, The Pragmatic Programmer, 1999).*
+
+### #4 — "Remember to verify" never fires
+A guideline buried in docs won't trigger in a brand-new session — exactly when author bias is highest.
+
+**The fix → `tasting`:** the moment you finish something, it runs `shower`, `ssotchk`, and `re0` on your output, automatically.
+
+> *Prior art: [dogfooding](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) — eat your own dog food (Microsoft, 1988). Taste your own cooking before you serve it.*
+
+### #5 — Your session doesn't travel; the git log does
+Your session is stuck where it ran — this agent, this account, this machine. A teammate or another agent can't load the context your work happened in.
+
+**The fix → `re0-git`:** clean a finished commit's message so `git log` — the one thing every environment shares — carries the handoff, and anyone picks up from the log alone.
+
+<details>
+<summary><b>[PROOF]</b></summary>
+
+- **Setup** — `re0-git`'s very first target was its own release commit.
+- **Result** — dogfooding it surfaced two faults, both fixed:
+  - a message padded with trivia,
+  - a spec that preached "no redundancy" while repeating itself.
+- **So** — its first cleanup was after itself.
+</details>
+
+## Credits
+
+- **Built on** [mattpocock/skills](https://github.com/mattpocock/skills) (MIT) — its architecture and philosophy.
+- **Not a fork** — these are [LilMGenius](https://github.com/LilMGenius)'s own, non-overlapping workflows.
+- **Vendored verbatim** — a few shared building blocks, kept as-is with per-source attribution in [NOTICE](./NOTICE).
+- **Authoring guide** — conventions and philosophy live in [CLAUDE.md](./CLAUDE.md).

package/assets/banner.svg

@@ -0,0 +1,65 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 400" width="1200" height="400" role="img" aria-label="PaperThin — Trust the artifact, not the author.">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1200" y2="400" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#0B0D11"/>
+      <stop offset="1" stop-color="#15181E"/>
+    </linearGradient>
+
+    <radialGradient id="halo" cx="290" cy="195" r="250" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#7FD8FF" stop-opacity="0.13"/>
+      <stop offset="1" stop-color="#7FD8FF" stop-opacity="0"/>
+    </radialGradient>
+
+    <linearGradient id="paper" x1="0.1" y1="0" x2="0.5" y2="1">
+      <stop offset="0" stop-color="#FCFDFE"/>
+      <stop offset="1" stop-color="#CED7E0"/>
+    </linearGradient>
+
+    <linearGradient id="edge" x1="0" y1="0" x2="1" y2="0">
+      <stop offset="0" stop-color="#E6F4FF"/>
+      <stop offset="0.5" stop-color="#9FDCFF"/>
+      <stop offset="1" stop-color="#6FCBFF"/>
+    </linearGradient>
+
+    <filter id="glow" x="-60%" y="-60%" width="220%" height="220%">
+      <feGaussianBlur stdDeviation="5" result="b"/>
+      <feMerge>
+        <feMergeNode in="b"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+
+    <filter id="soft" x="-80%" y="-80%" width="260%" height="260%">
+      <feGaussianBlur stdDeviation="13"/>
+    </filter>
+  </defs>
+
+  <rect width="1200" height="400" fill="url(#bg)"/>
+  <rect width="1200" height="400" fill="url(#halo)"/>
+
+  <!-- the sheet: a perspective rectangle (corners + straight sides), one swept front edge -->
+  <g transform="translate(95 104) rotate(-5)">
+    <!-- float shadow -->
+    <ellipse cx="205" cy="158" rx="150" ry="20" fill="#000000" opacity="0.5" filter="url(#soft)"/>
+
+    <!-- top surface -->
+    <path d="M 40 54 L 330 26 L 360 96 C 250 118, 150 122, 70 124 Z" fill="url(#paper)"/>
+
+    <!-- razor edge: the lit, swept leading edge -->
+    <path d="M 360 96 C 250 118, 150 122, 70 124" fill="none"
+          stroke="url(#edge)" stroke-width="3.5" stroke-linecap="round" filter="url(#glow)"/>
+  </g>
+
+  <!-- wordmark: "Thin" drawn as hairline outline — thinness made literal, font-weight independent -->
+  <text x="568" y="206" font-family="'Helvetica Neue', Helvetica, Arial, sans-serif"
+        font-size="94" letter-spacing="0.5">
+    <tspan font-weight="500" fill="#EEF3F8">Paper</tspan><tspan
+        font-weight="400" fill="none" stroke="#D4E3EF" stroke-width="1.4">Thin</tspan>
+  </text>
+
+  <!-- tagline -->
+  <text x="571" y="252" font-family="'Helvetica Neue', Helvetica, Arial, sans-serif"
+        font-size="18.5" font-weight="300" letter-spacing="5" fill="#7E8893">
+    TRUST THE ARTIFACT, NOT THE AUTHOR.
+  </text>
+</svg>

package/assets/thumbnail.svg

@@ -0,0 +1,62 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 1080" width="1080" height="1080" role="img" aria-label="PaperThin — Trust the artifact, not the author.">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1080" y2="1080" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#0B0D11"/>
+      <stop offset="1" stop-color="#15181E"/>
+    </linearGradient>
+
+    <radialGradient id="halo" cx="540" cy="420" r="430" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#7FD8FF" stop-opacity="0.14"/>
+      <stop offset="1" stop-color="#7FD8FF" stop-opacity="0"/>
+    </radialGradient>
+
+    <linearGradient id="paper" x1="0.1" y1="0" x2="0.5" y2="1">
+      <stop offset="0" stop-color="#FCFDFE"/>
+      <stop offset="1" stop-color="#CED7E0"/>
+    </linearGradient>
+
+    <linearGradient id="edge" x1="0" y1="0" x2="1" y2="0">
+      <stop offset="0" stop-color="#E6F4FF"/>
+      <stop offset="0.5" stop-color="#9FDCFF"/>
+      <stop offset="1" stop-color="#6FCBFF"/>
+    </linearGradient>
+
+    <filter id="glow" x="-60%" y="-60%" width="220%" height="220%">
+      <feGaussianBlur stdDeviation="6" result="b"/>
+      <feMerge>
+        <feMergeNode in="b"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+
+    <filter id="soft" x="-80%" y="-80%" width="260%" height="260%">
+      <feGaussianBlur stdDeviation="16"/>
+    </filter>
+  </defs>
+
+  <rect width="1080" height="1080" fill="url(#bg)"/>
+  <rect width="1080" height="1080" fill="url(#halo)"/>
+
+  <!-- the sheet (same form as the wide banner), centered and scaled up -->
+  <g transform="translate(230 274) rotate(-5) scale(1.55)">
+    <ellipse cx="205" cy="158" rx="150" ry="20" fill="#000000" opacity="0.5" filter="url(#soft)"/>
+    <path d="M 40 54 L 330 26 L 360 96 C 250 118, 150 122, 70 124 Z" fill="url(#paper)"/>
+    <path d="M 360 96 C 250 118, 150 122, 70 124" fill="none"
+          stroke="url(#edge)" stroke-width="3.5" stroke-linecap="round" filter="url(#glow)"/>
+  </g>
+
+  <!-- wordmark, centered -->
+  <text x="540" y="722" text-anchor="middle"
+        font-family="'Helvetica Neue', Helvetica, Arial, sans-serif"
+        font-size="132" letter-spacing="0.5">
+    <tspan font-weight="500" fill="#EEF3F8">Paper</tspan><tspan
+        font-weight="400" fill="none" stroke="#D4E3EF" stroke-width="1.8">Thin</tspan>
+  </text>
+
+  <!-- tagline, centered -->
+  <text x="540" y="794" text-anchor="middle"
+        font-family="'Helvetica Neue', Helvetica, Arial, sans-serif"
+        font-size="25" font-weight="300" letter-spacing="6.5" fill="#7E8893">
+    TRUST THE ARTIFACT, NOT THE AUTHOR.
+  </text>
+</svg>

package/docs/invocation.md

@@ -0,0 +1,18 @@
+# Model-invoked vs user-invoked
+
+Every `SKILL.md` in this repo is a skill. The one axis that splits them is **invocation** — who can reach it:
+
+- **User-invoked** — reachable **only by the human typing its name**. Set `disable-model-invocation: true` in the frontmatter. The `description` is **human-facing**: a one-line summary read by a person browsing slash-commands. Strip trigger lists ("Use when the user says…").
+- **Model-invoked** — reachable by **model or user**. The default: omit `disable-model-invocation`. The `description` is **model-facing** and keeps rich trigger phrasing ("Use when the user wants…, mentions…, asks for…") so auto-invocation fires. The test for whether a skill should stay model-invoked: _could the model usefully reach for this autonomously?_ (Reuse is the reason to extract a skill, not the test.)
+
+Because a user-invoked skill has no description, nothing but the human can reach it — no other skill can fire it. So a user-invoked skill may invoke model-invoked skills, but it can never reach another user-invoked skill.
+
+Bucket `README.md`s and the top-level `README.md` group entries into **User-invoked** and **Model-invoked**.
+
+## Dependencies between them
+
+Dependencies are expressed as **`/skill`-style prose invocation** ("Run the `/grilling` skill"), not deep `../other-skill/FILE.md` cross-references. Shared reference docs live inside the skill that owns them; other skills reach that material by invoking the skill, not by linking across folders.
+
+## Passive vs active domain work
+
+Merely _reading_ `CONTEXT.md` for vocabulary is a one-line prose pointer, not the `domain-modeling` skill. Only the active build/sharpen discipline (challenge terms, edge-case scenarios, write ADRs, update `CONTEXT.md` inline) is `domain-modeling`.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "paperthin",
+  "version": "0.5.0",
+  "description": "Plain-Markdown skills that turn old engineering wisdom into reflexes your agent reaches for on its own — on any agent.",
+  "keywords": [
+    "agent-skills",
+    "agent-agnostic",
+    "ai-agents",
+    "anti-slop",
+    "single-source-of-truth",
+    "ssot",
+    "self-improvement",
+    "refactor",
+    "dedupe",
+    "clean-code",
+    "verification",
+    "documentation",
+    "knowledge-base",
+    "git"
+  ],
+  "author": "LilMGenius (https://github.com/LilMGenius)",
+  "license": "MIT",
+  "homepage": "https://github.com/LilMGenius/paperthin#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LilMGenius/paperthin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LilMGenius/paperthin/issues"
+  }
+}

package/scripts/link-skills.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Links all skills in the repository to ~/.claude/skills, so that
+# they can be used by the local Claude CLI.
+
+REPO="$(cd "$(dirname "$0")/.." && pwd)"
+DEST="$HOME/.claude/skills"
+
+# If ~/.claude/skills is a symlink that resolves into this repo, we'd end up
+# writing the per-skill symlinks back into the repo's own skills/ tree. Detect
+# and bail out instead of polluting the working copy.
+if [ -L "$DEST" ]; then
+  resolved="$(readlink -f "$DEST")"
+  case "$resolved" in
+    "$REPO"|"$REPO"/*)
+      echo "error: $DEST is a symlink into this repo ($resolved)." >&2
+      echo "Remove it (rm \"$DEST\") and re-run; the script will recreate it as a real dir." >&2
+      exit 1
+      ;;
+  esac
+fi
+
+mkdir -p "$DEST"
+
+find "$REPO/skills" -name SKILL.md -not -path '*/node_modules/*' -not -path '*/deprecated/*' -print0 |
+while IFS= read -r -d '' skill_md; do
+  src="$(dirname "$skill_md")"
+  name="$(basename "$src")"
+  target="$DEST/$name"
+
+  if [ -e "$target" ] && [ ! -L "$target" ]; then
+    rm -rf "$target"
+  fi
+
+  ln -sfn "$src" "$target"
+  echo "linked $name -> $src"
+done

package/scripts/list-skills.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO="$(cd "$(dirname "$0")/.." && pwd)"
+
+cd "$REPO"
+find . -name SKILL.md -not -path '*/node_modules/*' | sed 's|^\./||' | sort

package/skills/cross/ssotchk/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: ssotchk
+description: "Audit where one fact lives in many places and report the canonical source of truth plus a consolidation plan — read-only. Use when the same fact, spec, decision, config, status, or definition appears in multiple artifacts or platforms and may have drifted; when refactoring a legacy codebase, building or grading the severity of a knowledge base, or scaffolding a new project; before trusting a value stated in more than one place; or when asked to find duplication, check consistency, or locate the source of truth. Never modifies anything."
+---
+
+Find every place a single truth lives, name its rightful home, and report the drift — without changing anything.
+
+## Goal
+
+Locate Single-Source-of-Truth (SSOT) violations: one fact duplicated, paraphrased, or contradicted across artifacts or platforms. A fact with N copies carries N-1 liabilities, because copies drift out of sync. The output is a map — where it lives, which copy should be canonical, and what to do with the rest — that `/ssotize` or a human can act on. This is read-only.
+
+**A different vector from `re0`, and they pair well.** `re0` refreshes one artifact into a clean v0 (depth, one thing at a time); SSOT work unifies one truth across many places (breadth, across artifacts and platforms). Reach for SSOT when establishing order — refactoring a legacy codebase, building or grading the severity of a knowledge base, or scaffolding a new project. Once a fact is cleanly SSOT'd, keep it tidy with `re0` rather than repeated consolidation.
+
+## Workflow
+
+1. Name the truth in scope — the specific fact, value, spec, decision, status, or definition being tracked, not the whole document.
+2. Enumerate every occurrence across the given artifacts and platforms.
+3. Classify each occurrence: exact copy, paraphrase, partial, stale, or contradictory.
+4. Pick the canonical home — the most authoritative and most-maintained location, closest to where the fact actually changes (the code/config for a value, the spec for a decision, the ticket for status).
+5. Decide the action per non-canonical occurrence: **dedupe** (redundant copy), **reference** (should link to canonical), or **reconcile** (it disagrees — needs a human call on which is right).
+6. Report: a table of occurrences (location · kind · action), the proposed canonical home with a one-line justification, and a separate list of contradictions/drift that need a decision.
+
+## Rules
+
+- Read-only. Propose; do not edit, move, or delete.
+- An empty findings list is a valid result — never invent drift to fill the report.
+- Justify the canonical choice by authority, proximity-to-change, and freshness — never pick arbitrarily.
+- Keep contradictions separate from plain duplicates; never silently decide which conflicting value is "true".
+- Flag any detail that lives ONLY in a non-canonical copy — it must be folded into the canonical home before that copy can be cut.
+- Respect boundaries: surface (don't ignore) when copies span trust/permission scopes — private vs public, internal vs customer-facing.
+- Be platform-aware: some places can transclude, some only link, some need a quote plus a link.
+
+## Verification
+
+Before finishing:
+
+1. Every occurrence is accounted for — none left unclassified.
+2. The canonical home is justified, not assumed.
+3. Contradictions and unique-only-in-a-copy details are surfaced separately from simple duplications.
+4. The report is actionable: a human or `/ssotize` could execute it without re-discovering anything.

package/skills/cross/ssotize/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: ssotize
+description: "Consolidate a fact that's scattered across places into one canonical source and replace the rest with references — mutating. Use when the user asks to deduplicate, consolidate, unify, or establish a single source of truth across artifacts or platforms; or when the same fact lives in many places and copies are drifting. Folds unique details into the canonical home and reconciles contradictions before removing any copy."
+---
+
+Collapse a scattered truth into one canonical home; make every other place point to it.
+
+## Goal
+
+Enforce Single Source of Truth (SSOT): one fact = one home, and every other place that needs it references that home instead of copying it. References don't drift; copies do. This mutates artifacts, so it is deliberate and loss-averse.
+
+Use this to **establish or repair** SSOT — messy, legacy, or freshly-scaffolded states. Audit first with `/ssotchk`. Once SSOT holds, don't overuse `/ssotize`: maintain artifacts with `re0` instead. (See `/ssotchk` for how the SSOT vector differs from `re0`.)
+
+## Workflow
+
+1. Audit first — run the `/ssotchk` workflow (or reuse its result) for the canonical home and the per-occurrence action plan. Don't consolidate blind.
+2. Make the canonical home complete and current — fold in any unique detail that lived only in a copy. Never lose information to consolidation.
+3. Reconcile contradictions in the canonical home FIRST (confirm the correct value with the human when ambiguous); only then point others at it.
+4. Replace each duplicate with a reference to the canonical home — a link, a "see <home>", a quote-with-link, or a transclude where the platform supports it.
+5. Remove the now-redundant copies. Where removal would orphan a reader, leave a one-line pointer instead of deleting outright.
+6. Re-read the canonical home: it must now carry the whole truth on its own.
+
+## Rules
+
+- A pass that finds no scatter to consolidate changes nothing.
+- Fold before you cut — never delete the only place a detail exists.
+- One canonical home per fact; prefer a reference over a copy everywhere else.
+- Reconcile, don't duplicate, contradictions — resolve the conflicting value in one place, never preserve it in two.
+- Don't consolidate across a trust/permission boundary (private → public, customer-facing → internal) without explicit confirmation.
+- Be platform-aware: transclude where possible, else link to a stable anchor; never replace a copy with a link the reader can't follow.
+- Keep it reversible: prefer a reference over a hard deletion when a platform can't link back.
+
+## Verification
+
+Before finishing:
+
+1. The canonical home holds the complete, current truth on its own.
+2. Every former copy now references it, and each reference resolves.
+3. No unique detail was lost and nothing was orphaned.
+4. Contradictions were reconciled to one value, not left duplicated.
+5. Report what was consolidated, where the canonical home is, and what (if anything) still needs a human decision.

package/skills/single/re0/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: re0
+description: "Refresh an existing artifact into the current best v0. Use when the user asks to clean up, sync up, dedupe, de-noise, rewrite, or update an artifact after iteration; when nearby artifacts may have drifted; or when changes in one place should be reflected across related artifacts while keeping the result minimal."
+---
+
+Refresh the target artifact as if it were the first clean version.
+
+## Goal
+
+Use this when the user asks to clean up, sync up, dedupe, or rewrite an existing
+artifact into the current best v0.
+
+The result must be lighter, more current, and more accurate than the input. It
+should not read like a changelog, cleanup note, or patch over an older draft.
+
+## Workflow
+
+1. Identify the target artifact from the user's request or the active context.
+2. Read the target artifact end to end before editing.
+3. Check nearby artifacts that must stay aligned with it.
+4. Remove scaffolding residue, stale deltas, duplicated process noise, deprecated
+   information, and over-specific history.
+5. Fold durable lessons into the place they should have lived from the start.
+6. Rewrite instead of appending when appending would preserve noise.
+7. Preserve the artifact's useful voice and structure; simplify everything else.
+8. Re-read the result and cut again.
+
+## Rules
+
+- A pass that finds nothing to genuinely improve changes nothing.
+- Prefer editing existing sections over adding new ones.
+- Convert "what changed" into "what is true now".
+- Keep only details that improve future execution, accuracy, or recall.
+- Do not leave old/new traces unless the artifact is explicitly a changelog.
+- Do not create extra files unless the user asks.
+
+## Verification
+
+Before finishing:
+
+1. Re-read the changed sections.
+2. Confirm related artifacts still point in the same direction.
+3. Confirm the output is smaller or cleaner unless the user explicitly wanted expansion.
+4. Report what noise was removed and what durable truth was kept.

package/skills/single/re0-git/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: re0-git
+disable-model-invocation: true
+description: "Rewrite a finished commit's message into a clean, handoff-ready form — in your own log style — so `git log` alone tells the story, no `git diff` archaeology next session. Run it yourself after a commit (user-invoked on purpose, never auto-fired). Message only: never the tree, always gpg-signed; the commit you finalize takes fresh dates, older commits keep theirs."
+---
+
+`re0` for git: rewrite a finished commit's message so the log hands off on its own — in the author's own voice, not an imposed one.
+
+## Goal
+
+Repeated amends and momentum-commits leave a message bloated, stale, or padded with trivia. `re0-git` applies `re0` to the message: a clean version that lets a fresh session continue from `git log` alone, without reading the diff. It refines *what the author already writes* — it never imposes a format, and it never makes a commit. Only the message moves — and timestamps, per the date rule below; the tree never changes.
+
+It is **user-invoked** — you run it once you've decided to commit. Deliberately not model-invoked and not chained from `tasting`: a commit-cleanup tool sitting in the agent's reach would bias it toward committing when it shouldn't, so it's kept out of that reach entirely.
+
+## Workflow
+
+1. Scope the target — usually `HEAD`, sometimes a short unpushed range. A commit must already exist; re0-git never creates one.
+2. Read two things: what actually changed (`git show --stat`, `git diff`) so the message is true, and the author's recent `git log` so you match how they write — a one-line head, or a subject with bullets, terse or prose, whatever it is.
+3. Rewrite the message in that style, keeping only what carries the change for a handoff. Cut the rest: stale or half-true lines, context or principles already documented elsewhere, and mechanical or derivable trivia (version bumps, file registration, platform or scope enumerations, "also updated X"). One point per real change — fold a minor change into a related point instead of giving it its own line; never pad to a length.
+4. Re-commit signed, with dates per the rule below: for the tip you're finalizing (`HEAD`), a plain `git commit --amend -S` lets both dates default to now; to keep an older commit's dates, rebuild it with `GIT_AUTHOR_DATE`/`GIT_COMMITTER_DATE git commit-tree <tree> -p <parent> -S` and move the branch ref. For a range, the tip restamps and the rest preserve.
+5. Verify and report.
+
+## Rules
+
+- **Never create or suggest a commit** — re0-git only rewrites the message of a commit that already exists. Using it is never a reason to commit.
+- **Message only** — the tree must stay byte-identical (`git diff <old> <new>` empty); never edit content in a re0-git pass.
+- **Match the author's style, don't impose one** — no mandated convention, structure, tone, or emoji. Mirror their existing log; a one-line head stays a one-line head.
+- **Keep the essence, cut the trivia** — leave only what a fresh session needs to hand off from the log; no padding, no mechanical or derivable noise. The log is the single source of truth for the change.
+- **Dates by position; always gpg-signed.** The commit you're finalizing — `HEAD` — takes both author and committer date = now, because re-cleaning the latest commit is itself continued work. Every older commit (`HEAD~1` and back) keeps its original author + committer dates; never restamp the past.
+- **Never rewrite pushed or shared history** without explicit confirmation — it forces a force-push.
+
+## Verification
+
+1. `git diff <old-tip> <new-tip>` is empty — content unchanged.
+2. Each rewritten commit is gpg-signed (`%G?` = `G`) with dates as intended.
+3. `git log` reads clean in the author's own style and is enough for handoff on its own.

package/skills/single/shower/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: shower
+description: "Cold-read the artifact you're focused on from a fresh, zero-context sub-session to confirm it stands on its own — a shower-thought reset for accumulated session bias. Use when a long session has worn away your fresh eyes and you can no longer tell whether the artifact in focus is clear to someone with no prior context; before a handoff, publish, or merge; or when you want a clean-room comprehension smoke test. Spawns a separate context-free reviewer; it diagnoses, it does not fix."
+---
+
+Step out of the session and let a clean mind read it: does the artifact stand on its own?
+
+## Goal
+
+A long session quietly accumulates context you can't un-see, so you lose the ability to judge whether your work reads clearly to a first-timer — you no longer know what you left unsaid (the unknown-unknowns). The fix is a literally fresh brain: a separate sub-session that never saw this conversation cold-reads the artifact in focus and reports where a clean reader would stall. A smoke test for comprehension and handoff. This skill diagnoses; fixing happens back here (often with `re0`).
+
+## Workflow
+
+1. Pin the scope: the artifact (or set) currently in focus. If "in focus" is ambiguous, confirm with the user or take the artifact just produced or under discussion. Privately note, in one line, what it is meant to be and who it is for — your yardstick for step 4; the reviewer never sees it.
+2. Launch a **fresh sub-session** (a subagent / Task — it starts context-free). Hand it the artifact's **contents** (inline, or a copy), not a repo path, and tell it not to open the project's README, docs, or neighboring files that would spoil the cold read. Give it nothing about your intent or reasoning.
+3. Have it cold-read blind and report, from the artifact alone:
+   - what it takes the artifact to be, do, and expect;
+   - what is unclear, ambiguous, or assumed-but-unstated;
+   - what it would need to act confidently, and what it had to guess (the unknown-unknowns).
+4. Compare its blind understanding against the intent you noted in step 1 (which it never saw). Every mismatch is a defect in the artifact, not a reader error.
+5. Report the defects and concrete fixes, ordered by how badly each blocks a fresh reader.
+
+## Rules
+
+- The read MUST come from a separate, context-free sub-session — never self-assess in this session, because you can't un-see the context (that is the whole point).
+- Hand over material, withhold meaning: pass the artifact's contents, never your intent; pass contents, not a path; keep it from reading explainer or neighboring files that leak intent.
+- A forced "I had to assume…" is a finding, not a reader failure.
+- Medium-agnostic: adapt the cold-read questions to what the artifact is.
+- Diagnose only — fix back in the main session.
+
+## Verification
+
+Before finishing:
+
+1. The read came from a fresh sub-session blind to your intent.
+2. Findings are concrete — what a fresh reader misunderstood, couldn't do, or had to guess — each with a fix.
+3. Report the verdict (stands on its own / needs work) and hand the fixes to the main session.

package/skills/single/tasting/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: tasting
+description: "After you create or change an artifact or skill, taste-test it with our own skills instead of trusting your in-session judgment — recursive self-improvement, made automatic. Use right after writing or editing anything, before calling it done, committing, or handing it off: cold-read it with shower, check repo consistency with ssotchk, and tidy with re0. Model-invoked so it fires even in a brand-new session."
+---
+
+Taste your own cooking: the moment you finish making something, check it with the very skills this repo ships before you serve it.
+
+## Goal
+
+A reminder buried in docs ("remember to verify") won't reliably fire in a fresh session. `tasting` makes the recursive self-improvement loop a triggered habit: right after any create or change, run our own skills on the result so quality doesn't ride on the author's biased in-session judgment. It orchestrates; the individual skills do the work.
+
+## Workflow
+
+1. Spot the trigger: you just created or changed an artifact or skill and are about to call it done, commit, or hand it off.
+2. **Cold-read it** — run `shower` on the artifact (fresh-eyes comprehension / handoff check).
+3. **Check consistency** — run `ssotchk` across the repo for anything the change duplicated or contradicted; `ssotize` if it found scatter.
+4. **Tidy** — `re0` the changed docs so the result reads as a clean v0, not a patch over a draft.
+5. Apply the findings here, then serve it.
+
+## Rules
+
+- Trigger on your OWN output, right after making it — that's when bias is highest and a check is cheapest.
+- Use the skills; don't re-implement them (`shower` for clarity, `ssotchk`/`ssotize` for SSOT, `re0` for cleanup).
+- Skip what plainly doesn't apply (a one-line change may need only `ssotchk`), but say what you skipped and why.
+- Findings flow back to the author session to fix — `tasting` routes, it doesn't replace the fixing skills.
+- Stop at the artifact — `tasting` never touches git or makes commits. Cleaning a commit's message is a separate, user-invoked step (`re0-git`), and `tasting` must not chain to it.
+
+## Verification
+
+Before finishing:
+
+1. The change was actually run through the relevant skills, not eyeballed.
+2. Findings were applied (or consciously deferred with a stated reason).
+3. The result would survive a fresh-session look — which is exactly what `shower` just checked.