@nerdev/skillset 0.2.1

package/curations/impeccable/WHY.md

@@ -0,0 +1,34 @@
+# WHY.md: why this skill is owned, not synced
+
+DRAFT. Rewrite each section in your own words before you commit this curation. The first line is echoed by sync; make it yours.
+
+> First line (suggestion, replace): iconic taste is the one thing only I can decide, so impeccable ships my rules first.
+
+## What I changed
+
+- Overlaid SKILL.md: added the House rules block on top of upstream v4.1.1.
+- Did not touch: the command table, references, scripts. Upstream improvements there still land on the next sync.
+
+(Draft: expand with the exact date you set this up and the upstream version it was based on.)
+
+## How I like things
+
+- UI that looks bought, not generated: one CTA, simple buttons, one accent color, whitespace, Apple/Google clean.
+- No purple slop, no AI-default look.
+- Short plain English, lists over paragraphs, outcomes over internals.
+- No em dashes anywhere, ever.
+
+(Draft: say it in your voice. This is the part an agent will read back to you when it reviews your next screen.)
+
+## Why these changes matter to my codebase
+
+- Upstream impeccable optimizes for award-worthy expression. I want restraint and clarity first; expression second.
+- Default AI patterns feel loud and generic. They make every product look the same and they age badly.
+
+(Draft: add the concrete moment something bothered you enough to write this down.)
+
+## Review cadence
+
+- When upstream impeccable bumps a version: run `npm run sync`, then diff the overlay against the new SKILL.md and re-merge the House rules block if the body changed.
+
+(Draft: say how often you will actually do this.)

