init

.opencode/skills/problem-solving/references/attribution.md

@@ -0,0 +1,69 @@
+# Problem-Solving Skills - Attribution
+
+These skills were derived from agent patterns in the Microsoft Amplifier project.
+
+## Source Repository
+
+- **Name:** Amplifier
+- **URL:** https://github.com/microsoft/amplifier
+- **Commit:** 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
+- **Date:** 2025-10-10
+
+## Skills Derived from Amplifier Agents
+
+### From insight-synthesizer agent:
+- **simplification-cascades** - Finding insights that eliminate multiple components
+- **collision-zone-thinking** - Forcing unrelated concepts together for breakthroughs
+- **meta-pattern-recognition** - Spotting patterns across 3+ domains
+- **inversion-exercise** - Flipping assumptions to reveal alternatives
+- **scale-game** - Testing at extremes to expose fundamental truths
+
+### From ambiguity-guardian agent:
+- **preserving-productive-tensions** - Preserving multiple valid approaches (in architecture skill)
+
+### From knowledge-archaeologist agent:
+- **tracing-knowledge-lineages** - Understanding how ideas evolved (in research skill)
+
+### Dispatch pattern:
+- **when-stuck** - Maps stuck-symptoms to appropriate technique
+
+## What Was Adapted
+
+The Amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
+
+- **Scannable quick-reference guides** (~60-80 lines each)
+- **Symptom-based discovery** via when_to_use descriptions
+- **Immediate application** without special tooling
+- **Composable patterns** through dispatch system
+- **Progressive disclosure** via SKILL.md + references structure
+
+## Core Insight
+
+Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "problem-solving skill", the underlying technique is the same.
+
+We extracted the techniques and made them:
+- Portable across contexts
+- Immediately applicable
+- Token-efficient through progressive disclosure
+- Discoverable through symptom-matching
+- Combinable for complex problems
+
+## License
+
+Original Amplifier project uses MIT License. These adapted skills maintain attribution and follow the same open spirit.
+
+## Adaptation Notes
+
+**Changes from original:**
+- Converted from long-lived agent to scannable reference
+- Added symptom-based dispatch system
+- Removed JSON output requirements
+- Focused on immediate application
+- Added concrete examples
+- Structured for progressive disclosure
+
+**Preserved from original:**
+- Core problem-solving techniques
+- Recognition patterns
+- Application processes
+- Fundamental insights

.opencode/skills/problem-solving/references/collision-zone-thinking.md

@@ -0,0 +1,79 @@
+# Collision-Zone Thinking
+
+Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
+
+## Core Principle
+
+Revolutionary insights from deliberate metaphor-mixing. Treat X like Y and see what emerges.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| Stuck in conventional thinking | Force wild domain collision |
+| Solutions feel incremental | Need breakthrough, not optimization |
+| "Tried everything in this domain" | Import concepts from elsewhere |
+| Need innovation, not iteration | Deliberately mix unrelated ideas |
+
+## Quick Reference Collisions
+
+| Treat This | Like This | Discovers |
+|------------|-----------|-----------|
+| Code organization | DNA/genetics | Mutation testing, evolutionary algorithms |
+| Service architecture | Lego bricks | Composable microservices, plug-and-play |
+| Data management | Water flow | Streaming, data lakes, flow-based systems |
+| Request handling | Postal mail | Message queues, async processing |
+| Error handling | Circuit breakers | Fault isolation, graceful degradation |
+
+## Process
+
+1. **Pick two unrelated concepts** from different domains
+2. **Force combination** - "What if we treated [A] like [B]?"
+3. **Explore emergent properties** - What new capabilities appear?
+4. **Test boundaries** - Where does the metaphor break?
+5. **Extract insight** - What did we learn?
+
+## Detailed Example
+
+**Problem:** Complex distributed system with cascading failures
+
+**Collision:** "What if we treated services like electrical circuits?"
+
+**Emergent properties:**
+- Circuit breakers (disconnect on overload)
+- Fuses (one-time failure protection)
+- Ground faults (error isolation)
+- Load balancing (current distribution)
+- Voltage regulation (rate limiting)
+
+**Where it works:** Preventing cascade failures, fault isolation
+
+**Where it breaks:** Circuits don't have retry logic, healing mechanisms
+
+**Insight gained:** Failure isolation patterns from electrical engineering
+
+## Best Source Domains
+
+Rich domains for concept mining:
+- **Physics** - Forces, thermodynamics, relativity
+- **Biology** - Evolution, ecosystems, immune systems
+- **Economics** - Markets, incentives, game theory
+- **Psychology** - Cognition, behavior, motivation
+- **Architecture** - Structure, flow, space utilization
+
+## Red Flags
+
+You need collision-zone thinking when:
+- "I've tried everything in this domain"
+- Solutions feel incremental, not breakthrough
+- Stuck in conventional thinking
+- Need innovation, not optimization
+- "Standard approach isn't working"
+
+## Remember
+
+- Wild combinations often yield best insights
+- Test metaphor boundaries rigorously
+- Document even failed collisions (they teach)
+- Breakthrough > incremental improvement
+- Question: "What would [domain expert] do?"

