paperthin 0.5.0 → 0.6.0

package/.claude-plugin/plugin.json

@@ -1,12 +1,15 @@
-{
-  "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"
-  ]
-}
+{
+  "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/depth/factchk",
+    "./skills/depth/mandela",
+    "./skills/depth/re0",
+    "./skills/depth/re0-git",
+    "./skills/depth/redteam",
+    "./skills/depth/shower",
+    "./skills/depth/sip",
+    "./skills/breadth/ssotchk",
+    "./skills/breadth/ssotize"
+  ]
+}

package/.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - name: Validate the skill catalog
+        run: bash scripts/validate-skills.sh

package/.github/workflows/release.yml

@@ -0,0 +1,39 @@
+name: release
+
+on:
+  push:
+    tags: ['v*.*.*']
+
+permissions:
+  contents: write     # create the GitHub Release
+  id-token: write     # npm provenance via OIDC
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+
+      - name: Validate the skill catalog
+        run: bash scripts/validate-skills.sh
+
+      - name: Verify tag matches package.json
+        run: |
+          PKG=$(node -p "require('./package.json').version")
+          TAG=${GITHUB_REF_NAME#v}
+          test "$PKG" = "$TAG" || { echo "tag $TAG != package.json $PKG"; exit 1; }
+
+      - name: Publish to npm (public, with provenance)
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Create the GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh release create "$GITHUB_REF_NAME" --title "PaperThin ${GITHUB_REF_NAME#v}" --notes-from-tag

package/CLAUDE.md

@@ -1,10 +1,10 @@
 # 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).
+PaperThin is an agent-agnostic suite of plain-Markdown skills that keep an artifact **clean and true** — hygiene reflexes an agent reaches for on its own. This is the guide for authoring them — and itself a skill artifact, so `re0` it when it drifts. Every skill it names below — `re0`, `factchk`, `redteam`, … — is defined in the shipped catalog, the [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.
+- **Trust the artifact, not the author.** A skill exists to make work read true to someone who wasn't there — *clear* (does it read?) and *correct* (is what it claims real?). The maker's in-session mind is the worst judge of either — 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.
@@ -15,12 +15,20 @@ The guide for authoring these skills — and itself a skill artifact, so `re0` i
 skills/<perspective>/<name>/SKILL.md
 ```
 
-Group by **artifact perspective** — which is the suite's two vectors made physical:
+Topic domains belong in separate plugins, so within a plugin the only durable cut is **perspective**. One skill = one directory with a `SKILL.md`.
 
-- `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`).
+That cut is two orthogonal axes, **cardinality × time**:
 
-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`.
+- `depth/` — **one artifact, now**: refine or verify the thing in hand (`re0`, `re0-git`, `shower`, `sip`, `factchk`, `mandela`, `redteam`).
+- `breadth/` — **many artifacts, now**: reconcile one truth across files and platforms (`ssotchk`, `ssotize`).
+- `coil/` — **one project, across iterations**: carry learning between build cycles *(reserved, v0.7)*.
+- `mesh/` — **many minds, across rounds**: converge many independent views into consensus *(reserved, v0.8)*.
+
+**File by trigger-scope, not by what a skill invokes.** A skill lives where the work it *triggers or emits* ranges, even when it orchestrates skills from other folders — `sip` gates one finished deliverable, so it's `depth/`, though its check runs a cross-file `ssotchk`.
+
+Reach for `breadth/` 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. Keep drafts and retired skills out of the README and `plugin.json`.
+
+**Name it for the reflex it fires** — a plain real word (`shower`, `sip`) or a tight compression of a real term (`re0`, `ssotchk`, `ssotize`); a stranger should half-guess what it does from the name alone, so no opaque coinage. A self-evident metaphor-noun is allowed only as a deliberate exception, when its own intuition carries it.
 
 ## SKILL.md format
 
@@ -28,6 +36,7 @@ Reach for `cross/` to *establish* order (legacy refactor, knowledge-base build,
 ---
 name: <kebab-name>            # matches the directory and the invocation
 description: "<trigger-rich one-liner>"
+# disable-model-invocation: true   ← user-invoked skills only
 ---
 
 <one line: what the skill does>
@@ -42,7 +51,14 @@ description: "<trigger-rich one-liner>"
 
 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.
+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 `sip`. Two qualify today: `re0-git` (it cleans a commit's message — committing is human-decided) and `redteam` (a kill-it reflex always in the agent's reach would bias it toward demolition).
+
+## Conventions
+
+Shared rules a skill references rather than restates:
+
+- **edit-safety** (any mutating skill — `re0`, `ssotize`): a find-replace that could match nothing must **assert its target exists** (report a MISS, never silently no-op); byte-level tools corrupt multibyte text, so mutate with a **unicode-safe** pass (`PYTHONUTF8=1`, stdout reconfigured to UTF-8); never **blanket-replace a single target whose right replacement is positional** (the same token mapping to different replacements per location) — decide per occurrence, never a blind sweep; and make large *structural* moves with a script, not by retyping.
+- **negatives-as-corpus**: "cut" means **move-to-archive, never delete** — pruned and failed branches are assets, not waste.
 
 ## Shipping
 
@@ -52,7 +68,7 @@ Before committing:
 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.
+5. Run **`sip`** — `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.
 

package/README.md

@@ -1,132 +1,179 @@
-<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).
+<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) · [Index](#index) · [The Map](#the-map) · [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.
+
+## Index
+
+### Model-invoked — your agent reaches for these on its own
+| Skill | Scope | What it does |
+|---|---|---|
+| ♻️ **[re0](./skills/depth/re0/SKILL.md)** | one artifact | Rewrite a drifted artifact into a clean v0 — not another patch |
+| 🚿 **[shower](./skills/depth/shower/SKILL.md)** | one artifact | Cold-read it with fresh, zero-context eyes — does it stand on its own? *(read-only)* |
+| 🔬 **[factchk](./skills/depth/factchk/SKILL.md)** | one claim | Verify a reality-grounded claim against sources, both directions — could the absurd be real, the obvious false? *(read-only → fix)* |
+| 🧪 **[mandela](./skills/depth/mandela/SKILL.md)** | one eval | Audit a validation for leakage — does outside ground-truth actually enter? Walks 8 patterns *(read-only)* |
+| 🔎 **[ssotchk](./skills/breadth/ssotchk/SKILL.md)** | many artifacts | Find where one fact is scattered or duplicated; name the canonical source *(read-only)* |
+| 🧲 **[ssotize](./skills/breadth/ssotize/SKILL.md)** | many artifacts | Consolidate it into one home and point the rest at it |
+| 🥄 **[sip](./skills/depth/sip/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/depth/re0-git/SKILL.md)** | one commit | Rewrite a finished commit's message into a clean v0 so `git log` alone hands off |
+| ⚔️ **[redteam](./skills/depth/redteam/SKILL.md)** | one plan | Try to kill it before reality does — the one root flaw + the cheapest experiment that falsifies it |
+
+## The Map
+
+**How many artifacts, and across how much time?**
+
+Two axes — **cardinality × time** — carve four regions.
+
+<div align="center">
+<img src="https://raw.githubusercontent.com/LilMGenius/paperthin/main/assets/map.svg" alt="The PaperThin map: a two-by-two matrix. Horizontal axis cardinality (one, then many); vertical axis time (now, then across iterations); four regions. Top-left, depth: one artifact, now; is this one thing clean and true? Top-right, breadth: many artifacts, now; is one truth consistent everywhere? Bottom-left, coil: one project, across iterations; did each pass teach the next? Bottom-right, mesh: many minds, across rounds; does the crowd converge on truth?" width="820">
+</div>
+
+## 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,
+- `sip` 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
+
+<!-- Fixes follow the lifecycle of a piece of work, not the skill list: first keep it clean (draft → read fresh → reconcile across files → automate → ship), then keep it true (a single claim → a validation → the whole plan). Slot any new fix in by where it acts in that arc. -->
+
+**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 → `sip`:** 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>
+
+> [!NOTE]
+> The five fixes above keep an artifact **clean**. The next three keep it **true** — the same distrust of the author, turned on the reasoning instead of the prose.
+
+### #6 — Your gut isn't a source
+"Plausible," "absurd," "novel" — the least reliable line in any artifact. Human priors fail **both ways**: they exclude the real (desert frogs exist) and normalize the impossible (weightless crates).
+
+**The fix → `factchk`:** verify any reality-grounded claim against external sources, in both directions, before it ships — and flag, don't guess, when you can't reach one.
+
+> *Prior art: [WEIRD bias](https://www.cambridge.org/core/journals/behavioral-and-brain-sciences/article/abs/weirdest-people-in-the-world/BF84F7517D56AFF7B7EB58411A554C17) (Henrich, Heine & Norenzayan, 2010) and the [naive-physics / impetus error](https://www.science.org/doi/10.1126/science.210.4474.1139) (McCloskey, Caramazza & Green, 1980) — intuition misjudges reality in both directions.*
+
+<details>
+<summary><b>[PROOF]</b></summary>
+
+- **Setup** — we ran `factchk` on its own shipped citations, in both directions.
+- **Result** — all held, and it still caught two attribution slips to fix: the famous "what's measured becomes the target" wording is Strathern (1997), not Goodhart; and "McCloskey 1980" is the co-authored *Science* paper, not the 1983 *Scientific American* piece.
+- **So** — a fact-checker that audits its own footnotes will audit yours.
+</details>
+
+### #7 — The eval confirms itself
+A model, a scorer, and a designer can all agree a result is real while no outside ground-truth ever entered the loop — a whole room confidently remembering something that never independently happened.
+
+**The fix → `mandela`:** audit any eval, metric, or experiment against an 8-pattern leakage taxonomy — does external ground-truth enter independently, or is the verifier the designer?
+
+> *Prior art: [Goodhart's law](https://en.wikipedia.org/wiki/Goodhart%27s_law), [data leakage](https://dl.acm.org/doi/10.1145/2382577.2382579) (Kaufman et al., 2012), and [circular analysis](https://www.nature.com/articles/nn.2303) — "double dipping" (Kriegeskorte et al., 2009).*
+
+### #8 — You can't kill your own plan
+You built it, so you defend it. The questions that would break it are exactly the ones you won't ask.
+
+**The fix → `redteam`:** try to kill the plan before reality does — return the single load-bearing flaw and the cheapest experiment that would falsify it (the "first nail"), not a checklist. User-invoked: you point it at a plan deliberately.
+
+> *Prior art: [egoless programming](https://en.wikipedia.org/wiki/Egoless_programming) (Weinberg, 1971 — the same root `shower` cites), red-teaming, and fail-fast.*
+
+## 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/map.svg

@@ -0,0 +1,53 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 740" width="1080" height="740" role="img" aria-label="The PaperThin map: a two-by-two matrix. Horizontal axis cardinality (one, then many); vertical axis time (now, then across iterations); four regions. Top-left, depth: one artifact, now; is this one thing clean and true? Top-right, breadth: many artifacts, now; is one truth consistent everywhere? Bottom-left, coil: one project, across iterations; did each pass teach the next? Bottom-right, mesh: many minds, across rounds; does the crowd converge on truth?">
+  <rect width="1080" height="740" fill="#FCFCFA"/>
+
+  <!-- header rule + eyebrow -->
+  <line x1="132" y1="74" x2="1024" y2="74" stroke="#DCDBD3" stroke-width="1"/>
+  <text x="132" y="56" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="14" font-weight="400" letter-spacing="4.5" fill="#8C8C86">CARDINALITY &#215; TIME &#8212; FOUR REGIONS</text>
+
+  <!-- live row tint (depth + breadth = available now) -->
+  <rect x="132" y="96" width="892" height="262" fill="#F4F3ED"/>
+
+  <!-- matrix frame + internal cross -->
+  <rect x="132" y="96" width="892" height="524" fill="none" stroke="#1B1B1A" stroke-width="1.3"/>
+  <line x1="578" y1="96" x2="578" y2="620" stroke="#1B1B1A" stroke-width="1"/>
+  <line x1="132" y1="358" x2="1024" y2="358" stroke="#1B1B1A" stroke-width="1"/>
+
+  <!-- depth -->
+  <text x="166" y="200" font-family="Georgia,'Times New Roman',serif" font-size="44" fill="#1B1B1A">depth</text>
+  <text x="168" y="234" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="17" fill="#6F6F69">one artifact, now</text>
+  <text x="168" y="266" font-family="Georgia,'Times New Roman',serif" font-size="16" font-style="italic" fill="#2F5374">is this one thing clean &amp; true?</text>
+
+  <!-- breadth -->
+  <text x="612" y="200" font-family="Georgia,'Times New Roman',serif" font-size="44" fill="#1B1B1A">breadth</text>
+  <text x="614" y="234" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="17" fill="#6F6F69">many artifacts, now</text>
+  <text x="614" y="266" font-family="Georgia,'Times New Roman',serif" font-size="16" font-style="italic" fill="#2F5374">is one truth consistent everywhere?</text>
+
+  <!-- coil (forthcoming) -->
+  <text x="166" y="462" font-family="Georgia,'Times New Roman',serif" font-size="44" fill="#9A9A93">coil</text>
+  <text x="168" y="496" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="17" fill="#9A9A93">one project, across iterations</text>
+  <text x="168" y="528" font-family="Georgia,'Times New Roman',serif" font-size="16" font-style="italic" fill="#A6A69E">did each pass teach the next?</text>
+  <g transform="translate(466 380)">
+    <rect x="0" y="0" width="70" height="25" rx="3" fill="none" stroke="#B6B6AE" stroke-width="1"/>
+    <text x="35" y="17" text-anchor="middle" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="12" letter-spacing="1" fill="#8C8C86">v0.7</text>
+  </g>
+
+  <!-- mesh (forthcoming) -->
+  <text x="612" y="462" font-family="Georgia,'Times New Roman',serif" font-size="44" fill="#9A9A93">mesh</text>
+  <text x="614" y="496" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="16.5" fill="#9A9A93">many minds, across rounds</text>
+  <text x="614" y="528" font-family="Georgia,'Times New Roman',serif" font-size="16" font-style="italic" fill="#A6A69E">does the crowd converge on truth?</text>
+  <g transform="translate(908 380)">
+    <rect x="0" y="0" width="70" height="25" rx="3" fill="none" stroke="#B6B6AE" stroke-width="1"/>
+    <text x="35" y="17" text-anchor="middle" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="12" letter-spacing="1" fill="#8C8C86">v0.8</text>
+  </g>
+
+  <!-- x axis labels -->
+  <text x="355" y="656" text-anchor="middle" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="15" fill="#5A5A55">one</text>
+  <text x="801" y="656" text-anchor="middle" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="15" fill="#5A5A55">many</text>
+  <text x="578" y="690" text-anchor="middle" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="13" letter-spacing="3.5" fill="#9A9A93">CARDINALITY</text>
+
+  <!-- y axis labels -->
+  <text x="104" y="227" text-anchor="middle" transform="rotate(-90 104 227)" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="15" fill="#5A5A55">now</text>
+  <text x="104" y="489" text-anchor="middle" transform="rotate(-90 104 489)" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="15" fill="#5A5A55">across iterations</text>
+  <text x="72" y="358" text-anchor="middle" transform="rotate(-90 72 358)" font-family="'Helvetica Neue',Helvetica,Arial,sans-serif" font-size="13" letter-spacing="3.5" fill="#9A9A93">TIME</text>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperthin",
-  "version": "0.5.0",
+  "version": "0.6.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",
@@ -14,6 +14,10 @@
     "dedupe",
     "clean-code",
     "verification",
+    "fact-check",
+    "leakage",
+    "red-team",
+    "reasoning-hygiene",
     "documentation",
     "knowledge-base",
     "git"

package/scripts/validate-skills.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Validate the skill catalog against the conventions in CLAUDE.md + docs/invocation.md.
+# The single source of truth for "is the catalog shippable" — called by release.yml
+# (pre-publish), ci.yml (every push/PR), and runnable locally (e.g. from sip).
+set -uo pipefail
+cd "$(dirname "$0")/.."
+
+fail=0
+err() { echo "::error::$*"; fail=1; }   # GitHub annotation on CI; prints plainly off-CI
+
+# plugin.json must be valid JSON
+node -e "JSON.parse(require('fs').readFileSync('.claude-plugin/plugin.json','utf8'))" 2>/dev/null \
+  || err "plugin.json is not valid JSON"
+
+# the brand one-liner is single-sourced: package.json and plugin.json must agree
+pkg_desc=$(node -p "require('./package.json').description" 2>/dev/null)
+plg_desc=$(node -p "require('./.claude-plugin/plugin.json').description" 2>/dev/null)
+[ "$pkg_desc" = "$plg_desc" ] || err "package.json and plugin.json 'description' differ — keep the brand one-liner in sync"
+
+while IFS= read -r f; do
+  d=$(dirname "$f"); name=$(awk -F': *' '/^name:/{print $2; exit}' "$f")
+  grep -q '^description:' "$f"                       || err "$f: missing 'description'"
+  [ -n "$name" ]                                     || err "$f: missing 'name'"
+  [ "$name" = "$(basename "$d")" ]                   || err "$f: name '$name' != directory '$(basename "$d")'"
+  grep -qF "\"./$d\"" .claude-plugin/plugin.json     || err "$d: not registered in plugin.json"
+  grep -qF "$d/SKILL.md" README.md                   || err "$d: not listed in README.md"
+  grep -q '\.\./' "$f"                               && err "$f: deep cross-file ref ('../') — compose by naming, not relative links"
+done < <(find skills -name SKILL.md)
+
+# every plugin.json skill path resolves to a SKILL.md
+while IFS= read -r p; do
+  [ -f "$p/SKILL.md" ] || err "plugin.json: '$p' has no SKILL.md"
+done < <(grep -oE '\./skills/[A-Za-z0-9/_-]+' .claude-plugin/plugin.json)
+
+if [ "$fail" -eq 0 ]; then
+  echo "✓ skill catalog valid ($(find skills -name SKILL.md | wc -l | tr -d ' ') skills)"
+else
+  echo "✗ catalog validation failed"; exit 1
+fi

package/skills/{cross → breadth}/ssotchk/SKILL.md

@@ -7,16 +7,16 @@ Find every place a single truth lives, name its rightful home, and report the dr
 
 ## 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.
+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.
+A different vector from `re0` (depth, one artifact); once a fact is cleanly SSOT'd, keep it tidy with `re0`. Reach for SSOT when establishing order.
 
 ## 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).
+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); never arbitrarily.
 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.
 
@@ -24,7 +24,6 @@ Locate Single-Source-of-Truth (SSOT) violations: one fact duplicated, paraphrase
 
 - 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.
@@ -34,7 +33,6 @@ Locate Single-Source-of-Truth (SSOT) violations: one fact duplicated, paraphrase
 
 Before finishing:
 
-1. Every occurrence is accounted for — none left unclassified.
+1. Re-enumerate by a second method — a different search term, synonym, or tool — and confirm it surfaces no occurrence the report missed. Completeness is the core SSOT risk: a copy you never found is a copy that will drift.
 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.
+3. The report is actionable: a human or `ssotize` could execute it without re-discovering anything.

package/skills/{cross → breadth}/ssotize/SKILL.md

@@ -9,26 +9,21 @@ Collapse a scattered truth into one canonical home; make every other place point
 
 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`.)
+Use this to **establish or repair** SSOT — messy, legacy, or freshly-scaffolded states. 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.
+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.
+- Be platform-aware: transclude where possible, else link to a stable anchor the reader can follow; prefer a reference over a hard deletion when a platform can't link back.
 
 ## Verification
 

package/skills/depth/factchk/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: factchk
+description: "Verify reality-grounded claims against external sources in both directions before they ship — could the 'absurd' be real, could the 'obvious' be false or long-established? Use whenever an artifact, or the sentence you are about to write, asserts something as plausible, realistic, absurd, novel, or impossible from intuition rather than a checked source; before relying on a factual claim in prose, a design rationale, a research claim, or a plan. Fires on metacognitive doubt — when you can't actually know, verify instead of trusting the feeling. Scans read-only, then fixes the clear errors or flags the judgment calls; leaves deliberate fiction alone."
+---
+
+Check what's asserted as real against reality — in both directions — before it ships.
+
+## Goal
+
+The author's "plausible / absurd / novel" is the least reliable line in any artifact. Human priors fail **both ways** — they exclude the real (desert frogs exist) and normalize the impossible (weightless crates). `factchk` scans claims presented as reality-grounded, verifies each against external sources in both directions, and fixes or flags. A claim about *the world* is `factchk`; for a validation's soundness see `mandela`, for the whole plan see `redteam`.
+
+## Workflow
+
+1. Scan for **reality-grounded assertions** — anything leaning on "this is plausible / realistic / absurd / novel / impossible because X," including the claim you are *about to write*, not only those already on the page.
+2. Verify each against **external sources** (web search, open references) in **both directions**: could the "absurd" be real? could the "obvious" or "novel" be false or long-established? If you cannot reach a source, **flag — never assert from intuition**.
+3. **Fix or flag:** a mechanically-clear error (a wrong date, a misattributed source, a falsified number) → correct it with a cited source; a judgment call (a contested or interpretive claim) → surface it, don't silently rewrite.
+4. Report each claim, its verdict, the source, and — for a failed claim — which direction it failed.
+
+## Rules
+
+- Target claims asserted **as reality-grounded**, never deliberate fiction ("in our world, boxes float" is a declared choice). When it is unclear whether a claim is an in-world choice or a real-world assertion, **flag, don't fix** — the hardest call in the skill.
+- Flagging only the unrealistic catches half the errors.
+- The trigger is **metacognition, not knowledge**: you can't know every domain, so the moment you are about to assert a checkable fact from a feeling, verify it instead of trusting the feeling.
+- A pass that finds nothing changes nothing.
+
+## Verification
+
+Before finishing: every verdict traces to a citable external source, not a reworded prior intuition — and the report reads as fixes-vs-flags, not restated intuitions.

package/skills/depth/mandela/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: mandela
+description: "Audit any eval, metric, experiment, or benchmark for leakage — does external ground-truth enter independently, or are the model, scorer, and designer just confirming a result no outside truth ever produced? Use before trusting any 'how we'll know it worked' — an A/B, a holdout, a score, a validation — and whenever a result feels too clean or self-confirming. Walks an 8-pattern leakage taxonomy and returns only the patterns that fire, each with an independence fix. Read-only."
+---
+
+Audit a validation for leakage: does outside ground-truth actually enter, or is everyone confirming a result no one independently produced?
+
+## Goal
+
+The name is the **Mandela Effect** — a whole population *confidently remembers* something that never independently happened; a leaky validation is the same shape. Walk the 8 patterns below. `mandela` checks whether a *validation* is independent; `factchk` checks a claim against the world, and `redteam` calls `mandela` for the leakage axis of a design.
+
+## Workflow
+
+1. Identify the validation (eval / metric / experiment / holdout / "how we'll know"). Name its **components** — what plays model, scorer, designer, dataset.
+2. Ask the **core question**: does external ground-truth enter *independently*?
+3. Test the validation against all **8 patterns** below (some apply only to certain components — a human subject, a scorer); report only the ones that fire, each by name.
+4. Give the independent-ground-truth fix for each hit.
+
+## The 8 leakage patterns
+
+1. **Recall, not reason** — a memorized answer recited instead of one actually derived; the system already knows the result it is supposedly computing.
+2. **Wrong null hypothesis** — an ablation that removes a surface label but not the underlying signal the system actually exploits, so the "control" still leaks.
+3. **Shared hallucination** — two components verifying each other; circularity reported as a number.
+4. **Tautology** — a scorer grading buckets it drew itself.
+5. **Verifier = designer** — a private, unreproducible recipe in a holdout's clothes.
+6. **Shared-pool bias** — train and holdout drawn from one labeler pool, so one bias enters both sides.
+7. **Frame injection** — a question that hands the subject the hypothesis.
+8. **Demand characteristics** — measured subjects who know they're being measured.
+
+## Rules
+
+- Subtlety that bites twice: you can blind the **output value** and still leak the **collection recipe**.
+- Read-only — name the leak and the independence fix; don't rewrite the experiment.
+
+## Verification
+
+Turn mandela on this audit:
+
+1. Run patterns #3–#5 on yourself: are you a scorer grading buckets you drew (Tautology, #4)? is the verifier the designer (#5)? is your verdict a shared hallucination with the design's own claims (#3)?
+2. Could a reader who didn't run the audit reach your verdict from the cited evidence alone — independent ground-truth?
+3. The report names the root, not a laundry list.

package/skills/{single → depth}/re0/SKILL.md

@@ -7,9 +7,6 @@ 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.
 
@@ -32,13 +29,12 @@ should not read like a changelog, cleanup note, or patch over an older draft.
 - 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.
+- Fix machine-clear residue; surface judgment calls — never auto-resolve an ambiguity or "fix" a deliberate look-alike.
+- Repair from the source of truth — the canonical or sibling artifact, not the damaged surface — and mutate per the edit-safety convention (CLAUDE.md): never a blanket positional sweep.
 - 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.
+The result reads as a clean v0 to fresh eyes — no trace of the older draft, no
+sign it was patched rather than rewritten (defer to `shower` if unsure). Report
+what noise was removed and what durable truth was kept.

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

@@ -0,0 +1,38 @@
+---
+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. User-invoked: run it after a commit."
+---
+
+`re0` for git: rewrite a finished commit 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. Only the message moves — and timestamps, per the date rule below; the tree never changes.
+
+It is **user-invoked** (see docs/invocation.md) — run it once you've decided to commit. A commit-cleanup tool in the agent's reach would bias it toward committing when it shouldn't.
+
+## Workflow
+
+1. Scope the target — usually `HEAD`, sometimes a short unpushed range.
+2. Read the change (`git show --stat`, `git diff`) and any documented commit rules. Then sample nearby non-target messages: start with 10, stop earlier if the convention is obvious, or expand only until the convention is clear.
+3. Resolve mixed logs in this order: documented project rules, nearby commits touching the same area, then same-author commits within that convention. Do not average incompatible styles or let one author's habits override the repo.
+4. Rewrite the message in that style, keeping only durable handoff facts. Cut stale lines, motives already documented elsewhere, file lists, registration details, version/tag/package bumps, and any fact the diff or tag already proves. Fold supporting edits into the real change they serve; do not give trivia its own bullet.
+5. Re-commit signed, dates per the rule below. For the tip (`HEAD`): `git commit --amend -S`. For an older commit, keeping its dates: rebuild it — `GIT_AUTHOR_DATE`/`GIT_COMMITTER_DATE git commit-tree <tree> -p <parent> -S -m "<new message>"` — then replay every descendant onto the rebuilt commit (a non-tip rewrite is a rebase, not a ref move), or you orphan them.
+6. 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 local message economy** — mirror the nearby log's density as well as its shape: subject style, body/no-body choice, bullet style, punctuation, and what it leaves unsaid.
+- **In shared repos, match the repo before the person** — author voice matters only inside the repository's convention.
+- **Keep the essence, cut the trivia** — leave only what a fresh session needs to know next. Do not mention versions, tags, package metadata, file moves, generated artifacts, or validation plumbing unless they are the actual product 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. Re-read `git log` alone, diff hidden — if any cut line turns out to be needed to follow the change, restore it.

package/skills/depth/redteam/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: redteam
+disable-model-invocation: true
+description: "Adversarially try to KILL a plan, design, or argument before you commit to it — return the single load-bearing flaw and the cheapest experiment that would falsify it (the 'first nail'), not a checklist. Run it yourself when you're about to spend real effort on something; user-invoked on purpose, never auto-fired, because a kill-it reflex always in the agent's reach would bias it toward demolition. Composes factchk and mandela for the fact and leakage axes; it owns the synthesis to one root."
+---
+
+Try to kill the artifact, not improve it — return the one root flaw and the cheapest shot that fells it.
+
+## Goal
+
+Where `shower` asks "can a stranger follow this?" (comprehension), `redteam` asks "does this survive someone trying to break it?" (validity). It is the **superset** reflex: where `factchk` checks one fact and `mandela` audits one validation, `redteam` attacks the *whole* plan and collapses it to a single root. The highest-value output is never a checklist — it's one root cause plus the cheaper experiment hiding inside the elaborate plan.
+
+## Workflow
+
+1. Pin the **load-bearing assumption(s)** — what must hold for the whole thing to stand.
+2. Attack on whatever axes apply — the general ones first: **a load-bearing fact** that may be false (run `factchk`), **confabulation** (a post-hoc story treated as ground truth), **analogy-mistaken-for-isomorphism** (structure assumed to transfer across domains where it doesn't), **future-tense suture** (the argument leans on a result that doesn't exist yet), and the sharpest — **cites a principle but implements its opposite**; and for empirical / research plans, **leakage** (run `mandela`) and **statistical power / family-wise α** (a true hypothesis auto-failing from uncorrected tests; a near-zero-power condition that rubber-stamps regardless of truth).
+3. Collapse the findings to the **single root** cause — the one whose failure makes the others moot.
+4. Find the **first nail** — the cheapest falsification of the load-bearing assumption: the check (in time / cost / sample) that could kill it *before* the expensive program runs.
+5. Return `{ root, first_nail }` — not a list.
+
+## Rules
+
+- **Kill, don't improve** — improving is a different reflex.
+- Compose, don't duplicate — invoke `factchk` and `mandela` for their axes; you own the synthesis to one root.
+
+## Verification
+
+Before finishing:
+
+1. The root is genuinely load-bearing — the plan falls without it.
+2. The first nail is genuinely cheaper than the plan it would pre-empt.

package/skills/{single → depth}/shower/SKILL.md

@@ -16,22 +16,21 @@ A long session quietly accumulates context you can't un-see, so you lose the abi
 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).
+   - what it would need to act confidently, and what it had to guess.
 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.
+- Pass the artifact's contents, never your 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.
+- **Read, don't sweep.** The cold-read is an end-to-end read, not a pattern-grep — a sweep catches only known patterns and misses stale refs, dead links, fact drift, and silent edit-damage. Track how much was actually read; never report "clean" from a grep alone.
 
 ## 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.
+2. Report the verdict (stands on its own / minor gaps / needs work) and hand the fixes to the main session.

package/skills/{single/tasting → depth/sip}/SKILL.md

@@ -1,13 +1,13 @@
 ---
-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."
+name: sip
+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."
 ---
 
 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.
+A reminder buried in docs ("remember to verify") won't reliably fire in a fresh session. `sip` 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.
 
 ## Workflow
 
@@ -20,10 +20,9 @@ A reminder buried in docs ("remember to verify") won't reliably fire in a fresh
 ## 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).
+- Use the skills; don't re-implement them (`shower` for clarity, `ssotchk`/`ssotize` for SSOT, `re0` for cleanup) — `sip` orchestrates and routes findings back to the author session to fix; the skills do the work.
 - 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.
+- Stop at the artifact — `sip` never touches git or makes commits. Cleaning a commit's message is a separate, user-invoked step (`re0-git`), and `sip` must not chain to it.
 
 ## Verification
 
@@ -31,4 +30,4 @@ 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.
+3. The artifact actually changed as a result (a diff exists), or every skipped skill has a stated reason.

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

@@ -1,36 +0,0 @@
----
-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.