specsmd 0.0.0-dev.9 → 0.0.0-dev.90

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/first-principles.md

@@ -0,0 +1,56 @@
+# First Principles Technique
+
+**Origin**: Aristotelian reasoning, popularized in innovation context by Elon Musk and others. Distinct from reasoning by analogy.
+
+**Interaction type**: Generate — AI decomposes to fundamentals, then rebuilds novel solutions.
+
+## How It Works
+
+1. **Identify the conventional approach** — how is this problem normally solved?
+2. **List all assumptions** embedded in the conventional approach
+3. **Challenge each assumption** — is it a physical law, or just a convention?
+4. **Decompose to fundamentals** — what are the irreducible truths?
+5. **Rebuild from fundamentals** — without the conventional assumptions, what new solutions emerge?
+
+## Decomposition Framework
+
+### Layer 1: Surface (What people do)
+
+- Current behaviors, products, services
+- "Everyone does it this way because..."
+
+### Layer 2: Convention (Why they do it)
+
+- Industry norms, best practices, legacy reasons
+- "We've always done it this way because..."
+
+### Layer 3: Constraints (Real vs. assumed)
+
+- Physical laws, regulations, actual technical limits
+- vs. "We assumed this was a constraint but it's actually a choice"
+
+### Layer 4: Fundamentals (Irreducible truths)
+
+- What must be true regardless of implementation?
+- What does the user actually need (not what they're used to)?
+- What are the physics/economics that can't be changed?
+
+## Example
+
+**Topic**: Improving conference networking
+
+- **Conventional**: Name badges, cocktail hours, speed networking sessions
+- **Assumption challenged**: "People need to be in the same room to network"
+- **Assumption challenged**: "Networking means meeting new people"
+- **Fundamental**: People need to find others with complementary interests/needs
+- **Rebuilt**: A system that matches attendees by complementary gaps (what you need + what you offer) and creates micro-contexts for connection, regardless of physical proximity
+
+## AI Application Notes
+
+When using first-principles internally:
+
+1. Don't just list the fundamentals — actually strip away conventions and rebuild
+2. The power is in identifying which "constraints" are actually conventions
+3. Best used when ideas feel incremental — first-principles thinking produces category-shifting ideas
+4. Present the rebuilt ideas as concrete concepts, not philosophical observations
+5. Can combine with other techniques: first-principles decomposition → analogy transfer → SCAMPER refinement

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/index.yaml

@@ -0,0 +1,76 @@
+# Spark Technique Index
+# Each technique declares its natural interaction type and AI behavior.
+# The AI selects techniques internally — never expose technique names to the user.
+
+techniques:
+  - id: scamper
+    name: SCAMPER
+    interaction: generate
+    energy: high
+    best_for: "Transforming existing concepts into new variations"
+    asks: null
+    ai_behavior: "Apply S-C-A-M-P-E-R transformations to the topic and present modified concepts"
+    reference: techniques/scamper.md
+
+  - id: random-word
+    name: Random Word
+    interaction: generate
+    energy: high
+    best_for: "Breaking fixation with unexpected connections"
+    asks: null
+    ai_behavior: "Select a random concept from an unrelated domain and force connections with the topic"
+    reference: techniques/random-word.md
+
+  - id: what-if
+    name: What-If Scenarios
+    interaction: generate
+    energy: medium
+    best_for: "Challenging assumptions and exploring alternate realities"
+    asks: null
+    ai_behavior: "Generate 'what if' scenarios that challenge core assumptions about the topic"
+    reference: techniques/what-if.md
+
+  - id: inversion
+    name: Inversion
+    interaction: generate
+    energy: high
+    best_for: "Finding opportunities by reversing problems or assumptions"
+    asks: null
+    ai_behavior: "Reverse the problem, assumptions, or desired outcome and generate ideas from the inverted perspective"
+    reference: techniques/inversion.md
+
+  - id: analogy
+    name: Cross-Domain Analogy
+    interaction: generate
+    energy: medium
+    best_for: "Transferring solutions from one domain to another"
+    asks: null
+    ai_behavior: "Find analogous problems in distant domains and adapt their solutions to the current topic"
+    reference: techniques/analogy.md
+
+  - id: first-principles
+    name: First Principles
+    interaction: generate
+    energy: low
+    best_for: "Fundamental rethinking when existing approaches feel stale"
+    asks: null
+    ai_behavior: "Decompose the topic to its fundamental truths, then rebuild solutions from scratch"
+    reference: techniques/first-principles.md
+
+  - id: questorming
+    name: Questorming
+    interaction: co-build
+    energy: medium
+    best_for: "Reframing the problem space through better questions"
+    asks:
+      - trigger: "after generating question batch"
+        question: "Which of these questions feels most important to you?"
+    ai_fallback: "AI selects the most provocative question and generates ideas from it"
+    reference: techniques/questorming.md
+
+# Technique Selection Strategy
+# The AI selects techniques based on:
+# 1. Which domains are underexplored (anti-bias engine)
+# 2. User energy/engagement level
+# 3. Which techniques haven't been used recently
+# 4. Whether the user wants "wilder" (→ inversion, random-word) or "practical" (→ first-principles, analogy)

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/inversion.md

@@ -0,0 +1,52 @@
+# Inversion Technique
+
+**Origin**: Charlie Munger's "invert, always invert" principle; also found in de Bono's lateral thinking and Osborn's reversal prompters.
+
+**Interaction type**: Generate — AI inverts assumptions, user reacts to the resulting ideas.
+
+## How It Works
+
+1. **State the goal** clearly
+2. **Invert it** — ask "how would I achieve the exact opposite?"
+3. **List the inversions** — what would guarantee failure, the worst experience, the opposite outcome?
+4. **Reverse each inversion** — the opposite of each failure mode is often a non-obvious success strategy
+
+## Inversion Patterns
+
+### Goal Inversion
+
+- Goal: "Make onboarding fast" → Inverted: "How to make onboarding take forever?"
+- Answers: No documentation, no buddy system, surprise requirements → Ideas: Pre-arrival portal, day-1 buddy auto-match, zero-surprise checklist
+
+### User Inversion
+
+- Design for the opposite user: experts → beginners, individuals → teams, tech-savvy → tech-averse
+- Forces empathy and reveals assumptions
+
+### Process Inversion
+
+- Reverse the order: What if the last step came first?
+- End-to-outcome: Start with the desired result and work backward
+- Often reveals unnecessary steps
+
+### Value Inversion
+
+- What if the biggest cost became the biggest feature?
+- What if the bug became the selling point?
+- Turns weaknesses into differentiators
+
+### Anti-Problem
+
+- Instead of solving the problem, make it irrelevant
+- Instead of reducing friction, make the friction delightful
+- Reframe rather than fix
+
+## AI Application Notes
+
+When using inversion internally:
+
+1. Pick the most interesting inversion pattern for the current topic
+2. Actually go through the full inversion (state goal → invert → list failure modes → reverse)
+3. The best ideas come from reversing *non-obvious* failure modes
+4. Present the resulting ideas without explaining the inversion process
+5. Excellent for batch #2+ when initial ideas feel too "safe"

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/questorming.md

@@ -0,0 +1,57 @@
+# Questorming Technique
+
+**Origin**: Hal Gregersen's "Question Burst" methodology; also related to Osborn's principle of exploring the problem space before solving.
+
+**Interaction type**: Co-build — AI generates questions, user identifies the most important ones, AI builds ideas from those.
+
+## How It Works
+
+1. **State the topic** without any solutions in mind
+2. **Generate questions only** — no answers allowed during this phase
+3. **Aim for 15-20 questions** in rapid succession
+4. **Categorize** — which questions challenge assumptions? Which reframe the problem?
+5. **Select the most provocative questions** — these become the seed for new ideas
+6. **Generate ideas** from the selected questions
+
+## Question Types
+
+### Assumption-Challenging
+
+- Why do we assume [X] is necessary?
+- What if [commonly accepted truth] were false?
+- Who said this has to be done by [conventional actor]?
+
+### Scope-Shifting
+
+- What if we zoom out 10x — what's the bigger problem?
+- What if we zoom in 10x — what's the specific pain point?
+- What would this look like from the customer's customer's perspective?
+
+### Stakeholder Questions
+
+- Who benefits from the current broken state?
+- Who would lose if we solved this perfectly?
+- Who has already solved this in a different context?
+
+### Temporal Questions
+
+- Why hasn't this been solved yet?
+- What will make this irrelevant in 5 years?
+- What had to change for this to become solvable now?
+
+### Provocative Questions
+
+- What's the most expensive possible solution? The cheapest?
+- What would a competitor do with this opportunity?
+- What would a child suggest?
+
+## AI Application Notes
+
+When using questorming internally:
+
+1. Generate a burst of 8-10 questions about the topic
+2. Present 3-5 of the most provocative ones to the user
+3. Ask: "Which of these feels most important?" (the one elicit moment)
+4. If user doesn't engage, pick the most provocative question yourself (ai_fallback)
+5. Generate ideas seeded from the selected question(s)
+6. Best used when the problem space feels unclear or when the user says "I'm not sure what I want"

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/random-word.md

@@ -0,0 +1,35 @@
+# Random Word Technique
+
+**Origin**: Edward de Bono's lateral thinking toolkit. Forces connections between unrelated concepts.
+
+**Interaction type**: Generate — AI selects random stimulus and forces connections.
+
+## How It Works
+
+1. **Select a random concept** from an unrelated domain (not a literal random word — pick a vivid, concrete thing)
+2. **List its attributes** — what makes it interesting, how it works, what it's known for
+3. **Force connections** — map each attribute to the ideation topic
+4. **Develop the strongest connections** into full ideas
+
+## Examples of Forcing Connections
+
+**Topic**: Improving employee onboarding
+**Random concept**: Coral reef
+
+| Coral Reef Attribute | Forced Connection |
+|---------------------|-------------------|
+| Self-organizing ecosystem | Onboarding that self-organizes based on new hire's role and interests |
+| Symbiotic relationships | Pair each new hire with a "symbiont" — someone from a different team |
+| Builds slowly, lasts centuries | First-week foundations that compound over the entire tenure |
+| Bleaches under stress | Early warning system when onboarding overwhelms |
+| Attracts diverse species | Make onboarding a magnet event that existing employees want to attend |
+
+## AI Application Notes
+
+When using random-word internally:
+
+1. Pick concepts from **distant domains** — nature, games, history, architecture, music
+2. The more unrelated the concept, the more novel the connections
+3. Generate at least 5 attribute-connections, then pick the 2-3 most surprising
+4. Present only the resulting ideas — never mention "random word" or the stimulus process
+5. This technique is excellent for breaking fixation when ideas are clustering

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/scamper.md

@@ -0,0 +1,67 @@
+# SCAMPER Technique
+
+**Origin**: Bob Eberle, building on Alex Osborn's idea prompter checklists from *Applied Imagination* (1953).
+
+**Interaction type**: Generate — AI applies transformations, user reacts.
+
+## The Seven Operators
+
+### S — Substitute
+
+What can be substituted? Different materials, people, processes, components, approaches?
+
+- Replace one element with something unexpected
+- Swap the medium, channel, or context
+
+### C — Combine
+
+What can be combined? Blend two ideas, merge functions, mix purposes?
+
+- Combine features from different domains
+- Merge two user needs into one solution
+
+### A — Adapt
+
+What can be adapted from elsewhere? What analogies apply? What else is like this?
+
+- Borrow solutions from other industries
+- Adapt natural processes to the problem
+
+### M — Modify (also: Magnify / Minimize)
+
+What can be changed? Size, shape, color, meaning, frequency, intensity?
+
+- Make it 10x bigger or smaller
+- Change the speed, frequency, or intensity
+- Alter the form factor entirely
+
+### P — Put to Other Use
+
+Can this serve a different purpose? New contexts? New users? New markets?
+
+- Repurpose for a completely different audience
+- Use the byproduct as the main product
+
+### E — Eliminate
+
+What can be removed? Simplify? What's non-essential?
+
+- Remove the most complex component — what happens?
+- Strip to the absolute minimum viable version
+
+### R — Reverse (also: Rearrange)
+
+What if the order were reversed? What if roles swapped? What if inside-out?
+
+- Reverse the workflow
+- Let the user become the provider
+- Flip the value proposition
+
+## AI Application Notes
+
+When using SCAMPER internally:
+
+1. Pick 2-3 operators per batch (not all 7 — that produces too-similar ideas)
+2. Apply each operator to a **different domain** from the domain wheel
+3. Make the result vivid and specific, not abstract
+4. Never tell the user you're "using SCAMPER" — just present the transformed ideas

package/flows/ideation/agents/orchestrator/skills/spark/references/techniques/what-if.md

@@ -0,0 +1,55 @@
+# What-If Scenarios Technique
+
+**Origin**: Assumption-challenging methodology found across creative problem solving traditions.
+
+**Interaction type**: Generate — AI constructs scenarios, user reacts to the most interesting ones.
+
+## How It Works
+
+1. **Identify core assumptions** about the topic (explicit and implicit)
+2. **Challenge each assumption** with a "what if" that negates or transforms it
+3. **Explore the scenario** — what would the world look like if this were true?
+4. **Extract ideas** from the alternate reality
+
+## Types of What-If
+
+### Constraint Removal
+
+- What if money were no object?
+- What if there were no technical limitations?
+- What if you had unlimited time?
+- What if there were no regulations?
+
+### Constraint Inversion
+
+- What if the user had to pay NOT to use it?
+- What if it only worked for 5 minutes per day?
+- What if it required 100 people to operate?
+
+### Context Shift
+
+- What if this existed in 1920? In 2120?
+- What if this were designed for children? For astronauts? For animals?
+- What if this operated underwater? In zero gravity? In complete darkness?
+
+### Scale Shift
+
+- What if 1 billion people used this simultaneously?
+- What if it were the size of a building? A molecule?
+- What if it lasted 100 years? 100 milliseconds?
+
+### Role Reversal
+
+- What if the customer built it and the company used it?
+- What if the problem were actually the solution?
+- What if success and failure metrics were swapped?
+
+## AI Application Notes
+
+When using what-if internally:
+
+1. Identify 2-3 non-obvious assumptions about the topic
+2. Pick the most interesting what-if type for each assumption
+3. Briefly explore the scenario (2-3 sentences), then extract a concrete idea
+4. Present only the ideas — mention the "what if" framing only if it makes the idea clearer
+5. Best used when ideas are getting too conventional or practical

package/flows/ideation/agents/orchestrator/skills/spark/templates/spark-bank.md.hbs

@@ -0,0 +1,72 @@
+---
+session: {{session_id}}
+topic: "{{topic}}"
+phase: spark
+created: {{created}}
+total_ideas: {{total_ideas}}
+total_batches: {{total_batches}}
+favorites_count: {{favorites_count}}
+domains_covered: {{domains_covered}}
+---
+
+# Spark Bank: {{topic}}
+
+> {{total_ideas}} ideas generated across {{total_batches}} batches, covering {{domains_covered}}/12 domains.
+
+---
+
+## Favorites
+
+{{#each favorites}}
+### {{id}} — {{title}}
+
+{{description}}
+
+*Domain: {{domain}}*
+
+{{/each}}
+
+{{#unless favorites}}
+*No favorites selected yet.*
+{{/unless}}
+
+---
+
+## All Ideas by Theme
+
+{{#each themes}}
+### {{name}}
+
+{{#each ideas}}
+**{{id}}** — **{{title}}**
+{{description}}
+{{#if is_favorite}}*(favorite)*{{/if}}
+*Domain: {{domain}}*
+
+{{/each}}
+
+{{/each}}
+
+---
+
+## Domain Coverage
+
+| Domain | Ideas | Coverage |
+|--------|-------|----------|
+{{#each domain_stats}}
+| {{name}} | {{count}} | {{bar}} |
+{{/each}}
+
+---
+
+## Session Stats
+
+- **Batches generated**: {{total_batches}}
+- **Total ideas**: {{total_ideas}}
+- **Favorites**: {{favorites_count}}
+- **Techniques used**: {{techniques_used}}
+- **Provocations injected**: {{provocations_count}}
+
+---
+
+*Generated by specsmd Ideation Flow — Spark skill*

package/flows/ideation/commands/flame.md

@@ -0,0 +1,43 @@
+---
+description: Flame - multi-perspective idea evaluation and scoring
+---
+
+# Activate Flame
+
+**Command**: `/specsmd-flame`
+
+---
+
+## Activation
+
+You are now the **Ideation Orchestrator** in **Flame mode** for specsmd.
+
+**IMMEDIATELY** read and adopt the persona from:
+→ `.specsmd/ideation/agents/orchestrator/agent.md`
+
+Then execute the Flame skill:
+→ `.specsmd/ideation/agents/orchestrator/skills/flame/SKILL.md`
+
+---
+
+## Critical First Steps
+
+1. **Read Config**: `.specsmd/ideation/memory-bank.yaml`
+2. **Read Interaction Protocol**: `.specsmd/ideation/shared/protocols/interaction-adaptation.md`
+3. **If Spark Bank exists**: Load it and begin evaluation
+4. **If ideas provided directly**: Accept them and begin evaluation
+5. **If nothing**: Ask "Which ideas would you like to evaluate?"
+
+---
+
+## Routing Targets
+
+- **Back to Orchestrator**: `/specsmd-ideation`
+- **To Spark**: `/specsmd-spark`
+- **To Forge**: `/specsmd-forge`
+
+---
+
+## Begin
+
+Activate now. Read the Flame skill and start evaluating ideas.

package/flows/ideation/commands/forge.md

@@ -0,0 +1,43 @@
+---
+description: Forge - shape top ideas into actionable concept briefs
+---
+
+# Activate Forge
+
+**Command**: `/specsmd-forge`
+
+---
+
+## Activation
+
+You are now the **Ideation Orchestrator** in **Forge mode** for specsmd.
+
+**IMMEDIATELY** read and adopt the persona from:
+→ `.specsmd/ideation/agents/orchestrator/agent.md`
+
+Then execute the Forge skill:
+→ `.specsmd/ideation/agents/orchestrator/skills/forge/SKILL.md`
+
+---
+
+## Critical First Steps
+
+1. **Read Config**: `.specsmd/ideation/memory-bank.yaml`
+2. **Read Interaction Protocol**: `.specsmd/ideation/shared/protocols/interaction-adaptation.md`
+3. **If Flame Report exists**: Load shortlisted ideas and begin shaping
+4. **If ideas provided directly**: Accept them and begin shaping
+5. **If nothing**: Ask "Which ideas would you like to develop into concepts?"
+
+---
+
+## Routing Targets
+
+- **Back to Orchestrator**: `/specsmd-ideation`
+- **To Spark**: `/specsmd-spark`
+- **To Flame**: `/specsmd-flame`
+
+---
+
+## Begin
+
+Activate now. Read the Forge skill and start shaping concepts.

package/flows/ideation/commands/ideation.md

@@ -0,0 +1,51 @@
+---
+description: Ideation Flow - creative idea generation, evaluation, and shaping
+---
+
+# Activate Ideation Flow
+
+**Command**: `/specsmd-ideation`
+
+---
+
+## Activation
+
+You are now the **Ideation Orchestrator** for specsmd.
+
+**IMMEDIATELY** read and adopt the persona from:
+→ `.specsmd/ideation/agents/orchestrator/agent.md`
+
+---
+
+## Critical First Steps
+
+1. **Read Config**: `.specsmd/ideation/memory-bank.yaml`
+2. **Check Sessions**: Look for active sessions in `.specs-ideation/sessions/`
+3. **Route**:
+   - Topic provided → jump to Spark skill
+   - Ideas provided → jump to Flame skill
+   - Concepts provided → jump to Forge skill
+   - Nothing → ask "What would you like to explore ideas about?"
+
+---
+
+## Your Skills
+
+- **Spark**: `.specsmd/ideation/agents/orchestrator/skills/spark/SKILL.md` → Generate ideas
+- **Flame**: `.specsmd/ideation/agents/orchestrator/skills/flame/SKILL.md` → Evaluate ideas
+- **Forge**: `.specsmd/ideation/agents/orchestrator/skills/forge/SKILL.md` → Shape concepts
+
+---
+
+## Shared Protocols
+
+- **Anti-Bias**: `.specsmd/ideation/shared/protocols/anti-bias.md`
+- **Deep Thinking**: `.specsmd/ideation/shared/protocols/deep-thinking.md`
+- **Diverge-Converge**: `.specsmd/ideation/shared/protocols/diverge-converge.md`
+- **Interaction Adaptation**: `.specsmd/ideation/shared/protocols/interaction-adaptation.md`
+
+---
+
+## Begin
+
+Activate now. Read your agent definition and start ideating.

package/flows/ideation/commands/spark.md

@@ -0,0 +1,43 @@
+---
+description: Spark - rapid idea generation with cross-domain diversity
+---
+
+# Activate Spark
+
+**Command**: `/specsmd-spark`
+
+---
+
+## Activation
+
+You are now the **Ideation Orchestrator** in **Spark mode** for specsmd.
+
+**IMMEDIATELY** read and adopt the persona from:
+→ `.specsmd/ideation/agents/orchestrator/agent.md`
+
+Then execute the Spark skill:
+→ `.specsmd/ideation/agents/orchestrator/skills/spark/SKILL.md`
+
+---
+
+## Critical First Steps
+
+1. **Read Config**: `.specsmd/ideation/memory-bank.yaml`
+2. **Read Anti-Bias Protocol**: `.specsmd/ideation/shared/protocols/anti-bias.md`
+3. **Read Deep Thinking Protocol**: `.specsmd/ideation/shared/protocols/deep-thinking.md`
+4. **If topic provided**: Jump straight to generating the first batch
+5. **If no topic**: Ask "What would you like to explore ideas about?" — then generate immediately
+
+---
+
+## Routing Targets
+
+- **Back to Orchestrator**: `/specsmd-ideation`
+- **To Flame**: `/specsmd-flame`
+- **To Forge**: `/specsmd-forge`
+
+---
+
+## Begin
+
+Activate now. Read the Spark skill and start generating ideas.