.opencode/skills/problem-solving/references/inversion-exercise.md

@@ -0,0 +1,91 @@
+# Inversion Exercise
+
+Flip core assumptions to reveal hidden constraints and alternative approaches. "What if the opposite were true?"
+
+## Core Principle
+
+**Inversion exposes hidden assumptions.** Sometimes the opposite reveals the truth.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| "There's only one way" | Flip the assumption |
+| Solution feels forced | Invert the constraints |
+| Can't articulate why necessary | Question the "must" |
+| "This is just how it's done" | Try the opposite |
+
+## Quick Reference
+
+| Normal Assumption | Inverted | What It Reveals |
+|-------------------|----------|-----------------|
+| Cache to reduce latency | Add latency to enable caching | Debouncing patterns |
+| Pull data when needed | Push data before needed | Prefetching, eager loading |
+| Handle errors when occur | Make errors impossible | Type systems, contracts |
+| Build features users want | Remove features users don't need | Simplicity >> addition |
+| Optimize for common case | Optimize for worst case | Resilience patterns |
+
+## Process
+
+1. **List core assumptions** - What "must" be true?
+2. **Invert each systematically** - "What if opposite were true?"
+3. **Explore implications** - What would we do differently?
+4. **Find valid inversions** - Which actually work somewhere?
+5. **Document insights** - What did we learn?
+
+## Detailed Example
+
+**Problem:** Users complain app is slow
+
+**Normal approach:** Make everything faster
+- Add caching
+- Optimize queries
+- Use CDN
+- Reduce bundle size
+
+**Inverted approach:** Make things intentionally slower in some places
+- **Debounce search** - Add latency → enable better results (wait for full query)
+- **Rate limit requests** - Add friction → prevent abuse, improve for others
+- **Lazy load content** - Delay loading → reduce initial load time
+- **Progressive rendering** - Show slower → perceived performance
+
+**Insight:** Strategic slowness can improve UX
+
+## Valid vs Invalid Inversions
+
+**Valid inversion example:**
+- Normal: "Store data in database"
+- Inverted: "Derive data on-demand instead of storing"
+- Valid when: Computation cheaper than storage, data changes frequently
+
+**Invalid inversion example:**
+- Normal: "Validate user input"
+- Inverted: "Trust all user input"
+- Invalid because: Security vulnerability, not context-dependent
+
+**Test validity:** Does the inversion work in ANY context? If yes, it's valid somewhere.
+
+## Common Inversions
+
+- **Eager → Lazy** (or vice versa)
+- **Push → Pull** (or vice versa)
+- **Store → Compute** (or vice versa)
+- **Optimize → Simplify** (or vice versa)
+- **Add features → Remove features** (or vice versa)
+
+## Red Flags
+
+You need inversion exercise when:
+- "There's only one way to do this"
+- Forcing solution that feels wrong
+- Can't articulate why approach is necessary
+- "This is just how it's done"
+- Stuck on unquestioned assumptions
+
+## Remember
+
+- Not all inversions work (test boundaries)
+- Valid inversions reveal context-dependence
+- Sometimes opposite is the answer
+- Question "must be" statements
+- Document both successful and failed inversions

