wan-huiyan

Diagnose and bypass `gh pr merge --squash --delete-branch` failing with "failed to run git: fatal: 'main' is already used by worktree at ..." when another git worktree has main checked out. Use when: (1) you run gh pr merge and see this exact error, (2) you have multiple worktrees in the repo (e.g. `.claude/worktrees/*`), (3) the error appears even though the GitHub merge itself looks fine. The merge SUCCEEDED on GitHub — only gh's local-side effect (post-merge `git checkout main`) failed. Verify via `gh pr view N --json state,mergedAt`; if state=MERGED, you're done. This also applies to `gh pr checkout` and any other `gh` subcommand that tries to touch the local main branch while another worktree has it claimed. v1.2.0 (2026-05-26) adds the sequential-error variant: if you re-run from the main-repo worktree after the first error, you can then hit "cannot delete branch <feature-branch> used by worktree at <feature-worktree>" — same one-checkout-per-branch invariant, this time applied to the feature branch. Cl

When generating LONG Chinese/Japanese/Korean (CJK) STRUCTURED output (a big JSON report, a multi-section document) from an LLM chat API, the response truncates mid-JSON and your parser throws "no parseable JSON" / "Expecting ',' delimiter" / JSONDecodeError — even though the SAME prompt in English worked. Root cause: CJK is token-heavy (≈1–2 tokens per character vs ≈0.25 for English), so a report that fit your max_tokens in English overflows it in Chinese. Some models ALSO hard-cap output well below what you request (e.g. qwen-max caps at 8192) and silently truncate. Use when: a zh/ja/ko structured-generation run fails JSON parsing, worked in English, or a specific model truncates while others on the same prompt succeed. Covers the ~2× token budget rule, per-model output caps, and a salvage that recovers the complete sections from a truncated object.

