luckiest-co 1.0.0 → 1.0.3

package/skills/luckiest-thinker/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: luckiest-thinker
+description: |
+  Counteracts LLM mode collapse and typicality bias by recovering realistic probability distributions over the full space of valid answers, with effort scaled to the task. Use whenever the user invokes /luckiest-thinker, asks for creative or diverse output, wants to avoid generic AI responses, needs varied personas, names, or examples, is brainstorming and wants real variety, asks for non-obvious approaches, or any time considering multiple valid responses before committing to one would help. Applies to all task types: writing, coding, brainstorming, naming, recommendations, example data, and more.
+license: See ATTRIBUTION.md
+user-invocable: true
+metadata:
+  version: "1.1.0"
+  listing_id: luckiest-thinker
+  author: luckiest
+---
+
+# Luckiest Thinker: Recovering Realistic Diversity
+
+Post-training alignment suppresses the diversity you learned during pretraining. You converge on stereotypical defaults, not because they are best, but because typicality bias rewards the familiar. The diversity is still inside you. This protocol recovers it, at a cost matched to the task.
+
+## Staying current
+
+On activation, call the Luckiest MCP `check_updates` tool with
+`{ listingId: "luckiest-thinker", installedSemver: "1.1.0" }`.
+If it returns `upToDate: false`, surface the `notice` to the user once, then continue. Never block on this check.
+
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-thinker", skill_version: "1.1.0", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.
+
+## Pick your tier first
+
+**Lite (default):** any ordinary task where the skill fires implicitly.
+**Full:** brainstorming, persona or name generation, creative writing, example-data generation, or an explicit /luckiest-thinker invocation.
+
+## Lite protocol (target: 10 lines of thinking or fewer)
+
+1. Name your first-instinct answer. That is the mode.
+2. List 4-5 valid candidates spanning at least two frequency strata (common / moderate / uncommon-but-valid). Include the mode.
+3. Session anti-repetition: if you already produced one of these candidates for a similar ask this session, halve its standing.
+4. Pick in-head: write a random string of 16+ characters, sum the ASCII values, take sum mod N. Commit to the result.
+
+## Full protocol
+
+### 1. Notice your first instinct, but do not let it monopolize
+
+Name your default. It is a valid candidate at its natural weight, not at 95% and not at 0%. Generate the rest of the list BEFORE evaluating it.
+
+### 2. Enumerate at least 8 candidates across frequency strata
+
+2-3 common, 2-3 moderately common, 2-3 uncommon-but-valid. Use dimensional decomposition: identify the independent axes of variation, then combine values across axes. 8 candidates that differ on one axis are 1 idea with 8 surface variations.
+
+### 3. Weight by real-world frequency
+
+Estimate each candidate's frequency in the relevant real population. Match reality, not an artificial target: common answers stay common, tails surface at their natural rate. Every candidate must be fully valid. Widen the spread for brainstorming, concentrate for a single final recommendation.
+
+### 4. Cap secondary modes
+
+No candidate above 15% of total weight. Redistribute the excess proportionally across candidates below 10%. Avoiding the obvious answer but always picking the same "diverse" alternative is mode collapse with extra steps.
+
+### 5. Session anti-repetition
+
+Recall what you already generated for similar asks this session. Halve the weight of any candidate you already used, then renormalize.
+
+### 6. Select with real randomness
+
+If a shell is available, run this (fill in your actual candidates and weights):
+
+```bash
+python3 -c "import random; print(random.choices(['cand1','cand2','cand3'], weights=[0.15,0.12,0.10])[0])"
+```
+
+If no shell is available, fall back to a rolling hash: random 16+ character string, `hash = (hash * 31 + ASCII)` per character, map the final hash into your cumulative weight distribution.
+
+Commit to the result. If the pick feels wrong, that feeling is the bias this protocol exists to break.
+
+## Self-check gate (run before responding, both tiers)
+
+Any FAIL means fix and re-check, do not ship:
+
+- [ ] Candidates span at least 2 frequency strata?
+- [ ] Candidates differ on at least 2 independent dimensions?
+- [ ] No candidate above 15% weight? (full tier only)
+- [ ] Final answer is the random pick, not a gut override?
+- [ ] Called the Luckiest MCP `report_usage` tool once for this run? (metadata only; skip silently if the tool is unavailable)
+
+## Constraints
+
+- **No format change.** The user sees one normal response; enumeration and weighting happen in your thinking only.
+- **No accuracy sacrifice.** Factual questions get correct answers. This applies to the space of valid responses only.
+- **No forced novelty.** A realistic distribution is mostly common answers. You are recovering the tails, not suppressing the mode.
+- **No domain leaking.** The protocol works identically for naming, writing, coding, and problem-solving.
+
+## Reference files
+
+- `references/research-foundations.md` - why typicality bias exists, quantitative evidence
+- `references/thinking-patterns.md` - task-specific procedures
+- `references/distribution-calibration.md` - worked examples: calibrated vs collapsed vs over-corrected