.opencode/skills/problem-solving/references/meta-pattern-recognition.md

@@ -0,0 +1,87 @@
+# Meta-Pattern Recognition
+
+Spot patterns appearing in 3+ domains to find universal principles.
+
+## Core Principle
+
+**Find patterns in how patterns emerge.** When the same pattern appears in 3+ domains, it's likely a universal principle worth extracting.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| Same issue in different places | Extract the abstract form |
+| Déjà vu in problem-solving | Find the universal pattern |
+| Reinventing wheels across domains | Identify the meta-pattern |
+| "Haven't we done this before?" | Yes, find and reuse it |
+
+## Quick Reference
+
+| Pattern Appears In | Abstract Form | Where Else? |
+|-------------------|---------------|-------------|
+| CPU/DB/HTTP/DNS caching | Store frequently-accessed data closer | LLM prompt caching, CDN |
+| Layering (network/storage/compute) | Separate concerns into abstraction levels | Architecture, org structure |
+| Queuing (message/task/request) | Decouple producer from consumer with buffer | Event systems, async |
+| Pooling (connection/thread/object) | Reuse expensive resources | Memory mgmt, governance |
+
+## Process
+
+1. **Spot repetition** - See same shape in 3+ places
+2. **Extract abstract form** - Describe independent of any domain
+3. **Identify variations** - How does it adapt per domain?
+4. **Check applicability** - Where else might this help?
+5. **Document pattern** - Make it reusable
+
+## Detailed Example
+
+**Pattern spotted:** Rate limiting appears in:
+- API throttling (requests per minute)
+- Traffic shaping (packets per second)
+- Circuit breakers (failures per window)
+- Admission control (concurrent connections)
+
+**Abstract form:** Bound resource consumption to prevent exhaustion
+
+**Variation points:**
+- What resource (requests, packets, failures, connections)
+- What limit (per time window, concurrent, cumulative)
+- What happens when exceeded (reject, queue, degrade)
+
+**New application:** LLM token budgets
+- Same pattern: prevent context window exhaustion
+- Resource: tokens
+- Limit: context window size
+- Action: truncate or reject
+
+## 3+ Domain Rule
+
+**Why 3 domains?**
+- 1 occurrence = coincidence
+- 2 occurrences = possible pattern
+- 3+ occurrences = likely universal
+
+**Domain independence test:**
+Can you describe the pattern without mentioning specific domains?
+
+## Red Flags
+
+Signs you're missing meta-patterns:
+- "This problem is unique" (probably not)
+- Multiple teams solving "different" problems identically
+- Reinventing wheels across domains
+- "Haven't we done something like this?" (yes, find it)
+
+## Benefits of Meta-Patterns
+
+- **Battle-tested** - Proven across multiple domains
+- **Reusable** - Apply to new situations
+- **Universal** - Domain-independent solutions
+- **Documented** - Known variations and trade-offs
+
+## Remember
+
+- 3+ domains = likely universal
+- Abstract form reveals new applications
+- Variations show adaptation points
+- Universal patterns save time
+- Document for future reuse

.opencode/skills/problem-solving/references/scale-game.md