Catch the failure where a subagent dispatched ONLY to DECIDE/DESIGN (a judge, a design-panel synthesizer, a "pick the mechanism" agent) instead EXECUTES the plan — and, having full Bash/gcloud/bq, provisions LIVE infrastructure (creates a BQ dataset/table, a DTS scheduled query, a log metric, a paging alert policy) and even git-commits code — when you only wanted a recommendation. Use when: (1) you author a Workflow/Agent whose structured-output schema has a field that reads as an execution mandate ("this_session_plan", "exact ordered steps", "deploy_steps", "what was provisioned") and the agent has mutate-capable tools; (2) a design/judge agent's result says "DONE — created X" / "provisioned live" instead of "recommend X"; (3) you are about to trust a decision agent's self-report of what it changed. The agent treats a "plan/steps" output field as a TODO to carry out, not a proposal. Fix: constrain design/decision subagents READ-ONLY in the prompt (explicitly: "do NOT run any mutating bq/gcloud/git command; S

Prevent (and recover from) `git add -u` + `git commit --amend` + `git push --force-with-lease` catastrophically rolling thousands of unrelated tracked-file deletions into an amended commit when the project has an async post-commit hook that mutates tracked files (e.g. regenerates `docs/site/*.html`, `docs/site/index.html`, `MEMORY.md`, or any other tracked artefact in a background `&` / `nohup` / "running … in background" process). Use when: (1) you just made a small commit, the post-commit log line says `[post-commit] … running … in background`, and you're about to amend with corrected message / typo / issue ref; (2) `git commit --amend` output reports `1000+ files changed, … insertions, NNN,NNN deletions(-)` when you only intended a 6-file change; (3) the force-pushed branch on origin shows a massive deletion diff and `git status` after the amend shows previously-tracked files like `MEMORY.md`, `.github/`, `.cursor/`, `scripts/` as Untracked; (4) you ran `git add -u` reflexively before `--amend` on a projec

Prevent and diagnose nested git worktrees created at the wrong filesystem path when orchestrating parallel work from the main Claude Code agent. Use when (1) you ran `git worktree add .claude/worktrees/<name> ...` from the main agent's Bash tool, (2) `git worktree list` shows the new worktree at an unexpected nested path like `.claude/worktrees/<previous-worktree>/.claude/worktrees/<name>` instead of the intended top-level location, (3) a subagent dispatched to the intended path reports "worktree path mismatch" or operates from a longer nested path. Root cause: the main agent's Bash tool **persists cwd between calls** (per its docstring: "The working directory persists between commands"). An earlier `cd /abs/path && cmd` changes the main shell's cwd; a later `git worktree add <relative-path> ...` resolves against that persisted cwd rather than the project root, silently creating nested layouts. This is the **inverse** of the subagent variant (subagent-bash-cd-wrong-worktree) — subagent shells reset per call,

Diagnose "I merged my PR + CI is green but the live service still doesn't show my changes." Use when: (1) a code-bearing PR has been squash-merged into main with all required status checks passing, (2) the user reports the change is still missing from the deployed environment minutes-to-hours later, (3) the repo has a `pull_request: types: [closed]` workflow gated on a label (typically `auto-deploy`, `deploy`, `ship-it`) and/or a path filter, (4) the deploy workflow's run row in `gh run list` shows `conclusion=skipped` for your PR's branch — visually identical to `success` in the run summary. Distinct from `gha-auto-deploy-never-ran-skipped-mask` (sister skill: same "skipped masks failure" symptom class but different cause — that skill is about the FIRST time the gate fires and the deploy step then hits a permission gap; THIS skill is about the routine case where the gate correctly works and the PR simply didn't satisfy it). Trigger phrases: "I can't see the changes live", "merged but not deployed", "PR shipp

When a large Workflow/Agent fan-out (dozens of parallel subagents on Opus) mass-fails with "Server is temporarily limiting requests (not your usage limit)" / HTTP 429 — most agents dying, a few that finished before the burst surviving — recover by re-running the SAME fan-out on Sonnet and throttled into sequential waves (not one wide burst). Use when: (1) a Workflow returns far fewer results than dispatched and the failures all read "Rate limited" / 429 with "not your usage limit"; (2) you launched 20+ concurrent Opus subagents in one shot; (3) the task is well within Sonnet's range (triage, review, code-tracing, classification). Sonnet is a SEPARATE capacity pool, so it sidesteps the Opus-specific server throttle; the orchestrator/synthesis can stay on Opus.

Diagnose silent semantic duplication after two parallel PRs ship. Use when: (1) one PR (the **mover**) relocates a section/component/block from template X to template Y (X loses it, Y gains it), (2) a sibling PR (the **forker**), authored against pre-mover main, creates / promotes / copies template Z from the OLD version of X (when X still contained the section), (3) both PRs squash-merge without textual conflict because they touch different files, (4) after both deploy, the section appears on BOTH the mover's destination Y AND on the forker's route Z. Symptom is user-visible: "I see this radar / card / nav block in two places, why?" Root cause is structural — git's textual 3-way merge can't see that file Z ⊆ pre-mover-X. Fix: hand-delete the section from one location (usually the forker's), update tests if any asserted on the duplicate render. Prevention: when the mover merges first, rebase the forker BEFORE squash and audit any moved sections; or add a cross-route uniqueness test (`grep -c "<section-id>"` a

The LAST MILE of a de-stale (protocol step 9): a corrected observational finding is not shipped until every RENDERED surface matches the ledger. Use AFTER the honest ledger (step 8) whenever a figure or a marker-vs-lever / causal verdict changes and that number already appears on a live surface — a served/baked HTML page, an embedded chart image, a client+dashboard "twin" pair, a dashboard payload or cache table. The trap: you correct the TEXT/captions and believe you shipped, but the baked chart image still renders the retired number (and its old causal title), a twin doc still asserts the retired claim, or a cached payload still serves the old value — so a corrected caption sits next to a chart that contradicts it. Also covers HOW to draw a retired-causal / marker-not-lever finding honestly. Trigger when you edit a figure that is displayed anywhere, or review a de-stale PR for completeness.

Run an overnight autonomous workflow that takes a cluster of related GitHub issues (typically a P1 review-panel finding set) and ships them to merged PRs by morning. Use when: (1) the user wants 6-15 related issues closed in one autonomous run, (2) the issues split naturally into two PRs (e.g., hardening + features, or refactor + new-functionality), (3) the user is going to sleep and won't be available to merge PR1 between phases, (4) each issue has clear acceptance criteria so each task can be implemented + tested + reviewed independently. Specializes `superpowers:subagent-driven- development` for the "issues -> stacked PRs by morning" problem shape: stacks PR2 on PR1's branch (so PR2 doesn't wait for human PR1-merge mid- night), audits tracker IDs against main before claiming (concurrent sessions steal ids), runs final code-review subagent before proposing merge, and surfaces important findings as PR comments before squashing (so review trail survives). Sister plugin to `overnight-review-client- delivery` (

Guard the step where a VALID early-funnel lift becomes a recommendation. A segment genuinely starts/converts more at stage N — and the write-up is about to say "prioritize this segment" as if that buys the END outcome (enrollment, purchase, activation). Use when: (1) a finding, headline, card, or play recommends tilting effort toward a segment based on a stage-N rate (lead→start, start→submit, signup→trial); (2) the favored segment funnels into a capacity-capped or selective downstream stage (limited seats/inventory/approval slots, an admissions committee, a review queue); (3) you are REWORDING or promoting an existing funnel-stage finding — the reword inherits the original's stage scope, so re-check it; (4) a stakeholder asks "but doesn't that program/product only take a few?". The lift can be real AND the recommendation still over-promise: extra stage-N entrants feed a bottleneck, not the end outcome. Distinct from cohort-milestone-lift-is-funnel-position-not-effect (which attacks the lift's VALIDITY); here

The validity gate for any finding from OBSERVATIONAL data (no randomization). Use this BEFORE trusting or shipping a data finding, and when reviewing/verifying one. Runs a 9-step protocol — leak-free point-in-time cohort · probe outcome−anchor before an event-anchored design · decompose pooled rates by the structural axis (composition / Simpson) · de-confound with a multiple-testing-corrected regression · marker-vs-lever discipline · coverage-limited-join unbiasedness · triple-probe headlines · honest de-stale ledger · ship the correction to every rendered surface — that catches the finding which is genuinely surprising but WRONG (a composition artifact, a leak, an anchor-timing inversion, or an intent marker sold as a lever). Invoke whenever you analyze funnels, cohorts, lift, conversion rates, feature signals, retention, or any "do X → they convert / advance" claim from observational data; whenever a gradient or effect "looks too good"; and whenever you verify a finding before it reaches a stakeholder. The

A request to ELEVATE / amplify / feature an existing number that's already in a deliverable — turn a prose figure into a chart, make it a headline, restore "the breakdown we had" — is itself the trigger to re-verify that number's provenance BEFORE amplifying it. Use when: (1) asked to add a visual/chart for a number that already exists as text, (2) asked to make an existing stat more prominent, (3) a stakeholder says "we had this insight, put it back / show it bigger", (4) a number was seeded earlier as "client feedback" / "stakeholder feedback" / "per the reviewer" and is being built on. Pre-existing and especially stakeholder-contributed numbers carry FALSE AUTHORITY — they look already-vetted, so they skip the provenance scrutiny a brand-new number gets, and may trace to nothing. Verify (grep the source, re-derive with triple-probe) before making them louder. Prevents amplifying a fabrication.

When you orchestrate verification subagents AFTER reading the claims/numbers yourself, do NOT hand the agents the published number to "check" — that anchors them into replicate-and-confirm, not independent verification, and their agreement proves nothing because you already knew the answer. Instead BLIND the re-derivation pass: give each agent the QUESTION, not the number ("what % of X are Y?", never "verify it's 43%"). Put the published number only in front of a SECOND, adversary pass whose job is to break it via a DIFFERENT join/source. Use when: (1) you've read a finding doc / analysis / PR claim in full and are about to dispatch agents to verify it; (2) you're writing a re-derivation/triple-check/fact-check subagent prompt and tempted to include the target number "so they know what to confirm"; (3) a handoff asks you to "independently re-derive" something whose answer is already written in the doc you were handed; (4) you want subagent convergence to mean real agreement, not anchoring on a number you leak

Diagnose silent monotonicity violations (e.g. "Low bucket has higher conversion rate than High bucket" on a rank-quality chart, or any reverse-ordered metric on a model-quality dashboard) caused by broadening a cohort filter in one CTE while leaving sibling event/stage-source CTEs at their original narrower scope. Use when: (1) you just removed or relaxed a `WHERE period IN (...)` / `WHERE scope = X` / similar scope filter on a cohort-defining CTE to broaden coverage (e.g. "include all scored records, not just period-A applicants"), (2) the downstream JOIN pulls in a `funnel_stage` / `latest_status` / `enrollment_state` field from a separate row in the same table, (3) a rank-quality chart suddenly shows reverse-ordered or otherwise impossible numbers (Low > High on Net/cumulative rate, while per-step conditional rates look fine), (4) the per-step transition rates (conditional on prior stage) look reasonable but the "% of full cohort reached final stage" column is broken. Root cause: cohort CTE now spans perio

Diagnose the trap where a cohort defined by a LATE-funnel milestone (aid application filed, application submitted, deposit paid, event attended, document received) shows a strong raw outcome "lift" — and you're about to frame a client/dashboard action ("these convert higher, target/nudge them"). Use when: (1) a cohort's raw conversion/deposit/enrollment rate is much higher than a comparison group (+5–25pp) and the cohort membership is itself reached only AFTER getting partway down the funnel; (2) the comparison ("non-X") group is contaminated by a population that structurally CAN'T have the milestone (e.g. non-domestic applicants can't file a domestic aid form); (3) someone proposes a new feature or a "high-yield" nudge card off that gap. The raw gap is composition + funnel position, not a causal effect of the milestone. Decisive test = matched-grain stratification holding the confounders fixed in BOTH arms; sign-instability across strata is the fingerprint of residual composition; beware the seductive positi

Use when an agent harness's skills/tools catalog has grown large (hundreds+, e.g. from an auto-skill-minting loop) and is taxing context: the listing of skill names+descriptions is injected every turn AND into every subagent, so cost multiplies on fan-out and small-context agents can overflow ("Prompt is too long" at 0 tokens). This skill is the AUDIT + CURATION methodology plus measurement/reporting: the trimming levers are now native harness features (Claude Code ships them built in) — the durable value is deciding WHAT to trim (episodic lessons vs real skills), applying it safely, and measuring the result. The PROBLEM + curation METHODOLOGY are harness-agnostic — the Agent Skills open standard (agentskills.io) is shared by Claude Code, Cursor, Codex, Copilot CLI, Gemini CLI; only the levers differ. Covers: the portable diagnosis + classification rigor (curate by INTENT not name, conservative asymmetry, blind re-rate, deterministic checks over LLM votes); the cross-harness landscape (native budget on Claude

Wire up CI validation and automatic release-cutting for a Claude Code plugin or marketplace repo (a repo with a `.claude-plugin/marketplace.json` and `plugins/*`). Adds two GitHub Actions — a structure validator that runs on every PR/push, and a release-on-version-bump job that cuts a GitHub Release whenever a `VERSION` file changes — plus the bundled validator script and workflow templates. Use this WHENEVER a plugin/marketplace repo has no CI, when GitHub Releases have drifted behind the shipped version (e.g. release says v2.0.0 but the skill is v3.3.0), when the user says "set up CI for my plugin repo / marketplace", "my releases keep falling behind", "tag/release on version bump", "auto-cut releases", "validate my marketplace.json / plugin.json", "catch when a plugin folder and its plugin.json name disagree", or has just added/bumped plugins and wants releases to keep up. Works for both single-plugin repos (nested `skills/<name>/`) and multi-plugin bundles (flat `plugins/<name>/`). Don't use for: generic

Pre-PR checklist and repo cleanup for data science and analytics projects. Use this skill BEFORE creating a PR, merging branches, or handing off a repo. Catches common mistakes that waste hours later: data files committed to git, hardcoded paths, runtime artifacts tracked, branch ownership confusion, internal docs drifting from deliverables, and client data in public repos. Also use when the user says "clean up the repo", "is this ready to merge?", "prepare for handover", "before we push", "repo hygiene", or when you notice tracked .csv, .db, .parquet, or /Users/ paths during any file operation. Especially important for repos with multiple contributors working on parallel branches. Also covers reviewing/auditing a published plugin/skill repo: probe live CI + run the repo's own tests before eyeballing files ("review if this repo needs updating", "is this repo up to date?", "audit my plugin repo").

Scan a portfolio of authored Claude Code skills and produce, per target repo, a precise list of which skills to ADD, which to UPDATE (with direction), and which to CROSS-LINK rather than copy. Uses a per-repo function-level inclusion bar, portfolio deduplication (never recommend a skill already homed as its own repo or in a sibling target), and a version/`last_verified` divergence check for updates. Use this WHENEVER the user asks "which of my skills should go in repo X", "scan my skills and tell me what to add or update in these repos", "where should this new skill live", "find skills in the wrong bundle or duplicated across repos", "which repos have stale copies of skills I've improved locally", or wants to reorganize/consolidate a multi-repo skill portfolio. This is PLACEMENT/FIT mapping, and it produces a recommendation report — it never mutates repos. Don't use for (these are different tools): standardizing READMEs/badges or catching factual errors across skills (`skill-portfolio-audit`), finding dormant

ALWAYS use this skill when the user asks any question about their Claude Code setup, installed skills, memory system, handoffs, worktrees, or ~/.claude directory health. This is the go-to skill for introspection of the Claude Code environment itself. Specifically trigger on: (1) Skill inventory questions — "how many skills do I have", "which skills am I using", "what's dormant", "which skills can I uninstall", "are there overlapping skills"; (2) Cleanup and hygiene requests — "clean up my ecosystem", "audit my setup", "~/.claude feels bloated", "monthly hygiene check", "what needs cleanup", "stale worktrees", "orphaned handoff prompts"; (3) Diagnostic symptoms — "my memory system isn't working", "lessons aren't being picked up", "skill is not triggering", "claude keeps forgetting", "why is the wrong skill firing", "duplicate skill confusion"; (4) Health dashboards — "show me a health dashboard", "utilization across skills/memory/handoffs", "ecosystem health report"; (5) Any mention of auditing persistent arti

Detect stale normative guidance after the user adds a NEW "don't X / avoid Y" rule to ~/.claude/lessons.md, ~/.claude/axioms.md, or any ~/.claude/projects/<slug>/memory/feedback_*.md. Also audits ~/.claude/skills/ for skills whose `last_verified` frontmatter has expired or that opt into a freshness contract without declaring one (axiom #21). Trigger when: (1) a PostToolUse hook fires on Edit|Write to one of those memory files and the diff contains a new negation rule; (2) user asks "are my project docs still consistent with my lessons / feedback?", "any stale advice in docs/?", "run doc freshness audit", "any stale skills?"; (3) weekly cron audit is due. Produces a list of CANDIDATE stale claims — file:line refs only. NEVER auto-edits. Conservative by design: for prose lint, surfaces only when the new rule has an explicit negation (don't / never / avoid / stop) AND a multi-token searchable phrase AND ≥1 grep hit. For skill freshness, the default mode flags only on EXPLICIT frontmatter signals (expired `last_v

Audit and clean up Claude Code's persistent memory system — MEMORY.md, memory files, lessons, and ADRs. Use this skill when: (1) the user asks to clean up, audit, or review their memory/lessons/ADRs, (2) MEMORY.md is approaching or exceeding the 200-line limit, (3) lesson files have grown large and may contain duplicates, (4) you notice ADR numbering conflicts, (5) memory files seem stale or contradicted by current code, or (6) the user says things like 'my memory is getting messy', 'clean up my lessons', 'deduplicate', 'review ADRs', 'memory audit'. Also proactively suggest running this after 10+ sessions on a project, or when MEMORY.md triggers a truncation warning.

Quantitatively measure how effective a project's automated tests are at catching real bugs. Use this skill when: (1) the user asks 'how good are our tests?', 'do our tests actually catch bugs?', 'measure test effectiveness', or 'audit our test suite'; (2) a team has anecdotal impressions about test quality but no data; (3) before investing in more tests, to identify which gaps matter most; (4) after an incident slipped through CI, to understand whether the test suite should have caught it; (5) when evaluating whether a CI pipeline is paying for itself. Produces a report at ~/Documents/<project>_test_effectiveness_audit.md with per-incident catch rates, a classified gap list, and targeted recommendations. Read-only relative to project source — does not modify code or auto-write tests.

Write precise client-facing definitions of dashboard KPIs / metrics by reading the backing SQL, not the display label. Use when: (1) drafting an "explain this dashboard to a client" doc, tooltip, onboarding email, or page-by-page narration; (2) the user pushes back on a metric definition you wrote ("that's not what X means"); (3) you're about to describe what a KPI "means" using its rendered label, the variable name in Python, or the column alias in SQL; (4) writing release notes, ADRs, or methodology notes for a metric. Covers the two traps caught repeatedly: (a) display label diverges from underlying SQL (e.g. "Active Students" labels a query that is literally `COUNT(*) FROM predictions WHERE scoring_date = MAX(scoring_date) AND <term>_suppressed IS NULL` — i.e. "rows in today's scoring run, post-suppression"); (b) UI toggles (term, lookback, segment) silently re-parametrize the count, so the same number means different things depending on which pill is active.

GitHub auto-close on squash-merge only catches ONE issue per PR even when the PR title/body says "Closes #447, #448, #449, #450". The first issue closes; the rest stay OPEN. Use when: (1) you opened a PR with a title or body listing multiple "Closes #X, #Y, #Z" references, (2) the PR squash-merged successfully (`gh pr view N --json state` = MERGED), (3) `gh issue list --state open` shows some of the referenced issues are still OPEN. Root cause: GitHub's auto-close keyword parser binds one keyword to one issue; "Closes #447, #448" is interpreted as "Closes #447" plus an inline reference to #448. Fix: either (a) write one keyword per issue ("Closes #447. Closes #448. Closes #449.") in the PR body BEFORE merging, or (b) post-merge, run `gh issue close $N --comment "Closed by PR #M (squash-merge auto-close caught only one)"` for each leftover. Different from `pr-followup-commit-stranded-after-squash` (which covers stranded COMMITS, not stranded ISSUES). Saves a "why are my issues still open after merging the fix?

Diagnose "the dashboard shows the wrong number even though the backend payload has been correct for months." Use when: (1) auditing rendered numbers against a baked / cached / pre-aggregated payload table, (2) finding that the payload row in BQ / Redis / KV has the right value but the template renders a stale hardcoded literal (e.g. "~930 students" next to a payload that says cohort_size=94), (3) earlier PRs in the area updated copy / historical-rate language but never wired the headline integer to the payload key, (4) other surfaces on the same page DO read the payload correctly (proves the wiring pattern exists) but specific tiles were missed during a redesign carve-up. Distinct from `baked-payload-stale-after-merge` (producer didn't re-run) and from `cloud-run-results-bq-postsync` (write race) — this is the inverse: the producer has been correct for a long time, the CONSUMER never connected to it. Provides the "for each rendered number on every audit page, classify as payload-derived / hardcoded / mock-dat

Audit a whole live data-dashboard (or any multi-page user-facing product) for (1) numbers correctness against the source database and (2) language fit for stated audiences, in one synchronous ~30–45 minute round of parallel research subagents. Use when: (1) the user says "review this dashboard / site / app", "fact-check the numbers", "make sure the copy lands for X audience", or "do a whole-X audit"; (2) the product has 6+ user-facing pages backed by a queryable data source (BigQuery payload table, Postgres, read-replica, JSON cache, etc.); (3) the deliverable is a single written report the user can scan + decide what to fix; (4) the user has at least one written voice/persona doc (`PRODUCT.md`, brand guidelines, audience brief). Provides the cluster-split methodology (3–4 page-clusters by audience/purpose), the per-page diagnostic table schema (Element / Source / Claimed / Actual / Verdict), the subagent prompt template, the synthesis structure (TL;DR P0 table + per-page detail + cross-cutting themes), and t

Use when writing or upgrading a GitHub/open-source project's README so it actually pops — a cute, high-signal front page instead of a wall of text. Triggers on "write a README", "make my README pretty/cute/pop/stylish", "polish/redo my repo's README", "README template", "repo front page", "add badges / a hero banner / a feature table / an install section / a demo GIF", "open-source my project's readme", "give my repo a glow-up". Produces a centered pixel/arcade hero, a shields.io badge row, a bold one-line value-prop blockquote, a captioned demo image, a why-it-exists section, an emoji feature/ingredient table, a copy-paste install block, a contributors shoutout, and an honest limitations section. Ships a fill-in template + baked-in hero recipes (ASCII box + pixel SVG). Skip for terse internal-only repos, strict corporate brand templates, or non-README docs (API refs, tutorials).

Use when a user wants to add cute, playful runtime effects to a web page — a fairy-wand or magic custom cursor (star / heart / moon / pixel / sailor-moon), a sparkle / star / heart / fairy-dust trail following the mouse on move and click, an animated floating scroll-depth / scroll-progress indicator (ring, comet bar, or climbing mascot), tab-title peekaboo ("come back!" when the tab loses focus), click confetti or heart burst, ambient floating petals / leaves / snowflakes / bubbles / fairy-dust, and cute-chrome touches (pastel ::selection, wobble hover, kawaii loading spinner, pastel scrollbar). Pick a color palette (candy / neon / meadow) and a pixel-art style variant on each. Skip for serious / corporate UIs, or when the user wants a full design system or a heavyweight particle framework.

Add a cute, hand-authored SVG favicon to a web app — the tiny icon that shows in the browser tab. Use when the user asks to add a favicon, browser tab icon, tab logo, page icon, site icon, or "cute thing in the tab," or says the current tab shows a blank/default square. Covers 3 techniques in increasing effort: (A) emoji-as-favicon via inline SVG data URI — zero assets; (B) gradient mascot blob — a soft blob shape with a face built from circles + a quadratic-curve smile; (C) 16×16 pixel-art sticker using SVG <rect> on an integer grid with shape-rendering="crispEdges" (bunny, bear, chick, mochi cat, ghost, frog, strawberry, cloud, dango, bee, ...). Includes the modern `<link rel="icon" type="image/svg+xml">` recipe (no more .ico files, no PNG fallbacks needed for modern browsers), tab-size verification, and which technique fits which vibe. Skip if the user wants a corporate/photographic logo — this skill is for hand-authored, cute, low-effort icons.

Orchestrate a multi-agent adversarial review panel where several Claude Code subagents with different perspectives independently review a piece of work, debate with each other, reach (or fail to reach) consensus, then a supreme judge renders the final verdict. Use this skill whenever the user asks for a "review panel", "multi-agent review", "adversarial review", "have agents debate this", "review with multiple perspectives", "panel review", "get different opinions on this code/plan/doc", or invokes /agent-review-panel. Also trigger when a user says things like "I want thorough feedback from different angles", "stress-test this design", "red team this", "get a second (third, fourth) opinion", "fresh eyes on this", "multiple reviewers", "devil's advocate perspective", "every angle covered", "I want agents to argue pros and cons", "independently evaluate", "critical look from security and performance angles", "high-stakes — cover every angle", or "debate the pros and cons". This skill is specifically about launc

Integrate structured review panel findings into an implementation plan document. Takes output from agent-review-panel (or any structured review with severity-rated findings) and cross-references each finding against the plan, classifies it into an action category, applies concrete edits, and produces a traceability summary. Trigger when the user says "update the plan with review findings", "incorporate review feedback into the plan", "integrate review results", "apply review recommendations to the plan", "cross-reference review output against the plan", "merge review findings into the implementation plan", "what needs to change in the plan based on the review", "take the review panel output and update my plan", "reconcile the review feedback with the current plan", or invokes /plan-review-integrator. Does NOT trigger for running a review panel (use agent-review-panel), writing a plan from scratch, general code review, summarizing review findings without applying them, or brainstorming implementation approache

End-of-session handoff that captures session knowledge, dispatches output across the canonical 7-bucket docs/ taxonomy (decisions/runbooks/analysis/references/reviews/handoffs/deliverables — aligned with memory-hygiene v3.3), triggers a doc-freshness reverse-lint + skill-freshness audit to catch stale normative guidance, emits the future-to-do plan's follow-up items as GitHub issues, updates memory, and prepares next-session prompts. Use when: (1) user says 'wrap up', 'hand over', 'create handoff', 'end of session', 'write handoff', 'session handoff'; (2) non-trivial work session (3+ tasks) is ending; (3) context window is approaching limits; (4) user says 'consolidate', 'what's the current state', 'start here document' after parallel sessions; (5) the session produced artifacts that belong in more than one docs/ bucket (ADR + analysis + runbook + review). Includes cross-session consolidation when 3+ handoffs accumulate and a mandatory reverse-lint verify step against any lessons.md / feedback_*.md touched th

Use when orchestrating long-running autonomous work — overnight runs, multi-hour research, multi-track experiments, 10+ hour jobs — where a single Claude context window cannot hold the full run. Establishes a lean parent orchestrator, file-first subagents, and successor-handoff (fresh subagent spawned mid-run when context pressure rises). This is distinct from session-handoff, which is for end-of-run delivery to a human — use successor-handoff instead whenever the handoff is agent-to-agent and mid-run. Trigger on any mention of overnight workflows, autonomous multi-track runs, context-window budgeting for long jobs, successor or continuation agents, mid-run context pressure, file-first orchestration, lean-parent patterns, or scenarios where the user needs work to continue without a human in the loop.

Turn dense technical findings, an analysis, a code/research session outcome, or a jargon-heavy document into a genuinely PLAIN-ENGLISH self-contained HTML explainer a non-technical or busy stakeholder can actually understand AND trust — built on a single everyday metaphor carried through the whole piece (the bad news included), with the REAL numbers shown honestly beside each plain claim, an "engineer's note" layer so technical readers aren't shortchanged, a foregrounded honesty/limits box, and a bundled FACT-VERIFIER that checks every claim, number, and metaphor back against the source document to catch translation drift before anyone reads it (self-contained, opens straight from file:// — no build, no server; arcade/pixel aesthetic). Use this WHENEVER the user wants to explain technical work in plain English, make a pretty/shareable report, one-pager, or recap, summarize an investigation/session "so my boss/team/client can understand it," translate jargon results for a lay audience, or asks for an explainer

Turn dense technical findings, an analysis, a code/research session outcome, or a jargon-heavy document into a genuinely PLAIN-ENGLISH self-contained HTML explainer a non-technical or busy stakeholder can actually understand AND trust — built on a single everyday metaphor carried through the whole piece (the bad news included), with the REAL numbers shown honestly beside each plain claim, an "engineer's note" layer so technical readers aren't shortchanged, a foregrounded honesty/limits box, and a bundled FACT-VERIFIER that checks every claim, number, and metaphor back against the source document to catch translation drift before anyone reads it (self-contained, opens straight from file:// — no build, no server; arcade/pixel aesthetic). Use this WHENEVER the user wants to explain technical work in plain English, make a pretty/shareable report, one-pager, or recap, summarize an investigation/session "so my boss/team/client can understand it," translate jargon results for a lay audience, or asks for an explainer

Use when an agent harness's skills/tools catalog has grown large (hundreds+, e.g. from an auto-skill-minting loop) and is taxing context: the listing of skill names+descriptions is injected every turn AND into every subagent, so cost multiplies on fan-out and small-context agents can overflow ("Prompt is too long" at 0 tokens). This skill is the AUDIT + CURATION methodology plus measurement/reporting: the trimming levers are now native harness features (Claude Code ships them built in) — the durable value is deciding WHAT to trim (episodic lessons vs real skills), applying it safely, and measuring the result. The PROBLEM + curation METHODOLOGY are harness-agnostic — the Agent Skills open standard (agentskills.io) is shared by Claude Code, Cursor, Codex, Copilot CLI, Gemini CLI; only the levers differ. Covers: the portable diagnosis + classification rigor (curate by INTENT not name, conservative asymmetry, blind re-rate, deterministic checks over LLM votes); the cross-harness landscape (native budget on Claude

Use when an agent harness's skills/tools catalog has grown large (hundreds+, e.g. from an auto-skill-minting loop) and is taxing context: the listing of skill names+descriptions is injected every turn AND into every subagent, so cost multiplies on fan-out and small-context agents can overflow ("Prompt is too long" at 0 tokens). This skill is the AUDIT + CURATION methodology plus measurement/reporting: the trimming levers are now native harness features (Claude Code ships them built in) — the durable value is deciding WHAT to trim (episodic lessons vs real skills), applying it safely, and measuring the result. The PROBLEM + curation METHODOLOGY are harness-agnostic — the Agent Skills open standard (agentskills.io) is shared by Claude Code, Cursor, Codex, Copilot CLI, Gemini CLI; only the levers differ. Covers: the portable diagnosis + classification rigor (curate by INTENT not name, conservative asymmetry, blind re-rate, deterministic checks over LLM votes); the cross-harness landscape (native budget on Claude

Repair a Claude Code session whose transcript JSONL has an orphan `server_tool_use` / `*_tool_result` content block, causing every API call (including `/compact` and `claude --resume`) to fail with HTTP 400 "unexpected tool_use_id found in advisor_tool_result blocks: srvtoolu_... Each ... block must have a corresponding server_tool_use block before it". Use when: (1) a Claude Code session dies mid-advisor call with "socket connection was closed unexpectedly", (2) resume / compact returns the 400 above naming `srvtoolu_...`, (3) `/remote-control` (or any system event) activated mid-stream while the assistant was emitting an advisor response. Covers diagnosis via grouping JSONL lines by shared `message.id`, surgical deletion of the orphan pair (both halves), and the line-number-drift gotcha that occurs when the file grows between inspection and edit.

Repair a Claude Code session whose transcript JSONL has assistant messages containing a whitespace-only text block (typically `{"type":"text","text":" "}`), causing every API call (including new prompts, `/compact`, and `claude --resume`) to fail with HTTP 400 "messages: text content blocks must contain non-whitespace text". Use when: (1) a session refuses to accept new input with that exact 400, (2) `/compact` fails with the same 400 (since compact replays the full history first — it does NOT bypass the validator), (3) `claude --resume <id>` immediately exits with the same error. Covers diagnosis via JSON-walking the message.content array (NOT plain grep — the empty block is often nested), the distinction between message.content (sent to API → must fix) and toolUseResult (local metadata → harmless, leave alone), the underlying cause (extended-thinking turn serialization emits a synthetic single-space placeholder before the thinking block), and an idempotent fixer script that replaces " " with "." while prese

End-of-session handoff that captures session knowledge, dispatches output across the canonical 7-bucket docs/ taxonomy (decisions/runbooks/analysis/references/reviews/handoffs/deliverables — aligned with memory-hygiene v3.3), triggers a doc-freshness reverse-lint + skill-freshness audit to catch stale normative guidance, emits the future-to-do plan's follow-up items as GitHub issues, updates memory, and prepares next-session prompts. Use when: (1) user says 'wrap up', 'hand over', 'create handoff', 'end of session', 'write handoff', 'session handoff'; (2) non-trivial work session (3+ tasks) is ending; (3) context window is approaching limits; (4) user says 'consolidate', 'what's the current state', 'start here document' after parallel sessions; (5) the session produced artifacts that belong in more than one docs/ bucket (ADR + analysis + runbook + review). Includes cross-session consolidation when 3+ handoffs accumulate and a mandatory reverse-lint verify step against any lessons.md / feedback_*.md touched th

Generate Token Torch's AI insights using THIS agent session (no API key). Use when the user says "generate token torch insights", "write my insights", "run token-torch insights", or after running `pnpm generate` in the token-torch repo. Reads insights-request.md, writes insights.local.md, re-runs generate.