paperthin 0.5.0 → 0.7.0

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.