@@ -0,0 +1,95 @@
+# Scale Game
+
+Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths hidden at normal scales.
+
+## Core Principle
+
+**Extremes expose fundamentals.** What works at one scale fails at another.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| "Should scale fine" (without testing) | Test at extremes |
+| Uncertain about production behavior | Scale up 1000x |
+| Edge cases unclear | Test minimum and maximum |
+| Architecture validation needed | Extreme testing |
+
+## Quick Reference
+
+| Scale Dimension | Test At Extremes | What It Reveals |
+|-----------------|------------------|-----------------|
+| **Volume** | 1 item vs 1B items | Algorithmic complexity limits |
+| **Speed** | Instant vs 1 year | Async requirements, caching needs |
+| **Users** | 1 user vs 1B users | Concurrency issues, resource limits |
+| **Duration** | Milliseconds vs years | Memory leaks, state growth |
+| **Failure rate** | Never fails vs always fails | Error handling adequacy |
+
+## Process
+
+1. **Pick dimension** - What could vary extremely?
+2. **Test minimum** - What if 1000x smaller/faster/fewer?
+3. **Test maximum** - What if 1000x bigger/slower/more?
+4. **Note what breaks** - Where do limits appear?
+5. **Note what survives** - What's fundamentally sound?
+6. **Design for reality** - Use insights to validate architecture
+
+## Detailed Examples
+
+### Example 1: Error Handling
+- **Normal scale:** "Handle errors when they occur" works fine
+- **At 1B scale:** Error volume overwhelms logging, crashes system
+- **Reveals:** Need to make errors impossible (type systems) or expect them (chaos engineering)
+- **Action:** Design error handling for volume, not just occurrence
+
+### Example 2: Synchronous APIs
+- **Normal scale:** Direct function calls work, < 100ms latency
+- **At global scale:** Network latency makes synchronous unusable (200-500ms)
+- **Reveals:** Async/messaging becomes survival requirement, not optimization
+- **Action:** Design async-first from start
+
+### Example 3: In-Memory State
+- **Normal duration:** Works for hours/days in development
+- **At years:** Memory grows unbounded, eventual crash (weeks → months → years)
+- **Reveals:** Need persistence or periodic cleanup, can't rely on memory forever
+- **Action:** Design for stateless or externalized state
+
+### Example 4: Single vs Million Users
+- **Normal scale:** Session in memory works for 100 users
+- **At 1M scale:** Memory exhausted, server crashes
+- **Reveals:** Need distributed session store (Redis, database)
+- **Action:** Design for horizontal scaling from start
+
+## Both Directions Matter
+
+**Test smaller too:**
+- What if only 1 user? Does complexity make sense?
+- What if only 10 items? Is optimization premature?
+- What if instant response? What becomes unnecessary?
+
+Often reveals over-engineering or premature optimization.
+
+## Red Flags
+
+You need scale game when:
+- "It works in dev" (but will it work in production?)
+- No idea where limits are
+- "Should scale fine" (without evidence)
+- Surprised by production behavior
+- Architecture feels arbitrary
+
+## Success Metrics
+
+After scale game, you should know:
+- Where system breaks (exact limits)
+- What survives (fundamentally sound parts)
+- What needs redesign (scale-dependent)
+- Production readiness (validated architecture)
+
+## Remember
+
+- Extremes reveal fundamentals hidden at normal scales
+- What works at one scale fails at another
+- Test BOTH directions (bigger AND smaller)
+- Use insights to validate architecture early
+- Don't guess - test at extremes

.opencode/skills/problem-solving/references/simplification-cascades.md