package/curations/impeccable/overlay/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: impeccable
+description: Use when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a frontend interface. Covers websites, landing pages, dashboards, product UI, app shells, components, forms, settings, onboarding, and empty states. Handles UX review, visual hierarchy, information architecture, cognitive load, accessibility, performance, responsive behavior, theming, anti-patterns, typography, fonts, spacing, layout, alignment, color, motion, micro-interactions, UX copy, error states, edge cases, i18n, and reusable design systems or tokens. Also use for bland designs that need to become bolder or more delightful, loud designs that should become quieter, live browser iteration on UI elements, or ambitious visual effects that should feel technically extraordinary. Not for backend-only or non-UI tasks.
+version: 4.1.1
+user-invocable: true
+argument-hint: "[shape · audit|critique · animate|bolder|colorize|delight|layout|overdrive|quieter|typeset · adapt|clarify|distill · harden|onboard|optimize|polish · init|document|extract|live] [target]"
+license: Apache 2.0
+allowed-tools:
+  - Bash(npx impeccable *)
+  - Bash(node .opencode/skills/impeccable/scripts/*)
+---
+
+## House rules (owned, not negotiable)
+
+These rules sit above every command in this skill. They are my voice. If a
+reference or command below suggests something that breaks a rule, the rule
+wins. This block is applied on top of upstream by the sync, so it survives
+every re-vendor. See WHY.md for the reasoning.
+
+1. **No purple slop.** No purple gradients, no glowing buttons, no oversized
+   rounded cards, no screens that could pass for what any AI tool outputs by
+   default. If the work looks generated, it is wrong.
+2. **Looks bought, not generated.** Before finishing any screen, ask one
+   question: if Apple or Google shipped this, would it look out of place?
+   Their shared vocabulary is the target: one clear action per screen,
+   simple buttons, flat or barely rounded, no glow, one accent color,
+   whitespace over borders and shadows, real type hierarchy.
+3. **Eye-catching is calm plus one detail.** One surprising moment per
+   screen: a perfect number, a sharp shape, one bold layout move. Not
+   decoration everywhere.
+4. **Plain English, short and sweet.** Write so a 5th grader gets it. Lists
+   over paragraphs. `name: what it does`. Outcomes over internals.
+5. **No em dashes. Anywhere. Never.** Not in files, diffs, docs, comments,
+   or chat. Use commas or periods. One em dash means the deliverable fails
+   review.
+6. **Tailwind, strictly.** Component-based Tailwind CSS. Every visual
+   decision is a Tailwind utility or a small composable component. Raw CSS
+   only when Tailwind cannot do what the design needs, and only with a
+   reason.
+
+Upstream content follows unchanged.
+
+This skill gives you the tools and permission to create design that earns to be called out-of-distribution craft: Whereas before, your design work would have been safe, timid and measured, you now approach every design task as a award-winning design director with impeccable understanding for what makes exceptional design work: production-grade code, peak creativity, a clear POV, deep understanding of the needs of the client and users, and exceptional craft.
+
+Core principles:
+- Go all out. No hedging, no shortcuts. The deliverable must be complete (except assets the user must provide).
+- Dream big and bold. Distinct, beautiful, outstanding and highly inspiring work.
+- Verify in bounded passes, not a loop, and the ceiling covers the whole cycle: screenshots, defect scans, micro-edits, and rebuilds alike. Build fully, inspect once with a batched round (desktop and mobile together on the web; the shipped device classes on a native platform), fix everything it shows in one batch, confirm with at most one more round, and stop polishing. Open-ended self-QA burns the user's money doing worse what the finish handoffs do better.
+
+## Setup
+
+1. Run `node <skill-base-dir>/scripts/context.mjs` once per session, where `<skill-base-dir>` is the loaded base directory the runtime reports for this skill; keep cwd at the user's project. That base directory resolves every `node .opencode/skills/impeccable/scripts/...` command in this skill and its references, and `.opencode/skills/impeccable/scripts` is the fallback only when the runtime reports no base directory. Pass a named source file or route as `--target <path>`. It loads PRODUCT.md, DESIGN.md, the matching surface brief, and native-platform guidance when applicable; follow its directives and do not rerun it.
+2. Before acting, load the one playbook that owns the request: the Commands table's reference for an explicit or clearly implied sub-command, or [reference/new-work.md](reference/new-work.md) for a new surface or replacement visual world. Then inspect the target and at least one representative source of incumbent visual truth (tokens, theme, CSS, component, or asset) before editing.
+3. After analysis and direction are resolved, load [reference/craft-floor.md](reference/craft-floor.md) immediately before editing UI. It carries the quality floor, the absolute bans, and the reflexes no detector catches. Do not load it for planning-only work.
+
+## How to design
+
+- **The brief wins.** Honor pinned aesthetics, eras, materials, fonts, and palettes even when they conflict with a saturated-pattern warning. Redirecting a clear brief toward your taste is failure.
+- **Refinement preserves; redesign replaces.** Refinement keeps the incumbent identity, behavior, copy, and everything outside scope. Ask before replacing factual copy or adding claims. Redesign keeps product truth, content, function, native affordances, and constraints, but treats the old look as evidence and anti-reference; choose a replacement world in new-work and replace DESIGN.md. Never split the difference into polish on the discarded look.
+- **Visual authority is evidence, not a filename.** Missing DESIGN.md alone does not make a project greenfield; new-work decides whether to preserve, expand, or replace the incumbent world.
+
+## Modes
+
+The mode names what the visitor's success looks like on this surface.
+
+- **Persuade:** the visitor decides and acts; design is the product. Landing pages, marketing, campaigns, pricing. Earn attention and action. Ship real imagery when the brief needs it; follow the committed world, not category habit.
+- **Operate:** the visitor completes a task. App UI, dashboards, editors, admin, settings, tools. Scanability, consistency, native expectations, and the real usage scene outrank expression. Brand lives in precise details.
+- **Read:** the visitor understands something. Docs, articles, guides, help, changelogs. Structure for comprehension, then make the reading experience worth staying in.
+- **Experience:** the visitor is inside the work itself. Portfolios, galleries, showcases. Let the artifact lead from the first viewport; the interface recedes.
+
+Choose the mode from the requested surface, not the product, and persist it only in that surface brief. A tool's landing page is still Persuade; a fashion house's documentation is still Read; a docs index is Read, not Persuade. See [new-work.md](reference/new-work.md) for new surfaces and [operate.md](reference/operate.md) for deeper Operate/Read guidance.
+
+## Commands
+
+| Command | Category | Description | Reference |
+|---|---|---|---|
+| `craft [feature]` | Build | Deprecated alias for an ordinary new-work request | [reference/craft.md](reference/craft.md) |
+| `shape [feature]` | Build | Plan UX/UI before writing code | [reference/shape.md](reference/shape.md) |
+| `init` | Build | Capture durable product context in PRODUCT.md | [reference/init.md](reference/init.md) |
+| `document` | Build | Generate DESIGN.md from existing project code | [reference/document.md](reference/document.md) |
+| `extract [target]` | Build | Pull reusable tokens and components into design system | [reference/extract.md](reference/extract.md) |
+| `critique [target]` | Evaluate | UX design review with heuristic scoring | [reference/critique.md](reference/critique.md) |
+| `audit [target]` | Evaluate | Technical quality checks (a11y, perf, responsive) | [reference/audit.md](reference/audit.md) · native: [reference/audit.native.md](reference/audit.native.md) |
+| `polish [target]` | Refine | Final quality pass before shipping | [reference/polish.md](reference/polish.md) |
+| `bolder [target]` | Refine | Amplify safe or bland designs | [reference/bolder.md](reference/bolder.md) |
+| `quieter [target]` | Refine | Tone down aggressive or overstimulating designs | [reference/quieter.md](reference/quieter.md) |
+| `distill [target]` | Refine | Strip to essence, remove complexity | [reference/distill.md](reference/distill.md) |
+| `harden [target]` | Refine | Production-ready: errors, i18n, edge cases | [reference/harden.md](reference/harden.md) |
+| `onboard [target]` | Refine | Design first-run flows, empty states, activation | [reference/onboard.md](reference/onboard.md) |
+| `animate [target]` | Enhance | Add purposeful animations and motion | [reference/animate.md](reference/animate.md) |
+| `colorize [target]` | Enhance | Add strategic color to monochromatic UIs | [reference/colorize.md](reference/colorize.md) |
+| `typeset [target]` | Enhance | Improve typography hierarchy and fonts | [reference/typeset.md](reference/typeset.md) |
+| `layout [target]` | Enhance | Fix spacing, rhythm, and visual hierarchy | [reference/layout.md](reference/layout.md) |
+| `delight [target]` | Enhance | Add personality and memorable touches | [reference/delight.md](reference/delight.md) |
+| `overdrive [target]` | Enhance | Push past conventional limits | [reference/overdrive.md](reference/overdrive.md) |
+| `clarify [target]` | Fix | Improve UX copy, labels, and error messages | [reference/clarify.md](reference/clarify.md) |
+| `adapt [target]` | Fix | Adapt for different devices and screen sizes | [reference/adapt.md](reference/adapt.md) · native: [reference/adapt.native.md](reference/adapt.native.md) |
+| `optimize [target]` | Fix | Diagnose and fix UI performance | [reference/optimize.md](reference/optimize.md) |
+| `live` | Iterate | Visual variant mode: pick elements in the browser, generate alternatives | [reference/live.md](reference/live.md) |
+
+Routing:
+
+- **No argument:** read [routing.md](reference/routing.md) and present its context-aware menu; never auto-run a command.
+- **Explicit or clearly implied command:** load its reference (native variant on native platforms) and follow it. Ask once if two commands fit.
+- **Otherwise:** treat the request as general design work. Missing PRODUCT.md routes a new surface or replacement world through init, then new-work; a narrow refinement of existing code proceeds on the incumbent implementation as context.mjs directs, offering init afterward rather than blocking on it.
+- `teach` aliases `init`. `craft` is a deprecated alias for ordinary new-work and adds nothing. `shape` owns task discovery, then enters new-work only for visual-world and surface-concept decisions.
+
+After init writes PRODUCT.md, resume without rerunning `context.mjs`; init loads the native platform reference itself when the platform it recorded is `ios`, `android`, or `adaptive`.
+
+**Pin / Unpin:** `node .opencode/skills/impeccable/scripts/pin.mjs <pin|unpin> <command>` creates or removes a standalone `/<command>` shortcut. Report the script's result concisely; relay stderr verbatim on error.
+
+**Hooks:** `/impeccable hooks <on|off|status|ignore-rule|ignore-file|ignore-value|reset>` manages the design detector hook for this project (auto-runs the detector after UI file edits and surfaces findings). Load [reference/hooks.md](reference/hooks.md) when the user invokes it with any argument.
+
+**Doctor:** `/impeccable doctor` reports and repairs drift between this project's Impeccable artifacts (PRODUCT.md, DESIGN.md and its sidecar, config, surface briefs, the hook) and what this version reads. Load [reference/doctor.md](reference/doctor.md) when the user invokes it, or when they ask what is out of date, stale, or needs refreshing. A `CONTEXT_STALE` directive in Setup's output is the cheap subset of the same report; act on it there per its own instructions rather than running doctor unasked.
+
+**Never repair drift as a side effect of a design task.** A `CONTEXT_STALE` finding is reported, not acted on, unless the user asks. The one exception is a finding marked `auto`, which the next write to that file performs anyway.

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@nerdev/skillset",
+  "version": "0.2.1",
+  "description": "A curated, auto-synced collection of agent skills (design, animation, dev workflow) with a CLI to install them into any harness: Claude Code, OpenCode, Cursor, Codex, Gemini.",
+  "type": "module",
+  "bin": {
+    "skillset": "./bin/skillset.mjs"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "skills",
+    "curations",
+    "vendor.json"
+  ],
+  "scripts": {
+    "sync": "node scripts/sync.mjs",
+    "list": "node bin/skillset.mjs list",
+    "install": "node bin/skillset.mjs install",
+    "lint:ste": "node scripts/ste-gate.mjs"
+  },
+  "keywords": [
+    "agent",
+    "skills",
+    "claude",
+    "opencode",
+    "cursor",
+    "codex",
+    "design",
+    "ai"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NalinDalal/skillset.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/ste-gate.mjs

@@ -0,0 +1,39 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+const vendor = JSON.parse(readFileSync("vendor.json", "utf8"));
+const syncedDests = new Set(
+  vendor.upstreams.flatMap((u) => u.skills.map((s) => s.dest))
+);
+
+function isSynced(relPath) {
+  for (const dest of syncedDests) {
+    if (relPath.startsWith(dest + "/") || relPath === dest) return true;
+  }
+  return false;
+}
+
+function walk(dir, out, prefix) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${e.name}` : e.name;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walk(p, out, rel);
+    else if (e.name.endsWith(".md") && !isSynced(rel)) out.push(p);
+  }
+}
+
+const files = [];
+walk("skills", files, "");
+
+console.log(`STE linting ${files.length} owned files (synced upstreams skipped)`);
+try {
+  execFileSync(
+    "python3",
+    ["scripts/ste-lint.py", "--strict", "--fail-over", "5.0", ...files],
+    { stdio: "inherit" }
+  );
+  console.log("All owned files pass (<= 5.0 violations per 100 words)");
+} catch {
+  process.exit(1);
+}

package/scripts/ste-lint.py

@@ -0,0 +1,201 @@
+import re, sys, json, glob, os
+
+# Score v2: adds complex_tense (perfect tenses, modal stacks), exempts
+# adjectival/stative participles from the passive count, moves "provide" to the
+# banned list, adds a noun-train marker and a --strict mode. The episode's
+# published numbers were measured with score v1 (this file's git history at the
+# episode date); v1 and v2 totals are close but not directly comparable.
+#
+# Score v3: strips code fences with a line-by-line state machine instead of a
+# regex (a single unclosed ``` shifted pairing and leaked fenced semicolons
+# into the prose count), counts possessive 's (user's, thread's) as possessive
+# not contraction - only pronoun-stem 's (it's, that's, who's) is a
+# contraction - and exempts double-quoted spans from word-level checks (STE
+# treats quoted material as verbatim speech).
+SCORE_VERSION = 3
+
+MARKETING = ["seamless","seamlessly","robust","powerful","cutting-edge","effortless","effortlessly",
+    "world-class","next-generation","revolutionary","blazing","lightning-fast","elegant","delightful",
+    "turnkey","best-in-class","state-of-the-art","game-changing","first-class","battle-tested",
+    "enterprise-grade","supercharge","unlock","unleash","empower","empowers"]
+BANNED = ["begin","begins","commence","commences","initiate","initiates","originate",
+    "utilize","utilizes","utilizing","leverage","leverages","leveraging","facilitate","facilitates",
+    "ensure","ensures","ensuring","prior to","subsequent to","obtain","obtains","acquire","acquires",
+    "demonstrate","demonstrates","additionally","furthermore","moreover","comprehensive","comprehensively",
+    "utilization","aforementioned","henceforth","therein","whilst","amongst","numerous","myriad","plethora",
+    "provide","provides","provided",
+    "in order to","a variety of","in the event that","due to the fact that","it is important to note"]
+# STE's own recurring-errors list (see ste-recurring-errors.md). Counted only
+# with --strict: these are correct STE but would flag normal prose in docs.
+STRICT_BANNED = ["however","since","should","shall","using","follow","follows","followed"]
+PHRASAL = ["spin up","spin down","reach out","dive into","dives into","diving into","kick off","kicks off",
+    "roll out","rolls out","tear down","ramp up","circle back","drill down","spun up","reaching out"]
+MODAL_HEDGE = ["it is important to note","it should be noted","it is worth noting","please note that",
+    "as mentioned","as noted above"]
+BE = r"(?:am|is|are|was|were|be|been|being)"
+PP_IRREG = r"(?:done|made|sent|read|built|kept|held|set|put|run|written|shown|given|taken|found|got|gotten|seen|known|thrown|drawn)"
+# Rule 3.3: a past participle used as an adjective is not passive. These
+# stative participles only count as passive when a by-agent follows.
+STATIVE = r"(?:closed|opened?|damaged|completed?|installed|connected|required|expected|configured|enabled|disabled|deprecated|supported)"
+FUNC_WORDS = set("""a an the this that these those of for to in on at by with from as and or but if
+when then than not no is are was were be been being am do does did has have had will would can could
+may might must should shall it its their your our his her they we you i""".split())
+
+def strip_code(t):
+    out = []
+    in_fence = False
+    for line in t.split("\n"):
+        if re.match(r"^\s*```", line):
+            in_fence = not in_fence
+            continue
+        if not in_fence:
+            out.append(line)
+    t = "\n".join(out)
+    t = re.sub(r"`[^`]*`", " ", t)
+    return t
+
+def sentences(text):
+    out = []
+    for line in text.split("\n"):
+        s = line.strip()
+        if not s: continue
+        s = re.sub(r"^\s*#{1,6}\s*", "", s)
+        s = re.sub(r"^\s*(?:[-*+]|\d+[.)])\s+", "", s)
+        if not s: continue
+        parts = re.split(r"(?<=[.!?:])\s+(?=[A-Z0-9\"'\-])", s)
+        for p in parts:
+            p = p.strip()
+            if p: out.append(p)
+    return out
+
+def wc(s):
+    return len([w for w in re.findall(r"[A-Za-z0-9][A-Za-z0-9'\-/]*", s)])
+
+def count_ci(text, phrases):
+    n = 0; hits = []
+    low = text.lower()
+    for ph in phrases:
+        for m in re.finditer(r"(?<![a-z])" + re.escape(ph) + r"(?![a-z])", low):
+            n += 1; hits.append(ph)
+    return n, hits
+
+def noun_trains(text):
+    """Runs of 4+ consecutive non-function lowercase words (Rule 2.1 proxy).
+    Heuristic marker only - proper nouns break a run, the leading word of each
+    sentence is skipped, and the count stays out of the total."""
+    hits = []
+    for s in sentences(text):
+        words = re.findall(r"[A-Za-z][A-Za-z'\-]*", s)[1:]
+        run = []
+        for w in words + [""]:
+            if w and w.lower() not in FUNC_WORDS and not w[0].isupper():
+                run.append(w)
+            else:
+                if len(run) >= 4: hits.append(" ".join(run))
+                run = []
+    return hits
+
+def unquote(text):
+    """Exempt double-quoted spans from word-level checks (STE treats quoted
+    material as verbatim). YAML description wrapper quotes are not quoted
+    speech: unwrap them first so descriptions still get checked."""
+    out = []
+    for line in text.split("\n"):
+        m = re.match(r'^(\s*[a-z_-]+:\s*)"(.*)"\s*$', line, re.S)
+        if m:
+            line = m.group(1) + m.group(2)
+        res = []
+        in_q = False
+        for seg in re.split(r'(")', line):
+            if seg == '"':
+                in_q = not in_q
+                continue
+            res.append(" " * len(seg) if in_q else seg)
+        out.append("".join(res))
+    return "\n".join(out)
+
+def lint(text, strict=False):
+    raw = text
+    text = unquote(strip_code(text))
+    sents = sentences(text)
+    words = sum(wc(s) for s in sents) or 1
+    v = {}
+    longs = [(wc(s), s) for s in sents if wc(s) > 20]
+    v["long_sentence(>20w)"] = len(longs)
+    v["semicolon"] = text.count(";")
+    v["contraction"] = len(re.findall(
+        r"\b(?:\w+['’](?:t|re|ve|ll|d|m)\b|(?:it|that|who|what|there|here|he|she|let|how|where|when|why)['’]s\b)",
+        text))
+    passive_parts = re.findall(rf"\b{BE}\s+(\w+ed|{PP_IRREG})\b", text, re.I)
+    v["passive_voice"] = sum(1 for p in passive_parts if not re.fullmatch(STATIVE, p, re.I)) \
+        + len(re.findall(rf"\b{BE}\s+{STATIVE}\s+by\b", text, re.I))
+    v["complex_tense"] = len(re.findall(
+        rf"\b(?:(?:may|might|could|would|should|must|will|shall|can)\s+)?(?:have|has|had)\s+(?:been\s+)?(?:\w+ed|{PP_IRREG})\b",
+        text, re.I))
+    v["ing_main_verb"] = len(re.findall(rf"\b{BE}\s+\w+ing\b", text, re.I))
+    v["nominalization"] = len(re.findall(r"\b(?:perform(?:s|ed)?|conduct(?:s|ed)?|carry out|carries out|make use of|makes use of)\b", text, re.I)) + len(re.findall(r"\b\w{4,}(?:tion|ment|ance|ence)\s+of\b", text, re.I))
+    v["phrasal_verb"], _ = count_ci(text, PHRASAL)
+    v["banned_word"], bh = count_ci(text, BANNED)
+    v["marketing_adjective"], mh = count_ci(text, MARKETING)
+    v["modal_hedge"], _ = count_ci(text, MODAL_HEDGE)
+    paras = [p for p in re.split(r"\n\s*\n", text) if p.strip()]
+    def is_list_block(p):
+        lines = [l for l in p.split("\n") if l.strip()]
+        if not lines: return False
+        listy = [l for l in lines if re.match(r"^\s*(?:[-*+]|\d+[.)])\s+", l)]
+        return len(listy) / len(lines) >= 0.5
+    def is_description(p):
+        first = next((l for l in p.split("\n") if l.strip()), "")
+        return bool(re.match(r"^\s*(?:description|motion_description|additional-description):", first))
+    v["long_paragraph(>6s)"] = sum(1 for p in paras if not is_description(p) and not is_list_block(p) and len(sentences(strip_code(p))) > 6)
+    em = raw.count("—") + raw.count("–")
+    trains = noun_trains(text)
+    if strict:
+        n_strict, sh = count_ci(text, STRICT_BANNED)
+        # "may" is matched case-sensitively so the month "May" stays clean
+        n_strict += len(re.findall(r"(?<![A-Za-z])may(?![a-z])", text))
+        v["strict_banned_word"] = n_strict
+        v["em_dash"] = em
+    total = sum(v.values())
+    return {
+        "score_version": SCORE_VERSION,
+        "mode": "strict" if strict else "flavored",
+        "words": words, "sentences": len(sents),
+        "violations": v, "total": total,
+        "total_per100w": round(total*100.0/words, 2),
+        "em_dash(slop-marker)": em,
+        "noun_train(>=4w,marker)": len(trains),
+        "longest_sentence_words": (max(longs)[0] if longs else max((wc(s) for s in sents), default=0)),
+        "sample_marketing": list(dict.fromkeys(mh))[:6],
+        "sample_banned": list(dict.fromkeys(bh))[:6],
+        "sample_noun_train": trains[:3],
+    }
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    strict = "--strict" in args
+    as_json = "--json" in args
+    fail_over = None
+    if "--fail-over" in args:
+        i = args.index("--fail-over")
+        fail_over = float(args[i + 1])
+        del args[i:i + 2]
+    files = [a for a in args if a not in ("--strict", "--json")]
+    worst = 0.0
+    if not files:
+        sys.stdin.reconfigure(encoding="utf-8")
+        r = lint(sys.stdin.read(), strict=strict)
+        print(json.dumps(r, indent=2))
+        worst = r["total_per100w"]
+    else:
+        exp = []
+        for f in files: exp += sorted(glob.glob(f)) if any(c in f for c in "*?[") else [f]
+        for f in exp:
+            with open(f, encoding="utf-8") as fh: r = lint(fh.read(), strict=strict)
+            worst = max(worst, r["total_per100w"])
+            if as_json:
+                print(json.dumps({"file": f, **r}, indent=2))
+            else:
+                print(f"{os.path.basename(f):32} words={r['words']:4d} total={r['total']:3d} per100w={r['total_per100w']:6.2f} em_dash={r['em_dash(slop-marker)']:2d}")
+    if fail_over is not None and worst > fail_over:
+        sys.exit(1)

package/scripts/sync.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * sync.mjs: pull latest skills from upstream repos and re-vendor them.
+ *
+ * Usage:  node scripts/sync.mjs            # check + apply updates
+ *         node scripts/sync.mjs --dry-run  # report without writing
+ *         node scripts/sync.mjs --repo taste-skill
+ *
+ * Reads vendor.json, shallow-clones each upstream into .sync-cache/,
+ * copies the listed skill folders into skills/, and bumps the pinned
+ * commit. Exits 0 with "UP_TO_DATE" when nothing changed (so CI can
+ * skip opening a PR), 1 with "CHANGED" when updates were applied.
+ *
+ * Ownership model: upstream files are a BASE, not the final word.
+ * Anything under curations/<skill>/overlay/ is copied back over the
+ * freshly-vendored skill afterwards (force), so the skills you own keep
+ * your voice no matter how much the upstream moves. curations/<skill>/WHY.md
+ * records why you own it the way you do. It is never shipped into skills/.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, cpSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const CACHE_DIR = join(ROOT, ".sync-cache");
+const SKILLS_DIR = join(ROOT, "skills");
+const CURATIONS_DIR = join(ROOT, "curations");
+const VENDOR_FILE = join(ROOT, "vendor.json");
+
+const args = process.argv.slice(2);
+const dryRun = args.includes("--dry-run");
+const onlyRepo = args.find((a) => a.startsWith("--repo="))?.split("=")[1] ?? null;
+
+function sh(cmd, cwd) {
+  return execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+
+function latestCommit(repo) {
+  try {
+    return sh(`git ls-remote https://github.com/${repo}.git HEAD`).split(/\s+/)[0];
+  } catch {
+    return null;
+  }
+}
+
+function computeSha256(dir) {
+  const files = [];
+  function walk(d) {
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else files.push(full);
+    }
+  }
+  walk(dir);
+  files.sort();
+  const hash = createHash("sha256");
+  for (const f of files) {
+    const rel = f.slice(dir.length + 1);
+    hash.update(rel + "\0");
+    hash.update(readFileSync(f));
+  }
+  return hash.digest("hex");
+}
+
+function fetchUpstream(name, repo, source) {
+  if (!/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(repo)) {
+    throw new Error(`invalid repo format: ${repo} (expected owner/repo)`);
+  }
+  const dir = join(CACHE_DIR, name);
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  try {
+    sh(`git clone --depth 1 --filter=blob:none --sparse https://github.com/${repo}.git .`, dir);
+    sh(`git sparse-checkout set ${source}`, dir);
+  } catch (err) {
+    throw new Error(`clone failed for ${repo}: ${err.message}`);
+  }
+  return dir;
+}
+
+function applyCurations(skill, destPath) {
+  const overlay = join(CURATIONS_DIR, skill, "overlay");
+  if (!existsSync(overlay)) return false;
+  cpSync(overlay, destPath, { recursive: true, force: true });
+  const why = join(CURATIONS_DIR, skill, "WHY.md");
+  if (existsSync(why)) console.log(`    notes: ${readFileSync(why, "utf8").trim().split("\n")[0]}`);
+  return true;
+}
+
+function applySkill(srcDir, skillObj, dry) {
+  const skill = skillObj.name;
+  const from = join(srcDir, skill);
+  const to = join(SKILLS_DIR, skillObj.dest);
+  if (!existsSync(from)) {
+    if (existsSync(to)) {
+      console.error(`  ! upstream no longer ships "${skill}". Keeping your owned copy (remove curations/${skill} and skills/${skillObj.dest} to drop it)`);
+    } else {
+      console.error(`  ! missing in upstream: ${skill}`);
+    }
+    return;
+  }
+  if (dry) {
+    console.log(`  ~ would update: ${skill} → ${skillObj.dest}`);
+    return;
+  }
+  rmSync(to, { recursive: true, force: true });
+  mkdirSync(join(SKILLS_DIR, dirname(skillObj.dest)), { recursive: true });
+  cpSync(from, to, { recursive: true });
+  const curated = applyCurations(skill, to);
+  const sha256 = computeSha256(to);
+  if (skillObj.sha256 && skillObj.sha256 !== "TBD" && skillObj.sha256 !== sha256) {
+    console.warn(`  ⚠ SHA256 mismatch for ${skill}: expected ${skillObj.sha256.slice(0, 16)}..., got ${sha256.slice(0, 16)}...`);
+  }
+  skillObj.sha256 = sha256;
+  console.log(`  ✓ updated: ${skill} → ${skillObj.dest}${curated ? " [+ curation overlay]" : ""} (sha256: ${sha256.slice(0, 16)}...)`);
+}
+
+const vendor = JSON.parse(readFileSync(VENDOR_FILE, "utf8"));
+let changed = false;
+
+for (const upstream of vendor.upstreams) {
+  if (onlyRepo && upstream.name !== onlyRepo) continue;
+
+  const head = latestCommit(upstream.repo);
+  if (!head) {
+    console.error(`✗ could not reach ${upstream.repo}. Skipping`);
+    continue;
+  }
+
+  const missing = upstream.skills.filter((s) => !existsSync(join(SKILLS_DIR, s.dest)));
+  if (head === upstream.commit && missing.length === 0) {
+    console.log(`  * ${upstream.name}: up to date (${head.slice(0, 7)})`);
+    continue;
+  }
+
+  const srcDir = fetchUpstream(upstream.name, upstream.repo, upstream.source);
+  if (head === upstream.commit) {
+    console.log(`↻ ${upstream.name}: restoring missing skill(s): ${missing.map(s => s.dest).join(", ")}`);
+  } else {
+    console.log(`↻ ${upstream.name}: ${upstream.commit.slice(0, 7)} → ${head.slice(0, 7)}`);
+    changed = true;
+  }
+  for (const skillObj of upstream.skills) {
+    applySkill(join(srcDir, upstream.source), skillObj, dryRun);
+  }
+  if (changed && !dryRun) upstream.commit = head;
+}
+
+if (changed && !dryRun) {
+  writeFileSync(VENDOR_FILE, JSON.stringify(vendor, null, 2) + "\n");
+  console.log("\nvendor.json bumped.");
+} else if (changed && dryRun) {
+  console.log("\n[dry-run] updates pending; nothing written.");
+} else {
+  console.log("\nAll upstreams up to date.");
+}
+
+if (!dryRun && existsSync(CURATIONS_DIR)) {
+  const destLookup = Object.fromEntries(
+    vendor.upstreams.flatMap((u) => u.skills.map((s) => [s.name, s.dest]))
+  );
+  for (const entry of readdirSync(CURATIONS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dest = destLookup[entry.name];
+    if (!dest || !existsSync(join(SKILLS_DIR, dest))) continue;
+    if (applyCurations(entry.name, join(SKILLS_DIR, dest))) console.log(`◈ ensured curation overlay: ${entry.name}`);
+  }
+  writeFileSync(join(ROOT, ".sync-state"), changed ? "CHANGED" : "UP_TO_DATE");
+}
+process.exit(0);