paperthin 0.5.0 → 0.7.0

package/assets/map.svg

@@ -0,0 +1,103 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 740" width="1080" height="740" role="img" aria-label="The PaperThin map: an old-paper four-quadrant graph. Horizontal axis cardinality moves from one to many; vertical axis time moves from now to across iterations. Depth is one artifact now, breadth is many artifacts now, coil is one project across iterations, and mesh is many minds across rounds.">
+  <defs>
+    <filter id="paper-grain" x="-10%" y="-10%" width="120%" height="120%">
+      <feTurbulence type="fractalNoise" baseFrequency="0.82" numOctaves="4" seed="23" result="noise"/>
+      <feColorMatrix in="noise" type="matrix" values="0.32 0 0 0 0.58 0 0.28 0 0 0.51 0 0 0.22 0 0.38 0 0 0 0.16 0" result="warmNoise"/>
+      <feBlend in="SourceGraphic" in2="warmNoise" mode="multiply"/>
+    </filter>
+
+    <pattern id="small-grid" width="20" height="20" patternUnits="userSpaceOnUse">
+      <path d="M 20 0 H 0 V 20" fill="none" stroke="#9FB0B7" stroke-width="0.65" opacity="0.32"/>
+    </pattern>
+
+    <pattern id="large-grid" width="100" height="100" patternUnits="userSpaceOnUse">
+      <rect width="100" height="100" fill="url(#small-grid)"/>
+      <path d="M 100 0 H 0 V 100" fill="none" stroke="#758890" stroke-width="1" opacity="0.34"/>
+    </pattern>
+
+    <marker id="arrow" viewBox="0 0 10 10" refX="8.5" refY="5" markerWidth="9" markerHeight="9" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#2D2A24"/>
+    </marker>
+  </defs>
+
+  <rect width="1080" height="740" fill="#E7D9B8"/>
+  <rect x="38" y="28" width="1004" height="684" rx="2" fill="#F4E8C8" filter="url(#paper-grain)"/>
+  <rect x="38" y="28" width="1004" height="684" rx="2" fill="none" stroke="#B9A778" stroke-width="1.2"/>
+
+  <!-- notebook stains and deckled age marks -->
+  <path d="M 74 70 C 178 48, 246 64, 346 48 C 480 27, 607 48, 738 40 C 844 34, 942 45, 1010 70" fill="none" stroke="#C8B47A" stroke-width="3" opacity="0.16"/>
+  <path d="M 58 656 C 189 682, 330 650, 474 674 C 596 694, 733 661, 881 680 C 944 688, 997 676, 1025 662" fill="none" stroke="#B59663" stroke-width="4" opacity="0.12"/>
+  <circle cx="910" cy="116" r="56" fill="#B7834A" opacity="0.05"/>
+  <circle cx="188" cy="596" r="78" fill="#8B6C41" opacity="0.045"/>
+
+  <!-- red margin rule, like old graph paper -->
+  <line x1="112" y1="54" x2="112" y2="690" stroke="#B65443" stroke-width="1.4" opacity="0.52"/>
+
+  <!-- graph field -->
+  <rect x="146" y="92" width="846" height="536" fill="#F6ECCF"/>
+  <rect x="146" y="92" width="846" height="536" fill="url(#large-grid)"/>
+  <rect x="146" y="92" width="846" height="536" fill="none" stroke="#3A3328" stroke-width="1.4"/>
+
+  <!-- quadrant divider lines -->
+  <line x1="569" y1="92" x2="569" y2="628" stroke="#3A3328" stroke-width="1.1" stroke-dasharray="7 7"/>
+  <line x1="146" y1="360" x2="992" y2="360" stroke="#3A3328" stroke-width="1.1" stroke-dasharray="7 7"/>
+
+  <!-- arrowed axes -->
+  <line x1="146" y1="360" x2="1018" y2="360" stroke="#2D2A24" stroke-width="2.4" marker-end="url(#arrow)"/>
+  <line x1="569" y1="66" x2="569" y2="654" stroke="#2D2A24" stroke-width="2.4" marker-end="url(#arrow)"/>
+  <circle cx="569" cy="360" r="4.2" fill="#2D2A24"/>
+
+  <!-- axis labels -->
+  <text x="584" y="660" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#3C352A">time</text>
+  <text x="920" y="350" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#3C352A">cardinality</text>
+  <text x="356" y="656" text-anchor="middle" font-family="'Courier New',Courier,monospace" font-size="13" fill="#5C5448">one</text>
+  <text x="786" y="656" text-anchor="middle" font-family="'Courier New',Courier,monospace" font-size="13" fill="#5C5448">many</text>
+  <text x="82" y="229" font-family="'Courier New',Courier,monospace" font-size="13" fill="#5C5448">now</text>
+  <text x="64" y="492" font-family="'Courier New',Courier,monospace" font-size="13" fill="#5C5448">across</text>
+  <text x="64" y="510" font-family="'Courier New',Courier,monospace" font-size="13" fill="#5C5448">iterations</text>
+
+  <!-- title note -->
+  <text x="151" y="66" font-family="'Courier New',Courier,monospace" font-size="13" letter-spacing="1.6" fill="#6A5B42">CARDINALITY x TIME</text>
+  <text x="362" y="66" font-family="Georgia,'Times New Roman',serif" font-size="15" font-style="italic" fill="#6A5B42">four regions on one thin sheet</text>
+
+  <!-- depth -->
+  <g transform="translate(184 143)">
+    <text x="0" y="0" font-family="Georgia,'Times New Roman',serif" font-size="48" fill="#23211D">depth</text>
+    <line x1="0" y1="18" x2="132" y2="18" stroke="#7B3F2A" stroke-width="1.4" opacity="0.62"/>
+    <text x="0" y="52" font-family="'Courier New',Courier,monospace" font-size="16" fill="#4F493D">one artifact, now</text>
+    <text x="0" y="92" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#314C5B">is this one thing</text>
+    <text x="0" y="116" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#314C5B">clean and true?</text>
+  </g>
+
+  <!-- breadth -->
+  <g transform="translate(615 143)">
+    <text x="0" y="0" font-family="Georgia,'Times New Roman',serif" font-size="48" fill="#23211D">breadth</text>
+    <line x1="0" y1="18" x2="156" y2="18" stroke="#7B3F2A" stroke-width="1.4" opacity="0.62"/>
+    <text x="0" y="52" font-family="'Courier New',Courier,monospace" font-size="16" fill="#4F493D">many artifacts, now</text>
+    <text x="0" y="92" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#314C5B">is one truth</text>
+    <text x="0" y="116" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#314C5B">consistent everywhere?</text>
+  </g>
+
+  <!-- coil -->
+  <g transform="translate(184 422)">
+    <text x="0" y="0" font-family="Georgia,'Times New Roman',serif" font-size="48" fill="#23211D">coil</text>
+    <line x1="0" y1="18" x2="92" y2="18" stroke="#7B3F2A" stroke-width="1.4" opacity="0.62"/>
+    <text x="0" y="52" font-family="'Courier New',Courier,monospace" font-size="15" fill="#4F493D">one project, across iterations</text>
+    <text x="0" y="92" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#314C5B">did each pass</text>
+    <text x="0" y="116" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#314C5B">teach the next?</text>
+  </g>
+
+  <!-- mesh -->
+  <g transform="translate(615 422)" opacity="0.82">
+    <text x="0" y="0" font-family="Georgia,'Times New Roman',serif" font-size="48" fill="#5B554A">mesh</text>
+    <line x1="0" y1="18" x2="104" y2="18" stroke="#7B3F2A" stroke-width="1.2" opacity="0.36"/>
+    <text x="0" y="52" font-family="'Courier New',Courier,monospace" font-size="15" fill="#6A6255">many minds, across rounds</text>
+    <text x="0" y="92" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#6B6F67">does the crowd</text>
+    <text x="0" y="116" font-family="Georgia,'Times New Roman',serif" font-size="17" font-style="italic" fill="#6B6F67">converge on truth?</text>
+  </g>
+
+  <!-- hand-drawn registration ticks -->
+  <path d="M 132 88 l 18 0 M 142 78 l 0 18" stroke="#493F32" stroke-width="1" opacity="0.42"/>
+  <path d="M 978 632 l 18 0 M 988 622 l 0 18" stroke="#493F32" stroke-width="1" opacity="0.42"/>
+  <path d="M 132 632 l 18 0 M 142 622 l 0 18" stroke="#493F32" stroke-width="1" opacity="0.3"/>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperthin",
-  "version": "0.5.0",
+  "version": "0.7.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",
+    "adversarial-review",
+    "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/coil/flywheel/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: flywheel
+description: "Run repeated build-QA-retro-scratch cycles while preserving learning and letting code die. Use for long agentic projects where progress must be measured by quality-cleared templates, reusable modules, and eliminated anti-patterns rather than hours spent or features accumulated."
+---
+
+Run the cycle so learning compounds and code accumulation does not masquerade as
+progress.
+
+## Goal
+
+`flywheel` keeps a project moving through repeated turns:
+
+```text
+FRAME -> BUILD -> DRIVE -> RETRO -> HATE -> SCRATCH -> BUILD AGAIN
+```
+
+The unit of progress is not hours, files, panels, or features. It is the count of
+quality-cleared templates, reusable platform modules, and anti-patterns eliminated
+in later cycles.
+
+## Workflow
+
+1. Frame the thesis and quality gates.
+2. Build one complete vertical slice.
+3. Drive it through the real surface: browser for web apps, HTTP for API
+   contracts, computer-use for desktop apps, and CLI only for data-shaped
+   artifacts.
+4. Run `retro` to extract lessons, anti-patterns, and next-cycle gates.
+5. Decide whether the next pass iterates in place or uses `scratch`.
+6. Kill the next plan before build: use the project's adversarial review skill or
+   a human-invoked attack when that skill is user-only.
+7. Version only templates or modules that clear their gates.
+
+## Rules
+
+- Tests are supporting evidence, not the gate; every turn needs a real-surface
+  proof sized to the artifact.
+- Do not widen before the core loop clears.
+- Do not confuse generated variety with structural variety. If many outputs
+  converge to the same shape, the cycle failed the variety gate.
+- Preserve negative corpus so later cycles can prove the same anti-pattern is
+  gone.
+- Let code die. A restart that preserves the right lessons is progress.
+- Stop a lap when no outside truth enters; add evidence before another internal
+  pass.
+
+## Verification
+
+Before finishing a lap:
+
+1. The real surface was driven and evidence was captured.
+2. The retro names at least one lesson, anti-pattern, or gate that affects the
+   next pass.
+3. The keep/iterate/scratch decision is explicit.
+4. Any version label belongs only to a quality-cleared template or module.