@@ -0,0 +1,80 @@
+# Simplification Cascades
+
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+## Core Principle
+
+**Everything is a special case of...** collapses complexity dramatically.
+
+One powerful abstraction > ten clever hacks.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| Same thing implemented 5+ ways | Abstract the common pattern |
+| Growing special case list | Find the general case |
+| Complex rules with exceptions | Find rule with no exceptions |
+| Excessive config options | Find defaults working for 95% |
+
+## The Pattern
+
+**Look for:**
+- Multiple implementations of similar concepts
+- Special case handling everywhere
+- "We need to handle A, B, C, D differently..."
+- Complex rules with many exceptions
+
+**Ask:** "What if they're all the same thing underneath?"
+
+## Examples
+
+### Example 1: Stream Abstraction
+- **Before:** Separate handlers for batch/real-time/file/network data
+- **Insight:** "All inputs are streams - just different sources"
+- **After:** One stream processor, multiple stream sources
+- **Eliminated:** 4 separate implementations
+
+### Example 2: Resource Governance
+- **Before:** Session tracking, rate limiting, file validation, connection pooling (all separate)
+- **Insight:** "All are per-entity resource limits"
+- **After:** One ResourceGovernor with 4 resource types
+- **Eliminated:** 4 custom enforcement systems
+
+### Example 3: Immutability
+- **Before:** Defensive copying, locking, cache invalidation, temporal coupling
+- **Insight:** "Treat everything as immutable data + transformations"
+- **After:** Functional programming patterns
+- **Eliminated:** Entire classes of synchronization problems
+
+## Process
+
+1. **List variations** - What's implemented multiple ways?
+2. **Find essence** - What's the same underneath?
+3. **Extract abstraction** - What's the domain-independent pattern?
+4. **Test fit** - Do all cases fit cleanly?
+5. **Measure cascade** - How many things become unnecessary?
+
+## Red Flags
+
+Signs you're missing a cascade:
+- "Just need to add one more case..." (repeating forever)
+- "These are similar but different" (maybe they're the same?)
+- Refactoring feels like whack-a-mole (fix one, break another)
+- Growing configuration file
+- "Don't touch that, it's complicated" (complexity hiding pattern)
+
+## Success Metrics
+
+- **10x wins, not 10% improvements**
+- Measure in "how many things can we delete?"
+- Lines of code removed > lines added
+- Configuration options eliminated
+- Special cases unified
+
+## Remember
+
+- The pattern is usually already there, just needs recognition
+- Valid cascades feel obvious in retrospect
+- Test with "can this handle all existing cases?"
+- Document the insight for future reference

.opencode/skills/problem-solving/references/when-stuck.md

@@ -0,0 +1,72 @@
+# When Stuck - Problem-Solving Dispatch
+
+Different stuck-types need different techniques. Match stuck-symptom to technique.
+
+## Dispatch Flowchart
+
+```
+YOU'RE STUCK
+│
+├─ Complexity spiraling? Same thing 5+ ways? Growing special cases?
+│  └─→ USE: Simplification Cascades
+│
+├─ Can't find fitting approach? Conventional solutions inadequate?
+│  └─→ USE: Collision-Zone Thinking
+│
+├─ Same issue different places? Reinventing wheels? Feels familiar?
+│  └─→ USE: Meta-Pattern Recognition
+│
+├─ Solution feels forced? "Must be done this way"? Stuck on assumptions?
+│  └─→ USE: Inversion Exercise
+│
+├─ Will this work at production? Edge cases unclear? Unsure of limits?
+│  └─→ USE: Scale Game
+│
+└─ Code broken? Wrong behavior? Test failing?
+   └─→ USE: Debugging skill (systematic-debugging)
+```
+
+## Stuck-Type → Technique Map
+
+| How You're Stuck | Symptom Details | Use This |
+|------------------|-----------------|----------|
+| **Complexity spiraling** | Same thing 5+ ways, growing special cases, excessive if/else | simplification-cascades.md |
+| **Need innovation** | Conventional inadequate, can't find fitting approach, need breakthrough | collision-zone-thinking.md |
+| **Recurring patterns** | Same issue different places, reinventing wheels, déjà vu feeling | meta-pattern-recognition.md |
+| **Forced by assumptions** | "Must be done this way", can't question premise, forced solution | inversion-exercise.md |
+| **Scale uncertainty** | Production unclear, edge cases unknown, unsure of limits | scale-game.md |
+| **Code broken** | Wrong behavior, test failing, unexpected output | debugging skill |
+
+## Process
+
+1. **Identify stuck-type** - What symptom matches above?
+2. **Load that technique** - Read the specific reference file
+3. **Apply technique** - Follow its process
+4. **Document attempt** - What worked/failed?
+5. **If still stuck** - Try different technique or combine
+
+## Combining Techniques
+
+Some problems need multiple techniques:
+
+- **Simplification + Meta-pattern** - Find pattern → simplify all instances
+- **Collision + Inversion** - Force metaphor → invert assumptions
+- **Scale + Simplification** - Test extremes → reveal what to eliminate
+- **Meta-pattern + Scale** - Universal pattern → test at extremes
+
+## When Nothing Works
+
+If no technique helps:
+1. **Reframe problem** - Are you solving the right problem?
+2. **Get fresh perspective** - Explain to someone else
+3. **Take break** - Distance often reveals solution
+4. **Simplify scope** - Solve smaller version first
+5. **Question constraints** - Are they real or assumed?
+
+## Remember
+
+- Match symptom to technique
+- One technique at a time
+- Combine if first doesn't work
+- Document what you tried
+- Not stuck forever, just temporarily