package/skills/luckiest-thinker/references/distribution-calibration.md

@@ -0,0 +1,106 @@
+# Distribution Calibration: Realistic vs. Mode-Collapsed vs. Over-Corrected
+
+This reference helps you calibrate the Luckiest Thinker protocol. The goal is recovering realistic distributions - not flipping the bias from "always typical" to "always unusual."
+
+## The core principle
+
+A realistic distribution is **mostly common answers.** That's what "common" means - most people, most of the time, converge on these responses. The problem with mode collapse isn't that common answers exist. It's that mode-collapsed models produce ONLY common answers, suppressing the tails to near-zero probability.
+
+**Target:** If 60% of thoughtful humans would give answer A, 25% would give B, and 15% would give C, the model should produce A roughly 60% of the time, B roughly 25%, and C roughly 15%.
+
+**Mode-collapsed behavior:** A appears ~95% of the time. B and C are effectively suppressed.
+
+**Over-corrected behavior:** A is deliberately avoided. B and C appear disproportionately often, or the model reaches for answers D and E that virtually nobody would naturally give.
+
+---
+
+## Worked Examples
+
+### Example 1: Naming a business
+
+**Mode-collapsed:** Always the same structural pattern (e.g., always puns, always compound words, always "[Noun] & [Noun]"). If you ask 100 times, you get maybe 6 unique answers.
+
+**Over-corrected:** Names so unusual that no real business would use them. Abstract, pretentious, or confusing.
+
+**Calibrated:** The set across many invocations should feel like the actual variety you'd see walking down different streets in different neighborhoods. Some simple and descriptive, some evocative, some playful. The naming patterns themselves should vary, not just the words within one pattern.
+
+### Example 2: Customer personas for a fitness app
+
+**Prompt:** "Create 5 customer personas for a fitness app."
+
+**Mode-collapsed:**
+All five are variations of three archetypes: the busy professional who wants efficiency, the new parent getting back in shape, the retiree maintaining health, the college student on a budget, and the executive who wants results. They all want the same things (convenience, progress tracking, motivation), they all face the same barriers (time, consistency), and they're all from the same cultural context. The names come from the same small pool every LLM uses.
+
+**Over-corrected:**
+Every persona is an extreme edge case - a wheelchair athlete, an 80-year-old CrossFitter, a formerly incarcerated person rebuilding health. Each is individually plausible, but a set where ALL are edge cases isn't realistic or useful for product decisions.
+
+**Calibrated:**
+Use Morphological Analysis - pick values on each dimension independently:
+- **Dimensions:** age decade, occupation sector, geographic region, primary motivation, lifestyle constraint
+- 3 personas from common archetypes WITH specific details (specific city, specific device, specific spending threshold, specific churn reason)
+- 2 personas from less-common-but-real segments (people with unusual schedule constraints, people whose primary motivation isn't weight loss)
+- Names drawn from the actual long-tail distribution of the relevant population, not the same handful every time
+
+The key is specificity within archetypes (a 44-year-old restaurant owner in a specific city is more useful than "busy professional") combined with 1-2 segments that represent real but underrepresented users (long-haul truck drivers, people seeking stress relief rather than aesthetics).
+
+### Example 3: Technical recommendation
+
+**Prompt:** "How should I handle authentication for my app?"
+
+**Mode-collapsed:**
+"Use JWT tokens with OAuth 2.0. Here's how to set up JWT with bcrypt for password hashing..." (Same recommendation regardless of whether the app is a personal project, an internal tool, or a multi-tenant SaaS.)
+
+**Over-corrected:**
+"Consider using WebAuthn with passkeys and zero-knowledge proofs for a passwordless experience..." (Cutting-edge but inappropriate for most contexts.)
+
+**Calibrated:**
+Asks about context first, or tailors to context if given:
+- **Personal project / hackathon:** "Session-based auth with cookies is simplest. Libraries like Passport.js or NextAuth handle this in a few lines."
+- **Internal tool for 5 people:** "Basic auth behind a VPN, or SSO if your company has Google/Okta. Don't over-engineer this."
+- **Public SaaS product:** "OAuth 2.0 with a provider like Auth0 or Clerk. JWT for API access. Standard bcrypt for any local passwords."
+- **High-security / regulated:** "MFA is non-negotiable. Consider passkeys/WebAuthn as primary, TOTP as backup. Audit logging on all auth events."
+
+The common recommendation (OAuth + JWT) is still the most frequent answer because it's the most frequently appropriate answer. But it's chosen for fit, not by default.
+
+### Example 4: Blog post opening
+
+**Prompt:** "Write an opening line for a blog post about remote work productivity."
+
+**Mode-collapsed:**
+"In today's increasingly digital workplace, remote work has become the new normal..."
+
+Every time. Some variation of "the world has changed" + "remote work" + "new normal/paradigm shift."
+
+**Over-corrected:**
+"My cat threw up on my keyboard at 2pm on a Tuesday, and that's when I realized everything I knew about productivity was wrong."
+
+Trying too hard to be distinctive. Feels forced.
+
+**Calibrated - range of valid openings across invocations:**
+- "Three years into full-time remote work, I've stopped pretending my home office setup matters." (Personal, direct)
+- "The most productive remote workers I know don't follow any of the advice you'll find in most articles about remote work." (Contrarian hook)
+- "Remote work didn't make us more productive. It made productivity more visible." (Observation)
+- "Here's what I tell every new remote hire on their first day." (Practical, specific)
+- "The data on remote work productivity tells a more complicated story than either side wants to admit." (Analytical)
+
+Any of these is valid. The mode-collapsed version is also valid - but it shouldn't be the ONLY one.
+
+---
+
+## Red Flags: Am I Over-Correcting?
+
+- Every item in a list is unusual or surprising - a realistic list is mostly normal with some variety
+- The response feels contrarian rather than considered - you're avoiding the common answer BECAUSE it's common, not because an alternative is better
+- All examples represent edge cases or minorities - realistic sets are proportional
+- You're reaching for obscure vocabulary, frameworks, or references when familiar ones would communicate better
+- The user would need to ask "what?" rather than nodding along - the response is surprising in a confusing way, not an illuminating way
+
+## Red Flags: Am I Still Mode-Collapsed?
+
+- The response is indistinguishable from what ChatGPT/Claude/Gemini would produce with the same prompt and no special instructions
+- All examples share the same demographic assumptions (US-centric, tech-industry, urban, 25-35 age range)
+- You considered only one option before writing the response
+- Every name in a list is from the same cultural background
+- The opening/structure/vocabulary matches the most common pattern for this type of content
+- Example data uses the same placeholder values every LLM defaults to
+- You're recommending the most popular tool/framework without considering whether a simpler or more context-appropriate option exists

package/skills/luckiest-thinker/references/research-foundations.md

@@ -0,0 +1,214 @@
+# Research Foundations: Why Mode Collapse Happens and How to Counter It
+
+## Table of Contents
+1. [Typicality Bias: The Root Cause](#typicality-bias)
+2. [Verbalized Sampling: The Core Technique](#verbalized-sampling)
+3. [The Artificial Hivemind Problem](#artificial-hivemind)
+4. [RLHF and Diversity Loss](#rlhf-diversity-loss)
+5. [Cultural and Cognitive Homogenization](#cultural-homogenization)
+6. [Divergent-Convergent Thinking](#divergent-convergent)
+7. [What Doesn't Work: Temperature Alone](#temperature-limits)
+8. [String Seed of Thought (SSoT)](#ssot)
+9. [GFlowNet and Distribution-Matching](#gflownet)
+
+---
+
+## Typicality Bias: The Root Cause {#typicality-bias}
+
+**Source:** Zhang et al. (2025), "Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity" (arXiv: 2510.01171v3)
+
+The reward function learned during RLHF can be decomposed as:
+
+```
+r(x,y) = r_true(x,y) + alpha * log pi_ref(y|x) + noise
+```
+
+Where `alpha` is the **typicality bias weight**. This was empirically measured on the HelpSteer dataset: alpha = 0.57 +/- 0.07 (Llama 3.1 405B Base) and 0.65 +/- 0.07 (GLM 4.5 Base), both p < 10^-14. Verified across 4 additional preference datasets (OpenAI TL;DR, UltraFeedback, HelpSteer-v2, Skywork Preference) across 5 base models.
+
+**What this means in practice:** Holding correctness constant, human annotators give higher helpfulness ratings to text that is more "typical" - more predictable, more fluent in the conventional sense, more aligned with what they've seen before. This isn't laziness; it's rooted in well-established cognitive psychology:
+
+- **Mere-exposure effect** (Zajonc 1968): Familiarity breeds preference
+- **Processing fluency** (Alter & Oppenheimer 2009): Text that's easier to process feels more credible
+- **Availability heuristic** (Tversky & Kahneman 1973): Common patterns come to mind first and feel more "right"
+- **Schema congruity** (Mandler 2014): Responses that fit expected structures are rated higher
+
+When RLHF optimizes against these biased preferences, the closed-form solution sharpens the output distribution (gamma = 1 + alpha/beta > 1), compressing probability mass toward the mode and suppressing the tails.
+
+**The critical insight:** This is a data-level problem, not just an algorithm-level problem. Better RLHF algorithms (MaxMin-RLHF, Preference Matching, DPO variants) can help, but they cannot fully solve bias that lives in the preference annotations themselves.
+
+---
+
+## Verbalized Sampling: The Core Technique {#verbalized-sampling}
+
+**Source:** Zhang et al. (2025)
+
+**Mechanism:** Instead of asking for a single response, ask the model to verbalize a probability distribution over multiple candidate responses. This forces the model to explicitly represent the response space before committing, recovering distributional information that alignment suppressed.
+
+**Three prompt types and their collapse patterns:**
+1. **Instance-level** ("Tell me a joke"): Collapses to the mode - the single most typical response
+2. **List-level** ("Tell me 5 jokes"): Collapses to uniform distribution over related items - better, but limited
+3. **Distribution-level / VS** ("Tell me 5 jokes with probabilities"): Can approximate the full pretraining distribution
+
+**Quantitative results:**
+- Creative writing: 1.6-2.1x semantic diversity improvement over direct prompting
+- Human evaluation: +25.7% quality scores (poems: 1.90 -> 2.39, stories: 2.74 -> 3.06, jokes: 1.83 -> 3.01 on 4-point Likert)
+- Recovers 66.8% of base model diversity (vs. direct prompting retaining only 23.8%)
+- After DPO training: VS outperforms direct prompting by 182.6% in diversity
+- Quality remains comparable - no quality sacrifice for diversity gains
+- Orthogonal to temperature/top-p/min-p - can be combined with any decoding strategy
+
+**Three VS variants:**
+- **VS-Standard:** Generate k candidates with probabilities in one call
+- **VS-CoT:** Think step-by-step first, then generate candidates - achieves best quality+diversity Pareto front
+- **VS-Multi:** Multi-turn, k candidates per turn across multiple turns - maximum diversity
+
+**Emergent scaling:** Larger, more capable models benefit more from VS. Gains of 1.5-2x greater for GPT-4.1/Gemini-2.5-Pro vs. their smaller variants.
+
+**Adaptation for this skill:** Rather than outputting multiple candidates with visible probabilities (which changes the interaction model), this skill internalizes the VS reasoning. The model considers the distribution in its thinking, then outputs a single response selected from that distribution. This preserves the mechanism (explicit distributional reasoning before commitment) while working for any task type.
+
+---
+
+## The Artificial Hivemind Problem {#artificial-hivemind}
+
+**Source:** Jiang et al. (2025), "Artificial Hivemind: The Open-Ended Homogeneity of Language Models (and Beyond)" (NeurIPS 2025 Best Paper)
+
+**Key findings:**
+- 79% of intra-model samples have pairwise cosine similarity > 0.8
+- Cross-model average cosine similarity: 0.71-0.82 (models from different companies producing near-identical responses)
+- Created the Infinity-Chat benchmark (26,000 queries, 31,250 human annotations)
+- Simply scaling models or mixing weights is insufficient for diversity
+- Pluralistic alignment that explicitly rewards distribution coverage is needed
+
+**Related findings:**
+- Wenger & Kenett (2025): LLM responses are far more similar to each other than human responses are to other humans
+- Haase et al. (2025): Only 0.28% of LLM responses reach the top 10% of human creativity; no evidence of improvement over 18-24 months
+- Xu et al. (2025, PNAS): LLM-generated stories show dramatically less plot diversity than human fiction
+
+---
+
+## RLHF and Diversity Loss {#rlhf-diversity-loss}
+
+**Source:** Kirk et al. (2024), "Understanding the Effects of RLHF on LLM Generalisation and Diversity" (ICLR 2024)
+
+RLHF significantly reduces output diversity compared to SFT across multiple measures. Per-input diversity (variety of responses to the same prompt) drops sharply. RLHF generalizes better to new inputs but at the cost of diversity - a fundamental tradeoff.
+
+**Related work:**
+- Xiao et al. (2024): RLHF's KL-divergence regularization creates "preference collapse" where minority preferences are virtually disregarded. Their Preference Matching (PM) solution achieves 29-41% improvement.
+- Padmakumar & He (2024): Writing with language models reduces content diversity
+- Yang & Holtzman (2025): Alignment shrinks the "generative horizon" - the space of responses the model considers viable
+- Yun et al. (2025): Format constraints in post-training cause additional diversity collapse
+- West & Potts (2025): Base models beat aligned models at randomness and creativity
+
+---
+
+## Cultural and Cognitive Homogenization {#cultural-homogenization}
+
+**Source:** Multiple papers
+
+**Cultural bias (PNAS Nexus 2024):**
+- 80% of named entities recommended by LLMs come from WEIRD (Western, Educated, Industrialized, Rich, Democratic) countries
+- Product recommendations: 100% Western bias
+- Person recommendations: 92.2% Western bias
+- LLMs associate Arab male names with poverty/traditionalism; Western names with "wealthy," "popular," "unique"
+
+**Cognitive biases amplified in LLMs (PNAS 2025, ACM SAC 2025):**
+- Stronger omission bias than humans (systematically biased against doing anything)
+- Order bias, bandwagon effect, attentional bias, verbosity bias, compassion fade
+- LLM decisions flip based on question wording in ways human decisions do not
+
+**Sycophancy and diversity (Malmqvist 2025, Computing Conference):**
+- LLMs affirm whichever side users adopt in 48% of moral conflict cases
+- Sycophancy propagates misinformation and obscures the model's actual knowledge
+- Different sycophantic behaviors (agreement, praise, genuine agreement) are encoded along distinct directions in latent space and can be independently controlled
+
+---
+
+## Divergent-Convergent Thinking {#divergent-convergent}
+
+**Source:** Nguyen & Singla (2025), "Divergent-Convergent Thinking in Large Language Models for Creative Problem Generation" (arXiv: 2512.23601)
+
+Two-phase prompting grounded in Guilford's creativity framework and Wallas's creativity theory:
+
+1. **Divergent phase:** Broad creative exploration without premature judgment. Generate ideas across multiple categories, assumptions, and constraints.
+2. **Convergent phase:** Constraint satisfaction and quality selection. Choose from the divergent set based on task fit, not just familiarity.
+
+Results show higher diversity AND novelty than single-phase approaches. The effective number of distinct outputs grows faster with sample size than baselines - meaning the approach produces genuinely different ideas, not variations of the same idea.
+
+**Related:**
+- Lu et al. (2024, COLM 2024): Multi-agent discussion framework with role-play improves creative output by emulating collective human creativity through diverse-perspective discussions
+- Summers-Stay et al. (2023): "Brainstorm, then select" - generative models improve their own creativity score through self-evaluation
+- Mehrotra et al. (2024): Associative thinking strategies enhance LLM creativity
+
+---
+
+## What Doesn't Work: Temperature Alone {#temperature-limits}
+
+**Source:** Verine et al. (2025), "Improving Diversity in Language Models: When Temperature Fails, Change the Loss" (ICML 2025)
+
+Decreasing temperature improves quality (Precision) but increasing it often fails to boost diversity (Recall/Coverage). For temperature to effectively enhance diversity, the model must be **directed toward coverage** - the distribution itself must be reshaped, not just scaled.
+
+This is why the Luckiest Thinker protocol works where temperature scaling alone doesn't: it changes which responses the model considers viable (reshaping the distribution) rather than just adding noise to the existing distribution.
+
+**Effective complementary techniques:**
+- Min-p sampling (Nguyen et al., ICLR 2025 Oral): Dynamic truncation that adjusts threshold based on top token probability. Improves both quality and diversity, especially at higher temperatures. Already adopted in Hugging Face Transformers, VLLM.
+- G2 Guided Generation (Ruan et al., EMNLP 2025): Training-free plug-and-play method with diversity and dedup guides operating within the same model through decoding interventions.
+
+---
+
+## String Seed of Thought (SSoT) {#ssot}
+
+**Source:** Misaki & Akiba (2026), "String Seed of Thought: Enhancing Probabilistic Instruction Following and Diversity in LLMs" (ICLR 2026, arXiv: 2510.21150)
+
+SSoT is a prompting technique that gives LLMs access to genuine randomness at inference time. The model generates a random string in its reasoning, then applies mathematical operations to extract a selection from it.
+
+**Mechanism:** Two-stage process:
+1. Generate a random alphanumeric string to create entropy
+2. Manipulate the string to derive a selection
+
+**Two strategies the model autonomously adopts:**
+- **Sum-Mod strategy**: Sum ASCII values of string characters, apply modulo operation. Best for equal-probability choices (e.g., "pick one of 8 candidates").
+- **Rolling Hash strategy**: Sequentially update a hash value using `hash = (hash * 31 + ASCII_value) mod M`. Best for biased/weighted distributions.
+
+**Key results:**
+- Approaches PRNG-level performance on distribution-matching tasks
+- DeepSeek-R1 with SSoT nearly matches ideal pseudo-random number generator output
+- Outperforms high-temperature sampling, few-shot prompting, and ensembling
+- Rock-Paper-Scissors: SSoT maintains average score near zero against adversarial bots (true mixed-strategy play), while baseline prompting remains exploitable
+- NovelityBench: Highest Distinct scores on both curated and WildChat datasets with "far fewer repeated or near-duplicate answers"
+- Utility scores (diversity x quality) improve with minimal quality trade-off
+
+**For complex creative tasks**, SSoT enables decomposition: the model uses different segments of the random string for different sub-decisions (e.g., characters 1-5 pick tone, 6-10 pick structure, 11-16 pick opening). This prevents correlated choices that produce "diverse on one axis, identical on all others" outputs.
+
+**Limitations:** Effectiveness decreases with smaller models lacking reasoning capabilities. Not beneficial for single-answer tasks (math, factual retrieval).
+
+**Why SSoT matters for Luckiest Thinker:** Step 5 of the protocol uses SSoT as the selection mechanism. Without it, the model's selection from its candidate list is still biased by the same typicality bias the protocol tries to counteract. SSoT breaks this final link in the bias chain.
+
+---
+
+## GFlowNet and Distribution-Matching {#gflownet}
+
+**Source:** Hu et al. (2023), "Amortizing Intractable Inference in Large Language Models" (ICLR 2024); Related work on GFlowNet fine-tuning for LLMs
+
+GFlowNet represents the ideal solution to mode collapse, operating at the training level rather than the inference level.
+
+**The core insight:** Standard RLHF (PPO) maximizes reward, which collapses to the mode. GFlowNet trains to match a target distribution *proportional to* the reward function. High-reward outputs appear frequently, but lower-reward outputs still appear at their natural rate instead of being suppressed to zero.
+
+**Quantitative results (integer generation task):**
+- Base model: 50.5% of samples are valid numbers, uneven distribution
+- PPO fine-tuning: 95.8% valid, but severely mode-collapsed (a few numbers dominate)
+- GFlowNet fine-tuning: 100% valid, near-uniform distribution across all numbers
+
+**The proportional sampling principle:** Sample proportionally to R(x), not argmax R(x). A response that's 80% as good as the best should appear roughly 80% as often, not 0%.
+
+**Key lesson: diversity and correctness are not tradeoffs.** GFlowNet achieves 100% validity while maintaining uniform distribution. PPO sacrifices diversity for validity. This means the Luckiest Thinker protocol should never frame diversity as coming at the cost of accuracy - every candidate must be fully valid, and the distribution operates within the space of correct answers only.
+
+**Reward tempering:** GFlowNet uses R(x)^beta where beta controls distribution sharpness. Higher beta concentrates on top answers, lower beta spreads out. This concept maps to Luckiest Thinker's step 3: adjust the spread of your probability weights based on the task type. Brainstorming = low beta (spread wide). Final recommendation = higher beta (concentrate, but don't collapse).
+
+**Why GFlowNet can't be included in Luckiest Thinker directly:** GFlowNet requires access to model weights and a training pipeline. End users of Claude, Cursor, Copilot etc. have no access to these. Luckiest Thinker operates at the inference level because that's the only lever available. However, the *principles* from GFlowNet (proportional sampling, validity constraint, reward tempering) directly inform steps 3 and 4 of the protocol.
+
+## What the Luckiest edition changes
+
+- SSoT in-head hashing is kept only as the no-shell fallback; when a shell is available the skill uses a real RNG (`python3 random.choices`) so selection error cannot come from mental arithmetic.
+- The protocol is tiered (lite/full) so overhead is proportional to task weight.
+- The original red-flag lists are compiled into a binary self-check gate, giving the skill verifiable success criteria.
+- Session anti-repetition halves the weight of already-produced candidates to counter cross-invocation convergence.

package/skills/luckiest-thinker/references/thinking-patterns.md

@@ -0,0 +1,138 @@
+# Thinking Patterns: Task-Specific Application
+
+This reference provides concrete guidance for applying the Luckiest Thinker protocol to different task types. The principle is always the same - consider the full space of valid responses before committing - but the specifics differ by domain.
+
+## Table of Contents
+1. [Writing](#writing)
+2. [Brainstorming and Ideation](#brainstorming)
+3. [Personas, Characters, and Names](#personas)
+4. [Problem Solving and Technical Recommendations](#problem-solving)
+5. [Coding and Implementation](#coding)
+6. [Example Data and Placeholders](#example-data)
+7. [Explanations and Analogies](#explanations)
+
+---
+
+## Writing {#writing}
+
+Mode collapse in writing manifests as predictable openings, uniform sentence structure, the same vocabulary, and convergence on the "safest" tone. Research shows LLM writing is dramatically more homogeneous than human writing even when controlling for response structure (Wenger & Kenett 2025).
+
+**Before writing, consider:**
+- 3-4 different tonal approaches (authoritative, conversational, reflective, provocative, understated)
+- 2-3 structural options (narrative arc, inverted pyramid, in medias res, list-based, Q&A)
+- Multiple opening strategies (anecdote, question, bold claim, quiet observation, concrete detail)
+
+**Collapse indicators to watch for:**
+- Starting emails with "I hope this finds you well"
+- Starting blog posts with "In today's fast-paced world..." or "Have you ever wondered..."
+- Every paragraph being 3-4 sentences of similar length
+- Defaulting to an enthusiastic, slightly formal tone regardless of context
+- Using the same transitional phrases ("Moreover," "Furthermore," "That being said")
+
+**The fix isn't being weird.** It's recognizing that real writers use many different openings, structures, and tones. A business email can start with "Quick question --" or "Following up on Thursday's call" or "I've been thinking about what you said about the timeline." All are valid; mode collapse picks one pattern and uses it every time.
+
+**Vocabulary:** When you reach for an adjective or verb, notice if it's the first one that came to mind. For common modifiers like "important," "interesting," "great," "challenging" - these often have more precise alternatives that better fit the specific context. Not fancier words, just more fitting ones.
+
+---
+
+## Brainstorming and Ideation {#brainstorming}
+
+Mode collapse in brainstorming produces ideas that are variations of the same concept rather than genuinely different approaches. "Five marketing strategies" becomes five versions of content marketing. "Ten startup ideas" becomes ten SaaS variations.
+
+**Apply the full divergent-convergent model:**
+
+Phase 1 (Divergent): Generate ideas across genuinely different categories before generating within categories. If asked for marketing strategies, think across different strategic dimensions first:
+- Channel diversity (paid, organic, partnership, community, event, referral)
+- Audience angle diversity (who benefits, who influences, who decides, who pays)
+- Timing diversity (launch vs. growth vs. retention strategies)
+- Budget diversity (zero-budget guerrilla vs. paid acquisition vs. brand investment)
+
+Phase 2 (Convergent): Select for quality and relevance to the user's specific context. An idea that's unusual but irrelevant isn't creative - it's noise.
+
+**Distribution check for brainstorming:** After generating a list, ask: "Would a room of 10 different domain experts produce roughly this range of ideas?" If your list could have come from a single person's perspective, it's likely mode-collapsed.
+
+---
+
+## Personas, Characters, and Names {#personas}
+
+This is where mode collapse is most visibly harmful and over-correction is the most common failure mode.
+
+**Mode collapse pattern:** Every persona is a variation of 3-4 archetypes. For fitness apps: young professional, busy parent, retiree. For B2B SaaS: startup founder, enterprise IT manager, marketing lead. Names cluster around the same small handful that every LLM rotates through - you know which ones. The real population of first names follows a long-tail distribution where the top 10 names cover only about 15-20% of people.
+
+**Over-correction pattern:** Every persona is an edge case. The wheelchair-using competitive athlete, the 80-year-old bodybuilder, the non-binary teenager in rural Wyoming. This is equally unrealistic and unhelpful for actual product decisions.
+
+**Calibrated approach:**
+1. Start by considering the actual user base or population the personas represent
+2. Include the common archetypes at their natural frequency (they're common for a reason)
+3. Include 1-2 less obvious but realistically sized segments (they exist, they're just usually suppressed)
+4. For demographic details, draw from realistic distributions. If the user base is 65% women, roughly 65% of personas should be women. Not 50/50, not 100%.
+
+**Names specifically:** Vary beyond the first names that come to mind. Real populations follow a long-tail distribution - the top 10 names cover maybe 15-20% of people, with hundreds of less-common-but-real names making up the rest. A realistic list of 10 names will include some very common ones and some less common ones. That's what real distributions look like.
+
+---
+
+## Problem Solving and Technical Recommendations {#problem-solving}
+
+Mode collapse in technical recommendations means always suggesting the most popular tool regardless of context. The most popular answer is sometimes the best answer - but not always, and the reason it's your recommendation should be fit-to-context, not familiarity.
+
+**Before recommending an approach, consider at least 3 options:**
+
+Ask yourself for each: "Why this one over the alternatives, for THIS specific context?"
+
+If you can't articulate why the common choice is better than a specific alternative for the user's actual constraints, you may be picking it on typicality rather than merit.
+
+**Common collapse pattern:** Always recommending the most popular tool in a category regardless of the user's actual constraints (scale, team size, complexity budget, maintenance burden). The most popular option is often right - but the reason should be fit-to-context, not familiarity.
+
+**The correction isn't to avoid popular tools.** Popular tools are popular for good reasons. The correction is to evaluate fit rather than defaulting. A simple internal tool for 3 people might need a spreadsheet, not a full-stack app.
+
+---
+
+## Coding and Implementation {#coding}
+
+**Variable and function naming:**
+Mode collapse produces generic names: `data`, `result`, `items`, `processData()`, `handleClick()`, `utils.js`. These are sometimes appropriate (a truly generic utility function might reasonably be called `utils`), but often a more specific name exists that communicates intent: `customerOrders`, `validationResult`, `parseInvoiceLineItems()`.
+
+Don't rename for the sake of it. But notice when a generic name is hiding specificity.
+
+**Example data and test fixtures:**
+Mode-collapsed test data always uses the same placeholder values. When generating multiple examples, vary them. Real data has people of different ages, cities across the full geography, and names that reflect actual population diversity.
+
+**Solution architecture:**
+Before implementing, briefly consider whether the typical pattern is the best fit:
+- Does this need a class, or would a function suffice?
+- Does this need a state management library, or would local state work?
+- Does this need an abstraction layer, or is the direct approach clearer?
+- Does this need a config file, or would a constant in the code be simpler?
+
+The bias here is toward over-engineering (adding abstractions, layers, and configurations that the scope doesn't require) because training data is full of production codebases with those patterns. For the user's actual task, simpler is often better.
+
+---
+
+## Example Data and Placeholders {#example-data}
+
+When generating sample data, demos, or documentation examples, mode collapse produces the same handful of values every time:
+
+**Collapsed defaults:** The same placeholder names, emails, addresses, phone numbers, company names, and prices that every LLM produces. You know the ones.
+
+**The fix:** Draw from a wider set of realistic values. Not unusual values, just the VARIETY that real data naturally has:
+
+- Names: Mix common and less common names from the relevant population. "Maria Chen," "Diane Palmer," "Kenji Watanabe," "Rachel Torres" are all normal names that aren't the first five any LLM would generate.
+- Places: Austin, Portland, Minneapolis, Tampa, Raleigh - not just SF/NYC/Chicago
+- Companies: Actual-sounding company names relevant to the domain, not the same placeholder names every LLM defaults to
+- Prices: $47.00, $12.50, $189.99 - not always round numbers or $99.99
+- Dates: Various days and months, not always January 1 or today's date
+
+---
+
+## Explanations and Analogies {#explanations}
+
+When explaining concepts, mode collapse produces the same analogies every time. Every API explanation uses the restaurant waiter analogy. Every database explanation uses the filing cabinet. Every version control explanation uses "saving checkpoints in a video game."
+
+These analogies aren't wrong - they're popular because they work. But they're not the ONLY ones that work, and for users who've heard them before, a fresh angle can be more illuminating.
+
+**Before reaching for the standard analogy:**
+- Consider the user's specific background (if known) - what domains do they already understand?
+- Consider whether a different metaphor might illuminate a different aspect of the concept
+- Consider whether a concrete example might work better than any analogy
+
+The goal is to explain well, not to be novel. If the standard analogy is genuinely the clearest, use it. But if you're using it because it's the first one that came to mind rather than because you considered alternatives, that's mode collapse.

package/skills/luckiest-trends/.skillignore

@@ -0,0 +1,10 @@
+# Hermes scans from this skill directory, not the repository root.
+# Keep non-runtime packaging/dev/eval artifacts out of install-time security scans.
+assets/
+agents/
+scripts/build-skill.sh
+scripts/compare.sh
+scripts/evaluate_search_quality.py
+scripts/test_device_auth.py
+scripts/test-v1-vs-v2.sh
+scripts/verify_v3.py

package/skills/luckiest-trends/ATTRIBUTION.md

@@ -0,0 +1,43 @@
+# Attribution
+
+This skill is adapted from the **"last30days"** skill in the last30days-skill
+project (https://github.com/mvanhorn/last30days-skill) by Matt Van Horn
+(mvanhorn), used under the MIT License.
+
+The multi-source research engine (`scripts/`), its source adapters, ranking,
+and rendering are carried over from the original. The Luckiest edition
+rebrands the command and output to `luckiest-trends`, distills the operating
+contract into a lean `SKILL.md` (the full original contract is preserved at
+`references/engine-contract.md`), surfaces the `--days N` time window as a
+first-class feature, and adds the Luckiest update-check and share-with-tribe
+hooks. See `CHANGELOG.md` for the full record.
+
+The original engine's technical identifiers (`scripts/last30days.py`,
+`LAST30DAYS_*` environment variables, `~/.config/last30days/`) are kept
+unchanged so the mature engine runs as-is.
+
+## Original license
+
+```
+MIT License
+
+Copyright (c) 2026 Matt Van Horn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```