package/skills/coil/nba/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: nba
+description: "Read the live cycle state and return the single highest-leverage next best action, not a menu. Use when a project is between phases, the author asks what to do next, too many valid threads are open, or the work needs re-entry into frame, build, drive, retro, hate, scratch, or ship."
+---
+
+Find the next best action from state, not from vibes.
+
+## Goal
+
+`nba` is the manual re-entry point for a stalled cycle. It reads the current state
+and returns one action: the cheapest move that clears the binding constraint. It
+does not execute the action and it does not offer a menu, because a menu recreates
+the paralysis it exists to resolve.
+
+## Workflow
+
+1. Read the live cycle state: plan gates, retro anti-patterns, priority notes,
+   recent git/file changes, QA evidence, and the current workflow phase.
+2. Locate the project in the cycle: FRAME, BUILD, DRIVE, RETRO, HATE, SCRATCH,
+   BUILD AGAIN, or SHIP.
+3. Diagnose the blank-out cause: too many open threads, lost thread, unnamed
+   blocker, closed-loop fatigue, avoidance of the hard step, or a phase that is
+   already done.
+4. Return one action: the cheapest move that clears the most. It may name the
+   right skill for the human to fire, the external input needed, the first nail to
+   test, or the phase transition that is already due.
+5. Frame it as: where you are, next best action, why now, and done when.
+
+## Rules
+
+- One action, not a checklist.
+- State-grounded, never generic. Cite the gate, doc, evidence, or file state that
+  drives the pick.
+- Return the avoided move, not the easy busywork.
+- If no outside truth is entering, the next action is external input, not another
+  internal lap.
+- If the gate is already met, the action is to move phase or ship, not add another
+  surface.
+- Read-only on the project. `nba` recommends; it does not execute.
+- Do not auto-invoke user-only skills. Tell the human when one is the next move.
+
+## Verification
+
+Before finishing:
+
+1. The recommendation cites the state it read.
+2. There is exactly one next action.
+3. The action has a clear "done when" observable.
+4. A reader can tell why this action beats the other visible options.

package/skills/coil/retro/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: retro
+description: "Turn a finished, failed, or disappointing work cycle into portable lessons, anti-patterns, quality gates, and next-cycle vocabulary. Use after a build, QA pass, demo, user complaint, or abandoned attempt when the useful output is what the next pass must learn rather than the code itself."
+---
+
+Turn a completed cycle into lessons the next cycle can actually use.
+
+## Goal
+
+`retro` extracts durable learning from a work cycle without defending the artifact
+that produced it. A cycle can run, pass tests, and still be the wrong thing. The
+output is not a changelog or therapy note: it is a local, evidence-backed record
+of what worked, what misled the build, and what gate the next pass must clear.
+
+Use `retro` when the artifact is done, failed, disappointing, or ambiguous enough
+that the next agent needs the cycle's lessons more than its momentum.
+
+## Workflow
+
+1. Read the original objective, final artifact, QA evidence, user complaints, and
+   any local planning notes.
+2. Separate working assets from misleading progress: contracts, schemas, tests,
+   services, vocabulary, and examples that earned reuse vs. UI, panels, scaffolds,
+   or abstractions that only looked productive.
+3. Name each failure as an anti-pattern, not a mood.
+4. Convert repeated or high-impact failures into quality gates for the next pass.
+5. Convert vague user direction into architecture vocabulary a fresh agent can
+   use.
+6. Write or refresh local docs for the cycle: a retro for lessons and a plan for
+   next-cycle contracts, gates, and vocabulary.
+7. Verify that a from-scratch agent could avoid the same failure from those docs
+   alone.
+
+## Rules
+
+- Do not defend the artifact. If it missed the product, say what missed.
+- Do not write a changelog. File lists and effort summaries are not lessons.
+- Preserve negative corpus. Failed paths are training data.
+- Prefer hard gates over advice.
+- Cite evidence from the cycle: objective, file facts, QA output, screenshots,
+  transcripts, diffs, or user feedback.
+- If the next agent cannot act on it, it is not a lesson yet.
+- Keep provenance local; shipped artifacts should not narrate their scars.
+
+## Verification
+
+Before finishing:
+
+1. Every lesson traces to observed cycle evidence.
+2. Every anti-pattern names a concrete failure mode and the gate that catches it.
+3. A fresh agent can tell what to preserve, what to discard, and what to test
+   first without reading the whole old session.

package/skills/coil/scratch/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: scratch
+description: "Restart a project or artifact from v0 while preserving only proven lessons, contracts, gates, vocabulary, real-surface tests, and negative corpus. Use when the foundation is wrong, accumulated code is misleading progress, or a new pass should learn from the old one without inheriting its accidental architecture."
+---
+
+Start over from what the previous cycle proved, not from what it happened to
+build.
+
+## Goal
+
+`scratch` is a controlled restart. It keeps earned knowledge and refuses to copy
+forward accidental architecture. Starting from scratch is not amnesia: contracts,
+schemas, vocabulary, real-surface tests, quality gates, and negative corpus survive
+when they earned it. Scaffold, explanatory UI, debug panels, shallow generated
+content, and code whose only value was learning what not to do do not.
+
+## Workflow
+
+1. Read the current plan, retro, local domain notes, QA evidence, and any user
+   complaint that triggered the restart.
+2. Identify what to preserve: contracts, schemas that survived QA, quality gates,
+   vocabulary, reusable services, real-surface tests, and negative corpus.
+3. Identify what to discard: explanatory UI, debug panels, scaffold, shallow
+   generated content, accidental abstractions, and code whose only value was
+   learning what not to do.
+4. Name the first quality gate before planning code.
+5. Write a v0 skeleton plan with one complete vertical loop.
+6. Build only the first loop until it clears the gate.
+
+## Rules
+
+- Starting from scratch means no copy-forward unless the artifact earned it.
+- One complete vertical loop beats many shallow surfaces.
+- Preserve provenance in local docs, not in the shipped product.
+- Do not rebuild around a vague lesson. Turn it into a gate or leave it out.
+- Do not delete negative corpus; archive or reference it where the next cycle
+  will see it.
+- If a reusable module survives, name the contract that proved it survives.
+
+## Verification
+
+Before finishing:
+
+1. The preserve/discard split is explicit and evidence-backed.
+2. The new v0 plan has one complete vertical loop and a named first gate.
+3. No old architecture is copied forward merely because it exists.
+4. A fresh builder can start without rereading the failed codebase.

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 `hate`.
+
+## 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/hate/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: hate
+disable-model-invocation: true
+description: "Attack a plan, design, or argument like you want it to fail before you commit real effort — return the single load-bearing objection and the cheapest experiment that would prove it matters, not a checklist. User-invoked on purpose: a hate-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."
+---
+
+Refuse to be nice to the plan — return the one objection that could kill it and the cheapest shot that proves it matters.
+
+## Goal
+
+Where `shower` asks "can a stranger follow this?" (comprehension), `hate` asks "what would someone who wants this to fail attack first?" (validity). It is the **superset** reflex: where `factchk` checks one fact and `mandela` audits one validation, `hate` attacks the *whole* plan and collapses it to a single root. The highest-value output is never a checklist — it's one objection 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** objection — 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
+
+- **Attack, 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/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 `hate` 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.